R14-TQ2-PQ1-R4-R1 Production Readiness Consolidated Fix

app.py

@@ -759,8 +759,8 @@ def _render_monitor_box(task: dict, lang_code: str) -> None:
         """
 
     st.markdown(f"""
-    {progress_markup}
     <div class='log-box' id='sp-live-monitor'>
+        {progress_markup}
         <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>
@@ -794,6 +794,14 @@ def _watch_task_status_live(task: dict) -> dict | None:
     if not api_origin:
         logging.warning("[SP_UI] live_watch_missing_api_origin task_id=%s", task_id)
         return None
+    expected_request_hash = str(task.get("request_hash") or "").strip().lower()
+    if not expected_request_hash:
+        try:
+            request_path = _task_dir(task_id) / "request.json"
+            if request_path.is_file():
+                expected_request_hash = str(json.loads(request_path.read_text(encoding="utf-8")).get("request_hash") or "").strip().lower()
+        except Exception:
+            expected_request_hash = ""
     try:
         watch_result = edge_bridge(
             action="task_watch",
@@ -805,8 +813,9 @@ def _watch_task_status_live(task: dict) -> dict | None:
                 "preview_interval_ms": 700,
                 "preview_path": _task_preview_path(task_id),
                 "expected_execution_epoch": int(task.get("execution_epoch") or 0),
+                "expected_request_hash": expected_request_hash,
                 "initial_checkpoint_seq": int(task.get("checkpoint_seq") or 0),
-                "best_effort_page_exit_cancel": True,
+                "best_effort_page_exit_cancel": False,
                 "draft_status_labels": {
                     "default": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_preparing"),
                     "inputs_and_evidence": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_inputs"),

config.py

@@ -15,6 +15,17 @@ def load_config():
         "s2_max_logical_searches": max(1, min(6, int(os.environ.get("S2_MAX_LOGICAL_SEARCHES", "3")))),
         "citation_planner_batch_size": max(8, min(24, int(os.environ.get("CITATION_PLANNER_BATCH_SIZE", "18")))),
         "citation_planner_max_tokens": max(1200, min(3200, int(os.environ.get("CITATION_PLANNER_MAX_TOKENS", "2200")))),
+        # R14-TQ2-PQ1-R4-R1: pre-draft reasoning is bounded and observable.
+        # These are diagnostic SLA budgets, not manuscript-failure authorities.
+        "prewrite_reasoning_max_tokens": {
+            "literature_synthesis": max(1200, min(3200, int(os.environ.get("PREWRITE_SYNTHESIS_REASONING_MAX_TOKENS", "2400")))),
+            "qualitative_packet": max(1200, min(3200, int(os.environ.get("PREWRITE_QUAL_PACKET_REASONING_MAX_TOKENS", "2400")))),
+        },
+        "prewrite_sla_seconds": {
+            "literature_synthesis": max(30, int(os.environ.get("PREWRITE_SYNTHESIS_SLA_SECONDS", "90"))),
+            "research_logic": max(15, int(os.environ.get("PREWRITE_RESEARCH_LOGIC_SLA_SECONDS", "30"))),
+            "qualitative_packet": max(30, int(os.environ.get("PREWRITE_QUAL_PACKET_SLA_SECONDS", "75"))),
+        },
         "chunk_words_default": int(os.environ.get("CHUNK_WORDS_DEFAULT", "1500")),
         "target_words_min": 5000,
         "target_words_default": 5000,

core/generation_runner.py

@@ -1721,7 +1721,7 @@ class GenerationRunner:
         )
 
     @staticmethod
-    def _evidence_coverage_summary(*, status, early_risk, final_reference_count, minimums, validated_by_top_level, claims_by_top_level, events):
+    def _evidence_coverage_summary(*, status, early_risk, final_reference_count, minimums, validated_by_top_level, claims_by_top_level, events, method_authority_count=0, method_external_claims=0):
         sections = []
         for section_id, planned_minimum in dict(minimums or {}).items():
             validated = len(set((validated_by_top_level or {}).get(section_id) or []))
@@ -1739,9 +1739,52 @@ class GenerationRunner:
             "early_risk_detected": bool(early_risk),
             "final_reference_count": max(0, int(final_reference_count or 0)),
             "sections": sections,
+            "methodology_authority": {
+                "validated_method_authority_citations": max(0, int(method_authority_count or 0)),
+                "methodology_external_claims": max(0, int(method_external_claims or 0)),
+            },
             "events": list(events or []),
         }
 
+    @staticmethod
+    def _paragraph_token_set(value):
+        text = re.sub(r'\[CITE-\d+\]', ' ', str(value or ''), flags=re.I)
+        return set(re.findall(r'[A-Za-z][A-Za-z0-9_-]{2,}', text.lower()))
+
+    @classmethod
+    def _remove_severe_cross_unit_duplicates(cls, candidate, prior_text):
+        """Drop only very high-confidence cross-unit duplicate paragraphs."""
+        previous = [p.strip() for p in re.split(r'\n\s*\n', str(prior_text or '')) if len(p.split()) >= 55 and not p.lstrip().startswith('#')]
+        kept, diagnostics = [], []
+        for paragraph in re.split(r'(\n\s*\n)', str(candidate or '')):
+            if re.fullmatch(r'\n\s*\n', paragraph or ''):
+                kept.append(paragraph); continue
+            value = str(paragraph or '').strip()
+            if len(value.split()) < 55 or value.startswith('#'):
+                kept.append(paragraph); continue
+            tokens = cls._paragraph_token_set(value)
+            citations = set(re.findall(r'\[CITE-\d+\]', value, flags=re.I))
+            numerics = set(re.findall(r'(?<![A-Za-z])[-+]?\d+(?:\.\d+)?%?(?![A-Za-z])', value))
+            duplicate = None
+            for old in previous:
+                old_tokens = cls._paragraph_token_set(old)
+                union = tokens | old_tokens
+                similarity = len(tokens & old_tokens) / max(1, len(union))
+                if similarity < 0.90:
+                    continue
+                old_citations = set(re.findall(r'\[CITE-\d+\]', old, flags=re.I))
+                old_numerics = set(re.findall(r'(?<![A-Za-z])[-+]?\d+(?:\.\d+)?%?(?![A-Za-z])', old))
+                # Never delete a paragraph carrying different evidence/facts.
+                if citations == old_citations and numerics == old_numerics:
+                    duplicate = (similarity, old[:180])
+                    break
+            if duplicate:
+                diagnostics.append({"similarity": round(duplicate[0], 4), "removed_preview": value[:180]})
+                continue
+            kept.append(paragraph)
+            previous.append(value)
+        return ''.join(kept).strip(), diagnostics
+
     def _resolve_paths(self, items) -> list[str]:
         output = []
         for item in items or []:
@@ -1834,7 +1877,10 @@ class GenerationRunner:
                 )
             else:
                 raw_interviews = extract_text_from_files(interview_paths[:1]) if interview_paths else ""
+                prewrite_started = time.monotonic()
+                prewrite_calls = agent.ds_calls
                 user_data_md, _, data_metadata = qual_engine.resolve_qualitative_data(topic, keywords, raw_interviews)
