R14-TQ2-PQ1-R3-R1 Evidence-Limited Completion + Four-Language Detailed Progress

app.py

@@ -688,10 +688,58 @@ os.makedirs(_user_workspace, exist_ok=True)
 ACTIVE_TASK_STATUSES = {"created", "running", "resumable", "cancelling"}
 LIVE_TASK_STATUSES = {"created", "running", "cancelling"}
 
+def _localized_task_status(lang_code: str, status: str) -> str:
+    key = f"task_status_{str(status or '').strip().lower()}"
+    value = tr(lang_code, key)
+    return value if value != key else tr(lang_code, "draft_stage_processing")
+
+def _localized_monitor_node(lang_code: str, node: str) -> str:
+    """Translate stable executor progress codes without exposing engineering identifiers."""
+    value = str(node or "").strip()
+    exact = {
+        "inputs_and_evidence": "draft_stage_inputs",
+        "S2 + OpenAlex": "draft_stage_search",
+        "literature_synthesis": "draft_stage_synthesis",
+        "research_logic": "draft_stage_research_logic",
+        "working_front_matter": "draft_stage_working_front",
+        "outline_planning": "draft_stage_outline",
+        "citation_planning": "draft_stage_citation",
+        "english_validation": "draft_stage_english_validation",
+        "final_front_matter": "draft_stage_final_front",
+        "translation": "draft_stage_translation",
+        "translation_complete": "translation_complete_label",
+        "packaging": "draft_stage_packaging",
+        "package_validation": "draft_stage_package_validation",
+        "package_validated": "draft_stage_package_validated",
+    }
+    if value in exact:
+        return tr(lang_code, exact[value])
+    for prefix, key in (
+        ("writing:", "draft_stage_writing_unit"),
+        ("citation_audit:", "draft_stage_citation_audit_unit"),
+        ("citation_recovery:", "draft_stage_citation_recovery_unit"),
+        ("writing_complete:", "draft_stage_writing_complete_unit"),
+        ("translation_final_gate:", "draft_stage_translation"),
+    ):
+        if value.startswith(prefix):
+            parts = value[len(prefix):].split(":")
+            if key == "draft_stage_translation":
+                return tr(lang_code, key)
+            if len(parts) >= 2:
+                return tr(lang_code, key, current=parts[0], total=parts[1])
+            return tr(lang_code, "draft_stage_processing")
+    if value.startswith("translation_"):
+        return tr(lang_code, "draft_stage_translation")
+    if value.startswith("section_"):
+        return tr(lang_code, "draft_stage_writing")
+    return tr(lang_code, "draft_stage_processing")
+
 def _render_monitor_box(task: dict, lang_code: str) -> None:
     """Render the approved monitor location with DOM targets for live updates."""
     status = str(task.get("status") or "")
     node = str(task.get("current_node") or status or "")
+    status_label = _localized_task_status(lang_code, status)
+    node_label = _localized_monitor_node(lang_code, node)
     progress = max(0, min(100, int(task.get("progress_pct") or 0)))
     checkpoint_seq = int(task.get("checkpoint_seq") or 0)
     checkpoint_stage = str(task.get("checkpoint_stage") or "")
@@ -703,7 +751,7 @@ def _render_monitor_box(task: dict, lang_code: str) -> None:
     if status in ACTIVE_TASK_STATUSES:
         progress_markup = f"""
         <div id='sp-live-progress-wrap' style='margin:0 0 12px 0;'>
-          <div id='sp-live-progress-text' style='margin-bottom:7px;'>{progress}% — {node}</div>
+          <div id='sp-live-progress-text' style='margin-bottom:7px;'>{progress}% — {html.escape(node_label)}</div>
           <div style='width:100%;height:10px;background:rgba(128,128,128,.24);border-radius:999px;overflow:hidden;'>
             <div id='sp-live-progress-fill' style='width:{progress}%;height:100%;background:currentColor;border-radius:999px;transition:width .35s ease;'></div>
           </div>
@@ -713,11 +761,12 @@ def _render_monitor_box(task: dict, lang_code: str) -> None:
     st.markdown(f"""
     {progress_markup}
     <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>
+        <div><b>{tr(lang_code, 'monitor_pipeline')}:</b> <span id='sp-live-status'>{html.escape(status_label)}</span></div>
+        <div><b>{tr(lang_code, 'monitor_node')}:</b> <span id='sp-live-node'>{html.escape(node_label)}</span></div>
+        <div><b>{tr(lang_code, 'monitor_log')}:</b> <span id='sp-live-checkpoint-stage'>{html.escape(tr(lang_code, 'monitor_checkpoint_saved', seq=checkpoint_seq))}</span><span id='sp-live-checkpoint-seq' style='display:none'>{checkpoint_seq}</span></div>
+        <div id='sp-live-evidence-warning' style='display:none;margin:8px 0;padding:8px 10px;border-radius:6px;background:rgba(245,158,11,.13);'></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>• {html.escape(node_label)}</div>
         </div><hr>
         <div><b>{tr(lang_code, 'monitor_compute')}:</b></div>
         <div style='display:flex;gap:8px;'>
@@ -767,6 +816,27 @@ 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"),
+                    "working_front_matter": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_working_front"),
+                    "writing_unit": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_writing_unit"),
+                    "citation_audit_unit": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_citation_audit_unit"),
+                    "citation_recovery_unit": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_citation_recovery_unit"),
+                    "writing_complete_unit": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_writing_complete_unit"),
+                    "english_validation": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_english_validation"),
+                    "final_front_matter": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_final_front"),
+                    "translation": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_translation"),
+                    "packaging": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_packaging"),
+                    "package_validation": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_package_validation"),
+                    "package_validated": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_package_validated"),
+                    "processing": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_processing"),
+                    "checkpoint_saved": tr(str(st.session_state.get("sp_lang_code") or "zh"), "monitor_checkpoint_saved"),
+                    "status_created": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_created"),
+                    "status_running": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_running"),
+                    "status_resumable": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_resumable"),
+                    "status_cancelling": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_cancelling"),
+                    "status_completed": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_completed"),
+                    "status_failed": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_failed"),
+                    "status_cancelled": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_cancelled"),
+                    "evidence_limited": tr(str(st.session_state.get("sp_lang_code") or "zh"), "evidence_limited_running"),
                     "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"),
@@ -998,6 +1068,8 @@ def _render_task_status_once(lang_code: str) -> None:
                 f"<div id='sp-completed-download-anchor' data-sp-task-id='{html.escape(task_id, quote=True)}'></div>",
                 unsafe_allow_html=True,
             )
+            if str(task.get("safe_error_code") or "") == "W_EVIDENCE_COVERAGE_LIMITED":
+                st.warning(tr(lang_code, "evidence_limited_completed"))
             st.success(tr(lang_code, "success"))
             st.download_button(label=tr(lang_code, "download"), data=output_path.read_bytes(), file_name=output_path.name, mime="application/zip")
             _scroll_to_completed_download_once(task_id)

