Step 4A-6-C-R3.2.5 Generation UX Reference Metrics & Translation Integrity Fix

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+core/__pycache__/pipeline_agent.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text

app.py

@@ -595,7 +595,10 @@ def _render_monitor_box(task: dict, lang_code: str) -> None:
     <div class='log-box' id='sp-live-monitor'>
         <div><b>{tr(lang_code, 'monitor_pipeline')}:</b> <span id='sp-live-status'>{status}</span></div>
         <div><b>{tr(lang_code, 'monitor_node')}:</b> <span id='sp-live-node'>{node}</span></div>
-        <div><b>{tr(lang_code, 'monitor_log')}:</b> checkpoint <span id='sp-live-checkpoint-seq'>{checkpoint_seq}</span> · <span id='sp-live-checkpoint-stage'>{checkpoint_stage}</span></div><hr>
+        <div><b>{tr(lang_code, 'monitor_log')}:</b> checkpoint <span id='sp-live-checkpoint-seq'>{checkpoint_seq}</span> · <span id='sp-live-checkpoint-stage'>{checkpoint_stage}</span></div>
+        <div id='sp-live-activity-feed' style='margin:8px 0 10px 0;max-height:150px;overflow:auto;line-height:1.55;'>
+            <div>• {node}</div>
+        </div><hr>
         <div><b>{tr(lang_code, 'monitor_compute')}:</b></div>
         <div style='display:flex;gap:8px;'>
             <span style='background: #fef3c7;padding:4px 8px;border-radius:4px;color:black;'>🧠 DeepSeek: <b id='sp-live-ds'>{ds_calls}</b></span>
@@ -606,38 +609,85 @@ def _render_monitor_box(task: dict, lang_code: str) -> None:
     """, unsafe_allow_html=True)
 
 
-def _watch_task_status_live(task: dict) -> None:
-    """Start browser-only read polling for active task UI state.
+def _watch_task_status_live(task: dict) -> dict | None:
+    """Start browser-only read polling for live UI state.
 
-    The component updates monitor DOM locally. It sends a Streamlit value only
-    when a terminal task state is observed, causing exactly one boundary rerun.
-    It never sends heartbeat, claim, finish, or cancellation commands.
+    DOM updates remain read-only and never participate in task liveness. A
+    Streamlit boundary is emitted only when a durable checkpoint advances or a
+    terminal/resumable state appears. Checkpoint boundaries let the UI reveal
+    newly completed manuscript text without periodic full-page reruns.
     """
     task_id = str(task.get("task_id") or "").strip()
     status = str(task.get("status") or "")
     if not task_id or status not in LIVE_TASK_STATUSES:
-        return
+        return None
     api_origin = str(st.session_state.get("sp_auth_api_origin") or "").strip()
     if not api_origin:
         logging.warning("[SP_UI] live_watch_missing_api_origin task_id=%s", task_id)
-        return
+        return None
     try:
         watch_result = edge_bridge(
             action="task_watch",
             command_id=f"watch:{task_id}",
             api_origin=api_origin,
-            payload={"task_id": task_id, "poll_interval_ms": 2500},
+            payload={
+                "task_id": task_id,
+                "poll_interval_ms": 2000,
+                "initial_checkpoint_seq": int(task.get("checkpoint_seq") or 0),
+            },
             key=f"sp_task_watch_{_safe_key(task_id)}",
         )
         boundary_task = watch_result.get("task") if isinstance(watch_result, dict) and watch_result.get("boundary") else None
         if isinstance(boundary_task, dict) and str(boundary_task.get("task_id") or "") == task_id:
-            # Consume the watcher's authoritative boundary snapshot directly so
-            # the ordinary 5-second task-status cache cannot delay terminal UI.
             st.session_state["sp_generation_task"] = dict(boundary_task)
             st.session_state["sp_last_ui_task_status"] = str(boundary_task.get("status") or "")
