R14-TQ2-LP1-R1 Protected Entity Ledger + Typed Lexical Authority + Final-Gate Progress

app.py

@@ -775,6 +775,11 @@ def _watch_task_status_live(task: dict) -> dict | None:
                     "waiting": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_waiting"),
                     "translating": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_section_running"),
                     "qa": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_section_qa"),
+                    "final_gate": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_final_gate"),
+                    "repairing": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_section_repairing"),
+                    "repair_pending": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_section_repair_pending"),
+                    "adjudicating": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_section_adjudicating"),
+                    "counts": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_progress_counts"),
                     "ready": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_section_ready"),
                     "complete": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_complete_label"),
                 },

core/generation_runner.py

@@ -43,7 +43,7 @@ CITATION_ROLE_RULES = {
     "methods": (2, 280),
     "discussion": (2, 220),
 }
-TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v7'
+TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v8'
 
 
 def _clean_trailing_references(text, keywords=("reference", "references", "reference list", "参考文献")):
@@ -1159,7 +1159,7 @@ class GenerationRunner:
     def _translate_frozen_unit(
         self, agent, *, unit_key: str, unit_name: str, source_text: str, target_lang: str,
         translation_sections: dict, translation_glossary: dict, adaptive_structure, include_front=False,
-        defer_failures=True, english_commit_text: str | None = None,
+        defer_failures=True, english_commit_text: str | None = None, final_gate: bool = False,
     ):
         source = str(source_text or '').strip()
         if not source:
@@ -1170,6 +1170,14 @@ class GenerationRunner:
         canonical_translation_source = identity['compiled_source']
         contract_version = TRANSLATION_CONTRACT_VERSION
         fact_ledger_hash = identity['fact_ledger_hash']
+        entity_ledger_method = getattr(agent, 'translation_protected_entity_ledger_hash', None)
+        protected_entity_ledger_hash = str(
+            entity_ledger_method(canonical_translation_source, translation_glossary)
+            if callable(entity_ledger_method) else ''
+        )
+        protected_entity_ledger_version = str(
+            getattr(agent, 'PROTECTED_ENTITY_LEDGER_VERSION', 'protected-entity-ledger-v1') or 'protected-entity-ledger-v1'
+        )
         existing = dict((translation_sections or {}).get(unit_key) or {})
         if not isinstance(getattr(self, '_translation_progress_queued', None), set):
             self._translation_progress_queued = set()
@@ -1199,8 +1207,9 @@ class GenerationRunner:
             logging.info('Translation reuse miss | unit=%s phase=final_or_direct reasons=%s', unit_name, ','.join(reasons) or 'unknown')
         self._translation_progress_inflight.add(str(unit_key))
         partial = self._assemble_partial_translation(translation_sections, adaptive_structure, include_front=include_front)
+        initial_target_stage = f'translation_final_gate:{unit_name}' if final_gate else f'translating:{unit_name}'
         self._publish_target_preview(
-            partial, f'translating:{unit_name}', force=True, complete=False,
+            partial, initial_target_stage, force=True, complete=False,
             english_commit_text=english_commit_text,
         )
         updated_sections = dict(translation_sections or {})
@@ -1242,8 +1251,14 @@ class GenerationRunner:
 
         def publish_translation_stage(stage):
             value = str(stage or '').strip().casefold()
-            if value in {'qa', 'repairing'}:
+            if value == 'qa':
                 preview_stage = f'translation_qa:{unit_name}'
+            elif value == 'repairing':
+                preview_stage = f'translation_repairing:{unit_name}'
+            elif value == 'adjudicating':
+                preview_stage = f'translation_adjudicating:{unit_name}'
+            elif final_gate:
+                preview_stage = f'translation_final_gate:{unit_name}'
             else:
                 preview_stage = f'translating:{unit_name}'
             self._publish_target_preview(
@@ -1346,6 +1361,8 @@ class GenerationRunner:
                 'glossary_version': self._glossary_version(translation_glossary),
                 'translation_contract_version': contract_version,
                 'fact_ledger_hash': fact_ledger_hash,
+                'protected_entity_ledger_version': protected_entity_ledger_version,
+                'protected_entity_ledger_hash': protected_entity_ledger_hash,
                 'translated_text': '',
                 'qa_status': 'repair_pending',
                 'claim_states': dict(getattr(agent, '_last_translation_claim_states', {}) or {}),
@@ -1376,6 +1393,8 @@ class GenerationRunner:
             'glossary_version': self._glossary_version(updated_glossary),
             'translation_contract_version': str(result.get('translation_contract_version') or contract_version),
             'fact_ledger_hash': result_fact_ledger_hash,
+            'protected_entity_ledger_version': str(result.get('protected_entity_ledger_version') or protected_entity_ledger_version),
+            'protected_entity_ledger_hash': str(result.get('protected_entity_ledger_hash') or protected_entity_ledger_hash),
             'translated_text': str(result.get('text') or '').strip(),
             'qa_status': str(result.get('qa_status') or 'passed'),
             'language_adapter': str(result.get('language_adapter') or ''),
@@ -2508,7 +2527,7 @@ Output only final academic prose. Do not report the word count."""
                     target_lang=target_lang, translation_sections=translation_sections,
                     translation_glossary=translation_glossary, adaptive_structure=adaptive_structure,
                     include_front=True, defer_failures=False,
-                    english_commit_text=full_draft_en,
+                    english_commit_text=full_draft_en, final_gate=True,
                 )
                 partial = self._assemble_partial_translation(
                     translation_sections, adaptive_structure, include_front=True
@@ -2571,6 +2590,7 @@ Output only final academic prose. Do not report the word count."""
             literature_metrics=agent.get_source_metrics(),
             quality_diagnostics=quality_diagnostics,
         )
