Update app.py

app.py

@@ -1,7 +1,9 @@
 # -*- coding: utf-8 -*-
-"""Smart Draft - Agentic Two-Pass Pipeline with JIT RAG"""
+"""Smart Draft - Empirical State Machine (HITL & Hybrid Clone Architecture)"""
 
 import streamlit as st
+
+# 🚨 核心修复：必须在引入任何可能包含 Streamlit 动作的本地模块前，先设置 Page Config！
 st.set_page_config(page_title="SSCI Pipeline Agent", page_icon="📊", layout="wide")
 
 import os
@@ -16,13 +18,14 @@ from datetime import datetime, timezone, timedelta
 import pandas as pd
 import numpy as np
 
+# 然后再引入本地模块
 from app_config import APP_CONFIG, AMJ_PROMPTS, GENERIC_PROMPTS
 from utils.file_parser import extract_text_from_files, extract_data_from_files
 from utils.docx_builder import text_to_docx
 from core.pipeline_agent import SSciPipelineAgent
 
 # ==========================================
-# 0. 环境与状态机配置
+# 0. 核心环境、全局变量与状态机准备
 # ==========================================
 os.environ["STREAMLIT_SERVER_ENABLE_CORS"] = "false"
 os.environ["STREAMLIT_SERVER_ENABLE_XSRF_PROTECTION"] = "false"
@@ -31,72 +34,159 @@ global_ds_key = os.environ.get("DEEPSEEK_API_KEY", "")
 if not global_ds_key:
     try: global_ds_key = st.secrets.get("DEEPSEEK_API_KEY", "")
     except: pass
+
 global_s2_key = os.environ.get("S2_API_KEY", "")
+if not global_s2_key:
+    try: global_s2_key = st.secrets.get("S2_API_KEY", "")
+    except: pass
 
+# 状态机：断点续传工作区配置
 WORKSPACE_DIR = ".workspace"
 CHECKPOINT_FILE = os.path.join(WORKSPACE_DIR, "snapshot.json")
-if not os.path.exists(WORKSPACE_DIR): os.makedirs(WORKSPACE_DIR, exist_ok=True)
-
-WECHAT_BLOCKER = "<script>try { if (navigator.userAgent.toLowerCase().indexOf('micromessenger') !== -1) { var d = window.parent.document; if (!d.getElementById('wx-block')) { var o = d.createElement('div'); o.id = 'wx-block'; o.style.cssText = 'position:fixed;top:0;left:0;width:100vw;height:100vh;background:#1a365d;z-index:9999999;color:white;display:flex;align-items:center;justify-content:center;text-align:center;padding:30px;'; o.innerHTML = '<h2>请在外部浏览器打开以支持文件下载</h2>'; d.body.appendChild(o); } } } catch(e) {}</script>"
-components.html(WECHAT_BLOCKER, height=0, width=0)
+if not os.path.exists(WORKSPACE_DIR):
+    os.makedirs(WORKSPACE_DIR, exist_ok=True)
+
+WECHAT_BLOCKER_JS = """
+<script>
+try {
+    var ua = navigator.userAgent.toLowerCase();
+    if (ua.indexOf('micromessenger') !== -1) {
+        var parentDoc = window.parent.document;
+        if (!parentDoc.getElementById('wx-blocker')) {
+            var overlay = parentDoc.createElement('div');
+            overlay.id = 'wx-blocker';
+            overlay.style.cssText = 'position:fixed;top:0;left:0;width:100vw;height:100vh;background:#1a365d;z-index:9999999;color:white;display:flex;flex-direction:column;align-items:center;justify-content:center;text-align:center;font-family:sans-serif;padding:30px;box-sizing:border-box;';
+            overlay.innerHTML = '<h2 style="font-size:26px;margin-bottom:15px;font-weight:bold;">环境受限 / Restricted</h2><p style="font-size:18px;line-height:1.6;color:#e2e8f0;max-width:100%;">为了保障最终双语 ZIP 压缩包正常下载，<b>本系统禁止在微信内直接运行</b>。<br><br>👉 <b>请点击右上角 [···] 菜单，选择“在浏览器打开” (Open in Browser)</b></p>';
+            parentDoc.body.appendChild(overlay);
+        }
+    }
+} catch (e) {}
+</script>
+"""
+components.html(WECHAT_BLOCKER_JS, height=0, width=0)
 
 # ==========================================
-# 1. 蒙特卡洛防幻觉数据引擎 (保持不变)
+# 1. 鲁棒的蒙特卡洛实证模拟引擎 (带严密信效度约束)
 # ==========================================
 def generate_psd_corr_matrix(n_constructs, max_corr=0.5):
+    """动态生成绝对正定矩阵，强制限制最大相关系数以保证区分效度"""
     if n_constructs == 1: return np.array([[1.0]])
+    
     base_corr = np.random.uniform(0.2, max_corr - 0.1) 
     A = np.random.uniform(base_corr - 0.1, base_corr + 0.1, (n_constructs, n_constructs))
     A = (A + A.T) / 2
     np.fill_diagonal(A, 1.0)
+    
     min_eig = np.min(np.linalg.eigvals(A))
-    if min_eig < 0: A -= (min_eig - 0.01) * np.eye(n_constructs)
+    if min_eig < 0:
+        A -= (min_eig - 0.01) * np.eye(n_constructs)
+    
     d = np.sqrt(np.diag(A))
     return A / np.outer(d, d)
 
-def generate_empirical_data_robust(construct_names=None, n=300):
-    if not construct_names or len(construct_names) < 2: construct_names = ["IV", "Mediator", "DV"]
+def calculate_validity_metrics(df, constructs_info, true_loadings):
+    """动态计算信度与效度 (Cronbach's alpha, CR, AVE)"""
+    metrics = []
+    for const in constructs_info:
+        c_name = const['name']
+        items = const['items']
+        
+        # 经验 Cronbach's Alpha
+        sub_df = df[items]
+        var_total = sub_df.sum(axis=1).var(ddof=1)
+        sum_var = sub_df.var(ddof=1).sum()
+        n_items = len(items)
+        alpha = 0.0 if var_total <= 0 else (n_items / (n_items - 1)) * (1 - sum_var / var_total)
+        
+        # 理论 CR & AVE
+        c_loadings = np.array(true_loadings[c_name])
+        sum_loadings_sq = np.sum(c_loadings)**2
+        sum_sq_loadings = np.sum(c_loadings**2)
+        sum_error = np.sum(1 - c_loadings**2)
+        
+        cr = sum_loadings_sq / (sum_loadings_sq + sum_error)
+        ave = sum_sq_loadings / len(c_loadings)
+        
+        metrics.append({
+            "Construct": c_name,
+            "Items": n_items,
+            "Cronbach's α": round(alpha, 3),
+            "CR": round(cr, 3),
+            "AVE": round(ave, 3)
+        })
+    return pd.DataFrame(metrics)
+
+def generate_empirical_data_robust(construct_names=None, n=300, scale_points=7):
+    """全自适应的实证数据生成器"""
+    if not construct_names or len(construct_names) < 2:
+        construct_names = ["Independent_Var", "Mediator_Var", "Dependent_Var"]
+        
     n_constructs = len(construct_names)
-    latent_scores = np.random.multivariate_normal(mean=[0]*n_constructs, cov=generate_psd_corr_matrix(n_constructs), size=n)
-    data, true_loadings, info = {}, {}, []
+    corr = generate_psd_corr_matrix(n_constructs, max_corr=0.55)
+    latent_scores = np.random.multivariate_normal(mean=[0]*n_constructs, cov=corr, size=n)
+    
+    data, true_loadings, constructs_info = {}, {}, []
+    target_mean = scale_points / 2.0 + 0.5
+    target_std = scale_points / 5.0
+    
     for idx, c_name in enumerate(construct_names):
         true_score = latent_scores[:, idx]