core/generation_runner.py

@@ -243,6 +243,11 @@ class GenerationRunner:
         self._translation_progress_inflight = set()
         self._translation_progress_total = 0
         self._qualitative_quote_sources = {}
+        # R14-TQ2-PQ1-R3-R1: evidence coverage is a quality signal, not a
+        # manuscript-completeness authority. It is persisted in checkpoints and
+        # exposed to the browser only as a stable status code.
+        self._preview_evidence_status = "normal"
+        self._evidence_coverage_events = []
         if self.preview_token:
             preview_dir = Path(__file__).resolve().parents[1] / "static" / "previews"
             preview_dir.mkdir(parents=True, exist_ok=True)
@@ -284,9 +289,12 @@ class GenerationRunner:
             oa_calls=oa_calls,
         )
 
-    def _checkpoint(self, stage: str, state: dict[str, Any], pct: int) -> None:
+    def _checkpoint(self, stage: str, state: dict[str, Any], pct: int, *, display_node: str | None = None) -> None:
         seq, normalized_stage = self.checkpoints.save(stage, state)
-        self._progress(pct, normalized_stage, checkpoint_seq=seq, checkpoint_stage=normalized_stage)
+        self._progress(
+            pct, display_node or normalized_stage,
+            checkpoint_seq=seq, checkpoint_stage=normalized_stage,
+        )
 
     @staticmethod
     def _preview_visible_text(value: str) -> str:
@@ -803,6 +811,7 @@ class GenerationRunner:
                     self._preview_target_english_commit_text
                 ),
                 "target_progress": self._translation_progress_snapshot(),
+                "evidence_status": str(self._preview_evidence_status or "normal")[:40],
                 "updated_at": datetime.now(timezone.utc).isoformat(),
             }
             temporary = self.preview_path.with_suffix(".json.tmp")
@@ -1661,6 +1670,78 @@ class GenerationRunner:
             "keywords and try again; unrelated references will not be used to satisfy a quota."
         )
 
+    @staticmethod
+    def _evidence_warning_detail() -> str:
+        return (
+            "Some externally oriented claims have limited direct high-relevance literature coverage. "
+            "This may reflect a newer or specialized topic, dispersed literature, search/keyword limits, "
+            "or limited prior evidence; this status does not determine the novelty, importance, or overall "
+            "research value of the topic. Unrelated sources were not used to satisfy a citation count."
+        )
+
+    def _record_evidence_coverage_event(self, state, shortfalls, *, phase: str, preview_status: str) -> None:
+        """Persist a neutral evidence-coverage signal without stopping generation.
+
+        The event records only deterministic coverage counts. It never infers why
+        literature is sparse and never evaluates topic value. Duplicate events
+        are collapsed across resume/replay.
+        """
+        rows = []
+        for name, actual, required in shortfalls or []:
+            rows.append({
+                "section": str(name or ""),
+                "actual": max(0, int(actual or 0)),
+                "required": max(0, int(required or 0)),
+            })
+        if not rows:
+            return
+        signature = (str(phase or ""), tuple((r["section"], r["actual"], r["required"]) for r in rows))
+        existing = list(state.get("evidence_coverage_events") or self._evidence_coverage_events or [])
+        seen = {
+            (str(item.get("phase") or ""), tuple(
+                (str(row.get("section") or ""), int(row.get("actual") or 0), int(row.get("required") or 0))
+                for row in (item.get("shortfalls") or []) if isinstance(row, dict)
+            ))
+            for item in existing if isinstance(item, dict)
+        }
+        if signature not in seen:
+            existing.append({
+                "phase": str(phase or ""),
+                "shortfalls": rows,
+                "observed_at": datetime.now(timezone.utc).isoformat(),
+            })
+        self._evidence_coverage_events = existing
+        state["evidence_coverage_events"] = existing
+        state["evidence_risk_detected"] = True
+        self._preview_evidence_status = str(preview_status or "limited_risk")
+        self._write_preview_payload(force=True)
+        logging.warning(
+            "Evidence coverage warning | phase=%s | shortfalls=%s | nonfatal=true",
+            phase, rows,
+        )
+
+    @staticmethod
+    def _evidence_coverage_summary(*, status, early_risk, final_reference_count, minimums, validated_by_top_level, claims_by_top_level, events):
+        sections = []
+        for section_id, planned_minimum in dict(minimums or {}).items():
+            validated = len(set((validated_by_top_level or {}).get(section_id) or []))
+            external_claims = max(0, int((claims_by_top_level or {}).get(section_id, 0) or 0))
+            required = min(int(planned_minimum), external_claims) if external_claims else 0
+            sections.append({
+                "section": str(section_id),
+                "validated_direct_citations": validated,
+                "evidence_requirement": required,
+                "external_claims": external_claims,
+                "planning_minimum": int(planned_minimum),
+            })
+        return {
+            "status": str(status or "adequate"),
+            "early_risk_detected": bool(early_risk),
+            "final_reference_count": max(0, int(final_reference_count or 0)),
+            "sections": sections,
+            "events": list(events or []),
+        }
+
     def _resolve_paths(self, items) -> list[str]:
         output = []
         for item in items or []:
@@ -1708,6 +1789,11 @@ class GenerationRunner:
         else:
             state = self.checkpoints.load_confirmed() or {}
         quality_diagnostics = list(state.get("quality_diagnostics") or [])
+        self._evidence_coverage_events = list(state.get("evidence_coverage_events") or [])
+        if str(state.get("evidence_status") or "") == "limited":
+            self._preview_evidence_status = "limited"
+        elif bool(state.get("evidence_risk_detected")):
+            self._preview_evidence_status = "limited_risk"
         if state:
             self._preview_english_text = str(state.get('full_draft_en') or '')
             self._preview_target_text = str(state.get('full_draft_translated') or '')
@@ -1879,6 +1965,22 @@ class GenerationRunner:
                 adaptive_structure, topic, synthesis_result, mode=mode,
                 target_unique=max(1, citation_plan_target),
             )
+            # Early neutral risk signal: evaluate the high-relevance plan before
+            # reserve filling/JIT can make a raw candidate count look healthier
+            # than the claim-specific plan actually is. This is advisory only.
+            initial_top_level_counts = self._top_level_unique_tag_counts(
+                citation_plan, citation_unit_section_map
+            )
+            initial_shortfalls = [
+                (section_id, int(initial_top_level_counts.get(section_id, 0)), required)
+                for section_id, required in citation_top_level_minimums.items()
+                if int(initial_top_level_counts.get(section_id, 0)) < int(required)
+            ]
+            if initial_shortfalls:
+                self._record_evidence_coverage_event(
+                    state, initial_shortfalls, phase="initial_claim_specific_plan",
+                    preview_status="limited_risk",
+                )
 
             # Fill unit-specific reserve gaps before expensive drafting. Existing
             # retrieved evidence is preferred; bounded contextual JIT is last resort.
