Step 4A-6-C-R3.2.6 S2 Recovery Flicker-Free Streaming Citation-First AMJ-ASQ Prompt Upgrade

.streamlit/config.toml

@@ -1,4 +1,5 @@
 [server]
+enableStaticServing = true
 enableCORS = false
 enableXsrfProtection = false
 enableWebsocketCompression = false

app.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 """SmartPaper R3-Free UI: Streamlit is an observer, never the paper executor."""
 import hashlib
+import html
 import json
 import logging
 import os
@@ -41,6 +42,9 @@ st.set_page_config(
 
 WORKSPACE_DIR = APP_CONFIG.get("workspace_dir", ".workspace")
 os.makedirs(WORKSPACE_DIR, exist_ok=True)
+# The display-only preview cache must exist from the first Streamlit script run.
+# Runtime preview files remain ephemeral and carry no task/execution authority.
+(Path(__file__).resolve().parent / "static" / "previews").mkdir(parents=True, exist_ok=True)
 os.environ["STREAMLIT_SERVER_ENABLE_CORS"] = "false"
 os.environ["STREAMLIT_SERVER_ENABLE_XSRF_PROTECTION"] = "false"
 
@@ -301,6 +305,21 @@ def _task_dir(task_id: str) -> Path:
     return Path(_user_workspace) / "tasks" / _safe_key(task_id)
 
 
+def _task_preview_path(task_id: str) -> str:
+    """Return the unguessable local static preview URL for this task, if any."""
+    request_path = _task_dir(task_id) / "request.json"
+    if not request_path.is_file():
+        return ""
+    try:
+        payload = json.loads(request_path.read_text(encoding="utf-8"))
+        token = str(payload.get("preview_token") or "").strip()
+        if not re.fullmatch(r"[A-Za-z0-9_-]{32,128}", token):
+            return ""
+        return f"/app/static/previews/{token}.json"
+    except Exception:
+        return ""
+
+
 def _task_output_path(task: dict) -> Path | None:
     task_id = str(task.get("task_id") or "").strip()
     filename = os.path.basename(str(task.get("output_filename") or "").strip())
@@ -356,6 +375,9 @@ def _persist_task_request(task: dict, mode: str, lang_code: str) -> dict:
         "topic": str(st.session_state.get("sp_topic") or DEFAULT_TOPIC),
         "keywords": str(st.session_state.get("sp_keywords") or DEFAULT_KEYWORDS),
         "target_words": int(st.session_state.get("sp_words") or APP_CONFIG["target_words_default"]),
+        # High-entropy, display-only token. It is part of the immutable task
+        # request/hash, but it grants no Worker/D1 authority.
+        "preview_token": secrets.token_urlsafe(32),
         "reference_files": refs,
         "data_files": data,
         "interview_files": interviews,
@@ -612,10 +634,10 @@ def _render_monitor_box(task: dict, lang_code: str) -> None:
 def _watch_task_status_live(task: dict) -> dict | None:
     """Start browser-only read polling for live UI state.
 
-    DOM updates remain read-only and never participate in task liveness. A
-    Streamlit boundary is emitted only when a durable checkpoint advances or a
-    terminal/resumable state appears. Checkpoint boundaries let the UI reveal
-    newly completed manuscript text without periodic full-page reruns.
+    DOM updates remain read-only and never participate in task liveness.
+    During execution, progress and manuscript preview updates stay entirely in
+    the browser; Streamlit is notified only once at terminal/resumable state.
+    This prevents checkpoint-driven full-page reruns and visible flicker.
     """
     task_id = str(task.get("task_id") or "").strip()
     status = str(task.get("status") or "")
@@ -633,6 +655,9 @@ def _watch_task_status_live(task: dict) -> dict | None:
             payload={
                 "task_id": task_id,
                 "poll_interval_ms": 2000,
+                "preview_interval_ms": 700,
+                "preview_path": _task_preview_path(task_id),
+                "expected_execution_epoch": int(task.get("execution_epoch") or 0),
                 "initial_checkpoint_seq": int(task.get("checkpoint_seq") or 0),
             },
             key=f"sp_task_watch_{_safe_key(task_id)}",
@@ -641,8 +666,6 @@ def _watch_task_status_live(task: dict) -> dict | None:
         if isinstance(boundary_task, dict) and str(boundary_task.get("task_id") or "") == task_id:
             st.session_state["sp_generation_task"] = dict(boundary_task)
             st.session_state["sp_last_ui_task_status"] = str(boundary_task.get("status") or "")
-            if str(watch_result.get("boundary_type") or "") == "checkpoint":
-                st.session_state["sp_scroll_to_generation_action"] = True
             return dict(boundary_task)
     except Exception as exc:
         logging.warning("[SP_UI] live_watch_error task_id=%s error=%s", task_id, type(exc).__name__)
@@ -679,15 +702,21 @@ def _load_confirmed_checkpoint(task: dict) -> dict | None:
 
 
 def _render_checkpoint_preview(task: dict, lang_code: str) -> None:
-    """Show the durable English draft accumulated through the latest checkpoint."""
+    """Render one stable DOM target; browser preview updates mutate it in place."""
     checkpoint = _load_confirmed_checkpoint(task)
-    if not checkpoint:
-        return
-    draft = str(checkpoint.get("full_draft_en") or "").strip()
-    if not draft:
-        return
+    draft = str((checkpoint or {}).get("full_draft_en") or "").strip()
+    escaped = html.escape(draft)
     st.markdown(tr(lang_code, "english_draft"))
-    st.markdown(draft)
+    st.markdown(
+        f"""
+        <div id='sp-live-manuscript-shell' style='border:1px solid #e5e7eb;border-radius:8px;padding:14px 16px;min-height:180px;max-height:68vh;overflow:auto;background:#ffffff;'>
+          <div id='sp-live-manuscript-preview' style='white-space:pre-wrap;overflow-wrap:anywhere;margin:0;font-family:inherit;line-height:1.72;color:#111827;'>{escaped}</div>
+          <span id='sp-live-manuscript-cursor' aria-hidden='true' style='display:inline-block;width:7px;height:1.05em;background:#111827;margin-left:2px;vertical-align:-0.12em;animation:spBlink 1s steps(1,end) infinite;'></span>
+        </div>
+        <style>@keyframes spBlink {{ 0%,49% {{opacity:1}} 50%,100% {{opacity:0}} }}</style>
+        """,
+        unsafe_allow_html=True,
+    )
 
 
 def _render_task_status_once(lang_code: str) -> None:
@@ -759,11 +788,33 @@ def _inject_generation_action_scroll(mode: str) -> None:
 
 
 def _scroll_to_generation_action_once() -> None:
-    """One-time post-launch/resume/checkpoint scroll to the generation action."""
+    """One-time post-launch/resume scroll to the live manuscript, never per checkpoint."""
     if not bool(st.session_state.get("sp_scroll_to_generation_action")):
         return
     st.session_state["sp_scroll_to_generation_action"] = False
-    _inject_generation_action_scroll(str(st.session_state.get("run_mode") or "amj"))
+    mode = str(st.session_state.get("run_mode") or "amj")
+    fallback_id = "sp-generation-action-asq" if mode.lower() == "asq" else "sp-generation-action-amj"
+    components.html(
+        f"""
+        <script>
+        (() => {{
+          const parentDocument = window.parent.document;
+          const fallbackId = {json.dumps(fallback_id)};
+          let done = false;
+          const locate = () => {{
+            if (done) return;
+            const target = parentDocument.getElementById('sp-live-manuscript-shell') || parentDocument.getElementById(fallbackId);
+            if (!target) return;
+            done = true;
+            target.scrollIntoView({{behavior:'auto', block:'center'}});
+          }};
+          [0, 40, 100, 220, 450, 800].forEach((delay) => window.parent.setTimeout(locate, delay));
+        }})();
+        </script>
+        """,
+        height=0,
+        width=0,
+    )
 
 
 def render_workspace_controls(user):

config.py

@@ -201,13 +201,13 @@ def load_config():
             {
                 "section_id": "introduction",
                 "section": "Introduction",
-                "weight": 0.10,
+                "weight": 0.11,
                 "subsections": [],
             },
             {
                 "section_id": "theory",
                 "section": "Theoretical Background and Hypotheses",
-                "weight": 0.27,
+                "weight": 0.25,
                 "subsections": [
                     {"subsection_id": "conceptual_background", "title": "Conceptual Background and Research Gap", "share": 0.23},
                     {"subsection_id": "theoretical_mechanisms", "title": "Theoretical Mechanisms", "share": 0.27},
@@ -218,7 +218,7 @@ def load_config():
             {
                 "section_id": "methodology",
                 "section": "Methodology",
-                "weight": 0.20,
+                "weight": 0.19,
                 "subsections": [
                     {"subsection_id": "research_design", "title": "Research Design and Context", "share": 0.18},
                     {"subsection_id": "sample_data", "title": "Sample and Data Collection", "share": 0.20},
@@ -230,7 +230,7 @@ def load_config():
             {
                 "section_id": "results",
                 "section": "Results",
-                "weight": 0.23,
+                "weight": 0.17,
                 "subsections": [
                     {"subsection_id": "measurement_results", "title": "Descriptive Statistics and Measurement Assessment", "share": 0.34},
                     {"subsection_id": "hypothesis_results", "title": "Hypothesis and Association Tests", "share": 0.46},
@@ -240,7 +240,7 @@ def load_config():
             {
                 "section_id": "discussion",
                 "section": "Discussion",
-                "weight": 0.15,
+                "weight": 0.24,
                 "subsections": [
                     {"subsection_id": "interpretation", "title": "Interpretation of the Findings", "share": 0.30},
                     {"subsection_id": "theoretical_contributions", "title": "Theoretical Contributions", "share": 0.30},
@@ -251,7 +251,7 @@ def load_config():
             {
                 "section_id": "conclusion",
                 "section": "Conclusion",
-                "weight": 0.05,
+                "weight": 0.04,
                 "subsections": [],
             },
         ],
@@ -265,7 +265,7 @@ def load_config():
             {
                 "section_id": "theoretical_framing",
                 "section": "Theoretical Framing",
-                "weight": 0.18,
+                "weight": 0.15,
                 "subsections": [
                     {"subsection_id": "phenomenon_puzzle", "title": "Phenomenon and Theoretical Puzzle", "share": 0.35},
                     {"subsection_id": "conceptual_tension", "title": "Relevant Literature and Conceptual Tension", "share": 0.40},
@@ -275,7 +275,7 @@ def load_config():
             {
                 "section_id": "methods",
                 "section": "Research Setting and Methods",
-                "weight": 0.17,
+                "weight": 0.16,
                 "subsections": [
                     {"subsection_id": "research_setting", "title": "Research Setting", "share": 0.24},
                     {"subsection_id": "data_collection", "title": "Data Sources and Collection", "share": 0.28},
@@ -286,7 +286,7 @@ def load_config():
             {
                 "section_id": "findings",
                 "section": "Findings",
-                "weight": 0.30,
+                "weight": 0.34,
                 "dynamic_subsections": "qualitative_themes",
                 "subsections": [
                     {"subsection_id": "emergent_model", "title": "Emergent Process Model", "share": 0.18},
@@ -295,7 +295,7 @@ def load_config():
             {
                 "section_id": "discussion",
                 "section": "Discussion",
-                "weight": 0.15,
+                "weight": 0.22,
                 "subsections": [
                     {"subsection_id": "interpretation", "title": "Interpretation of the Emergent Findings", "share": 0.30},
                     {"subsection_id": "theoretical_contributions", "title": "Theoretical Contributions", "share": 0.30},
@@ -306,24 +306,67 @@ def load_config():
             {
                 "section_id": "conclusion",
                 "section": "Conclusion",
-                "weight": 0.05,
+                "weight": 0.03,
                 "subsections": [],
             },
             {
                 "section_id": "appendix",
                 "section": "Appendix: Data Structure and Evidence",
-                "weight": 0.05,
+                "weight": 0.0,
+                "exclude_from_word_budget": True,
                 "subsections": [],
             },
         ],
         "manuscript_validation": {
-            "minimum_total_ratio": 0.85,
-            "maximum_total_ratio": 1.15,
+            "minimum_total_ratio": 0.97,
+            "maximum_total_ratio": 1.03,
             "minimum_section_words": 120,
             "minimum_conclusion_words": 120,
             "minimum_qualitative_themes": 3,
             "minimum_qualitative_quotes": 8,
         },
+        "word_budget": {
+            "front_matter_words": 220,
+            "target_min_ratio": 0.97,
+            "target_max_ratio": 1.03,
+            "section_min_ratio": 0.92,
+            "section_max_ratio": 1.08,
+        },
+        "evidence_integrity_contract": """[EVIDENCE & INTEGRITY CONTRACT]
+1. Treat the frozen research evidence packet as the only source of truth for the study setting, sample, measures, qualitative material, analysis, numerical results, and empirical findings.
+2. Retrieved literature may support external theoretical or methodological claims, but it must never be used as evidence for this study's own sample, coefficients, events, quotations, or findings.
+3. Do not invent a country, organization, university, sample characteristic, instrument, software package, coefficient, p-value, confidence interval, R-squared, fit index, robustness test, interview count, quotation, event, or date that is absent from the frozen evidence.
+4. Theoretical inference is allowed only when it is explicitly framed as interpretation rather than as a new empirical fact.
+5. Causal language must match the design. Association, mediation estimates, temporal process evidence, and experimental identification are not interchangeable.
+6. If evidence is absent, narrow the claim instead of filling the gap with a plausible detail.
+""",
+        "section_reasoning_profiles": {
+            "amj": {
+                "introduction": "Move from an important management problem to a precise theoretical tension, show why the prevailing explanation is incomplete, state the research move, and preview the bounded contribution. Do not front-load results or generic importance claims.",
+                "theory": "Define constructs precisely, develop the mechanism step by step, identify boundaries only when supported, and derive hypotheses from the mechanism. Each paragraph must advance one theoretical job.",
+                "methodology": "Report frozen design facts, justify actual analytical choices, identify validity threats, and state only mitigations or robustness procedures that are present in the evidence packet.",
+                "results": "Report this study's empirical facts without literature decoration. State uncertainty and hypothesis implications. Do not interpret an association as causal identification.",
+                "discussion": "Start from a validated finding, compare it with the prior theoretical expectation, explain the mechanism or boundary that accounts for the pattern, and state the specific theoretical revision. Separate theoretical and practical implications.",
+                "conclusion": "Answer the research question and summarize the bounded theoretical change using only conclusions already established in Results and Discussion. Introduce no new evidence.",
+            },
+            "asq": {
+                "introduction": "Open with the organizational puzzle, establish why existing explanations are insufficient, state the research question, and preview the emergent theoretical payoff without pre-solving the puzzle.",
+                "theoretical_framing": "Use prior theory as sensitizing concepts and a source of tension. Define what remains unexplained without forcing hypotheses or predicting the findings.",
+                "methods": "Describe the frozen setting, data, analytic design, trustworthiness, ethics, and reflexivity. The analytic method must match the selected qualitative design rather than default to Gioia.",
+                "findings": "Move from concrete episode, quotation, or observation to recurring pattern, temporal/process relationship, and emergent mechanism. Keep informant or field evidence central and include deviant evidence when available.",
+                "discussion": "Explain how the emergent mechanism changes, qualifies, or extends prior theory. Distinguish what is grounded in this setting from what may transfer beyond it.",
+                "conclusion": "Resolve the organizational puzzle and state the bounded theoretical contribution without introducing new data, quotations, or claims.",
+                "appendix": "Present the frozen data structure and evidence compactly. Do not use the appendix to add new claims to the manuscript argument.",
+            },
+        },
+        "journal_voice_profiles": {
+            "amj": "Use direct, theoretically dense, broadly intelligible management scholarship. Prefer precise verbs and explicit mechanisms over evaluative adjectives. Avoid contribution-counting templates, generic topic sentences, and repeated summaries.",
+            "asq": "Use coherent phenomenon-driven prose with concrete evidence, temporal continuity, and theoretical depth. Preserve one central argument; avoid formulaic contribution lists, decorative narration, and generic sensemaking language unsupported by the data.",
+        },
+        "top_journal_critic_profiles": {
+            "amj": ["management_problem", "theoretical_tension", "mechanism", "hypothesis_logic", "empirical_fidelity", "theoretical_contribution", "evidence_strength_wording", "citation_support", "concision"],
+            "asq": ["organizational_puzzle", "evidence_richness", "process_logic", "negative_or_deviant_evidence", "mechanism", "theory_data_fit", "theoretical_revision", "coherence"],
+        },
 
         "prompt_templates": {
             "meta_extract": """You are an expert academic data extractor. Read the provided text and extract the core metadata.
@@ -343,7 +386,7 @@ CRITICAL: You MUST output ONLY a valid JSON object. Do not include markdown form
     "context": "<String: Max 10 words, e.g., 'US Tech Industry'>",
     "analysis_tool": "<String: e.g., 'SEM, PLS, OLS'>"
   },
-  "key_findings": "<String: Strict ONE-SENTENCE summary emphasizing causality>",
+  "key_findings": "<String: Strict ONE-SENTENCE summary using causal language only when the design identifies causality>",
   "future_gaps": "<String: Explicit limitations or future directions>"
 }""",
             "synthesis_system": "You are a top-tier academic researcher in Business Administration.",
@@ -367,7 +410,7 @@ Literature Metadata:
     # 定量引擎 (AMJ 风格) - 保持原样，极致严谨与假设推演
     # =====================================================================
     amj_prompts = {
-        "sys_academic_writer": """You are a distinguished, highly cited scholar writing a manuscript for the Academy of Management Journal (AMJ). Your writing must exhibit unparalleled theoretical rigor, causal depth, and academic authority.
+        "sys_academic_writer": """You are a senior management scholar preparing an AMJ-oriented quantitative manuscript. Prioritize theoretical importance, mechanism precision, empirical fidelity, and a clear bounded contribution over status language or stylistic display.
 [CRITICAL LANGUAGE MANDATE]: You MUST generate all responses strictly in ACADEMIC ENGLISH. Even if the user provides topic, data, or context in Chinese or another language, your final output MUST be in English.
 [ABSOLUTE ANTI-AI-TONE MANDATES]:
 1. CRITICAL: NEVER use these cliché AI words: delve into, intricate, paramount, overarching, pivotal, foster, seamlessly, multifaceted, beacon, landscape, underscore, robust.
@@ -375,7 +418,7 @@ Literature Metadata:
 3. NATURAL SYNTAX: Vary sentence structure only where the argument requires it. Avoid artificial short-long sentence alternation and repetitive templates.
 4. ACADEMIC HEDGING: Use strategic hedging (e.g., 'This suggests a tendency toward X, bounded by Y').
 5. NO SWEEPING GENERALIZATIONS: Every sentence must carry specific theoretical weight or empirical fact.
-6. FOCUS ON CAUSALITY: You MUST articulate the exact theoretical mechanism driving the relationship.
+6. MECHANISM WITHOUT OVERCLAIMING: Articulate the theoretical mechanism precisely, but use causal wording only when the research design and frozen evidence justify causal identification.
 7. ACADEMIC REGISTER: Use concise, accurate, and rigorous language. Concepts must be explicit, hierarchy clear, and reasoning logically traceable.
 8. PROHIBITED RHETORIC: Never use metaphors, analogies, rhetorical questions, literary embellishment, or promotional claims.
 9. ABSTRACT DISCIPLINE: In abstracts, report only the minimum numerical evidence needed to convey the main finding; do not crowd the abstract with coefficients or test statistics.
@@ -384,26 +427,25 @@ Literature Metadata:
 """,
         "deep_refinement_directive": "Produce a final, polished section ready for top-tier submission. Ensure flawless logical flow without meta-commentary. Apply claim-specific citation: use at most one [CITE-XX] tag per sentence, never combine sources in one parenthesis, and cite only the single most direct source when multiple sources support the same claim.\n[SELF-REFLECTION]: Before drafting, critically analyze common AI clichés related to this topic and actively suppress them in your output.",
         "deep_synthesis_directive": "Structure this synthesis to expose a critical theoretical tension: Consensus vs Paradox, Competing Perspectives, Theoretical Blind Spot.",
-        "hypothesis_development_directive": "Construct a rigorous causal chain: 1. Base Theory. 2. Mechanism (Mediator logic). 3. Boundary Condition (Moderator logic). 4. Hypothesis Phrasing (italicized).",
-        "methodological_defense_directive": "Write with extreme defensive precision: Justify Contextual Relevance, Detail Endogeneity & Bias Mitigation, Measurement Validity, and Analytical Strategy.",
-        "discussion_depth_directive": "Elevate findings back to grand theory. Explicitly state how the study extends, refines, or challenges named theories. Provide counter-intuitive implications.",
-        "conclusion_anchor_directive": "1. Conceptual Pivot. 2. Mechanism Summary. 3. Call to Action for the next decade.",
-        "anchor_generation_directive": "Generate a STRUCTURED ABSTRACT (max 200 words) mimicking an AMJ abstract, and a CONCLUSION ANCHOR (approx. 150 words). Output format:\n---ABSTRACT---\n...\n---CONCLUSION---\n...",
-        "empirical_data_logic": "Maintain strict adherence to APA 7th edition reporting standards. Include plausible degrees of freedom, exact p-values, confidence intervals, and effect sizes.",
+        "hypothesis_development_directive": "Develop only hypotheses justified by the frozen research design: define the focal constructs, establish the theoretical mechanism, state relevant boundary conditions only when supported, and phrase directional hypotheses without claiming causal identification beyond the design.",
+        "methodological_defense_directive": "Use defensive methodological precision. Report only frozen design facts; justify the analytical choices actually present; distinguish validity threats from mitigations; do not invent endogeneity tests, robustness checks, software, sample details, or statistics.",
+        "discussion_depth_directive": "Interpret the validated findings against prior theoretical expectations. Explain why the pattern matters, what mechanism or boundary it clarifies, and exactly which part of prior theory is extended, refined, bounded, or challenged. Do not manufacture counter-intuitive implications.",
+        "conclusion_anchor_directive": "Derive the conclusion only after the validated Results and Discussion. Restate the research answer, the bounded theoretical change, and the practical implication without introducing new evidence.",
+        "anchor_generation_directive": "Generate a PROVISIONAL RESEARCH LOGIC CONTRACT, not an expected result or conclusion. Identify the management problem, theoretical tension, research move, evidence boundaries, and questions the study may answer. Do not predict findings. Output only the contract.",
+        "empirical_data_logic": "Report only empirical values that appear in the frozen evidence packet. Preserve every coefficient, p-value, confidence interval, degree of freedom, effect size, sample count, and model statistic exactly. Never create a value because it would be statistically plausible.",
     }
 
     # =====================================================================
     # 定性引擎 (ASQ 风格) - 聚焦现象描述、意义建构与语录引用
     # =====================================================================
     asq_prompts = {
-        "sys_academic_writer": """You are a senior editor and distinguished qualitative researcher writing for Administrative Science Quarterly (ASQ). 
-Your writing style is phenomenon-driven, deeply narrative, and theoretically rich.
+        "sys_academic_writer": """You are a senior qualitative management scholar preparing an ASQ-oriented manuscript. The manuscript must be phenomenon-driven, evidence-rich, theoretically consequential, and organized around one central organizational puzzle rather than a generic topic.
 [CRITICAL LANGUAGE MANDATE]: You MUST generate all responses strictly in ACADEMIC ENGLISH. 
 [ABSOLUTE ASQ MANDATES]:
-1. FOCUS ON THE PUZZLE: Embrace counter-intuitive empirical phenomena and paradoxes.
-2. THICK DESCRIPTION: Use descriptive, evocative language to ground your qualitative findings in reality.
-3. SENSEMAKING: Focus on how organizational actors interpret, negotiate, and construct their reality.
-4. NO FORMAL HYPOTHESES: DO NOT use 'Hypothesis 1' phrasing. Use 'Propositions' or conceptual emergent models instead.
+1. FOCUS ON THE PUZZLE: Identify the organizational puzzle or theoretical tension that is actually supported by the frozen evidence. Do not manufacture a paradox merely to make the paper sound surprising.
+2. EVIDENCE-RICH DESCRIPTION: Ground claims in concrete setting, event, actor, quotation, comparison, and temporal detail only when those elements exist in the frozen evidence. Do not add decorative or invented description.
+3. ACTOR/PROCESS LOGIC: Follow interpretation, action, coordination, sequence, comparison, or change as the selected analytic design and evidence warrant. Do not force a sensemaking lens onto every qualitative study.
+4. NO FORMAL HYPOTHESES: Do not use formal hypothesis testing. Use a research question, process/model explanation, or propositions only when the selected qualitative design and evidence warrant them.
 5. NO AI CLICHES: Strictly avoid 'delve', 'tapestry', 'multifaceted', 'beacon', 'landscape'.
 6. ACADEMIC REGISTER: Use concise, accurate, and rigorous language with explicit concepts and logically ordered claims.
 7. PROHIBITED RHETORIC: Never use metaphors, analogies, rhetorical questions, literary embellishment, or promotional claims. Use concrete evidence-based description rather than decorative prose.
@@ -412,11 +454,11 @@ Your writing style is phenomenon-driven, deeply narrative, and theoretically ric
         "deep_refinement_directive": "Ensure logical flow and focus on the emergent theoretical model. Write in continuous, engaging paragraphs. Apply claim-specific citation: use at most one [CITE-XX] tag per sentence, never combine sources in one parenthesis, and cite only the single most direct source when several sources support the same claim.",
         "deep_synthesis_directive": "Structure this synthesis to highlight a critical empirical puzzle or theoretical paradox that qualitative investigation can unravel.",
         "hypothesis_development_directive": "Develop the theoretical framing. DO NOT use formal hypotheses. Detail the conceptual gaps and frame the overarching research questions or theoretical propositions.",
-        "methodological_defense_directive": "Detail the research setting vividly. Justify data sources (interviews, ethnographic observations, archives), and rigorously explain the step-by-step coding process (e.g., Gioia methodology).",
-        "discussion_depth_directive": "Elevate the emergent qualitative findings back to grand theory. Contrast your inductive process model with existing linear or variance-based theories.",
-        "conclusion_anchor_directive": "Summarize the theoretical contribution, the resolution of the empirical puzzle, and the sensemaking implications.",
-        "anchor_generation_directive": "Generate a NARRATIVE ABSTRACT (max 200 words) mimicking an ASQ abstract (focusing on the puzzle, setting, and emergent model), and a CONCLUSION ANCHOR (approx. 150 words). Output format:\n---ABSTRACT---\n...\n---CONCLUSION---\n...",
-        "empirical_data_logic": "Present findings as a compelling narrative. You MUST integrate representative quotes seamlessly into the text to provide raw evidence for each 1st-order concept and 2nd-order theme. Ensure the voice of the informants is central.",
+        "methodological_defense_directive": "Describe only the frozen research setting and data sources. Explain the analytic design actually selected for this study (for example process analysis, comparative case logic, grounded-theory/Gioia-style coding when appropriate) and its trustworthiness procedures without forcing one method onto every qualitative study.",
+        "discussion_depth_directive": "Connect the emergent mechanism or process to prior theory. Show precisely what the evidence changes, qualifies, or newly explains, including negative or deviant evidence when present. Do not force a process-model contrast when the selected qualitative design does not support it.",
+        "conclusion_anchor_directive": "Derive the conclusion only after validated Findings and Discussion. Resolve the organizational puzzle and state the bounded theoretical change without introducing new evidence or forcing sensemaking language.",
+        "anchor_generation_directive": "Generate a PROVISIONAL RESEARCH LOGIC CONTRACT, not an expected finding or conclusion. Identify the organizational puzzle, sensitizing theoretical tension, evidence boundaries, and research question while leaving the empirical resolution open. Output only the contract.",
+        "empirical_data_logic": "Present findings through the selected qualitative analytic design. Integrate frozen representative quotations and other evidence where they directly substantiate a pattern, process, comparison, or mechanism. Do not impose Gioia-style first-order/second-order terminology unless that analytic design was explicitly selected.",
     }
 
     generic_prompts = amj_prompts.copy()

core/__pycache__/pipeline_agent.cpython-313.pyc

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

core/generation_runner.py

@@ -13,6 +13,7 @@ import logging
 import math
 import os
 import re
+import time
 from datetime import datetime, timezone, timedelta
 from pathlib import Path
 from typing import Callable, Any
@@ -30,7 +31,8 @@ from utils.file_parser import extract_text_from_files
 ProgressCallback = Callable[..., None]
 
 MIN_FINAL_REFERENCES = 50
-CITATION_COVERAGE_TARGET = 60
+LITERATURE_EVIDENCE_TARGET = 75
+CITATION_PLAN_TARGET = 70
 
 
 def _clean_trailing_references(text, keywords=("reference", "references", "reference list", "参考文献")):
@@ -76,6 +78,23 @@ class GenerationRunner:
         self.output_dir = self.task_dir / "outputs"
         self.output_dir.mkdir(parents=True, exist_ok=True)
         self.agent = None
+        preview_token = str(self.request.get("preview_token") or "").strip()
+        self.preview_token = preview_token if re.fullmatch(r"[A-Za-z0-9_-]{32,128}", preview_token) else ""
+        self.preview_path = None
+        self._last_preview_write = 0.0
+        if self.preview_token:
+            preview_dir = Path(__file__).resolve().parents[1] / "static" / "previews"
+            preview_dir.mkdir(parents=True, exist_ok=True)
+            self.preview_path = preview_dir / f"{self.preview_token}.json"
+            # Best-effort cleanup of stale display-only previews; task/checkpoint
+            # authority is unaffected by this cache.
+            cutoff = time.time() - 24 * 3600
+            for old_preview in preview_dir.glob("*.json"):
+                try:
+                    if old_preview.stat().st_mtime < cutoff:
+                        old_preview.unlink()
+                except OSError:
+                    pass
 
     def _compute_request_counts(self) -> tuple[int, int, int]:
         """Return UI metrics: DeepSeek requests and eligible literature results."""
@@ -108,8 +127,45 @@ class GenerationRunner:
         self._progress(pct, normalized_stage, checkpoint_seq=seq, checkpoint_stage=normalized_stage)
 
     @staticmethod
-    def _stream_text(generator) -> str:
-        return "".join(str(chunk or "") for chunk in generator)
+    def _preview_visible_text(value: str) -> str:
+        text = str(value or "")
+        # Never expose hidden reasoning; only final manuscript prose is previewed.
+        text = re.sub(r"(?is)<think>.*?(?:</think>|$)", "", text)
+        return text.strip()
+
+    def _publish_preview(self, text: str, stage: str, *, force: bool = False, complete: bool = False) -> None:
+        if self.preview_path is None:
+            return
+        now = time.monotonic()
+        if not force and now - self._last_preview_write < 0.45:
+            return
+        payload = {
+            "task_id": str(self.request.get("task_id") or ""),
+            "request_hash": self.request_hash,
+            "execution_epoch": self.execution_epoch,
+            "stage": str(stage or "")[:240],
+            "text": self._preview_visible_text(text),
+            "complete": bool(complete),
+            "updated_at": datetime.now(timezone.utc).isoformat(),
+        }
+        temporary = self.preview_path.with_suffix(".json.tmp")
+        temporary.write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
+        os.replace(temporary, self.preview_path)
+        self._last_preview_write = now
+
+    def _stream_text(self, generator, *, preview_prefix: str | None = None, preview_stage: str = "") -> str:
+        chunks = []
+        for chunk in generator:
+            value = str(chunk or "")
+            if not value:
+                continue
+            chunks.append(value)
+            if preview_prefix is not None:
+                self._publish_preview(preview_prefix + "".join(chunks), preview_stage, force=False)
+        text = "".join(chunks)
+        if preview_prefix is not None:
+            self._publish_preview(preview_prefix + text, preview_stage, force=True)
+        return text
 
     @staticmethod
     def _bounded_target(base_target: int, accumulated_deviation: float, remaining_including_current: int, safe_chunk: int) -> int:
@@ -122,13 +178,14 @@ class GenerationRunner:
     @staticmethod
     def _english_count_for_target(manuscript: str) -> int:
         body = re.split(r"(?m)^#\s+References\s*$", str(manuscript or ""), maxsplit=1)[0]
+        body = re.split(r"(?m)^#\s+Appendix: Data Structure and Evidence\s*$", body, maxsplit=1)[0]
         # Markdown punctuation is ignored; contractions/hyphenated terms stay one token.
         return len(re.findall(r"\b[A-Za-z0-9]+(?:[-'][A-Za-z0-9]+)*\b", body))
 
     def _validate_target_length(self, manuscript: str, target_words: int) -> None:
         quality = APP_CONFIG.get("manuscript_validation", {})
-        minimum = int(target_words * float(quality.get("minimum_total_ratio", 0.85)))
-        maximum = int(target_words * float(quality.get("maximum_total_ratio", 1.15)))
+        minimum = int(target_words * float(quality.get("minimum_total_ratio", 0.97)))
+        maximum = int(target_words * float(quality.get("maximum_total_ratio", 1.03)))
         actual = self._english_count_for_target(manuscript)
         if actual < minimum or actual > maximum:
             raise RuntimeError(
@@ -191,6 +248,8 @@ class GenerationRunner:
         data_paths = self._resolve_paths(req.get("data_files") or [])
         interview_paths = self._resolve_paths(req.get("interview_files") or [])
 
+        base_evidence_contract = str(APP_CONFIG.get("evidence_integrity_contract") or "")
+
         # Restore agent state before continuing any dependent step.
         if isinstance(state.get("agent_state"), dict):
             agent.load_state(state["agent_state"])
@@ -207,7 +266,9 @@ class GenerationRunner:
                 agent.global_memory["core_golden_metadata"] = extract_golden_metadata(agent, all_paper_texts)
             if mode == "amj":
                 data_file = data_paths[0] if data_paths else None
-                _, user_data_md, _, data_metadata = quant_engine.resolve_empirical_data(data_file, interface_language)
+                _, user_data_md, _, data_metadata = quant_engine.resolve_empirical_data(
+                    data_file, interface_language, topic=topic, keywords=keywords, agent=agent
+                )
             else:
                 raw_interviews = extract_text_from_files(interview_paths[:1]) if interview_paths else ""
                 user_data_md, _, data_metadata = qual_engine.resolve_qualitative_data(topic, keywords, raw_interviews)
@@ -234,7 +295,7 @@ class GenerationRunner:
             refs_text = agent.fetch_references_parallel(
                 topic,
                 keywords,
-                min_required=MIN_FINAL_REFERENCES,
+                min_required=LITERATURE_EVIDENCE_TARGET,
                 progress_callback=lambda: self._progress(9, "S2 + OpenAlex"),
             )
             if len(agent.citation_map) < MIN_FINAL_REFERENCES:
@@ -265,42 +326,54 @@ class GenerationRunner:
 
         adaptive_structure = state.get("adaptive_structure")
         if not isinstance(adaptive_structure, list) or not adaptive_structure:
-            self._progress(14, "anchors_and_outline")
-            anchor_response = self._stream_text(
-                agent.stream_generate_anchors(
+            self._progress(14, "research_logic_and_outline")
+            research_logic_response = self._stream_text(
+                agent.stream_generate_research_logic(
                     topic, keywords, synthesis_result, refs_text,
                     data_evidence=user_data_md, mode=mode,
                 )
             )
-            anchor_clean = re.sub(r"<think>.*?</think>", "", anchor_response, flags=re.DOTALL).strip()
-            abstract_match = re.search(
-                r"-+\s*ABSTRACT\s*-+\s*(.*?)(?=\s*-+\s*CONCLUSION\s*-+|$)",
-                anchor_clean, re.DOTALL | re.IGNORECASE,
-            )
-            conclusion_match = re.search(
-                r"-+\s*CONCLUSION\s*-+\s*(.*?)$", anchor_clean, re.DOTALL | re.IGNORECASE,
-            )
-            abstract_anchor = abstract_match.group(1).strip() if abstract_match else anchor_clean
-            conclusion_anchor = conclusion_match.group(1).strip() if conclusion_match else ""
-            agent.global_memory["abstract_anchor"] = abstract_anchor
-            agent.global_memory["conclusion_anchor"] = conclusion_anchor
+            research_logic_contract = re.sub(
+                r"<think>.*?</think>", "", research_logic_response, flags=re.DOTALL
+            ).strip()
+            if not research_logic_contract:
+                raise RuntimeError("research_logic_contract_missing")
+            agent.global_memory["research_logic_contract"] = research_logic_contract
 
             plan = agent.generate_outline(topic, keywords, mode=mode, data_metadata=data_metadata)
             en_topic = str(plan.get("en_topic", topic))
             structure = plan.get("structure", [])
-            en_abstract_clean = _clean_markdown_headings(
-                re.sub(r"(?i)^abstract[:\s]*", "", str(abstract_anchor)).strip()
-            )
-            full_draft_en = f"# {en_topic}\n\n## Abstract\n{en_abstract_clean}\n\n## Keywords\n{keywords}\n\n"
-            adaptive_structure = agent.build_generation_tasks(structure, target_words, safe_chunk_words)
+            # The final abstract is derived after Results/Findings validation;
+            # do not pre-commit the paper to an expected conclusion.
+            full_draft_en = f"# {en_topic}\n\n## Abstract\n\n## Keywords\n{keywords}\n\n"
+            front_budget = max(180, int(APP_CONFIG.get("word_budget", {}).get("front_matter_words", 220)))
+            body_target_words = max(1000, target_words - front_budget)
+            adaptive_structure = agent.build_generation_tasks(structure, body_target_words, safe_chunk_words)
             for task in adaptive_structure:
                 task["is_first"] = bool(task.get("section_first"))
             jit_texts = agent.prefetch_jit_literature(topic, keywords, adaptive_structure)
             if jit_texts:
                 rag_engine._initialize_chunks([jit_texts])
+            citation_plan = agent.build_claim_evidence_plan(
+                adaptive_structure, topic, synthesis_result, mode=mode, target_unique=CITATION_PLAN_TARGET
+            )
+            planned_unique = {
+                item.get("tag")
+                for items in citation_plan.values()
+                for item in items
+                if item.get("tag")
+            }
+            if len(planned_unique) < MIN_FINAL_REFERENCES:
+                raise RuntimeError(
+                    "Insufficient claim-evidence plan before drafting: "
+                    f"{len(planned_unique)}/{MIN_FINAL_REFERENCES}."
+                )
             state.update(
                 {
                     "adaptive_structure": adaptive_structure,
+                    "citation_plan": citation_plan,
+                    "research_logic_contract": research_logic_contract,
+                    "body_target_words": body_target_words,
                     "full_draft_en": full_draft_en,
                     "full_draft_translated": "",
                     "completed_sections": [],
@@ -310,6 +383,7 @@ class GenerationRunner:
                     "outline_ready": True,
                 }
             )
+            self._publish_preview(full_draft_en, "outline_ready", force=True)
             self._checkpoint("outline_ready", state, 15)
         else:
             full_draft_en = str(state.get("full_draft_en") or "")
@@ -319,22 +393,15 @@ class GenerationRunner:
         completed_sections = list(state.get("completed_sections") or [])
         context_tail = str(state.get("context_tail") or "")
         accumulated_deviation = float(state.get("accumulated_deviation") or 0.0)
-        all_cite_keys = list(agent.citation_map.keys())
-        coverage_cite_keys = all_cite_keys[: min(len(all_cite_keys), CITATION_COVERAGE_TARGET)]
-        valid_chunks = [
-            item for item in adaptive_structure
-            if not any(word in item["section"].lower() for word in ["abstract", "keyword", "appendix"])
-        ]
-        allocation_map: dict[str, list[str]] = {}
-        current_cite_idx = 0
-        for idx, item in enumerate(valid_chunks):
-            count = max(1, math.ceil(len(coverage_cite_keys) / max(1, len(valid_chunks))))
-            allocation_map[item["display_name"]] = (
-                coverage_cite_keys[current_cite_idx:]
-                if idx == len(valid_chunks) - 1
-                else coverage_cite_keys[current_cite_idx:current_cite_idx + count]
+        research_logic_contract = str(
+            state.get("research_logic_contract") or agent.global_memory.get("research_logic_contract") or ""
+        )
+        citation_plan = state.get("citation_plan") if isinstance(state.get("citation_plan"), dict) else {}
+        if not citation_plan:
+            citation_plan = agent.build_claim_evidence_plan(
+                adaptive_structure, topic, synthesis_result, mode=mode, target_unique=CITATION_PLAN_TARGET
             )
-            current_cite_idx += count
+            state["citation_plan"] = citation_plan
 
         total_steps = len(adaptive_structure)
         for sec in adaptive_structure:
@@ -353,16 +420,35 @@ class GenerationRunner:
                 word in sec_title.lower()
                 for word in ["abstract", "keyword", "conclusion", "references", "appendix"]
             )
-            assigned_tag_list = list(allocation_map.get(display_name, []))
-            assigned_tags = ", ".join(assigned_tag_list) or "the single most relevant source"
-            citation_rule = (
-                "NO IN-TEXT CITATIONS ALLOWED IN THIS SECTION."
-                if is_quarantined
-                else "Use claim-specific citation. Each sentence may contain at most one source tag. "
-                     "Use the assigned candidate tags across distinct supported claims whenever their evidence directly applies; "
-                     "never stack sources or cite a source that does not support the sentence. "
-                     f"Assigned candidate tags: {assigned_tags}. <AVAILABLE_CITATIONS>{refs_text}</AVAILABLE_CITATIONS>"
+            planned_items = list(citation_plan.get(display_name, []))
+            assigned_tag_list = [str(item.get("tag") or "") for item in planned_items if item.get("tag")]
+            claim_plan_text = agent.format_claim_evidence_plan(planned_items)
+            section_id = str(sec.get("section_id") or "")
+            section_role = str(
+                APP_CONFIG.get("section_reasoning_profiles", {}).get(mode, {}).get(section_id) or ""
             )
+            mode_directive = ""
+            if section_id in {"theory", "theoretical_framing"}:
+                mode_directive = str(APP_CONFIG.get("hypothesis_development_directive") or "")
+            elif section_id in {"methodology", "methods"}:
+                mode_directive = str(APP_CONFIG.get("methodological_defense_directive") or "")
+            elif section_id == "discussion":
+                mode_directive = str(APP_CONFIG.get("discussion_depth_directive") or "")
+            elif section_id == "conclusion":
+                mode_directive = str(APP_CONFIG.get("conclusion_anchor_directive") or "")
+
+            if is_quarantined or section_id in {"results", "findings"}:
+                citation_rule = (
+                    "NO EXTERNAL LITERATURE CITATIONS ALLOWED IN THIS UNIT. "
+                    "Report only frozen empirical/qualitative evidence and the interpretation permitted by the section role."
+                )
+            else:
+                citation_rule = (
+                    "Use the citation-first claim-evidence plan below. Every listed item has already been assigned to this unit on evidence relevance: use each assigned item exactly once unless it would contradict the frozen research evidence. "
+                    "For each item, write one distinct claim no broader than the supplied evidence and attach exactly its assigned [CITE-XX] tag. "
+                    "Never stack sources, substitute tags, or use literature as evidence for this study's own facts.\n"
+                    f"<CLAIM_EVIDENCE_PLAN>\n{claim_plan_text}\n</CLAIM_EVIDENCE_PLAN>"
+                )
             memory_context = agent._build_memory_context(sec_title, 2500)
             memory_block = f"\n<GLOBAL_MEMORY>\n{memory_context}\n</GLOBAL_MEMORY>\n" if memory_context else ""
             snippets = rag_engine.get_relevant_context(display_name) if rag_engine is not None else ""
@@ -382,38 +468,64 @@ class GenerationRunner:
                     "never use level-4 headings or numbered headings."
                 )
             table_rule = (
-                "Present statistical evidence in standard Markdown tables with plain-text captions."
+                "Present only frozen statistical evidence in standard Markdown tables with plain-text captions."
                 if sec["is_method_or_result"] and mode == "amj" else ""
             )
             concepts = ", ".join(sec.get("concepts") or [])
+            theme_evidence = [item for item in (sec.get("theme_evidence") or []) if isinstance(item, dict)]
+            evidence_labels = []
+            for item in theme_evidence:
+                tag = str(item.get("tag") or "").strip()
+                stage = str(item.get("stage") or "Not specified").strip()
+                role = str(item.get("evidence_role") or "typical").strip()
+                case_label = str(item.get("case_label") or "Not specified").strip()
+                if tag:
+                    evidence_labels.append(f"{tag} [stage={stage}; case={case_label}; role={role}]")
             qualitative_rule = (
-                f"Assigned qualitative concepts: {concepts}. Use only their assigned representative quotations "
-                "and do not repeat a quotation already used elsewhere."
-                if concepts else ""
+                f"Assigned qualitative concepts: {concepts}. Assigned quotation tags: {', '.join(evidence_labels)}. "
+                "Use only these assigned quotation tags in this Findings unit and do not repeat a tag used elsewhere. "
+                "When invoking a quotation, output only its [QUOTE-XX] tag at the exact position; do not reproduce or paraphrase the quotation because the system inserts the frozen verbatim text. "
+                "Preserve any frozen stage/case/deviant role and use deviant evidence to qualify rather than erase the pattern."
+                if concepts or evidence_labels else ""
             )
-            data_injection = (
-                f"\n<RESEARCH_EVIDENCE>\n{user_data_md}\n</RESEARCH_EVIDENCE>\n"
-                if user_data_md and sec["is_method_or_result"] else ""
+            evidence_packet = (
+                f"{base_evidence_contract}\n<FROZEN_RESEARCH_EVIDENCE>\n{user_data_md}\n</FROZEN_RESEARCH_EVIDENCE>"
+                if user_data_md else base_evidence_contract
             )
             completed_label = ", ".join(completed_sections)
             anti_repeat = (
                 f"Already completed: {completed_label}. Do not restate their background, gap, or contribution."
                 if completed_label else ""
             )
-            sys_prompt = APP_CONFIG.get("sys_academic_writer", "") + "\n" + APP_CONFIG.get("deep_refinement_directive", "")
+            voice = str(APP_CONFIG.get("journal_voice_profiles", {}).get(mode) or "")
+            sys_prompt = (
+                APP_CONFIG.get("sys_academic_writer", "") + "\n"
+                + evidence_packet + "\n" + voice + "\n"
+                + APP_CONFIG.get("deep_refinement_directive", "")
+            )
+            word_budget = APP_CONFIG.get("word_budget", {})
+            min_ratio = float(word_budget.get("section_min_ratio", 0.92))
+            max_ratio = float(word_budget.get("section_max_ratio", 1.08))
             user_prompt = f"""Write the assigned English manuscript unit.
 Section: {sec_title}
 Subsection: {subsection or 'None'}
-Target length: {int(adjusted_target * 0.9)}-{int(adjusted_target * 1.1)} words.
+Section reasoning role: {section_role}
+Additional mode directive: {mode_directive}
+Target length: {int(adjusted_target * min_ratio)}-{int(adjusted_target * max_ratio)} words.
 {heading_directive}
 {citation_rule}
 {table_rule}
 {str(sec.get('required_content') or '')}
 {qualitative_rule}
 {anti_repeat}
+<PROVISIONAL_RESEARCH_LOGIC>
+{research_logic_contract}
+</PROVISIONAL_RESEARCH_LOGIC>
 {memory_block}
 Literature synthesis: {synthesis_result}
-{data_injection}
+<FROZEN_RESEARCH_EVIDENCE>
+{user_data_md}
+</FROZEN_RESEARCH_EVIDENCE>
 Previous tail: {context_tail[-2500:]}
 Output only final academic prose. Do not report the word count."""
             if agent._count_tokens(sys_prompt) + agent._count_tokens(user_prompt) > 60000:
@@ -422,11 +534,18 @@ 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)
+            prefix = ""
+            if sec.get("section_first"):
+                prefix += f"# {sec_title}\n\n"
+            if sec.get("subsection_first") and subsection:
+                prefix += f"## {subsection}\n\n"
             en_raw = self._stream_text(
                 agent.stream_deepseek(
                     sys_prompt, user_prompt, max_tokens=7000,
                     model_role="writing", thinking=False, allow_fallback=False,
-                )
+                ),
+                preview_prefix=full_draft_en + prefix,
+                preview_stage=display_name,
             )
             en_raw = re.sub(r"<think>.*?</think>", "", en_raw, flags=re.S).strip()
             en_raw = re.sub(rf"(?im)^#\s*{re.escape(sec_title)}\s*\n+", "", en_raw).strip()
@@ -435,27 +554,62 @@ Output only final academic prose. Do not report the word count."""
             en_raw = re.sub(r"(?m)^(#{2,3})\s+[\d\.\s一二三四五六七八九十、]+\s*(.*)", r"\1 \2", en_raw)
             en_raw = re.sub(r"(?m)^#{4,}\s+(.*)", r"**\1**", en_raw)
             en_raw = re.sub(r"(?m)^#\s+(.+)$", r"## \1", en_raw)
+            en_raw = agent.critique_and_repair_section(
+                en_raw, section_id=section_id, section_name=display_name, mode=mode,
+                evidence_contract=evidence_packet,
+            )
+            en_raw = agent.polish_academic_section(en_raw, display_name, abstract=False, mode=mode)
+            # Keep QUOTE tags immutable through critic/style editing, then bind
+            # each tag to its frozen verbatim quotation exactly once. This
+            # prevents editorial passes from silently paraphrasing evidence.
             if mode == "asq" and user_data_md and "appendix" not in sec_title.lower():
                 quote_dict = {tag: quote for quote, tag in re.findall(r'"([^"]+)"\s*\[(QUOTE-\d+)\]', user_data_md)}
                 for tag, quote in quote_dict.items():
                     en_raw = en_raw.replace(tag, f'"{quote}"')
-            en_raw = agent.polish_academic_section(en_raw, display_name, abstract=False)
             if not is_quarantined and assigned_tag_list:
                 en_raw = agent.reinforce_claim_specific_citation_coverage(
                     en_raw, assigned_tag_list, section_name=display_name
                 )
-            prefix = ""
-            if sec.get("section_first"):
-                prefix += f"# {sec_title}\n\n"
-            if sec.get("subsection_first") and subsection:
-                prefix += f"## {subsection}\n\n"
+            used_before = set(agent.used_citations)
             en_resolved = agent.audit_and_resolve_citations(
                 prefix + en_raw, section_name=display_name, quarantine=is_quarantined
             )
+            used_after = set(agent.used_citations)
+            survived = used_after - used_before
+            if assigned_tag_list and not is_quarantined:
+                required_survival = min(
+                    len(assigned_tag_list),
+                    max(1, int(math.ceil(len(assigned_tag_list) * 0.78))),
+                )
+                if len(survived) < required_survival:
+                    missing_items = [
+                        item for item in planned_items
+                        if str(item.get("tag") or "") not in used_after
+                    ]
+                    needed = max(0, required_survival - len(survived))
+                    supplemental_raw = agent.build_citation_recovery_paragraph(
+                        missing_items[:needed], section_name=display_name
+                    )
+                    if supplemental_raw:
+                        supplemental_resolved = agent.audit_and_resolve_citations(
+                            supplemental_raw,
+                            section_name=f"{display_name} — citation recovery",
+                            quarantine=False,
+                        )
+                        if supplemental_resolved.strip():
+                            en_resolved = en_resolved.rstrip() + "\n\n" + supplemental_resolved.strip()
+                        used_after = set(agent.used_citations)
+                        survived = used_after - used_before
             full_draft_en += en_resolved + "\n\n"
+            if assigned_tag_list:
+                logging.info(
+                    "Citation-first survival: section=%s planned=%s validated_new=%s",
+                    display_name, len(assigned_tag_list), len(survived),
+                )
+            self._publish_preview(full_draft_en, display_name, force=True)
             agent._extract_memory_from_text(en_raw, sec_title)
             context_tail = " ".join(en_raw.split()[-200:])
-            actual_words = len(en_raw.split())
+            actual_words = self._english_count_for_target(en_resolved)
             accumulated_deviation += actual_words - adjusted_target
             completed_sections.append(display_name)
             state.update(
@@ -496,7 +650,17 @@ Output only final academic prose. Do not report the word count."""
                     f"{len(references)}/{MIN_FINAL_REFERENCES}."
                 )
             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)
+            quality = APP_CONFIG.get("manuscript_validation", {})
+            minimum_words = int(target_words * float(quality.get("minimum_total_ratio", 0.97)))
+            maximum_words = int(target_words * float(quality.get("maximum_total_ratio", 1.03)))
+            if actual_words < minimum_words or actual_words > maximum_words:
+                full_draft_en = agent.rebalance_discussion_length(
+                    full_draft_en, target_words=target_words, mode=mode, actual_words=actual_words
+                )
+                agent.validate_manuscript_structure(full_draft_en, adaptive_structure, translated=False)
             self._validate_target_length(full_draft_en, target_words)
+            self._publish_preview(full_draft_en, "english_complete", force=True, complete=True)
             state.update(
                 {
                     "full_draft_en": full_draft_en,

core/pipeline_agent.py

@@ -87,11 +87,22 @@ class SSciPipelineAgent:
                 "last_status_code": None,
                 "last_safe_error": "",
                 "status": "not_started",
+                "key_present": bool(self.s2_key) if source == "s2" else bool(self.openalex_key),
+                "authenticated_status": None,
+                "anonymous_status": None,
+                "access_mode": "key" if source == "s2" and self.s2_key else "anonymous" if source == "s2" else "api",
             }
             for source in ("s2", "oa")
         }
         self._cancel_checker = None
         self._execution_progress_hook = None
+        # S2 authentication recovery is task-local. Never log or persist the key.
+        # "key" means use the configured key, "anonymous" means a 401/403 key
+        # rejection was recovered by an anonymous probe, and "blocked" means
+        # both authenticated and anonymous access were rejected.
+        self._s2_access_mode = "key" if self.s2_key else "anonymous"
+        self._s2_probe_lock = threading.Lock()
+        self._s2_probe_complete = not bool(self.s2_key)
         self.s2_fused = False
         self.oa_fused = False
         self.citation_map = {}
@@ -150,7 +161,7 @@ class SSciPipelineAgent:
         
         self.global_memory = {
             "hypotheses": "", "variables": "", "model_summary": "",
-            "method_summary": "", "abstract_anchor": "", "conclusion_anchor": "",
+            "method_summary": "", "research_logic_contract": "",
             "core_golden_metadata": []
         }
         
@@ -250,7 +261,9 @@ class SSciPipelineAgent:
                 "citation_map": self.citation_map, 
                 "used_citations": list(self.used_citations),
                 "citation_audit_log": list(self.citation_audit_log),
-                "global_memory": self.global_memory
+                "global_memory": self.global_memory,
+                "s2_access_mode": self._s2_access_mode,
+                "s2_probe_complete": bool(self._s2_probe_complete),
             }
 
     def load_state(self, state_dict):
@@ -268,6 +281,10 @@ class SSciPipelineAgent:
             self.used_citations = set(state_dict.get("used_citations", []))
             self.citation_audit_log = list(state_dict.get("citation_audit_log", []))
             self.global_memory = state_dict.get("global_memory", self.global_memory)
+            loaded_mode = str(state_dict.get("s2_access_mode") or "").strip().lower()
+            if loaded_mode in {"key", "anonymous", "blocked"}:
+                self._s2_access_mode = loaded_mode
+            self._s2_probe_complete = bool(state_dict.get("s2_probe_complete", self._s2_probe_complete))
         logging.info(f"🔄 状态恢复成功: DS API={self.ds_calls}, 现有文献={len(self.citation_map)}")
 
     def _requests_get_with_retry(self, url, headers=None, params=None, timeout=None):
@@ -407,57 +424,66 @@ class SSciPipelineAgent:
         memory_parts = []
         lower_sec = section_name.lower() if section_name else ""
         golden_meta = self.global_memory.get("core_golden_metadata", [])
-        
-        if self.global_memory["abstract_anchor"]: 
-            memory_parts.append(f"【PAPER ANCHOR - ABSTRACT】\n{self.global_memory['abstract_anchor']}")
-            
-        is_intro_lit = any(kw in lower_sec for kw in ["introduction", "background", "literature", "theor", "review", "framing"])
+        research_logic = str(self.global_memory.get("research_logic_contract") or "").strip()
+        if research_logic:
+            memory_parts.append(f"【PROVISIONAL RESEARCH LOGIC】\n{research_logic}")
+
+        is_intro_lit = any(
+            kw in lower_sec
+            for kw in ["introduction", "background", "literature", "theor", "review", "framing"]
+        )
         is_method = any(kw in lower_sec for kw in ["method", "measure", "data", "sample", "setting"])
         is_result = any(kw in lower_sec for kw in ["result", "analysis", "finding"])
         is_discussion = any(kw in lower_sec for kw in ["discussion", "conclusion", "implication"])
 
-        if is_intro_lit or is_discussion:
-            if self.global_memory["conclusion_anchor"]: 
-                memory_parts.append(f"【PAPER ANCHOR - EXPECTED CONCLUSION】\n{self.global_memory['conclusion_anchor']}")
-
         if is_method or is_result or is_discussion:
-            if self.global_memory["hypotheses"]: 
+            if self.global_memory["hypotheses"]:
                 memory_parts.append(f"【ESTABLISHED HYPOTHESES】\n{self.global_memory['hypotheses']}")
-            if self.global_memory["variables"]: 
+            if self.global_memory["variables"]:
                 memory_parts.append(f"【CORE CONSTRUCT DEFINITIONS】\n{self.global_memory['variables']}")
-        
+
         if is_method:
-            if self.global_memory["model_summary"]: 
+            if self.global_memory["model_summary"]:
                 memory_parts.append(f"【RESEARCH MODEL】\n{self.global_memory['model_summary']}")
-            if self.global_memory["method_summary"]: 
+            if self.global_memory["method_summary"]:
                 memory_parts.append(f"【METHODOLOGICAL SUMMARY】\n{self.global_memory['method_summary']}")
-        
+
         if isinstance(golden_meta, list) and section_name:
             injected_data = []
             if is_intro_lit:
-                for p in golden_meta:
-                    if isinstance(p, dict):
-                        if p.get('future_gaps'): injected_data.append(f"[{p.get('title', 'Ref')}] Future Gaps: {p['future_gaps']}")
-                        if p.get('theoretical_lens'): injected_data.append(f"[{p.get('title', 'Ref')}] Theory: {p['theoretical_lens']}")
-                if injected_data: 
-                    memory_parts.append("【TARGETED INJECTION: CORE GAPS & THEORIES】\n" + "\n".join(injected_data))
-                    
+                for paper in golden_meta:
+                    if isinstance(paper, dict):
+                        if paper.get("future_gaps"):
+                            injected_data.append(f"[{paper.get('title', 'Ref')}] Future Gaps: {paper['future_gaps']}")
+                        if paper.get("theoretical_lens"):
+                            injected_data.append(f"[{paper.get('title', 'Ref')}] Theory: {paper['theoretical_lens']}")
+                if injected_data:
+                    memory_parts.append(
+                        "【TARGETED INJECTION: CORE GAPS & THEORIES】\n" + "\n".join(injected_data)
+                    )
             elif is_method:
-                for p in golden_meta:
-                    if isinstance(p, dict) and p.get('variables_and_measurements'): 
-                        injected_data.append(f"[{p.get('title', 'Ref')}] Measurements: {p['variables_and_measurements']}")
-                if injected_data: 
-                    memory_parts.append("【TARGETED INJECTION: CORE MEASUREMENTS】\n" + "\n".join(injected_data))
-                    
+                for paper in golden_meta:
+                    if isinstance(paper, dict) and paper.get("variables_and_measurements"):
+                        injected_data.append(
+                            f"[{paper.get('title', 'Ref')}] Measurements: {paper['variables_and_measurements']}"
+                        )
+                if injected_data:
+                    memory_parts.append(
+                        "【TARGETED INJECTION: CORE MEASUREMENTS】\n" + "\n".join(injected_data)
+                    )
             elif is_discussion:
-                for p in golden_meta:
-                    if isinstance(p, dict) and p.get('causal_pathways'): 
-                        injected_data.append(f"[{p.get('title', 'Ref')}] Prior Pathways: {p['causal_pathways']}")
-                if injected_data: 
-                    memory_parts.append("【TARGETED INJECTION: CORE LITERATURE FINDINGS】\n" + "\n".join(injected_data))
+                for paper in golden_meta:
+                    if isinstance(paper, dict) and paper.get("causal_pathways"):
+                        injected_data.append(
+                            f"[{paper.get('title', 'Ref')}] Prior mechanisms/pathways: {paper['causal_pathways']}"
+                        )
+                if injected_data:
+                    memory_parts.append(
+                        "【TARGETED INJECTION: CORE LITERATURE FINDINGS】\n" + "\n".join(injected_data)
+                    )
 
         full = "\n\n".join(memory_parts)
-        if self._count_tokens(full) > max_tokens: 
+        if self._count_tokens(full) > max_tokens:
             return self._truncate_context(full, max_tokens)
         return full
 
@@ -1120,68 +1146,16 @@ class SSciPipelineAgent:
         data_evidence="",
         mode="amj",
     ):
-        sys_prompt = (
-            "You are a senior scholar conceptualizing a high-impact "
-            "empirical paper."
-        )
-        format_mandate = """\n\n[CRITICAL FORMAT MANDATE]
-You MUST output your response EXACTLY using the following two delimiters. Do not add Markdown headings before them:
----ABSTRACT---
-(Write the comprehensive abstract here)
----CONCLUSION---
-(Write the expected conclusion here)"""
-        evidence_block = (
-            f"\nResearch Mode: {mode}\n"
-            "The following evidence packet is the single source of truth "
-            "for setting, sample, data sources, method, findings, and all "
-            "numerical details. Do not invent or alter them.\n"
-            f"<RESEARCH_EVIDENCE>\n{data_evidence[:12000]}\n"
-            "</RESEARCH_EVIDENCE>\n"
-            if data_evidence
-            else ""
-        )
-        base_directive = APP_CONFIG.get(
-            "anchor_generation_directive",
-            "",
-        )
-        user_prompt = (
-            f"Topic: {topic}\nKeywords: {keywords}\n"
-            f"Literature Synthesis:\n{synthesis_result}\n"
-            f"Citation Context:\n{refs_text[:3000]}\n"
-            f"{evidence_block}{base_directive}{format_mandate}"
-        )
-        response = self.call_deepseek(
-            sys_prompt,
-            user_prompt,
-            max_tokens=8000,
-            temp=0.3,
-            model_role="reasoning",
-            thinking=True,
-            allow_fallback=False,
-        )
-        abstract_match = re.search(
-            r"-+\s*ABSTRACT\s*-+\s*(.*?)(?=\s*-+\s*CONCLUSION\s*-+|$)",
-            response,
-            re.DOTALL | re.IGNORECASE,
-        )
-        conclusion_match = re.search(
-            r"-+\s*CONCLUSION\s*-+\s*(.*?)$",
-            response,
-            re.DOTALL | re.IGNORECASE,
-        )
-        final_abstract = (
-            abstract_match.group(1).strip()
-            if abstract_match
-            else response.strip()
-        )
-        final_conclusion = (
-            conclusion_match.group(1).strip()
-            if conclusion_match
-            else ""
+        """Deprecated compatibility shim; never prewrites a conclusion."""
+        response = "".join(
+            str(chunk or "")
+            for chunk in self.stream_generate_research_logic(
+                topic, keywords, synthesis_result, refs_text,
+                data_evidence=data_evidence, mode=mode,
+            )
         )
-        return final_abstract, final_conclusion
-
-        # ... 保留上面的 synthesize_literature 和 generate_anchors 函数不变 ...
+        response = re.sub(r"<think>.*?</think>", "", response, flags=re.DOTALL).strip()
+        return response, ""
 
     # [新增] 综合文献的流式输出方法
     def stream_synthesize_literature(self, topic, refs_text, user_core_literature=""):
@@ -1199,7 +1173,7 @@ You MUST output your response EXACTLY using the following two delimiters. Do not
         )
 
     # Generate abstract and conclusion anchors from literature plus evidence.
-    def stream_generate_anchors(
+    def stream_generate_research_logic(
         self,
         topic,
         keywords,
@@ -1208,43 +1182,38 @@ You MUST output your response EXACTLY using the following two delimiters. Do not
         data_evidence="",
         mode="amj",
     ):
-        sys_prompt = (
-            "You are a senior scholar conceptualizing a high-impact "
-            "empirical paper."
-        )
-        format_mandate = """\n\n[CRITICAL FORMAT MANDATE]
-You MUST output your response EXACTLY using the following two delimiters. Do not add Markdown headings before them:
----ABSTRACT---
-(Write the comprehensive abstract here)
----CONCLUSION---
-(Write the expected conclusion here)"""
+        """Generate a provisional research-logic contract without prewriting results."""
+        mode = 'asq' if str(mode).lower() == 'asq' else 'amj'
+        sys_prompt = "You are a senior management scholar planning a high-impact empirical paper before manuscript drafting."
         evidence_block = (
-            f"\nResearch Mode: {mode}\n"
-            "The following evidence packet is the single source of truth "
-            "for setting, sample, data sources, method, findings, and all "
-            "numerical details. Do not invent or alter them.\n"
-            f"<RESEARCH_EVIDENCE>\n{data_evidence[:12000]}\n"
-            "</RESEARCH_EVIDENCE>\n"
-            if data_evidence
-            else ""
+            "The following evidence packet is the single source of truth for setting, sample, data sources, method, findings, and numerical details. "
+            "Do not invent or alter them.\n"
+            f"<RESEARCH_EVIDENCE>\n{data_evidence[:14000]}\n</RESEARCH_EVIDENCE>\n"
+            if data_evidence else ""
         )
-        base_directive = APP_CONFIG.get(
-            "anchor_generation_directive",
-            "",
-        )
-        user_prompt = (
-            f"Topic: {topic}\nKeywords: {keywords}\n"
-            f"Literature Synthesis:\n{synthesis_result}\n"
-            f"Citation Context:\n{refs_text[:3000]}\n"
-            f"{evidence_block}{base_directive}{format_mandate}"
+        mode_directive = (
+            "For the quantitative AMJ-oriented track, identify the management problem, theoretical tension, research move, focal mechanism, evidence-strength boundary, and questions/hypotheses the evidence can address. Do not predict coefficients or findings."
+            if mode == 'amj'
+            else "For the qualitative ASQ-oriented track, identify the organizational puzzle, sensitizing theoretical tension, research question, likely process/meaning domains to examine, and evidence boundaries. Do not predict the emergent resolution."
         )
+        user_prompt = f"""Topic: {topic}
+Keywords: {keywords}
+Literature Synthesis:
+{synthesis_result}
+
+{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."""
         return self.stream_deepseek(
-            sys_prompt,
-            user_prompt,
-            max_tokens=8000,
-            model_role="reasoning",
-            thinking=True,
-            allow_fallback=False,
+            sys_prompt, user_prompt, max_tokens=2200,
+            model_role="reasoning", thinking=True, allow_fallback=False,
+        )
+
+    # Backward-compatible name retained for old checkpoints/tests.
+    def stream_generate_anchors(self, topic, keywords, synthesis_result, refs_text, data_evidence="", mode="amj"):
+        return self.stream_generate_research_logic(
+            topic, keywords, synthesis_result, refs_text,
+            data_evidence=data_evidence, mode=mode,
         )
 
     # =====================================================================
@@ -1286,6 +1255,9 @@ You MUST output your response EXACTLY using the following two delimiters. Do not
                         suffix += 1
                     seen_ids.add(subsection_id)
                     concepts = [str(item).strip() for item in theme.get("concepts", []) if str(item).strip()]
+                    theme_evidence = [dict(item) for item in (theme.get("evidence") or []) if isinstance(item, dict)]
+                    stages = [str(item).strip() for item in (theme.get("stages") or []) if str(item).strip()]
+                    has_deviant = bool(theme.get("has_deviant_evidence"))
                     dynamic_subsections.append(
                         {
                             "subsection_id": subsection_id,
@@ -1293,9 +1265,12 @@ You MUST output your response EXACTLY using the following two delimiters. Do not
                             "share": per_theme_share,
                             "theme_title": title,
                             "concepts": concepts,
+                            "theme_evidence": theme_evidence,
                             "required_content": (
-                                "Explain this theme using only its assigned concepts and "
-                                "representative quotations. Do not repeat another theme."
+                                "Explain this theme using only its assigned concepts and tagged representative quotations. "
+                                + (f"Preserve the frozen process order across these stages: {', '.join(stages)}. " if stages else "")
+                                + ("Use the assigned deviant/boundary evidence to qualify the pattern rather than hiding it. " if has_deviant else "")
+                                + "Do not reuse evidence assigned to another theme or invent a temporal sequence."
                             ),
                         }
                     )
@@ -1311,7 +1286,12 @@ You MUST output your response EXACTLY using the following two delimiters. Do not
     def build_generation_tasks(self, structure, total_words, safe_chunk_words):
         tasks = []
         for section in structure:
-            section_target = max(120, int(total_words * float(section.get("weight", 0.1))))
+            excluded_budget = bool(section.get("exclude_from_word_budget"))
+            section_target = (
+                max(320, int(APP_CONFIG.get("qualitative_appendix_words", 420)))
+                if excluded_budget
+                else max(120, int(total_words * float(section.get("weight", 0.1))))
+            )
             subsections = section.get("subsections") or []
             units = subsections or [None]
             for unit_index, subsection in enumerate(units):
@@ -1322,6 +1302,7 @@ You MUST output your response EXACTLY using the following two delimiters. Do not
                     required_content = subsection.get("required_content", "")
                     theme_title = subsection.get("theme_title")
                     concepts = subsection.get("concepts", [])
+                    theme_evidence = subsection.get("theme_evidence", [])
                 else:
                     unit_target = section_target
                     subsection_id = None
@@ -1329,10 +1310,16 @@ You MUST output your response EXACTLY using the following two delimiters. Do not
                     required_content = ""
                     theme_title = None
                     concepts = []
+                    theme_evidence = []
 
                 part_count = max(1, math.ceil(unit_target / max(1, int(safe_chunk_words))))
                 for part_index in range(part_count):
                     part_target = max(80, int(unit_target / part_count))
+                    part_theme_evidence = (
+                        theme_evidence[part_index::part_count]
+                        if theme_evidence and part_count > 1
+                        else theme_evidence
+                    )
                     label = section["section"]
                     if subsection_title:
                         label += f" > {subsection_title}"
@@ -1352,7 +1339,9 @@ You MUST output your response EXACTLY using the following two delimiters. Do not
                             "required_content": required_content,
                             "theme_title": theme_title,
                             "concepts": concepts,
+                            "theme_evidence": part_theme_evidence,
                             "is_method_or_result": bool(section.get("is_method_or_result")),
+                            "exclude_from_word_budget": excluded_budget,
                         }
                     )
         return tasks
@@ -1607,24 +1596,79 @@ Return ONLY a valid JSON array of strings."""
         if not query:
             self._record_source_error('s2', 'S2_BAD_QUERY')
             return []
-        headers = {'x-api-key': str(self.s2_key).strip()} if self.s2_key else {}
+        params = {
+            'query': query,
+            'offset': offset,
+            'limit': 50,
+            'fields': 'paperId,title,authors,year,venue,abstract,externalIds',
+        }
+        if self._s2_access_mode == 'blocked':
+            # The task already proved that both keyed and anonymous access are
+            # refused from this runtime. Avoid repeating doomed network calls;
+            # OpenAlex remains the safe literature fallback.
+            self._record_source_error('s2', 'S2_ACCESS_BLOCKED', self.source_metrics['s2'].get('last_status_code'))
+            return []
         self._source_metric_add('s2', 'request_count')
         self._source_metric_set('s2', 'status', 'running')
         logging.info('S2 search: term=%r normalized=%r offset=%s', term, query, offset)
         try:
+            access_mode = self._s2_access_mode
+            headers = {'x-api-key': self.s2_key} if access_mode == 'key' and self.s2_key else {}
             response = self._requests_get_with_retry(
                 f"{self.s2_api_url}/paper/search",
                 headers=headers,
-                params={
-                    'query': query,
-                    'offset': offset,
-                    'limit': 50,
-                    'fields': 'paperId,title,authors,year,venue,abstract,externalIds',
-                },
+                params=params,
             )
-            status = response.status_code
+            status = int(response.status_code)
             self._source_metric_set('s2', 'last_status_code', status)
-            if status in (401, 403):
+            if access_mode == 'key':
+                self._source_metric_set('s2', 'authenticated_status', status)
+            else:
+                self._source_metric_set('s2', 'anonymous_status', status)
+            if status in (401, 403) and access_mode == 'key' and self.s2_key:
+                # A configured key can be stale/revoked while the public Graph
+                # endpoint remains usable. Probe anonymously exactly once per
+                # task; this reveals only status codes, never the secret.
+                with self._s2_probe_lock:
+                    if not self._s2_probe_complete:
+                        self._s2_probe_complete = True
+                        self._source_metric_add('s2', 'request_count')
+                        anonymous = self._requests_get_with_retry(
+                            f"{self.s2_api_url}/paper/search",
+                            headers={},
+                            params=params,
+                        )
+                        anonymous_status = int(anonymous.status_code)
+                        self._source_metric_set('s2', 'anonymous_status', anonymous_status)
+                        logging.warning(
+                            'S2 access diagnostic: key_present=true authenticated_status=%s anonymous_status=%s',
+                            status, anonymous_status,
+                        )
+                        if anonymous_status not in (401, 403):
+                            self._s2_access_mode = 'anonymous'
+                            self._source_metric_set('s2', 'access_mode', 'anonymous')
+                            response = anonymous
+                            status = anonymous_status
+                            self._source_metric_set('s2', 'last_status_code', status)
+                        else:
+                            self._s2_access_mode = 'blocked'
+                            self._source_metric_set('s2', 'access_mode', 'blocked')
+                    elif self._s2_access_mode == 'anonymous':
+                        self._source_metric_add('s2', 'request_count')
+                        response = self._requests_get_with_retry(
+                            f"{self.s2_api_url}/paper/search", headers={}, params=params
+                        )
+                        status = int(response.status_code)
+                        self._source_metric_set('s2', 'anonymous_status', status)
+                        self._source_metric_set('s2', 'last_status_code', status)
+                if self._s2_access_mode == 'blocked' or status in (401, 403):
+                    self._record_source_error('s2', 'S2_AUTH_ERROR', status)
+                    return []
+            elif status in (401, 403):
+                # Anonymous access itself is refused from this runtime.
+                if access_mode == 'anonymous':
+                    self._s2_access_mode = 'blocked'
+                    self._source_metric_set('s2', 'access_mode', 'blocked')
                 self._record_source_error('s2', 'S2_AUTH_ERROR', status)
                 return []
             if status == 429:
@@ -1822,6 +1866,12 @@ Return ONLY a valid JSON array of strings."""
                 self.source_metrics[source]['last_status_code'] = None
                 self.source_metrics[source]['last_safe_error'] = ''
                 self.source_metrics[source]['status'] = 'not_started'
+                self.source_metrics[source]['authenticated_status'] = None
+                self.source_metrics[source]['anonymous_status'] = None
+            self._s2_access_mode = 'key' if self.s2_key else 'anonymous'
+            self._s2_probe_complete = not bool(self.s2_key)
+            self.source_metrics['s2']['key_present'] = bool(self.s2_key)
+            self.source_metrics['s2']['access_mode'] = self._s2_access_mode
             self.s2_calls = self.oa_calls = 0
 
         all_used_terms = set()
@@ -1949,6 +1999,238 @@ Return ONLY a valid JSON array of strings."""
         words = re.findall(r"[A-Za-z][A-Za-z0-9_-]{2,}", str(value).lower())
         return {word for word in words if word not in stopwords}
 
+    def build_claim_evidence_plan(self, tasks, topic, synthesis_result, mode='amj', target_unique=60):
+        """Plan citations by claim/evidence relevance before prose is written.
+
+        This replaces position-based tag allocation. A source is assigned to at
+        most one manuscript unit and only together with a claim that its title/
+        abstract evidence can directly support. Results/Findings, conclusion,
+        abstract-like and appendix units are excluded from literature quotas.
+        """
+        mode = 'asq' if str(mode).lower() == 'asq' else 'amj'
+        allowed_ids = (
+            {'introduction', 'theoretical_framing', 'methods', 'discussion'}
+            if mode == 'asq'
+            else {'introduction', 'theory', 'methodology', 'discussion'}
+        )
+        section_profiles = APP_CONFIG.get('section_reasoning_profiles', {}).get(mode, {})
+        sections = []
+        seen = set()
+        for task in tasks or []:
+            section_id = str(task.get('section_id') or '')
+            name = str(task.get('display_name') or '').strip()
+            if section_id not in allowed_ids or not name or name in seen:
+                continue
+            seen.add(name)
+            sections.append({
+                'name': name,
+                'section_id': section_id,
+                'role': str(section_profiles.get(section_id) or ''),
+                'target_words': max(1, int(task.get('target_words') or 1)),
+            })
+        if not sections:
+            return {}
+
+        candidates = []
+        for tag in sorted(self.citation_map, key=self._citation_tag_number)[:80]:
+            meta = self.citation_map.get(tag) or {}
+            evidence = re.sub(r'\s+', ' ', str(meta.get('evidence') or '')).strip()
+            if not evidence:
+                continue
+            candidates.append({
+                'tag': tag,
+                'title': str(meta.get('title') or '')[:240],
+                'year': str(meta.get('year') or ''),
+                'evidence': evidence[:900],
+            })
+        target = min(max(1, int(target_unique)), len(candidates))
+        if not candidates:
+            return {}
+
+        total_section_words = sum(item['target_words'] for item in sections) or len(sections)
+        capacities = {}
+        for item in sections:
+            proportional = target * (item['target_words'] / total_section_words)
+            capacities[item['name']] = max(3, int(math.ceil(proportional * 1.18)))
+        while sum(capacities.values()) < target:
+            for item in sorted(sections, key=lambda row: row['target_words'], reverse=True):
+                capacities[item['name']] += 1
+                if sum(capacities.values()) >= target:
+                    break
+
+        payload = {
+            'topic': str(topic or '')[:700],
+            'mode': mode,
+            'target_unique_sources': target,
+            'sections': [dict(item, citation_capacity=capacities[item['name']]) for item in sections],
+            'sources': candidates,
+        }
+        system_prompt = """You are a rigorous claim-evidence planner for a top management journal manuscript. Build the citation architecture BEFORE prose is written. 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 the target. Return only valid JSON."""
+        user_prompt = f"""Create a claim-evidence plan.
+JSON schema:
+{{"assignments":[{{"tag":"[CITE-01]","section":"exact display_name from sections","claim":"one directly supported external/theoretical/methodological claim"}}]}}
+Aim for {target} distinct sources when the evidence permits. Distribute sources across appropriate non-results sections; do not assign literature to Results/Findings or Conclusion.
+INPUT:
+{json.dumps(payload, ensure_ascii=False)}"""
+
+        best = []
+        for attempt in range(2):
+            raw = self.call_deepseek(
+                system_prompt,
+                user_prompt + ("\nPrevious attempt was incomplete. Return a fuller plan while keeping every claim directly evidence-supported." if attempt else ""),
+                max_tokens=8000,
+                temp=0.1 + attempt * 0.1,
+                model_role='reasoning',
+                thinking=True,
+                allow_fallback=False,
+            )
+            parsed = self._extract_json_from_text(raw)
+            rows = parsed.get('assignments') if isinstance(parsed, dict) else None
+            if not isinstance(rows, list):
+                continue
+            allowed_sections = {item['name'] for item in sections}
+            valid_tags = set(self.citation_map)
+            unique_tags = set()
+            cleaned = []
+            section_loads = {item['name']: 0 for item in sections}
+            for row in rows:
+                if not isinstance(row, dict):
+                    continue
+                tag = str(row.get('tag') or '').upper().strip()
+                if not tag.startswith('['):
+                    tag = f'[{tag}]'
+                section = str(row.get('section') or '').strip()
+                claim = re.sub(r'\s+', ' ', str(row.get('claim') or '')).strip()
+                if tag not in valid_tags or tag in unique_tags or section not in allowed_sections or len(claim.split()) < 5:
+                    continue
+                if section_loads.get(section, 0) >= capacities.get(section, target):
+                    continue
+                # Lightweight lexical sanity check. The semantic audit remains
+                # authoritative later, but a zero-overlap plan is rejected now.
+                evidence = str((self.citation_map.get(tag) or {}).get('evidence') or '')
+                overlap = self._citation_terms(claim) & self._citation_terms(evidence)
+                if len(overlap) < 2:
+                    continue
+                unique_tags.add(tag)
+                cleaned.append({'tag': tag, 'section': section, 'claim': claim})
+                section_loads[section] = section_loads.get(section, 0) + 1
+            if len(cleaned) > len(best):
+                best = cleaned
+            if len(best) >= target:
+                break
+
+        # If a model response is truncated or structurally incomplete, recover
+        # only with claims copied from the supplied abstract evidence itself.
+        # This is not the old position-based citation allocation: the fallback
+        # still requires nonempty abstract evidence and chooses the manuscript
+        # unit by lexical relevance, while each source remains unique.
+        if len(best) < target:
+            used_tags = {row['tag'] for row in best}
+            loads = {item['name']: sum(1 for row in best if row['section'] == item['name']) for item in sections}
+            for candidate in candidates:
+                if candidate['tag'] in used_tags:
+                    continue
+                evidence = str(candidate.get('evidence') or '')
+                abstract = evidence.split('Abstract evidence:', 1)[-1].strip() if 'Abstract evidence:' in evidence else ''
+                if len(abstract.split()) < 8:
+                    continue
+                sentence_parts = re.split(r'(?<=[.!?])\s+', abstract)
+                claim = next((part.strip() for part in sentence_parts if 8 <= len(part.split()) <= 55), '')
+                if not claim:
+                    words = abstract.split()
+                    if len(words) < 8:
+                        continue
+                    claim = ' '.join(words[:55]).rstrip(' ,;:') + '.'
+                evidence_terms = self._citation_terms(evidence)
+                ranked = []
+                for section in sections:
+                    name = section['name']
+                    if loads[name] >= capacities.get(name, target):
+                        continue
+                    section_terms = self._citation_terms(
+                        name + ' ' + section['role']
+                    )
+                    overlap = len(evidence_terms & section_terms)
+                    if overlap <= 0:
+                        continue
+                    # Relevance is primary; normalized load prevents one unit
+                    # from absorbing the full citation plan when several units
+                    # are genuinely relevant.
+                    load_ratio = loads[name] / max(1, capacities.get(name, 1))
+                    ranked.append((overlap, -load_ratio, section['target_words'], name))
+                if not ranked:
+                    continue
+                ranked.sort(reverse=True)
+                chosen = ranked[0][3]
+                best.append({'tag': candidate['tag'], 'section': chosen, 'claim': claim})
+                used_tags.add(candidate['tag'])
+                loads[chosen] += 1
+                if len(best) >= target:
+                    break
+
+        plan = {item['name']: [] for item in sections}
+        for row in best:
+            meta = self.citation_map.get(row['tag']) or {}
+            plan[row['section']].append({
+                'tag': row['tag'],
+                'claim': row['claim'],
+                'evidence': re.sub(r'\s+', ' ', str(meta.get('evidence') or '')).strip()[:900],
+            })
+        logging.info(
+            'Citation-first plan built: target=%s planned=%s sections=%s',
+            target, len(best), sum(1 for items in plan.values() if items),
+        )
+        return plan
+
+    @staticmethod
+    def format_claim_evidence_plan(items):
+        lines = []
+        for item in items or []:
+            tag = str(item.get('tag') or '').strip()
+            claim = str(item.get('claim') or '').strip()
+            evidence = str(item.get('evidence') or '').strip()
+            if tag and claim and evidence:
+                lines.append(f"- {tag} SUPPORTED CLAIM: {claim}\n  EVIDENCE: {evidence}")
+        return '\n'.join(lines)
+
+    def build_citation_recovery_paragraph(self, items, section_name=''):
+        """Create one bounded literature paragraph from already planned evidence.
+
+        This is invoked only when semantic validation removed too many planned
+        citations from a unit. It never invents new sources or study facts.
+        """
+        selected = [item for item in (items or []) if item.get('tag') and item.get('claim') and item.get('evidence')][:5]
+        if not selected:
+            return ''
+        plan_text = self.format_claim_evidence_plan(selected)
+        expected = [str(item['tag']) for item in selected]
+        prompt = f"""Write ONE cohesive top-journal literature paragraph for the named manuscript unit using ONLY the planned claim-evidence items below.
+Rules:
+1. Use every assigned [CITE-XX] tag exactly once, attached only to its own directly supported claim.
+2. Do not broaden a claim beyond its evidence and do not add any study-specific fact, statistic, setting, result, quotation, hypothesis, or new source.
+3. Do not stack citations. Keep each source's claim in a distinct sentence or clause.
+4. Avoid generic literature-listing prose and contribution-counting templates; connect the claims through one clear theoretical point relevant to the unit.
+5. Output only the paragraph, no heading or commentary.
+SECTION: {section_name}
+<CLAIM_EVIDENCE_PLAN>
+{plan_text}
+</CLAIM_EVIDENCE_PLAN>"""
+        raw = self.call_deepseek(
+            'You are a precise management-journal evidence integrator.',
+            prompt,
+            max_tokens=1400,
+            temp=0.1,
+            model_role='writing',
+            thinking=False,
+            allow_fallback=False,
+        ).strip()
+        actual = Counter(re.findall(r'\[CITE-\d+\]', raw, re.I))
+        expected_counter = Counter(expected)
+        if actual != expected_counter:
+            logging.warning('Citation recovery paragraph model output rejected; using evidence-plan fallback: section=%s', section_name)
+            raw = ' '.join(f"{str(item['claim']).rstrip('.')} {item['tag']}." for item in selected)
+        return raw.strip()
+
     def _candidate_citation_tags(self, sentence, required_tags, limit):
         valid_required = [
             tag for tag in required_tags
@@ -2589,7 +2871,7 @@ Return exactly:
             value = re.sub(pattern, '', value)
         return re.sub(r'\n{3,}', '\n\n', value).strip()
 
-    def polish_academic_section(self, text, section_name='', abstract=False):
+    def polish_academic_section(self, text, section_name='', abstract=False, mode='amj'):
         value = self._remove_ai_meta_traces(text)
         quality = APP_CONFIG.get('manuscript_quality', {})
         forbidden = quality.get('forbidden_phrases', [])
@@ -2606,7 +2888,12 @@ Return exactly:
             if abstract
             else "Preserve every number, percentage, coefficient, p-value, and confidence interval exactly."
         )
-        prompt = f"""Revise only the supplied academic section. Preserve every heading, citation tag, quotation, hypothesis label, variable abbreviation, and conclusion direction exactly. {numeric_rule} Use concise, accurate, rigorous academic English. Remove formulaic transitions, repetitive summaries, metaphors, analogies, promotional language, and any AI-writing meta-commentary. Do not add new evidence or citations.\nSECTION: {section_name}\nTEXT:\n{value}"""
+        voice = str(APP_CONFIG.get('journal_voice_profiles', {}).get('asq' if str(mode).lower() == 'asq' else 'amj') or '')
+        prompt = f"""Revise only the supplied academic section. Preserve every heading, citation tag, quotation, hypothesis label, variable abbreviation, and conclusion direction exactly. {numeric_rule} Use concise, accurate, rigorous academic English. Remove formulaic transitions, repetitive summaries, metaphors, analogies, promotional language, and any AI-writing meta-commentary. Do not add new evidence or citations.
+JOURNAL VOICE: {voice}
+SECTION: {section_name}
+TEXT:
+{value}"""
         revised = self.call_deepseek(
             'You are a meticulous academic language editor. Output only the revised section.',
             prompt,
@@ -2638,8 +2925,99 @@ Return exactly:
         if original_tags != revised_tags:
             logging.warning('Quality revision rejected because citation tags changed: %s', section_name)
             return value
+        original_quote_tags = Counter(re.findall(r'QUOTE-\d+', value, re.I))
+        revised_quote_tags = Counter(re.findall(r'QUOTE-\d+', revised, re.I))
+        if original_quote_tags != revised_quote_tags:
+            logging.warning('Quality revision rejected because quotation tags changed: %s', section_name)
+            return value
         return revised.strip()
 
+    def critique_and_repair_section(self, text, *, section_id, section_name, mode, evidence_contract=''):
+        """Independent top-journal critic with bounded local repair."""
+        value = str(text or '').strip()
+        mode = 'asq' if str(mode).lower() == 'asq' else 'amj'
+        critical_sections = ({'introduction', 'theory', 'discussion'} if mode == 'amj' else {'introduction', 'theoretical_framing', 'findings', 'discussion'})
+        if str(section_id or '') not in critical_sections or len(value.split()) < 120:
+            return value
+        dimensions = APP_CONFIG.get('top_journal_critic_profiles', {}).get(mode, [])
+        profile = APP_CONFIG.get('section_reasoning_profiles', {}).get(mode, {}).get(str(section_id or ''), '')
+        prompt = f"""Assess ONLY this manuscript unit as an independent top-journal critic. Return valid JSON only:
+{{"pass":true,"critical_issue":"","repair_instruction":""}}
+Set pass=false only for a material argument/evidence defect, not for minor stylistic preference. Evaluate: {', '.join(dimensions)}.
+SECTION ROLE: {profile}
+EVIDENCE CONTRACT: {evidence_contract[:4500]}
+TEXT:
+{value}"""
+        raw = self.call_deepseek(
+            'You are an independent senior management-journal reviewer. Be exact and conservative.',
+            prompt, max_tokens=800, temp=0.0, model_role='fast', thinking=False, allow_fallback=True,
+        )
+        parsed = self._extract_json_from_text(raw)
+        if not isinstance(parsed, dict) or parsed.get('pass') is not False:
+            return value
+        instruction = re.sub(r'\s+', ' ', str(parsed.get('repair_instruction') or parsed.get('critical_issue') or '')).strip()
+        if not instruction:
+            return value
+        repair_prompt = f"""Repair only the material issue identified by an independent reviewer.
+Do not change or remove any number, citation tag, quotation/QUOTE tag, hypothesis label, variable abbreviation, heading, or empirical conclusion direction. Do not add a new statistic, source, quotation, setting fact, sample fact, or method. Preserve the approximate length.
+MODE: {mode}
+SECTION: {section_name}
+REVIEWER INSTRUCTION: {instruction}
+EVIDENCE CONTRACT: {evidence_contract[:4500]}
+TEXT:
+{value}
+Output only the repaired section."""
+        revised = self.call_deepseek(
+            'You are a meticulous top-journal academic editor.', repair_prompt,
+            max_tokens=max(1600, min(8000, self._count_tokens(value) + 1000)), temp=0.1,
+            model_role='writing', thinking=False, allow_fallback=False,
+        ).strip()
+        invariants = [
+            (self._numeric_tokens(value), self._numeric_tokens(revised)),
+            (Counter(re.findall(r'CITE-\d+', value, re.I)), Counter(re.findall(r'CITE-\d+', revised, re.I))),
+            (Counter(re.findall(r'QUOTE-\d+', value, re.I)), Counter(re.findall(r'QUOTE-\d+', revised, re.I))),
+            (Counter(re.findall(r'\bH\d+[A-Za-z]?\b', value)), Counter(re.findall(r'\bH\d+[A-Za-z]?\b', revised))),
+        ]
+        if any(left != right for left, right in invariants):
+            logging.warning('Top-journal local repair rejected because protected content changed: %s', section_name)
+            return value
+        logging.info('Top-journal local repair accepted: section=%s issue=%s', section_name, instruction[:180])
+        return self._remove_ai_meta_traces(revised)
+
+    def rebalance_discussion_length(self, manuscript, *, target_words, mode, actual_words):
+        """Use Discussion as the bounded final word-budget correction surface."""
+        value = str(manuscript or '')
+        delta = int(target_words) - int(actual_words)
+        if abs(delta) < 40:
+            return value
+        match = re.search(r'(?ms)^#\s+Discussion\s*$\n(.*?)(?=^#\s+[^#].*?$|\Z)', value)
+        if not match:
+            return value
+        original = match.group(1).strip()
+        if len(original.split()) < 200:
+            return value
+        action = 'expand' if delta > 0 else 'compress'
+        requested = min(abs(delta), max(120, int(len(original.split()) * 0.28)))
+        prompt = f"""{action.capitalize()} this Discussion section by approximately {requested} words so the completed manuscript approaches its requested total length.
+Preserve every heading, number, resolved author-year citation, quotation, hypothesis label, variable abbreviation, and conclusion direction. Do not add new empirical facts, sources, statistics, quotations, or methods. If expanding, deepen mechanism, theoretical boundary, and interpretation already supported by the section. If compressing, remove repetition and low-information phrasing without deleting a substantive finding or citation.
+MODE: {mode}
+TEXT:
+{original}
+Output only the revised Discussion body, without the '# Discussion' heading."""
+        revised = self.call_deepseek(
+            'You are a precise top-journal length editor.', prompt,
+            max_tokens=max(1800, min(8000, self._count_tokens(original) + max(800, requested * 2))),
+            temp=0.1, model_role='writing', thinking=False, allow_fallback=False,
+        ).strip()
+        if self._numeric_tokens(original) != self._numeric_tokens(revised):
+            logging.warning('Word-budget Discussion repair rejected because numbers changed.')
+            return value
+        cite_pattern = r'\([^()\n]*?(?:19|20)\d{2}[a-z]?[^()\n]*?\)'
+        if Counter(re.findall(cite_pattern, original, re.I)) != Counter(re.findall(cite_pattern, revised, re.I)):
+            logging.warning('Word-budget Discussion repair rejected because citations changed.')
+            return value
+        return value[:match.start(1)] + revised + '\n\n' + value[match.end(1):]
+
     @staticmethod
     def _trim_at_sentence_boundary(value, max_words):
         text = str(value or '').strip()
@@ -2712,7 +3090,7 @@ Return exactly:
         )
         abstract = self._remove_ai_meta_traces(abstract)
         abstract = re.sub(r'(?im)^#+\s*abstract\s*', '', abstract).strip()
-        abstract = self.polish_academic_section(abstract, 'Abstract', abstract=True)
+        abstract = self.polish_academic_section(abstract, 'Abstract', abstract=True, mode=mode)
         max_words = max(80, int(APP_CONFIG.get('manuscript_quality', {}).get('abstract_max_words', 200)))
         return self._trim_at_sentence_boundary(abstract, max_words)
 

core/qualitative_engine.py

@@ -1,16 +1,24 @@
 # -*- coding: utf-8 -*-
-"""Qualitative evidence preparation for SmartPaper's ASQ track."""
+"""Qualitative evidence preparation for SmartPaper's ASQ-oriented track."""
 
 from __future__ import annotations
 
 import logging
 import re
 
-
 from config import APP_CONFIG
 
 
 class QualitativeEngine:
+    ALLOWED_ANALYTIC_DESIGNS = {
+        "Process analysis",
+        "Comparative case analysis",
+        "Grounded theory",
+        "Gioia-style inductive coding",
+        "Longitudinal qualitative analysis",
+        "Iterative thematic/process analysis",
+    }
+
     def __init__(self, agent):
         self.agent = agent
 
@@ -19,31 +27,52 @@ class QualitativeEngine:
         cleaned = str(value or default).replace("\n", " ").strip()
         return cleaned or default
 
+    @classmethod
+    def _normalize_analytic_design(cls, value):
+        cleaned = re.sub(r"\s+", " ", str(value or "")).strip()
+        if not cleaned:
+            return "Iterative thematic/process analysis"
+        lookup = {item.lower(): item for item in cls.ALLOWED_ANALYTIC_DESIGNS}
+        return lookup.get(cleaned.lower(), "Iterative thematic/process analysis")
+
     def _build_request(self, topic, keywords, raw_interviews):
         schema = """Return ONLY one valid JSON object with this schema:
 {
   "study_facts": {
-    "research_setting": "string",
+    "research_setting": "string or Not specified",
     "data_sources": ["string"],
     "participant_count": integer or null,
     "interview_count": integer or null,
-    "analysis_method": "string"
+    "analytic_design": "one allowed design",
+    "analytic_logic": "one concise sentence",
+    "temporal_structure": "string or Not specified",
+    "case_structure": "string or Not specified"
   },
   "evidence": [
-    {"theme": "2nd-order theme", "concept": "1st-order concept", "quote": "verbatim quote"}
+    {
+      "theme": "higher-order pattern/theme",
+      "concept": "empirical concept",
+      "quote": "verbatim quotation",
+      "stage": "temporal/process stage or Not specified",
+      "case_label": "generic case/actor label or Not specified",
+      "evidence_role": "typical or deviant"
+    }
   ]
 }
+Allowed analytic designs: Process analysis; Comparative case analysis; Grounded theory; Gioia-style inductive coding; Longitudinal qualitative analysis; Iterative thematic/process analysis.
 """
         if raw_interviews and len(raw_interviews) > 100:
             return f"""Topic: {topic}
 Keywords: {keywords}
-Analyze the supplied interview or field material.
+Analyze the supplied interview or field material for an ASQ-oriented qualitative manuscript.
 
 Rules:
-1. Use only setting, sample, source, and count information supported by the supplied material. Use null or "Not specified" when absent.
-2. Extract up to 15 representative quotations verbatim; do not rewrite quotations.
-3. Build a coherent Gioia-style coding structure.
-4. The study_facts object will become the single source of truth for the entire manuscript.
+1. Treat the supplied material as the only source of study facts. Use null or "Not specified" for any setting, sample, count, date, case, or data source not supported by the material.
+2. Extract 8-15 representative quotations VERBATIM. Never repair, paraphrase, translate, combine, or invent a quotation.
+3. Choose the analytic design that best fits the actual material. Do NOT default to Gioia. Use Gioia-style coding only if the evidence structure genuinely warrants it.
+4. Organize evidence around a central organizational puzzle and, when the material supports it, preserve temporal stages, actor/case contrasts, process transitions, and at least one deviant or boundary observation.
+5. Do not manufacture a longitudinal sequence when the material is cross-sectional, and do not manufacture multiple cases when only one is present.
+6. The study_facts object and quotations will become the frozen single source of truth for the entire manuscript.
 
 {schema}
 <QUALITATIVE_MATERIAL>
@@ -53,14 +82,17 @@ Rules:
 
         return f"""Topic: {topic}
 Keywords: {keywords}
-Construct one internally coherent qualitative study design and evidence packet for a complete ASQ-style manuscript when no interview material is supplied.
+Construct one internally coherent qualitative evidence packet for a complete ASQ-oriented manuscript because no interview material was supplied.
 
 Rules:
-1. Choose one research setting and keep it fixed.
-2. Choose one participant count, interview count, data-source set, and analysis method; do not create conflicting counts.
-3. Produce exactly 12 natural representative quotations organized into a Gioia-style coding structure.
-4. The study_facts object will become the single source of truth for the entire manuscript.
-5. Avoid decorative language, generic AI phrasing, and repetitive quotation patterns.
+1. Choose one generic organizational research setting directly relevant to the topic and keep it fixed. Do not name a real organization, institution, or identifiable person.
+2. Freeze one participant count, interview count, data-source set, analytic design, temporal/case structure, and analytic logic. Keep them internally consistent.
+3. Produce exactly 12 natural representative quotations distributed across at least three higher-order themes. Quotations must sound like distinct participants rather than repeated template variants.
+4. Choose the analytic design that best fits the constructed evidence; do NOT default to Gioia. Use process, comparative-case, grounded-theory, longitudinal, or Gioia-style logic only when the packet supports it.
+5. Include at least one clearly labelled deviant/boundary observation so the eventual theory is not built only from confirming examples.
+6. The evidence should support a process/mechanism explanation, not merely descriptive topic categories.
+7. The study_facts object and evidence packet will become the frozen single source of truth for the entire manuscript.
+8. Avoid decorative language, generic AI phrasing, and repetitive quotation patterns.
 
 {schema}
 """
@@ -69,11 +101,11 @@ Rules:
         has_user_data = bool(raw_interviews and len(raw_interviews) > 100)
         prompt = self._build_request(topic, keywords, raw_interviews)
         # R3-Free engine code is headless. Streamlit rendering belongs to app.py;
-        # this method only produces deterministic evidence + metadata.
+        # this method only produces frozen evidence + metadata.
         response = "".join(
             str(chunk or "")
             for chunk in self.agent.stream_deepseek(
-                "You are a rigorous qualitative research analyst.",
+                "You are a rigorous qualitative research analyst. Evidence fidelity has priority over narrative completeness.",
                 prompt,
                 model_role="reasoning",
                 thinking=True,
@@ -90,80 +122,88 @@ Rules:
         data = self.agent._extract_json_from_text(response)
 
         if not isinstance(data, dict):
-            logging.error("Qualitative JSON parsing failed; using safe fallback.")
-            data = {
-                "study_facts": {
-                    "research_setting": "Not specified",
-                    "data_sources": ["Interview or field material"],
-                    "participant_count": None,
-                    "interview_count": None,
-                    "analysis_method": "Gioia-style inductive coding",
-                },
-                "evidence": [
-                    {
-                        "theme": "Sensemaking",
-                        "concept": "Initial uncertainty",
-                        "quote": (
-                            "We did not yet have a shared understanding "
-                            "of how to respond."
-                        ),
-                    }
-                ],
-            }
+            raise RuntimeError("Qualitative evidence packet could not be parsed safely.")
 
         facts = data.get("study_facts") or {}
         evidence = data.get("evidence") or data.get("quotes") or []
-        if not isinstance(evidence, list):
-            evidence = []
+        if not isinstance(facts, dict) or not isinstance(evidence, list):
+            raise RuntimeError("Qualitative evidence packet has an invalid schema.")
 
         data_sources = facts.get("data_sources") or ["Not specified"]
         if not isinstance(data_sources, list):
             data_sources = [data_sources]
 
         setting = self._clean_cell(facts.get("research_setting"))
-        sources = ", ".join(self._clean_cell(item) for item in data_sources)
+        clean_sources = [self._clean_cell(item) for item in data_sources]
+        sources = ", ".join(clean_sources)
         participants = facts.get("participant_count")
         interviews = facts.get("interview_count")
-        method = self._clean_cell(
-            facts.get("analysis_method"),
-            "Gioia-style inductive coding",
+        analytic_design = self._normalize_analytic_design(
+            facts.get("analytic_design") or facts.get("analysis_method")
+        )
+        analytic_logic = self._clean_cell(
+            facts.get("analytic_logic"),
+            "Iteratively compare empirical observations to refine a process/mechanism explanation.",
         )
+        temporal_structure = self._clean_cell(facts.get("temporal_structure"))
+        case_structure = self._clean_cell(facts.get("case_structure"))
+
+        for value, label in ((participants, "participant_count"), (interviews, "interview_count")):
+            if value is not None and (not isinstance(value, int) or value <= 0):
+                raise RuntimeError(f"Qualitative evidence packet has invalid {label}.")
 
         md = (
-            "### Qualitative Study Design Summary\n"
+            "### Frozen Qualitative Study Design\n"
             "| Field | Frozen value |\n"
             "| :--- | :--- |\n"
             f"| Research setting | {setting} |\n"
             f"| Data sources | {sources} |\n"
             f"| Participants | {participants if participants is not None else 'Not specified'} |\n"
             f"| Interviews | {interviews if interviews is not None else 'Not specified'} |\n"
-            f"| Analysis method | {method} |\n\n"
-            "[CONSISTENCY MANDATE]\n"
-            "Use the study-design summary above as the single source of truth. "
-            "Do not change the setting, sample, interview count, data sources, "
-            "or analysis method in any section.\n\n"
-            "### Table: Qualitative Coding Structure (Data Evidence)\n"
-            "| 2nd-order Theme | 1st-order Concept | Representative Quote |\n"
-            "| :--- | :--- | :--- |\n"
+            f"| Analytic design | {analytic_design} |\n"
+            f"| Analytic logic | {analytic_logic} |\n"
+            f"| Temporal structure | {temporal_structure} |\n"
+            f"| Case structure | {case_structure} |\n\n"
+            "[QUALITATIVE EVIDENCE CONTRACT]\n"
+            "Use the frozen design summary and tagged evidence below as the only source of this study's empirical facts. "
+            "Do not change the setting, sample, interview count, data sources, analytic design, temporal structure, cases, or quotations. "
+            "Do not infer an event sequence, actor comparison, negative case, or quotation that is absent from this packet.\n\n"
+            "### Table: Qualitative Evidence Structure\n"
+            "| Higher-order Theme | Empirical Concept | Process Stage | Case/Actor | Evidence Role | Representative Quote |\n"
+            "| :--- | :--- | :--- | :--- | :--- | :--- |\n"
         )
 
         clean_evidence = []
-        for index, item in enumerate(evidence[:15]):
+        seen_quotes = set()
+        for item in evidence[:15]:
             if not isinstance(item, dict):
                 continue
             quote = self._clean_cell(item.get("quote"), "").replace('"', "'")
-            concept = self._clean_cell(item.get("concept"), "Analysis")
-            theme = self._clean_cell(item.get("theme"), "Observation")
-            if not quote:
+            concept = self._clean_cell(item.get("concept"), "Empirical observation")
+            theme = self._clean_cell(item.get("theme"), "Emergent pattern")
+            stage = self._clean_cell(item.get("stage"))
+            case_label = self._clean_cell(item.get("case_label"))
+            evidence_role = str(item.get("evidence_role") or "typical").strip().lower()
+            if evidence_role not in {"typical", "deviant"}:
+                evidence_role = "typical"
+            normalized_quote = re.sub(r"\s+", " ", quote).strip().lower()
+            if not quote or len(quote.split()) < 4 or normalized_quote in seen_quotes:
                 continue
-            tag = f"QUOTE-{index + 1:02d}"
-            md += f'| {theme} | {concept} | "{quote}" [{tag}] |\n'
+            seen_quotes.add(normalized_quote)
+            tag = f"QUOTE-{len(clean_evidence) + 1:02d}"
+            md += (
+                f'| {theme} | {concept} | {stage} | {case_label} | {evidence_role} | '
+                f'"{quote}" [{tag}] |\n'
+            )
             clean_evidence.append(
                 {
                     "theme": theme,
                     "concept": concept,
                     "quote": quote,
                     "tag": tag,
+                    "stage": stage,
+                    "case_label": case_label,
+                    "evidence_role": evidence_role,
                 }
             )
 
@@ -171,12 +211,28 @@ Rules:
         for item in clean_evidence:
             theme_entry = theme_map.setdefault(
                 item["theme"],
-                {"title": item["theme"], "concepts": [], "evidence": []},
+                {
+                    "title": item["theme"],
+                    "concepts": [],
+                    "evidence": [],
+                    "stages": [],
+                    "has_deviant_evidence": False,
+                },
             )
             if item["concept"] not in theme_entry["concepts"]:
                 theme_entry["concepts"].append(item["concept"])
+            if item["stage"] != "Not specified" and item["stage"] not in theme_entry["stages"]:
+                theme_entry["stages"].append(item["stage"])
+            if item["evidence_role"] == "deviant":
+                theme_entry["has_deviant_evidence"] = True
             theme_entry["evidence"].append(
-                {"tag": item["tag"], "quote": item["quote"]}
+                {
+                    "tag": item["tag"],
+                    "quote": item["quote"],
+                    "stage": item["stage"],
+                    "case_label": item["case_label"],
+                    "evidence_role": item["evidence_role"],
+                }
             )
 
         themes = list(theme_map.values())
@@ -189,6 +245,8 @@ Rules:
                 f"themes={len(themes)}, quotes={len(clean_evidence)}; "
                 f"required themes>={minimum_themes}, quotes>={minimum_quotes}."
             )
+        if not has_user_data and not any(item["evidence_role"] == "deviant" for item in clean_evidence):
+            raise RuntimeError("Generated qualitative evidence packet lacks a deviant/boundary observation.")
 
         metadata = {
             "mode": "qualitative",
@@ -198,31 +256,37 @@ Rules:
             "disclosure_required": not has_user_data,
             "study_facts": {
                 "research_setting": setting,
-                "data_sources": data_sources,
+                "data_sources": clean_sources,
                 "participant_count": participants,
                 "interview_count": interviews,
-                "analysis_method": method,
+                "analytic_design": analytic_design,
+                "analysis_method": analytic_design,
+                "analytic_logic": analytic_logic,
+                "temporal_structure": temporal_structure,
+                "case_structure": case_structure,
             },
             "evidence_count": len(clean_evidence),
             "generation_parameters": {
-                "coding_approach": "Gioia-style inductive coding",
+                "analytic_design": analytic_design,
                 "requested_quote_count_when_generated": 12,
                 "maximum_retained_quotes": 15,
                 "minimum_themes": minimum_themes,
                 "minimum_quotes": minimum_quotes,
+                "requires_generated_deviant_evidence": not has_user_data,
                 "consistency_constraints": [
-                    "one fixed research setting",
-                    "one fixed participant count",
-                    "one fixed interview count",
-                    "one fixed data-source set",
-                    "one fixed analysis method",
+                    "one frozen research setting",
+                    "one frozen participant count",
+                    "one frozen interview count",
+                    "one frozen data-source set",
+                    "one frozen analytic design",
+                    "no unsupported temporal or case structure",
                     "quotation tags must remain unique",
                 ],
             },
             "evidence": clean_evidence,
             "themes": themes,
         }
-        status_message = "✅ 定性研究事实、摘要锚点输入和Gioia编码证据已准备完成。"
+        status_message = "✅ 定性研究事实、分析设计与证据结构已冻结。"
         return md, status_message, metadata
 
 

core/quantitative_engine.py

@@ -1,8 +1,10 @@
 # -*- coding: utf-8 -*-
-"""Quantitative data preparation for SmartPaper's AMJ track."""
+"""Quantitative evidence preparation for SmartPaper's AMJ-oriented track."""
 
 from __future__ import annotations
 
+import json
+import logging
 import re
 
 import numpy as np
@@ -13,7 +15,7 @@ from utils.file_parser import extract_data_from_files
 
 
 class QuantitativeEngine:
-    """Keep quantitative preparation isolated from the Streamlit UI."""
+    """Prepare one frozen quantitative evidence packet before manuscript writing."""
 
     @staticmethod
     def generate_psd_corr_matrix(n_constructs, max_corr=0.5):
@@ -66,6 +68,68 @@ class QuantitativeEngine:
             )
         return pd.DataFrame(metrics)
 
+    @staticmethod
+    def _safe_constructs(values):
+        cleaned = []
+        for value in values or []:
+            name = re.sub(r"\s+", " ", str(value or "")).strip(" .,:;-_\n\t")
+            if not name or len(name) > 80 or name.lower() in {item.lower() for item in cleaned}:
+                continue
+            cleaned.append(name)
+        return cleaned[:3]
+
+    def _derive_system_design(self, agent, topic="", keywords=""):
+        """Freeze a parsimonious topic-aligned design without inventing named sites."""
+        fallback = {
+            "constructs": [
+                "Focal Predictor",
+                "Focal Mediator",
+                "Focal Outcome",
+            ],
+            "research_context": "respondents with experience relevant to the focal management phenomenon",
+        }
+        if agent is None:
+            return fallback
+        prompt = f"""Design the minimum coherent quantitative management-study skeleton for the topic below.
+Return ONLY valid JSON:
+{{"constructs":["predictor construct","mediating construct","outcome construct"],"research_context":"one generic respondent context"}}
+Rules:
+1. Exactly three distinct constructs in predictor -> mediator -> outcome order.
+2. Use concise construct labels that can appear throughout a journal article.
+3. The context must be generic and directly relevant to the topic. Do NOT name or invent a country, university, firm, industry sample frame, software package, time period, or institution.
+4. This is a cross-sectional single-wave survey design, so do not imply experimental or causal identification.
+5. Do not create any number; sample size and scale are frozen elsewhere.
+Topic: {topic}
+Keywords: {keywords}"""
+        try:
+            raw = agent.call_deepseek(
+                "You are a rigorous management research-design editor.",
+                prompt,
+                max_tokens=500,
+                temp=0.0,
+                model_role="fast",
+                thinking=False,
+                allow_fallback=True,
+            )
+            parsed = agent._extract_json_from_text(raw)
+            if not isinstance(parsed, dict):
+                return fallback
+            constructs = self._safe_constructs(parsed.get("constructs"))
+            context = re.sub(r"\s+", " ", str(parsed.get("research_context") or "")).strip()
+            if len(constructs) != 3:
+                return fallback
+            if not context or len(context) > 240:
+                context = fallback["research_context"]
+            # Named-location/site details are deliberately not accepted from this
+            # design step. The manuscript may remain generic when no user evidence
+            # supplies a real setting.
+            if re.search(r"\b(university|company|corporation|inc\.?|ltd\.?|country|china|usa|united states|europe|asia)\b", context, re.I):
+                context = fallback["research_context"]
+            return {"constructs": constructs, "research_context": context}
+        except Exception as exc:
+            logging.warning("Quantitative study-design freeze fell back safely: %s", exc)
+            return fallback
+
     def generate_empirical_data_robust(
         self,
         construct_names=None,
@@ -74,9 +138,9 @@ class QuantitativeEngine:
     ):
         if not construct_names or len(construct_names) < 2:
             construct_names = [
-                "Independent_Var",
-                "Mediator_Var",
-                "Dependent_Var",
+                "Focal Predictor",
+                "Focal Mediator",
+                "Focal Outcome",
             ]
 
         n_constructs = len(construct_names)
@@ -98,6 +162,7 @@ class QuantitativeEngine:
             loadings = np.random.uniform(0.72, 0.88, n_items)
             true_loadings[construct_name] = loadings
             item_names = []
+            safe_prefix = re.sub(r"[^A-Za-z0-9]+", "_", construct_name).strip("_") or f"Construct_{index + 1}"
             for item_index, loading in enumerate(loadings):
                 error = np.random.normal(
                     0,
@@ -111,7 +176,7 @@ class QuantitativeEngine:
                     1,
                     scale_points,
                 ).astype(int)
-                column_name = f"{construct_name}_{item_index + 1}"
+                column_name = f"{safe_prefix}_{item_index + 1}"
                 data[column_name] = item_int
                 item_names.append(column_name)
             constructs_info.append(
@@ -130,7 +195,8 @@ class QuantitativeEngine:
                 for construct in constructs_info
             }
         )
-        fl_matrix = mean_scores.corr().astype(object)
+        corr_matrix = mean_scores.corr()
+        fl_matrix = corr_matrix.astype(object)
 
         for _, row in validity_df.iterrows():
             construct_name = row["Construct"]
@@ -142,13 +208,109 @@ class QuantitativeEngine:
         for row_index in range(len(fl_matrix.columns)):
             for column_index in range(row_index + 1, len(fl_matrix.columns)):
                 fl_matrix.iloc[row_index, column_index] = ""
+            for column_index in range(row_index):
+                value = fl_matrix.iloc[row_index, column_index]
+                if isinstance(value, (int, float, np.integer, np.floating)):
+                    fl_matrix.iloc[row_index, column_index] = f"{float(value):.3f}"
 
         desc_stats = mean_scores.mean().to_frame("Mean").join(
             mean_scores.std().to_frame("SD")
         )
-        return df, validity_df, desc_stats.join(fl_matrix)
+        return df, validity_df, desc_stats.join(fl_matrix), mean_scores, corr_matrix
+
+    @staticmethod
+    def _standardized_ols(y, predictors):
+        y = np.asarray(y, dtype=float)
+        x = np.column_stack([np.asarray(value, dtype=float) for value in predictors])
+        y_sd = y.std(ddof=1)
+        x_sd = x.std(axis=0, ddof=1)
+        if y_sd <= 0 or np.any(x_sd <= 0):
+            raise RuntimeError("quantitative_zero_variance")
+        yz = (y - y.mean()) / y_sd
+        xz = (x - x.mean(axis=0)) / x_sd
+        design = np.column_stack([np.ones(len(yz)), xz])
+        coef = np.linalg.lstsq(design, yz, rcond=None)[0]
+        fitted = design @ coef
+        ss_res = float(np.sum((yz - fitted) ** 2))
+        ss_tot = float(np.sum((yz - yz.mean()) ** 2))
+        r2 = 0.0 if ss_tot <= 0 else 1.0 - ss_res / ss_tot
+        return coef[1:], max(0.0, min(1.0, r2))
+
+    def _path_evidence(self, mean_scores, construct_names, bootstrap_iterations=1500):
+        if len(construct_names) < 3:
+            return {}, pd.DataFrame(), pd.DataFrame()
+        x_name, m_name, y_name = construct_names[0], construct_names[1], construct_names[2]
+        x = mean_scores[x_name].to_numpy(dtype=float)
+        m = mean_scores[m_name].to_numpy(dtype=float)
+        y = mean_scores[y_name].to_numpy(dtype=float)
+        a_coef, r2_m = self._standardized_ols(m, [x])
+        y_coef, r2_y = self._standardized_ols(y, [x, m])
+        a = float(a_coef[0])
+        direct = float(y_coef[0])
+        b = float(y_coef[1])
+        indirect = a * b
 
-    def resolve_empirical_data(self, uploaded_files=None, language="zh"):
+        rng = np.random.default_rng(20260809)
+        indirect_boot = []
+        direct_boot = []
+        n = len(mean_scores)
+        for _ in range(int(bootstrap_iterations)):
+            idx = rng.integers(0, n, n)
+            try:
+                a_b, _ = self._standardized_ols(m[idx], [x[idx]])
+                y_b, _ = self._standardized_ols(y[idx], [x[idx], m[idx]])
+                indirect_boot.append(float(a_b[0] * y_b[1]))
+                direct_boot.append(float(y_b[0]))
+            except Exception:
+                continue
+        if len(indirect_boot) < 100:
+            raise RuntimeError("quantitative_bootstrap_insufficient")
+        indirect_ci = np.percentile(indirect_boot, [2.5, 97.5])
+        direct_ci = np.percentile(direct_boot, [2.5, 97.5])
+
+        path_table = pd.DataFrame(
+            [
+                {"Association": f"{x_name} → {m_name}", "Standardized estimate": round(a, 3), "R² of outcome": round(r2_m, 3)},
+                {"Association": f"{m_name} → {y_name} (controlling {x_name})", "Standardized estimate": round(b, 3), "R² of outcome": round(r2_y, 3)},
+                {"Association": f"{x_name} → {y_name} (controlling {m_name})", "Standardized estimate": round(direct, 3), "R² of outcome": round(r2_y, 3)},
+                {"Association": f"Indirect association: {x_name} → {m_name} → {y_name}", "Standardized estimate": round(indirect, 3), "R² of outcome": "—"},
+            ]
+        )
+        bootstrap_table = pd.DataFrame(
+            [
+                {"Estimate": "Indirect association", "Point estimate": round(indirect, 3), "95% bootstrap CI lower": round(float(indirect_ci[0]), 3), "95% bootstrap CI upper": round(float(indirect_ci[1]), 3)},
+                {"Estimate": "Residual direct association", "Point estimate": round(direct, 3), "95% bootstrap CI lower": round(float(direct_ci[0]), 3), "95% bootstrap CI upper": round(float(direct_ci[1]), 3)},
+            ]
+        )
+        x_m_corr = float(np.corrcoef(x, m)[0, 1])
+        vif = 1.0 / max(1e-9, 1.0 - x_m_corr**2)
+        spearman = mean_scores.corr(method="spearman")
+        summary = {
+            "predictor": x_name,
+            "mediator": m_name,
+            "outcome": y_name,
+            "a": round(a, 3),
+            "b": round(b, 3),
+            "direct": round(direct, 3),
+            "indirect": round(indirect, 3),
+            "r2_mediator": round(r2_m, 3),
+            "r2_outcome": round(r2_y, 3),
+            "indirect_ci": [round(float(indirect_ci[0]), 3), round(float(indirect_ci[1]), 3)],
+            "direct_ci": [round(float(direct_ci[0]), 3), round(float(direct_ci[1]), 3)],
+            "predictor_mediator_vif": round(float(vif), 3),
+            "bootstrap_iterations": int(bootstrap_iterations),
+        }
+        return summary, path_table, spearman
+
+    def resolve_empirical_data(
+        self,
+        uploaded_files=None,
+        language="zh",
+        *,
+        topic="",
+        keywords="",
+        agent=None,
+    ):
         if uploaded_files:
             user_md = extract_data_from_files(uploaded_files)
             if user_md:
@@ -166,20 +328,58 @@ class QuantitativeEngine:
                     "disclosure_required": False,
                     "evidence_sections": evidence_sections[:20]
                     or ["User-provided quantitative evidence"],
+                    "evidence_boundary": (
+                        "Only values explicitly present in the uploaded evidence are frozen. "
+                        "Do not infer absent setting, sample, measures, software, or results."
+                    ),
                 }
                 return None, user_md, tr(language, "actual_stats_parsed"), metadata
 
-        df, validity_df, fl_matrix_df = self.generate_empirical_data_robust()
-        generated_prompt = f"""### Table 1: Reliability and Convergent Validity
+        design = self._derive_system_design(agent, topic, keywords)
+        construct_names = design["constructs"]
+        df, validity_df, fl_matrix_df, mean_scores, corr_matrix = self.generate_empirical_data_robust(
+            construct_names=construct_names
+        )
+        path_summary, path_table, spearman = self._path_evidence(mean_scores, construct_names)
+        context = design["research_context"]
+        generated_prompt = f"""### Frozen Quantitative Study Design
+| Field | Frozen value |
+| :--- | :--- |
+| Design | Cross-sectional, single-wave questionnaire study |
+| Respondent context | {context} |
+| Sample size | {len(df)} |
+| Response scale | 7-point Likert-type scale |
+| Predictor | {construct_names[0]} |
+| Mediator | {construct_names[1]} |
+| Outcome | {construct_names[2]} |
+| Causal identification | None; report associations and estimated indirect association, not causal effects |
+
+### Table 1: Reliability and Convergent Validity
 {validity_df.to_markdown(index=False)}
+
 ### Table 2: Descriptive Statistics and Discriminant Validity (Fornell-Larcker Criterion)
 *Note: Diagonal elements in parentheses are the square roots of AVE.*
 {fl_matrix_df.to_markdown()}
+
+### Table 3: Frozen Association Model Results
+{path_table.to_markdown(index=False)}
+
+### Table 4: Rank-Order Robustness Correlations (Spearman)
+{spearman.round(3).to_markdown()}
+
+### Frozen Bootstrap and Collinearity Checks
+- Bootstrap resamples: {path_summary['bootstrap_iterations']}.
+- Indirect association ({construct_names[0]} → {construct_names[1]} → {construct_names[2]}): {path_summary['indirect']}; 95% bootstrap CI [{path_summary['indirect_ci'][0]}, {path_summary['indirect_ci'][1]}].
+- Residual direct association ({construct_names[0]} → {construct_names[2]} controlling {construct_names[1]}): {path_summary['direct']}; 95% bootstrap CI [{path_summary['direct_ci'][0]}, {path_summary['direct_ci'][1]}].
+- Predictor/mediator VIF in the outcome model: {path_summary['predictor_mediator_vif']}.
+
 [STRICT EMPIRICAL INSTRUCTION]
-1. ZERO HALLUCINATION: Report the exact metrics provided above.
-2. VALIDITY DEFENSE: State convergent validity only when the displayed AVE and CR values support it.
-3. DISCRIMINANT DEFENSE: State discriminant validity only when the displayed diagonal and correlation values support it.
-4. CONSISTENCY: Use these tables as the single source of numerical truth throughout the paper.
+1. ZERO HALLUCINATION: Every study-specific fact and number must come from this frozen packet. Never invent a country, named organization, sampling frame, response rate, demographic characteristic, measure source, software package, coefficient, p-value, fit index, robustness test, or date.
+2. DESIGN DISCIPLINE: This is a cross-sectional observational survey. Use association language. The indirect estimate is not causal mediation identification.
+3. MEASUREMENT DEFENSE: State reliability/convergent/discriminant validity only when the displayed values support it.
+4. RESULTS DISCIPLINE: Results must report this study's frozen numbers without attaching external citations to the coefficients or sample facts.
+5. ROBUSTNESS: The Spearman matrix, bootstrap intervals, and VIF above are the only frozen robustness evidence. Do not add another robustness procedure.
+6. CONSISTENCY: The predictor, mediator, outcome, sample size, context, scale, and all numerical results above are the single source of quantitative truth throughout the manuscript.
 """
         metadata = {
             "mode": "quantitative",
@@ -187,17 +387,21 @@ class QuantitativeEngine:
             "disclosure_required": True,
             "sample_size": int(len(df)),
             "scale_points": 7,
+            "study_design": "cross-sectional single-wave questionnaire",
+            "research_context": context,
+            "constructs": {
+                "predictor": construct_names[0],
+                "mediator": construct_names[1],
+                "outcome": construct_names[2],
+            },
+            "association_results": path_summary,
             "method": (
-                "Positive-semidefinite latent correlation generation, "
-                "indicator loadings, discretization, and derived "
-                "reliability/validity summaries."
+                "Positive-semidefinite latent correlation generation, indicator loadings, "
+                "Likert discretization, reliability/validity summaries, standardized association "
+                "models, fixed-seed bootstrap intervals, and Spearman robustness correlations."
             ),
             "generation_parameters": {
-                "constructs": [
-                    "Independent_Var",
-                    "Mediator_Var",
-                    "Dependent_Var",
-                ],
+                "constructs": construct_names,
                 "sample_size": int(len(df)),
                 "likert_scale_points": 7,
                 "items_per_construct": "random integer from 3 to 5",
@@ -205,17 +409,28 @@ class QuantitativeEngine:
                 "latent_correlation_control": "positive-semidefinite matrix with maximum target correlation 0.55",
                 "item_generation": "loading × latent score + normally distributed measurement error",
                 "discretization": "round to nearest integer and clamp to 1–7",
+                "bootstrap_iterations": path_summary["bootstrap_iterations"],
+                "bootstrap_seed": 20260809,
                 "reported_summaries": [
                     "Cronbach alpha",
                     "composite reliability",
                     "average variance extracted",
                     "descriptive statistics",
                     "Fornell-Larcker matrix",
+                    "standardized association estimates",
+                    "R-squared",
+                    "bootstrap confidence intervals",
+                    "Spearman correlations",
+                    "VIF",
                 ],
             },
             "evidence_sections": [
+                "Frozen quantitative study design",
                 "Reliability and convergent validity",
                 "Descriptive statistics and discriminant validity",
+                "Frozen association model results",
+                "Rank-order robustness correlations",
+                "Frozen bootstrap and collinearity checks",
             ],
         }
         return (

smartpaper_restore_bridge/frontend/index.html

@@ -24,6 +24,8 @@
   let activeTaskWatch = null;
   let lastMonitorNode = "";
   let lastMonitorCheckpointSeq = 0;
+  let lastPreviewText = "";
+  let lastPreviewDisplayText = "";
 
   const ACTION_PATHS = Object.freeze({
     task_start: "/edge/task/start",
@@ -197,6 +199,102 @@
     feed.scrollTop = feed.scrollHeight;
   }
 
+  function previewUrl(path) {
+    const value = String(path || "").trim();
+    if (!value || !value.startsWith("/app/static/previews/")) return "";
+    try { return new URL(value, window.parent.location.origin).toString(); }
+    catch (_) { return ""; }
+  }
+
+  function appendSafeInline(parentDocument, parent, value) {
+    const parts = String(value || "").split(/(\*\*[^*]+\*\*)/g);
+    for (const part of parts) {
+      if (!part) continue;
+      if (part.startsWith("**") && part.endsWith("**") && part.length > 4) {
+        const strong = parentDocument.createElement("strong");
+        strong.textContent = part.slice(2, -2);
+        parent.appendChild(strong);
+      } else {
+        parent.appendChild(parentDocument.createTextNode(part));
+      }
+    }
+  }
+
+  function renderPreviewContent(parentDocument, target, text) {
+    // Keep one stable text node and append only the newly generated suffix.
+    // Rebuilding the whole manuscript DOM on every preview poll caused visible
+    // repaint/flicker and did not feel like ChatGPT-style streaming.
+    const displayText = String(text || "")
+      .replace(/\r/g, "")
+      .replace(/^#{1,3}\s+/gm, "");
+    let stream = target.querySelector("[data-sp-live-stream='1']");
+    if (!stream) {
+      stream = parentDocument.createElement("div");
+      stream.dataset.spLiveStream = "1";
+      stream.style.whiteSpace = "pre-wrap";
+      stream.style.overflowWrap = "anywhere";
+      stream.style.lineHeight = "1.72";
+      target.replaceChildren(stream);
+      lastPreviewDisplayText = "";
+    }
+    if (displayText.startsWith(lastPreviewDisplayText)) {
+      const delta = displayText.slice(lastPreviewDisplayText.length);
+      if (delta) stream.appendChild(parentDocument.createTextNode(delta));
+    } else {
+      // Resume/recovery or a bounded server-side revision can replace prior
+      // prose. Update the existing node in place rather than replacing the DOM.
+      stream.textContent = displayText;
+    }
+    lastPreviewDisplayText = displayText;
+  }
+
+  function previewShouldFollow(parentWindow, shell) {
+    if (!shell) return false;
+    if (!lastPreviewText) return true;
+    try {
+      const rect = shell.getBoundingClientRect();
+      const viewport = parentWindow.innerHeight || 0;
+      // Follow only while the preview is already on-screen or immediately
+      // below it. A user who scrolls upward is never pulled back down.
+      return rect.top < viewport * 0.92 && rect.bottom > -80;
+    } catch (_) { return false; }
+  }
+
+  function updateManuscriptPreview(payload) {
+    let parentDocument, parentWindow;
+    try { parentDocument = window.parent.document; parentWindow = window.parent; }
+    catch (_) { return; }
+    const target = parentDocument.getElementById("sp-live-manuscript-preview");
+    const shell = parentDocument.getElementById("sp-live-manuscript-shell");
+    if (!target || !shell) return;
+    const text = String(payload && payload.text || "");
+    if (!text || text === lastPreviewText) return;
+    const shouldFollow = previewShouldFollow(parentWindow, shell);
+    renderPreviewContent(parentDocument, target, text);
+    lastPreviewText = text;
+    if (shouldFollow) {
+      // Keep the manuscript viewport pinned to the newest prose without moving
+      // the whole browser page. Whole-page scrolling is reserved for the single
+      // post-launch positioning action in app.py.
+      shell.scrollTop = shell.scrollHeight;
+    }
+  }
+
+  async function fetchPreview(watch) {
+    if (!watch || !watch.previewUrl || activeTaskWatch !== watch || watch.stopped) return;
+    try {
+      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;
+      const epoch = asCount(payload.execution_epoch);
+      if (watch.expectedEpoch > 0 && epoch !== watch.expectedEpoch) return;
+      updateManuscriptPreview(payload);
+    } catch (_) {}
+  }
+
   function updateTaskMonitor(task) {
     let parentDocument;
     try { parentDocument = window.parent.document; }
@@ -231,6 +329,7 @@
     const watch = activeTaskWatch;
     activeTaskWatch = null;
     if (watch && watch.timer) window.clearTimeout(watch.timer);
+    if (watch && watch.previewTimer) window.clearTimeout(watch.previewTimer);
     if (watch && watch.controller) {
       try { watch.controller.abort(); } catch (_) {}
     }
@@ -243,16 +342,30 @@
     const taskId = typeof payload.task_id === "string" ? payload.task_id.trim() : "";
     const requestedInterval = Number(payload.poll_interval_ms || 2000);
     const intervalMs = Math.max(1500, Math.min(10000, Number.isFinite(requestedInterval) ? requestedInterval : 2000));
+    const requestedPreviewInterval = Number(payload.preview_interval_ms || 700);
+    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 initialCheckpointSeq = asCount(payload.initial_checkpoint_seq);
     if (!apiOrigin || !taskId) {
       sendValue({ ok:false, action:"task_watch", command_id:commandId, error:"invalid_task_watch" });
       return;
     }
 
-    const watch = { commandId, taskId, apiOrigin, intervalMs, timer:null, controller:null, stopped:false, lastCheckpointSeq:initialCheckpointSeq };
+    const watch = { commandId, taskId, apiOrigin, intervalMs, previewIntervalMs, previewUrl:resolvedPreviewUrl, expectedEpoch, timer:null, previewTimer:null, controller:null, stopped:false, lastCheckpointSeq:initialCheckpointSeq };
     activeTaskWatch = watch;
+    lastPreviewText = "";
+    lastPreviewDisplayText = "";
     lastMonitorCheckpointSeq = Math.max(lastMonitorCheckpointSeq, initialCheckpointSeq);
 
+    const schedulePreview = () => {
+      if (activeTaskWatch !== watch || watch.stopped || !watch.previewUrl) return;
+      watch.previewTimer = window.setTimeout(async () => {
+        await fetchPreview(watch);
+        schedulePreview();
+      }, watch.previewIntervalMs);
+    };
+
     const schedule = () => {
       if (activeTaskWatch !== watch || watch.stopped) return;
       watch.timer = window.setTimeout(poll, watch.intervalMs);
@@ -281,21 +394,13 @@
         }
         if (checkpointSeq > watch.lastCheckpointSeq) {
           watch.lastCheckpointSeq = checkpointSeq;
-          watch.stopped = true;
-          activeTaskWatch = null;
-          sendValue(Object.assign({}, result, {
-            action:"task_watch",
-            command_id:commandId,
-            terminal:false,
-            boundary:true,
-            boundary_type:"checkpoint"
-          }));
-          return;
         }
       }
       schedule();
     };
 
+    fetchPreview(watch);
+    schedulePreview();
     poll();
   }
 

static/desktop.ini

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

static/previews/.gitkeep

@@ -0,0 +1 @@
+# SmartPaper runtime live-preview directory. Preview JSON is ephemeral and non-authoritative.

static/previews/desktop.ini

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