+                agent.record_prewrite_stage("qualitative_packet", prewrite_started, prewrite_calls)
             state.update(
                 {
                     "topic": topic,
@@ -1894,9 +1940,12 @@ class GenerationRunner:
         synthesis_result = str(state.get("synthesis_result") or "")
         if not synthesis_result:
             self._progress(12, "literature_synthesis")
+            prewrite_started = time.monotonic()
+            prewrite_calls = agent.ds_calls
             synthesis_result = self._stream_text(
                 agent.stream_synthesize_literature(topic, refs_text, user_core_literature=user_lit_context)
             )
+            agent.record_prewrite_stage("literature_synthesis", prewrite_started, prewrite_calls)
             synthesis_result = re.sub(r"<think>.*?</think>", "", synthesis_result, flags=re.DOTALL).strip()
             state.update({"synthesis_result": synthesis_result, "agent_state": agent.export_state()})
             self._checkpoint("synthesis_ready", state, 13)
@@ -1904,12 +1953,15 @@ class GenerationRunner:
         adaptive_structure = state.get("adaptive_structure")
         if not isinstance(adaptive_structure, list) or not adaptive_structure:
             self._progress(14, "research_logic")
+            prewrite_started = time.monotonic()
+            prewrite_calls = agent.ds_calls
             research_logic_response = self._stream_text(
                 agent.stream_generate_research_logic(
                     topic, keywords, synthesis_result, refs_text,
                     data_evidence=planning_data_md, mode=mode,
                 )
             )
+            agent.record_prewrite_stage("research_logic", prewrite_started, prewrite_calls)
             research_logic_contract = re.sub(
                 r"<think>.*?</think>", "", research_logic_response, flags=re.DOTALL
             ).strip()
@@ -2416,6 +2468,8 @@ class GenerationRunner:
                 f"Already completed: {completed_label}. Do not restate their background, gap, or contribution."
                 if completed_label else ""
             )
+            if re.search(r"\(Part\s+2/2\)", display_name, flags=re.I):
+                anti_repeat += " Part 2/2 must extend and complement Part 1/2; do not recap its background, mechanism explanation, evidence, or contribution framing."
             voice = str(APP_CONFIG.get("journal_voice_profiles", {}).get(mode) or "")
             sys_prompt = (
                 APP_CONFIG.get("sys_academic_writer", "") + "\n"
@@ -2575,6 +2629,10 @@ Output only final academic prose. Do not report the word count."""
                     data_metadata=data_metadata,
                     quote_invocation_plan=quote_invocation_plan,
                 )
+            en_resolved, duplicate_rows = self._remove_severe_cross_unit_duplicates(en_resolved, full_draft_en)
+            if duplicate_rows:
+                logging.warning("Severe cross-unit redundancy removed | unit=%s count=%s max_similarity=%s", display_name, len(duplicate_rows), max(row["similarity"] for row in duplicate_rows))
+                quality_diagnostics.append({"scope":"manuscript_redundancy","name":display_name,"status":"bounded_duplicate_removed","count":len(duplicate_rows),"examples":duplicate_rows[:3]})
             full_draft_en += en_resolved + "\n\n"
             if assigned_tag_list:
                 logging.info(
@@ -2647,6 +2705,8 @@ Output only final academic prose. Do not report the word count."""
                 repeated_quotes = agent.find_repeated_qualitative_quotes(full_draft_en, data_metadata)
                 if repeated_quotes:
                     raise RuntimeError(f"Repeated qualitative quotations: {repeated_quotes[:5]}")
+            actual_used_tags = {f"[{tag.upper()}]" for tag in re.findall(r"CITE-\d+", full_draft_en, flags=re.I)}
+            agent.used_citations = set(tag for tag in actual_used_tags if tag in agent.citation_map)
             references = []
             seen_refs = set()
             for tag in sorted(agent.used_citations, key=agent._citation_tag_number):
@@ -2667,6 +2727,13 @@ Output only final academic prose. Do not report the word count."""
                 claims_by_top_level[section_id] = claims_by_top_level.get(section_id, 0) + int(
                     citation_required_claim_counts_by_unit.get(unit_name, 0) or 0
                 )
+            method_section_id = 'methods' if mode == 'asq' else 'methodology'
+            method_validated_tags = set(validated_by_top_level.get(method_section_id) or []) & set(agent.used_citations)
+            method_authority_tags = {
+                tag for tag in method_validated_tags
+                if 'method_authority' in set((agent.citation_map.get(tag) or {}).get('evidence_lanes') or [])
+            }
+            method_external_claims = max(0, int(claims_by_top_level.get(method_section_id, 0) or 0))
             final_shortfalls = []
             for section_id, planned_minimum in citation_top_level_minimums.items():
                 validated_tags = set(validated_by_top_level.get(section_id) or [])
@@ -2704,6 +2771,8 @@ Output only final academic prose. Do not report the word count."""
                 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,
+                method_authority_count=len(method_authority_tags),
+                method_external_claims=method_external_claims,
             )
             state["evidence_status"] = evidence_status
             state["evidence_coverage_summary"] = evidence_coverage_summary

core/pipeline_agent.py

@@ -139,6 +139,7 @@ class SSciPipelineAgent:
         # R3.2.8.6: translation validators emit hierarchical assurance evidence.
         # Low-level diagnostics cannot independently terminate a manuscript.
         self.translation_assurance_log = []
+        self.prewrite_metrics = {}
         self.lock = threading.RLock()
         
         self.lit_target_papers = APP_CONFIG["lit_target_papers"]
@@ -223,6 +224,25 @@ class SSciPipelineAgent:
                 type(exc).__name__,
             )
 
+    def record_prewrite_stage(self, stage, started_at, start_ds_calls):
+        """Record bounded non-secret latency/call diagnostics for pre-draft stages."""
+        key = str(stage or "unknown")
+        duration = max(0.0, time.monotonic() - float(started_at or time.monotonic()))
+        calls = max(0, int(self.ds_calls) - int(start_ds_calls or 0))
+        sla = float((APP_CONFIG.get("prewrite_sla_seconds") or {}).get(key, 0) or 0)
+        row = {
+            "duration_seconds": round(duration, 3),
+            "deepseek_calls": calls,
+            "sla_seconds": sla,
+            "status": "within_sla" if not sla or duration <= sla else "over_sla",
+        }
+        self.prewrite_metrics[key] = row
+        logging.info(
+            "Prewrite stage metric | stage=%s duration=%.3fs deepseek_calls=%s sla=%.1fs status=%s",
+            key, duration, calls, sla, row["status"],
+        )
+        return dict(row)
+
     def _check_cancelled(self):
         if self._cancel_checker is not None:
             result = self._cancel_checker()
@@ -293,6 +313,7 @@ class SSciPipelineAgent:
                 "used_citations": list(self.used_citations),
                 "citation_audit_log": list(self.citation_audit_log),
                 "translation_assurance_log": list(self.translation_assurance_log),
+                "prewrite_metrics": dict(self.prewrite_metrics),
                 "global_memory": self.global_memory,
                 "s2_access_mode": self._s2_access_mode,
                 "s2_logical_searches": int(self._s2_logical_searches),
@@ -315,6 +336,7 @@ class SSciPipelineAgent:
             self.used_citations = set(state_dict.get("used_citations", []))
             self.citation_audit_log = list(state_dict.get("citation_audit_log", []))
             self.translation_assurance_log = list(state_dict.get("translation_assurance_log", []))
+            self.prewrite_metrics = dict(state_dict.get("prewrite_metrics") or {})
             self.global_memory = state_dict.get("global_memory", self.global_memory)
             loaded_mode = str(state_dict.get("s2_access_mode") or "").strip().lower()
             expected_mode = "key" if self.s2_key else "anonymous"
@@ -1227,9 +1249,11 @@ class SSciPipelineAgent:
 
         def _stream_with_reasoning_exhaustion_recovery():
             try:
+                reasoning_budget = int((APP_CONFIG.get("prewrite_reasoning_max_tokens") or {}).get("literature_synthesis", 2400))
                 yield from self.stream_deepseek(
                     sys_prompt,
                     user_prompt,
+                    max_tokens=reasoning_budget,
                     model_role="reasoning",
                     thinking=True,
                     allow_fallback=False,
@@ -1252,6 +1276,7 @@ class SSciPipelineAgent:
             yield from self.stream_deepseek(
                 recovery_system,
                 user_prompt,
+                max_tokens=8000,
                 model_role="reasoning",
                 thinking=False,
                 allow_fallback=False,
@@ -1291,34 +1316,18 @@ Literature Synthesis:
 {evidence_block}
 {mode_directive}
 Return a concise PROVISIONAL RESEARCH LOGIC CONTRACT in plain English prose. It must guide later sections without fixing an expected result or conclusion. Do not use citations in the contract."""
-        def _stream_with_reasoning_exhaustion_recovery():
-            try:
-                yield from self.stream_deepseek(
-                    sys_prompt,
-                    user_prompt,
-                    max_tokens=2200,
-                    model_role="reasoning",
-                    thinking=True,
-                    allow_fallback=False,
-                    reasoning_only_recovery=True,
-                )
-                return
-            except DeepSeekReasoningOnlyExhaustionError as exc:
-                logging.warning(
-                    "Research logic reasoning-only exhaustion; retrying once with thinking disabled: %s",
-                    exc,
-                )
-                self._touch_execution_progress("research_logic_direct_recovery")
-
-            recovery_system = (
+        def _stream_direct_research_logic():
+            # R4-A: research logic is a concise planning contract. A reasoning-first
+            # request repeatedly spent the whole hidden-reasoning budget before any
+            # usable content, so direct final-output mode is now the default.
+            direct_system = (
                 sys_prompt
-                + "\n\nRECOVERY MODE: Produce the final provisional research logic contract directly. "
-                  "Do not perform extended hidden reasoning. Preserve the original topic, literature synthesis, "
-                  "research evidence, uncertainty, evidence-strength boundaries, and mode-specific planning constraints. "
-                  "Do not invent findings, coefficients, causal claims, or facts."
+                + "\n\nDIRECT PLANNING MODE: Produce the final provisional research logic contract directly. "
+                  "Do not perform extended hidden reasoning. Preserve uncertainty and evidence-strength boundaries; "
+                  "do not invent findings, coefficients, causal claims, or facts."
             )
             yield from self.stream_deepseek(
-                recovery_system,
+                direct_system,
                 user_prompt,
                 max_tokens=2200,
                 model_role="reasoning",
@@ -1326,7 +1335,7 @@ Return a concise PROVISIONAL RESEARCH LOGIC CONTRACT in plain English prose. It
                 allow_fallback=False,
             )
 
-        return _stream_with_reasoning_exhaustion_recovery()
+        return _stream_direct_research_logic()
 
     @staticmethod
     def _front_matter_keywords(value, minimum=4, maximum=6):
@@ -1821,56 +1830,87 @@ USER KEYWORD SEEDS: {keywords}
                 violations.append({"tag": item.get("tag"), "count": count})
         return violations
 
+    @staticmethod
+    def _method_authority_queries(structure):
+        """Derive bounded methodology queries from design language, never topic keywords."""
+        text_parts = []
+        for sec in structure or []:
+            if not isinstance(sec, dict):
+                continue
+            section = str(sec.get('section') or sec.get('section_id') or '')
+            if not re.search(r'(?i)method|methodology', section):
+                continue
+            text_parts.extend([
+                section,
+                str(sec.get('required_content') or ''),
+                str(sec.get('subsection') or ''),
+            ])
+            for child in sec.get('subsections') or []:
+                if isinstance(child, dict):
+                    text_parts.extend([str(child.get('subsection') or ''), str(child.get('required_content') or '')])
+                else:
+                    text_parts.append(str(child or ''))
+        text = ' '.join(text_parts).lower()
+        if not text.strip():
+            return []
+        queries = []
+        if re.search(r'interview|qualitative|case study|coding|thematic|process analys|triangulat|reflexiv|gioia|grounded theor', text):
+            queries.extend([
+                'qualitative case study methodology',
+                'qualitative process analysis methodology',
+                'qualitative triangulation reflexivity',
+            ])
+        if re.search(r'regression|structural equation|sem\b|pls|mediat|moderation|bootstrap|reliab|validity|factor analys|panel data', text):
+            queries.extend([
+                'structural equation modeling methodology',
+                'bootstrap mediation methodology',
+                'measurement validity methodology',
+            ])
+        if not queries:
+            queries.append('empirical research design methodology')
+        return list(dict.fromkeys(queries))[:3]
+
     def prefetch_jit_literature(self, topic, keywords, structure):
+        """Retrieve a dedicated methodology-authority lane without an LLM query call."""
         jit_rag_texts = []
-        queries_to_fetch = set()
-        
-        for sec in structure:
-            sec_title = sec.get("section", "")
-            if any(kw in sec_title.lower() for kw in ["method", "methodology", "analysis", "result", "finding", "setting"]):
-                jit_prompt = f"Topic: '{topic}'. Keywords: '{keywords}'. Section: '{sec_title}'. Generate exactly 1 highly specific English search query (e.g., a specific statistical method, measurement scale, or analytical framework needed). Keep it UNDER 5 terms. NO complex boolean logic. Return ONLY the query string, no quotes."
-                query = self.call_deepseek("You are an expert academic librarian.", jit_prompt, max_tokens=50, temp=0.2, model_role="fast").strip(' "\'')
-                if query:
-                    queries_to_fetch.add(query)
-
+        queries_to_fetch = self._method_authority_queries(structure)
         if not queries_to_fetch:
             return ""
-
-        logging.info(f"🔍 [Pre-fetch JIT] 生成了 {len(queries_to_fetch)} 个定向检索词: {queries_to_fetch}")
-        
+        logging.info("METHOD_AUTHORITY retrieval | queries=%s", queries_to_fetch)
         with concurrent.futures.ThreadPoolExecutor(max_workers=self.lit_max_workers) as executor:
-            futures = []
+            future_lane = {}
             for query in queries_to_fetch:
-                futures.append(executor.submit(self._s2_worker, query, 0))
-                futures.append(executor.submit(self._oa_worker, query, 1, "language:en,type:article,is_paratext:false"))
-
-            for future in concurrent.futures.as_completed(futures):
+                future_lane[executor.submit(self._s2_worker, query, 0)] = 'method_authority'
+                future_lane[executor.submit(self._oa_worker, query, 1, "language:en,type:article,is_paratext:false")] = 'method_authority'
+            for future in concurrent.futures.as_completed(future_lane):
                 results = future.result()
+                lane = future_lane[future]
                 with self.lock:
                     for res in results:
                         result_keys = self._reference_keys(res)
                         existing_keys = {
-                            key
-                            for metadata in self.citation_map.values()
-                            for key in self._reference_keys(metadata)
+                            key for metadata in self.citation_map.values() for key in self._reference_keys(metadata)
                         }
                         if result_keys and any(key in existing_keys for key in result_keys):
+                            # If already present, promote the existing source to the
+                            # methodology lane without duplicating the reference.
+                            for metadata in self.citation_map.values():
+                                if any(key in self._reference_keys(metadata) for key in result_keys):
+                                    metadata.setdefault('evidence_lanes', [])
+                                    if lane not in metadata['evidence_lanes']:
+                                        metadata['evidence_lanes'].append(lane)
                             continue
                         cite_tag = f"[CITE-{len(self.citation_map)+1:02d}]"
                         self.citation_map[cite_tag] = {
-                            "in_text": res["in_text"],
-                            "ref": res["ref"],
+                            "in_text": res["in_text"], "ref": res["ref"],
                             "id": result_keys[0] if result_keys else ('title_year', res.get('title'), res.get('year')),
-                            "doi": res.get("doi", ""),
-                            "external_id": res.get("external_id", ""),
-                            "title": res.get("title", ""),
-                            "year": res.get("year", ""),
-                            "evidence": res.get("rag_text", ""),
-                            "sources": [res.get("source", "jit")],
+                            "doi": res.get("doi", ""), "external_id": res.get("external_id", ""),
+                            "title": res.get("title", ""), "year": res.get("year", ""),
+                            "evidence": res.get("rag_text", ""), "sources": [res.get("source", "jit")],
+                            "evidence_lanes": [lane],
                         }
                         jit_rag_texts.append(f"{cite_tag} {res.get('rag_text', '')}")
-
-        logging.info(f"✅ [Pre-fetch JIT] 成功抓取并注入了 {len(jit_rag_texts)} 篇底层支撑文献。")
+        logging.info("METHOD_AUTHORITY retrieval complete | accepted=%s", len(jit_rag_texts))
         return "\n".join(jit_rag_texts)
 
     def generate_search_queries(self, topic, keywords):
@@ -2008,6 +2048,36 @@ Return ONLY a valid JSON array of strings."""
                 before_request=self._s2_before_http_attempt,
             )
 
+    @staticmethod
+    def _format_reference_authors(names):
+        """Return deterministic author display data or reject clearly malformed records."""
+        last_names, formatted = [], []
+        for raw in names or []:
+            name = re.sub(r"\s+", " ", str(raw or "")).strip(" ,;")
+            if not name:
+                continue
+            parts = [part.strip(" ,.;") for part in name.split() if part.strip(" ,.;")]
+            if not parts:
+                continue
+            # API metadata occasionally collapses a full author list into initials
+            # (e.g. J., M., J., K.). Such data is not repairable without invention.
+            substantive = [part for part in parts if sum(ch.isalpha() for ch in part) >= 2]
+            if not substantive:
+                continue
+            if sum(ch.isalpha() for ch in parts[-1]) >= 2:
+                last = parts[-1]
+                given = parts[0] if len(parts) > 1 else ""
+            elif sum(ch.isalpha() for ch in parts[0]) >= 2 and len(parts) >= 2:
+                # Bounded support for surname-first metadata such as "Li J".
+                last = parts[0]
+                given = parts[-1]
+            else:
+                continue
+            first_alpha = next((ch for ch in given if ch.isalpha()), "")
+            last_names.append(last)
+            formatted.append(f"{last}, {first_alpha.upper()}." if first_alpha else last)
+        return last_names, formatted
+
     def _s2_worker(self, term, offset):
         # Serialize complete logical searches. This is deliberately separate
         # from the HTTP-attempt gate: OpenAlex can still run concurrently, while
@@ -2084,15 +2154,9 @@ Return ONLY a valid JSON array of strings."""
                 if not title or not year or not self._is_english_dominant(title):
                     continue
                 authors = paper.get('authors') or []
-                last_names, formatted_authors = [], []
-                for author in authors:
-                    name = str(author.get('name') or '').strip()
-                    if not name:
-                        continue
-                    parts = name.split()
-                    last = parts[-1]
-                    last_names.append(last)
-                    formatted_authors.append(f"{last}, {parts[0][0]}." if len(parts) > 1 else last)
+                last_names, formatted_authors = self._format_reference_authors(
+                    [str(author.get('name') or '') for author in authors if isinstance(author, dict)]
+                )
                 if not last_names:
                     continue
                 if len(last_names) == 1:
@@ -2188,14 +2252,10 @@ Return ONLY a valid JSON array of strings."""
                 if not title or not self._is_english_dominant(title):
                     continue
                 year = item.get('publication_year') or 'n.d.'
-                formatted_authors, last_names = [], []
-                for authorship in item.get('authorships') or []:
-                    name = str((authorship.get('author') or {}).get('display_name') or '').strip()
-                    if not name:
-                        continue
-                    parts = name.split(); last = parts[-1]
-                    last_names.append(last)
-                    formatted_authors.append(f"{last}, {parts[0][0]}." if len(parts) > 1 else last)
+                last_names, formatted_authors = self._format_reference_authors([
+                    str((authorship.get('author') or {}).get('display_name') or '')
+                    for authorship in (item.get('authorships') or []) if isinstance(authorship, dict)
+                ])
                 if not formatted_authors:
                     continue
                 if len(last_names) == 1:
@@ -2448,6 +2508,7 @@ Return ONLY a valid JSON array of strings."""
                 'title': str(meta.get('title') or '')[:240],
                 'year': str(meta.get('year') or ''),
                 'evidence': evidence[:900],
+                'evidence_lanes': list(meta.get('evidence_lanes') or []),
             })
         target = min(max(1, int(target_unique)), len(candidates))
         if not candidates:
@@ -2476,7 +2537,8 @@ Return ONLY a valid JSON array of strings."""
             "Use only the supplied title/abstract evidence. Never use a source to support this study's "
             "own sample, coefficients, events, quotations, or findings. Each source may be assigned at "
             "most once. Each planned claim must be narrow enough that the supplied evidence directly "
-            "supports it. Do not manufacture a claim merely to hit a quota. Return only valid JSON."
+            "supports it. Sources marked method_authority may be used only in Methods/Methodology and only "
+            "for methodological rationale, never for this study's own facts. Do not manufacture a claim merely to hit a quota. Return only valid JSON."
         )
 
         for batch_index in range(0, len(candidates), batch_size):