@@ -1947,9 +2049,21 @@ class GenerationRunner:
                 if int(top_level_counts.get(section_id, 0)) < int(required)
             ]
             if shortfalls:
-                raise self._literature_insufficient_error(shortfalls)
+                self._record_evidence_coverage_event(
+                    state, shortfalls, phase="bounded_retrieval_complete",
+                    preview_status="limited_risk",
+                )
+                logging.warning(
+                    "Top-level citation feasibility limited: minimum_total=%s reserve_target=%s planned_unique=%s sections=%s nonfatal=true",
+                    sum(citation_top_level_minimums.values()), citation_plan_target, len(planned_tags), len(citation_top_level_minimums),
+                )
+            else:
+                logging.info(
+                    "Top-level citation feasibility passed: minimum_total=%s reserve_target=%s planned_unique=%s sections=%s",
+                    sum(citation_top_level_minimums.values()), citation_plan_target, len(planned_tags), len(citation_top_level_minimums),
+                )
             logging.info(
-                "Top-level citation feasibility passed: minimum_total=%s reserve_target=%s planned_unique=%s sections=%s",
+                "Top-level citation planning complete: minimum_total=%s reserve_target=%s planned_unique=%s sections=%s",
                 sum(citation_top_level_minimums.values()), citation_plan_target, len(planned_tags), len(citation_top_level_minimums),
             )
             canonical_concept_ledger = self._build_canonical_concept_ledger(
@@ -2145,7 +2259,10 @@ class GenerationRunner:
                 if int(top_level_counts.get(section_id, 0)) < int(required)
             ]
             if shortfalls:
-                raise self._literature_insufficient_error(shortfalls)
+                self._record_evidence_coverage_event(
+                    state, shortfalls, phase="resume_claim_specific_plan",
+                    preview_status="limited_risk",
+                )
             state["citation_plan"] = citation_plan
             state["citation_minimums"] = citation_minimums
             state["citation_reserve_targets"] = citation_reserve_targets
@@ -2343,7 +2460,7 @@ Output only final academic prose. Do not report the word count."""
 
             current_index = len(completed_sections) + 1
             pct = min(88, 15 + int((current_index / max(1, total_steps)) * 72))
-            self._progress(pct, display_name)
+            self._progress(pct, f"writing:{current_index}:{total_steps}")
             prefix = ""
             if sec.get("section_first"):
                 prefix += f"# {sec_title}\n\n"
@@ -2384,6 +2501,7 @@ Output only final academic prose. Do not report the word count."""
                 en_raw = agent.reinforce_claim_specific_citation_coverage(
                     en_raw, assigned_tag_list, section_name=display_name
                 )
+            self._progress(pct, f"citation_audit:{current_index}:{total_steps}")
             used_before = set(agent.used_citations)
             en_resolved = agent.audit_and_resolve_citations(
                 prefix + en_raw, section_name=display_name, quarantine=is_quarantined
@@ -2424,7 +2542,9 @@ Output only final academic prose. Do not report the word count."""
                     # an already-written claim. It is never authorized to create a
                     # supplemental paragraph from a source merely to satisfy citation
                     # survival. If no existing claim can be validated, leave prose
-                    # unchanged and let the literature-sufficiency Gate fail closed.
+                    # unchanged. Evidence coverage may later be reported as limited,
+                    # while citation correctness itself remains fail-closed.
+                    self._progress(pct, f"citation_recovery:{current_index}:{total_steps}")
                     recovered = agent.recover_citations_on_existing_claims(
                         en_resolved,
                         recovery_items[:needed],
@@ -2508,7 +2628,10 @@ Output only final academic prose. Do not report the word count."""
                     "data_metadata": data_metadata,
                 }
             )
-            self._checkpoint(f"section_{len(completed_sections):03d}", state, pct)
+            self._checkpoint(
+                f"section_{len(completed_sections):03d}", state, pct,
+                display_node=f"writing_complete:{len(completed_sections)}:{total_steps}",
+            )
 
         if not state.get("english_finalized"):
             self._progress(91, "english_validation")
@@ -2554,13 +2677,36 @@ Output only final academic prose. Do not report the word count."""
                 required = min(int(planned_minimum), external_claims) if external_claims else 0
                 if len(validated_tags) < required:
                     final_shortfalls.append((section_id, len(validated_tags), required))
-            if final_shortfalls:
-                raise self._literature_insufficient_error(final_shortfalls)
             final_reference_count = len(references)
-            logging.info(
-                "Top-level claim-evidence final Gate passed: validated_references=%s sections=%s",
-                final_reference_count, len(citation_top_level_minimums),
-            )
+            if final_shortfalls:
+                self._record_evidence_coverage_event(
+                    state, final_shortfalls, phase="final_claim_evidence_gate",
+                    preview_status="limited",
+                )
+                evidence_status = "limited"
+                logging.warning(
+                    "Top-level claim-evidence final Gate completed with evidence warning: validated_references=%s sections=%s shortfalls=%s",
+                    final_reference_count, len(citation_top_level_minimums), final_shortfalls,
+                )
+            else:
+                evidence_status = "adequate"
+                self._preview_evidence_status = "adequate"
+                self._write_preview_payload(force=True)
+                logging.info(
+                    "Top-level claim-evidence final Gate passed: validated_references=%s sections=%s",
+                    final_reference_count, len(citation_top_level_minimums),
+                )
+            evidence_coverage_summary = self._evidence_coverage_summary(
+                status=evidence_status,
+                early_risk=bool(state.get("evidence_risk_detected")),
+                final_reference_count=final_reference_count,
+                minimums=citation_top_level_minimums,
+                validated_by_top_level=validated_by_top_level,
+                claims_by_top_level=claims_by_top_level,
+                events=state.get("evidence_coverage_events") or self._evidence_coverage_events,
+            )
+            state["evidence_status"] = evidence_status
+            state["evidence_coverage_summary"] = evidence_coverage_summary
             full_draft_en = full_draft_en.rstrip() + "\n\n# References\n" + "\n\n".join(references)
             actual_words = self._english_count_for_target(full_draft_en)
             self._upsert_quality_diagnostic(
@@ -2624,6 +2770,10 @@ Output only final academic prose. Do not report the word count."""
                     "final_keywords": final_keywords,
                     "front_matter_phase": "final",
                     "final_reference_count": final_reference_count,
