R3.2.8.6-R1.3C-RU2 Russian Contamination Adjudication and Target Preview State

core/generation_runner.py

@@ -8,6 +8,7 @@ connections. Checkpoints are task-scoped, immutable-by-sequence JSON snapshots.
 from __future__ import annotations
 
 import hashlib
+import inspect
 import json
 import logging
 import math
@@ -33,7 +34,7 @@ ProgressCallback = Callable[..., None]
 MIN_FINAL_REFERENCES = 50
 LITERATURE_EVIDENCE_TARGET = 75
 CITATION_PLAN_TARGET = 70
-TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v1'
+TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v2'
 
 
 def _clean_trailing_references(text, keywords=("reference", "references", "reference list", "参考文献")):
@@ -299,10 +300,31 @@ class GenerationRunner:
         partial = self._assemble_partial_translation(translation_sections, adaptive_structure, include_front=include_front)
         self._publish_target_preview(partial, f'translating:{unit_name}', force=True, complete=False)
         updated_sections = dict(translation_sections or {})
+
+        def publish_translation_stage(stage):
+            value = str(stage or '').strip().casefold()
+            if value in {'qa', 'repairing'}:
+                preview_stage = f'translation_qa:{unit_name}'
+            else:
+                preview_stage = f'translating:{unit_name}'
+            self._publish_target_preview(partial, preview_stage, force=True, complete=False)
+
         try:
-            result = agent.translate_frozen_section(
-                source, target_lang, glossary=translation_glossary, section_name=unit_name, max_attempts=2
-            )
+            translate_method = agent.translate_frozen_section
+            call_kwargs = {
+                'glossary': translation_glossary, 'section_name': unit_name, 'max_attempts': 2,
+            }
+            try:
+                parameters = inspect.signature(translate_method).parameters.values()
+                supports_stage_callback = any(
+                    item.name == 'stage_callback' or item.kind == inspect.Parameter.VAR_KEYWORD
+                    for item in parameters
+                )
+            except (TypeError, ValueError):
+                supports_stage_callback = False
+            if supports_stage_callback:
+                call_kwargs['stage_callback'] = publish_translation_stage
+            result = translate_method(source, target_lang, **call_kwargs)
         except PipelineCancelledError:
             raise
         except Exception as error:
@@ -326,6 +348,9 @@ class GenerationRunner:
                 'Translation deferred until final gate | unit=%s code=%s error=%s',
                 unit_name, error_code, type(error).__name__,
             )