@@ -2547,6 +2609,10 @@ INPUT:
                 if len(self._citation_terms(claim) & self._citation_terms(evidence)) < 2:
                     continue
                 section_meta = next((item for item in sections if item['name'] == section), {})
+                lanes = set((self.citation_map.get(tag) or {}).get('evidence_lanes') or [])
+                if 'method_authority' in lanes and str(section_meta.get('section_id') or '') not in {'methods', 'methodology'}:
+                    logging.info('Citation planner rejected METHOD_AUTHORITY outside methods: section=%s tag=%s', section, tag)
+                    continue
                 section_context = ' '.join([
                     str(topic or ''), section, str(section_meta.get('role') or ''),
                 ])
@@ -2707,6 +2773,32 @@ INPUT:
                 break
         return selected
 
+    def _deterministic_contextual_jit_query(self, topic, section_name, section_context):
+        """Build one bounded section-aware recovery query without a model call."""
+        generic = set(self._CITATION_RECOVERY_GENERIC_TERMS)
+        context_terms = [
+            term for term in sorted(self._citation_terms(section_context))
+            if term not in generic and len(term) >= 3
+        ]
+        topic_terms = [
+            term for term in sorted(self._citation_terms(topic))
+            if term not in generic and len(term) >= 3
+        ]
+        section_terms = [
+            term for term in re.findall(r"[A-Za-z][A-Za-z-]{2,}", str(section_name or '').lower())
+            if term not in generic
+        ]
+        selected = []
+        # Context is authoritative because JIT exists to repair one current unit,
+        # not to broaden the manuscript into another application domain.
+        for term in context_terms + section_terms + topic_terms:
+            normalized = self._normalize_search_query(term)
+            if normalized and normalized not in selected:
+                selected.append(normalized)
+            if len(selected) >= 5:
+                break
+        return ' '.join(selected[:5]) if len(selected) >= 3 else ''
+
     def fetch_contextual_jit_recovery_items(
         self, *, topic, section_name, section_context, needed=1, excluded_tags=None,
     ):
@@ -2722,27 +2814,9 @@ INPUT:
         if needed <= 0:
             return []
         excluded = {str(tag or '').strip() for tag in (excluded_tags or set()) if str(tag or '').strip()}
-        context_words = [
-            term for term in sorted(self._citation_terms(section_context))
-            if term not in self._CITATION_RECOVERY_GENERIC_TERMS
-        ][:12]
-        prompt = (
-            "Generate exactly one concise English academic search query of 3-5 terms. "
-            "It must target the named manuscript unit and must not introduce a different application domain. "
-            "Return only the query.\n"
-            f"Topic: {str(topic or '')[:300]}\nSection: {section_name}\n"
-            f"Context terms: {' '.join(context_words)}"
-        )
-        try:
-            query = self.call_deepseek(
-                'You are a precise academic librarian.', prompt, max_tokens=50, temp=0.1,
-                model_role='fast', thinking=False, allow_fallback=False,
-            ).strip(' "\'')
-            query = self._normalize_search_query(query)
-        except Exception as exc:
-            logging.warning('Contextual citation JIT query generation failed: section=%s error=%s', section_name, type(exc).__name__)
-            return []
+        query = self._deterministic_contextual_jit_query(topic, section_name, section_context)
         if not query:
+            logging.info('Contextual citation JIT skipped: no bounded deterministic query for section=%s', section_name)
             return []
         logging.info('Contextual citation JIT: section=%s query=%r needed=%s', section_name, query, needed)
         results = []
@@ -3161,6 +3235,41 @@ INPUT:
             passages.extend(re.findall(pattern, str(value)))
         return [passage for passage in passages if len(passage.strip()) >= 8]
 