+        self._progress(98, "package_validation")
         output_filename = f"SmartPaper_{bj_time}.zip"
         pending = self.output_dir / (".pending_" + output_filename)
         pending.write_bytes(package.zip_bytes)

core/pipeline_agent.py

@@ -70,8 +70,9 @@ class CitationAuditError(DeepSeekRequestError):
 
 
 class SSciPipelineAgent:
-    TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v7'
+    TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v8'
     MAX_TRANSLATION_CLAIM_REPAIR_ATTEMPTS = 2
+    PROTECTED_ENTITY_LEDGER_VERSION = 'protected-entity-ledger-v1'
 
     def __init__(self, ds_key, s2_key=""):
         self.ds_key = str(ds_key or "").strip()
@@ -3884,6 +3885,209 @@ Output only the repaired section."""
             'Do not retain ordinary English words or phrases merely because they appear technical or familiar.'
         )
 
+    @staticmethod
+    def _translation_ascii_boundary_pattern(surface):
+        """Return an ASCII-word-boundary pattern that remains safe next to CJK/Cyrillic.
+
+        Python ``\\b`` treats many non-Latin letters as word characters.  A protected
+        object such as ``ChatGPT`` can therefore fail to match in ``使用ChatGPT模型``.
+        Translation lexical authority uses explicit ASCII boundaries instead.
+        """
+        value = str(surface or '').strip()
+        if not value:
+            return None
+        return re.compile(rf'(?<![A-Za-z0-9_]){re.escape(value)}(?![A-Za-z0-9_])', re.I)
+
+    @staticmethod
+    def _translation_technical_entity_shape(value):
+        token = str(value or '').strip()
+        if not token or not re.search(r'[A-Za-z]', token):
+            return False
+        compact = re.sub(r'[^A-Za-z0-9]', '', token)
+        return bool(
+            any(ch.isdigit() for ch in compact)
+            or (len(compact) >= 2 and compact.isupper())
+            or (len(compact) > 2 and any(ch.isupper() for ch in compact[1:]))
+        )
+
+    @classmethod
+    def _translation_protected_entity_ledger(cls, source, glossary=None):
+        """Build a deterministic source-owned Latin entity ledger.
+
+        The ledger is derived from the current frozen source, never from a product
+        tier or global user whitelist.  Registry scope is the supplied frozen unit;
+        each entry retains claim-local ownership so an entity occurring elsewhere in
+        the manuscript cannot authorize insertion into another claim.
+        """
+        source_value = str(source or '')
+        entries = []
+        seen = set()
+        ordinary_sentence_starters = {
+            'the','this','these','those','prior','previous','current','our','we','results','findings',
+            'participants','evidence','analysis','study','research','however','therefore','because',
+            'method','methods','discussion','introduction','conclusion','open',
+        }
+        compound_suffixes = {
+            'based','style','derived','enabled','assisted','powered','driven','supported','mediated',
+            'inspired','oriented','led','related','specific','level','type',
+        }
+
+        def add(canonical, category, claim_id, surface=None, target_surface=None):
+            canonical = str(canonical or '').strip()
+            if not canonical or not re.search(r'[A-Za-z]', canonical):
+                return
+            surface = str(surface or canonical).strip()
+            target_surface = str(target_surface or canonical).strip()
+            key = (canonical.casefold(), str(category or ''), str(claim_id or ''), target_surface.casefold())
+            if key in seen:
+                return
+            seen.add(key)
+            entity_material = '|'.join(key).encode('utf-8')
+            entries.append({
+                'entity_id': 'E' + hashlib.sha256(entity_material).hexdigest()[:12],
+                'canonical': canonical,
+                'category': str(category or 'PROPER_NAME'),
+                'source_surface': surface,
+                'target_surface': target_surface,
+                'claim_id': str(claim_id or 'C000001'),
+                'retention_policy': 'exact_latin_identity',
+            })
+
+        for claim in cls._translation_claim_units(source_value):
+            claim_id = str(claim.get('claim_id') or 'C000001')
+            claim_source = str(claim.get('text') or '')
+            ir = cls._compile_translation_ir(claim_source)
+            for manifest in (ir.get('fact_ledger') or {}).values():
+                if not isinstance(manifest, dict):
+                    continue
+                anchor_type = str(manifest.get('type') or '')
+                surface = str(manifest.get('source') or '').strip()
+                if anchor_type == 'NAME':
+                    add(surface, 'MODEL_TOOL', claim_id, surface)
+                elif anchor_type == 'ACRONYM':
+                    add(surface, 'ACRONYM', claim_id, surface)
+                elif anchor_type in {'HYPOTHESIS','QUOTE_ID'}:
+                    add(surface, 'VARIABLE', claim_id, surface)
+
+            token_pattern = re.compile(
+                r'(?<![A-Za-z0-9_])([A-Za-z][A-Za-z0-9+.#]*(?:-[A-Za-z0-9+.#]+)*)(?![A-Za-z0-9_])'
+            )
+            for match in token_pattern.finditer(claim_source):
+                token = match.group(1)
+                if '-' in token:
+                    base, suffix = token.split('-', 1)
+                    suffix_folded = suffix.casefold()
+                    if suffix_folded in compound_suffixes and cls._translation_technical_entity_shape(base):
+                        add(base, 'MODEL_TOOL', claim_id, token, base)
+                        continue
+                    if suffix_folded in compound_suffixes and re.fullmatch(r'[A-Z][a-z]{2,}', base):
+                        add(base, 'PROPER_NAME', claim_id, token, base)
+                        continue
+                if cls._translation_technical_entity_shape(token):
+                    add(token, 'MODEL_TOOL', claim_id, token)
+
+            # Conservative standalone proper-name support.  Hyphen-adjacent words
+            # are excluded here and handled only by the bounded compound rule above,
+            # preventing ``Open-ended`` from authorizing a bare ``Open``.
+            for match in re.finditer(r'(?<![A-Za-z0-9_-])([A-Z][a-z]{2,})(?![A-Za-z0-9_-])', claim_source):
+                token = match.group(1)
+                if token.casefold() in ordinary_sentence_starters:
+                    continue
+                if match.start() == 0:
+                    continue
+                add(token, 'PROPER_NAME', claim_id, token)
+
+            for source_term, target_term in dict(glossary or {}).items():
+                source_term = str(source_term or '').strip()
+                target_term = str(target_term or '').strip()
+                if not source_term or source_term.casefold() not in claim_source.casefold():
+                    continue
+                words = re.findall(r'[A-Za-z][A-Za-z0-9+.#-]*', target_term)
+                title_like = bool(words) and len(words) <= 6 and all(
+                    word.casefold() in {'a','an','and','as','at','by','for','from','in','of','on','or','the','to','with'}
+                    or word[:1].isupper() for word in words
+                )
+                if target_term and re.search(r'[A-Za-z]', target_term) and (
+                    title_like or cls._translation_technical_entity_shape(target_term)
+                ):
+                    add(target_term, 'LEGAL_GLOSSARY', claim_id, source_term, target_term)
+
+        normalized_entries = sorted(
+            entries,
+            key=lambda row: (row['claim_id'], row['canonical'].casefold(), row['category'], row['target_surface'].casefold()),
+        )
+        material = json.dumps(normalized_entries, ensure_ascii=False, sort_keys=True, separators=(',', ':'))
+        return {
+            'version': cls.PROTECTED_ENTITY_LEDGER_VERSION,
+            'entries': normalized_entries,
+            'hash': hashlib.sha256(material.encode('utf-8')).hexdigest(),
+        }
+
+    @classmethod
+    def translation_protected_entity_ledger_hash(cls, source, glossary=None):
+        return str(cls._translation_protected_entity_ledger(source, glossary).get('hash') or '')
+
+    @classmethod
+    def _translation_lexical_nonentity_protected_pattern(cls):
+        """Protect non-lexical immutable objects without granting global entity authority.
+
+        Names/acronyms/model identifiers are intentionally excluded: they are legal
+        only through the source-owned Protected Entity Ledger.  This prevents a
+        target-only ``ChatGPT``/``OpenAI``/tool name from being silently exempted.
+        """
+        numeric = cls._translation_numeric_regex()
+        date_pattern = cls._translation_date_regex()
+        quantity_words = cls._translation_number_word_regex()
+        compound_ci = r'(?i:(?:\d+(?:\.\d+)?%)?\s*CI\s*\[\s*[-+]?\.?\d+(?:\.\d+)?\s*,\s*[-+]?\.?\d+(?:\.\d+)?\s*\])'
+        return re.compile(
+            rf'(?:{date_pattern})'
+            rf'|(?:{compound_ci})'
+            rf'|(?:{quantity_words})'
+            r'|(?i:https?://[^\s)>]+)'
+            r'|(?i:\bdoi:\s*[^\s)>]+)'
+            r'|(?i:\b10\.\d{4,9}/[-._;()/:A-Z0-9]+)'
+            r'|(?i:\b(?:p|t|f|z|r|n)\s*(?:<=|>=|=|<|>|≤|≥)\s*[-+]?(?:\d+(?:\.\d+)?|\.\d+))'
+            r'|(?:β|χ²|R²|ΔR²)\s*(?:<=|>=|=|<|>|≤|≥)\s*[-+]?(?:\d+(?:\.\d+)?|\.\d+)'
+            r'|\([^()\n]*?(?:19|20)\d{2}[a-z]?[^()\n]*?\)'
+            r'|`[^`\n]+`'
+            r'|\$[^$\n]+\$'
+            r'|(?:χ²|R²|ΔR²|η²|ω²|[αβγδΔχλμρστφηωΩ])'
+            r'|\b(?:QUOTE|CASE|RESP|P)-\d+\b'
+            rf'|(?:{numeric})'
+            r'|\|'
+        )
+
+    @staticmethod
+    def _translation_sustained_latin_prose_evidence(text):
+        value = str(text or '')
+        matches = list(re.finditer(r"[A-Za-z][A-Za-z'’-]*", value))
+        function_words = {
+            'a','an','and','are','as','at','be','been','being','by','for','from','had','has','have',
+            'in','into','is','it','of','on','or','that','the','these','this','those','to','was','were',
+            'which','with','within','without','would','could','should','than','then','their','its',
+        }
+        allowed_gap = re.compile(r"^[\s,;:()\[\]{}.!?\"'“”‘’—–/\\-]*$")
+        runs = []
+        current = []
+        previous_end = None
+        for match in matches:
+            if previous_end is None or allowed_gap.fullmatch(value[previous_end:match.start()] or ''):
+                current.append(match)
+            else:
+                if current:
+                    runs.append(current)
+                current = [match]
+            previous_end = match.end()
+        if current:
+            runs.append(current)
+        max_words = 0
+        for run in runs:
+            words = [item.group(0).casefold() for item in run]
+            max_words = max(max_words, len(words))
+            if (len(words) >= 4 and any(word in function_words for word in words)) or len(words) >= 7:
+                return {'confirmed': True, 'max_run_words': len(words)}
+        return {'confirmed': False, 'max_run_words': max_words}
+
     @classmethod
     def _translation_language_rule(cls, target_lang):
         profile = cls._translation_language_profile(target_lang)
@@ -3918,7 +4122,7 @@ Output only the repaired section."""
         # statistics and numeric anchors.
         quote_pattern = re.compile(r'“[^”\n]{1,500}”|"[^"\n]{1,500}"')
         text = quote_pattern.sub(lambda match: ' ' if match.group(0) in source_value else match.group(0), text)