+            self._publish_target_preview(
+                partial, f'translation_repair_pending:{unit_name}', force=True, complete=False
+            )
             return updated_sections, translation_glossary
         updated_glossary = dict(result.get('glossary') or translation_glossary or {})
         updated_sections[unit_key] = {
@@ -720,7 +745,13 @@ class GenerationRunner:
         if working_abstract and not state.get("english_finalized"):
             section_order_for_front = self._unique_top_level_sections(adaptive_structure)
             if section_order_for_front:
-                working_front_source = self._extract_front_matter(full_draft_en, section_order_for_front[0][1])
+                first_section_title = section_order_for_front[0][1]
+                working_front_source = self._extract_front_matter(full_draft_en, first_section_title)
+                if not working_front_source and not completed_sections:
+                    # Fresh tasks contain only Title/Abstract/Keywords here; the
+                    # first body heading does not exist yet. Preserve legacy
+                    # resume behavior when completed body sections are present.
+                    working_front_source = str(full_draft_en or '').strip()
                 translation_sections, translation_glossary = self._translate_frozen_unit(
                     agent, unit_key='__front_matter__', unit_name='Working Front Matter',
                     source_text=working_front_source, target_lang=target_lang,

core/pipeline_agent.py

@@ -61,7 +61,7 @@ class CitationAuditError(DeepSeekRequestError):
 
 
 class SSciPipelineAgent:
-    TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v1'
+    TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v2'
 
     def __init__(self, ds_key, s2_key=""):
         self.ds_key = str(ds_key or "").strip()
@@ -3459,6 +3459,123 @@ Output only the repaired section."""
             core = 'Use formal academic Simplified Chinese with explicit concepts, natural Chinese syntax, clear hierarchy, and logically connected claims. Avoid carrying English nominalization and clause order into Chinese mechanically.'
         return core + ' ' + profile['term_policy'] + ' ' + profile['contamination_policy']
 
+    @classmethod
+    def _russian_contamination_evidence(cls, source, target, glossary=None):
+        """Deterministically confirm only sustained, unprotected Latin prose in Russian.
+
+        LLM QA may propose LANGUAGE_CONTAMINATION, but a fatal/repair signal is
+        accepted only when this evidence check finds a multi-word Latin clause
+        after removing immutable research objects and explicit glossary terms.
+        This prevents AI/LLM/ChatGPT/SEM/model names from becoming lexical
+        blacklists while preserving fail-closed behavior for real English prose.
+        """
+        source_value = str(source or '')
+        text = cls._strip_translation_claim_markers(str(target or ''))
+        # A verbatim quoted span is protected evidence only when the same quote
+        # exists in the locked English source. Invented/untranslated English
+        # quotes are not silently exempted. Research-object protection also
+        # removes acronyms, model/tool names, citations, URLs, DOI strings,
+        # 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 = re.sub(r'\[\[SP-(?:P\d{6}|C\d{6}|T\d{6})\]\]', ' ', text)
+
+        # A glossary target may legitimately remain Latin (for example a
+        # standardized construct/tool name). Remove only exact glossary targets;
+        # do not whitelist arbitrary English source prose.
+        glossary_terms = []
+        english_function_words = {
+            'a','an','and','as','at','by','for','from','in','of','on','or','the','to','with',
+        }
+        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):
+                glossary_terms.append(term)
+        for term in sorted(set(glossary_terms), key=len, reverse=True):
+            text = re.sub(re.escape(term), ' ', text, flags=re.I)
+
+        # Mixed-case technical names such as OpenAI/TensorFlow are not covered by
+        # the all-caps acronym rule. Allow them only when they are present in the
+        # locked English source; ordinary source prose is never whitelisted.
+        source_tokens = set(re.findall(r'\b[A-Za-z][A-Za-z0-9+.#-]*\b', str(source or '')))
+        technical = {
+            token for token in source_tokens
+            if any(ch.isdigit() for ch in token)
+            or (len(token) > 2 and any(ch.isupper() for ch in token[1:]))
+        }
+        for token in sorted(technical, key=len, reverse=True):
+            text = re.sub(rf'(?<![A-Za-z0-9_]){re.escape(token)}(?![A-Za-z0-9_])', ' ', text)
+
+        latin = list(re.finditer(r"[A-Za-z][A-Za-z'’-]*", text))
+        allowed_gap = re.compile(r"^[\s,;:()\[\]{}.!?\"'“”‘’—–/\\-]*$")
+        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',
+        }
+        max_run = 0
+        max_run_has_function = False
+        run = []
+        previous_end = None
+        normalized_source = re.sub(r'\s+', ' ', source_value).casefold()
+
+        def evaluate(items):
+            nonlocal max_run, max_run_has_function
+            if not items:
+                return False
+            original_words = [item.group(0) for item in items]
+            words = [word.casefold() for word in original_words]
+            has_function = any(word in function_words for word in words)
+            if len(words) > max_run:
+                max_run = len(words)
+                max_run_has_function = has_function
+            # Preserve a bounded source-matched proper name/title such as
+            # "University of California at Berkeley". Ordinary copied English
+            # prose is not title-like and therefore remains detectable.
+            title_like = len(words) <= 6 and all(
+                word in function_words or original[:1].isupper()
+                for word, original in zip(words, original_words)
+            )
+            candidate = ' '.join(original_words).casefold()
+            if title_like and candidate and candidate in normalized_source:
+                return False
+            # Four-word clause with an English function word is strong evidence;
+            # seven Latin words is strong even without one. Short titles/terms
+            # and isolated Latin research objects remain legal.
+            return (len(words) >= 4 and has_function) or len(words) >= 7
+
+        confirmed = False
+        for match in latin:
+            if previous_end is None:
+                run = [match]
+            else:
+                gap = text[previous_end:match.start()]
+                if allowed_gap.fullmatch(gap or ''):
+                    run.append(match)
+                else:
+                    confirmed = confirmed or evaluate(run)
+                    run = [match]
+            previous_end = match.end()
+        confirmed = confirmed or evaluate(run)
+        return {
+            'confirmed': bool(confirmed),
+            'max_latin_run_words': int(max_run),
+            'max_run_has_function_word': bool(max_run_has_function),
+            'glossary_latin_terms': int(len(set(glossary_terms))),
+            'source_technical_tokens': int(len(technical)),
+        }
+
     @classmethod
     def _compile_translation_ir(cls, source):
         """Compile a private, language-neutral translation intermediate representation."""
@@ -4302,7 +4419,7 @@ SECTION: {section_name}
             system_prompt = f"""You are a bilingual academic translation QA classifier for {target_lang}.
 Review EACH claim independently. Do not rewrite and do not provide free-form explanations. Check semantic equivalence and language quality: omissions/additions, negation, uncertainty, association-versus-causation strength, terminology, grammar, language contamination, citation attachment, and acronym attachment.
 LANGUAGE ADAPTER: {profile['adapter_id']}; morphology={profile['morphology']}. {profile['term_policy']} {profile['contamination_policy']}
-For Russian, do not flag a terminology error merely because a translated term is inflected for grammatical case/number/gender. For Kazakh, do not flag a terminology error merely because productive suffixes attach to the correct term stem. For Kazakh language identity, absence of Kazakh-specific letters in one short claim is not sufficient evidence of Russian contamination.
+For Russian, do not flag a terminology error merely because a translated term is inflected for grammatical case/number/gender. For Russian LANGUAGE_CONTAMINATION, require sustained unprotected non-Russian prose such as a multi-word English clause or sentence. Never use LANGUAGE_CONTAMINATION merely for protected acronyms, AI/LLM/SEM, model or tool names, variable names, citations, glossary terms, source-matched proper names/titles, or isolated Latin terminology. For Kazakh, do not flag a terminology error merely because productive suffixes attach to the correct term stem. For Kazakh language identity, absence of Kazakh-specific letters in one short claim is not sufficient evidence of Russian contamination.
 Return valid JSON only in this exact form: {{"items":[{{"id":"SP-P000001-C000001","ok":true,"codes":[]}}]}}.
 If ok=false, codes MUST contain only values from allowed_issue_codes. Never return numbered prose, examples, quotes, or corrective wording. Return every supplied id exactly once."""
             response = self.call_deepseek(
@@ -4319,15 +4436,42 @@ If ok=false, codes MUST contain only values from allowed_issue_codes. Never retu
                     f'Translation claim QA id mismatch: expected={expected_row_ids}, got={sorted(by_id)}.'
                 )
             row_lookup = {row['id']: row for row in rows}
+            language_code = profile.get('language_code')
             for row_id in expected_row_ids:
                 returned_row = by_id[row_id]
-                if returned_row.get('ok') is True:
-                    continue
+                meta = row_lookup[row_id]
                 raw_codes = [str(code or '').strip().upper() for code in (returned_row.get('codes') or [])]
                 codes = [code for code in raw_codes if code in allowed_codes]
+                model_contamination = 'LANGUAGE_CONTAMINATION' in codes
+                contamination = None
+                if language_code == 'ru':
+                    contamination = self._russian_contamination_evidence(
+                        meta['english'], meta['target'], relevant_glossary
+                    )
+                    if contamination.get('confirmed'):
+                        if 'LANGUAGE_CONTAMINATION' not in codes:
+                            codes.append('LANGUAGE_CONTAMINATION')
+                    elif model_contamination:
+                        codes = [code for code in codes if code != 'LANGUAGE_CONTAMINATION']
+                        self._record_translation_assurance(
+                            'RU_LANGUAGE_CONTAMINATION_UNCONFIRMED', target_lang=target_lang, block_id=row_id,
+                            severity='diagnostic', decision='PASS_WITH_WARNING', detail=contamination,
+                        )
+
+                # A deterministic confirmed Russian contamination signal can
+                # override an LLM false negative. Conversely, a sole Russian
+                # contamination code without deterministic evidence is suppressed.
+                if returned_row.get('ok') is True and not (contamination and contamination.get('confirmed')):
+                    continue
                 if not codes:
+                    only_suppressed_contamination = (
+                        language_code == 'ru' and model_contamination
+                        and not (contamination or {}).get('confirmed')
+                        and bool(raw_codes) and all(code == 'LANGUAGE_CONTAMINATION' for code in raw_codes)
+                    )
+                    if only_suppressed_contamination:
+                        continue
                     codes = ['SEMANTIC_DRIFT']
-                meta = row_lookup[row_id]
                 issues.setdefault(meta['block_id'], {})[meta['claim_id']] = list(dict.fromkeys(codes))[:5]
         return issues
 
@@ -4685,7 +4829,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 )
         return {}
 
-    def translate_frozen_section(self, section_text, target_lang, glossary=None, section_name='', max_attempts=2):
+    def translate_frozen_section(self, section_text, target_lang, glossary=None, section_name='', max_attempts=2, stage_callback=None):
         """Translate one frozen English unit and publish only after all QA passes."""
         value = str(section_text or '').strip()
         if not value:
@@ -4716,8 +4860,21 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
         )
         attempts = max(1, int(max_attempts or 1))
         last_error = None
+
+        def emit_stage(stage):
+            if not callable(stage_callback):
+                return
+            try:
+                stage_callback(str(stage or ''))
+            except Exception as error:
+                logging.warning(
+                    'Translation stage callback ignored: section=%s stage=%s error=%s',
+                    section_name or 'section', stage, type(error).__name__,
+                )
+
         for attempt in range(1, attempts + 1):
             self._check_cancelled()
+            emit_stage('translating')
             translations = {}
             try:
                 for batch in batches:
@@ -4727,6 +4884,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                     for batch in batches
                     for block_id, source in batch
                 }
+                emit_stage('qa')
                 quality_issues = self._audit_translation_blocks_with_retry(
                     source_blocks, translations, target_lang, frozen_glossary,
                     section_name=section_name or 'frozen section', max_attempts=2,
@@ -4742,8 +4900,12 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                     logging.warning(
                         'Translation claim-local QA recovery: section=%s round=%s failed=%s',
                         section_name or 'section', local_round,
-                        [f'SP-P{block_id}-{claim_id}' for block_id, claim_id, _codes in failed_pairs],
+                        [
+                            {'id': f'SP-P{block_id}-{claim_id}', 'codes': list(codes)}
+                            for block_id, claim_id, codes in failed_pairs
+                        ],
                     )
+                    emit_stage('repairing')
                     touched_blocks = set()
                     for block_id, claim_id, codes in failed_pairs:
                         source_claims = {
@@ -4760,6 +4922,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                         )
                         translations[block_id] = self._compose_translation_claim_segments(claim_order, segments)
                         touched_blocks.add(block_id)
+                    emit_stage('qa')
                     quality_issues = self._audit_translation_blocks_with_retry(
                         {block_id: source_blocks[block_id] for block_id in sorted(touched_blocks)},
                         {block_id: translations[block_id] for block_id in sorted(touched_blocks)},

smartpaper_restore_bridge/frontend/index.html

@@ -335,10 +335,33 @@
     target.textContent = value;
   }
 
+  function ensureTargetStatusNode(parentDocument) {
+    const shell = parentDocument.getElementById("sp-live-translation-shell");
+    const target = parentDocument.getElementById("sp-live-translation-preview");
+    if (!shell || !target) return null;
+    let status = parentDocument.getElementById("sp-live-translation-status");
+    if (!status) {
+      status = parentDocument.createElement("div");
+      status.id = "sp-live-translation-status";
+      status.style.whiteSpace = "pre-wrap";
+      status.style.fontSize = "0.88em";
+      status.style.opacity = "0.72";
+      status.style.marginBottom = "8px";
+      status.style.paddingBottom = "4px";
+      status.style.position = "sticky";
+      status.style.top = "0";
+      status.style.zIndex = "1";
+      status.style.background = "#ffffff";
+      status.style.display = "none";
+      shell.insertBefore(status, target);
+    }
+    return status;
+  }
+
   function updateTargetPreparation(parentDocument, payload, labels) {
     const target = parentDocument.getElementById("sp-live-translation-preview");
     const channel = renderChannels.target;
-    if (!target || channel.authoritative || target.querySelector("[data-sp-live-stream='1']")) return;
+    if (!target) return;
     const map = labels && typeof labels === "object" ? labels : {};
     const stage = String(payload && payload.target_stage || "");
     let value = String(map.waiting || "");
@@ -346,12 +369,23 @@
       value = formatTemplate(map.translating || value, {name:stage.slice("translating:".length)});
     } else if (stage.startsWith("translation_qa:")) {
       value = formatTemplate(map.qa || value, {name:stage.slice("translation_qa:".length)});
+    } else if (stage.startsWith("translation_repair_pending:")) {
+      value = formatTemplate(map.qa || value, {name:stage.slice("translation_repair_pending:".length)});
     } else if (stage.startsWith("translation_ready:")) {
       value = formatTemplate(map.ready || value, {name:stage.slice("translation_ready:".length)});
     } else if (stage === "translation_complete") {
       value = String(map.complete || value);
     }
     if (!value) return;
+    const hasTargetText = Boolean(String(payload && payload.target_text || "").trim()) || Boolean(channel.authoritative);
+    if (hasTargetText) {
+      const status = ensureTargetStatusNode(parentDocument);
+      if (!status) return;
+      status.textContent = value;
+      status.style.display = "block";
+      return;
+    }
+    if (target.querySelector("[data-sp-live-stream='1']")) return;
     target.dataset.spPlaceholder = "1";
     target.textContent = value;
   }
@@ -512,7 +546,7 @@
       updateOnePreview(parentDocument, parentWindow, "sp-live-translation-preview", "sp-live-translation-shell", targetText, renderChannels.target);
       lastTargetPreviewText = targetText;
     }
-    if (!targetText) updateTargetPreparation(parentDocument, payload, watch && watch.targetStatusLabels);
+    updateTargetPreparation(parentDocument, payload, watch && watch.targetStatusLabels);
   }
 
   async function fetchPreview(watch) {