+    @classmethod
+    def _repair_local_discourse_after_citation_removal(cls, original, audited, section_name=''):
+        """Repair only enumeration/ordinal framing after fail-closed sentence removal."""
+        before = str(original or '')
+        value = str(audited or '')
+        if not value or value == before:
+            return value
+        ordinal_words = {'first':1, 'second':2, 'third':3, 'fourth':4, 'fifth':5, 'sixth':6}
+        ordinal_matches = list(re.finditer(r'\bThe\s+(first|second|third|fourth|fifth|sixth)\b', value, flags=re.I))
+        if len(ordinal_matches) < 2:
+            return value
+        nums = [ordinal_words[m.group(1).lower()] for m in ordinal_matches]
+        if nums == list(range(1, len(nums)+1)):
+            return value
+        words = {1:'first',2:'second',3:'third',4:'fourth',5:'fifth',6:'sixth'}
+        index = 0
+        def repl(match):
+            nonlocal index
+            index += 1
+            return 'The ' + words[index]
+        repaired = re.sub(r'\bThe\s+(?:first|second|third|fourth|fifth|sixth)\b', repl, value, flags=re.I)
+        count_words = {'two':2,'three':3,'four':4,'five':5,'six':6}
+        reverse = {2:'two',3:'three',4:'four',5:'five',6:'six'}
+        def count_repl(match):
+            old_n = count_words.get(match.group(1).lower(), 0)
+            noun = match.group(2)
+            if old_n >= max(nums) and len(nums) in reverse:
+                return f"{reverse[len(nums)]} {noun}"
+            return match.group(0)
+        repaired = re.sub(
+            r'\b(two|three|four|five|six)\s+(process\s+domains?|mechanisms?|dimensions?|stages?|patterns?|components?)\b',
+            count_repl, repaired, flags=re.I,
+        )
+        return repaired
+
     def semantic_audit_claim_specific_citations(
         self,
         text,
@@ -3439,6 +3548,14 @@ Return exactly:
         audited = "".join(rebuilt)
         audited = re.sub(r"[ \t]+\n", "\n", audited)
         audited = re.sub(r"\n{3,}", "\n\n", audited).strip()
+        if unsupported:
+            repaired = self._repair_local_discourse_after_citation_removal(text, audited, section_name)
+            if repaired != audited:
+                self._append_citation_audit(
+                    section_name, "repair_local_discourse_framing", audited, repaired,
+                    "Renumbered surviving ordinal/enumeration framing after unsupported claim removal; no external claim added.",
+                )
+                audited = repaired
         violations = self.find_multi_citation_violations(audited)
         if violations:
             raise DeepSeekRequestError(
@@ -4948,6 +5065,114 @@ Output only the repaired section."""
             and "{'numeric':" in message
         )
 
+    _TRANSLATION_NUMERIC_ROLE_PATTERNS = (
+        ('INTERVIEW_COUNT', r'\b(?:interviews?|interview sessions?)\b'),
+        ('PARTICIPANT_COUNT', r'\b(?:participants?|respondents?|informants?)\b'),
+        ('SAMPLE_SIZE', r'\b(?:samples?|sample size|observations?|respondents?)\b'),
+        ('WAVE_COUNT', r'\b(?:waves?)\b'),
+        ('GROUP_COUNT', r'\b(?:groups?|conditions?|arms?)\b'),
+        ('ITEM_COUNT', r'\b(?:items?|questions?|scale items?)\b'),
+        ('CASE_COUNT', r'\b(?:cases?|sites?|organizations?|organisations?)\b'),
+        ('TEAM_COUNT', r'\b(?:teams?)\b'),
+    )
+
+    @classmethod
+    def _translation_numeric_semantic_role(cls, source, start, end, anchor_type):
+        if str(anchor_type or '') not in {'NUMBER', 'QUANTITY'}:
+            return ''
+        text = str(source or '')
+        left = text[max(0, int(start)-36):int(start)]
+        right = text[int(end):min(len(text), int(end)+52)]
+        # Prefer the noun immediately following the quantity ("44 interviews").
+        for role, pattern in cls._TRANSLATION_NUMERIC_ROLE_PATTERNS:
+            if re.match(rf'^[\s,;:()\-]*(?:[A-Za-z-]+\s+)?{pattern}', right, flags=re.I):
+                return role
+        # Then allow bounded noun-before-number constructions ("participants: 38").
+        for role, pattern in cls._TRANSLATION_NUMERIC_ROLE_PATTERNS:
+            if re.search(rf'{pattern}[\s:=,()\-]*$', left, flags=re.I):
+                return role
+        return ''
+
+    @classmethod
+    def _translation_role_lexemes(cls, target_lang, role):
+        lang = str(target_lang or '').lower()
+        lexicons = {
+            'INTERVIEW_COUNT': {
+                'zh': (r'访谈', r'采访'),
+                'ru': (r'интервью', r'бесед'),
+                'kk': (r'сұхбат', r'интервью'),
+            },
+            'PARTICIPANT_COUNT': {
+                'zh': (r'参与者', r'受访者'),
+                'ru': (r'участник', r'респондент', r'информант'),
+                'kk': (r'қатысуш', r'респондент', r'ақпарат беруш'),
+            },
+            'SAMPLE_SIZE': {
+                'zh': (r'样本', r'观测'),
+                'ru': (r'выборк', r'наблюден'),
+                'kk': (r'іріктем', r'таңдам', r'бақыла'),
+            },
+            'WAVE_COUNT': {'zh': (r'轮', r'波'), 'ru': (r'волн', r'этап'), 'kk': (r'толқын', r'кезең')},
+            'GROUP_COUNT': {'zh': (r'组', r'条件'), 'ru': (r'групп', r'услов'), 'kk': (r'топ', r'шарт')},
+            'ITEM_COUNT': {'zh': (r'题项', r'项目', r'条目'), 'ru': (r'пункт', r'элемент', r'вопрос'), 'kk': (r'тармақ', r'элемент', r'сұрақ')},
+            'CASE_COUNT': {'zh': (r'案例', r'个案', r'站点', r'组织'), 'ru': (r'случа', r'кейс', r'организац', r'сайт'), 'kk': (r'жағдай', r'кейс', r'ұйым', r'алаң')},
+            'TEAM_COUNT': {'zh': (r'团队',), 'ru': (r'команд',), 'kk': (r'команда', r'топ')},
+        }
+        key = 'zh' if ('chinese' in lang or '中文' in lang or '简体' in lang) else 'ru' if ('russian' in lang or 'рус' in lang) else 'kk' if ('kazakh' in lang or 'қазақ' in lang) else ''
+        localized = tuple((lexicons.get(str(role or '')) or {}).get(key) or ())
+        english = tuple(pattern for role_key, pattern in cls._TRANSLATION_NUMERIC_ROLE_PATTERNS if role_key == str(role or ''))
+        # Source-language role words are accepted only for role binding. The
+        # independent deterministic lexical-purity Gate still rejects ordinary
+        # English residue in a finished ZH/RU/KK translation.
+        return localized + english
+
+    @classmethod
+    def _translation_semantic_role_matches(cls, target_claim, placeholder, role, target_lang):
+        """Bind each numeric anchor to the nearest recognized quantitative-role noun."""
+        expected = str(role or '')
+        if not cls._translation_role_lexemes(target_lang, expected):
+            return True
+        value = str(target_claim or '')
+        marker = str(placeholder or '')
+        pos = value.find(marker)
+        if pos < 0:
+            return False
+        end = pos + len(marker)
+        # First bind inside the local punctuation-delimited proposition. This
+        # prevents a noun in the following clause (for example after a Chinese
+        # comma) from stealing ownership from a noun-before-number construction
+        # such as ``团队数为20，参与者总数为300``.
+        clause_left = max(
+            value.rfind("，", 0, pos), value.rfind(",", 0, pos),
+            value.rfind("；", 0, pos), value.rfind(";", 0, pos),
+            value.rfind("。", 0, pos), value.rfind(".", 0, pos),
+            value.rfind("\n", 0, pos),
+        ) + 1
+        right_hits = [idx for token in ("，", ",", "；", ";", "。", ".", "\n")
+                      if (idx := value.find(token, end)) >= 0]
+        clause_right = min(right_hits) if right_hits else len(value)
+        window = value[clause_left:clause_right]
+        marker_start = pos - clause_left
+        marker_end = end - clause_left
+        candidates = []
+        for candidate_role, _pattern in cls._TRANSLATION_NUMERIC_ROLE_PATTERNS:
+            for pattern in cls._translation_role_lexemes(target_lang, candidate_role):
+                for match in re.finditer(pattern, window, flags=re.I):
+                    if match.end() <= marker_start:
+                        distance = marker_start - match.end()
+                    elif match.start() >= marker_end:
+                        distance = match.start() - marker_end
+                    else:
+                        distance = 0
+                    candidates.append((distance, candidate_role))
+        if not candidates:
+            # No deterministic role noun is visible. Defer this claim to the
+            # existing semantic QA rather than guessing from script/word order.
+            return True
+        minimum = min(distance for distance, _candidate_role in candidates)
+        nearest_roles = {candidate_role for distance, candidate_role in candidates if distance == minimum}
+        return expected in nearest_roles
+
     @classmethod
     def _protect_translation_tokens(cls, value, claim_id='C000001'):
         """Protect one claim while keeping factual values in a private server ledger."""
@@ -4969,6 +5194,7 @@ Output only the repaired section."""
                 'canonical': cls._translation_fact_canonical(original, anchor_type),
                 'render_policy': cls._translation_fact_render_policy(anchor_type),
                 'claim_id': str(claim_id or 'C000001'),
+                'semantic_role': cls._translation_numeric_semantic_role(source, match.start(), match.end(), anchor_type),
                 # Kept only as diagnostic compatibility; never authoritative.
                 'sentence_index': 0,
             }
@@ -5003,6 +5229,7 @@ Output only the repaired section."""
                     'canonical': cls._translation_fact_canonical(original, anchor_type),
                     'render_policy': cls._translation_fact_render_policy(anchor_type),
                     'claim_id': _claim_id,
+                    'semantic_role': cls._translation_numeric_semantic_role(claim_source, match.start(), match.end(), anchor_type),
                     'sentence_index': 0,
                 }
                 return placeholder
@@ -5022,6 +5249,7 @@ Output only the repaired section."""
                 'fact_id': str(item.get('fact_id') or placeholder),
                 'type': str(item.get('type') or 'IMMUTABLE'),
                 'claim_id': str(item.get('claim_id') or 'C000001'),
+                'semantic_role': str(item.get('semantic_role') or ''),
                 'mobility': 'same_claim',
             })
         return safe