-        loadings = np.random.uniform(0.72, 0.88, np.random.randint(3, 6))
+        n_items = np.random.randint(3, 6) 
+        loadings = np.random.uniform(0.72, 0.88, n_items) # 数学约束：确保 AVE > 0.5
         true_loadings[c_name] = loadings
+        
         item_names = []
         for i, load in enumerate(loadings):
-            item_score = load * true_score + np.random.normal(0, np.sqrt(1 - load**2), n)
+            error = np.random.normal(0, np.sqrt(1 - load**2), n)
+            item_score = load * true_score + error 
+            raw_scaled = item_score * target_std + target_mean
+            item_int = np.clip(np.round(raw_scaled), 1, scale_points).astype(int)
             col_name = f"{c_name}_{i+1}"
-            data[col_name] = np.clip(np.round(item_score * 1.4 + 4), 1, 7).astype(int)
+            data[col_name] = item_int
             item_names.append(col_name)
-        info.append({"name": c_name, "items": item_names})
-    
+            
+        constructs_info.append({"name": c_name, "items": item_names})
+        
     df = pd.DataFrame(data)
-    metrics = []
-    for c in info:
-        sub = df[c['items']]
-        var_t, sum_v, k = sub.sum(axis=1).var(ddof=1), sub.var(ddof=1).sum(), len(c['items'])
-        alpha = 0.0 if var_t <= 0 else (k / (k - 1)) * (1 - sum_v / var_t)
-        load = np.array(true_loadings[c['name']])
-        cr = np.sum(load)**2 / (np.sum(load)**2 + np.sum(1 - load**2))
-        ave = np.sum(load**2) / k
-        metrics.append({"Construct": c['name'], "Items": k, "Cronbach's α": round(alpha, 3), "CR": round(cr, 3), "AVE": round(ave, 3)})
-    val_df = pd.DataFrame(metrics)
+    validity_df = calculate_validity_metrics(df, constructs_info, true_loadings)
     
-    mean_scores = pd.DataFrame({c['name']: df[c['items']].mean(axis=1) for c in info})
+    mean_scores = pd.DataFrame({c['name']: df[c['items']].mean(axis=1) for c in constructs_info})
     fl_matrix = mean_scores.corr()
-    for i, row in val_df.iterrows(): fl_matrix.loc[row['Construct'], row['Construct']] = f"({np.sqrt(row['AVE']):.3f})"
+    
+    for i, row in validity_df.iterrows():
+        c_name = row['Construct']
+        sqrt_ave = np.sqrt(row['AVE'])
+        fl_matrix.loc[c_name, c_name] = f"({sqrt_ave:.3f})"
+        
     for i in range(len(fl_matrix.columns)):
-        for j in range(i + 1, len(fl_matrix.columns)): fl_matrix.iloc[i, j] = ""
-    return df, val_df, mean_scores.mean().to_frame('Mean').join(mean_scores.std().to_frame('SD')).join(fl_matrix)
+        for j in range(i + 1, len(fl_matrix.columns)):
+            fl_matrix.iloc[i, j] = ""
+
+    desc_stats = mean_scores.mean().to_frame('Mean').join(mean_scores.std().to_frame('SD'))
+    return df, validity_df, desc_stats.join(fl_matrix)
 
 def resolve_empirical_data(extracted_vars=None):
-    df, val_df, fl_matrix = generate_empirical_data_robust(extracted_vars)
-    prompt = f"### Table 1: Validity\n{val_df.to_markdown(index=False)}\n\n### Table 2: Discriminant\n{fl_matrix.to_markdown()}\n[STRICT INSTRUCTION]: ZERO HALLUCINATION. Report exact metrics. State AVE>0.5 establishes Convergent Validity."
-    return df, prompt, "✅ 已启用蒙特卡洛防幻觉引擎"
+    """路由层：生成数据并返回 LLM 专用的 Markdown 提示词"""
+    df, validity_df, fl_matrix_df = generate_empirical_data_robust(extracted_vars)
+    
+    simulated_md_prompt = f"""
+### 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()}
+
+[STRICT EMPIRICAL INSTRUCTION]
+1. ZERO HALLUCINATION: You MUST report the exact metrics (Cronbach's α, CR, AVE, correlations) provided in the tables above.
+2. VALIDITY DEFENSE: Explicitly state that Convergent Validity is established because all AVEs > 0.5 and CRs > 0.7.
+3. DISCRIMINANT DEFENSE: Explicitly state that Discriminant Validity is satisfied per the Fornell-Larcker criterion, as the square root of AVE (diagonal values) exceeds inter-construct correlations.
+"""
+    status_msg = "✅ 已成功启用稳健信效度生成引擎，AVE与Fornell-Larcker准则均验证达标。"
+    return df, simulated_md_prompt, status_msg
 
 # ==========================================
-# 2. UI 布局与拦截器
+# 2. UI 界面布局与初始化
 # ==========================================
 if "is_running" not in st.session_state: st.session_state.is_running = False
 if "start_pipeline" not in st.session_state: st.session_state.start_pipeline = False
@@ -104,262 +194,530 @@ if "resume_pipeline" not in st.session_state: st.session_state.resume_pipeline =
 if "zip_buffer" not in st.session_state: st.session_state.zip_buffer = None
 if "run_mode" not in st.session_state: st.session_state.run_mode = "wizard"
 
-lang_choice = st.radio("Lang", list(APP_CONFIG["ui_labels"].keys()), horizontal=True, label_visibility="collapsed")
+lang_choice = st.radio("Language", list(APP_CONFIG["ui_labels"].keys()), horizontal=True, label_visibility="collapsed")
 ui, target_lang = APP_CONFIG["ui_labels"][lang_choice], APP_CONFIG["target_lang_map"][lang_choice]
 st.markdown(f"<div class='main-title'><h2>{ui['title']}</h2></div>", unsafe_allow_html=True)
 
-# 断点恢复拦截器
-if os.path.exists(CHECKPOINT_FILE) and not st.session_state.is_running:
-    st.warning("⚠️ 系统检测到上次因网络或意外中断的未完成任务。")
-    c1, c2 = st.columns([1, 1])
-    if c1.button("🔄 恢复断点续传 (Resume Task)"):
-        st.session_state.resume_pipeline, st.session_state.start_pipeline = True, False
+# 状态机：如果存在未完成快照，拦截并提示用户恢复
+if os.path.exists(CHECKPOINT_FILE) and not (st.session_state.is_running):
+    st.warning("⚠️ 系统检测到上次因网络或意外中断的未完成论文任务。")
+    colA, colB = st.columns([1, 1])
+    if colA.button("🔄 恢复断点续传 (Resume Progress)", key="resume_task"):
+        st.session_state.resume_pipeline = True
+        st.session_state.start_pipeline = False
         st.rerun()
-    if c2.button("🗑️ 清除临时数据 (Clear Data)"):
+    if colB.button("🗑️ 清除临时数据 (Clear Garbage)", key="clear_task"):
         os.remove(CHECKPOINT_FILE)
         st.rerun()
     st.markdown("---")
 
 topic = st.text_input(ui["topic_label"], value="虚拟旅游体验对实地旅游意愿的影响研究", disabled=st.session_state.is_running)
-keywords = st.text_input(ui["keywords_label"], value="临场感；国家公园；虚拟旅游；消费者行为", disabled=st.session_state.is_running)
+keywords = st.text_input(ui["keywords_label"], value="临场感；国家公园；全景漫游体验；虚拟旅游体验；消费者行为", disabled=st.session_state.is_running)
 words = st.number_input(ui["words_label"], min_value=500, max_value=50000, value=10000, step=500, disabled=st.session_state.is_running)
 
-tab_wiz, tab_clone = st.tabs(["✨ 智能向导模式", "🧬 靶向克隆模式"])
+tab_wizard, tab_clone = st.tabs(["✨ 智能向导模式 (Smart Wizard)", "🧬 靶向克隆模式 (Clone Mode)"])
 
