codebee 0.1.48 → 0.1.50

package/app/core/manager.py

@@ -6,6 +6,7 @@
 """
 from __future__ import annotations
 
+import hashlib
 import json
 import os
 import re
@@ -15,6 +16,7 @@ import signal
 import socket
 import subprocess
 import sys
+import tempfile
 import threading
 import time
 import webbrowser
@@ -46,6 +48,31 @@ def _expand(p):
     return os.path.abspath(os.path.expanduser(os.path.expandvars(p)))
 
 
+def _under(path, root):
+    try:
+        return os.path.commonpath([os.path.realpath(path), root]) == root
+    except ValueError:
+        return False
+
+
+def tmp_data_no_home_write():
+    """测试实例防毒闸：TUTTI_DATA 指向系统临时目录、且进程主目录仍是真实
+    主目录时，一切对真实 CLI 配置的写入都应拒绝。
+
+    一次性测试服务的 models.json 里全是 a.test/sk-test 夹具，忘设假 HOME 的
+    测试一旦触发 launch/自愈/autobind 同步，就会把夹具毒进真实
+    ~/.claude/settings.json（2026-09-22 实案：claude 步骤全体 ENOTFOUND，
+    下一次测试又覆盖回来，形成「越测越坏」循环）。已设假 HOME 的测试不受
+    影响——假 HOME 本身就在临时目录下。
+    """
+    td = (os.environ.get("TUTTI_DATA") or "").strip()
+    if not td:
+        return False
+    tmp = tempfile.gettempdir()
+    home = os.path.abspath(os.path.expanduser("~"))
+    return _under(td, tmp) and not _under(home, tmp)
+
+
 def _safe_config_path(raw):
     """展开并校验配置路径：必须在用户主目录内（防穿越）。"""
     if not raw:
@@ -521,6 +548,9 @@ def read_model(entry):
 def write_model(entry, model):
     """写入默认模型（改动前自动备份 .bak）。支持 toml-line / toml-section /
     json / json-path / jsonc / yaml-line。"""
+    if tmp_data_no_home_write():
+        return {"ok": False,
+                "error": "测试数据目录（TUTTI_DATA 在临时目录）不写真实 CLI 配置，已拦截"}
     path = _config_path(entry)
     cfg = entry.get("config") or {}
     fmt = cfg.get("format")
@@ -750,6 +780,8 @@ def _sync_dsh_settings(entry, model, base_url):
     端点不同步不行——settings 优先级高于 env，密钥会发给旧端点；
     models 列表不同步不行——dsh web 的模型下拉只列它，缺条目就选不中。
     返回错误串或 None。"""
+    if tmp_data_no_home_write():
+        return "测试数据目录（TUTTI_DATA 在临时目录）不写真实 CLI 配置，已拦截"
     path = _config_path(entry)
     if not path:
         return "dsh 配置路径无效"
@@ -891,6 +923,8 @@ def _sync_codex_settings(entry, model, cp):
     _codex_provider_args 同构，但落 config 文件。返回错误串或 None。"""
     if _is_dead_endpoint(cp.get("base_url")):
         return "供应商端点 %r 是测试/保留地址，拒绝写入 config.toml" % (cp.get("base_url"),)
+    if tmp_data_no_home_write():
+        return "测试数据目录（TUTTI_DATA 在临时目录）不写真实 CLI 配置，已拦截"
     path = _config_path(entry)
     if not path:
         return "codex 配置路径无效"
@@ -1120,6 +1154,8 @@ def _sync_settings_env(path, updates, remove_keys=()):
     """把键值对写进目标 settings.json 的 env 段（claude/qwen 等同构：交互 TUI
     启动时把该段合并进进程环境）。只动 env 相关键，其余内容保留；坏 JSON 中止
     不覆盖；改动前 .bak。返回错误串或 None。path 必须已过主目录围栏校验。"""
+    if tmp_data_no_home_write():
+        return "测试数据目录（TUTTI_DATA 在临时目录）不写真实 CLI 配置，已拦截"
     try:
         if os.path.isfile(path):
             text = _read_text(path)
@@ -1213,6 +1249,8 @@ def _sync_opencode_settings(entry, model, prov):
     没 key）。写入所有已存在的候选文件（避免新文件遮蔽旧文件的读取优先级），
     全不存在时建 catalog 登记的那个。纯 JSON 走整体读改写；带注释的 JSONC 走
     文本级就地 patch（保留注释）。返回错误串或 None。"""