-            st.rerun()
+            if str(watch_result.get("boundary_type") or "") == "checkpoint":
+                st.session_state["sp_scroll_to_generation_action"] = True
+            return dict(boundary_task)
     except Exception as exc:
         logging.warning("[SP_UI] live_watch_error task_id=%s error=%s", task_id, type(exc).__name__)
+    return None
+
+
+def _load_confirmed_checkpoint(task: dict) -> dict | None:
+    """Load only the checkpoint sequence already acknowledged by Worker/D1."""
+    task_id = str(task.get("task_id") or "").strip()
+    checkpoint_seq = int(task.get("checkpoint_seq") or 0)
+    if not task_id or checkpoint_seq <= 0:
+        return None
+    task_dir = _task_dir(task_id)
+    request_path = task_dir / "request.json"
+    if not request_path.is_file():
+        return None
+    try:
+        request_payload = json.loads(request_path.read_text(encoding="utf-8"))
+        expected_hash = str(request_payload.get("request_hash") or "")
+        candidates = sorted((task_dir / "checkpoints").glob(f"checkpoint_{checkpoint_seq:05d}_*.json"))
+        if not candidates:
+            return None
+        payload = json.loads(candidates[-1].read_text(encoding="utf-8"))
+        if not isinstance(payload, dict):
+            return None
+        if expected_hash and str(payload.get("request_hash") or "") != expected_hash:
+            return None
+        if int(payload.get("checkpoint_seq") or 0) != checkpoint_seq:
+            return None
+        return payload
+    except Exception as exc:
+        logging.warning("[SP_UI] checkpoint_preview_error task_id=%s error=%s", task_id, type(exc).__name__)
+        return None
+
+
+def _render_checkpoint_preview(task: dict, lang_code: str) -> None:
+    """Show the durable English draft accumulated through the latest checkpoint."""
+    checkpoint = _load_confirmed_checkpoint(task)
+    if not checkpoint:
+        return
+    draft = str(checkpoint.get("full_draft_en") or "").strip()
+    if not draft:
+        return
+    st.markdown(tr(lang_code, "english_draft"))
+    st.markdown(draft)
 
 
 def _render_task_status_once(lang_code: str) -> None:
@@ -645,7 +695,6 @@ def _render_task_status_once(lang_code: str) -> None:
     task_id = str(task.get("task_id") or "").strip()
     if not task_id:
         return
-    previous_status = str(st.session_state.get("sp_last_ui_task_status") or str(task.get("status") or ""))
     status = str(task.get("status") or "")
     if status in ACTIVE_TASK_STATUSES:
         try:
@@ -655,10 +704,19 @@ def _render_task_status_once(lang_code: str) -> None:
             status = str(task.get("status") or "")
         except Exception as exc:
             logging.warning("[SP_UI] status_poll_error task_id=%s error=%s", task_id, type(exc).__name__)
+
+    if status in LIVE_TASK_STATUSES:
+        boundary_task = _watch_task_status_live(task)
+        if isinstance(boundary_task, dict):
+            task = boundary_task
+            status = str(task.get("status") or "")
+
     st.session_state["sp_last_ui_task_status"] = status
     _render_monitor_box(task, lang_code)
-    if status in LIVE_TASK_STATUSES:
-        _watch_task_status_live(task)
+    _render_checkpoint_preview(task, lang_code)
+
+    if status == "resumable":
+        st.warning(tr(lang_code, "checkpoint_warning"))
     elif status == "completed":
         output_path = _task_output_path(task)
         if output_path and output_path.is_file():
@@ -673,19 +731,10 @@ def _render_task_status_once(lang_code: str) -> None:
         if detail:
             st.warning(detail)
 
-    # Only terminal/resume boundaries may rerun the whole Streamlit app. Live
-    # progress is DOM-only and therefore cannot reintroduce periodic flicker.
-    if previous_status and status != previous_status and status in {"resumable", "completed", "failed", "cancelled"}:
-        st.rerun()
-
 