-        text = cls._translation_protected_pattern().sub(' ', text)
+        text = cls._translation_lexical_nonentity_protected_pattern().sub(' ', text)
         text = re.sub(r'\[\[SP-(?:P\d{6}|C\d{6}|T\d{6})\]\]', ' ', text)
 
         # A glossary target may legitimately remain Latin (for example a
@@ -4018,88 +4222,85 @@ Output only the repaired section."""
 
     @classmethod
     def _translation_lexical_purity_evidence(cls, source, target, target_lang, glossary=None):
-        """Detect isolated ordinary English lexemes left in ZH/RU/KK prose.
-
-        This is deliberately narrower than general language identification. It
-        protects research objects, source-matched proper names, and legitimate
-        Latin glossary targets, then treats any remaining ordinary Latin word as
-        untranslated lexical residue. The same gate is shared by Chinese, Russian
-        and Kazakh. Kazakh-vs-Russian discrimination remains evidence-grounded QA
-        because the languages share Cyrillic script and overlapping vocabulary.
+        """Classify target Latin residue after claim-local protected-entity provenance.
+
+        Source-authorized entities are removed with ASCII-safe boundaries before
+        lexical contamination authority is assigned.  Genuine ordinary English
+        residue remains fail-closed, while a target-invented technical entity is
+        routed as an entity-provenance mismatch rather than mislabeled as an
+        untranslated source lexeme.
         """
         profile = cls._translation_language_profile(target_lang)
         language_code = profile.get('language_code')
         if language_code not in {'zh', 'ru', 'kk'}:
-            return {'confirmed': False, 'tokens': [], 'language_code': language_code or ''}
+            return {
+                'confirmed': False, 'tokens': [], 'token_count': 0,
+                'language_code': language_code or '', 'subtype': '',
+                'protected_entities': [], 'ledger_version': cls.PROTECTED_ENTITY_LEDGER_VERSION,
+                'ledger_hash': '',
+            }
 
         source_value = str(source or '')
         text = cls._strip_translation_claim_markers(str(target or ''))
-        # Do not exempt source-matched English quotations here: participant
-        # quotations are target-language content and must not remain ordinary
-        # English merely because the same literal exists in the frozen source.
-        text = cls._translation_protected_pattern().sub(' ', text)
-        text = re.sub(r'\[\[SP-(?:P\d{6}|C\d{6}|T\d{6})\]\]', ' ', text)
-
-        english_function_words = {'a','an','and','as','at','by','for','from','in','of','on','or','the','to','with'}
-        legal_latin_terms = set()
-        for value in dict(glossary or {}).values():
-            term = str(value or '').strip()
-            words = re.findall(r'[A-Za-z][A-Za-z0-9+.#-]*', term)
-            title_like = bool(words) and len(words) <= 5 and all(
-                word.casefold() in english_function_words or word[:1].isupper() for word in words
-            )
-            technical_shape = bool(words) and any(
-                any(ch.isdigit() for ch in word) or word.isupper()
-                or (len(word) > 2 and any(ch.isupper() for ch in word[1:])) for word in words
-            )
-            if term and re.search(r'[A-Za-z]', term) and (title_like or technical_shape):
-                legal_latin_terms.add(term)
-        for term in sorted(legal_latin_terms, key=len, reverse=True):
-            text = re.sub(re.escape(term), ' ', text, flags=re.I)
-
-        source_tokens = list(re.finditer(r'\b[A-Za-z][A-Za-z0-9+.#-]*\b', source_value))
-        technical = set()
-        proper = set()
-        ordinary_sentence_starters = {
-            'the','this','these','those','prior','previous','current','our','we','results','findings',
-            'participants','evidence','analysis','study','research','however','therefore','because',
-        }
-        for match in source_tokens:
-            token = match.group(0)
-            if any(ch.isdigit() for ch in token) or token.isupper() or (len(token) > 2 and any(ch.isupper() for ch in token[1:])):
-                technical.add(token)
+        ledger = cls._translation_protected_entity_ledger(source_value, glossary)
+        retained = []
+        for entry in ledger.get('entries') or []:
+            surface = str(entry.get('target_surface') or entry.get('canonical') or '').strip()
+            pattern = cls._translation_ascii_boundary_pattern(surface)
+            if not pattern:
                 continue