+    if tmp_data_no_home_write():
+        return "测试数据目录（TUTTI_DATA 在临时目录）不写真实 CLI 配置，已拦截"
     npm = "@ai-sdk/anthropic" if prov.get("protocol") == "anthropic" else "@ai-sdk/openai-compatible"
     base = prov.get("base_url") or ""
     if prov.get("protocol") == "anthropic" and not base.rstrip("/").endswith("/v1"):
@@ -1323,7 +1361,9 @@ def _sync_kimi_settings(entry, model, prov):
     yolo/defaultPermissionMode（camelCase）+ [providers.<id>]（type/apiKey/
     baseUrl）+ [models.<别名>]（provider/model/maxContextSize 必填）。无人值守
     要 yolo——否则工具调用逐个要审批，headless 全被拒。文本级托管块（标记注释
-    之间）幂等重写，用户自有内容保留在外。"""
+    之间）幂等重写，用户自有内容保留在外。返回错误串或 None。"""
+    if tmp_data_no_home_write():
+        return "测试数据目录（TUTTI_DATA 在临时目录）不写真实 CLI 配置，已拦截"
     import re as _re
     top_keys = ("defaultProvider", "defaultModel", "yolo", "defaultPermissionMode")
     targets = [os.path.abspath(os.path.expanduser("~/.kimi-code/config.toml"))]
@@ -1357,10 +1397,23 @@ def _sync_kimi_settings(entry, model, prov):
     return "；".join(errs) or None
 
 
+def _claude_sync_enabled():
+    """「直写 claude 配置」开关（settings 的 claude_config_sync，默认开）。
+    关闭 = ~/.claude/settings.json 归用户手动管理（cc-switch 等），打开/运行前
+    防线一律不落盘；编排步骤经 runner 一次性 --settings 注入绑定链，不受影响。"""
+    try:
+        from . import settings
+        return settings.load().get("claude_config_sync", True)
+    except Exception:
+        return True
+
+
 def sync_cli_config_now(agent_id):
     """运行期自愈：CLI 本体没配置（如 kimi「No model configured」）→ 立即把
     绑定注入其自家配置，换将/下轮即可用。返回给日志的备注（空=无事发生）。"""
     try:
+        if agent_id == "claude-code" and not _claude_sync_enabled():
+            return "按设置跳过直写 ~/.claude 配置（编排步骤经一次性 --settings 注入，不受影响）"
         from . import modelhub
         entry = next((a for a in catalog.load() if a.get("id") == agent_id), None)
         if not entry:
@@ -1397,6 +1450,8 @@ def _sync_agent_injection(entry, binding):
     spec = _AGENT_INJECTORS.get(entry["id"])
     if spec:
         protocols, injector = spec
+        if entry["id"] == "claude-code" and not _claude_sync_enabled():
+            return "按设置跳过直写 ~/.claude 配置（交互 TUI 保持手动管理；编排步骤经一次性 --settings 注入不受影响）"
         pick, note = modelhub.launch_pick(entry["id"], protocols)
         if pick:
             prov = pick["provider"]
@@ -1466,7 +1521,19 @@ def _sync_launch_model(entry, binding):
 # （draft-c12 等），CLI 身份在 kind 里；目录型智能体的 id 就是条目 id。
 _KIND_ENTRY = {"codex": "codex-cli", "claude": "claude-code",
                "qwen": "qwencode", "opencode": "opencode", "aider": "aider"}
-_RUNTIME_SYNC = {"fps": {}, "lock": threading.Lock()}
+_RUNTIME_SYNC = {"fps": {}, "files": {}, "lock": threading.Lock()}
+
+
+def _runtime_cfg_hash(entry):
+    """CLI 自家配置文件的内容指纹；文件不存在返回 None。"""
+    try:
+        p = _safe_config_path((entry.get("config") or {}).get("path"))
+        if p and os.path.isfile(p):
+            with open(p, "rb") as fh:
+                return hashlib.sha256(fh.read()).hexdigest()
+    except Exception:
+        pass
+    return None
 
 
 def sync_runtime_config(agent):
@@ -1509,10 +1576,16 @@ def sync_runtime_config(agent):
         fp = (model, repr(sorted(env.items())),
               repr(binding.get("codex_provider") or "")[:300])
         with _RUNTIME_SYNC["lock"]:
-            if _RUNTIME_SYNC["fps"].get(entry["id"]) == fp:
+            if (_RUNTIME_SYNC["fps"].get(entry["id"]) == fp
+                    and _RUNTIME_SYNC["files"].get(entry["id"]) == _runtime_cfg_hash(entry)):
                 return
+            # 绑定没变≠文件没变：指纹命中但文件被外部改写（测试毒写/手工编辑
+            # 托管段）时必须按绑定重写——2026-09-22 kimi 实案：测试夹具毒入
+            # ~/.kimi-code/config.toml（x.example 不可解析），换将步骤因指纹
+            # 命中跳过重写，kimi 带毒配置静默退出码 1
             _sync_launch_model(entry, binding)
             _RUNTIME_SYNC["fps"][entry["id"]] = fp
+            _RUNTIME_SYNC["files"][entry["id"]] = _runtime_cfg_hash(entry)
     except Exception:
         pass
 

package/app/core/modelhub.py

@@ -448,6 +448,30 @@ def _drop_model_refs(data, prov, name):
             _sync_chain_refs(b)
 
 
+def _prune_binding_chains(data, prov_ids=(), pairs=()):
+    """停用即出调度：把指向已停用供应商/模型的条目从所有绑定链里剔除。
+
+    与删除的清引用（_drop_model_refs / providers_op delete）不同，停用可逆，
+    只摘链上死条目，不动主供应商 provider_id 与厂商默认模型——重新启用后
+    原样恢复。链上剔除不回填：调度页所见即所绑，不靠运行时降级默默跳过
+    占位死条目（2026-09-22 用户拍板：禁用就直接去掉，自动就行）。
+    """
+    ids = {i for i in (prov_ids or ()) if i}
+    prs = {(p, m) for p, m in (pairs or ()) if p and m}
+    if not ids and not prs:
+        return
+    for b in (data.get("bindings") or {}).values():
+        chain = b.get("chain")
+        if not chain:
+            continue
+        kept = [c for c in chain
+                if (c.get("provider_id") or "") not in ids
+                and (c.get("provider_id") or "", c.get("model") or "") not in prs]
+        if len(kept) != len(chain):
+            b["chain"] = kept
+            _sync_chain_refs(b)
+
+
 _MODEL_OPS = ("enable", "disable", "delete", "restore")
 
 
@@ -475,6 +499,7 @@ def _apply_model_op(data, prov, models, name, op):
         if not target.get("enabled", True):
             return False, ""
         target["enabled"] = False
+        _prune_binding_chains(data, pairs=[(prov.get("id"), name)])
     elif op == "delete":
         if target.get("hidden"):
             return False, ""
@@ -494,6 +519,8 @@ def model_ops(provider_id, names, op):
 
     先整体校验再落盘：任一名不存在、或 enable/disable 选中了已删除的模型，
     整个请求都不生效，避免只改一半。全部改动合并为一次写盘。
+    disable 即出调度：命中的 (供应商, 模型) 条目自动从所有绑定链剔除，
+    不回填；delete 走 _drop_model_refs 连默认模型引用一起清。
     restore 与可见模型混选时，可见项直接跳过（不算失败），便于「恢复所选」。
     """
     names = list(dict.fromkeys(n for n in (names or []) if n))
@@ -656,9 +683,13 @@ def provider_view():
 _KEY_COOLDOWN_S = 30 * 60      # 欠费类失败后的冷却时长
 MAX_PROVIDER_KEYS = 8          # 单厂商 KEY 上限
 MAX_CHAIN_ATTEMPTS = 8         # 链展开后的尝试上限（模型 × KEY）
-# 欠费/配额类失败：换 KEY 有意义（同厂商另一账号还能用），与瞬态网络错误分开记
+# 欠费/配额/限流类失败：换 KEY 有意义（同厂商另一账号=另一份额度与并发桶），
+# 与瞬态网络错误分开记。429 限流文案一并纳入——只记错不冷却会让每个新步骤都
+# 从超限的首选 KEY 重新烧起（2026-09-22 首选超限不切备用实案）。
 _QUOTA_HINTS = ("insufficient", "quota", "balance", "credit", "billing", "arrears",
-                "payment required", "402", "欠费", "余额", "额度", "exceeded")
+                "payment required", "402", "欠费", "余额", "额度", "exceeded",
+                "too many requests", "rate limit", "rate_limit", "http 429",
+                "并发", "超过限")
 
 
 def _quota_error(err):
@@ -938,8 +969,9 @@ def upsert_provider(entry):
 def providers_op(ids, op):
     """批量供应商操作（enable | disable | delete | duplicate）。返回 (改动数, 错误)。
 
