Step 4A-6-C-R3.2.8 Citation Singularity Word Streaming Bilingual Translation and Structure Gate Fix (#18)

- Step 4A-6-C-R3.2.8 Citation Singularity Word Streaming Bilingual Translation and Structure Gate Fix (e95bfefb68ee6c51de6e81468676be31afe5967a)

app.py

@@ -693,6 +693,17 @@ def _watch_task_status_live(task: dict) -> dict | None:
                     "outline_planning": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_outline"),
                     "citation_planning": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_citation"),
                     "writing": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_writing"),
+                    "progress": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_detail_progress"),
+                    "s2": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_detail_s2"),
+                    "oa": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_detail_oa"),
+                    "current": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_detail_current"),
+                },
+                "target_status_labels": {
+                    "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"),
+                    "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"),
                 },
             },
             key=f"sp_task_watch_{_safe_key(task_id)}",
@@ -737,23 +748,38 @@ def _load_confirmed_checkpoint(task: dict) -> dict | None:
 
 
 def _render_checkpoint_preview(task: dict, lang_code: str) -> None:
-    """Render one stable DOM target; browser preview updates mutate it in place."""
+    """Render stable bilingual DOM targets; browser mutates them in place."""
     checkpoint = _load_confirmed_checkpoint(task)
-    draft = str((checkpoint or {}).get("full_draft_en") or "").strip()
-    initial_text = draft if draft else tr(lang_code, "draft_preparing")
-    escaped = html.escape(initial_text)
-    placeholder = "0" if draft else "1"
-    st.markdown(tr(lang_code, "english_draft"))
-    st.markdown(
-        f"""
-        <div id='sp-live-manuscript-shell' style='border:1px solid #e5e7eb;border-radius:8px;padding:14px 16px;min-height:180px;max-height:68vh;overflow:auto;background:#ffffff;'>
-          <div id='sp-live-manuscript-preview' data-sp-placeholder='{placeholder}' style='white-space:pre-wrap;overflow-wrap:anywhere;margin:0;font-family:inherit;line-height:1.72;color:#111827;'>{escaped}</div>
-          <span id='sp-live-manuscript-cursor' aria-hidden='true' style='display:inline-block;width:7px;height:1.05em;background:#111827;margin-left:2px;vertical-align:-0.12em;animation:spBlink 1s steps(1,end) infinite;'></span>
-        </div>
-        <style>@keyframes spBlink {{ 0%,49% {{opacity:1}} 50%,100% {{opacity:0}} }}</style>
-        """,
-        unsafe_allow_html=True,
-    )
+    english = str((checkpoint or {}).get("full_draft_en") or "").strip()
+    target = str((checkpoint or {}).get("full_draft_translated") or "").strip()
+    english_initial = english if english else tr(lang_code, "draft_preparing")
+    target_initial = target if target else tr(lang_code, "translation_waiting")
+    english_placeholder = "0" if english else "1"
+    target_placeholder = "0" if target else "1"
+    left, right = st.columns([1, 1], gap="medium")
+    with left:
+        st.markdown(tr(lang_code, "english_draft"))
+        st.markdown(
+            f"""
+            <div id='sp-live-manuscript-shell' style='border:1px solid #e5e7eb;border-radius:8px;padding:14px 16px;min-height:220px;max-height:68vh;overflow:auto;background:#ffffff;'>
+              <div id='sp-live-manuscript-preview' data-sp-placeholder='{english_placeholder}' style='white-space:pre-wrap;overflow-wrap:anywhere;margin:0;font-family:inherit;line-height:1.72;color:#111827;'>{html.escape(english_initial)}</div>
+              <span id='sp-live-manuscript-cursor' aria-hidden='true' style='display:inline-block;width:7px;height:1.05em;background:#111827;margin-left:2px;vertical-align:-0.12em;animation:spBlink 1s steps(1,end) infinite;'></span>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+    with right:
+        st.markdown(tr(lang_code, "target_draft", flag=get_target_flag(lang_code)))
+        st.markdown(
+            f"""
+            <div id='sp-live-translation-shell' style='border:1px solid #e5e7eb;border-radius:8px;padding:14px 16px;min-height:220px;max-height:68vh;overflow:auto;background:#ffffff;'>
+              <div id='sp-live-translation-preview' data-sp-placeholder='{target_placeholder}' style='white-space:pre-wrap;overflow-wrap:anywhere;margin:0;font-family:inherit;line-height:1.72;color:#111827;'>{html.escape(target_initial)}</div>
+              <span id='sp-live-translation-cursor' aria-hidden='true' style='display:inline-block;width:7px;height:1.05em;background:#111827;margin-left:2px;vertical-align:-0.12em;animation:spBlink 1s steps(1,end) infinite;'></span>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+    st.markdown("<style>@keyframes spBlink { 0%,49% {opacity:1} 50%,100% {opacity:0} }</style>", unsafe_allow_html=True)
 
 
 def _render_task_status_once(lang_code: str) -> None:

core/generation_runner.py

@@ -82,6 +82,12 @@ class GenerationRunner:
         self.preview_token = preview_token if re.fullmatch(r"[A-Za-z0-9_-]{32,128}", preview_token) else ""
         self.preview_path = None
         self._last_preview_write = 0.0
+        self._preview_english_text = ""
+        self._preview_english_stage = ""
+        self._preview_english_complete = False
+        self._preview_target_text = ""
+        self._preview_target_stage = "translation_waiting"
+        self._preview_target_complete = False
         if self.preview_token:
             preview_dir = Path(__file__).resolve().parents[1] / "static" / "previews"
             preview_dir.mkdir(parents=True, exist_ok=True)
@@ -129,11 +135,15 @@ class GenerationRunner:
     @staticmethod
     def _preview_visible_text(value: str) -> str:
         text = str(value or "")
-        # Never expose hidden reasoning; only final manuscript prose is previewed.
+        # Never expose hidden reasoning. Raw CITE placeholders are also hidden
+        # from the user because they have not passed semantic citation QA yet;
+        # the authoritative manuscript buffer remains untouched.
         text = re.sub(r"(?is)<think>.*?(?:</think>|$)", "", text)
+        text = re.sub(r"\s*\[?CITE-\d+\]?\s*", " ", text, flags=re.I)
+        text = re.sub(r"[ \t]{2,}", " ", text)
         return text.strip()
 
-    def _publish_preview(self, text: str, stage: str, *, force: bool = False, complete: bool = False) -> None:
+    def _write_preview_payload(self, *, force: bool = False) -> None:
         if self.preview_path is None:
             return
         now = time.monotonic()
@@ -143,9 +153,12 @@ class GenerationRunner:
             "task_id": str(self.request.get("task_id") or ""),
             "request_hash": self.request_hash,
             "execution_epoch": self.execution_epoch,
-            "stage": str(stage or "")[:240],
-            "text": self._preview_visible_text(text),
-            "complete": bool(complete),
+            "stage": str(self._preview_english_stage or "")[:240],
+            "text": self._preview_visible_text(self._preview_english_text),
+            "complete": bool(self._preview_english_complete),
+            "target_stage": str(self._preview_target_stage or "")[:240],
+            "target_text": self._preview_visible_text(self._preview_target_text),
+            "target_complete": bool(self._preview_target_complete),
             "updated_at": datetime.now(timezone.utc).isoformat(),
         }
         temporary = self.preview_path.with_suffix(".json.tmp")
@@ -153,6 +166,18 @@ class GenerationRunner:
         os.replace(temporary, self.preview_path)
         self._last_preview_write = now
 
+    def _publish_preview(self, text: str, stage: str, *, force: bool = False, complete: bool = False) -> None:
+        self._preview_english_text = str(text or "")
+        self._preview_english_stage = str(stage or "")
+        self._preview_english_complete = bool(complete)
+        self._write_preview_payload(force=force)
+
+    def _publish_target_preview(self, text: str, stage: str, *, force: bool = True, complete: bool = False) -> None:
+        self._preview_target_text = str(text or "")
+        self._preview_target_stage = str(stage or "")
+        self._preview_target_complete = bool(complete)
+        self._write_preview_payload(force=force)
+
     def _stream_text(self, generator, *, preview_prefix: str | None = None, preview_stage: str = "") -> str:
         chunks = []
         for chunk in generator:
@@ -167,6 +192,102 @@ class GenerationRunner:
             self._publish_preview(preview_prefix + text, preview_stage, force=True)
         return text
 
+    @staticmethod
+    def _text_hash(value: str) -> str:
+        normalized = re.sub(r'\s+', ' ', str(value or '')).strip()
+        return hashlib.sha256(normalized.encode('utf-8')).hexdigest()
+
+    @staticmethod
+    def _unique_top_level_sections(tasks):
+        output = []
+        seen = set()
+        for task in tasks or []:
+            key = str(task.get('section_id') or task.get('section') or '').strip()
+            title = str(task.get('section') or '').strip()
+            if key and title and key not in seen:
+                seen.add(key); output.append((key, title))
+        return output
+
+    @staticmethod
+    def _extract_top_level_section(manuscript: str, title: str) -> str:
+        value = str(manuscript or '')
+        match = re.search(
+            rf'(?ms)^#\s+{re.escape(str(title))}\s*$\n(.*?)(?=^#\s+[^#].*?$|\Z)', value
+        )
+        if not match:
+            return ''
+        return f"# {title}\n" + match.group(1).strip()
+
+    @staticmethod
+    def _extract_front_matter(manuscript: str, first_section_title: str) -> str:
+        value = str(manuscript or '')
+        match = re.search(rf'(?m)^#\s+{re.escape(str(first_section_title))}\s*$', value)
+        return value[:match.start()].strip() if match else ''
+
+    @staticmethod
+    def _section_is_complete(tasks, completed_display_names, section_key: str) -> bool:
+        relevant = [
+            str(task.get('display_name') or '') for task in (tasks or [])
+            if str(task.get('section_id') or task.get('section') or '') == str(section_key)
+        ]
+        done = set(str(item) for item in (completed_display_names or []))
+        return bool(relevant) and all(name in done for name in relevant)
+
+    @staticmethod
+    def _glossary_version(glossary) -> str:
+        encoded = json.dumps(dict(glossary or {}), ensure_ascii=False, sort_keys=True).encode('utf-8')
+        return hashlib.sha256(encoded).hexdigest()[:16]
+
+    @staticmethod
+    def _assemble_partial_translation(translation_sections, adaptive_structure, *, include_front=False) -> str:
+        mapping = translation_sections if isinstance(translation_sections, dict) else {}
+        parts = []
+        if include_front:
+            record = mapping.get('__front_matter__') or {}
+            if record.get('qa_status') == 'passed' and record.get('translated_text'):
+                parts.append(str(record['translated_text']).strip())
+        for key, _title in GenerationRunner._unique_top_level_sections(adaptive_structure):
+            record = mapping.get(key) or {}
+            if record.get('qa_status') == 'passed' and record.get('translated_text'):
+                parts.append(str(record['translated_text']).strip())
+        return '\n\n'.join(part for part in parts if part).strip()
+
+    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,
+    ):
+        source = str(source_text or '').strip()
+        if not source:
+            return translation_sections, translation_glossary
+        source_hash = self._text_hash(source)
+        existing = dict((translation_sections or {}).get(unit_key) or {})
+        if (
+            existing.get('qa_status') == 'passed'
+            and existing.get('source_hash') == source_hash
+            and existing.get('target_lang') == target_lang
+            and existing.get('translated_text')
+        ):
+            return translation_sections, translation_glossary
+        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)
+        result = agent.translate_frozen_section(
+            source, target_lang, glossary=translation_glossary, section_name=unit_name, max_attempts=2
+        )
+        updated_glossary = dict(result.get('glossary') or translation_glossary or {})
+        updated_sections = dict(translation_sections or {})
+        updated_sections[unit_key] = {
+            'source_hash': source_hash,
+            'target_lang': target_lang,
+            'glossary_version': self._glossary_version(updated_glossary),
+            'translated_text': str(result.get('text') or '').strip(),
+            'qa_status': 'passed',
+            'attempts': int(result.get('attempts') or 1),
+            'completed_at': datetime.now(timezone.utc).isoformat(),
+        }
+        partial = self._assemble_partial_translation(updated_sections, adaptive_structure, include_front=include_front)
+        self._publish_target_preview(partial, f'translation_ready:{unit_name}', force=True, complete=False)
+        return updated_sections, updated_glossary
+
     @staticmethod
     def _bounded_target(base_target: int, accumulated_deviation: float, remaining_including_current: int, safe_chunk: int) -> int:
         base = max(80, int(base_target))
@@ -234,6 +355,8 @@ class GenerationRunner:
 
         state = self.checkpoints.load_latest() or {}
         if state:
+            self._preview_english_text = str(state.get('full_draft_en') or '')
+            self._preview_target_text = str(state.get('full_draft_translated') or '')
             logging.info(
                 "[SP_EXECUTOR] resume checkpoint seq=%s stage=%s",
                 state.get("checkpoint_seq"), state.get("checkpoint_stage"),
@@ -378,6 +501,8 @@ class GenerationRunner:
                     "body_target_words": body_target_words,
                     "full_draft_en": full_draft_en,
                     "full_draft_translated": "",
+                    "translation_sections": {},
+                    "translation_glossary": {},
                     "completed_sections": [],
                     "context_tail": "",
                     "accumulated_deviation": 0.0,
@@ -399,6 +524,10 @@ class GenerationRunner:
             state.get("research_logic_contract") or agent.global_memory.get("research_logic_contract") or ""
         )
         citation_plan = state.get("citation_plan") if isinstance(state.get("citation_plan"), dict) else {}