-def _scroll_to_generation_action_once() -> None:
-    """One-time post-launch/resume scroll to the paper-generation action area."""
-    if not bool(st.session_state.get("sp_scroll_to_generation_action")):
-        return
-    st.session_state["sp_scroll_to_generation_action"] = False
-    mode = str(st.session_state.get("run_mode") or "amj").lower()
-    target_id = "sp-generation-action-asq" if mode == "asq" else "sp-generation-action-amj"
+def _inject_generation_action_scroll(mode: str) -> None:
+    """Scroll immediately to the active generation action without a server wait."""
+    target_id = "sp-generation-action-asq" if str(mode or "").lower() == "asq" else "sp-generation-action-amj"
     components.html(
         f"""
         <script>
@@ -700,7 +749,7 @@ def _scroll_to_generation_action_once() -> None:
             done = true;
             target.scrollIntoView({{behavior:'auto', block:'center'}});
           }};
-          [60, 160, 320, 650, 1100].forEach((delay) => window.parent.setTimeout(locate, delay));
+          [0, 40, 100, 220, 450, 800].forEach((delay) => window.parent.setTimeout(locate, delay));
         }})();
         </script>
         """,
@@ -709,6 +758,14 @@ def _scroll_to_generation_action_once() -> None:
     )
 
 
+def _scroll_to_generation_action_once() -> None:
+    """One-time post-launch/resume/checkpoint scroll to the generation action."""
+    if not bool(st.session_state.get("sp_scroll_to_generation_action")):
+        return
+    st.session_state["sp_scroll_to_generation_action"] = False
+    _inject_generation_action_scroll(str(st.session_state.get("run_mode") or "amj"))
+
+
 def render_workspace_controls(user):
     top_toolbar = st.container()
     with top_toolbar:
@@ -772,7 +829,9 @@ def render_workspace_controls(user):
         if st.button(tr(lang_code, "start_amj"), disabled=active, key="btn_amj"):
             st.session_state["run_mode"] = "amj"
             st.session_state["sp_pending_launch"] = {"mode": "amj", "idempotency_key": _new_generation_idempotency_key()}
-            st.rerun()
+            st.session_state["sp_scroll_to_generation_action"] = True
+            st.info(tr(lang_code, "pipeline_start"))
+            _inject_generation_action_scroll("amj")
 
     with tab_asq:
         st.markdown(tr(lang_code, "asq_config"))
@@ -788,7 +847,9 @@ def render_workspace_controls(user):
         if st.button(tr(lang_code, "start_asq"), disabled=active, key="btn_asq"):
             st.session_state["run_mode"] = "asq"
             st.session_state["sp_pending_launch"] = {"mode": "asq", "idempotency_key": _new_generation_idempotency_key()}
-            st.rerun()
+            st.session_state["sp_scroll_to_generation_action"] = True
+            st.info(tr(lang_code, "pipeline_start"))
+            _inject_generation_action_scroll("asq")
 
     inject_file_uploader_i18n(lang_code)
 

core/__pycache__/pipeline_agent.cpython-313.pyc

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:576dd3905d2ec79e768e26b13790a53de0568073c16ef7e03c9dda6fcc26d5f7
-size 158942
+oid sha256:f86e44350d73c3bb8869b0963cf609be5356563dbd2713018d8695e5af70aed9
+size 169392

core/generation_runner.py

@@ -29,6 +29,9 @@ from utils.file_parser import extract_text_from_files
 
 ProgressCallback = Callable[..., None]
 
+MIN_FINAL_REFERENCES = 50
+CITATION_COVERAGE_TARGET = 60
+
 
 def _clean_trailing_references(text, keywords=("reference", "references", "reference list", "参考文献")):
     lines = str(text or "").split("\n")
@@ -75,7 +78,7 @@ class GenerationRunner:
         self.agent = None
 
     def _compute_request_counts(self) -> tuple[int, int, int]:
-        """Return one consistent UI metric: actual outbound request attempts."""
+        """Return UI metrics: DeepSeek requests and eligible literature results."""
         agent = self.agent
         if agent is None:
             return 0, 0, 0