-    停用只影响 Tutti 编排时的运行时解析（resolve_binding 返回空 → 回落 CLI 默认），
-    不清除配置，也不影响绑定引用，随时可再启用。
+    停用即出调度：绑定链里它的条目自动剔除（_prune_binding_chains），配置与
+    模型列表保留，随时可再启用；已剔除的链条目不回填。运行时解析本来就会
+    跳过停用供应商，这里把落盘链一并清掉，调度页所见即所绑。
     duplicate 复制一条（同地址同密钥的第二个账号/新网关），副本不带绑定引用。
     """
     ids = list(dict.fromkeys(i for i in (ids or []) if i))
@@ -998,6 +1030,8 @@ def providers_op(ids, op):
                     p["enabled"] = want
                     changed += 1
             if changed:
+                if not want:
+                    _prune_binding_chains(data, prov_ids=ids)
                 # 启用置顶：本次选中的启用者排最前，其余启用跟随，停用的殿后；
                 # 排序稳定，各块内部保持原有顺序。落盘重排，列表页看到的就是它。
                 sel = set(ids)
@@ -2298,11 +2332,13 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
         entries.append(_chain_entry_env(prov, model, target=agent_kind_or_id,
                                         endpoint=ep, key=kk["key"],
                                         key_id=kk.get("id") or "", provider_id=pid))
+    mk = (chain_keys or [{}])[0]   # 回退模型沿用首选可用 KEY：失败也要能记账冷却
     for n in fallbacks:
         if len(entries) >= MAX_CHAIN_ATTEMPTS:
             break
         entries.append(_chain_entry_env(prov, n, target=agent_kind_or_id,
-                                        endpoint=ep, provider_id=pid))
+                                        endpoint=ep, key=mk.get("key") or "",
+                                        key_id=mk.get("id") or "", provider_id=pid))
     head = entries[0]
     out = {"model": model, "env": head["env"], "provider": prov,
            "model_fallbacks": fallbacks,
@@ -2406,6 +2442,18 @@ def launch_pick(agent_id, protocols):
     protocols = tuple(p for p in (protocols or ()) if p)
     b = bindings().get(agent_id) or {}
     chain = _binding_chain(b)
+    if not chain and str(b.get("provider_id") or "").strip():
+        # 只锁定了供应商、没排链也没选模型的绑定：与 resolve_binding 的无链分支
+        # 同语义补一条，打开前才有凭据可注入。否则这类绑定永远「未指定供应商」，
+        # CLI 自家配置里的残留（a.test 占位案）等不到自愈覆盖——2026-09-22
+        # claude ENOTFOUND 四连败实测，settings.json 毒端点靠它长期存活。
+        _pid = str(b.get("provider_id")).strip()
+        _prov = {p.get("id"): p for p in providers()}.get(_pid)
+        _model = str(b.get("model") or "").strip()
+        if _prov and not _model:
+            _names = [m["name"] for m in _enabled_models(_prov)]
+            _model = _prov.get("model") or (_names[0] if _names else "")
+        chain = [{"provider_id": _pid, "model": _model}]
     provs = {p.get("id"): p for p in providers()}
     disabled, mismatch = [], False
     for item in chain:

package/app/core/pipeline.py

@@ -419,7 +419,25 @@ def _run_builtin_step(run_id, role, bi, prompt, workdir, ev, note="", images=Non
     def _log(line):
         lines.append(str(line))
 
-    res = builtin_agent.run(bi, prompt, workdir, cancel_event=ev, log=_log, images=images)
+    # 思考过程可视化（2026-09-22 用户诉求）：模型的思维链/正文/工具活动边收边
+    # 落进步骤记录（store.stream_step 内部节流），对话时间线 2s 轮询即能读到
+    # 「它正在想什么」——此前整轮只有三点打字动画。
+    live = {"thinking": "", "text": ""}
+
+    def _on_reason(chunk):
+        live["thinking"] += chunk or ""
+        store.stream_step(run_id, step["n"], thinking=live["thinking"])
+
+    def _on_stream(acc):
+        live["text"] = acc or ""
+        store.stream_step(run_id, step["n"], text=live["text"])
+
+    def _on_activity(line):
+        store.stream_step(run_id, step["n"], activity=str(line or "")[:200])
+
+    res = builtin_agent.run(bi, prompt, workdir, cancel_event=ev, log=_log, images=images,
+                            on_reason=_on_reason, on_stream=_on_stream,
+                            on_activity=_on_activity)
     if followups and res.get("ok"):
         clean, fups = _parse_followups(res.get("text") or "")
         if fups:
@@ -427,6 +445,10 @@ def _run_builtin_step(run_id, role, bi, prompt, workdir, ev, note="", images=Non
             res["followups"] = fups
     if log_abs:
         try:
+            # 思考过程同时进步骤日志（日志抽屉与对话气泡同源，便于事后复盘）
+            think = (res.get("reasoning") or "").strip()
+            if think:
+                lines.append("[思考过程]\n" + think)
             log_abs.write_text("\n".join(lines) + "\n", encoding="utf-8")
         except Exception:
             pass
@@ -550,7 +572,9 @@ def _finish_step_result(run_id, step, res, role, agent, start):
                       # 智能体的最终回答（runner 已从 JSONL 事件流里抽出 agent_message）。
                       # 对话视图直读这个；日志文件是全量事件流，塞进气泡就成了「看日志」。
                       output=(res.get("text") or ""),
-                      followups=res.get("followups"))
+                      followups=res.get("followups"),
+                      # 思考过程（内置智能体流式抓取）：落进步骤记录，对话气泡折叠展示
+                      thinking=res.get("reasoning") or None)
     # 错误台账：失败/超时各记一条结构化记录（遥测与诊断包的数据源）。
     # 用户主动取消不入账——那不是产品问题；detail 只存脱敏后的失败摘录。
     if status in ("failed", "timeout"):
@@ -1807,45 +1831,11 @@ def _plot_modules(workdir):
             "鼓励化用，不要照抄原句）\n\n" + txt)
 
 
-def _chain_volume_names(task):
-    """沿 serial.continues 链收集各批次大纲里的卷名/卷弧光（旧 → 新，后者覆盖）。
-    续写批次合并成书时要给全书（含此前各批）的卷都写上标题，那些卷的命名记在
-    更早的批次任务上，本批 run 的 outline 里没有。失败静默返回 {}。"""
-    from . import store as _store
-    names, seen, cur = {}, set(), task
-    chain = []
-    while cur and len(chain) < 20:
-        tid = str(cur.get("id") or "")
-        if not tid or tid in seen:
-            break
-        seen.add(tid)
-        chain.append(cur)
-        nxt = str((cur.get("serial") or {}).get("continues") or "")
-        cur = _store.get_task(nxt) if nxt else None
-    for t in reversed(chain):        # 旧 → 新：新批次的命名覆盖旧批次
-        try:
-            for r in _store.task_runs(t["id"]):
-                o = r.get("outline") or {}
-                if isinstance(o.get("volumes"), dict):
-                    names.update(o["volumes"])
-        except Exception:
-            continue
-    return names
-
-
 def _book_volume_plan(task, outline, upto):
-    """本书的卷规划表：显式卷表/每卷章数（serial）→ 规划表 → 合并卷名
-    （本批大纲 + 沿链更早批次）→ 保证覆盖到第 upto 章。
-    不分卷返回 []；调用方据此决定是否插卷标题/卷末约束。"""
-    serial = task.get("serial") or {}
-    per = volumes.norm_per(serial.get("volume_chapters"))
-    plan = volumes.build_plan(serial.get("volumes"), per, upto=upto)
-    if not plan:
-        return []
-    named = dict(_chain_volume_names(task))
-    if isinstance(outline, dict):
-        named.update(outline.get("volumes") or {})
-    return volumes.merge_titles(plan, named)
+    """本书的卷规划表（卷边界+卷名+卷弧光）。实现见 planner.book_volume_plan
+    ——放在 planner 是因为它要沿 serial.continues 链读历史 run 的卷名，属
+    「大纲/命名」职责；此处保留薄封装便于连载流程阅读。"""
+    return planner.book_volume_plan(task, outline, upto)
 
 
 LEDGER_FILE = os.path.join(".codebee", "resource-ledger.md")
@@ -2194,6 +2184,9 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
         kb = knowledge.block_for(task)
         if kb:
             tpl = tpl.replace("## 待评审稿件", "%s\n\n## 待评审稿件" % kb, 1)
+        # 确定性检测（AI 味/叙事架构/节奏）此前只挂在单稿件评审上，连载逐章
+        # 从未拿到——逐章节奏与钩子恰恰最需要这条参考线（命中才追加，不扣分）
+        tpl = aiflavor.inject_into_prompt(tpl, text, task.get("type"))
         return tpl.replace("__DIMKEYS__", dimkey).replace(
             "__MANUSCRIPT__", text or "（稿件为空！）")
 
@@ -2354,50 +2347,92 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
 
         def run_critique(text, rnd, note_extra="", critic_sids=None, event_check=""):
             """一轮多维评审：返回 (cj_by_agent, scored)。变体赛马与主循环共用。