@@ -5039,6 +5267,7 @@ Output only the repaired section."""
                     'type': str(item.get('type') or 'IMMUTABLE'),
                     'canonical': str(item.get('canonical') or item.get('source') or ''),
                     'render_policy': str(item.get('render_policy') or 'exact'),
+                    'semantic_role': str(item.get('semantic_role') or ''),
                 })
         payload = json.dumps(records, ensure_ascii=False, sort_keys=True, separators=(',', ':')).encode('utf-8')
         return hashlib.sha256(payload).hexdigest()
@@ -5212,10 +5441,11 @@ Output only the repaired section."""
         return (
             message.startswith('Translation order-sensitive relation changed')
             or message.startswith('Translation fact order changed')
+            or message.startswith('Translation semantic-role relation changed')
         )
 
     @classmethod
-    def _validate_translation_skeleton(cls, value, mapping, block_id='', claim_sources=None, glossary=None):
+    def _validate_translation_skeleton(cls, value, mapping, block_id='', claim_sources=None, glossary=None, target_lang=''):
         text = str(value or '')
         found = Counter(re.findall(r'\[\[SP-T\d{6}\]\]', text))
         expected = Counter((mapping or {}).keys())
@@ -5240,10 +5470,16 @@ Output only the repaired section."""
         for placeholder, raw_manifest in (mapping or {}).items():
             manifest = raw_manifest if isinstance(raw_manifest, dict) else {'type':'IMMUTABLE'}
             claim_id = str(manifest.get('claim_id') or 'C000001')
-            if placeholder not in str(target_claims.get(claim_id) or ''):
+            target_claim = str(target_claims.get(claim_id) or '')
+            if placeholder not in target_claim:
                 raise DeepSeekRequestError(
                     f'Translation fact moved across claim boundary in {block_id}: {manifest.get("fact_id") or placeholder}.'
                 )
+            role = str(manifest.get('semantic_role') or '')
+            if role and not cls._translation_semantic_role_matches(target_claim, placeholder, role, target_lang):
+                raise DeepSeekRequestError(
+                    f'Translation semantic-role relation changed in {block_id}: {manifest.get("fact_id") or placeholder} role={role}.'
+                )
 
         for claim_id in claim_order:
             target_claim = str(target_claims.get(claim_id) or '')
@@ -5298,7 +5534,7 @@ Output only the repaired section."""
     ):
         text = str(value or '')
         cls._validate_translation_skeleton(
-            text, mapping, block_id, claim_sources=claim_sources, glossary=glossary
+            text, mapping, block_id, claim_sources=claim_sources, glossary=glossary, target_lang=target_lang
         )
         for placeholder, manifest in (mapping or {}).items():
             text = text.replace(placeholder, cls._render_translation_fact(manifest, target_lang))

core/production_guard.py

@@ -532,6 +532,14 @@ def build_evidence_coverage_report(summary: dict[str, Any] | None) -> str:
             lines.append(
                 f"- {section}: validated direct citations={validated}; evidence requirement={required}; externally oriented claims={external_claims}."
             )
