R3.2.8.6-R1.3C-KK1-R5 Multilingual Async Translation Preview Alignment and Relation-Aware Fact Integrity

.streamlit/desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27

app.py

@@ -844,8 +844,8 @@ def _render_checkpoint_preview(task: dict, lang_code: str) -> None:
         st.markdown(tr(lang_code, "english_draft"))
         st.markdown(
             f"""
-            <div id='sp-live-manuscript-status' style='white-space:pre-wrap;font-size:0.88em;opacity:0.72;margin:0 0 8px 0;display:{english_status_display};'>{html.escape(english_status_initial)}</div>
             <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-status' style='white-space:pre-wrap;font-size:0.88em;opacity:0.72;margin:0 0 8px 0;display:{english_status_display};'>{html.escape(english_status_initial)}</div>
               <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>

core/desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27

core/generation_runner.py

@@ -13,8 +13,11 @@ import json
 import logging
 import math
 import os
+import queue
 import re
+import threading
 import time
+from concurrent.futures import Future
 from datetime import datetime, timezone, timedelta
 from pathlib import Path
 from typing import Callable, Any
@@ -34,7 +37,7 @@ ProgressCallback = Callable[..., None]
 MIN_FINAL_REFERENCES = 50
 LITERATURE_EVIDENCE_TARGET = 75
 CITATION_PLAN_TARGET = 70
-TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v2'
+TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v3'
 
 
 def _clean_trailing_references(text, keywords=("reference", "references", "reference list", "参考文献")):
@@ -56,6 +59,73 @@ def _canonical_request_hash(request_data: dict[str, Any]) -> str:
     return hashlib.sha256(encoded).hexdigest()
 
 
+class _OrderedTranslationWorker:
+    """One daemon worker owned by the headless Executor process.
+
+    It intentionally has no checkpoint authority.  Results are returned through
+    Future objects and are checkpointed only by GenerationRunner's main thread.
+    """
+
+    def __init__(self, handler):
+        self._handler = handler
+        self._queue = queue.Queue()
+        self._stop = threading.Event()
+        self._thread = threading.Thread(
+            target=self._run,
+            name="smartpaper-translation-worker",
+            daemon=True,
+        )
+        self._thread.start()
+
+    @property
+    def stop_event(self):
+        return self._stop
+
+    def submit(self, job: dict[str, Any]) -> Future:
+        future = Future()
+        self._queue.put((future, dict(job)))
+        return future
+
+    def _run(self):
+        while True:
+            item = self._queue.get()
+            try:
+                if item is None:
+                    return
+                future, job = item
+                if not future.set_running_or_notify_cancel():
+                    continue
+                try:
+                    result = self._handler(job)
+                except BaseException as error:
+                    future.set_exception(error)
+                else:
+                    future.set_result(result)
+            finally:
+                self._queue.task_done()
+
+    def close(self, *, wait: bool = False) -> None:
+        if self._stop.is_set():
+            if wait and self._thread.is_alive():
+                self._thread.join(timeout=2.0)
+            return
+        self._stop.set()
+        while True:
+            try:
+                item = self._queue.get_nowait()
+            except queue.Empty:
+                break
+            try:
+                if item is not None:
+                    future, _job = item
+                    future.cancel()
+            finally:
+                self._queue.task_done()
+        self._queue.put(None)
+        if wait and self._thread.is_alive():
+            self._thread.join(timeout=2.0)
+
+
 class GenerationRunner:
     def __init__(
         self,
@@ -80,6 +150,8 @@ class GenerationRunner:
         self.output_dir = self.task_dir / "outputs"
         self.output_dir.mkdir(parents=True, exist_ok=True)
         self.agent = None
+        self.translation_agent = None
+        self._preview_lock = threading.RLock()
         preview_token = str(self.request.get("preview_token") or "").strip()
         self.preview_token = preview_token if re.fullmatch(r"[A-Za-z0-9_-]{32,128}", preview_token) else ""
         self.preview_path = None
@@ -90,6 +162,14 @@ class GenerationRunner:
         self._preview_target_text = ""
         self._preview_target_stage = "translation_waiting"
         self._preview_target_complete = False
+        self._preview_target_english_commit_text = ""
+        self._translation_worker = None
+        self._translation_worker_sections = {}
+        self._translation_worker_glossary = {}
+        self._translation_worker_jobs = []
+        self._translation_worker_collected = 0
+        self._translation_worker_pending = set()
+        self._translation_worker_context = {}
         if self.preview_token:
             preview_dir = Path(__file__).resolve().parents[1] / "static" / "previews"
             preview_dir.mkdir(parents=True, exist_ok=True)
@@ -112,8 +192,9 @@ class GenerationRunner:
         metrics = getattr(agent, "source_metrics", {}) or {}
         s2_metric = metrics.get("s2", {}) if isinstance(metrics, dict) else {}
         oa_metric = metrics.get("oa", {}) if isinstance(metrics, dict) else {}
+        translator_calls = int(getattr(getattr(self, "translation_agent", None), "ds_calls", 0) or 0)
         return (
-            int(getattr(agent, "ds_calls", 0) or 0),
+            int(getattr(agent, "ds_calls", 0) or 0) + translator_calls,
             int(s2_metric.get("eligible_result_count", 0) or 0),
             int(oa_metric.get("eligible_result_count", 0) or 0),
         )
@@ -146,39 +227,50 @@ class GenerationRunner:
         return text.strip()
 
     def _write_preview_payload(self, *, force: bool = False) -> None:
-        if self.preview_path is None:
-            return
-        now = time.monotonic()
-        if not force and now - self._last_preview_write < 0.45:
-            return
-        payload = {
-            "task_id": str(self.request.get("task_id") or ""),
-            "request_hash": self.request_hash,
-            "execution_epoch": self.execution_epoch,
-            "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")
-        temporary.write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
-        os.replace(temporary, self.preview_path)
-        self._last_preview_write = now
+        with self._preview_lock:
+            if self.preview_path is None:
+                return
+            now = time.monotonic()
+            if not force and now - self._last_preview_write < 0.45:
+                return
+            payload = {
+                "task_id": str(self.request.get("task_id") or ""),
+                "request_hash": self.request_hash,
+                "execution_epoch": self.execution_epoch,
+                "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),
+                "target_english_commit_text": self._preview_visible_text(
+                    self._preview_target_english_commit_text
+                ),
+                "updated_at": datetime.now(timezone.utc).isoformat(),
+            }
+            temporary = self.preview_path.with_suffix(".json.tmp")
+            temporary.write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
+            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)
+        with self._preview_lock:
+            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,
+        english_commit_text: str | None = None,
+    ) -> None:
+        with self._preview_lock:
+            self._preview_target_text = str(text or "")
+            self._preview_target_stage = str(stage or "")
+            self._preview_target_complete = bool(complete)
+            if english_commit_text is not None:
+                self._preview_target_english_commit_text = str(english_commit_text or "")
+            self._write_preview_payload(force=force)
 
     def _stream_text(self, generator, *, preview_prefix: str | None = None, preview_stage: str = "") -> str:
         chunks = []
@@ -220,6 +312,14 @@ class GenerationRunner:
             return ''
         return f"# {title}\n" + match.group(1).strip()
 
+    @staticmethod
+    def _english_prefix_through_top_level(manuscript: str, title: str) -> str:
+        value = str(manuscript or '')
+        match = re.search(
+            rf'(?ms)^#\s+{re.escape(str(title))}\s*$\n.*?(?=^#\s+[^#].*?$|\Z)', value
+        )
+        return value[:match.end()].strip() if match else value.strip()
+
     @staticmethod
     def _extract_front_matter(manuscript: str, first_section_title: str) -> str:
         value = str(manuscript or '')
@@ -276,10 +376,110 @@ class GenerationRunner:
                 parts.append(str(record['translated_text']).strip())
         return '\n\n'.join(part for part in parts if part).strip()
 
+    def _start_translation_worker(
+        self, agent, *, translation_sections, translation_glossary,
+        adaptive_structure, target_lang,
+    ) -> None:
+        if self._translation_worker is not None:
+            return
+        self.translation_agent = agent
+        self._translation_worker_sections = dict(translation_sections or {})
+        self._translation_worker_glossary = dict(translation_glossary or {})
+        self._translation_worker_context = {
+            'adaptive_structure': list(adaptive_structure or []),
+            'target_lang': str(target_lang or ''),
+        }
+        self._translation_worker = _OrderedTranslationWorker(self._run_translation_job)
+
+    def _run_translation_job(self, job: dict[str, Any]) -> dict[str, Any]:
+        if self.translation_agent is None:
+            raise RuntimeError('translation_worker_agent_missing')
+        context = dict(self._translation_worker_context or {})
+        sections, glossary = self._translate_frozen_unit(
+            self.translation_agent,
+            unit_key=str(job.get('unit_key') or ''),
+            unit_name=str(job.get('unit_name') or ''),
+            source_text=str(job.get('source_text') or ''),
+            target_lang=str(context.get('target_lang') or ''),
+            translation_sections=self._translation_worker_sections,
+            translation_glossary=self._translation_worker_glossary,
+            adaptive_structure=context.get('adaptive_structure') or [],
+            include_front=True,
+            defer_failures=True,
+            english_commit_text=str(job.get('english_commit_text') or ''),
+        )
+        self._translation_worker_sections = dict(sections or {})
+        self._translation_worker_glossary = dict(glossary or {})
+        return {
+            'unit_key': str(job.get('unit_key') or ''),
+            'source_hash': str(job.get('source_hash') or ''),
+            'translation_sections': dict(self._translation_worker_sections),
+            'translation_glossary': dict(self._translation_worker_glossary),
+        }
+
+    def _enqueue_translation_unit(
+        self, agent, *, unit_key: str, unit_name: str, source_text: str,
+        translation_sections: dict, english_commit_text: str,
+    ) -> bool:
+        source = str(source_text or '').strip()
+        if not source or self._translation_worker is None:
+            return False
+        source_hash = self._text_hash(source)
+        fact_ledger_hash = self._translation_ledger_hash(agent, source)
+        existing = dict((translation_sections or {}).get(unit_key) or {})
+        if (
+            existing.get('qa_status') in {'passed', 'passed_with_warning'}
+            and existing.get('source_hash') == source_hash
+            and existing.get('target_lang') == str(self._translation_worker_context.get('target_lang') or '')
+            and existing.get('translation_contract_version') == TRANSLATION_CONTRACT_VERSION
+            and existing.get('fact_ledger_hash') == fact_ledger_hash
+            and existing.get('translated_text')
+        ):
+            return False
+        pending_key = (str(unit_key), source_hash, fact_ledger_hash)
+        if pending_key in self._translation_worker_pending:
+            return False
+        future = self._translation_worker.submit({
+            'unit_key': str(unit_key),
+            'unit_name': str(unit_name),
+            'source_text': source,
+            'source_hash': source_hash,
+            'fact_ledger_hash': fact_ledger_hash,
+            'english_commit_text': str(english_commit_text or ''),
+        })
+        self._translation_worker_pending.add(pending_key)
+        self._translation_worker_jobs.append({
+            'pending_key': pending_key,
+            'future': future,
+        })
+        return True
+
+    def _collect_translation_results(self, translation_sections, translation_glossary, *, block=False):
+        sections = dict(translation_sections or {})
+        glossary = dict(translation_glossary or {})
+        while self._translation_worker_collected < len(self._translation_worker_jobs):
+            item = self._translation_worker_jobs[self._translation_worker_collected]
+            future = item['future']
+            if not block and not future.done():
+                break
+            result = future.result()
+            sections = dict(result.get('translation_sections') or sections)
+            glossary = dict(result.get('translation_glossary') or glossary)
+            self._translation_worker_pending.discard(item['pending_key'])
+            self._translation_worker_collected += 1
+        return sections, glossary
+
+    def _shutdown_translation_worker(self, *, wait=False) -> None:
+        worker = self._translation_worker
+        if worker is None:
+            return
+        worker.close(wait=bool(wait))
+        self._translation_worker = None
+
     def _translate_frozen_unit(
         self, agent, *, unit_key: str, unit_name: str, source_text: str, target_lang: str,
         translation_sections: dict, translation_glossary: dict, adaptive_structure, include_front=False,
-        defer_failures=True,
+        defer_failures=True, english_commit_text: str | None = None,
     ):
         source = str(source_text or '').strip()
         if not source:
@@ -298,7 +498,10 @@ class GenerationRunner:
         ):
             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)
+        self._publish_target_preview(
+            partial, f'translating:{unit_name}', force=True, complete=False,
+            english_commit_text=english_commit_text,
+        )
         updated_sections = dict(translation_sections or {})
 
         def publish_translation_stage(stage):
@@ -307,7 +510,10 @@ class GenerationRunner:
                 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)
+            self._publish_target_preview(
+                partial, preview_stage, force=True, complete=False,
+                english_commit_text=english_commit_text,
+            )
 
         try:
             translate_method = agent.translate_frozen_section
@@ -349,7 +555,8 @@ class GenerationRunner:
                 unit_name, error_code, type(error).__name__,
             )
             self._publish_target_preview(
-                partial, f'translation_repair_pending:{unit_name}', force=True, complete=False
+                partial, f'translation_repair_pending:{unit_name}', force=True, complete=False,
+                english_commit_text=english_commit_text,
             )
             return updated_sections, translation_glossary
         updated_glossary = dict(result.get('glossary') or translation_glossary or {})
@@ -367,7 +574,10 @@ class GenerationRunner:
             '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)
+        self._publish_target_preview(
+            partial, f'translation_ready:{unit_name}', force=True, complete=False,
+            english_commit_text=english_commit_text,
+        )
         return updated_sections, updated_glossary
 
     @staticmethod
@@ -485,7 +695,7 @@ class GenerationRunner:
                 output.append(str(path))
         return output
 
-    def run(self) -> dict[str, Any]:
+    def _run_impl(self) -> dict[str, Any]:
         req = self.request
         mode = str(req.get("mode") or "").lower()
         if mode not in {"amj", "asq"}:
@@ -714,6 +924,26 @@ class GenerationRunner:
         if self._preview_target_text == '':
             self._preview_target_text = str(state.get('full_draft_translated') or '')
 
+        # Target-language work remains Executor-owned but no longer blocks the
+        # English writer.  A dedicated single translation agent/worker keeps
+        # glossary order deterministic and avoids sharing mutable writer state.
+        translation_agent = SSciPipelineAgent(ds_key, s2_key)
+        translation_agent.set_execution_progress_hook(lambda: self._progress_activity())
+        self._start_translation_worker(
+            translation_agent,
+            translation_sections=translation_sections,
+            translation_glossary=translation_glossary,
+            adaptive_structure=adaptive_structure,
+            target_lang=target_lang,
+        )
+        # Capture the worker stop Event itself.  `_shutdown_translation_worker()`
+        # clears `self._translation_worker`; a dynamic self lookup here would
+        # otherwise let an already-running target call miss task shutdown.
+        translation_stop_event = self._translation_worker.stop_event
+        translation_agent.set_cancel_checker(
+            lambda: self.cancel_checker() or translation_stop_event.is_set()
+        )
+
         # Backward-compatible resume path for a pre-R3.2.8.3 checkpoint that has
         # an outline but no Working Abstract yet. Generate it once, checkpoint it,
         # and reuse it thereafter; never regenerate an unchanged anchor on resume.
@@ -739,9 +969,9 @@ class GenerationRunner:
             self._publish_preview(full_draft_en, "working_front_matter", force=True)
             self._checkpoint("working_front_matter_ready", state, 15)
 
-        # Translate the QA-frozen Working front matter before Introduction. The
-        # same __front_matter__ record is hash-reused on resume and invalidated
-        # later when Final Abstract/Keywords replace the working front matter.
+        # Queue the QA-frozen Working front matter.  Translation is allowed to
+        # overlap later English work, but only frozen English units may enter
+        # this Executor-owned ordered worker.
         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:
@@ -752,23 +982,32 @@ class GenerationRunner:
                     # 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,
-                    translation_sections=translation_sections, translation_glossary=translation_glossary,
-                    adaptive_structure=adaptive_structure, include_front=True,
+                self._enqueue_translation_unit(
+                    translation_agent,
+                    unit_key='__front_matter__', unit_name='Working Front Matter',
+                    source_text=working_front_source,
+                    translation_sections=translation_sections,
+                    english_commit_text=working_front_source,
                 )
-                working_target = self._assemble_partial_translation(
-                    translation_sections, adaptive_structure, include_front=True
-                )
-                state.update({
-                    "full_draft_en": full_draft_en,
-                    "full_draft_translated": working_target,
-                    "translation_sections": translation_sections,
-                    "translation_glossary": translation_glossary,
-                    "agent_state": agent.export_state(),
-                })
-                self._checkpoint("working_front_matter_translated", state, 16)
+
+        # Resume/idempotency: completed English top-level sections whose current
+        # source-hash translation is absent/stale are queued exactly once.
+        for section_key, section_title in self._unique_top_level_sections(adaptive_structure):
+            if not self._section_is_complete(adaptive_structure, completed_sections, section_key):
+                continue
+            frozen_section = self._extract_top_level_section(full_draft_en, section_title)
+            self._enqueue_translation_unit(
+                translation_agent,
+                unit_key=section_key,
+                unit_name=section_title,
+                source_text=frozen_section,
+                translation_sections=translation_sections,
+                english_commit_text=self._english_prefix_through_top_level(full_draft_en, section_title),
+            )
+
+        translation_sections, translation_glossary = self._collect_translation_results(
+            translation_sections, translation_glossary, block=False
+        )
         if not citation_plan:
             self._progress(15, "citation_planning")
             citation_plan = agent.build_claim_evidence_plan(
@@ -995,12 +1234,17 @@ Output only final academic prose. Do not report the word count."""
             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=True,
+                self._enqueue_translation_unit(
+                    translation_agent,
+                    unit_key=section_key, unit_name=sec_title, source_text=frozen_section,
+                    translation_sections=translation_sections,
+                    english_commit_text=full_draft_en,
                 )
+            # Collect only already-finished target jobs.  This call never waits,
+            # so English Section N+1 can start while target Section N runs.
+            translation_sections, translation_glossary = self._collect_translation_results(
+                translation_sections, translation_glossary, block=False
+            )
             partial_translation = self._assemble_partial_translation(translation_sections, adaptive_structure, include_front=True)
             state.update(
                 {
@@ -1080,12 +1324,16 @@ Output only final academic prose. Do not report the word count."""
             section_order_for_front = self._unique_top_level_sections(adaptive_structure)
             if section_order_for_front:
                 final_front_source = self._extract_front_matter(body_only, section_order_for_front[0][1])
-                translation_sections, translation_glossary = self._translate_frozen_unit(
-                    agent, unit_key='__front_matter__', unit_name='Final Front Matter',
-                    source_text=final_front_source, target_lang=target_lang,
-                    translation_sections=translation_sections, translation_glossary=translation_glossary,
-                    adaptive_structure=adaptive_structure, include_front=True,
+                self._enqueue_translation_unit(
+                    translation_agent,
+                    unit_key='__front_matter__', unit_name='Final Front Matter',
+                    source_text=final_front_source,
+                    translation_sections=translation_sections,
+                    english_commit_text=full_draft_en,
                 )
+            translation_sections, translation_glossary = self._collect_translation_results(
+                translation_sections, translation_glossary, block=False
+            )
             partial_target = self._assemble_partial_translation(
                 translation_sections, adaptive_structure, include_front=True
             )
@@ -1114,6 +1362,13 @@ Output only final academic prose. Do not report the word count."""
         translation_glossary = dict(state.get('translation_glossary') or translation_glossary or {})
         if not state.get("translation_complete") or not full_draft_translated:
             self._progress(94, "translation")
+            # English is fully frozen.  Wait for all previously queued section
+            # translations before the strict final gate; checkpoint ownership
+            # remains on this main execution thread.
+            translation_sections, translation_glossary = self._collect_translation_results(
+                translation_sections, translation_glossary, block=True
+            )
+            self._shutdown_translation_worker(wait=True)
             body_only, reference_tail = agent.validate_reference_tail(
                 full_draft_en, minimum_references=MIN_FINAL_REFERENCES
             )
@@ -1126,10 +1381,11 @@ Output only final academic prose. Do not report the word count."""
                 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,
+                    translation_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, defer_failures=False,
+                    english_commit_text=full_draft_en,
                 )
                 partial = self._assemble_partial_translation(
                     translation_sections, adaptive_structure, include_front=True
@@ -1207,6 +1463,12 @@ Output only final academic prose. Do not report the word count."""
         self._checkpoint("package_validated", state, 99)
         return {"output_filename": output_filename, "output_path": str(final)}
 
+    def run(self) -> dict[str, Any]:
+        try:
+            return self._run_impl()
+        finally:
+            self._shutdown_translation_worker(wait=False)
+
     def _progress_activity(self) -> None:
         # Activity remains Executor-owned. We also snapshot actual request
         # counters so the next Executor heartbeat can persist live UI metrics.

core/pipeline_agent.py

@@ -61,7 +61,7 @@ class CitationAuditError(DeepSeekRequestError):
 
 
 class SSciPipelineAgent:
-    TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v2'
+    TRANSLATION_CONTRACT_VERSION = 'hierarchical-multilingual-v3'
 
     def __init__(self, ds_key, s2_key=""):
         self.ds_key = str(ds_key or "").strip()
@@ -3621,7 +3621,13 @@ Output only the repaired section."""
     @classmethod
     def translation_error_code(cls, error):
         message = str(error or '')
-        if 'unowned factual content' in message or 'protected placeholder mismatch' in message or 'fact moved across claim boundary' in message or 'fact order changed' in message:
+        if (
+            'unowned factual content' in message
+            or 'protected placeholder mismatch' in message
+            or 'fact moved across claim boundary' in message
+            or 'fact order changed' in message
+            or 'order-sensitive relation changed' in message
+        ):
             return 'FACT_INTEGRITY'
         if 'claim marker mismatch' in message or 'marker mismatch' in message or 'heading-tree mismatch' in message:
             return 'STRUCTURE_INTEGRITY'
@@ -4184,6 +4190,55 @@ Output only the repaired section."""
             unowned['doi_url'] = urls
         return {key: values for key, values in unowned.items() if values}
 
+    @staticmethod
+    def _translation_order_sensitive_placeholder_groups(protected_source):
+        """Return only high-confidence placeholder relations whose order is semantic.
+
+        Ordinary facts inside one claim are intentionally absent from this list:
+        target-language grammar may reorder them.  We retain order only for
+        explicit directional/range/comparison surfaces where reversing the two
+        protected endpoints would change the source relation.
+        """
+        text = str(protected_source or '')
+        p = r'(\[\[SP-T\d{6}\]\])'
+        patterns = (
+            rf'(?i:\bfrom\s+{p}\s+(?:up\s+)?to\s+{p})',
+            rf'{p}\s*(?:->|→|⇒|⟶)\s*{p}',
+            rf'{p}\s*(?:<|>|≤|≥)\s*{p}',
+            rf'{p}\s*(?:–|—)\s*{p}',
+        )
+        groups = []
+        for pattern in patterns:
+            for match in re.finditer(pattern, text):
+                pair = tuple(group for group in match.groups() if group)
+                if len(pair) == 2 and pair not in groups:
+                    groups.append(pair)
+        return groups
+
+    @classmethod
+    def _translation_order_sensitive_relations_for_claim(cls, source_claim, claim_placeholders):
+        """Map local source relation placeholders back to the claim's global IDs."""
+        protected_local, local_mapping = cls._protect_translation_tokens(source_claim, claim_id='C000001')
+        local_ids = list(local_mapping)
+        global_ids = list(claim_placeholders or [])
+        if len(local_ids) != len(global_ids):
+            return []
+        id_map = dict(zip(local_ids, global_ids))
+        relations = []
+        for group in cls._translation_order_sensitive_placeholder_groups(protected_local):
+            mapped = tuple(id_map.get(item, '') for item in group)
+            if all(mapped) and mapped not in relations:
+                relations.append(mapped)
+        return relations
+
+    @staticmethod
+    def _is_translation_relation_order_error(error):
+        message = str(error or '')
+        return (
+            message.startswith('Translation order-sensitive relation changed')
+            or message.startswith('Translation fact order changed')
+        )
+
     @classmethod
     def _validate_translation_skeleton(cls, value, mapping, block_id='', claim_sources=None):
         text = str(value or '')
@@ -4215,19 +4270,20 @@ Output only the repaired section."""
                     f'Translation fact moved across claim boundary in {block_id}: {manifest.get("fact_id") or placeholder}.'
                 )
 
-        ordered_types = {'NUMBER','QUANTITY','STAT','HYPOTHESIS','DOI_URL','FORMULA','QUOTE_ID'}
         for claim_id in claim_order:
             target_claim = str(target_claims.get(claim_id) or '')
-            expected_order = [
+            claim_placeholders = [
                 placeholder for placeholder, raw in (mapping or {}).items()
                 if str((raw if isinstance(raw, dict) else {}).get('claim_id') or 'C000001') == claim_id
-                and str((raw if isinstance(raw, dict) else {}).get('type') or '') in ordered_types
             ]
-            if len(expected_order) > 1:
-                actual_order = sorted(expected_order, key=lambda placeholder: target_claim.find(placeholder))
-                if actual_order != expected_order:
+            source_claim = str(private_claims.get(claim_id) or '')
+            for relation in cls._translation_order_sensitive_relations_for_claim(
+                source_claim, claim_placeholders
+            ):
+                actual_order = sorted(relation, key=lambda placeholder: target_claim.find(placeholder))
+                if tuple(actual_order) != tuple(relation):
                     raise DeepSeekRequestError(
-                        f'Translation fact order changed within owner claim in {block_id}: claim={claim_id}.'
+                        f'Translation order-sensitive relation changed within owner claim in {block_id}: claim={claim_id}.'
                     )
 
             unowned = cls._translation_unowned_objects(target_claim)
@@ -4731,6 +4787,34 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 raise failed[first_id]
             source_by_id = {block_id: source for block_id, source in batch}
             for block_id, error in failed.items():
+                if self._is_translation_relation_order_error(error):
+                    claim_match = re.search(r'claim=(C\d{6})', str(error))
+                    source_claims = dict(claim_sources_by_block.get(block_id) or {})
+                    claim_id = claim_match.group(1) if claim_match else ''
+                    if claim_id and claim_id in source_claims:
+                        logging.warning(
+                            'Translation relation-local recovery: block=SP-P%s claim=%s error=%s',
+                            block_id, claim_id, self._safe_source_error(error),
+                        )
+                        claim_order = list(source_claims)
+                        _order, segments = self._parse_translation_claim_segments(
+                            parsed[block_id], claim_order
+                        )
+                        segments[claim_id] = self._translate_single_claim_with_recovery(
+                            block_id, claim_id, source_claims[claim_id],
+                            system_prompt, target_lang, ['FACT_RELATION_ORDER'],
+                        )
+                        repaired = self._compose_translation_claim_segments(claim_order, segments)
+                        translated_with_claims = self._restore_translation_tokens(
+                            repaired, protected_maps.get(block_id, {}), f'SP-P{block_id}', target_lang,
+                            claim_sources=source_claims, keep_claim_markers=True,
+                        )
+                        clean_translation = self._strip_translation_claim_markers(translated_with_claims)
+                        self._validate_translation_block_protected(
+                            block_id, source_by_id[block_id], clean_translation, target_lang
+                        )
+                        restored[block_id] = translated_with_claims
+                        continue
                 logging.warning(
                     'Translation protected block recovery: block=SP-P%s error=%s; strict isolated retry.',
                     block_id, self._safe_source_error(error),
@@ -4974,6 +5058,8 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 if (
                     message.startswith('Translation claim-local QA failed')
                     or message.startswith('Translation introduced unowned factual content')
+                    or message.startswith('Translation order-sensitive relation changed')
+                    or message.startswith('Translation fact order changed')
                     or message.startswith('Translation alignment')
                     or message.startswith('Translation changed ')
                     or message.startswith('Translation protected ')

desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27

smartpaper_restore_bridge/desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27

smartpaper_restore_bridge/frontend/desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27

smartpaper_restore_bridge/frontend/index.html

@@ -510,6 +510,28 @@
     pumpRenderQueue(parentDocument, target, shell, channel);
   }
 
+  function ensureEnglishCommitVisible(parentDocument, commitText) {
+    const commit = normalizePreviewDisplay(commitText);
+    if (!commit) return;
+    const channel = renderChannels.english;
+    const target = parentDocument.getElementById("sp-live-manuscript-preview");
+    const shell = parentDocument.getElementById("sp-live-manuscript-shell");
+    if (!target || !shell) return;
+    if (channel.displayed.startsWith(commit)) return;
+    // The server only publishes this barrier for a fully frozen English source
+    // unit.  Never synthesize text that is not already authoritative.
+    if (!channel.authoritative.startsWith(commit)) return;
+    const stream = ensureStreamNode(parentDocument, target, channel);
+    stopRenderTimer(channel);
+    stream.textContent = commit;
+    channel.displayed = commit;
+    channel.queue = [];
+    const remaining = channel.authoritative.slice(commit.length);
+    if (remaining) channel.queue.push(...wordLikeUnits(remaining));
+    if (shell.dataset.spAutoFollow !== "0") shell.scrollTop = shell.scrollHeight;
+    pumpRenderQueue(parentDocument, target, shell, channel);
+  }
+
   function previewShouldFollow(parentWindow, shell, hasText) {
     if (!shell) return false;
     if (!hasText) return true;
@@ -543,6 +565,7 @@
     catch (_) { return; }
     const englishText = String(payload && payload.text || "");
     const targetText = String(payload && payload.target_text || "");
+    const targetEnglishCommitText = String(payload && payload.target_english_commit_text || "");
     if (englishText && englishText !== lastPreviewText) {
       updateOnePreview(parentDocument, parentWindow, "sp-live-manuscript-preview", "sp-live-manuscript-shell", englishText, renderChannels.english);
       const englishStatus = parentDocument.getElementById("sp-live-manuscript-status");
@@ -553,6 +576,7 @@
       lastPreviewText = englishText;
     }
     if (targetText && targetText !== lastTargetPreviewText) {
+      ensureEnglishCommitVisible(parentDocument, targetEnglishCommitText);
       updateOnePreview(parentDocument, parentWindow, "sp-live-translation-preview", "sp-live-translation-shell", targetText, renderChannels.target);
       lastTargetPreviewText = targetText;
     }

static/desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27

static/previews/desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27

utils/desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27