-            event_check：本章大纲核对块（逐项目标审稿），随评审下发并回收标记块。"""
+            event_check：本章大纲核对块（逐项目标审稿），随评审下发并回收标记块。
+
+            多评审并发跑（2026-09-22）：评审占运行总时长的六成以上，而各评审之间
+            互不依赖（同一份稿件、各自视角），串行等待纯属浪费——每位评审的墙上
+            时间直接叠加。与「同章多稿赛马」「best-of 候选」同一套线程范式（那两处
+            早已多线程调用 _run_step）。共享结构的写入全部收敛到 join 之后按
+            critics 原顺序合并，保证与串行版逐字节同结果（ev_check 取第一份非空、
+            issues/ledger 的先后顺序都不变），只在耗时上取并行收益。"""
             cj_map, sids = {}, dict(critic_sids or {})
             scored = 0   # 真正给出分数的评审数；失败/不可解析不得当成 0 分计入
-            for agent in critics:
-                role = "critique-c%d" % i
+            role = "critique-c%d" % i
+            results = {}
+            # 绑定解析提前到主线程：bind_agent 会把链首同步进 CLI 自家配置（写盘），
+            # 多线程同时调它有写盘竞争。解析结果随线程参数传入，线程内只做调用。
+            bound = [modelhub.bind_agent(a, difficulty) for a in critics]
+
+            def _critique_one(idx, agent):
+                """单评审执行体（线程内只做调用与解析，不改共享结构）。
+
+                异常不吞：记进 results 由主线程按原顺序重抛——串行版的
+                Cancelled/管道异常语义（上抛打断本 run）必须原样保留。"""
+                try:
+                    _critique_one_inner(idx, agent)
+                except BaseException as exc:      # noqa: BLE001（含 Cancelled）
+                    results[idx] = {"error": exc}
+
+            def _critique_one_inner(idx, agent):
                 if agent.get("mode") == "mock":
                     step, log_abs = store.add_step(run_id, role, agent["id"], agent.get("label"))
                     time.sleep(0.15)
                     cj = mocks.critique(agent["id"], rnd, dims, threshold_ch)