-with tab_wiz:
-    prompt_style_ui = st.radio("1. 写作规范：", ["工商管理实证研究 (AMJ Style)", "通用学术规范 (Generic Style)"], index=0, disabled=st.session_state.is_running)
-    up_papers = st.file_uploader("2. 上传参考论文 (可选)", type=["pdf", "docx"], accept_multiple_files=True, disabled=st.session_state.is_running)
-    up_data = st.file_uploader("3. 上传科研数据 (可选)", type=["csv", "xlsx"], disabled=st.session_state.is_running)
-    if st.button("🚀 启动生成", disabled=st.session_state.is_running, key="b1"):
-        st.session_state.run_mode, st.session_state.start_pipeline = "wizard", True
+with tab_wizard:
+    st.markdown("### 🛠️ 人在环路：研究材料配置")
+    prompt_style_ui = st.radio("1. 请选择期望的写作规范与提示词引擎：", 
+                               options=["工商管理实证研究 (AMJ Style)", "通用学术规范 (Generic Style)", "🤖 自动嗅探 (Auto-detect)"], 
+                               index=0, disabled=st.session_state.is_running)
+    uploaded_papers_wiz = st.file_uploader("2. 上传核心参考论文 (可选，支持 PDF/DOCX，强制优先引用)", type=["pdf", "doc", "docx"], accept_multiple_files=True, disabled=st.session_state.is_running)
+    uploaded_data_wiz = st.file_uploader("3. 上传统计分析结果 (可选，支持 CSV/Excel，用于 Results 章��数据支撑)", type=["csv", "xlsx", "xls"], disabled=st.session_state.is_running)
+    
+    if st.button("🚀 启动智能向导生成", disabled=st.session_state.is_running, key="btn_wiz"):
+        st.session_state.run_mode = "wizard"
+        st.session_state.start_pipeline = True
         st.rerun()
 
 with tab_clone:
-    ctx_diff = st.text_area("1. 研究背景与核心差异（必填）", placeholder="简述新研究与范例论文的区别...", max_chars=2000, disabled=st.session_state.is_running)
-    if "extracted_sections" not in st.session_state: st.session_state.extracted_sections = []
-    up_ref_clone = st.file_uploader("2. 上传范例论文 (必填)", type=["pdf", "docx"], key="cr", disabled=st.session_state.is_running)
+    st.markdown("### 🧬 高级克隆：骨架与风格复刻")
+    context_differences = st.text_area(
+        "1. 研究背景与核心差异（Context & Differences）【必填，建议 1-2000 字】", 
+        placeholder="简述您的新研究与参考论文在数据、案例或背景上的核心区别...", 
+        max_chars=2000,
+        disabled=st.session_state.is_running
+    )
     
-    if up_ref_clone and global_ds_key and not st.session_state.extracted_sections:
-        with st.spinner("🔍 提取范例目录中..."):
-            tmp_ag = SSciPipelineAgent(global_ds_key)
-            ref_txt = extract_text_from_files([up_ref_clone])
-            st.session_state.extracted_sections = tmp_ag.extract_document_structure(ref_txt)
-            st.success(f"已提取克隆结构：{', '.join(st.session_state.extracted_sections)}")
-            
-    up_data_clone = st.file_uploader("3. 上传科研数据 (可选)", type=["csv", "xlsx"], key="cd", disabled=st.session_state.is_running)
-    if st.button("🚀 启动克隆", disabled=st.session_state.is_running, key="b2"):
-        if not ctx_diff.strip() or not up_ref_clone: st.error("必须填写差异并上传范例！")
+    if "extracted_sections" not in st.session_state:
+        st.session_state.extracted_sections = ["Introduction", "Literature Review", "Methodology", "Results", "Discussion"]
+    if "last_uploaded_clone_ref" not in st.session_state:
+        st.session_state.last_uploaded_clone_ref = None
+
+    uploaded_reference_clone = st.file_uploader("2. 上传范例参考论文 (必填，支持 PDF/DOCX，系统将自动静默提取全文档目录)", type=["pdf", "doc", "docx"], key="clone_ref", disabled=st.session_state.is_running)
+    
+    if uploaded_reference_clone and global_ds_key:
+        if st.session_state.last_uploaded_clone_ref != uploaded_reference_clone.name:
+            with st.spinner("🔍 正在智能提取该范例论文的真实目录结构，请稍候..."):
+                temp_agent = SSciPipelineAgent(global_ds_key, global_s2_key)
+                ref_text_raw = extract_text_from_files([uploaded_reference_clone])
+                dynamic_sections = temp_agent.extract_document_structure(ref_text_raw)
+                
+                st.session_state.extracted_sections = dynamic_sections
+                st.session_state.last_uploaded_clone_ref = uploaded_reference_clone.name
+                st.success(f"✅ 目录提取成功，将自动全量克隆以下结构：{', '.join(dynamic_sections)}")
+    
+    uploaded_data_clone = st.file_uploader("3. 上传统计分析结果 (可选，用于实证章节防幻觉支撑)", type=["csv", "xlsx", "xls"], key="clone_data", disabled=st.session_state.is_running)
+
+    if st.button("🚀 启动克隆级生成", disabled=st.session_state.is_running, key="btn_clone"):
+        if not context_differences.strip():
+            st.error("🚨 启动克隆模式必须填写研究背景与核心差异！")
+        elif not uploaded_reference_clone:
+            st.error("🚨 启动克隆模式必须上传范例论文！")
         else:
-            st.session_state.run_mode, st.session_state.start_pipeline = "clone", True
+            st.session_state.run_mode = "clone"
+            st.session_state.start_pipeline = True
             st.rerun()
 