-            if token[:1].isupper() and token.casefold() not in ordinary_sentence_starters:
-                proper.add(token)
-        for token in sorted(technical | proper, key=len, reverse=True):
-            text = re.sub(rf'(?<![A-Za-z0-9_]){re.escape(token)}(?![A-Za-z0-9_])', ' ', text)
+            if pattern.search(text):
+                retained.append(str(entry.get('canonical') or surface))
+                text = pattern.sub(' ', text)
 
-        # Source-matched bounded proper titles/institutions remain legal even if
-        # they contain English function words, e.g. University of California.
-        latin_run_pattern = re.compile(r"(?:[A-Za-z][A-Za-z'’-]*(?:[ \t]+|$)){2,8}")
-        for match in list(latin_run_pattern.finditer(text)):
-            candidate = re.sub(r'\s+', ' ', match.group(0)).strip()
-            if not candidate:
-                continue
-            words = candidate.split()
-            title_like = all(word.casefold() in english_function_words or word[:1].isupper() for word in words)
-            if title_like and candidate.casefold() in re.sub(r'\s+', ' ', source_value).casefold():
-                text = text[:match.start()] + (' ' * (match.end() - match.start())) + text[match.end():]
+        # Non-lexical immutable objects remain protected. Names/acronyms/model
+        # identifiers are excluded here and require claim-local ledger ownership.
+        text = cls._translation_lexical_nonentity_protected_pattern().sub(' ', text)
+        text = re.sub(r'\[\[SP-(?:P\d{6}|C\d{6}|T\d{6})\]\]', ' ', text)
 
+        sustained = cls._translation_sustained_latin_prose_evidence(text)
         allow_words = {'et', 'al', 'vs'}
         residual = []
-        for match in re.finditer(r"[A-Za-z][A-Za-z'’-]*", text):
+        for match in re.finditer(r"[A-Za-z][A-Za-z0-9+.#]*(?:[-'’–—][A-Za-z0-9+.#]+)*", text):
             token = match.group(0).strip("-'’–—")
             folded = token.casefold()
             if folded in allow_words or len(token) < 4:
                 continue
             residual.append(token)
         unique = list(dict.fromkeys(residual))