-                    scored += 1
                     store.finish_step(run_id, step["n"], "done",
                                       summary="均分 %.1f：%s" % (
                                           sum(cj["scores"].values()) / max(1, len(dims)),
                                           cj["summary"]),
                                       duration_s=0.15)
-                else:
-                    lens = _critic_lens(critics, agent)
-                    res = _run_step(run_id, role, modelhub.bind_agent(agent, difficulty),
-                                    crit_prompt_for(
-                                        text,
-                                        note=("小说第 %d 章" % i) + (
-                                            "｜你的专属评审视角：%s（其他评审会覆盖其余视角，"
-                                            "请深挖你的镜头，但所有维度仍需打分）" % lens)
-                                        if lens else "",
-                                        event_check=event_check) + note_extra,
-                                    workdir, readonly=True, ev=ev,
-                                    resume=sids.get(agent["id"]))
-                    cj = _critique_json(res, dims)
-                    if cj.get("scores"):
-                        scored += 1
-                    # 逐项目标审稿 + 资源账本：解析评审回复里的标记块（借鉴
-                    # AI-Novel-Writer 逐项核对/角色资源账本）。多评审取第一份
-                    # 非空即可，聚合时已在前两处赋值处去重。
-                    evl = _parse_tagged_lines(res.get("text"), "event_check")
-                    if evl and not ev_check_lines[0]:
-                        ev_check_lines[0] = evl
-                    ledger_lines.extend(_parse_tagged_lines(res.get("text"), "ledger"))
+                    results[idx] = {"agent": agent, "cj": cj, "evl": [],
+                                    "ledger": [], "sid": None}
+                    return
+                lens = _critic_lens(critics, agent)
+                res = _run_step(run_id, role, bound[idx],
+                                crit_prompt_for(
+                                    text,
+                                    note=("小说第 %d 章" % i) + (
+                                        "｜你的专属评审视角：%s（其他评审会覆盖其余视角，"
+                                        "请深挖你的镜头，但所有维度仍需打分）" % lens)
+                                    if lens else "",
+                                    event_check=event_check) + note_extra,
+                                workdir, readonly=True, ev=ev,
+                                resume=sids.get(agent["id"]))
+                results[idx] = {
+                    "agent": agent, "cj": _critique_json(res, dims),
+                    # 逐项目标审稿 + 资源账本：标记块先各存各的，join 后按序合并
+                    "evl": _parse_tagged_lines(res.get("text"), "event_check"),
+                    "ledger": _parse_tagged_lines(res.get("text"), "ledger"),
                     # §07 T1.1：记录该评审的会话 id（第 2 轮复用）
-                    csid = _resume_sid(agent, res.get("sid"))
-                    if csid:
-                        sids[agent["id"]] = csid
+                    "sid": _resume_sid(agent, res.get("sid")),
+                }
+
+            threads = []
+            for idx, agent in enumerate(critics):
+                th = threading.Thread(target=_critique_one, args=(idx, agent),
+                                      name="crit-%s-c%d-%d" % (run_id, i, idx), daemon=True)
+                threads.append(th)
+                th.start()
+            for th in threads:
+                th.join(3000)
+            _check_cancel(ev)
+
+            # join 后按原顺序合并（确定性：与串行版结果一致）
+            for idx in range(len(critics)):
+                r = results.get(idx)
+                if r is None:
+                    continue     # 该评审线程超时未回，按「没出分」处理
+                if "error" in r:
+                    raise r["error"]     # 还原串行版的异常上抛语义
+                agent, cj = r["agent"], r["cj"]
+                if cj.get("scores"):
+                    scored += 1
+                if r["evl"] and not ev_check_lines[0]:
+                    ev_check_lines[0] = r["evl"]
+                ledger_lines.extend(r["ledger"])
+                if r["sid"]:
+                    sids[agent["id"]] = r["sid"]
                 cj_map[agent["id"]] = cj
                 issues_all.extend({"chapter": i, **it} for it in (cj.get("issues") or [])[:6])