+        translation_sections = dict(state.get('translation_sections') or {})
+        translation_glossary = dict(state.get('translation_glossary') or {})
+        if self._preview_target_text == '':
+            self._preview_target_text = str(state.get('full_draft_translated') or '')
         if not citation_plan:
             self._progress(15, "citation_planning")
             citation_plan = agent.build_claim_evidence_plan(
@@ -615,11 +744,23 @@ Output only final academic prose. Do not report the word count."""
             actual_words = self._english_count_for_target(en_resolved)
             accumulated_deviation += actual_words - adjusted_target
             completed_sections.append(display_name)
+            section_key = str(sec.get('section_id') or sec_title)
+            if self._section_is_complete(adaptive_structure, completed_sections, section_key):
+                frozen_section = self._extract_top_level_section(full_draft_en, sec_title)
+                translation_sections, translation_glossary = self._translate_frozen_unit(
+                    agent, unit_key=section_key, unit_name=sec_title, source_text=frozen_section,
+                    target_lang=target_lang, translation_sections=translation_sections,
+                    translation_glossary=translation_glossary, adaptive_structure=adaptive_structure,
+                    include_front=False,
+                )
+            partial_translation = self._assemble_partial_translation(translation_sections, adaptive_structure)
             state.update(
                 {
                     "completed_sections": completed_sections,
                     "full_draft_en": full_draft_en,
-                    "full_draft_translated": "",
+                    "full_draft_translated": partial_translation,
+                    "translation_sections": translation_sections,
+                    "translation_glossary": translation_glossary,
                     "context_tail": context_tail,
                     "accumulated_deviation": accumulated_deviation,
                     "agent_state": agent.export_state(),
@@ -661,12 +802,19 @@ Output only final academic prose. Do not report the word count."""
                 full_draft_en = agent.rebalance_discussion_length(
                     full_draft_en, target_words=target_words, mode=mode, actual_words=actual_words
                 )
-                agent.validate_manuscript_structure(full_draft_en, adaptive_structure, translated=False)
+            body_only, _reference_tail = agent.validate_reference_tail(
+                full_draft_en, minimum_references=MIN_FINAL_REFERENCES
+            )
+            agent.validate_manuscript_structure(body_only, adaptive_structure, translated=False)
+            agent.enforce_resolved_claim_specific_citations(body_only)
             self._validate_target_length(full_draft_en, target_words)
             self._publish_preview(full_draft_en, "english_complete", force=True, complete=True)
             state.update(
                 {
                     "full_draft_en": full_draft_en,
+                    "full_draft_translated": self._assemble_partial_translation(translation_sections, adaptive_structure),
+                    "translation_sections": translation_sections,
+                    "translation_glossary": translation_glossary,
                     "english_finalized": True,
                     "agent_state": agent.export_state(),
                 }
@@ -676,13 +824,55 @@ Output only final academic prose. Do not report the word count."""
             full_draft_en = str(state.get("full_draft_en") or "")
 
         full_draft_translated = str(state.get("full_draft_translated") or "")
+        translation_sections = dict(state.get('translation_sections') or translation_sections or {})
+        translation_glossary = dict(state.get('translation_glossary') or translation_glossary or {})
         if not state.get("translation_complete") or not full_draft_translated:
-            self._progress(95, "translation")
-            full_draft_translated = agent.translate_locked_manuscript(full_draft_en, target_lang)
+            self._progress(94, "translation")
+            body_only, reference_tail = agent.validate_reference_tail(
+                full_draft_en, minimum_references=MIN_FINAL_REFERENCES
+            )
+            section_order = self._unique_top_level_sections(adaptive_structure)
+            if not section_order:
+                raise RuntimeError('translation_section_plan_missing')
+            front_matter = self._extract_front_matter(body_only, section_order[0][1])
+            final_units = [('__front_matter__', 'Front Matter', front_matter)]
+            for key, title in section_order:
+                final_units.append((key, title, self._extract_top_level_section(body_only, title)))
+            for index, (unit_key, unit_name, source_text) in enumerate(final_units, start=1):
+                translation_sections, translation_glossary = self._translate_frozen_unit(
+                    agent, unit_key=unit_key, unit_name=unit_name, source_text=source_text,
+                    target_lang=target_lang, translation_sections=translation_sections,
+                    translation_glossary=translation_glossary, adaptive_structure=adaptive_structure,
+                    include_front=True,
+                )
+                partial = self._assemble_partial_translation(
+                    translation_sections, adaptive_structure, include_front=True
+                )
+                state.update({
+                    'full_draft_en': full_draft_en,
+                    'full_draft_translated': partial,
+                    'translation_sections': translation_sections,
+                    'translation_glossary': translation_glossary,
+                    'agent_state': agent.export_state(),
+                })
+                pct = min(96, 94 + int(index * 2 / max(1, len(final_units))))
+                self._checkpoint(f'translation_{unit_key}', state, pct)
+
+            full_draft_translated = self._assemble_partial_translation(
+                translation_sections, adaptive_structure, include_front=True
+            ).rstrip()
+            full_draft_translated += (
+                f"\n\n# {agent._localized_reference_heading(target_lang)}\n" + reference_tail.strip()
+            )
             agent.validate_translation_alignment(full_draft_en, full_draft_translated)
+            self._publish_target_preview(
+                full_draft_translated, 'translation_complete', force=True, complete=True
+            )
             state.update(
                 {
                     "full_draft_translated": full_draft_translated,
+                    "translation_sections": translation_sections,
+                    "translation_glossary": translation_glossary,
                     "translation_complete": True,
                     "agent_state": agent.export_state(),
                 }

core/pipeline_agent.py

@@ -1421,6 +1421,36 @@ Return a concise PROVISIONAL RESEARCH LOGIC CONTRACT in plain English prose. It
             )
         return True
 
+    @staticmethod
+    def validate_reference_tail(text, minimum_references=1):
+        """Validate the required English References tail independently of body H1s.
+
+        Canonical manuscript structure intentionally excludes References.  The
+        tail is therefore validated here instead of weakening the body schema.
+        """
+        value = str(text or '').strip()
+        matches = list(re.finditer(r'(?m)^#\s+References\s*$', value))
+        if len(matches) != 1:
+            raise DeepSeekAPIError(
+                f'References tail validation failed: heading_count={len(matches)}, expected=1.'
+            )
+        match = matches[0]
+        body = value[:match.start()].rstrip()
+        tail = value[match.end():].strip()
+        if not body:
+            raise DeepSeekAPIError('References tail validation failed: manuscript body is empty.')
+        if not tail:
+            raise DeepSeekAPIError('References tail validation failed: References is empty.')
+        if re.search(r'(?m)^#\s+', tail):
+            raise DeepSeekAPIError('References tail validation failed: another H1 appears after References.')
+        refs = [line.strip() for line in tail.splitlines() if line.strip().startswith('- ')]
+        required = max(1, int(minimum_references or 1))
+        if len(refs) < required:
+            raise DeepSeekAPIError(
+                f'References tail validation failed: references={len(refs)}, required>={required}.'
+            )
+        return body, tail
+
     @staticmethod
     def find_repeated_qualitative_quotes(text, data_metadata):
         violations = []
@@ -3066,6 +3096,9 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
         if Counter(re.findall(cite_pattern, original, re.I)) != Counter(re.findall(cite_pattern, revised, re.I)):
             logging.warning('Word-budget Discussion repair rejected because citations changed.')
             return value
+        if self.find_multi_citation_violations(revised):
+            logging.warning('Word-budget Discussion repair rejected because it stacked multiple sources in one sentence.')
+            return value
         return value[:match.start(1)] + revised + '\n\n' + value[match.end(1):]
 
     @staticmethod
@@ -3154,7 +3187,7 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
 
     @staticmethod
     def _translation_prompt(target_lang):
-        common = """Translate the supplied blocks from the locked English manuscript faithfully. Preserve every marker, citation, number, percentage, coefficient, p-value, confidence interval, DOI, hypothesis label, variable abbreviation, quotation meaning, and conclusion direction. Do not add or remove claims. Use concise, accurate, rigorous academic language. Avoid metaphors, analogies, rhetorical questions, promotional language, formulaic transitions, and mechanical repetition. Return every marker exactly once and in the same order. Output only the marked translations."""
+        common = """Translate the supplied blocks from the locked English manuscript faithfully. Preserve every [[SP-Pxxxxxx]] paragraph marker and every [[SP-Txxxxxx]] protected token exactly once and in the same order. Protected tokens represent citations, statistics, identifiers, formulas, URLs/DOIs, hypotheses, abbreviations, or other immutable research objects and must never be translated or normalized. Preserve quotation meaning and conclusion direction. Do not add or remove claims. Use concise, accurate, rigorous academic language. Avoid metaphors, analogies, rhetorical questions, promotional language, formulaic transitions, and mechanical repetition. Output only the marked translations."""
         return common + ' ' + SSciPipelineAgent._translation_language_rule(target_lang)
 
     @staticmethod
@@ -3192,6 +3225,216 @@ Output only the revised Discussion body, without the '# Discussion' heading."""
             )
         )
 