@@ -84,8 +87,8 @@ class GenerationRunner:
         oa_metric = metrics.get("oa", {}) if isinstance(metrics, dict) else {}
         return (
             int(getattr(agent, "ds_calls", 0) or 0),
-            int(s2_metric.get("request_count", 0) or 0),
-            int(oa_metric.get("request_count", 0) or 0),
+            int(s2_metric.get("eligible_result_count", 0) or 0),
+            int(oa_metric.get("eligible_result_count", 0) or 0),
         )
 
     def _progress(self, pct: int, node: str, *, checkpoint_seq=None, checkpoint_stage=None) -> None:
@@ -231,11 +234,13 @@ class GenerationRunner:
             refs_text = agent.fetch_references_parallel(
                 topic,
                 keywords,
-                min_required=50,
+                min_required=MIN_FINAL_REFERENCES,
                 progress_callback=lambda: self._progress(9, "S2 + OpenAlex"),
             )
-            if len(agent.citation_map) < 50:
-                raise RuntimeError(f"Insufficient eligible references: {len(agent.citation_map)}/50")
+            if len(agent.citation_map) < MIN_FINAL_REFERENCES:
+                raise RuntimeError(
+                    f"Insufficient eligible references: {len(agent.citation_map)}/{MIN_FINAL_REFERENCES}"
+                )
             if user_lit_context:
                 core_refs = agent.parse_user_core_literature(user_lit_context)
                 if core_refs:
@@ -315,6 +320,7 @@ class GenerationRunner:
         context_tail = str(state.get("context_tail") or "")
         accumulated_deviation = float(state.get("accumulated_deviation") or 0.0)
         all_cite_keys = list(agent.citation_map.keys())
+        coverage_cite_keys = all_cite_keys[: min(len(all_cite_keys), CITATION_COVERAGE_TARGET)]
         valid_chunks = [
             item for item in adaptive_structure
             if not any(word in item["section"].lower() for word in ["abstract", "keyword", "appendix"])
@@ -322,11 +328,11 @@ class GenerationRunner:
         allocation_map: dict[str, list[str]] = {}
         current_cite_idx = 0
         for idx, item in enumerate(valid_chunks):
-            count = max(1, math.ceil(len(all_cite_keys) / max(1, len(valid_chunks))))
+            count = max(1, math.ceil(len(coverage_cite_keys) / max(1, len(valid_chunks))))
             allocation_map[item["display_name"]] = (
-                all_cite_keys[current_cite_idx:]
+                coverage_cite_keys[current_cite_idx:]
                 if idx == len(valid_chunks) - 1
-                else all_cite_keys[current_cite_idx:current_cite_idx + count]
+                else coverage_cite_keys[current_cite_idx:current_cite_idx + count]
             )
             current_cite_idx += count
 
@@ -347,12 +353,15 @@ class GenerationRunner:
                 word in sec_title.lower()
                 for word in ["abstract", "keyword", "conclusion", "references", "appendix"]
             )
-            assigned_tags = ", ".join(allocation_map.get(display_name, [])) or "the single most relevant source"
+            assigned_tag_list = list(allocation_map.get(display_name, []))
+            assigned_tags = ", ".join(assigned_tag_list) or "the single most relevant source"
             citation_rule = (
                 "NO IN-TEXT CITATIONS ALLOWED IN THIS SECTION."
                 if is_quarantined
                 else "Use claim-specific citation. Each sentence may contain at most one source tag. "
-                     f"Candidate tags: {assigned_tags}. <AVAILABLE_CITATIONS>{refs_text}</AVAILABLE_CITATIONS>"
+                     "Use the assigned candidate tags across distinct supported claims whenever their evidence directly applies; "
+                     "never stack sources or cite a source that does not support the sentence. "
+                     f"Assigned candidate tags: {assigned_tags}. <AVAILABLE_CITATIONS>{refs_text}</AVAILABLE_CITATIONS>"
             )
             memory_context = agent._build_memory_context(sec_title, 2500)
             memory_block = f"\n<GLOBAL_MEMORY>\n{memory_context}\n</GLOBAL_MEMORY>\n" if memory_context else ""