+                    "evidence_status": str(state.get("evidence_status") or "adequate"),
+                    "evidence_risk_detected": bool(state.get("evidence_risk_detected")),
+                    "evidence_coverage_events": list(state.get("evidence_coverage_events") or []),
+                    "evidence_coverage_summary": dict(state.get("evidence_coverage_summary") or {}),
                     "citation_plan": citation_plan,
                     "citation_minimums": citation_minimums,
                     "citation_reserve_targets": citation_reserve_targets,
@@ -2683,7 +2833,10 @@ Output only final academic prose. Do not report the word count."""
                     '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)
+                self._checkpoint(
+                    f'translation_{unit_key}', state, pct,
+                    display_node=f'translation_final_gate:{index}:{len(final_units)}',
+                )
 
             unresolved_units = [
                 key for key, _name, _source in final_units
@@ -2728,7 +2881,14 @@ Output only final academic prose. Do not report the word count."""
             existing_path = self.output_dir / os.path.basename(existing_output)
             if existing_path.is_file() and existing_path.stat().st_size > 0:
                 self._progress(99, "package_validated")
-                return {"output_filename": existing_path.name, "output_path": str(existing_path)}
+                result = {"output_filename": existing_path.name, "output_path": str(existing_path)}
+                if str(state.get("evidence_status") or "") == "limited":
+                    result.update({
+                        "quality_status": "evidence_limited",
+                        "safe_error_code": "W_EVIDENCE_COVERAGE_LIMITED",
+                        "safe_error_detail": self._evidence_warning_detail(),
+                    })
+                return result
 
         self._progress(97, "packaging")
         bj_time = datetime.now(timezone(timedelta(hours=8))).strftime("%Y%m%d_%H%M")
@@ -2742,6 +2902,13 @@ Output only final academic prose. Do not report the word count."""
             citation_audit=agent.citation_audit_log,
             literature_metrics=agent.get_source_metrics(),
             quality_diagnostics=quality_diagnostics,
+            evidence_coverage=state.get("evidence_coverage_summary") or {
+                "status": str(state.get("evidence_status") or "adequate"),
+                "early_risk_detected": bool(state.get("evidence_risk_detected")),
+                "final_reference_count": int(state.get("final_reference_count") or 0),
+                "sections": [],
+                "events": list(state.get("evidence_coverage_events") or []),
+            },
         )
         self._progress(98, "package_validation")
         output_filename = f"SmartPaper_{bj_time}.zip"
@@ -2753,11 +2920,20 @@ Output only final academic prose. Do not report the word count."""
             {
                 "output_filename": output_filename,
                 "package_validated": True,
+                "evidence_status": str(state.get("evidence_status") or "adequate"),
+                "evidence_coverage_summary": dict(state.get("evidence_coverage_summary") or {}),
                 "agent_state": agent.export_state(),
             }
         )
-        self._checkpoint("package_validated", state, 99)
-        return {"output_filename": output_filename, "output_path": str(final)}
+        self._checkpoint("package_validated", state, 99, display_node="package_validated")
+        result = {"output_filename": output_filename, "output_path": str(final)}
+        if str(state.get("evidence_status") or "") == "limited":
+            result.update({
+                "quality_status": "evidence_limited",
+                "safe_error_code": "W_EVIDENCE_COVERAGE_LIMITED",
+                "safe_error_detail": self._evidence_warning_detail(),
+            })
+        return result
 
     def run(self) -> dict[str, Any]:
         try:

core/production_guard.py

@@ -498,6 +498,50 @@ def build_word_count_quality_report(diagnostics: list[dict[str, Any]] | None) ->
     ])
     return "\n".join(lines).strip() + "\n"
 
+def build_evidence_coverage_report(summary: dict[str, Any] | None) -> str:
+    """Build a neutral reader-facing literature evidence coverage report.
+
+    Sparse literature can have several explanations. This report intentionally
+    describes observed coverage only and never infers topic value, novelty, or
+    importance from literature counts.
+    """
+    data = dict(summary or {})
+    status = str(data.get("status") or "adequate").strip().lower()
+    limited = status == "limited"
+    lines = [
+        "SmartPaper Evidence Coverage Report",
+        "",
+        f"Overall evidence status: {'LIMITED' if limited else 'ADEQUATE'}",
+        f"Validated references in final manuscript: {max(0, int(data.get('final_reference_count') or 0))}",
+        f"Early coverage risk detected: {'yes' if bool(data.get('early_risk_detected')) else 'no'}",
+        "",
+        "Interpretation:",
+        "This status describes direct literature-evidence coverage only. It does not determine the novelty, importance, or overall research value of the topic.",
+        "A limited literature base may reflect a newer research area, a specialized or less-studied topic, dispersed interdisciplinary evidence, search/keyword or database coverage limits, or genuinely limited prior theoretical/empirical support.",
+        "SmartPaper does not infer which explanation applies from citation counts alone and does not use unrelated references merely to satisfy a quota.",
+        "",
+    ]
+    sections = [item for item in (data.get("sections") or []) if isinstance(item, dict)]
+    if sections:
+        lines.append("Top-level academic-section coverage:")
+        for item in sections:
+            section = str(item.get("section") or "section")
+            validated = max(0, int(item.get("validated_direct_citations") or 0))
+            required = max(0, int(item.get("evidence_requirement") or 0))
+            external_claims = max(0, int(item.get("external_claims") or 0))
+            lines.append(
+                f"- {section}: validated direct citations={validated}; evidence requirement={required}; externally oriented claims={external_claims}."
+            )
+    if limited:
+        lines.extend([
+            "",
+            "Author guidance:",
+            "The manuscript was completed because structural, translation, citation-correctness, quotation/fact, DOCX, and ZIP integrity gates are independent from literature coverage quantity.",
+            "Before formal submission, review the evidence gaps and consider adding more directly relevant core literature where appropriate.",
+        ])
+    return "\n".join(lines).strip() + "\n"
+
+
 def _manifest(entries: dict[str, bytes]) -> str:
     rows = []
     for name in sorted(entries):
@@ -516,6 +560,7 @@ def build_validated_package(
     citation_audit: list[dict[str, Any]],
     literature_metrics: dict[str, Any],
     quality_diagnostics: list[dict[str, Any]] | None = None,
+    evidence_coverage: dict[str, Any] | None = None,
 ) -> PackageResult:
     validate_markdown_manuscript(english_markdown, language_name="English")
     validate_markdown_manuscript(translated_markdown, language_name="Target-language")
@@ -543,6 +588,7 @@ def build_validated_package(
         "CITATION_AUDIT.json": json.dumps(citation_audit or [], ensure_ascii=False, indent=2).encode("utf-8"),
         "LITERATURE_METRICS.json": json.dumps(literature_metrics or {}, ensure_ascii=False, indent=2).encode("utf-8"),
         "WORD_COUNT_QUALITY_REPORT.txt": build_word_count_quality_report(quality_diagnostics).encode("utf-8"),
+        "EVIDENCE_COVERAGE_REPORT.txt": build_evidence_coverage_report(evidence_coverage).encode("utf-8"),
     }
     manifest = _manifest(entries)
     entries["FILE_MANIFEST_SHA256.txt"] = manifest.encode("utf-8")