-progress_bar, monitor_ui = st.empty(), st.empty()
-def render_monitor(ag, phase, sec="", dets=""):
-    monitor_ui.markdown(f"<div style='border:1px solid #ddd;padding:10px;border-radius:5px;'><b>🔄 {phase}</b> | 📍 {sec} <br>📝 {dets}<br>📡 Calls - DeepSeek: {ag.ds_calls} | OpenAlex: {ag.oa_calls} | S2: {ag.s2_calls}</div>", unsafe_allow_html=True)
+progress_bar = st.empty()
+monitor_ui = st.empty()
+
+def render_monitor(agent, phase, current_sec="", details=""):
+    monitor_ui.markdown(f"""
+    <div class='log-box'>
+        <div><b>🔄 流水线进度:</b> {phase}</div>
+        <div><b>📍 当前节点:</b> {current_sec}</div>
+        <div><b>📝 动作日志:</b> {details}</div>
+        <hr>
+        <div><b>📡 三维算力消耗监控:</b></div>
+        <div style='display: flex; gap: 8px;'>
+            <span style='background: #fef3c7; padding: 4px 8px; border-radius: 4px;'>🧠 DeepSeek: <b>{agent.ds_calls}</b></span>   
+            <span style='background: #d1fae5; padding: 4px 8px; border-radius: 4px;'>🌐 OpenAlex: <b>{agent.oa_calls}</b></span>
+            <span style='background: #dbeafe; padding: 4px 8px; border-radius: 4px;'>📚 S2: <b>{agent.s2_calls}</b></span>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+FLAG_MAP = {"Simplified Chinese (简体中文)": "🇨🇳", "Russian (Русский)": "🇷🇺", "Kazakh (Қазақша)": "🇰🇿"}
 
 # ==========================================
-# 3. 后台流水线执行 (Agentic Two-Pass + JIT)
+# 3. 后台流水线执行 (融合断点续传逻辑)
 # ==========================================
 if st.session_state.start_pipeline or st.session_state.resume_pipeline:
-    if not global_ds_key: st.stop()
+    if not global_ds_key:
+        st.error("❌ DEEPSEEK_API_KEY missing. 请配置API KEY。")
+        st.stop()
+        
     st.session_state.is_running = True
+    is_resume = st.session_state.resume_pipeline
     agent = SSciPipelineAgent(global_ds_key, global_s2_key)
     
     try:
-        # ---- 状态机加载/初始化 ----
-        if st.session_state.resume_pipeline:
-            pb = progress_bar.progress(50, text="🔄 从快照恢复状态...")
-            with open(CHECKPOINT_FILE, "r", encoding="utf-8") as f: state = json.load(f)
-            topic, keywords, target_lang, words = state["topic"], state["keywords"], state["target_lang"], state["words"]
-            user_data_md, user_lit_context = state["user_data_md"], state["user_lit_context"]
+        if is_resume:
+            pb = progress_bar.progress(50, text="🔄 正在从本地安全快照恢复状态...")
+            with open(CHECKPOINT_FILE, "r", encoding="utf-8") as f:
+                state = json.load(f)
+            
+            # 从状态机恢复核心配置，规避 Streamlit 组件刷新丢失的问题
+            topic = state["topic"]
+            keywords = state["keywords"]
+            target_lang = state["target_lang"]
+            words = state["words"]
+            user_data_md = state["user_data_md"]
+            user_lit_context = state["user_lit_context"]
+            
+            # 恢复 Agent 及核心变量
             agent.load_state(state["agent_state"])
-            adaptive_structure, completed_sections = state["adaptive_structure"], state["completed_sections"]
-            full_draft_en, full_draft_translated = state["full_draft_en"], state["full_draft_translated"]
-            synthesis_result, clone_metadata = state["synthesis_result"], state["clone_metadata"]
+            adaptive_structure = state["adaptive_structure"]
+            completed_sections = state["completed_sections"]
+            full_draft_en = state["full_draft_en"]
+            full_draft_translated = state["full_draft_translated"]
+            synthesis_result = state["synthesis_result"]
+            refs_text = state["refs_text"]
+            clone_metadata = state["clone_metadata"]
             context_tail = state["context_tail"]
+            st.session_state.run_mode = state.get("run_mode", "wizard")
             APP_CONFIG.update(state.get("prompt_config", GENERIC_PROMPTS))
+            
+            st.success(f"✅ 断点加载成功！将从节点 {len(completed_sections)}/{len(adaptive_structure)} 安全恢复。")
+            
         else:
             pb = progress_bar.progress(1, text="⏳ 流水线启动...")
-            user_lit_context, user_data_md = "", ""
-            if st.session_state.run_mode == "wizard":
-                if up_papers: user_lit_context = extract_text_from_files(up_papers)
-                if up_data: user_data_md = extract_data_from_files(up_data)
-            else:
-                reference_paper_text = extract_text_from_files([up_ref_clone])
-                if up_data_clone: user_data_md = extract_data_from_files(up_data_clone)
-
-            if not user_data_md: _, user_data_md, m = resolve_empirical_data(); st.info(m)
             
-            # 选择风格引擎
-            cfg = AMJ_PROMPTS if ("AMJ" in prompt_style_ui or agent._is_empirical_business_research(topic, keywords)) else GENERIC_PROMPTS
-            APP_CONFIG.update(cfg)
+            user_lit_context = ""
+            user_data_md = ""
+            if st.session_state.run_mode == "wizard":
+                if uploaded_papers_wiz: user_lit_context = extract_text_from_files(uploaded_papers_wiz)
+                if uploaded_data_wiz: user_data_md = extract_data_from_files(uploaded_data_wiz)
+            elif st.session_state.run_mode == "clone":
+                if uploaded_reference_clone: reference_paper_text = extract_text_from_files([uploaded_reference_clone])
+                if uploaded_data_clone: user_data_md = extract_data_from_files(uploaded_data_clone)
+
+            if not user_data_md:
+                with st.spinner("⚙️ 检测到未上传数据，正在通过蒙特卡洛引擎生成合格的底层防幻觉数据..."):
+                    sim_df, sim_md_prompt, sim_msg = resolve_empirical_data()
+                    user_data_md = sim_md_prompt 
+                    st.info(sim_msg)
+
+            # ��始化底层状态机参数
+            state = {
+                "topic": topic, "keywords": keywords, "target_lang": target_lang, "words": words,
+                "user_data_md": user_data_md, "user_lit_context": user_lit_context,
+                "completed_sections": [], "full_draft_en": "", "full_draft_translated": "",
+                "context_tail": "", "clone_metadata": {}, "run_mode": st.session_state.run_mode
+            }
+
+            pb.progress(5, text="🕵️ 引擎配置与范式路由...")
+            is_emp = False
+            if st.session_state.run_mode == "wizard":
+                if "AMJ" in prompt_style_ui:
+                    APP_CONFIG.update(AMJ_PROMPTS)
+                    st.success("🎯 用户显式指定：强制启用 AMJ 顶级期刊写作引擎。")
+                elif "Generic" in prompt_style_ui:
+                    APP_CONFIG.update(GENERIC_PROMPTS)
+                    st.info("ℹ️ 用户显式指定：启用通用学术规范引擎。")
+                else:
+                    is_emp = agent._is_empirical_business_research(topic, keywords)
+                    if is_emp: APP_CONFIG.update(AMJ_PROMPTS)
+                    else: APP_CONFIG.update(GENERIC_PROMPTS)
             
+            state["prompt_config"] = AMJ_PROMPTS if is_emp or "AMJ" in prompt_style_ui else GENERIC_PROMPTS
+
             clone_metadata = {}
             if st.session_state.run_mode == "clone":
-                pb.progress(5, text="🧬 逆向解构范例...")
+                pb.progress(8, text="🧬 正在对参考论文进行逆向解构...")
                 for sec_tgt in st.session_state.extracted_sections:
                     clone_metadata[sec_tgt] = agent.reverse_engineer_section(reference_paper_text, sec_tgt)
-
-            pb.progress(10, text="📚 种子文献检索 (Seed RAG)...")
-            render_monitor(agent, "全局种子检索", "API", "提取大纲所需支撑...")
-            seed_refs = agent.fetch_seed_references(topic, keywords)
+                st.success(f"🧬 逆向解构完成！已提取 {len(clone_metadata)} 个目标章节的骨架与风格。")
+                state["clone_metadata"] = clone_metadata
+
+            pb.progress(10, text="📚 文献检索...")
+            render_monitor(agent, "文献检索", "S2 + OpenAlex", "智能检索中...")
+            refs_text = agent.fetch_references_parallel(topic, keywords)
+            if not refs_text and len(agent.citation_map) == 0:
+                st.session_state.is_running = False
+                st.stop()
+            if len(agent.citation_map) < 80: 
+                st.warning(f"文献数量仅 {len(agent.citation_map)} 篇，可能影响引用数量，继续生成...")
+            state["refs_text"] = refs_text
+
+            pb.progress(12, text="🧠 文献综合...")
+            synthesis_result = agent.synthesize_literature(topic, refs_text, user_core_literature=user_lit_context)
+            state["synthesis_result"] = synthesis_result
             
-            pb.progress(15, text="🧠 文献综合与锚点生成...")
-            synthesis_result = agent.synthesize_literature(topic, seed_refs, user_lit_context)
-            abs_anc, conc_anc = agent.generate_anchors(topic, keywords, synthesis_result, seed_refs)
-            agent.global_memory["abstract_anchor"], agent.global_memory["conclusion_anchor"] = abs_anc, conc_anc
+            pb.progress(14, text="⚓ 生成锚点...")
+            abstract_anchor, conclusion_anchor = agent.generate_anchors(topic, keywords, synthesis_result, refs_text)
+            agent.global_memory["abstract_anchor"] = abstract_anchor
+            agent.global_memory["conclusion_anchor"] = conclusion_anchor
             
+            pb.progress(15, text="📝 大纲设计...")
             plan = agent.generate_outline(topic, keywords, synthesis_result)
-            en_topic, en_keywords = plan["en_topic"], plan["en_keywords"]
+            en_topic, en_keywords, structure = plan["en_topic"], plan["en_keywords"], plan["structure"]
 
-            t_abs = re.sub(r'(?i)^(摘要|abstract|аннотация|түйіндеме)[:\s]*', '', agent.call_deepseek(f"Translate into {target_lang}. ONLY text.", abs_anc, max_tokens=1500)).strip()
-            la = {"Simplified Chinese (简体中文)": "摘要", "Russian (Русский)": "Аннотация", "Kazakh (Қазақша)": "Түйіндеме"}.get(target_lang, "Abstract")
-            lk = {"Simplified Chinese (简体中文)": "关键词", "Russian (Русский)": "Ключевые слова", "Kazakh (Қазақша)": "Кілт сөздер"}.get(target_lang, "Keywords")
+            en_abstract_clean = re.sub(r'(?i)^abstract[:\s]*', '', abstract_anchor).strip()
+            en_keywords_clean = re.sub(r'(?i)^keywords[:\s]*', '', en_keywords).strip()
+            trans_abstract = agent.call_deepseek(f"Translate the following abstract into {target_lang}. Output ONLY translated text without prefix.", abstract_anchor, max_tokens=1500)
+            trans_abstract_clean = re.sub(r'(?i)^(摘要|abstract|аннотация|түйіндеме)[:\s]*', '', trans_abstract).strip()
+            
+            loc_abs = {"Simplified Chinese (简体中文)": "摘要", "Russian (Русский)": "Аннотация", "Kazakh (Қазақша)": "Түйіндеме"}.get(target_lang, "Abstract")
+            loc_kw = {"Simplified Chinese (简体中文)": "关键词", "Russian (Русский)": "Ключевые слова", "Kazakh (Қазақша)": "Кілт сөздер"}.get(target_lang, "Keywords")
 
-            full_draft_en = f"# {en_topic}\n\n## Abstract\n{re.sub(r'(?i)^abstract[:\s]*', '', abs_anc).strip()}\n\n## Keywords\n{re.sub(r'(?i)^keywords[:\s]*', '', en_keywords).strip()}\n\n"
-            full_draft_translated = f"# {topic}\n\n## {la}\n{t_abs}\n\n## {lk}\n{keywords}\n\n"
+            full_draft_en = f"# {en_topic}\n\n## Abstract\n{en_abstract_clean}\n\n## Keywords\n{en_keywords_clean}\n\n"
+            full_draft_translated = f"# {topic}\n\n## {loc_abs}\n{trans_abstract_clean}\n\n## {loc_kw}\n{keywords}\n\n"
 
+            SAFE_CHUNK_WORDS = agent.chunk_words_cyrillic if target_lang in ["Russian (Русский)", "Kazakh (Қазақша)"] else agent.chunk_words_default
             adaptive_structure = []
-            for sec in plan["structure"]:
-                s_name = sec.get("section", "Section")
-                t_words = int(words * sec.get("weight", 0.1))
-                if t_words > agent.chunk_words_default:
-                    num_c = max(2, math.ceil(t_words / agent.chunk_words_default))
-                    for i in range(num_c): adaptive_structure.append({"section": s_name, "display_name": f"{s_name} (Part {i+1}/{num_c})", "target_words": int(t_words/num_c), "is_first": i==0, "is_mor": sec.get("is_method_or_result", False)})
-                else: adaptive_structure.append({"section": s_name, "display_name": s_name, "target_words": t_words, "is_first": True, "is_mor": sec.get("is_method_or_result", False)})
+            for sec in structure:
+                sec_name = sec.get("section", "Section")
+                is_method_or_result = sec.get("is_method_or_result", False)
+                target_sec_words = int(words * sec.get("weight", 0.1))
+                if target_sec_words > SAFE_CHUNK_WORDS:
+                    num_chunks = max(2, math.ceil(target_sec_words / SAFE_CHUNK_WORDS))
+                    for i in range(num_chunks):
+                        adaptive_structure.append({"section": sec_name, "display_name": f"{sec_name} (Part {i+1}/{num_chunks})", "target_words": int(target_sec_words/num_chunks), "is_first": i==0, "is_method_or_result": is_method_or_result})
+                else:
+                    adaptive_structure.append({"section": sec_name, "display_name": sec_name, "target_words": target_sec_words, "is_first": True, "is_method_or_result": is_method_or_result})
             
-            state = {"topic": topic, "keywords": keywords, "target_lang": target_lang, "words": words, "user_data_md": user_data_md, "user_lit_context": user_lit_context, "completed_sections": [], "full_draft_en": full_draft_en, "full_draft_translated": full_draft_translated, "context_tail": "", "clone_metadata": clone_metadata, "prompt_config": cfg, "adaptive_structure": adaptive_structure, "synthesis_result": synthesis_result}
+            state["adaptive_structure"] = adaptive_structure
             state["agent_state"] = agent.export_state()
-            with open(CHECKPOINT_FILE, "w", encoding="utf-8") as f: json.dump(state, f, ensure_ascii=False)
-            completed_sections, context_tail = [], ""
+            state["full_draft_en"] = full_draft_en
+            state["full_draft_translated"] = full_draft_translated
+            completed_sections = []
+            context_tail = ""
+            
+            with open(CHECKPOINT_FILE, "w", encoding="utf-8") as f:
+                json.dump(state, f, ensure_ascii=False)
 
-        # ---- 微观循环生成 (Two-Pass WorkFlow) ----
+        # ====== 核心循环块：完全兼容断点读取 ======
+        total_steps = len(adaptive_structure) * 2
+        current_step = len(completed_sections) * 2
         st.markdown("---")
-        total_steps = len(adaptive_structure)
-        generation_aborted = False
-
-        for current_idx, sec in enumerate(adaptive_structure):
-            if generation_aborted: break
+        ui_blocks = []
+        target_flag = FLAG_MAP.get(target_lang, "🌐")
+        
+        # 先渲染 UI 占位符，识别哪些已经恢复
+        for sec in adaptive_structure:
             display_name = sec["display_name"]
             st.markdown(f"### ⚙️ {display_name}")
-            colA, colB = st.columns(2)
-            with colA: ph_en = st.empty()
-            with colB: ph_tr = st.empty()
+            col_en, col_trans = st.columns(2)
+            with col_en:
+                st.markdown("#### 🇬🇧 英文初稿")
+                en_ph = st.empty()
+            with col_trans:
+                st.markdown(f"#### {target_flag} 翻译初稿")
+                trans_ph = st.empty()
+                
+            if display_name in completed_sections:
+                en_ph.success("✅ 已从快照安全恢复并拼接")
+                trans_ph.success("✅ 已从快照安全恢复并拼接")
+            else:
+                en_ph.info("⏳ 等待执行...")
+                trans_ph.info("⏳ 等待...")
+            ui_blocks.append({"sec": sec, "en_ph": en_ph, "trans_ph": trans_ph})
 
+        generation_aborted = False
+        accumulated_deviation = 0
+        remaining_sections = len(adaptive_structure)
+
+        all_cite_keys = list(agent.citation_map.keys())
+        valid_chunks = [s for s in adaptive_structure if not any(kw in s["section"].lower() for kw in ["abstract", "keyword", "摘要", "关键字"])]
+        allocation_map = {}
+        current_cite_idx = 0
+        for idx, vc in enumerate(valid_chunks):
+            if idx == len(valid_chunks) - 1: allocation_map[vc["display_name"]] = all_cite_keys[current_cite_idx:]
+            else:
+                num_cites = max(1, math.ceil(len(all_cite_keys) / len(valid_chunks)))
+                allocation_map[vc["display_name"]] = all_cite_keys[current_cite_idx : current_cite_idx + num_cites]
+                current_cite_idx += num_cites
+
+        for i, block in enumerate(ui_blocks):
+            if generation_aborted: break
+            sec = block["sec"]; en_ph = block["en_ph"]; trans_ph = block["trans_ph"]
+            sec_title = sec["section"]; display_name = sec["display_name"]
+            
             if display_name in completed_sections:
-                ph_en.success("✅ [已从快照恢复]"); ph_tr.success("✅ [已从快照恢复]")
-                continue
+                remaining_sections -= 1
+                continue # 直接跳过已生成的步骤
                 
-            pb.progress(20 + int((current_idx/total_steps)*70), text=f"正在生成 {display_name}...")
+            remaining_sections -= 1
+            adjustment = -accumulated_deviation / remaining_sections if remaining_sections > 0 else 0
+            adjusted_target = max(50, int(sec['target_words'] + adjustment))
             
-            # JIT RAG: 实时补充弹药
-            is_quarantine = any(k in sec["section"].lower() for k in ["abstract", "keyword", "conclusion", "reference"])
-            if not is_quarantine:
-                render_monitor(agent, "JIT RAG", display_name, "实时检索支撑文献...")
-                agent.fetch_jit_references(sec["section"], topic, context_tail)
+            quarantine_keywords = ["abstract", "keyword", "摘要", "关键字", "关键词", "conclusion", "结论", "заключение", "қорытынды", "references"]
+            is_quarantined = any(kw in sec_title.lower() for kw in quarantine_keywords)
             
-            local_context_str, local_cites = agent.get_pruned_context(sec["section"])
-            q_rule = "【NO IN-TEXT CITATIONS ALLOWED HERE】" if is_quarantine else f"【CITE STRICTLY】: Integrate these citations contextually: {', '.join(local_cites)}. <LIT>{local_context_str}</LIT>"
-            head_inst = f"Output the section heading # {sec['section']}." if sec["is_first"] else "DO NOT output heading. Seamlessly continue."
+            if is_quarantined: quarantine_rule = "【CRITICAL】: NO IN-TEXT CITATIONS ALLOWED IN THIS SECTION."
+            else:
+                assigned_keys = allocation_map.get(display_name, [])
+                assigned_tags_str = ", ".join(assigned_keys) if assigned_keys else "any relevant citations"
+                quarantine_rule = f"""【CITATION GUIDANCE】: You are strongly encouraged to integrate citations: {assigned_tags_str}. <AVAILABLE_CITATIONS>{refs_text}</AVAILABLE_CITATIONS>"""
+            heading_instruction = f"Output the section heading # {sec_title}." if sec["is_first"] else "DO NOT output the main heading. Seamlessly continue."
             
-            # --- Pass 1: Drafting Agent (草拟) ---
-            render_monitor(agent, "Pass 1: Drafting", display_name, "主攻逻辑、数据流与引文...")
-            ph_en.info("✍️ [Pass 1] Drafting Content...")
+            memory_context = agent._build_memory_context(max_tokens=1500)
+            memory_block = f"\n【GLOBAL PAPER MEMORY】\n{memory_context}\n" if memory_context else ""
+
+            lower_bound = int(adjusted_target * 0.9)
+            upper_bound = int(adjusted_target * 1.1)
+            lang_hint = "ru" if "Русский" in target_lang else ("kk" if "Қазақша" in target_lang else "en")
+            num_paragraphs = agent._calc_paragraph_count(adjusted_target, lang_hint)
             
-            base_p1 = f"""{APP_CONFIG['pass1_directive']}
-Task: Write '{display_name}' for topic '{topic}'.
-{q_rule}
-{head_inst}
-<GLOBAL_MEMORY>\n{agent._build_memory_context(1000)}\n</GLOBAL_MEMORY>
-Previous Tail: ...{context_tail}..."""
-
-            is_clone = False
+            adaptive_heading_rule = ""
+            if adjusted_target > 800:
+                adaptive_heading_rule = "The section is long. You MUST use Level 2 (##) and Level 3 (###) subheadings to logically structure your arguments. Do not write massive blocks of un-sectioned text."
+            elif adjusted_target > 400:
+                adaptive_heading_rule = "Please use Level 2 (##) subheadings to organize your content clearly."
+
+            table_rule = ""
+            if sec["is_method_or_result"]:
+                table_rule = "[CRITICAL DATA FORMATTING] You MUST present ALL statistical data, descriptive statistics, validity metrics, and correlation matrices using STANDARD MARKDOWN TABLES. NEVER present dense statistical data in plain text paragraphs."
+
+            length_directive = f"""
+            [LENGTH MANDATE - STRICT] Write between {lower_bound} and {upper_bound} words (approx {num_paragraphs} paragraphs). No fluff.
+            {adaptive_heading_rule}
+            {table_rule}
+            [FINAL CHECK] Do not output a word count statement.
+            """
+
+            is_clone_target = False
+            active_clone_key = None
             if st.session_state.run_mode == "clone":
-                target_key = next((k for k in clone_metadata.keys() if set(re.findall(r'[a-z]{3,}', k.lower())) & set(re.findall(r'[a-z]{3,}', sec["section"].lower()))), None)
-                if target_key:
-                    is_clone = True
-                    meta = clone_metadata[target_key]
-                    base_p1 += f"\n[CLONE MODE: STRUCTURE] Follow this exact reporting sequence: {meta.get('reporting_structure')}. Integrate Core Diff: {ctx_diff}"
-
-            if sec["is_mor"]: base_p1 += f"\n<USER_DATA>\n{user_data_md}\n</USER_DATA>"
+                for target_key in clone_metadata.keys():
+                    target_words = set(re.findall(r'[a-zA-Z]{3,}', target_key.lower()))
+                    sec_words = set(re.findall(r'[a-zA-Z]{3,}', sec_title.lower()))
+                    
+                    if "result" in target_words: target_words.add("analysis")
+                    if "result" in sec_words: sec_words.add("analysis")
+                    
+                    if target_words & sec_words: 
+                        is_clone_target = True
+                        active_clone_key = target_key
+                        break
+
+            if is_clone_target:
+                meta = clone_metadata[active_clone_key]
+                sys_prompt_m3 = "You are a top-tier academic ghostwriter executing a structural and stylistic clone."
+                
+                base_user = f"""
+                [CLONE MODE ACTIVATED - TARGET: {sec_title}]
+                Mimic the academic tone, structural flow, and sentence patterns of this reference template:
+                <TONE_PROFILE>{meta.get("tone_and_style", "Objective")}</TONE_PROFILE>
+                <REFERENCE_TEMPLATE_SNIPPET>\n{meta.get("few_shot_snippet", "")}\n</REFERENCE_TEMPLATE_SNIPPET>
+                
+                [NEW CONTEXT]
+                Write '{display_name}' for the topic: {topic}. Core differences to integrate: {context_differences}
+                {length_directive} {quarantine_rule} {heading_instruction}
+                
+                【CONTEXT SMOOTHING MANDATE】
+                Your previous section ended with: "...{context_tail}..."
+                Write a natural, smooth transitional opening sentence to bridge this.
+                """
+                
+                if "method" in sec_title.lower() or "result" in sec_title.lower() or "analysis" in sec_title.lower():
+                    base_user += f"""\n[CRITICAL STOP - ZERO DATA HALLUCINATION RULE]
+                    You are writing an empirical section. YOU ARE ABSOLUTELY FORBIDDEN from using any exact numbers (R-square, p-values, sample sizes, beta coefficients) found in the <REFERENCE_TEMPLATE_SNIPPET>.
+                    You MUST ONLY rely on the user's actual statistical data provided below.
+                    If a required metric is missing from the user data, insert "[INSERT VALUE]" as a placeholder. DO NOT FABRICATE NUMBERS.
+                    <USER_ACTUAL_DATA>\n{user_data_md}\n</USER_ACTUAL_DATA>"""
+            else:
+                extra_directives = []
+                lower_sec = sec_title.lower()
+                if sec["is_method_or_result"]:
+                    extra_directives.append(APP_CONFIG["methodological_defense_directive"])
+                    extra_directives.append(APP_CONFIG["empirical_data_logic"])
+                if any(kw in lower_sec for kw in ["theory", "theoretical", "hypothesis", "introduction"]):
+                    extra_directives.append(APP_CONFIG["deep_synthesis_directive"])
+                    extra_directives.append(APP_CONFIG["hypothesis_development_directive"])
+                if "discussion" in lower_sec: extra_directives.append(APP_CONFIG["discussion_depth_directive"])
+                if "conclusion" in lower_sec: extra_directives.append(APP_CONFIG["conclusion_anchor_directive"])
+                
+                theory_injection = "\n\n".join(extra_directives)
+                sys_prompt_m3 = APP_CONFIG["sys_academic_writer"] + "\n" + APP_CONFIG["deep_refinement_directive"]
+                
+                wiz_data_injection = f"\n<USER_ACTUAL_DATA>\n{user_data_md}\n</USER_ACTUAL_DATA>\n" if user_data_md and sec["is_method_or_result"] else ""
+                
+                base_user = f"""Generate a polished section '{display_name}'.
+                {length_directive}\n{quarantine_rule}\n{heading_instruction}\n{theory_injection}\n{memory_block}
+                Global Research Synthesis: {synthesis_result}\n{wiz_data_injection}
+                Previous Context Tail: ...{context_tail}...\nIMPORTANT: Output directly the final academic text."""
+
+            total_tokens = agent._count_tokens(sys_prompt_m3) + agent._count_tokens(base_user)
+            if total_tokens > 60000:
+                base_user = agent._truncate_context(base_user, 60000 - agent._count_tokens(sys_prompt_m3))
             
-            try:
-                draft_stream = ph_en.write_stream(agent.stream_deepseek(APP_CONFIG['sys_academic_writer'], base_p1, 5000))
-                draft_clean = re.sub(r'<think>.*?</think>', '', draft_stream, flags=re.DOTALL).strip()
-            except Exception as e:
-                st.error(f"Pass 1 断网熔断: {e}"); generation_aborted = True; break
-
-            # --- Pass 2: Editorial Agent (审校与风格洗稿) ---
-            render_monitor(agent, "Pass 2: Editing", display_name, "主攻反 AI 味、突现度与排版...")
-            ph_en.info("👔 [Pass 2] Editorial Polishing...")
+            engine_label = "🧬 克隆引擎" if is_clone_target else "📚 标准引擎"
+            render_monitor(agent, f"English Drafting ({current_step+1}/{total_steps})", display_name, f"目标字数: {adjusted_target} ({engine_label})")
+            en_ph.info(f"🔄 正在生成高质量章节 (目标: {adjusted_target} 词 | {engine_label})...")
             
-            t_words = sec['target_words']
-            base_p2 = f"""{APP_CONFIG['pass2_directive']}
-[LENGTH CONSTRAINT] Force text to ~{t_words} words ({agent._calc_paragraph_count(t_words)} paras).
-[DRAFT TO EDIT]:
-{draft_clean}"""
-
-            if is_clone:
-                base_p2 += f"\n[CLONE MODE: STYLE] Wash the draft to perfectly mimic this tone: {meta.get('tone_and_style')}. Snippet to mimic: {meta.get('few_shot_snippet')}"
-
+            # --- API 生成并附加异常熔断逻辑 ---
             try:
-                final_stream = ph_en.write_stream(agent.stream_deepseek(APP_CONFIG['sys_academic_writer'], base_p2, 5000))
-                final_clean = re.sub(r'<think>.*?</think>', '', final_stream, flags=re.DOTALL).strip()
-                final_resolved = agent.resolve_citations(final_clean, is_quarantine)
-                ph_en.markdown(final_resolved)
-                full_draft_en += final_resolved + "\n\n"
+                en_draft_stream = en_ph.write_stream(agent.stream_deepseek(sys_prompt_m3, base_user, max_tokens=6000))
+                en_draft_clean = re.sub(r'<think>.*?</think>', '', en_draft_stream, flags=re.DOTALL).strip()
+                en_resolved = agent.resolve_citations(en_draft_clean, quarantine=is_quarantined)
+                en_ph.markdown(en_resolved)
+                full_draft_en += en_resolved + "\n\n"
+                agent._extract_memory_from_text(en_draft_clean, sec_title)
+                words_tail = en_draft_clean.split()
+                context_tail = " ".join(words_tail[-200:]) if len(words_tail) > 200 else en_draft_clean
+                
+                actual_words = len(en_draft_clean.split())
+                accumulated_deviation += (actual_words - adjusted_target)
+                st.caption(f"📊 本章节实际字数: {actual_words} (目标: {adjusted_target}), 累计偏差: {accumulated_deviation:+d}")
                 
-                agent._extract_memory_from_text(final_clean, sec["section"])
-                context_tail = " ".join(final_clean.split()[-200:])
+                current_step += 1
+                pb.progress(min(15 + int((current_step / total_steps) * 80), 99), text=f"🇬🇧 {display_name} 英文完成...")
             except Exception as e:
-                st.error(f"Pass 2 断网熔断: {e}"); generation_aborted = True; break
+                en_ph.error("🚨 节点网络异常或达到并发限制，生成已自动熔断。")
+                st.error(f"异常信息: {e} | 💥 系统已自动保存之前所有的生成快照，您随时可以刷新页面点击【恢复断点续传】继续任务。")
+                generation_aborted = True
+                break
 
-            # --- Translation ---
-            render_monitor(agent, "Translating", display_name, "多语种同步中...")
+            render_monitor(agent, f"Translating ({current_step+1}/{total_steps})", display_name, "翻译中...")
+            trans_ph.empty()
             try:
-                t_raw = ph_tr.write_stream(agent.stream_deepseek(f"Translate into {target_lang}. Preserve formatting and tags.", f"TEXT:\n{final_clean}", 5000))
-                t_clean = agent.resolve_citations(re.sub(r'<think>.*?</think>', '', t_raw, flags=re.DOTALL).strip(), is_quarantine)
-                ph_tr.markdown(t_clean)
-                full_draft_translated += t_clean + "\n\n"
+                trans_chunk_raw = trans_ph.write_stream(agent.stream_deepseek(f"Translate into {target_lang}. Preserve formatting and [CITE-XX] tags.", f"TEXT:\n{en_draft_clean}", max_tokens=6000))
+                trans_chunk_clean = re.sub(r'<think>.*?</think>', '', trans_chunk_raw, flags=re.DOTALL).strip()
+                trans_resolved = agent.resolve_citations(trans_chunk_clean, quarantine=is_quarantined)
+                trans_ph.markdown(trans_resolved)
+                full_draft_translated += trans_resolved + "\n\n"
+                current_step += 1
+                pb.progress(min(15 + int((current_step / total_steps) * 80), 99), text=f"{target_flag} {display_name} 翻译完成...")
             except Exception as e:
-                st.error(f"翻译断网熔断: {e}"); generation_aborted = True; break
-
-            # --- 状态快照持久化 ---
-            completed_sections.append(display_name)
-            state.update({"completed_sections": completed_sections, "full_draft_en": full_draft_en, "full_draft_translated": full_draft_translated, "context_tail": context_tail, "agent_state": agent.export_state()})
-            with open(CHECKPOINT_FILE, "w", encoding="utf-8") as f: json.dump(state, f, ensure_ascii=False)
+                trans_ph.error("🚨 节点网络异常，翻译已熔断。")
+                st.error(f"异常信息: {e} | 💥 系统已保存断点，可随时恢复任务。")
+                generation_aborted = True
+                break
+                
+            # 每成功完成一个 Section 的双语生成，立即持久化状态快照
+            state["completed_sections"].append(display_name)
+            state["full_draft_en"] = full_draft_en
+            state["full_draft_translated"] = full_draft_translated
+            state["context_tail"] = context_tail
+            state["agent_state"] = agent.export_state()
+            with open(CHECKPOINT_FILE, "w", encoding="utf-8") as f:
+                json.dump(state, f, ensure_ascii=False)
 
-        # ---- 全局打包与清理 (Finalization & GC) ----
+        # 仅在正常完整生成所有结构后，进入打包环节并触发无痕垃圾清理
         if not generation_aborted and full_draft_en.strip():
-            pb.progress(95, text="📦 打包并生成参考文献列表...")
-            full_draft_en = re.sub(r'(?im)^##?\s*(References?).*?(\n##?|\Z)', '', full_draft_en, flags=re.DOTALL).strip()
-            full_draft_translated = re.sub(r'(?im)^##?\s*(参考文献|References?).*?(\n##?|\Z)', '', full_draft_translated, flags=re.DOTALL).strip()
+            pb.progress(96, text="📦 打包DOCX...")
+            full_draft_en = re.sub(r'(?im)^##?\s*(References?|Reference List).*?(\n##?|\Z)', '', full_draft_en, flags=re.DOTALL).strip()
+            full_draft_translated = re.sub(r'(?im)^##?\s*(参考文献|References?|Reference List).*?(\n##?|\Z)', '', full_draft_translated, flags=re.DOTALL).strip()
             
-            # 引文聚合 (仅使用真实引用的文献)
-            used = sorted(list(agent.used_citations))
-            refs = sorted(list(set([agent.citation_map[tag]['ref'] for tag in used if tag in agent.citation_map])))
-            apa = "\n\n".join([f"- {r}" for r in refs])
-            full_draft_en += "\n\n# References\n" + apa
-            full_draft_translated += "\n\n# 参考文献\n" + apa
-
-            # 导出 ZIP
-            bj_t = datetime.now(timezone(timedelta(hours=8))).strftime("%Y%m%d_%H%M")
-            pref = {"Simplified Chinese (简体中文)": "ZH", "Russian (Русский)": "RU", "Kazakh (Қазақша)": "KK"}.get(target_lang, "ZH")
-            zb = io.BytesIO()
-            with zipfile.ZipFile(zb, "w", zipfile.ZIP_DEFLATED) as zf:
-                zf.writestr(f"Draft_EN_{bj_t}.docx", text_to_docx(full_draft_en).getvalue())
-                zf.writestr(f"Draft_{pref}_{bj_t}.docx", text_to_docx(full_draft_translated).getvalue())
-            st.session_state.zip_buffer, st.session_state.zip_filename = zb.getvalue(), f"SSCI_Agent_{bj_t}.zip"
+            total_words_en = len(full_draft_en.split())
+            target_words = int(words)
+            lower_limit = int(target_words * 0.95); upper_limit = int(target_words * 1.05)
+            st.info(f"📊 全文总字数: {total_words_en} (目标区间: {lower_limit} - {upper_limit})")
             
-            # 无痕 GC 清理
-            if os.path.exists(CHECKPOINT_FILE): os.remove(CHECKPOINT_FILE)
-            pb.progress(100, text="✅ 任务圆满完成")
-            render_monitor(agent, "完成", "✅", f"已生成 {len(refs)} 篇精确参考文献，临时数据已销毁")
-
-    except Exception as e: st.error(f"🚨 底层系统异常: {e}")
+            if total_words_en > upper_limit:
+                st.warning(f"⚠️ 全文超出上限 {total_words_en - upper_limit} 词，正在智能精简 Conclusion...")
+                conclusion_match = re.search(r'(## Conclusion.*?)(?=\n## |\Z)', full_draft_en, re.DOTALL | re.IGNORECASE)
+                if conclusion_match:
+                    conclusion_text = conclusion_match.group(1)
+                    compressed_en = agent.call_deepseek("You are an academic editor. Condense the following conclusion by 15-20% while preserving key findings and citations.", conclusion_text, max_tokens=1500)
+                    if compressed_en:
+                        full_draft_en = full_draft_en.replace(conclusion_text, compressed_en.strip())
+                        compressed_trans = agent._translate_text(compressed_en, target_lang, max_tokens=2000)
+                        if compressed_trans:
+                            trans_conc_title = {"Simplified Chinese (简体中文)": "结论", "Russian (Русский)": "Заключение", "Kazakh (Қазақша)": "Қорытынды"}.get(target_lang, "Conclusion")
+                            trans_match = re.search(rf'(## {trans_conc_title}.*?)(?=\n## |\Z)', full_draft_translated, re.DOTALL | re.IGNORECASE)
+                            if trans_match: full_draft_translated = full_draft_translated.replace(trans_match.group(1), compressed_trans.strip())
+                            else: full_draft_translated += "\n\n" + compressed_trans.strip()
+                        total_words_en = len(full_draft_en.split())
+                        st.success(f"✅ 精简完成，现总字数: {total_words_en}")
+            elif total_words_en < lower_limit:
+                st.warning(f"⚠️ 全文低于下限 {lower_limit - total_words_en} 词，正在扩展 Conclusion...")
+                expanded_en = agent.call_deepseek("Continue the conclusion by adding 100-200 words of academically substantive content (future research/limitations).", full_draft_en[-min(2000, len(full_draft_en)):], max_tokens=800)
+                if expanded_en:
+                    full_draft_en += "\n\n" + expanded_en.strip()
+                    expanded_trans = agent._translate_text(expanded_en, target_lang, max_tokens=1000)
+                    if expanded_trans: full_draft_translated += "\n\n" + expanded_trans.strip()
+                    total_words_en = len(full_draft_en.split())
+                    st.success(f"✅ 扩展完成，现总字数: {total_words_en}")
+            
+            if len(agent.used_citations) < 80: 
+                unused = [tag for tag in agent.citation_map if tag not in agent.used_citations]
+                for tag in unused[:80 - len(agent.used_citations)]: agent.used_citations.add(tag)
+            
+            used_tags = sorted(list(agent.used_citations))
+            raw_refs = [agent.citation_map[tag]['ref'] for tag in used_tags if tag in agent.citation_map]
+            unique_refs = sorted(list(set(raw_refs)))
+            apa_refs = "\n\n".join([f"- {ref}" for ref in unique_refs])
+            full_draft_en += "\n\n# References\n" + apa_refs
+            full_draft_translated += "\n\n# 参考文献\n" + apa_refs
+
+            bj_time = datetime.now(timezone(timedelta(hours=8))).strftime("%Y%m%d_%H%M")
+            lang_prefix = {"Simplified Chinese (简体中文)": "ZH", "Russian (Русский)": "RU", "Kazakh (Қазақша)": "KK"}.get(target_lang, "ZH")
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+                zf.writestr(f"Empirical_Research_EN_{bj_time}.docx", text_to_docx(full_draft_en).getvalue())
+                zf.writestr(f"Empirical_Research_Trans_{lang_prefix}_{bj_time}.docx", text_to_docx(full_draft_translated).getvalue())
+            zip_buffer.seek(0)
+            st.session_state.zip_buffer = zip_buffer.getvalue()
+            st.session_state.zip_filename = f"SSCI_Pipeline_Set_{bj_time}.zip"
+            
+            # 任务最终完成！执行自动无痕清理机制 (Garbage Collection)
+            if os.path.exists(CHECKPOINT_FILE):
+                os.remove(CHECKPOINT_FILE)
+                
+            pb.progress(100, text="✅ 完成")
+            render_monitor(agent, "完成", "✅", "文档已生成并已清空本地临时快照空间")
+            
+    except Exception as e: 
+        st.error(f"🚨 启动/恢复异常: {e}")
     finally:
-        st.session_state.is_running, st.session_state.start_pipeline, st.session_state.resume_pipeline = False, False, False
+        st.session_state.is_running = False
+        st.session_state.start_pipeline = False
+        st.session_state.resume_pipeline = False
 
 if st.session_state.zip_buffer:
     st.success(ui["success"])
-    st.download_button(ui["btn_download"], st.session_state.zip_buffer, st.session_state.zip_filename, "application/zip")
+    st.download_button(label=ui["btn_download"], data=st.session_state.zip_buffer, file_name=st.session_state.zip_filename, mime="application/zip")