+        if not unique:
+            return {
+                'confirmed': False,
+                'tokens': [],
+                'token_count': 0,
+                'language_code': language_code,
+                'subtype': 'PROTECTED_ENTITY_RETAINED' if retained else '',
+                'protected_entities': list(dict.fromkeys(retained))[:8],
+                'ledger_version': str(ledger.get('version') or cls.PROTECTED_ENTITY_LEDGER_VERSION),
+                'ledger_hash': str(ledger.get('hash') or ''),
+            }
+
+        source_folded = source_value.casefold()
+        mismatch = [
+            token for token in unique
+            if cls._translation_technical_entity_shape(token) and token.casefold() not in source_folded
+        ]
+        subtype = 'UNTRANSLATED_ORDINARY_LEXEME'
+        if sustained.get('confirmed'):
+            subtype = 'UNTRANSLATED_PROSE'
+        elif mismatch:
+            subtype = 'ENTITY_PROVENANCE_MISMATCH'
         return {
-            'confirmed': bool(unique),
+            'confirmed': True,
             'tokens': unique[:8],
             'token_count': len(residual),
             'language_code': language_code,
+            'subtype': subtype,
+            'protected_entities': list(dict.fromkeys(retained))[:8],
+            'entity_provenance_mismatch_tokens': mismatch[:8],
+            'ledger_version': str(ledger.get('version') or cls.PROTECTED_ENTITY_LEDGER_VERSION),
+            'ledger_hash': str(ledger.get('hash') or ''),
+            'max_latin_run_words': int(sustained.get('max_run_words') or 0),
         }
 
     @classmethod
@@ -5325,15 +5526,56 @@ If ok=false, codes MUST contain only values from allowed_issue_codes. For SEMANT
                         detail={'count': len(canonical_violations), 'sources': '|'.join(canonical_violations)[:160]},
                     )
                 contamination = None
-                deterministic_contamination = bool(lexical.get('confirmed'))
-                deterministic_issue = bool(canonical_violations)
-                if deterministic_contamination:
+                lexical_subtype = str(lexical.get('subtype') or '')
+                entity_mismatch = lexical_subtype == 'ENTITY_PROVENANCE_MISMATCH'
+                deterministic_contamination = bool(lexical.get('confirmed')) and not entity_mismatch
+                deterministic_issue = bool(canonical_violations) or entity_mismatch
+                if lexical_subtype == 'PROTECTED_ENTITY_RETAINED' and model_contamination:
+                    self._record_translation_assurance(
+                        'PROTECTED_ENTITY_RETAINED', target_lang=target_lang, block_id=row_id,
+                        severity='diagnostic', decision='PASS_WITH_WARNING',
+                        detail={
+                            'count': len(lexical.get('protected_entities') or []),
+                            'sample': '|'.join(lexical.get('protected_entities') or [])[:120],
+                        },
+                    )
+                if entity_mismatch:
+                    codes = [code for code in codes if code != 'LANGUAGE_CONTAMINATION']
+                    if 'ADDED_CLAIM' not in codes:
+                        codes.append('ADDED_CLAIM')
+                    evidence_row = self._translation_claim_qa_evidence.setdefault(
+                        (meta['block_id'], meta['claim_id']), {}
+                    )
+                    semantic = list(evidence_row.get('semantic_delta_codes') or [])
+                    if 'CLAIM_ADDED' not in semantic:
+                        semantic.append('CLAIM_ADDED')
+                    evidence_row['semantic_delta_codes'] = semantic[:6]
+                    evidence_row['entity_provenance_mismatch_tokens'] = list(
+                        lexical.get('entity_provenance_mismatch_tokens') or lexical.get('tokens') or []
+                    )[:8]
+                    self._record_translation_assurance(
+                        'ENTITY_PROVENANCE_MISMATCH', target_lang=target_lang, block_id=row_id,
+                        severity='repair', decision='REPAIR_LOCAL',
+                        detail={'sample': ','.join(lexical.get('entity_provenance_mismatch_tokens') or lexical.get('tokens') or [])[:120]},
+                    )
+                elif deterministic_contamination:
                     if 'LANGUAGE_CONTAMINATION' not in codes:
                         codes.append('LANGUAGE_CONTAMINATION')
+                    evidence_row = self._translation_claim_qa_evidence.setdefault(
+                        (meta['block_id'], meta['claim_id']), {}
+                    )
+                    evidence_row['contamination_evidence_codes'] = [
+                        'UNTRANSLATED_PROSE' if lexical_subtype == 'UNTRANSLATED_PROSE' else 'UNTRANSLATED_LEXEME'
+                    ]
+                    evidence_row['lexical_evidence_code'] = lexical_subtype or 'UNTRANSLATED_ORDINARY_LEXEME'
                     self._record_translation_assurance(
                         'LEXICAL_PURITY_CONFIRMED', target_lang=target_lang, block_id=row_id,
                         severity='repair', decision='REPAIR_LOCAL',
-                        detail={'token_count': int(lexical.get('token_count') or 0), 'sample': ','.join(lexical.get('tokens') or [])[:120]},
+                        detail={
+                            'token_count': int(lexical.get('token_count') or 0),
+                            'sample': ','.join(lexical.get('tokens') or [])[:120],
+                            'subtype': lexical_subtype or 'UNTRANSLATED_ORDINARY_LEXEME',
+                        },
                     )
                 if language_code == 'ru':
                     contamination = self._russian_contamination_evidence(
@@ -6480,14 +6722,19 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                                 source_claims[claim_id], current_target_claim, target_lang, frozen_glossary
                             )
                             if lexical.get('confirmed'):