@@ -431,6 +440,10 @@ Output only final academic prose. Do not report the word count."""
                 for tag, quote in quote_dict.items():
                     en_raw = en_raw.replace(tag, f'"{quote}"')
             en_raw = agent.polish_academic_section(en_raw, display_name, abstract=False)
+            if not is_quarantined and assigned_tag_list:
+                en_raw = agent.reinforce_claim_specific_citation_coverage(
+                    en_raw, assigned_tag_list, section_name=display_name
+                )
             prefix = ""
             if sec.get("section_first"):
                 prefix += f"# {sec_title}\n\n"
@@ -477,8 +490,11 @@ Output only final academic prose. Do not report the word count."""
                 if ref and ref not in seen_refs:
                     references.append(f"- {ref}")
                     seen_refs.add(ref)
-            if not references:
-                raise RuntimeError("No cited references remained after citation validation.")
+            if len(references) < MIN_FINAL_REFERENCES:
+                raise RuntimeError(
+                    "Insufficient final cited references after semantic validation: "
+                    f"{len(references)}/{MIN_FINAL_REFERENCES}."
+                )
             full_draft_en = full_draft_en.rstrip() + "\n\n# References\n" + "\n\n".join(references)
             self._validate_target_length(full_draft_en, target_words)
             state.update(

core/pipeline_agent.py

@@ -2456,6 +2456,81 @@ Return exactly:
         recovered = re.sub(r'[ \t]+\n', '\n', recovered)
         return re.sub(r'\n{3,}', '\n\n', recovered).strip()
 
+    def reinforce_claim_specific_citation_coverage(self, text, assigned_tags, section_name=''):
+        """Add assigned tags only to citation-free claims with lexical evidence overlap.
+
+        This pass is deterministic and makes no additional model call. It never
+        changes claim wording: a source tag is inserted only when at least two
+        substantive terms overlap between an existing sentence and the source
+        evidence/reference. The ordinary semantic citation audit remains the
+        final authority and may still reject an unsupported placement.
+        """
+        value = str(text or '').strip()
+        valid_tags = [tag for tag in dict.fromkeys(assigned_tags or []) if tag in self.citation_map]
+        if not value or not valid_tags:
+            return value
+        existing = {f"[{tag.upper()}]" for tag in re.findall(r'CITE-\d+', value, flags=re.I)}
+        missing = [tag for tag in valid_tags if tag not in existing]
+        if not missing:
+            return value
+
+        spans = self._sentence_spans(value)
+        candidates = []
+        for index, (start, end, sentence) in enumerate(spans):
+            stripped = str(sentence or '').strip()
+            if not stripped or stripped.startswith('#') or re.search(r'CITE-\d+', stripped, flags=re.I):
+                continue
+            terms = self._citation_terms(stripped)
+            if len(terms) < 4:
+                continue
+            candidates.append((index, start, end, sentence, terms))
+
+        assignments = []
+        occupied = set()
+        for tag in missing:
+            metadata = self.citation_map.get(tag) or {}
+            evidence = ' '.join([str(metadata.get('ref') or ''), str(metadata.get('evidence') or '')])
+            evidence_terms = self._citation_terms(evidence)
+            if not evidence_terms:
+                continue
+            scored = []
+            for item in candidates:
+                index, start, end, sentence, sentence_terms = item
+                if index in occupied:
+                    continue
+                overlap = len(sentence_terms & evidence_terms)
+                coverage = overlap / max(1, len(sentence_terms))
+                scored.append((overlap, coverage, -index, item))
+            if not scored:
+                continue
+            scored.sort(reverse=True, key=lambda row: (row[0], row[1], row[2]))
+            overlap, coverage, _, item = scored[0]
+            if overlap < 2 or coverage < 0.08:
+                continue
+            index, start, end, sentence, _ = item
+            occupied.add(index)
+            assignments.append((start, end, sentence, tag))
+
+        if not assignments:
+            return value
+        revised = value
+        for start, end, sentence, tag in sorted(assignments, key=lambda row: row[0], reverse=True):
+            raw = str(sentence)
+            trailing_match = re.search(r'(\s*)$', raw)
+            trailing = trailing_match.group(1) if trailing_match else ''
+            core = raw[:-len(trailing)] if trailing else raw
+            punctuation = ''
+            if core and core[-1] in '.!?。！？':
+                punctuation = core[-1]
+                core = core[:-1]
+            replacement = f"{core.rstrip()} {tag}{punctuation}{trailing}"
+            revised = revised[:start] + replacement + revised[end:]
+        logging.info(
+            'Citation coverage placement: section=%s assigned=%s inserted=%s',
+            section_name, len(valid_tags), len(assignments),
+        )
+        return revised
+
     def audit_and_resolve_citations(self, text, section_name='', quarantine=False):
         value = str(text or '')
         if quarantine:
@@ -2675,8 +2750,9 @@ Return exactly:
 
     @staticmethod
     def _translation_acronym_tokens(value):
+        """Protect exact uppercase abbreviations, including plural suffixes."""
         without_doi = re.sub(r'https?://\S+|doi:\s*\S+', ' ', str(value or ''), flags=re.I)
-        return Counter(re.findall(r'\b[A-Z][A-Z0-9-]{1,11}\b', without_doi))
+        return Counter(re.findall(r'\b[A-Z][A-Z0-9-]{1,11}(?:s|es)?\b', without_doi))
 
     @staticmethod
     def _translation_citation_tokens(value):
@@ -2790,8 +2866,15 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
             raise DeepSeekRequestError(f'Translation changed citations in {block_id}.')
         if self._translation_hypothesis_tokens(source) != self._translation_hypothesis_tokens(translated):
             raise DeepSeekRequestError(f'Translation changed hypothesis labels in {block_id}.')
-        if self._translation_acronym_tokens(source) != self._translation_acronym_tokens(translated):
-            raise DeepSeekRequestError(f'Translation changed variable abbreviations in {block_id}.')
+        source_acronyms = self._translation_acronym_tokens(source)
+        target_acronyms = self._translation_acronym_tokens(translated)
+        if source_acronyms != target_acronyms:
+            missing = list((source_acronyms - target_acronyms).elements())
+            added = list((target_acronyms - source_acronyms).elements())
+            raise DeepSeekRequestError(
+                f'Translation changed variable abbreviations in {block_id}: '
+                f'missing={missing}, added={added}.'
+            )
 
         source_compact = re.sub(r'\s+', '', str(source or ''))
         target_compact = re.sub(r'\s+', '', str(translated or ''))
@@ -2814,6 +2897,68 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
             if not is_chinese and not re.search(r'[А-Яа-яЁёӘәҒғҚқҢңӨөҰұҮүҺһІі]', translated):
                 raise DeepSeekRequestError(f'Translation block {block_id} contains no Cyrillic target-language text.')
 
+    def _retry_translation_block_for_abbreviations(self, block_id, source, system_prompt, target_lang):
+        protected_counter = self._translation_acronym_tokens(source)
+        protected = list(protected_counter.elements())
+        strict_prompt = (
+            system_prompt
+            + '\nCRITICAL ABBREVIATION PRESERVATION: Preserve every token in this JSON list '
+              'exactly, including capitalization and plural suffix, and preserve its exact count. '
+              'Do not normalize plural abbreviations (for example, LLMs must not become LLM).\n'
+            + json.dumps(protected, ensure_ascii=False)
+        )
+        marked_source = f'[[SP-P{block_id}]]\n{source}'
+        result = self.call_deepseek(
+            strict_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,
+        )
+        result = self._remove_ai_meta_traces(result)
+        try:
+            translated = self._parse_marked_translation(result, [block_id])[block_id]
+        except DeepSeekRequestError as error:
+            if not str(error).startswith('Translation marker mismatch:'):
+                raise
+            unexpected_markers = re.findall(
+                r'(?m)^\[\[SP-P(\d{6})\]\]\s*$',
+                str(result or ''),
+            )
+            if unexpected_markers:
+                raise DeepSeekRequestError(
+                    'Abbreviation retry returned an unexpected marker: '
+                    f'expected={block_id}, got={unexpected_markers}.'
+                ) from error
+            translated = str(result or '').strip()
+            if not translated:
+                raise DeepSeekRequestError(
+                    f'Abbreviation retry returned empty text for SP-P{block_id}.'
+                ) from error
+        self._validate_translation_block(source, translated, f'SP-P{block_id}', target_lang)
+        logging.info(
+            'Translation abbreviation recovery accepted block: SP-P%s protected=%s',
+            block_id, protected,
+        )
+        return translated
+
+    def _validate_translation_block_with_abbreviation_recovery(self, block_id, source, translated, system_prompt, target_lang):
+        try:
+            self._validate_translation_block(source, translated, f'SP-P{block_id}', target_lang)
+            return translated
+        except DeepSeekRequestError as error:
+            if not str(error).startswith('Translation changed variable abbreviations in SP-P'):
+                raise
+            logging.warning(
+                'Translation abbreviation recovery: block=SP-P%s error=%s',
+                block_id, str(error),
+            )
+            return self._retry_translation_block_for_abbreviations(
+                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.
 
@@ -2875,8 +3020,8 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
                 raise DeepSeekRequestError(
                     f'Single-block translation recovery returned empty text for SP-P{block_id}.'
                 ) from error
-            self._validate_translation_block(
-                source, translated, f'SP-P{block_id}', target_lang
+            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',
@@ -2885,10 +3030,10 @@ Translate headings and terminology naturally. Preserve standard variable abbrevi
             return {block_id: translated}
 
         for block_id, source in batch:
-            translated = parsed[block_id]
-            self._validate_translation_block(
-                source, translated, f'SP-P{block_id}', target_lang
+            translated = self._validate_translation_block_with_abbreviation_recovery(
+                block_id, source, parsed[block_id], system_prompt, target_lang
             )
+            parsed[block_id] = translated
         return parsed
 
     def translate_locked_manuscript(self, manuscript, target_lang):

smartpaper_restore_bridge/frontend/index.html

@@ -22,6 +22,8 @@
   const TERMINAL_TASK_STATUSES = new Set(["completed", "failed", "cancelled"]);
   let lastResponseSignature = "";
   let activeTaskWatch = null;
+  let lastMonitorNode = "";
+  let lastMonitorCheckpointSeq = 0;
 
   const ACTION_PATHS = Object.freeze({
     task_start: "/edge/task/start",
@@ -184,6 +186,17 @@
     if (element) element.textContent = String(value ?? "");
   }
 
+  function appendTaskActivity(parentDocument, text, complete=false) {
+    const feed = parentDocument.getElementById("sp-live-activity-feed");
+    const value = String(text || "").trim();
+    if (!feed || !value) return;
+    const row = parentDocument.createElement("div");
+    row.textContent = `${complete ? "✓" : "•"} ${value}`;
+    feed.appendChild(row);
+    while (feed.children.length > 12) feed.removeChild(feed.firstElementChild);
+    feed.scrollTop = feed.scrollHeight;
+  }
+
   function updateTaskMonitor(task) {
     let parentDocument;
     try { parentDocument = window.parent.document; }
@@ -191,16 +204,27 @@
     const status = String(task && task.status || "");
     const node = String(task && task.current_node || status || "");
     const progress = Math.max(0, Math.min(100, asCount(task && task.progress_pct)));
+    const checkpointSeq = asCount(task && task.checkpoint_seq);
+    const checkpointStage = String(task && task.checkpoint_stage || "");
     updateText(parentDocument, "sp-live-status", status);
     updateText(parentDocument, "sp-live-node", node);
-    updateText(parentDocument, "sp-live-checkpoint-seq", asCount(task && task.checkpoint_seq));
-    updateText(parentDocument, "sp-live-checkpoint-stage", String(task && task.checkpoint_stage || ""));
+    updateText(parentDocument, "sp-live-checkpoint-seq", checkpointSeq);
+    updateText(parentDocument, "sp-live-checkpoint-stage", checkpointStage);
     updateText(parentDocument, "sp-live-ds", asCount(task && task.ds_calls));
     updateText(parentDocument, "sp-live-s2", asCount(task && task.s2_calls));
     updateText(parentDocument, "sp-live-oa", asCount(task && task.oa_calls));
     updateText(parentDocument, "sp-live-progress-text", `${progress}% — ${node}`);
     const fill = parentDocument.getElementById("sp-live-progress-fill");
     if (fill) fill.style.width = `${progress}%`;
+
+    if (node && node !== lastMonitorNode) {
+      appendTaskActivity(parentDocument, node, false);
+      lastMonitorNode = node;
+    }
+    if (checkpointSeq > lastMonitorCheckpointSeq) {
+      appendTaskActivity(parentDocument, checkpointStage || node, true);
+      lastMonitorCheckpointSeq = checkpointSeq;
+    }
   }
 
   function stopTaskWatch() {
@@ -217,15 +241,17 @@
     const apiOrigin = normalizeOrigin(args.api_origin || "");
     const payload = args.payload && typeof args.payload === "object" ? args.payload : {};
     const taskId = typeof payload.task_id === "string" ? payload.task_id.trim() : "";
-    const requestedInterval = Number(payload.poll_interval_ms || 2500);
-    const intervalMs = Math.max(1500, Math.min(10000, Number.isFinite(requestedInterval) ? requestedInterval : 2500));
+    const requestedInterval = Number(payload.poll_interval_ms || 2000);
+    const intervalMs = Math.max(1500, Math.min(10000, Number.isFinite(requestedInterval) ? requestedInterval : 2000));
+    const initialCheckpointSeq = asCount(payload.initial_checkpoint_seq);
     if (!apiOrigin || !taskId) {
       sendValue({ ok:false, action:"task_watch", command_id:commandId, error:"invalid_task_watch" });
       return;
     }
 
-    const watch = { commandId, taskId, apiOrigin, intervalMs, timer:null, controller:null, stopped:false };
+    const watch = { commandId, taskId, apiOrigin, intervalMs, timer:null, controller:null, stopped:false, lastCheckpointSeq:initialCheckpointSeq };
     activeTaskWatch = watch;
+    lastMonitorCheckpointSeq = Math.max(lastMonitorCheckpointSeq, initialCheckpointSeq);
 
     const schedule = () => {
       if (activeTaskWatch !== watch || watch.stopped) return;
@@ -240,6 +266,7 @@
       if (result.ok && task) {
         updateTaskMonitor(task);
         const status = String(task.status || "");
+        const checkpointSeq = asCount(task.checkpoint_seq);
         if (TERMINAL_TASK_STATUSES.has(status) || status === "resumable") {
           watch.stopped = true;
           activeTaskWatch = null;
@@ -247,7 +274,21 @@
             action:"task_watch",
             command_id:commandId,
             terminal:TERMINAL_TASK_STATUSES.has(status),
-            boundary:true
+            boundary:true,
+            boundary_type:"terminal"
+          }));
+          return;
+        }
+        if (checkpointSeq > watch.lastCheckpointSeq) {
+          watch.lastCheckpointSeq = checkpointSeq;
+          watch.stopped = true;
+          activeTaskWatch = null;
+          sendValue(Object.assign({}, result, {
+            action:"task_watch",
+            command_id:commandId,
+            terminal:false,
+            boundary:true,
+            boundary_type:"checkpoint"
           }));
           return;
         }