-                _check_cancel(ev)
 
             # 评审者级 fallback：名单内评审全挂（网关抖动/CLI 故障）时，
             # 从其它已启用真实智能体补位至多 2 个（排除 mock 与已试过的），
@@ -2512,6 +2547,8 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                 chapter_reason = route.get("author", "")
                 last_attempt_impl = impl
                 last_attempt_reason = chapter_reason
+                prev_prompt = None      # 上一次实际下发的提示词
+                prev_timed_out = False  # 上一次是否「超时/停滞」收场
                 for draft_attempt in range(3):
                     if draft_attempt:
                         # 30s / 60s 退避；ev.wait 睡等可被取消即刻唤醒
@@ -2527,11 +2564,20 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                         # 30KB 对讯飞必挂）
                         sk2, bible2, _note = _shrink_context_block(sk_block, bible, budget=12000)
                         use_prompt = prompt.replace(sk_block, sk2).replace(bible, bible2)
+                    # 超时重试必须有新变量才值得做（2026-09-22）：提示词与上次逐字节
+                    # 相同、上次又是超时/停滞收场时，重试只是把同一个超时再烧一遍
+                    # （2400s × N）。此时直接跳出交替换将——换 CLI/模型才是新机会。
+                    # 注意保留「缩上下文重试」：提示词真的变小了（缩块生效）就照试，
+                    # 那是针对「提示词过大挂起」的有效降级。
+                    if prev_timed_out and use_prompt == prev_prompt:
+                        break
                     res = _run_step(run_id, "draft-c%d" % i, modelhub.bind_agent(impl, difficulty), use_prompt,
                                     step_wd, readonly=False, ev=ev, timeout=2400,
                                     resume=resume_ctx["session"] if resume_ctx else None,
                                     images=_task_images(task, workdir),
                                     note=("起草重试 %d/2（网关限流退避）" % draft_attempt) if draft_attempt else "")
+                    prev_prompt = use_prompt
+                    prev_timed_out = bool((res.get("raw") or {}).get("timed_out"))
                     good, txt = _chapter_state()
                     if good:
                         break
@@ -2852,9 +2898,23 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
     global_issues = []
 
     def run_global_round(agent_list):