+                                lexical_subtype = str(lexical.get('subtype') or 'UNTRANSLATED_ORDINARY_LEXEME')
                                 repair_evidence['detected_unprotected_english_tokens'] = list(lexical.get('tokens') or [])[:8]
-                                repair_evidence['contamination_evidence_codes'] = ['UNTRANSLATED_LEXEME']
+                                repair_evidence['contamination_evidence_codes'] = [
+                                    'UNTRANSLATED_PROSE' if lexical_subtype == 'UNTRANSLATED_PROSE' else 'UNTRANSLATED_LEXEME'
+                                ]
+                                repair_evidence['lexical_evidence_code'] = lexical_subtype
                                 self._record_translation_assurance(
                                     'LEXICAL_PURITY_REPAIR_EVIDENCE', target_lang=target_lang,
                                     block_id=f'SP-P{block_id}-{claim_id}', severity='repair', decision='REPAIR_LOCAL',
                                     detail={
                                         'token_count': int(lexical.get('token_count') or 0),
                                         'sample': ','.join(lexical.get('tokens') or [])[:120],
+                                        'subtype': lexical_subtype,
                                     },
                                 )
                             elif self._translation_language_profile(target_lang).get('language_code') == 'kk':
@@ -6564,6 +6811,7 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                                 detail={
                                     'token_count': int(post_repair_lexical.get('token_count') or 0),
                                     'sample': ','.join(post_repair_lexical.get('tokens') or [])[:120],
+                                    'subtype': str(post_repair_lexical.get('subtype') or ''),
                                 },
                             )
                         segments[claim_id] = repaired_claim
@@ -6600,7 +6848,7 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                                 if prior & current:
                                     meta['nonconvergent_state'] = 'exhausted_after_source_regenerate'
                 if quality_issues:
-                    emit_stage('qa')
+                    emit_stage('adjudicating')
                     quality_issues = self._adjudicate_persistent_translation_issues(
                         source_blocks, translations, quality_issues, target_lang, frozen_glossary,
                         section_name=section_name or 'frozen section',
@@ -6643,6 +6891,8 @@ Decision must be CONFIRMED_BLOCKING or NOT_CONFIRMED. evidence_code must be one
                     'qa_status': 'passed_with_warning' if diagnostics else 'passed',
                     'translation_contract_version': self.TRANSLATION_CONTRACT_VERSION,
                     'fact_ledger_hash': self.translation_fact_ledger_hash(value),
+                    'protected_entity_ledger_version': self.PROTECTED_ENTITY_LEDGER_VERSION,
+                    'protected_entity_ledger_hash': self.translation_protected_entity_ledger_hash(value, frozen_glossary),
                     'language_adapter': profile['adapter_id'],
                     'diagnostics': diagnostics[-20:],
                     'claim_states': dict(self._last_translation_claim_states),

i18n.py

@@ -233,6 +233,11 @@ TEXTS: dict[str, dict[str, str]] = {
         "draft_detail_current": "当前阶段：{stage}",
         "translation_section_running": "正在翻译【{name}】…",
         "translation_section_qa": "正在审核【{name}】的翻译完整性与语义一致性…",
+        "translation_final_gate": "正在进行【{name}】最终翻译质检……",
+        "translation_section_repairing": "正在修复【{name}】翻译问题……",
+        "translation_section_repair_pending": "【{name}】仍有翻译问题，等待最终复核……",
+        "translation_section_adjudicating": "正在进行【{name}】最终翻译一致性确认……",
+        "translation_progress_counts": "{passed}/{total} 已通过 · {repair} 待修复 · {inflight} 正在处理",
         "translation_section_ready": "【{name}】翻译审核通过，正在显示译文…",
         "translation_complete_label": "目标语言论文翻译完成。",
         "busy_short": "⏳ 有用户正在生成论文，预计25–35分钟后可用。",
@@ -404,6 +409,11 @@ TEXTS: dict[str, dict[str, str]] = {
         "draft_detail_current": "Current stage: {stage}",
         "translation_section_running": "Translating 【{name}】…",
         "translation_section_qa": "Checking translation integrity and semantic equivalence for 【{name}】…",
+        "translation_final_gate": "Running final translation QA for 【{name}】…",
+        "translation_section_repairing": "Repairing the translation of 【{name}】…",
+        "translation_section_repair_pending": "Translation issues remain in 【{name}】 and are queued for final review…",
+        "translation_section_adjudicating": "Running final translation consistency confirmation for 【{name}】…",
+        "translation_progress_counts": "{passed}/{total} passed · {repair} pending repair · {inflight} in progress",
         "translation_section_ready": "Translation of 【{name}】 passed QA and is being displayed…",
         "translation_complete_label": "The target-language paper translation is complete.",
         "busy_short": "⏳ Another user is generating a paper. Please try again in about 25–35 minutes.",
@@ -575,6 +585,11 @@ TEXTS: dict[str, dict[str, str]] = {
         "draft_detail_current": "Текущий этап: {stage}",
         "translation_section_running": "Перевод раздела 【{name}】…",
         "translation_section_qa": "Проверка полноты и смысловой эквивалентности перевода раздела 【{name}】…",
+        "translation_final_gate": "Финальная проверка перевода раздела 【{name}】…",
+        "translation_section_repairing": "Исправление перевода раздела 【{name}】…",
+        "translation_section_repair_pending": "В разделе 【{name}】 остаются проблемы перевода; ожидается финальная проверка…",
+        "translation_section_adjudicating": "Финальное подтверждение согласованности перевода раздела 【{name}】…",
+        "translation_progress_counts": "пройдено {passed}/{total} · ожидают исправления {repair} · обрабатывается {inflight}",
         "translation_section_ready": "Перевод раздела 【{name}】 прошёл проверку и отображается…",
         "translation_complete_label": "Перевод статьи на целевой язык завершён.",
         "busy_short": "⏳ Другой пользователь формирует статью. Повторите попытку примерно через 25–35 минут.",
@@ -746,6 +761,11 @@ TEXTS: dict[str, dict[str, str]] = {
         "draft_detail_current": "Ағымдағы кезең: {stage}",
         "translation_section_running": "【{name}】 бөлімі аударылуда…",
         "translation_section_qa": "【{name}】 аудармасының толықтығы мен мағыналық сәйкестігі тексерілуде…",
+        "translation_final_gate": "【{name}】 аудармасының соңғы сапа тексеруі орындалуда…",
+        "translation_section_repairing": "【{name}】 аудармасындағы мәселе түзетілуде…",
+        "translation_section_repair_pending": "【{name}】 аудармасында мәселе қалды; соңғы тексеруді күтуде…",
+        "translation_section_adjudicating": "【{name}】 аудармасының соңғы сәйкестігі расталуда…",
+        "translation_progress_counts": "{passed}/{total} өтті · {repair} түзетуді күтуде · {inflight} өңделуде",
         "translation_section_ready": "【{name}】 аудармасы тексеруден өтті және көрсетілуде…",
         "translation_complete_label": "Мақаланың мақса��ты тілдегі аудармасы аяқталды.",
         "busy_short": "⏳ Басқа пайдаланушы мақала дайындап жатыр. Шамамен 25–35 минуттан кейін қайталап көріңіз.",

smartpaper_restore_bridge/frontend/index.html

@@ -377,10 +377,16 @@
     let value = String(map.waiting || "");
     if (stage.startsWith("translating:")) {
       value = formatTemplate(map.translating || value, {name:stage.slice("translating:".length)});
+    } else if (stage.startsWith("translation_final_gate:")) {
+      value = formatTemplate(map.final_gate || map.qa || value, {name:stage.slice("translation_final_gate:".length)});
     } else if (stage.startsWith("translation_qa:")) {
       value = formatTemplate(map.qa || value, {name:stage.slice("translation_qa:".length)});
+    } else if (stage.startsWith("translation_repairing:")) {
+      value = formatTemplate(map.repairing || map.qa || value, {name:stage.slice("translation_repairing:".length)});
     } else if (stage.startsWith("translation_repair_pending:")) {
-      value = formatTemplate(map.qa || value, {name:stage.slice("translation_repair_pending:".length)});
+      value = formatTemplate(map.repair_pending || map.qa || value, {name:stage.slice("translation_repair_pending:".length)});
+    } else if (stage.startsWith("translation_adjudicating:")) {
+      value = formatTemplate(map.adjudicating || map.qa || value, {name:stage.slice("translation_adjudicating:".length)});
     } else if (stage.startsWith("translation_ready:")) {
       value = formatTemplate(map.ready || value, {name:stage.slice("translation_ready:".length)});
     } else if (stage === "translation_complete") {
@@ -393,7 +399,15 @@
       ? payload.target_progress : {};
     const total = Math.max(0, asCount(targetProgress.total));
     const qaPassed = Math.max(0, Math.min(total || Number.MAX_SAFE_INTEGER, asCount(targetProgress.qa_passed)));
-    if (total > 0) value = `${value} · ${qaPassed}/${total}`;
+    const repairPending = Math.max(0, Math.min(total || Number.MAX_SAFE_INTEGER, asCount(targetProgress.repair_pending)));
+    const inFlight = Math.max(0, Math.min(total || Number.MAX_SAFE_INTEGER, asCount(targetProgress.in_flight)));
+    if (total > 0) {
+      const countsTemplate = String(map.counts || "");
+      const counts = countsTemplate
+        ? formatTemplate(countsTemplate, {passed:qaPassed, total, repair:repairPending, inflight:inFlight})
+        : `${qaPassed}/${total}`;
+      value = `${value} · ${counts}`;
+    }
     if (!value) return;
     const hasTargetText = Boolean(String(payload && payload.target_text || "").trim()) || Boolean(channel.authoritative);
     if (hasTargetText) {