i18n.py

@@ -227,6 +227,18 @@ TEXTS: dict[str, dict[str, str]] = {
         "draft_stage_outline": "正在规划论文结构…",
         "draft_stage_citation": "正在建立论点与引用关系…",
         "draft_stage_writing": "正在准备正文写作…",
+        "draft_stage_working_front": "正在生成工作摘要与关键词…",
+        "draft_stage_writing_unit": "正在撰写英文正文：第 {current}/{total} 个写作单元",
+        "draft_stage_citation_audit_unit": "正在核验第 {current}/{total} 个写作单元的引用与论点匹配",
+        "draft_stage_citation_recovery_unit": "正在为第 {current}/{total} 个写作单元补充可直接支撑现有论点的文献",
+        "draft_stage_writing_complete_unit": "英文正文第 {current}/{total} 个写作单元已完成",
+        "draft_stage_english_validation": "正在进行英文母稿结构、事实与证据完整性检查…",
+        "draft_stage_final_front": "正在生成最终摘要与关键词…",
+        "draft_stage_translation": "英文母稿已冻结，正在完成目标语言翻译与最终质检…",
+        "draft_stage_packaging": "正在生成英文与目标语言 DOCX 并打包…",
+        "draft_stage_package_validation": "正在校验 DOCX、ZIP 与文件完整性…",
+        "draft_stage_package_validated": "交付文件已通过完整性检查",
+        "draft_stage_processing": "系统正在处理当前论文任务…",
         "draft_detail_progress": "论文进度：{progress}%",
         "draft_detail_s2": "Semantic Scholar：{count} 篇有效文献",
         "draft_detail_oa": "OpenAlex：{count} 篇有效文献",
@@ -305,8 +317,10 @@ TEXTS: dict[str, dict[str, str]] = {
         "word_count": "📊 本章节实际字数：{actual}（目标：{target}），累计偏差：{deviation:+d}",
         "translation_running": "⏳ 英文已完成，正在后台异步翻译……",
         "node_error": "🚨 节点异常已中止。",
-        "literature_insufficient": "当前高相关文献不足以直接支撑部分核心论断。系统没有使用无关文献凑数。请调整研究题目或关键词，或上传更直接相关的核心文献后重试。",
-        "upstream_translation_stopped": "英文母稿的证据检查未通过，后续翻译已停止；当前页面中已显示的译文不是完整论文。",
+        "literature_insufficient": "当前没有检索到可用于形成有效参考文献列表的直接相关文献。系统未使用无关文献凑数。请检查研究题目、关键词或补充核心文献后重试。",
+        "upstream_translation_stopped": "英文母稿未形成可交付的有效参考文献列表，因此后续翻译已停止；当前页面中已显示的译文不是完整论文。",
+        "evidence_limited_running": "文献证据覆盖提示：当前检索与语义核验显示，部分核心外部论断可直接匹配的高相关文献较少。这可能与研究主题较新、领域较专门、跨领域文献分散、关键词表达或数据库覆盖等因素有关；仅凭这一状态不能判断研究价值。系统将继续生成论文，并且不会使用无关文献补足数量。",
+        "evidence_limited_completed": "论文已完整生成。部分核心外部论断的直接文献证据覆盖有限，系统未使用不相关文献凑数。该状态不能判断研究价值；建议正式投稿前结合 EVIDENCE_COVERAGE_REPORT.txt 进一步补充或复核相关核心文献。",
         "node_error_detail": "错误代码：{code}｜{error}｜系统已保存断点，可继续恢复。",
         "task_cancelled": "任务已取消，断点和临时文件已删除。",
         "task_start_failed": "无法启动论文任务：{error}",
@@ -324,6 +338,14 @@ TEXTS: dict[str, dict[str, str]] = {
         "monitor_node": "📍 当前节点",
         "monitor_log": "📝 动作日志",
         "monitor_compute": "📡 三维算力消耗监控",
+        "monitor_checkpoint_saved": "已安全保存检查点 {seq}",
+        "task_status_created": "已创建",
+        "task_status_running": "运行中",
+        "task_status_resumable": "可继续",
+        "task_status_cancelling": "正在取消",
+        "task_status_completed": "已完成",
+        "task_status_failed": "失败",
+        "task_status_cancelled": "已取消",
         "actual_stats_parsed": "✅ 已成功解析用户上传的实证数据。",
         "synthetic_stats_generated": "⚙️ 未上传统计结果，系统已生成可用于论文结构与结果写作的统计数据。",
         "qualitative_ready": "✅ 定性材料已准备完成。",
@@ -405,6 +427,18 @@ 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_stage_working_front": "Generating the Working Abstract and keywords…",
+        "draft_stage_writing_unit": "Writing the English manuscript: unit {current}/{total}",
+        "draft_stage_citation_audit_unit": "Checking claim-citation fit for writing unit {current}/{total}",
+        "draft_stage_citation_recovery_unit": "Finding direct support for existing claims in writing unit {current}/{total}",
+        "draft_stage_writing_complete_unit": "English writing unit {current}/{total} completed",
+        "draft_stage_english_validation": "Checking English-manuscript structure, facts, and evidence integrity…",
+        "draft_stage_final_front": "Generating the final Abstract and keywords…",
+        "draft_stage_translation": "The English source is frozen; completing target-language translation and final QA…",
+        "draft_stage_packaging": "Generating English and target-language DOCX files and packaging them…",
+        "draft_stage_package_validation": "Validating DOCX, ZIP, and file integrity…",
+        "draft_stage_package_validated": "Delivery files passed integrity validation",
+        "draft_stage_processing": "The system is processing the current paper task…",
         "draft_detail_progress": "Paper progress: {progress}%",
         "draft_detail_s2": "Semantic Scholar: {count} eligible papers",
         "draft_detail_oa": "OpenAlex: {count} eligible papers",
@@ -483,8 +517,10 @@ TEXTS: dict[str, dict[str, str]] = {
         "word_count": "📊 Section word count: {actual} (target: {target}); cumulative deviation: {deviation:+d}",
         "translation_running": "⏳ English draft complete. Background translation is running…",
         "node_error": "🚨 The node stopped because of an error.",
-        "literature_insufficient": "The available high-relevance literature is insufficient to support some core manuscript claims. Unrelated sources were not used to fill a quota. Revise the research topic or keywords, or provide more directly relevant core literature, and try again.",
-        "upstream_translation_stopped": "The English source manuscript did not pass the evidence gate, so downstream translation stopped. Any translated text currently shown is incomplete and is not a final paper.",
+        "literature_insufficient": "No directly relevant literature was retrieved that can support a valid final reference list. Unrelated sources were not used to fill a quota. Check the topic or keywords, or provide relevant core literature, and try again.",
+        "upstream_translation_stopped": "The English source manuscript could not form a deliverable validated reference list, so downstream translation stopped. Any translated text currently shown is incomplete and is not a final paper.",
+        "evidence_limited_running": "Literature-evidence coverage notice: current retrieval and semantic validation indicate that some core external claims have relatively few directly matching high-relevance sources. This may reflect a newer topic, a specialized field, dispersed interdisciplinary literature, keyword phrasing, or database coverage; this status alone does not determine research value. Generation will continue, and unrelated sources will not be used to fill a quota.",
+        "evidence_limited_completed": "The paper was generated in full. Direct literature-evidence coverage is limited for some core external claims, and unrelated sources were not used to fill a quota. This status does not determine research value. Before formal submission, review EVIDENCE_COVERAGE_REPORT.txt and consider adding or rechecking relevant core literature.",
         "node_error_detail": "Error code: {code} | {error} | A checkpoint has been saved and can be resumed.",
         "task_cancelled": "The task was cancelled. Its checkpoint and temporary files were deleted.",
         "task_start_failed": "The paper task could not be started: {error}",
@@ -502,6 +538,14 @@ TEXTS: dict[str, dict[str, str]] = {
         "monitor_node": "📍 Current node",
         "monitor_log": "📝 Activity log",
         "monitor_compute": "📡 Compute-usage monitor",
+        "monitor_checkpoint_saved": "Checkpoint {seq} saved safely",
+        "task_status_created": "Created",
+        "task_status_running": "Running",
+        "task_status_resumable": "Ready to resume",
+        "task_status_cancelling": "Cancelling",
+        "task_status_completed": "Completed",
+        "task_status_failed": "Failed",
+        "task_status_cancelled": "Cancelled",
         "actual_stats_parsed": "✅ The uploaded empirical results were parsed successfully.",
         "synthetic_stats_generated": "⚙️ No statistical results were uploaded. The system generated statistical data for the paper structure and Results section.",
         "qualitative_ready": "✅ Qualitative materials are ready.",
@@ -583,6 +627,18 @@ TEXTS: dict[str, dict[str, str]] = {
         "draft_stage_outline": "Планирование структуры статьи…",
         "draft_stage_citation": "Связывание тезисов с источниками…",
         "draft_stage_writing": "Подготовка к написанию текста…",
+        "draft_stage_working_front": "Формируются рабочая аннотация и ключевые слова…",
+        "draft_stage_writing_unit": "Подготовка английской рукописи: блок {current}/{total}",
+        "draft_stage_citation_audit_unit": "Проверяется соответствие утверждений и источников в блоке {current}/{total}",
+        "draft_stage_citation_recovery_unit": "Подбираются прямые источники для уже существующих утверждений в блоке {current}/{total}",
+        "draft_stage_writing_complete_unit": "Блок английской рукописи {current}/{total} завершён",
+        "draft_stage_english_validation": "Проверяются структура, факты и доказательная целостность английской рукописи…",
+        "draft_stage_final_front": "Формируются окончательная аннотация и ключевые слова…",
+        "draft_stage_translation": "Английская рукопись зафиксирована; завершаются перевод и итоговая проверка качества…",
+        "draft_stage_packaging": "Создаются английский и целевой DOCX и формируется пакет…",
+        "draft_stage_package_validation": "Проверяется целостность DOCX, ZIP и файлов…",
+        "draft_stage_package_validated": "Файлы выдачи прошли проверку целостности",
+        "draft_stage_processing": "Система обрабатывает текущую задачу подготовки статьи…",
         "draft_detail_progress": "Прогресс статьи: {progress}%",
         "draft_detail_s2": "Semantic Scholar: {count} подходящих источников",
         "draft_detail_oa": "OpenAlex: {count} подходящих источников",
@@ -661,8 +717,10 @@ TEXTS: dict[str, dict[str, str]] = {
         "word_count": "📊 Объём раздела: {actual} слов (цель: {target}); накопленное отклонение: {deviation:+d}",
         "translation_running": "⏳ Английский текст завершён. Выполняется фоновый перевод…",
         "node_error": "🚨 Выполнение узла остановлено из-за ошибки.",
-        "literature_insufficient": "Доступной высокорелевантной литературы недостаточно для прямой поддержки части ключевых утверждений рукописи. Система не использовала нерелевантные источники ради количества. Измените тему или ключевые слова либо добавьте более релевантные основные источники и повторите попытку.",
-        "upstream_translation_stopped": "Английская исходная рукопись не прошла проверку доказательной базы, поэтому дальнейший перевод остановлен. Уже показанный перевод неполный и не является окончательной статьёй.",
+        "literature_insufficient": "Не удалось найти прямо релевантную литературу, достаточную для формирования валидного итогового списка источников. Система не использовала нерелевантные публикации ради количества. Проверьте тему и ключевые слова либо добавьте релевантные основные источники и повторите попытку.",
+        "upstream_translation_stopped": "Для английской исходной рукописи не удалось сформировать пригодный к выдаче валидный список источников, поэтому дальнейший перевод остановлен. Уже показанный перевод неполный и не является окончательной статьёй.",
+        "evidence_limited_running": "Уведомление о покрытии литературными доказательствами: текущий поиск и семантическая проверка показывают, что для части ключевых внешних утверждений найдено относительно мало высокорелевантных источников с прямой поддержкой. Это может быть связано с новизной темы, узкой специализацией, рассредоточенностью междисциплинарной литературы, формулировкой ключевых слов или охватом баз данных; по одному этому признаку нельзя судить о ценности исследования. Генерация продолжится, а нерелевантные источники не будут использоваться ради количества.",
+        "evidence_limited_completed": "Статья полностью сформирована. Для части ключевых внешних утверждений прямое покрытие литературными доказательствами ограничено; нерелевантные источники не использовались ради количества. Этот статус не определяет ценность исследования. Перед подачей рекомендуется изучить EVIDENCE_COVERAGE_REPORT.txt и при необходимости дополнить или перепроверить основную литературу.",
         "node_error_detail": "Код ошибки: {code} | {error} | Контрольная точка сохранена; работу можно продолжить.",
         "task_cancelled": "Задача отменена. Контрольная точка и временные файлы удалены.",
         "task_start_failed": "Не удалось запустить подготовку статьи: {error}",
@@ -680,6 +738,14 @@ TEXTS: dict[str, dict[str, str]] = {
         "monitor_node": "📍 Текущий узел",
         "monitor_log": "📝 Журнал действий",
         "monitor_compute": "📡 Монитор вычислительных затрат",
+        "monitor_checkpoint_saved": "Контрольная точка {seq} безопасно сохранена",
+        "task_status_created": "Создано",
+        "task_status_running": "Выполняется",
+        "task_status_resumable": "Можно продолжить",
+        "task_status_cancelling": "Отмена выполняется",
+        "task_status_completed": "Завершено",
+        "task_status_failed": "Ошибка",
+        "task_status_cancelled": "Отменено",
         "actual_stats_parsed": "✅ Загруженные эмпирические результаты успешно обработаны.",
         "synthetic_stats_generated": "⚙️ Статистические результаты не загружены. Система сформировала статистические данные для структуры статьи и раздела результатов.",
         "qualitative_ready": "✅ Качественные материалы подготовлены.",
@@ -761,6 +827,18 @@ TEXTS: dict[str, dict[str, str]] = {
         "draft_stage_outline": "Мақала құрылымы жоспарлануда…",
         "draft_stage_citation": "Тұжырымдар дереккөздермен сәйкестендірілуде…",
         "draft_stage_writing": "Негізгі мәтінді жазуға дайындалуда…",
+        "draft_stage_working_front": "Жұмыс аңдатпасы мен түйін сөздер әзірленуде…",
+        "draft_stage_writing_unit": "Ағылшын қолжазбасы жазылуда: {current}/{total} жазу бірлігі",
+        "draft_stage_citation_audit_unit": "{current}/{total} жазу бірлігіндегі тұжырымдар мен сілтемелер сәйкестігі тексерілуде",
+        "draft_stage_citation_recovery_unit": "{current}/{total} жазу бірлігіндегі бар тұжырымдарға тікелей қолдау көрсететін әдебиет ізделуде",
+        "draft_stage_writing_complete_unit": "Ағылшын қолжазбасының {current}/{total} жазу бірлігі аяқталды",
+        "draft_stage_english_validation": "Ағылшын қолжазбасының құрылымы, фактілері және дәлел тұтастығы тексерілуде…",
+        "draft_stage_final_front": "Соңғы аңдатпа мен түйін сөздер әзірленуде…",
+        "draft_stage_translation": "Ағылшын бастапқы мәтіні бекітілді; мақсатты тілдегі аударма және соңғы сапа тексерісі аяқталуда…",
+        "draft_stage_packaging": "Ағылшын және мақсатты тілдегі DOCX файлдары жасалып, пакетке жиналуда…",
+        "draft_stage_package_validation": "DOCX, ZIP және файл тұтастығы тексерілуде…",
+        "draft_stage_package_validated": "Жеткізу файлдары тұтастық тексерісінен өтті",
+        "draft_stage_processing": "Жүйе ағымдағы мақала тапсырмасын өңдеп жатыр…",
         "draft_detail_progress": "Мақала барысы: {progress}%",
         "draft_detail_s2": "Semantic Scholar: {count} жарамды дереккөз",
         "draft_detail_oa": "OpenAlex: {count} жарамды дереккөз",
@@ -839,8 +917,10 @@ TEXTS: dict[str, dict[str, str]] = {
         "word_count": "📊 Бөлім көлемі: {actual} сөз (мақсат: {target}); жиынтық ауытқу: {deviation:+d}",
         "translation_running": "⏳ Ағылшын мәтіні аяқталды. Фондық аударма орындалуда…",
         "node_error": "🚨 Қате салдарынан түйін тоқтатылды.",
-        "literature_insufficient": "Қолжетімді жоғары релевантты әдебиет қолжазбаның кейбір негізгі тұжырымдарын тікелей қолдауға жеткіліксіз. Жүйе санды толтыру үшін қатысы жоқ дереккөздерді пайдаланбады. Зерттеу тақырыбын немесе кілт сөздерді өзгертіңіз не тікелей релевантты негізгі әдебиетті қосып, қайта көріңіз.",
-        "upstream_translation_stopped": "Ағылшын тіліндегі бастапқы қолжазба дәлелдер тексерісінен өтпеді, сондықтан кейінгі аударма тоқтатылды. Қазір көрсетілген аударма толық емес және соңғы мақала болып саналмайды.",
+        "literature_insufficient": "Жарамды соңғы әдебиеттер тізімін құруға жеткілікті тікелей релевантты әдебиет табылмады. Жүйе санды толтыру үшін қатысы жоқ дереккөздерді пайдаланбады. Тақырып пен кілт сөздерді тексеріңіз немесе релевантты негізгі әдебиетті қосып, қайта көріңіз.",
+        "upstream_translation_stopped": "Ағылшын бастапқы қолжазбасы үшін жеткізуге жарамды тексерілген әдебиеттер тізімі қалыптаспады, сондықтан кейінгі аударма тоқтатылды. Қазір көрсетілген аударма толық емес және соңғы мақала болып саналмайды.",
+        "evidence_limited_running": "Әдеби дәлелдерді қамту туралы ескерту: ағымдағы іздеу және семантикалық тексеру кейбір негізгі сыртқы тұжырымдарға тікелей сәйкес келетін жоғары релевантты дереккөздер салыстырмалы түрде аз екенін көрсетеді. Бұл тақырыптың жаңалығына, саланың тар мамандандырылуына, пәнаралық әдебиеттің шашыраңқылығына, кілт сөздердің тұжырымдалуына немесе дерекқор қамтуына байланысты болуы мүмкін; осы мәртебенің өзі зерттеу құндылығын анықтамайды. Генерация жалғасады және жүйе санды толтыру үшін қатысы жоқ дереккөздерді пайдаланбайды.",
+        "evidence_limited_completed": "Мақала толық жасалды. Кейбір негізгі сыртқы тұжырымдар үшін тікелей әдеби дәлелдер қамтуы шектеулі, ал жүйе санды толтыру үшін қатысы жоқ дереккөздерді пайдаланбады. Бұл мәртебе зерттеу құндылығын анықтамайды. Ресми тапсыру алдында EVIDENCE_COVERAGE_REPORT.txt файлын қарап, қажет болса релевантты негізгі әдебиетті толықтыру немесе қайта тексеру ұсынылады.",
         "node_error_detail": "Қате коды: {code} | {error} | Бақылау нүктесі сақталды; жұмысты жалғастыруға болады.",
         "task_cancelled": "Тапсырма тоқтатылды. Бақылау нүктесі мен уақытша файлдар жойылды.",
         "task_start_failed": "Мақала тапсырмасын бастау мүмкін болмады: {error}",
@@ -858,6 +938,14 @@ TEXTS: dict[str, dict[str, str]] = {
         "monitor_node": "📍 Ағымдағы түйін",
         "monitor_log": "📝 Әрекеттер журналы",
         "monitor_compute": "📡 Есептеу шығындарының мониторингі",
+        "monitor_checkpoint_saved": "{seq} бақылау нүктесі қауіпсіз сақталды",
+        "task_status_created": "Құрылды",
+        "task_status_running": "Орындалуда",
+        "task_status_resumable": "Жалғастыруға болады",
+        "task_status_cancelling": "Тоқтатылуда",
+        "task_status_completed": "Аяқталды",
+        "task_status_failed": "Қате",
+        "task_status_cancelled": "Тоқтатылды",
         "actual_stats_parsed": "✅ Жүктелген эмпирикалық нәтижелер сәтті өңделді.",
         "synthetic_stats_generated": "⚙️ Статистикалық нәтижелер жүктелмеді. Жүйе мақала құрылымы мен нәтижелер бөлімі үшін статистикалық деректер дайындады.",
         "qualitative_ready": "✅ Сапалық материалдар дайындалды.",

smartpaper_restore_bridge/frontend/index.html

@@ -315,6 +315,66 @@
     return output;
   }
 
+  function localizeDraftNode(node, labels) {
+    const value = String(node || "").trim();
+    const map = labels && typeof labels === "object" ? labels : {};
+    const exact = {
+      "inputs_and_evidence":"inputs_and_evidence",
+      "S2 + OpenAlex":"S2 + OpenAlex",
+      "literature_synthesis":"literature_synthesis",
+      "research_logic":"research_logic",
+      "working_front_matter":"working_front_matter",
+      "outline_planning":"outline_planning",
+      "citation_planning":"citation_planning",
+      "english_validation":"english_validation",
+      "final_front_matter":"final_front_matter",
+      "translation":"translation",
+      "translation_complete":"translation",
+      "packaging":"packaging",
+      "package_validation":"package_validation",
+      "package_validated":"package_validated"
+    };
+    if (Object.prototype.hasOwnProperty.call(exact, value)) {
+      return String(map[exact[value]] || map.processing || map.default || "");
+    }
+    const typed = [
+      ["writing:", "writing_unit"],
+      ["citation_audit:", "citation_audit_unit"],
+      ["citation_recovery:", "citation_recovery_unit"],
+      ["writing_complete:", "writing_complete_unit"]
+    ];
+    for (const [prefix, key] of typed) {
+      if (!value.startsWith(prefix)) continue;
+      const parts = value.slice(prefix.length).split(":");
+      return formatTemplate(map[key] || map.processing || map.default || "", {
+        current:parts[0] || "", total:parts[1] || ""
+      });
+    }
+    if (value.startsWith("translation_")) return String(map.translation || map.processing || map.default || "");
+    if (value.startsWith("section_")) return String(map.writing || map.processing || map.default || "");
+    return String(map.processing || map.default || "");
+  }
+
+  function localizeTaskStatus(status, labels) {
+    const map = labels && typeof labels === "object" ? labels : {};
+    const key = `status_${String(status || "").trim().toLowerCase()}`;
+    return String(map[key] || map.processing || map.default || "");
+  }
+
+  function updateEvidenceWarning(parentDocument, payload, labels) {
+    const node = parentDocument.getElementById("sp-live-evidence-warning");
+    if (!node) return;
+    const status = String(payload && payload.evidence_status || "").trim().toLowerCase();
+    const map = labels && typeof labels === "object" ? labels : {};
+    if (status === "limited_risk" || status === "limited") {
+      node.textContent = String(map.evidence_limited || "");
+      node.style.display = node.textContent ? "block" : "none";
+    } else {
+      node.textContent = "";
+      node.style.display = "none";
+    }
+  }
+
   function updateDraftPreparation(parentDocument, node, labels, task=null) {
     const status = parentDocument.getElementById("sp-live-manuscript-status");
     const channel = renderChannels.english;
@@ -328,7 +388,7 @@
     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 stage = localizeDraftNode(node, map);
     const lines = [String(map.default || "").trim()];
     if (stage) lines.push(formatTemplate(map.current || "{stage}", {stage}));
     if (map.progress) lines.push(formatTemplate(map.progress, {progress}));
@@ -617,6 +677,7 @@
       lastTargetPreviewText = targetText;
     }
     updateTargetPreparation(parentDocument, payload, watch && watch.targetStatusLabels);
+    updateEvidenceWarning(parentDocument, payload, watch && watch.draftStatusLabels);
   }
 
   async function fetchPreview(watch) {
@@ -643,24 +704,34 @@
     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);
+    const labels = watch && watch.draftStatusLabels;
+    const statusLabel = localizeTaskStatus(status, labels);
+    const nodeLabel = localizeDraftNode(node, labels);
+    updateText(parentDocument, "sp-live-status", statusLabel);
+    updateText(parentDocument, "sp-live-node", nodeLabel);
     updateText(parentDocument, "sp-live-checkpoint-seq", checkpointSeq);
-    updateText(parentDocument, "sp-live-checkpoint-stage", checkpointStage);
+    updateText(
+      parentDocument, "sp-live-checkpoint-stage",
+      formatTemplate((labels && labels.checkpoint_saved) || "", {seq:checkpointSeq})
+    );
     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}`);
+    updateText(parentDocument, "sp-live-progress-text", `${progress}% — ${nodeLabel}`);
     const fill = parentDocument.getElementById("sp-live-progress-fill");
     if (fill) fill.style.width = `${progress}%`;
-    updateDraftPreparation(parentDocument, node, watch && watch.draftStatusLabels, task);
+    updateDraftPreparation(parentDocument, node, labels, task);
 
     if (node && node !== lastMonitorNode) {
-      appendTaskActivity(parentDocument, node, false);
+      appendTaskActivity(parentDocument, nodeLabel, false);
       lastMonitorNode = node;
     }
     if (checkpointSeq > lastMonitorCheckpointSeq) {
-      appendTaskActivity(parentDocument, checkpointStage || node, true);
+      appendTaskActivity(
+        parentDocument,
+        formatTemplate((labels && labels.checkpoint_saved) || "", {seq:checkpointSeq}),
+        true
+      );
       lastMonitorCheckpointSeq = checkpointSeq;
     }
   }

task_executor.py

@@ -584,6 +584,12 @@ def main() -> int:
                 "status": "completed",
                 "current_node": "package_validated",
                 "output_filename": str(result.get("output_filename") or "")[:240],
+                # R14-TQ2-PQ1-R3-R1: completed tasks may carry a nonfatal,
+                # backend-trusted quality warning. Worker/D1 already persists
+                # safe_error_code/detail for completed terminal transitions;
+                # quota semantics remain the ordinary completed/committed path.
+                "safe_error_code": str(result.get("safe_error_code") or "")[:80],
+                "safe_error_detail": str(result.get("safe_error_detail") or "")[:800],
             }
         )
         logging.info("[SP_EXECUTOR] completed task_id=%s epoch=%s", args.task_id, epoch)