-        """一轮全局评审：返回 (出分评审数, 按维累计分)。失败/不可解析不得当成低分计入。"""
+        """一轮全局评审：返回 (出分评审数, 按维累计分)。失败/不可解析不得当成低分计入。
+
+        多评审并发（2026-09-22，同章级评审并发）：各自读同一份全书文本、互不依赖，
+        串行只是把等待时间叠起来。共享结构仍在 join 后按原顺序合并，结果与串行一致。"""
         gmeans_acc, scored = {}, 0
-        for agent in agent_list:
+        results = {}
+        # 绑定解析提前到主线程（线程内不做会写盘的 bind_agent）
+        bound = [modelhub.bind_agent(a, difficulty) for a in agent_list]
+
+        def _global_one(idx, agent):
+            """异常不吞：记进 results 由主线程按原顺序重抛（保留串行语义）。"""
+            try:
+                _global_one_inner(idx, agent)
+            except BaseException as exc:      # noqa: BLE001（含 Cancelled）
+                results[idx] = {"error": exc}
+
+        def _global_one_inner(idx, agent):
             if agent.get("mode") == "mock":
                 step, _ = store.add_step(run_id, "global-critique", agent["id"],
                                          agent.get("label"))
@@ -2863,25 +2923,41 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                       "issues": [], "summary": "（mock）全书结构完整，达到可签约水平"}
                 store.finish_step(run_id, step["n"], "done", summary="均分 8.0：（mock）全书达标",
                                   duration_s=0.15)
+                results[idx] = gj
+                return
+            gtpl = SERIAL_GLOBAL_PROMPT
+            if bible:
+                gtpl = gtpl.replace("## 全书目标", bible + "\n\n## 全书目标", 1)
+            res = _run_step(run_id, "global-critique", bound[idx],
+                            (gtpl.replace("__DIMKEYS__", dimkey)
+                             .replace("__GOAL__", task["goal"])
+                             .replace("__MANUSCRIPT__", full_text[:60000])),
+                            workdir, readonly=True, ev=ev, timeout=2400)
+            results[idx] = _critique_json(res, dims)
+
+        threads = []
+        for idx, agent in enumerate(agent_list):
+            th = threading.Thread(target=_global_one, args=(idx, agent),
+                                  name="gcrit-%s-%d" % (run_id, idx), daemon=True)
+            threads.append(th)
+            th.start()
+        for th in threads:
+            th.join(3000)
+        _check_cancel(ev)
+
+        for idx in range(len(agent_list)):
+            gj = results.get(idx)
+            if gj is None:
+                continue
+            if "error" in gj:
+                raise gj["error"]     # 还原串行版的异常上抛语义
+            if gj.get("scores"):
                 scored += 1
-            else:
-                gtpl = SERIAL_GLOBAL_PROMPT
-                if bible:
-                    gtpl = gtpl.replace("## 全书目标", bible + "\n\n## 全书目标", 1)
-                res = _run_step(run_id, "global-critique", modelhub.bind_agent(agent, difficulty),
-                                (gtpl.replace("__DIMKEYS__", dimkey)
-                                 .replace("__GOAL__", task["goal"])
-                                 .replace("__MANUSCRIPT__", full_text[:60000])),
-                                workdir, readonly=True, ev=ev, timeout=2400)
-                gj = _critique_json(res, dims)
-                if gj.get("scores"):
-                    scored += 1
             global_issues.extend({"chapter": "全书", **it} for it in (gj.get("issues") or [])[:8])
             for d in dims:
                 v = gj.get("scores", {}).get(d)
                 if v is not None:
                     gmeans_acc.setdefault(d, []).append(float(v))
-            _check_cancel(ev)
         return scored, gmeans_acc
 
     gscored, gmeans_acc = run_global_round(critics)
@@ -3376,9 +3452,7 @@ def _run_content_review(run, task, agents, ev, stats, mode):
             crit_prompt += "\n\n## 原始任务背景与附件参考\n" + task["context"]
         # AI 味确定性检测（借鉴 oh-story 去AI味）：客观参考线随评审下发，
         # 命中才追加——评审官结合上下文判断是否真问题，脚本不直接扣分
-        _aiflavor_line = aiflavor.report_line(manuscript)
-        if _aiflavor_line:
-            crit_prompt += "\n\n## 确定性检测结果（供评审参考）\n" + _aiflavor_line
+        crit_prompt = aiflavor.inject_into_prompt(crit_prompt, manuscript, task.get("type"))
         for agent in critics:
             role = "critique-r%d" % r
             if agent.get("mode") == "mock":