+    @staticmethod
+    def _translation_protected_pattern():
+        # One-pass alternation prevents a placeholder created for a citation or
+        # URL from being matched again as an acronym/number.  Keep this list
+        # conservative: protect immutable research objects, not prose.
+        return re.compile(
+            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)\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'|(?i:\bH\d+[A-Za-z]?\b)'
+            r'|\b(?:fsQCA|SmartPLS|Mplus|OpenAlex|DeepSeek|ChatGPT|RStudio|SPSS|AMOS|Stata)\b'
+            r'|\b[A-Z][A-Z0-9-]{1,11}(?:s|es)?\b'
+            r'|(?:χ²|R²|ΔR²|η²|ω²|[αβγδΔχλ��ρστφηωΩ])'
+            r'|\b(?:QUOTE|CASE|RESP|P)-\d+\b'
+            r'|(?<![A-Za-z])[-+]?\d+(?:\.\d+)?%?'
+            r'|\|'
+        )
+
+    @classmethod
+    def _protect_translation_tokens(cls, value):
+        mapping = {}
+        counter = 0
+        pattern = cls._translation_protected_pattern()
+
+        def replace(match):
+            nonlocal counter
+            counter += 1
+            placeholder = f'[[SP-T{counter:06d}]]'
+            mapping[placeholder] = match.group(0)
+            return placeholder
+
+        return pattern.sub(replace, str(value or '')), mapping
+
+    @staticmethod
+    def _restore_translation_tokens(value, mapping, block_id=''):
+        text = str(value or '')
+        found = Counter(re.findall(r'\[\[SP-T\d{6}\]\]', text))
+        expected = Counter(mapping.keys())
+        if found != expected:
+            missing = list((expected - found).elements())[:8]
+            added = list((found - expected).elements())[:8]
+            raise DeepSeekRequestError(
+                f'Translation protected placeholder mismatch in {block_id}: missing={missing}, added={added}.'
+            )
+        for placeholder, original in mapping.items():
+            text = text.replace(placeholder, original)
+        if re.search(r'\[\[SP-T\d{6}\]\]', text):
+            raise DeepSeekRequestError(f'Translation left unresolved protected placeholders in {block_id}.')
+        return text
+
+    def extend_translation_glossary(self, body, target_lang, existing=None):
+        """Extend a task-level glossary without remapping an existing term."""
+        mapping = dict(existing or {})
+        headings = [title for _, title in self._markdown_heading_tree(body)]
+        acronyms = sorted(self._translation_acronym_tokens(body))
+        phrases = re.findall(r'\b(?:[A-Z][a-z]+(?:[- ][A-Z][a-z]+){1,3})\b', str(body or ''))
+        recurring = [term for term, count in Counter(phrases).most_common() if count >= 2]
+        term_limit = max(10, int(APP_CONFIG.get('translation_glossary_term_limit', 40)))
+        sources = list(dict.fromkeys(headings + recurring + acronyms))[:term_limit]
+        missing = [term for term in sources if not str(mapping.get(term) or '').strip()]
+        if missing:
+            language_rule = self._translation_language_rule(target_lang)
+            response = self.call_deepseek(
+                f"Create one consistent academic terminology glossary for translation into {target_lang}. {language_rule} Return valid JSON only as {{\"terms\":[{{\"source\":\"...\",\"target\":\"...\"}}]}}. Return every supplied source exactly once. Existing terminology is frozen and is not being supplied for remapping.",
+                json.dumps({'terms': missing}, ensure_ascii=False),
+                max_tokens=max(1200, min(5000, len(missing) * 80)),
+                temp=0.0, model_role='translation', thinking=False, allow_fallback=False,
+            )
+            parsed = self._extract_json_from_text(response)
+            items = parsed.get('terms', []) if isinstance(parsed, dict) else []
+            new_map = {
+                str(item.get('source') or '').strip(): str(item.get('target') or '').strip()
+                for item in items if isinstance(item, dict)
+            }
+            omitted = [term for term in missing if not new_map.get(term)]
+            if omitted:
+                raise DeepSeekRequestError('Translation glossary omitted term(s): ' + ', '.join(omitted[:5]))
+            for term in missing:
+                mapping.setdefault(term, new_map[term])
+        for acronym in acronyms:
+            mapping.setdefault(acronym, acronym)
+        return mapping
+
+    @staticmethod
+    def _validate_translation_language_quality(translated, target_lang):
+        text = str(translated or '')
+        compact = re.sub(r'\s+', '', text)
+        if len(compact) < 80:
+            return True
+        if 'Chinese' in target_lang:
+            if len(re.findall(r'[\u4e00-\u9fff]', text)) < max(12, int(len(compact) * 0.08)):
+                raise DeepSeekRequestError('Chinese translation quality validation failed: insufficient Chinese text.')
+            return True
+        cyrillic = re.findall(r'[А-Яа-яЁёӘәҒғҚқҢңӨөҰұҮүҺһІі]', text)
+        if not cyrillic:
+            raise DeepSeekRequestError('Target-language translation contains no Cyrillic text.')
+        kazakh_specific = re.findall(r'[ӘәҒғҚқҢңӨөҰұҮүҺһІі]', text)
+        if 'Kazakh' in target_lang and len(cyrillic) >= 200:
+            minimum = max(2, int(len(cyrillic) * 0.002))
+            if len(kazakh_specific) < minimum:
+                raise DeepSeekRequestError('Kazakh translation quality validation failed: insufficient Kazakh-specific letters.')
+        if 'Russian' in target_lang and cyrillic and len(kazakh_specific) / len(cyrillic) > 0.02:
+            raise DeepSeekRequestError('Russian translation quality validation failed: excessive Kazakh-specific letters.')
+        return True
+
+    def validate_translation_semantic_equivalence(self, source, translated, target_lang, section_name=''):
+        """Fail closed when translation changes claim meaning or evidence strength."""
+        source_value = str(source or '').strip()
+        target_value = str(translated or '').strip()
+        if len(source_value) < 120 or len(target_value) < 80:
+            return True
+        prompt = f"""Audit whether the TARGET is a faithful academic translation of the ENGLISH source into {target_lang}.
+Check only semantic equivalence. Reject if any substantive claim is omitted or added; negation/polarity changes; association becomes causation; uncertainty/modality becomes stronger; a hypothesis/result direction or supported/unsupported conclusion changes; a limitation disappears; or quotation meaning changes. Do not rewrite.
+Return JSON only: {{\"ok\":true|false,\"issues\":[\"short issue\"]}}.
+SECTION: {section_name}
+<ENGLISH>
+{source_value}
+</ENGLISH>
+<TARGET>
+{target_value}
+</TARGET>"""
+        response = self.call_deepseek(
+            'You are a bilingual academic translation equivalence auditor. Be conservative and evidence-preserving.',
+            prompt, max_tokens=1200, temp=0.0, model_role='reasoning', thinking=False, allow_fallback=False,
+        )
+        parsed = self._extract_json_from_text(response)
+        ok = parsed.get('ok') if isinstance(parsed, dict) else None
+        issues = parsed.get('issues', []) if isinstance(parsed, dict) else []
+        if ok is not True:
+            detail = '; '.join(str(item) for item in (issues or [])[:4]) or 'semantic equivalence not confirmed'
+            raise DeepSeekRequestError(
+                f'Translation semantic equivalence failed for {section_name or "section"}: {detail[:600]}'
+            )
+        return True
+
+    def audit_translation_blocks(self, sources, translations, target_lang, glossary=None, section_name=''):
+        """Return block-localized translation QA issues without rewriting good blocks.
+
+        This combines semantic-equivalence and target-language quality review so
+        a failed paragraph can be regenerated independently rather than forcing
+        a whole-section translation retry.
+        """
+        source_map = {str(key): str(value or '').strip() for key, value in dict(sources or {}).items()}
+        target_map = {str(key): str(value or '').strip() for key, value in dict(translations or {}).items()}
+        expected_ids = [key for key in source_map if key in target_map]
+        if set(expected_ids) != set(source_map) or set(expected_ids) != set(target_map):
+            raise DeepSeekRequestError('Translation block QA source/target ids differ.')
+        if not expected_ids:
+            return {}
+
+        glossary_value = dict(glossary or {})
+        batch_size = 6
+        issues = {}
+        for offset in range(0, len(expected_ids), batch_size):
+            batch_ids = expected_ids[offset:offset + batch_size]
+            relevant_glossary = {}
+            joined_source = '\n'.join(source_map[block_id] for block_id in batch_ids)
+            for source_term, target_term in glossary_value.items():
+                if source_term and str(source_term) in joined_source:
+                    relevant_glossary[str(source_term)] = str(target_term)
+            payload = {
+                'section': str(section_name or 'section'),
+                'target_language': target_lang,
+                'glossary': relevant_glossary,
+                'items': [
+                    {
+                        'id': f'SP-P{block_id}',
+                        'english': source_map[block_id],
+                        'target': target_map[block_id],
+                    }
+                    for block_id in batch_ids
+                ],
+            }
+            system_prompt = f"""You are a bilingual academic translation QA reviewer for {target_lang}.
+Review EACH supplied block independently. Do not rewrite. Check: (1) no substantive claim is omitted or added; (2) negation, direction, uncertainty, association-versus-causation strength, hypothesis/result status, limitations, and quotation meaning are preserved; (3) the target is natural, grammatically correct academic {target_lang}, not language-contaminated; (4) frozen glossary terms are used consistently, allowing only grammatical inflection where the target language requires it.
+For Russian, reject noticeable Kazakh-language contamination. For Kazakh, reject Russian wording/syntax masquerading as Kazakh and require natural Kazakh morphology. For Simplified Chinese, require natural academic Chinese while preserving protected research objects.
+Return valid JSON only: {{"items":[{{"id":"SP-P000001","ok":true,"issues":[]}}]}}. Return every supplied id exactly once."""
+            response = self.call_deepseek(
+                system_prompt,
+                json.dumps(payload, ensure_ascii=False),
+                max_tokens=max(1200, min(3600, 700 + 420 * len(batch_ids))),
+                temp=0.0, model_role='reasoning', thinking=False, allow_fallback=False,
+            )
+            parsed = self._extract_json_from_text(response)
+            rows = parsed.get('items', []) if isinstance(parsed, dict) else []
+            by_id = {}
+            for row in rows:
+                if not isinstance(row, dict):
+                    continue
+                raw_id = str(row.get('id') or '').strip()
+                match = re.fullmatch(r'SP-P(\d{6})', raw_id)
+                if match and match.group(1) in batch_ids and match.group(1) not in by_id:
+                    by_id[match.group(1)] = row
+            if set(by_id) != set(batch_ids):
+                raise DeepSeekRequestError(
+                    f'Translation block QA id mismatch: expected={batch_ids}, got={sorted(by_id)}.'
+                )
+            for block_id in batch_ids:
+                row = by_id[block_id]
+                if row.get('ok') is True:
+                    continue
+                detail = [str(item).strip() for item in (row.get('issues') or []) if str(item).strip()]
+                issues[block_id] = detail[:5] or ['translation quality was not confirmed']
+        return issues
+
     @staticmethod
     def _translation_body_units(body):
         units = []