+    method = data.get("methodology_authority") or {}
+    if isinstance(method, dict):
+        lines.extend([
+            "",
+            "Methodology-authority coverage:",
+            f"- validated method-authority citations={max(0, int(method.get('validated_method_authority_citations') or 0))}; methodology external claims={max(0, int(method.get('methodology_external_claims') or 0))}.",
+            "- Methodology-authority sources support methodological rationale only; they are not evidence for this study's own sample, procedures, or results.",
+        ])
     if limited:
         lines.extend([
             "",

core/qualitative_engine.py

@@ -335,16 +335,30 @@ Rules:
             # content retries here. Only a completed but locally invalid packet
             # reaches the second attempt.
             if local_attempt == 0:
-                response = "".join(
-                    str(chunk or "")
-                    for chunk in self.agent.stream_deepseek(
-                        system_prompt,
+                reasoning_budget = int((APP_CONFIG.get("prewrite_reasoning_max_tokens") or {}).get("qualitative_packet", 2400))
+                try:
+                    response = "".join(
+                        str(chunk or "")
+                        for chunk in self.agent.stream_deepseek(
+                            system_prompt,
+                            base_prompt,
+                            max_tokens=reasoning_budget,
+                            model_role="reasoning",
+                            thinking=True,
+                            allow_fallback=False,
+                            reasoning_only_recovery=True,
+                        )
+                    )
+                except Exception as exc:
+                    if exc.__class__.__name__ != "DeepSeekReasoningOnlyExhaustionError":
+                        raise
+                    logging.warning("Qualitative packet reasoning-only exhaustion; switching once to direct final-output mode.")
+                    response = self.agent.call_deepseek(
+                        system_prompt + "\n\nDIRECT OUTPUT MODE: Produce the complete evidence packet directly without extended hidden reasoning.",
                         base_prompt,
-                        model_role="reasoning",
-                        thinking=True,
-                        allow_fallback=False,
+                        max_tokens=8000, temp=0.0, model_role="reasoning",
+                        thinking=False, allow_fallback=False, response_format={"type": "json_object"},
                     )
-                )
             else:
                 retry_prompt = base_prompt + (
                     "\n\nLOCAL VALIDATION RETRY: The previous completed response failed local "

i18n.py

@@ -351,7 +351,7 @@ TEXTS: dict[str, dict[str, str]] = {
         "qualitative_ready": "✅ 定性材料已准备完成。",
         "core_literature_parsing": "🧠 正在深度解析用户上传的核心文献……",
         "section_complete_progress": "🇬🇧 【{name}】英文完成，翻译任务已进入后台。",
-        "login_title": "SmartPaper 登录",
+        "login_title": "SmartPaper",
         "service_description": "提供中文、英语、俄语、哈萨克语四种语言服务。",
         "secure_login_notice": "安全登录仅支持支付宝 App 扫码。登录后系统对数据加密，保护您的隐私。",
         "secure_login_title": "支付宝安全登录",
@@ -551,7 +551,7 @@ TEXTS: dict[str, dict[str, str]] = {
         "qualitative_ready": "✅ Qualitative materials are ready.",
         "core_literature_parsing": "🧠 Parsing the uploaded core literature in depth…",
         "section_complete_progress": "🇬🇧 English section 【{name}】 complete; translation is running in the background.",
-        "login_title": "Sign in to SmartPaper",
+        "login_title": "SmartPaper",
         "service_description": "Services are available in Chinese, English, Russian, and Kazakh.",
         "secure_login_notice": "Secure sign-in supports the Alipay app only. After sign-in, the system encrypts data to protect your privacy.",
         "secure_login_title": "Secure Sign-in with Alipay",
@@ -751,7 +751,7 @@ TEXTS: dict[str, dict[str, str]] = {
         "qualitative_ready": "✅ Качественные материалы подготовлены.",
         "core_literature_parsing": "🧠 Выполняется углублённая обработка загруженной основной литературы…",
         "section_complete_progress": "🇬🇧 Английский раздел 【{name}】 завершён; перевод выполняется в фоне.",
-        "login_title": "Вход в SmartPaper",
+        "login_title": "SmartPaper",
         "service_description": "Услуги доступны на китайском, английском, русском и казахском языках.",
         "secure_login_notice": "Безопасный вход поддерживается только в приложении Alipay. После входа система шифрует данные для защиты вашей конфиденциальности.",
         "secure_login_title": "Безопасный вход через Alipay",
@@ -951,7 +951,7 @@ TEXTS: dict[str, dict[str, str]] = {
         "qualitative_ready": "✅ Сапалық материалдар дайындалды.",
         "core_literature_parsing": "🧠 Жүктелген негізгі әдебиеттер терең өңделуде…",
         "section_complete_progress": "🇬🇧 【{name}】 ағылшын бөлімі аяқталды; аударма фондық режимде орындалуда.",
-        "login_title": "SmartPaper жүйесіне кіру",
+        "login_title": "SmartPaper",
         "service_description": "Қызмет қытай, ағылшын, орыс және қазақ тілдерінде қолжетімді.",
         "secure_login_notice": "Қауіпсіз кіру тек Alipay қолданбасы арқылы жүзеге асырылады. Кіргеннен кейін жүйе құпиялылығыңызды қорғау үшін деректерді шифрлайды.",
         "secure_login_title": "Alipay арқылы қауіпсіз кіру",

smartpaper_restore_bridge/frontend/index.html

@@ -29,12 +29,71 @@
   let lastPreviewText = "";
   let lastTargetPreviewText = "";
   let pageExitCancelCleanup = null;
+  const ownedShadowHosts = new WeakSet();
   const renderChannels = {
     english:{ authoritative:"", displayed:"", queue:[], timer:null },
     target:{ authoritative:"", displayed:"", queue:[], timer:null }
   };
 
 
+  const LIVE_HOST_BY_ID = Object.freeze({
+    "sp-live-progress-wrap":"sp-live-monitor",
+    "sp-live-progress-text":"sp-live-monitor",
+    "sp-live-progress-fill":"sp-live-monitor",
+    "sp-live-status":"sp-live-monitor",
+    "sp-live-node":"sp-live-monitor",
+    "sp-live-checkpoint-stage":"sp-live-monitor",
+    "sp-live-checkpoint-seq":"sp-live-monitor",
+    "sp-live-evidence-warning":"sp-live-monitor",
+    "sp-live-activity-feed":"sp-live-monitor",
+    "sp-live-ds":"sp-live-monitor",
+    "sp-live-s2":"sp-live-monitor",
+    "sp-live-oa":"sp-live-monitor",
+    "sp-live-manuscript-status":"sp-live-manuscript-shell",
+    "sp-live-manuscript-preview":"sp-live-manuscript-shell",
+    "sp-live-manuscript-cursor":"sp-live-manuscript-shell",
+    "sp-live-translation-status":"sp-live-translation-shell",
+    "sp-live-translation-preview":"sp-live-translation-shell",
+    "sp-live-translation-cursor":"sp-live-translation-shell"
+  });
+
+  function ensureOwnedShadow(parentDocument, hostId) {
+    const host = parentDocument && parentDocument.getElementById ? parentDocument.getElementById(hostId) : null;
+    if (!host) return null;
+    let root = host.shadowRoot;
+    if (!root) {
+      try {
+        root = host.attachShadow({mode:"open"});
+        root.innerHTML = host.innerHTML;
+        ownedShadowHosts.add(host);
+        recordNavDiagnostic("live_shadow_owner_mounted", {host:String(hostId || "").slice(0,80)});
+      } catch (_) { return null; }
+    }
+    return root;
+  }
+
+  function liveGetById(parentDocument, id) {
+    const hostId = LIVE_HOST_BY_ID[String(id || "")];
+    if (hostId) {
+      const root = ensureOwnedShadow(parentDocument, hostId);
+      const node = root && root.getElementById ? root.getElementById(id) : null;
+      if (node) return node;
+    }
+    return parentDocument && parentDocument.getElementById ? parentDocument.getElementById(id) : null;
+  }
+
+  function liveRootForHost(parentDocument, hostId) {
+    return ensureOwnedShadow(parentDocument, hostId);
+  }
+
+  function recordPreviewDiagnostic(code, detail={}) {
+    const safe = { code:String(code || "preview_error").slice(0,80) };
+    if (detail && Number.isFinite(Number(detail.http_status))) safe.http_status = Number(detail.http_status);
+    if (detail && typeof detail.stage === "string") safe.stage = detail.stage.slice(0,80);
+    recordNavDiagnostic("preview_transport", safe);
+  }
+
+
   function readSessionJson(key, fallback=null) {
     try {
       const raw = window.sessionStorage.getItem(key);
@@ -271,12 +330,12 @@
   }
 
   function updateText(parentDocument, id, value) {
-    const element = parentDocument.getElementById(id);
+    const element = liveGetById(parentDocument, id);
     if (element) element.textContent = String(value ?? "");
   }
 
   function appendTaskActivity(parentDocument, text, complete=false) {
-    const feed = parentDocument.getElementById("sp-live-activity-feed");
+    const feed = liveGetById(parentDocument, "sp-live-activity-feed");
     const value = String(text || "").trim();
     if (!feed || !value) return;
     const row = parentDocument.createElement("div");
@@ -362,7 +421,7 @@
   }
 
   function updateEvidenceWarning(parentDocument, payload, labels) {
-    const node = parentDocument.getElementById("sp-live-evidence-warning");
+    const node = liveGetById(parentDocument, "sp-live-evidence-warning");
     if (!node) return;
     const status = String(payload && payload.evidence_status || "").trim().toLowerCase();
     const map = labels && typeof labels === "object" ? labels : {};
@@ -376,7 +435,7 @@
   }
 
   function updateDraftPreparation(parentDocument, node, labels, task=null) {
-    const status = parentDocument.getElementById("sp-live-manuscript-status");
+    const status = liveGetById(parentDocument, "sp-live-manuscript-status");
     const channel = renderChannels.english;
     if (!status) return;
     if (channel.authoritative) {
@@ -402,9 +461,10 @@
 
   function ensureTargetStatusNode(parentDocument) {
     const shell = parentDocument.getElementById("sp-live-translation-shell");
-    const target = parentDocument.getElementById("sp-live-translation-preview");
-    if (!shell || !target) return null;
-    let status = parentDocument.getElementById("sp-live-translation-status");
+    const root = liveRootForHost(parentDocument, "sp-live-translation-shell");
+    const target = liveGetById(parentDocument, "sp-live-translation-preview");
+    if (!shell || !root || !target) return null;
+    let status = liveGetById(parentDocument, "sp-live-translation-status");
     if (!status) {
       status = parentDocument.createElement("div");
       status.id = "sp-live-translation-status";
@@ -423,13 +483,13 @@
       status.style.zIndex = "1";
       status.style.background = "#ffffff";
       status.style.display = "none";
-      shell.insertBefore(status, target);
+      root.insertBefore(status, target);
     }
     return status;
   }
 
   function updateTargetPreparation(parentDocument, payload, labels) {
-    const target = parentDocument.getElementById("sp-live-translation-preview");
+    const target = liveGetById(parentDocument, "sp-live-translation-preview");
     const channel = renderChannels.target;
     if (!target) return;
     const map = labels && typeof labels === "object" ? labels : {};
@@ -610,7 +670,7 @@
     const commit = normalizePreviewDisplay(commitText);
     if (!commit) return;
     const channel = renderChannels.english;
-    const target = parentDocument.getElementById("sp-live-manuscript-preview");
+    const target = liveGetById(parentDocument, "sp-live-manuscript-preview");
     const shell = parentDocument.getElementById("sp-live-manuscript-shell");
     if (!target || !shell) return;
     if (channel.displayed.startsWith(commit)) return;
@@ -639,7 +699,7 @@
   }
 
   function updateOnePreview(parentDocument, parentWindow, id, shellId, text, channel) {
-    const target = parentDocument.getElementById(id);
+    const target = liveGetById(parentDocument, id);
     const shell = parentDocument.getElementById(shellId);
     if (!target || !shell || !text) return;
     if (shell.dataset.spScrollGuard !== "1") {
@@ -664,7 +724,7 @@
     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");
+      const englishStatus = liveGetById(parentDocument, "sp-live-manuscript-status");
       if (englishStatus) {
         englishStatus.textContent = "";
         englishStatus.style.display = "none";
@@ -686,13 +746,32 @@
       const response = await fetch(watch.previewUrl + `?t=${Date.now()}`, {
         method:"GET", cache:"no-store", credentials:"same-origin", headers:{"Accept":"application/json"}
       });
-      if (!response.ok) return;
-      const payload = await response.json();
-      if (!payload || String(payload.task_id || "") !== watch.taskId) return;
+      if (!response.ok) {
+        recordPreviewDiagnostic("HTTP_STATUS", {http_status:response.status});
+        return;
+      }
+      let payload;
+      try { payload = await response.json(); }
+      catch (_) { recordPreviewDiagnostic("INVALID_JSON", {http_status:response.status}); return; }
+      if (!payload || String(payload.task_id || "") !== watch.taskId) {
+        recordPreviewDiagnostic("TASK_ID_MISMATCH");
+        return;
+      }
       const epoch = asCount(payload.execution_epoch);
-      if (watch.expectedEpoch > 0 && epoch !== watch.expectedEpoch) return;
+      if (watch.expectedEpoch > 0 && epoch !== watch.expectedEpoch) {
+        recordPreviewDiagnostic("EXECUTION_EPOCH_MISMATCH");
+        return;
+      }
+      const requestHash = String(payload.request_hash || "").trim().toLowerCase();
+      if (watch.expectedRequestHash && requestHash !== watch.expectedRequestHash) {
+        recordPreviewDiagnostic("REQUEST_HASH_MISMATCH");
+        return;
+      }
       updateManuscriptPreview(payload, watch);
-    } catch (_) {}
+      recordPreviewDiagnostic("OK", {http_status:response.status, stage:String(payload.stage || "")});
+    } catch (_) {
+      recordPreviewDiagnostic("FETCH_FAILED");
+    }
   }
 
   function updateTaskMonitor(task, watch=null) {
@@ -718,7 +797,7 @@
     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}% — ${nodeLabel}`);
-    const fill = parentDocument.getElementById("sp-live-progress-fill");
+    const fill = liveGetById(parentDocument, "sp-live-progress-fill");
     if (fill) fill.style.width = `${progress}%`;
     updateDraftPreparation(parentDocument, node, labels, task);
 
@@ -744,59 +823,13 @@
   }
 
   function installPageExitCancel(watch) {
+    // R4-R1: browser lifecycle events are observability only. Explicit Cancel
+    // owns cancellation; refresh/tab close/pagehide must never stop the
+    // independent Executor or consume a second reservation on reattach.
     removePageExitCancel();
-    if (!watch || !watch.bestEffortPageExitCancel) return;
-    let parentWindow;
-    try { parentWindow = window.parent; } catch (_) { return; }
-    let sent = false;
-    let suppressForReload = false;
-    const navigationHandler = (event) => {
-      if (event && String(event.navigationType || "") === "reload") suppressForReload = true;
-    };
-    const keyHandler = (event) => {
-      const key = String(event && event.key || "").toLowerCase();
-      if (key === "f5" || ((event.ctrlKey || event.metaKey) && key === "r")) suppressForReload = true;
-    };
-    try {
-      if (parentWindow.navigation && typeof parentWindow.navigation.addEventListener === "function") {
-        parentWindow.navigation.addEventListener("navigate", navigationHandler);
-      }
-      parentWindow.addEventListener("keydown", keyHandler, true);
-    } catch (_) {}
-    const handler = (event) => {
-      if (event && event.persisted) return;
-      if (suppressForReload) return;
-      if (sent || activeTaskWatch !== watch || watch.stopped) return;
-      sent = true;
-      const url = new URL(ACTION_PATHS.task_cancel, watch.apiOrigin).toString();
-      const body = JSON.stringify({ task_id:watch.taskId });
-      let beaconSent = false;
-      try {
-        if (parentWindow.navigator && typeof parentWindow.navigator.sendBeacon === "function") {
-          const blob = new Blob([body], { type:"application/json" });
-          beaconSent = parentWindow.navigator.sendBeacon(url, blob);
-        }
-      } catch (_) {}
-      if (!beaconSent) {
-        try {
-          parentWindow.fetch(url, {
-            method:"POST", credentials:"include", cache:"no-store", keepalive:true,
-            headers:{ "Accept":"application/json", "Content-Type":"application/json", "X-SmartPaper-Client":"browser-exit-v1" },
-            body
-          }).catch(() => {});
-        } catch (_) {}
-      }
-    };
-    parentWindow.addEventListener("pagehide", handler, { capture:true });
-    pageExitCancelCleanup = () => {
-      parentWindow.removeEventListener("pagehide", handler, { capture:true });
-      parentWindow.removeEventListener("keydown", keyHandler, true);
-      try {
-        if (parentWindow.navigation && typeof parentWindow.navigation.removeEventListener === "function") {
-          parentWindow.navigation.removeEventListener("navigate", navigationHandler);
-        }
-      } catch (_) {}
-    };
+    if (watch && watch.bestEffortPageExitCancel) {
+      recordNavDiagnostic("page_exit_cancel_ignored", { reason:"explicit_cancel_only" });
+    }
   }
 
   function stopTaskWatch() {
@@ -822,6 +855,7 @@
     const previewIntervalMs = Math.max(400, Math.min(2500, Number.isFinite(requestedPreviewInterval) ? requestedPreviewInterval : 700));
     const resolvedPreviewUrl = previewUrl(payload.preview_path || "");
     const expectedEpoch = asCount(payload.expected_execution_epoch);
+    const expectedRequestHash = String(payload.expected_request_hash || "").trim().toLowerCase();
     const initialCheckpointSeq = asCount(payload.initial_checkpoint_seq);
     if (!apiOrigin || !taskId) {
       sendValue({ ok:false, action:"task_watch", command_id:commandId, error:"invalid_task_watch" });
@@ -831,7 +865,7 @@
     const draftStatusLabels = payload.draft_status_labels && typeof payload.draft_status_labels === "object" ? payload.draft_status_labels : {};
     const targetStatusLabels = payload.target_status_labels && typeof payload.target_status_labels === "object" ? payload.target_status_labels : {};
     const bestEffortPageExitCancel = payload.best_effort_page_exit_cancel === true;
-    const watch = { commandId, taskId, apiOrigin, intervalMs, previewIntervalMs, previewUrl:resolvedPreviewUrl, expectedEpoch, draftStatusLabels, targetStatusLabels, bestEffortPageExitCancel, timer:null, previewTimer:null, controller:null, stopped:false, lastCheckpointSeq:initialCheckpointSeq };
+    const watch = { commandId, taskId, apiOrigin, intervalMs, previewIntervalMs, previewUrl:resolvedPreviewUrl, expectedEpoch, expectedRequestHash, draftStatusLabels, targetStatusLabels, bestEffortPageExitCancel, timer:null, previewTimer:null, controller:null, stopped:false, lastCheckpointSeq:initialCheckpointSeq };
     activeTaskWatch = watch;
     recordNavDiagnostic("task_watch_start");
     installPageExitCancel(watch);