@@ -3387,27 +3630,35 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 block_id, source, system_prompt, target_lang
             )
 
-    def _translate_marked_batch_with_recovery(self, batch, system_prompt, target_lang):
-        """Translate one marked batch with a conservative marker-recovery path.
+    def _translate_marked_batch_with_recovery(self, batch, system_prompt, target_lang, _strict=False):
+        """Translate one marked batch with protected tokens and bounded recovery.
 
-        A multi-block response must preserve every marker exactly. If the model
-        omits or reorders markers, retry each source block independently so no
-        paragraph-to-translation mapping is guessed. For a single-source retry,
-        a marker-free response can be bound safely to that sole source block,
-        but it must still pass the existing deterministic translation guards.
+        Multi-block marker/protected-token failures are binary-split first.  A
+        single block may accept a marker-free response only when it is the sole
+        source, after which every protected object and existing integrity gate
+        must still pass.
         """
         expected_ids = [block_id for block_id, _ in batch]
+        protected_batch = []
+        protected_maps = {}
+        for block_id, source in batch:
+            protected_source, token_map = self._protect_translation_tokens(source)
+            protected_batch.append((block_id, source, protected_source))
+            protected_maps[block_id] = token_map
         marked_source = '\n\n'.join(
-            f'[[SP-P{block_id}]]\n{source}' for block_id, source in batch
+            f'[[SP-P{block_id}]]\n{protected_source}'
+            for block_id, _, protected_source in protected_batch
         )
+        effective_prompt = system_prompt
+        if _strict:
+            effective_prompt += (
+                '\nSTRICT RETRY: Copy every SP-P and SP-T marker byte-for-byte. Do not merge, drop, reorder, '
+                'translate, pluralize, or normalize any protected token.'
+            )
         result = self.call_deepseek(
-            system_prompt,
-            marked_source,
+            effective_prompt, marked_source,
             max_tokens=max(1800, min(9000, self._count_tokens(marked_source) * 2 + 1200)),
-            temp=0.0,
-            model_role='translation',
-            thinking=False,
-            allow_fallback=False,
+            temp=0.0, model_role='translation', thinking=False, allow_fallback=False,
         )
         result = self._remove_ai_meta_traces(result)
 
@@ -3416,53 +3667,177 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
         except DeepSeekRequestError as error:
             if not str(error).startswith('Translation marker mismatch:'):
                 raise
-
             if len(batch) > 1:
+                found_ids = set(re.findall(r'(?m)^\[\[SP-P(\d{6})\]\]\s*$', str(result or '')))
+                if not found_ids:
+                    logging.warning(
+                        'Translation marker recovery: batch_size=%s expected=%s; all markers were lost, retrying as isolated single blocks.',
+                        len(batch), expected_ids,
+                    )
+                    recovered = {}
+                    for single in batch:
+                        recovered.update(self._translate_marked_batch_with_recovery([single], system_prompt, target_lang))
+                    return recovered
+                middle = max(1, len(batch) // 2)
                 logging.warning(
-                    'Translation marker recovery: batch_size=%s expected=%s; retrying blocks independently.',
-                    len(batch),
-                    expected_ids,
+                    'Translation marker recovery: batch_size=%s expected=%s found=%s; partial marker damage, binary splitting.',
+                    len(batch), expected_ids, sorted(found_ids),
                 )
                 recovered = {}
-                for item in batch:
-                    recovered.update(
-                        self._translate_marked_batch_with_recovery(
-                            [item], system_prompt, target_lang
-                        )
-                    )
+                recovered.update(self._translate_marked_batch_with_recovery(batch[:middle], system_prompt, target_lang))
+                recovered.update(self._translate_marked_batch_with_recovery(batch[middle:], system_prompt, target_lang))
                 return recovered
-
             block_id, source = batch[0]
-            unexpected_markers = re.findall(
-                r'(?m)^\[\[SP-P(\d{6})\]\]\s*$',
-                str(result or ''),
-            )
+            unexpected_markers = re.findall(r'(?m)^\[\[SP-P(\d{6})\]\]\s*$', str(result or ''))
             if unexpected_markers:
                 raise DeepSeekRequestError(
                     'Single-block translation returned an unexpected marker: '
                     f'expected={block_id}, got={unexpected_markers}.'
                 ) from error
-
             translated = str(result or '').strip()
             if not translated:
-                raise DeepSeekRequestError(
-                    f'Single-block translation recovery returned empty text for SP-P{block_id}.'
-                ) from error
-            translated = self._validate_translation_block_with_abbreviation_recovery(
-                block_id, source, translated, system_prompt, target_lang
-            )
-            logging.info(
-                'Translation marker recovery accepted marker-free single block: SP-P%s',
-                block_id,
-            )
-            return {block_id: translated}
+                raise DeepSeekRequestError(f'Single-block translation recovery returned empty text for SP-P{block_id}.') from error
+            parsed = {block_id: translated}
+            logging.info('Translation marker recovery accepted marker-free single block: SP-P%s', block_id)
 
-        for block_id, source in batch:
-            translated = self._validate_translation_block_with_abbreviation_recovery(
-                block_id, source, parsed[block_id], system_prompt, target_lang
-            )
-            parsed[block_id] = translated
-        return parsed
+        restored = {}
+        try:
+            for block_id, source in batch:
+                translated = self._restore_translation_tokens(
+                    parsed[block_id], protected_maps.get(block_id, {}), f'SP-P{block_id}'
+                )
+                translated = self._validate_translation_block_with_abbreviation_recovery(
+                    block_id, source, translated, system_prompt, target_lang
+                )
+                restored[block_id] = translated
+        except DeepSeekRequestError as error:
+            protected_failure = 'protected placeholder mismatch' in str(error) or 'unresolved protected placeholders' in str(error)
+            if protected_failure and len(batch) > 1:
+                middle = max(1, len(batch) // 2)
+                logging.warning('Translation protected-token recovery: batch_size=%s; binary splitting.', len(batch))
+                recovered = {}
+                recovered.update(self._translate_marked_batch_with_recovery(batch[:middle], system_prompt, target_lang))
+                recovered.update(self._translate_marked_batch_with_recovery(batch[middle:], system_prompt, target_lang))
+                return recovered
+            if protected_failure and len(batch) == 1 and not _strict:
+                logging.warning('Translation protected-token recovery: strict single-block retry for SP-P%s.', batch[0][0])
+                return self._translate_marked_batch_with_recovery(batch, system_prompt, target_lang, _strict=True)
+            raise
+        return restored
+
+    def translate_frozen_section(self, section_text, target_lang, glossary=None, section_name='', max_attempts=2):
+        """Translate one frozen English unit and publish only after all QA passes."""
+        value = str(section_text or '').strip()
+        if not value:
+            raise DeepSeekRequestError('Frozen English translation unit is empty.')
+        if re.search(r'(?m)^#\s+References\s*$', value):
+            raise DeepSeekRequestError('References must not be sent to the translation model.')
+        frozen_glossary = self.extend_translation_glossary(value, target_lang, glossary)
+        units = self._translation_body_units(value)
+        body_units = [unit for unit in units if unit['kind'] == 'body']
+        if not body_units:
+            raise DeepSeekRequestError('Frozen English translation unit contains no translatable body.')
+        token_budget = max(800, min(2000, int(APP_CONFIG.get('translation_batch_tokens', 2500))))
+        batches, current, current_tokens = [], [], 0
+        for index, unit in enumerate(body_units, start=1):
+            block_id = f'{index:06d}'
+            tokens = max(1, self._count_tokens(unit['text']))
+            if current and current_tokens + tokens > token_budget:
+                batches.append(current); current = []; current_tokens = 0
+            current.append((block_id, unit['text'])); current_tokens += tokens
+        if current:
+            batches.append(current)
+        system_prompt = (
+            self._translation_prompt(target_lang)
+            + '\nUse this frozen terminology glossary consistently. Never remap an existing term:\n'
+            + json.dumps(frozen_glossary, ensure_ascii=False)
+        )
+        attempts = max(1, int(max_attempts or 1))
+        last_error = None
+        for attempt in range(1, attempts + 1):
+            self._check_cancelled()
+            translations = {}
+            try:
+                for batch in batches:
+                    translations.update(self._translate_marked_batch_with_recovery(batch, system_prompt, target_lang))
+                source_blocks = {
+                    block_id: source
+                    for batch in batches
+                    for block_id, source in batch
+                }
+                quality_issues = self.audit_translation_blocks(
+                    source_blocks, translations, target_lang, frozen_glossary,
+                    section_name=section_name or 'frozen section',
+                )
+                local_round = 0
+                while quality_issues and local_round < 2:
+                    local_round += 1
+                    failed_ids = sorted(quality_issues)
+                    logging.warning(
+                        'Translation block-local QA recovery: section=%s round=%s failed=%s',
+                        section_name or 'section', local_round, failed_ids,
+                    )
+                    for block_id in failed_ids:
+                        details = '; '.join(quality_issues.get(block_id) or [])[:700]
+                        quality_prompt = (
+                            system_prompt
+                            + '\nQUALITY RETRY FOR ONE BLOCK: Correct only the translation-quality issue(s) listed below. '
+                              'Preserve every protected placeholder and SP-P marker exactly. Do not add claims.\n'
+                            + details
+                        )
+                        retry = self._translate_marked_batch_with_recovery(
+                            [(block_id, source_blocks[block_id])], quality_prompt, target_lang, _strict=True
+                        )
+                        translations[block_id] = retry[block_id]
+                    quality_issues = self.audit_translation_blocks(
+                        {block_id: source_blocks[block_id] for block_id in failed_ids},
+                        {block_id: translations[block_id] for block_id in failed_ids},
+                        target_lang, frozen_glossary, section_name=section_name or 'frozen section',
+                    )
+                if quality_issues:
+                    detail = '; '.join(
+                        f'SP-P{block_id}: {"; ".join(messages)}'
+                        for block_id, messages in sorted(quality_issues.items())
+                    )
+                    raise DeepSeekRequestError(
+                        f'Translation block-local QA failed for {section_name or "section"}: {detail[:1000]}'
+                    )
+
+                # Rebuild after any localized repairs, then apply deterministic
+                # whole-unit integrity/language checks before publication.
+                output_units = []
+                body_index = 0
+                for unit in units:
+                    if unit['kind'] == 'heading':
+                        translated_heading = str(frozen_glossary.get(unit['text']) or '').strip()
+                        if not translated_heading:
+                            raise DeepSeekRequestError(f'Translation glossary missing heading: {unit["text"]}')
+                        output_units.append('#' * int(unit['level']) + ' ' + translated_heading)
+                    else:
+                        body_index += 1
+                        output_units.append(translations[f'{body_index:06d}'])
+                output = '\n\n'.join(output_units).strip()
+                self.validate_translation_alignment(value, output)
+                self._validate_translation_language_quality(output, target_lang)
+                return {
+                    'text': output,
+                    'glossary': frozen_glossary,
+                    'attempts': attempt,
+                    'qa_status': 'passed',
+                }
+            except PipelineCancelledError:
+                raise
+            except Exception as error:
+                last_error = error
+                if str(error).startswith('Translation block-local QA failed'):
+                    raise
+                logging.warning(
+                    'Translation section technical retry: section=%s attempt=%s/%s error=%s',
+                    section_name or 'section', attempt, attempts, self._safe_source_error(error),
+                )
+                if attempt >= attempts:
+                    raise
+        raise last_error or DeepSeekRequestError('Translation section QA failed.')
 
     def translate_locked_manuscript(self, manuscript, target_lang):
         value = str(manuscript or '').strip()
@@ -3605,7 +3980,7 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
         violations = []
         raw_tag_pattern = re.compile(r"CITE-\d+", re.IGNORECASE)
         resolved_citation_pattern = re.compile(
-            r"\((?:[^()\n]*?)(?:19|20)\d{2}[a-z]?[^()\n]*?\)",
+            r"\((?=[^()\n]*[A-Za-zÀ-ÖØ-öø-ÿ'’.-]+(?:\s+(?:&\s+[A-Za-zÀ-ÖØ-öø-ÿ'’.-]+|et\s+al\.))?\s*,\s*(?:19|20)\d{2}[a-z]?\b)[^()\n]+\)",
             re.IGNORECASE,
         )
         for _, _, sentence in SSciPipelineAgent._sentence_spans(text):

i18n.py

@@ -19,7 +19,7 @@ LANGUAGE_OPTIONS = {
 
 TARGET_LANGUAGE = {
     "zh": "Simplified Chinese (简体中文)",
-    # Approved product rule: English UI still delivers English evidence draft + Chinese paper.
+    # Approved product rule: English UI still delivers English draft + Chinese paper.
     "en": "Simplified Chinese (简体中文)",
     "ru": "Russian (Русский)",
     "kk": "Kazakh (Қазақша)",
@@ -226,6 +226,14 @@ TEXTS: dict[str, dict[str, str]] = {
         "draft_stage_outline": "正在规划论文结构…",
         "draft_stage_citation": "正在建立论点与引用关系…",
         "draft_stage_writing": "正在准备正文写作…",
+        "draft_detail_progress": "论文进度：{progress}%",
+        "draft_detail_s2": "Semantic Scholar：{count} 篇有效文献",
+        "draft_detail_oa": "OpenAlex：{count} 篇有效文献",
+        "draft_detail_current": "当前阶段：{stage}",
+        "translation_section_running": "正在翻译【{name}】…",
+        "translation_section_qa": "正在审核【{name}】的翻译完整性与语义一致性…",
+        "translation_section_ready": "【{name}】翻译审核通过，正在显示译文…",
+        "translation_complete_label": "目标语言论文翻译完成。",
         "busy_short": "⏳ 有用户正在生成论文，预计25–35分钟后可用。",
         "tab_amj": "✨ 定量研究（AMJ 引擎）",
         "tab_asq": "📝 定性研究（ASQ 引擎）",
@@ -388,6 +396,14 @@ TEXTS: dict[str, dict[str, str]] = {
         "draft_stage_outline": "Planning the manuscript structure…",
         "draft_stage_citation": "Mapping claims to supporting sources…",
         "draft_stage_writing": "Preparing to draft the manuscript…",
+        "draft_detail_progress": "Paper progress: {progress}%",
+        "draft_detail_s2": "Semantic Scholar: {count} eligible papers",
+        "draft_detail_oa": "OpenAlex: {count} eligible papers",
+        "draft_detail_current": "Current stage: {stage}",
+        "translation_section_running": "Translating 【{name}】…",
+        "translation_section_qa": "Checking translation integrity and semantic equivalence for 【{name}】…",
+        "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.",
         "tab_amj": "✨ Quantitative Research (AMJ Engine)",
         "tab_asq": "📝 Qualitative Research (ASQ Engine)",
@@ -550,6 +566,14 @@ TEXTS: dict[str, dict[str, str]] = {
         "draft_stage_outline": "Планирование структуры статьи…",
         "draft_stage_citation": "Связывание тезисов с источниками…",
         "draft_stage_writing": "Подготовка к написанию текста…",
+        "draft_detail_progress": "Прогресс статьи: {progress}%",
+        "draft_detail_s2": "Semantic Scholar: {count} подходящих источников",
+        "draft_detail_oa": "OpenAlex: {count} подходящих источников",
+        "draft_detail_current": "Текущий этап: {stage}",
+        "translation_section_running": "Перевод раздела 【{name}】…",
+        "translation_section_qa": "Проверка полноты и смысловой эквивалентности перевода раздела 【{name}】…",
+        "translation_section_ready": "Перевод раздела 【{name}】 прошёл проверку и отображается…",
+        "translation_complete_label": "Перевод статьи на целевой язык завершён.",
         "busy_short": "⏳ Другой пользователь формирует статью. Повторите попытку примерно через 25–35 минут.",
         "tab_amj": "✨ Количественное исследование (движок AMJ)",
         "tab_asq": "📝 Качественное исследование (движок ASQ)",
@@ -712,6 +736,14 @@ TEXTS: dict[str, dict[str, str]] = {
         "draft_stage_outline": "Мақала құрылымы жоспарлануда…",
         "draft_stage_citation": "Тұжырымдар дереккөздермен сәйкестендірілуде…",
         "draft_stage_writing": "Негізгі мәтінді жазуға дайындалуда…",
+        "draft_detail_progress": "Мақала барысы: {progress}%",
+        "draft_detail_s2": "Semantic Scholar: {count} жарамды дереккөз",
+        "draft_detail_oa": "OpenAlex: {count} жарамды дереккөз",
+        "draft_detail_current": "Ағымдағы кезең: {stage}",
+        "translation_section_running": "【{name}】 бөлімі аударылуда…",
+        "translation_section_qa": "【{name}】 аудармасының толықтығы м��н мағыналық сәйкестігі тексерілуде…",
+        "translation_section_ready": "【{name}】 аудармасы тексеруден өтті және көрсетілуде…",
+        "translation_complete_label": "Мақаланың мақсатты тілдегі аудармасы аяқталды.",
         "busy_short": "⏳ Басқа пайдаланушы мақала дайындап жатыр. Шамамен 25–35 минуттан кейін қайталап көріңіз.",
         "tab_amj": "✨ Сандық зерттеу (AMJ қозғалтқышы)",
         "tab_asq": "📝 Сапалық зерттеу (ASQ қозғалтқышы)",

smartpaper_restore_bridge/frontend/index.html

@@ -25,8 +25,12 @@
   let lastMonitorNode = "";
   let lastMonitorCheckpointSeq = 0;
   let lastPreviewText = "";
-  let lastPreviewDisplayText = "";
+  let lastTargetPreviewText = "";
   let pageExitCancelCleanup = null;
+  const renderChannels = {
+    english:{ authoritative:"", displayed:"", queue:[], timer:null },
+    target:{ authoritative:"", displayed:"", queue:[], timer:null }
+  };
 
   const ACTION_PATHS = Object.freeze({
     task_start: "/edge/task/start",
@@ -221,24 +225,67 @@
     }
   }
 
-  function updateDraftPreparation(parentDocument, node, labels) {
+  function formatTemplate(template, values) {
+    let output = String(template || "");
+    for (const [key, value] of Object.entries(values || {})) {
+      output = output.split(`{${key}}`).join(String(value ?? ""));
+    }
+    return output;
+  }
+
+  function updateDraftPreparation(parentDocument, node, labels, task=null) {
     const target = parentDocument.getElementById("sp-live-manuscript-preview");
-    if (!target || lastPreviewText || target.querySelector("[data-sp-live-stream='1']")) return;
+    const channel = renderChannels.english;
+    if (!target || channel.authoritative || target.querySelector("[data-sp-live-stream='1']")) return;
     const map = labels && typeof labels === "object" ? labels : {};
-    const value = String(map[node] || map.writing || map.default || "").trim();
+    const progress = Math.max(0, Math.min(100, asCount(task && task.progress_pct)));
+    const s2 = asCount(task && task.s2_calls);
+    const oa = asCount(task && task.oa_calls);
+    const stage = String(map[node] || map.writing || map.default || node || "").trim();
+    const lines = [String(map.default || "").trim()];
+    if (stage) lines.push(formatTemplate(map.current || "{stage}", {stage}));
+    if (map.progress) lines.push(formatTemplate(map.progress, {progress}));
+    if (map.s2) lines.push(formatTemplate(map.s2, {count:s2}));
+    if (map.oa) lines.push(formatTemplate(map.oa, {count:oa}));
+    const value = lines.filter(Boolean).join("\n");
     if (!value) return;
     target.dataset.spPlaceholder = "1";
     target.textContent = value;
   }
 
-  function renderPreviewContent(parentDocument, target, text) {
-    // Keep one stable text node and append only the newly generated suffix.
-    target.dataset.spPlaceholder = "0";
-    // Rebuilding the whole manuscript DOM on every preview poll caused visible
-    // repaint/flicker and did not feel like ChatGPT-style streaming.
-    const displayText = String(text || "")
+  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;
+    const map = labels && typeof labels === "object" ? labels : {};
+    const stage = String(payload && payload.target_stage || "");
+    let value = String(map.waiting || "");
+    if (stage.startsWith("translating:")) {
+      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_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;
+    target.dataset.spPlaceholder = "1";
+    target.textContent = value;
+  }
+
+  function normalizePreviewDisplay(text) {
+    return String(text || "")
       .replace(/\r/g, "")
       .replace(/^#{1,3}\s+/gm, "");
+  }
+
+  function wordLikeUnits(value) {
+    const matches = String(value || "").match(/[\u4e00-\u9fff]{1,2}|\s+|[^\s\u4e00-\u9fff]+/g);
+    return matches || [];
+  }
+
+  function ensureStreamNode(parentDocument, target, channel) {
     let stream = target.querySelector("[data-sp-live-stream='1']");
     if (!stream) {
       stream = parentDocument.createElement("div");
@@ -247,49 +294,95 @@
       stream.style.overflowWrap = "anywhere";
       stream.style.lineHeight = "1.72";
       target.replaceChildren(stream);
-      lastPreviewDisplayText = "";
+      channel.displayed = "";
+    }
+    target.dataset.spPlaceholder = "0";
+    return stream;
+  }
+
+  function stopRenderTimer(channel) {
+    if (channel && channel.timer) window.clearTimeout(channel.timer);
+    if (channel) channel.timer = null;
+  }
+
+  function pumpRenderQueue(parentDocument, target, shell, channel) {
+    if (!target || !channel) return;
+    stopRenderTimer(channel);
+    if (!channel.queue.length) return;
+    const stream = ensureStreamNode(parentDocument, target, channel);
+    const backlog = channel.queue.length;
+    const perTick = backlog > 260 ? 5 : backlog > 140 ? 3 : backlog > 70 ? 2 : 1;
+    let chunk = "";
+    for (let i=0; i<perTick && channel.queue.length; i++) chunk += channel.queue.shift();
+    if (chunk) {
+      stream.appendChild(parentDocument.createTextNode(chunk));
+      channel.displayed += chunk;
+      if (shell && shell.dataset.spAutoFollow !== "0") shell.scrollTop = shell.scrollHeight;
     }
-    if (displayText.startsWith(lastPreviewDisplayText)) {
-      const delta = displayText.slice(lastPreviewDisplayText.length);
-      if (delta) stream.appendChild(parentDocument.createTextNode(delta));
+    channel.timer = window.setTimeout(() => pumpRenderQueue(parentDocument, target, shell, channel), 34);
+  }
+
+  function renderBufferedPreview(parentDocument, target, shell, text, channel) {
+    const displayText = normalizePreviewDisplay(text);
+    if (displayText === channel.authoritative) return;
+    const stream = ensureStreamNode(parentDocument, target, channel);
+    if (displayText.startsWith(channel.authoritative)) {
+      const delta = displayText.slice(channel.authoritative.length);
+      if (delta) channel.queue.push(...wordLikeUnits(delta));
     } else {
-      // Resume/recovery or a bounded server-side revision can replace prior
-      // prose. Update the existing node in place rather than replacing the DOM.
+      // A bounded server-side semantic/citation revision invalidates queued raw
+      // prose. Reconcile immediately to the audited authoritative text.
+      stopRenderTimer(channel);
+      channel.queue = [];
       stream.textContent = displayText;
+      channel.displayed = displayText;
     }
-    lastPreviewDisplayText = displayText;
+    channel.authoritative = displayText;
+    pumpRenderQueue(parentDocument, target, shell, channel);
   }
 
-  function previewShouldFollow(parentWindow, shell) {
+  function previewShouldFollow(parentWindow, shell, hasText) {
     if (!shell) return false;
-    if (!lastPreviewText) return true;
+    if (!hasText) return true;
     try {
       const rect = shell.getBoundingClientRect();
       const viewport = parentWindow.innerHeight || 0;
-      // Follow only while the preview is already on-screen or immediately
-      // below it. A user who scrolls upward is never pulled back down.
       return rect.top < viewport * 0.92 && rect.bottom > -80;
     } catch (_) { return false; }
   }
 
-  function updateManuscriptPreview(payload) {
+  function updateOnePreview(parentDocument, parentWindow, id, shellId, text, channel) {
+    const target = parentDocument.getElementById(id);
+    const shell = parentDocument.getElementById(shellId);
+    if (!target || !shell || !text) return;
+    if (shell.dataset.spScrollGuard !== "1") {
+      shell.dataset.spScrollGuard = "1";
+      shell.addEventListener("scroll", () => {
+        const distance = shell.scrollHeight - shell.scrollTop - shell.clientHeight;
+        shell.dataset.spAutoFollow = distance <= 48 ? "1" : "0";
+      }, {passive:true});
+    }
+    if (!channel.authoritative && previewShouldFollow(parentWindow, shell, false)) {
+      shell.dataset.spAutoFollow = "1";
+    }
+    renderBufferedPreview(parentDocument, target, shell, text, channel);
+  }
+
+  function updateManuscriptPreview(payload, watch=null) {
     let parentDocument, parentWindow;
     try { parentDocument = window.parent.document; parentWindow = window.parent; }
     catch (_) { return; }
-    const target = parentDocument.getElementById("sp-live-manuscript-preview");
-    const shell = parentDocument.getElementById("sp-live-manuscript-shell");
-    if (!target || !shell) return;
-    const text = String(payload && payload.text || "");
-    if (!text || text === lastPreviewText) return;
-    const shouldFollow = previewShouldFollow(parentWindow, shell);
-    renderPreviewContent(parentDocument, target, text);
-    lastPreviewText = text;
-    if (shouldFollow) {
-      // Keep the manuscript viewport pinned to the newest prose without moving
-      // the whole browser page. Whole-page scrolling is reserved for the single
-      // post-launch positioning action in app.py.
-      shell.scrollTop = shell.scrollHeight;
+    const englishText = String(payload && payload.text || "");
+    const targetText = String(payload && payload.target_text || "");
+    if (englishText && englishText !== lastPreviewText) {
+      updateOnePreview(parentDocument, parentWindow, "sp-live-manuscript-preview", "sp-live-manuscript-shell", englishText, renderChannels.english);
+      lastPreviewText = englishText;
+    }
+    if (targetText && targetText !== lastTargetPreviewText) {
+      updateOnePreview(parentDocument, parentWindow, "sp-live-translation-preview", "sp-live-translation-shell", targetText, renderChannels.target);
+      lastTargetPreviewText = targetText;
     }
+    if (!targetText) updateTargetPreparation(parentDocument, payload, watch && watch.targetStatusLabels);
   }
 
   async function fetchPreview(watch) {
@@ -303,7 +396,7 @@
       if (!payload || String(payload.task_id || "") !== watch.taskId) return;
       const epoch = asCount(payload.execution_epoch);
       if (watch.expectedEpoch > 0 && epoch !== watch.expectedEpoch) return;
-      updateManuscriptPreview(payload);
+      updateManuscriptPreview(payload, watch);
     } catch (_) {}
   }
 
@@ -326,7 +419,7 @@
     updateText(parentDocument, "sp-live-progress-text", `${progress}% — ${node}`);
     const fill = parentDocument.getElementById("sp-live-progress-fill");
     if (fill) fill.style.width = `${progress}%`;
-    updateDraftPreparation(parentDocument, node, watch && watch.draftStatusLabels);
+    updateDraftPreparation(parentDocument, node, watch && watch.draftStatusLabels, task);
 
     if (node && node !== lastMonitorNode) {
       appendTaskActivity(parentDocument, node, false);
@@ -410,6 +503,7 @@
     if (watch && watch.controller) {
       try { watch.controller.abort(); } catch (_) {}
     }
+    for (const channel of Object.values(renderChannels)) stopRenderTimer(channel);
   }
 
   function startTaskWatch(commandId, args) {
@@ -430,12 +524,16 @@
     }
 
     const draftStatusLabels = payload.draft_status_labels && typeof payload.draft_status_labels === "object" ? payload.draft_status_labels : {};
+    const targetStatusLabels = payload.target_status_labels && typeof payload.target_status_labels === "object" ? payload.target_status_labels : {};
     const bestEffortPageExitCancel = payload.best_effort_page_exit_cancel === true;
-    const watch = { commandId, taskId, apiOrigin, intervalMs, previewIntervalMs, previewUrl:resolvedPreviewUrl, expectedEpoch, draftStatusLabels, bestEffortPageExitCancel, timer:null, previewTimer:null, controller:null, stopped:false, lastCheckpointSeq:initialCheckpointSeq };
+    const watch = { commandId, taskId, apiOrigin, intervalMs, previewIntervalMs, previewUrl:resolvedPreviewUrl, expectedEpoch, draftStatusLabels, targetStatusLabels, bestEffortPageExitCancel, timer:null, previewTimer:null, controller:null, stopped:false, lastCheckpointSeq:initialCheckpointSeq };
     activeTaskWatch = watch;
     installPageExitCancel(watch);
     lastPreviewText = "";
-    lastPreviewDisplayText = "";
+    lastTargetPreviewText = "";
+    for (const channel of Object.values(renderChannels)) {
+      stopRenderTimer(channel); channel.authoritative = ""; channel.displayed = ""; channel.queue = [];
+    }
     lastMonitorCheckpointSeq = Math.max(lastMonitorCheckpointSeq, initialCheckpointSeq);
 
     const schedulePreview = () => {