codebee 0.1.5 → 0.1.6

package/CHANGELOG.md

@@ -4,6 +4,14 @@ CodeBee 的用户可感知变更记录。发布新版时：最上面加一节，
 `<!-- relnotes:start -->…<!-- relnotes:end -->` 段（那段会被 `npm view` 的
 README 元数据带回，供老版本在「发现新版本」时展示新版更新内容）。
 
+## v0.1.6（2026-09-18）
+
+- 连载韧性：网关限流/欠费时章稿失败先退避重试同作者（保住连载风格一致），重试穷尽才判死整 run；自动续跑改为延迟 5 分钟入队、上限提升到 3 次
+- 修复：任务分支从游离 HEAD 检出时「切回原分支」原地空转的假成功；游离基线的合并现在显式拒绝并说明
+- kimi 接入：僵尸 kimi 进程自动检测清理；CodeBee 托管配置按 TOML 语义渲染
+- 修复：generic 类 CLI 经 npm .cmd 垫片时提示词被 cmd 重解析截烂（改 node 直启）
+- 界面：新增蜜蜂图标，蜂巢工作台与皮肤视觉精修
+
 ## v0.1.5（2026-09-16）
 
 - 更新提示升级：发现新版本时直接展示「新版本更新内容」，升级后首次打开自动弹一次「本次更新内容」

package/README.md

@@ -21,12 +21,11 @@
 零第三方依赖：纯 Python 标准库（3.8+），本地 Web 界面，数据全部落盘可回放。
 
 <!-- relnotes:start -->
-### 最新版更新内容（v0.1.5）
+### 最新版更新内容（v0.1.6）
 
-- 发现新版本时直接展示「新版本更新内容」；升级后首次打开自动弹「本次更新内容」
-- 修复部分安全软件环境下启动卡在「正在启动任务队列」（启动期不再创建线程）
-- 启动逐步骤显示进度与耗时；卡超 20 秒自动打印卡点堆栈，截图即可排障
-- 完整更新日志见 CHANGELOG.md
+- 连载更抗限流：章稿失败先退避重试同作者，自动续跑延迟 5 分钟、上限 3 次
+- 修复任务分支游离 HEAD 的假成功切换与合并；kimi 僵尸进程检测与配置渲染修复
+- 修复 generic CLI 经 npm 垫片时提示词被截烂；界面新增蜜蜂图标与视觉精修
 <!-- relnotes:end -->
 
 ## 作者侧命令行（可选）

package/app/core/health.py

@@ -157,6 +157,58 @@ def report_failure(provider: str, error: str = "", *, model: str = "",
         _persist()
 
 
+# ------------------------------------------------- 静态死链告警（绑定层）
+
+def report_binding_dead(key: str, error: str = ""):
+    """静态死链告警：某 CLI 的绑定链在起跑前就已全部失效（厂商停用/删除/无密钥、
+    模型停用、协议不匹配）。与运行期 report_failure 的区别：不计数、不进探针，
+    立即置 down+告警（尊重静默）；绑定恢复后由 report_binding_ok 自动解除。
+    伪供应商名带「绑定链·」前缀，不会与真实厂商名相撞。"""
+    if not key:
+        return
+    with _LOCK:
+        name = "绑定链·%s" % key
+        st = _PROVIDERS.get(name)
+        if st is None:
+            st = _PROVIDERS.setdefault(name, {
+                "name": name, "provider_id": "", "model": "",
+                "status": "ok", "consecutive_failures": 0,
+                "first_fail_at": 0, "last_fail_at": 0, "last_ok_at": 0,
+                "last_error": "", "alerted": False, "silenced": False,
+                "silence_until": 0, "probe_next_at": 0, "probe_backoff_idx": 0,
+                "recovered_at": 0,
+            })
+        st["static"] = True
+        st["binding_key"] = str(key)
+        st["name"] = name
+        st["status"] = "down"
+        st["last_fail_at"] = _now()
+        st["last_error"] = str(error or "")[:300]
+        st["probe_next_at"] = 0
+        if not _effective_silenced(st) and not st.get("alerted"):
+            st["alerted"] = True
+            log.warning("[health] ⚠️ 绑定链告警：%s 全部失效（%s）",
+                        name, st["last_error"][:120])
+        _persist()
+
+
+def report_binding_ok(key: str):
+    """绑定链恢复可用：自动解除该 CLI 的静态死链告警（无记录时零开销）。"""
+    if not key:
+        return
+    with _LOCK:
+        st = _PROVIDERS.get("绑定链·%s" % key)
+        if not st or not st.get("static"):
+            return
+        st["status"] = "recovered"
+        st["alerted"] = False
+        st["silenced"] = False
+        st["silence_until"] = 0
+        st["recovered_at"] = _now()
+        log.info("[health] 绑定链 %s 已恢复（静态告警解除）", st["name"])
+        _persist()
+
+
 # ---------------------------------------------------------------- 手动操作
 
 def silence(provider: str, minutes: int = 0):
@@ -215,6 +267,7 @@ def snapshot():
                 "last_error": st.get("last_error") or "",
                 "alerting": alerting,
                 "silenced": silenced,
+                "static": bool(st.get("static")),
             })
         # 稳定排序：告警中 > 故障中 > 恢复 > 正常
         rank = {"down": 0, "failing": 1, "recovered": 2, "ok": 3}
@@ -271,7 +324,8 @@ def _probe_loop():
         try:
             with _LOCK:
                 targets = [(name, st) for name, st in _PROVIDERS.items()
-                           if st.get("status") in ("failing", "down")
+                           if not st.get("static")  # 静态死链无端点可探，绑定恢复时自动解除
+                           and st.get("status") in ("failing", "down")
                            and (st.get("probe_next_at") or 0) <= _now()]
                 for name, st in targets:
                     idx = int(st.get("probe_backoff_idx") or 0)

package/app/core/jobs.py

@@ -134,7 +134,9 @@ def cancel_event_for(run_id):
     return ev
 
 
-AUTO_RESUME_MAX = 2      # 连载任务自动续跑上限（超时/中断后自动接着写，无需人工）
+AUTO_RESUME_MAX = 3      # 连载任务自动续跑上限（超时/中断后自动接着写，无需人工）
+AUTO_RESUME_DELAY_S = 300  # 自动续跑延迟入队秒数：网关限流/欠费窗口通常分钟级，
+                           # 立即重排会撞在同一堵墙上把续跑次数烧光（2026-09-17 七猫实测）
 
 
 def _maybe_auto_resume(run_id):
@@ -160,7 +162,13 @@ def _maybe_auto_resume(run_id):
             return False
         store.update_run(new_run["id"], auto_resumes=int(run.get("auto_resumes") or 0) + 1,
                          auto_resumed_from=run_id)
-        _QUEUE.put({"kind": "orchestration", "run_id": new_run["id"], "task_id": task["id"]})
+
+        def _enqueue():
+            _QUEUE.put({"kind": "orchestration",
+                        "run_id": new_run["id"], "task_id": task["id"]})
+        t = threading.Timer(AUTO_RESUME_DELAY_S, _enqueue)
+        t.daemon = True
+        t.start()
         return True
     except Exception:
         return False

package/app/core/manager.py

@@ -78,6 +78,8 @@ def sweep_orphan_cli_processes():
     按「Tutti 调用签名 + 父进程已死」双条件匹配，不误杀用户自己在用的 CLI：
       opencode：命令行含 opencode + --model（同步写入的 provider 固定 orch）
       codex：命令行含 codex + --skip-git-repo-check（Tutti 专属 flag 组合）
+      kimi：命令行含 kimi-code/dist/main.mjs（node 直启路径，2026-09-17 实测
+      僵尸 kimi 会占住讯飞网关同钥请求队列，堵死后续所有 kimi 调用）
     claude 不扫（签名与用户手动使用难区分）。返回清扫数量。"""
     ps_exe = os.path.join(os.environ.get("SystemRoot", r"C:\Windows"),
                           "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
@@ -100,7 +102,8 @@ def sweep_orphan_cli_processes():
             cl = str(i.get("CommandLine") or "").lower()
             ppid = i.get("ParentProcessId")
             is_ours = (("opencode" in cl and "--model" in cl)
-                       or ("codex" in cl and "--skip-git-repo-check" in cl))
+                       or ("codex" in cl and "--skip-git-repo-check" in cl)
+                       or ("kimi-code" in cl and "main.mjs" in cl))
             if not is_ours or ppid in live or not i.get("ProcessId"):
                 continue
             try:
@@ -832,6 +835,11 @@ def _sync_codex_settings(entry, model, cp):
     name = cp.get("name", "orch")
     def q(v):
         return '"%s"' % str(v).replace("\\", "\\\\").replace('"', '\\"')
+    if (cp.get("wire_api") or "responses") == "chat":
+        # codex 0.154+ 起 chat wire 被官方移除，写进 config.toml 会让 CLI 连配置
+        # 都载入不了（Error loading config.toml）——宁可明确拒绝也不落坏配置。
+        return ("供应商只有 chat completions wire，codex 0.154+ 已移除支持，未写入"
+                " config.toml——请为 codex 绑定 responses 兼容的供应商")
     pairs = [("name", q(cp.get("name", name))),
              ("base_url", q(cp.get("base_url", ""))),
              ("env_key", q(cp.get("env_key", "ORCH_API_KEY"))),

package/app/core/modelhub.py

@@ -454,6 +454,7 @@ def model_ops(provider_id, names, op):
         if changed:
             _promote(models, newly_enabled)  # 启用的置顶，停用的退到启用块之后
             _save(data)
+            sync_binding_alerts()  # 模型启停/恢复 → 绑定链死活立即刷新告警
         return changed, ""
 
 
@@ -473,6 +474,7 @@ def _restore_all(provider_id):
             m["enabled"] = True
         _promote(models, names)  # 恢复 = 重新启用：同样置顶
         _save(data)
+        sync_binding_alerts()
         return None
 
 
@@ -925,6 +927,8 @@ def providers_op(ids, op):
                     not (p.get("id") in sel and p.get("enabled", True)),
                     not bool(p.get("enabled", True))))
         _save(data)
+        if changed or op == "delete":
+            sync_binding_alerts()  # 厂商启停/删除 → 绑定链死活立即刷新告警
         return changed, ("" if changed else "所选供应商已是目标状态")
 
 
@@ -1967,6 +1971,56 @@ def _protocol_candidates(prov):
             if (caps.get(p) or {}).get("base")]
 
 
+def bindable_protocols(agent_kind_or_id):
+    """该 CLI 可绑定的 wire 协议（与 resolve_binding 的 allowed 一致）。
+    供死链告警/失败文案解释「为什么绑不上」：claude 只认 anthropic，
+    codex/dsh 只认 openai，其余开放双协议（含 wire 适配）。"""
+    if _deepseek_env_target(agent_kind_or_id) or agent_kind_or_id in ("codex-cli", "codex"):
+        return ("openai",)
+    if agent_kind_or_id in ("claude-code", "claude"):
+        return ("anthropic",)
+    return tuple(_BINDABLE_PROTOCOLS)
+
+
+def binding_dead_msg(cli_id):
+    """死链失败/告警文案（pipeline 死链闸门与本模块 sync 共用）：说明为什么
+    不回落本机默认 + 该 CLI 需要什么协议的供应商。"""
+    try:
+        protos = bindable_protocols(cli_id)
+    except Exception:
+        protos = ()
+    hint = ("该 CLI 仅接受 %s 协议的已启用供应商；" % "、".join(protos)) if protos else ""
+    return ("绑定链全部失效（链上供应商已停用/删除/无密钥，或模型已停用），"
+            "本步判失败、不回落 CLI 本机默认——%s请在「CLI 绑定」页为该 CLI 绑定已启用的供应商" % hint)
+
+
+def sync_binding_alerts():
+    """厂商/模型启停、删除、恢复后立即重评估各 CLI 绑定链的静态死链告警：
+    恢复的当场解除、新死的当场亮起——不必等下一次步骤执行才发现
+    （2026-09-17 起与死链硬失败闸门配套）。幂等：health 侧静默/恢复语义不变。"""
+    from . import health
+    try:
+        binds = bindings()
+    except Exception:
+        return
+    for cli_id in sorted(binds.keys()):
+        b = binds.get(cli_id) or {}
+        if not _binding_chain(b):
+            continue  # 没配过链的 CLI 不归静态告警管（执行层闸门在跑时兜）
+        try:
+            r = resolve_binding(cli_id)
+            ok = bool(r and r.get("call_chain"))
+        except Exception:
+            ok = False
+        try:
+            if ok:
+                health.report_binding_ok(cli_id)
+            else:
+                health.report_binding_dead(cli_id, binding_dead_msg(cli_id))
+        except Exception:
+            pass  # 告警是尽力而为的旁路：persist 失败（如目录不可用）不拖累操作本身
+
+
 def resolve_binding(agent_kind_or_id, difficulty="default"):
     """返回 {env:{}, model:..., model_fallbacks:[...], codex_provider:..., call_chain:[...]} 或 None。
 
@@ -1981,17 +2035,11 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
     provs = {p.get("id"): p for p in providers()}
     routing = bool(b.get("difficulty_routing"))
     tier = difficulty if difficulty in ("easy", "hard") else None
-    # dsh 走 DEEPSEEK_* env，端点必须是 OpenAI 兼容的 /chat/completions，
-    # anthropic 协议的网关注进去也调不通，直接判为不可绑定。
-    allowed = ("openai",) if _deepseek_env_target(agent_kind_or_id) else _BINDABLE_PROTOCOLS
-    # 2026-09-15 连载验收实测：CLI 与供应商协议必须匹配——codex 只吃 openai wire
-    # （codex_provider 机制），claude 只吃 anthropic wire。混着注入会产生
-    # 「codex 拿到 ANTHROPIC_* env 却缺 ORCH_API_KEY」这类必然失败的组合
-    # （症状：Missing environment variable: ORCH_API_KEY）。
-    if agent_kind_or_id in ("codex-cli", "codex"):
-        allowed = ("openai",)
-    elif agent_kind_or_id in ("claude-code", "claude"):
-        allowed = ("anthropic",)
+    # 协议必须匹配（bindable_protocols）：dsh 只吃 OpenAI 兼容端点，codex 只吃
+    # openai wire（codex_provider 机制），claude 只吃 anthropic wire——混着注入
+    # 会产生「codex 拿到 ANTHROPIC_* env 却缺 ORCH_API_KEY」这类必然失败的组合
+    # （2026-09-15 连载验收实测，症状：Missing environment variable: ORCH_API_KEY）。
+    allowed = bindable_protocols(agent_kind_or_id)
 
     if chain:
         entries = []
@@ -2018,8 +2066,10 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
                 continue  # 原生协议与适配过的 wire 都不匹配：跳过
             if prov.get("name") in down_set:
                 continue  # 健康监测判定 down：跳过，省掉无效等待
-            if _is_codex_target(agent_kind_or_id) and codex_wire_blocked(prov):
-                continue  # codex 撞过该供应商 wire 不兼容（chat-only）：冷却中自动绕开
+            if _is_codex_target(agent_kind_or_id) and (ep[2] == "chat" or codex_wire_blocked(prov)):
+                continue  # codex 0.154+ 只讲 responses wire：chat-only 供应商在起跑前
+                          # 就剔除（此前撞了才冷却 30 分钟，每轮白烧一次注定失败的
+                          # 尝试——2026-09-17 续4 连载 c35 实测）
             if model and not _model_bindable(prov, model):
                 continue  # 模型被停用/删除：该条跳过（2026-09-15 告警弹框「禁用该模型」）
             # 多 KEY：同一厂商按 KEY 展开成多条，顺序即调用顺序。欠费的 KEY 被
@@ -2055,11 +2105,12 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
     prov = provs.get(pid)
     if not prov or not prov.get("enabled", True) or not prov.get("api_key"):
         return None
-    if _is_codex_target(agent_kind_or_id) and codex_wire_blocked(prov):
-        return None  # codex wire 不兼容冷却中：解析为空 → 路由绑定分自动转负
     ep = _entry_endpoint(prov, allowed)
     if not ep:
         return None  # google 只登记；dsh 只接受 OpenAI 兼容端点；未适配的不硬塞
+    if _is_codex_target(agent_kind_or_id) and (ep[2] == "chat" or codex_wire_blocked(prov)):
+        return None  # codex 0.154+ 只讲 responses：chat-only 供应商直接判不可绑
+                     # （解析为空 → 死链闸门/路由降权接手，不浪费 CLI 尝试）
     names = [m["name"] for m in _enabled_models(prov)]
     model = prov.get("model_" + tier) or "" if (routing and tier) else ""
     if not model:

package/app/core/pipeline.py

@@ -273,18 +273,51 @@ def _wait_gate(run_id, ev):
         time.sleep(1.0)
 
 
+def _binding_dead_msg(agent):
+    """死链失败文案：委托 modelhub 单一真源（告警 sync 共用同一文案）。"""
+    try:
+        from . import modelhub
+        return modelhub.binding_dead_msg(agent.get("id") or "")
+    except Exception:
+        return ("绑定链全部失效，本步判失败、不回落 CLI 本机默认——"
+                "请在「CLI 绑定」页为该 CLI 绑定已启用的供应商")
+
+
 def _run_step(run_id, role, agent, prompt, workdir, readonly, ev, timeout=runner.DEFAULT_TIMEOUT, note="", resume=None, images=None, require_tools=False):
     """执行一个智能体步骤并记录。返回 runner 统一结果。"""
     _wait_gate(run_id, ev)
-    # 绑定解析为空 → CLI 将回落本机默认配置（用户配置的模型/供应商全部不生效）。
-    # 2026-09-16 实测：这种状态下烧干配额的本机默认供应商被静默使用，用户以为
-    # 在用自己配的模型。首次出现时在步骤备注里醒目标出。
-    if agent.get("mode") == "real" and not (agent.get("call_chain") or agent.get("env")):
-        note = ((note + "；") if note else "") + \
-               "⚠ 未解析到绑定链，本步回落 CLI 本机默认配置（请在模型接入页检查该 CLI 的供应商绑定）"
+    # 绑定解析为空：旧语义是回落 CLI 本机默认继续跑，2026-09-16 实测这种状态
+    # 会静默烧本机默认供应商的配额（用户以为在用自己配的模型）。2026-09-17 起
+    # 改为「告警 + 本步直接判失败」——宁可失败不静默降级；auto 流程实现步的
+    # 既有换将会接手健康 CLI，真没有可用 CLI 时运行以明确的绑定错误收场。
+    dead_binding = (agent.get("mode") == "real"
+                    and not (agent.get("call_chain") or agent.get("env")))
+    dead_msg = _binding_dead_msg(agent) if dead_binding else ""
+    if dead_binding:
+        try:
+            from . import health
+            health.report_binding_dead(agent["id"], dead_msg)
+        except Exception:
+            pass
+        note = ((note + "；") if note else "") + "⚠ " + dead_msg
+    elif agent.get("mode") == "real":
+        try:  # 绑定恢复：自动解除该 CLI 的静态死链告警
+            from . import health
+            health.report_binding_ok(agent["id"])
+        except Exception:
+            pass
     step, log_abs = store.add_step(run_id, role, agent["id"],
                                    agent.get("label", agent["id"]), note=note)
     start = time.time()
+    if dead_binding:
+        from .error_codes import ErrorCode
+        res = {"ok": False, "text": "", "json": None, "cost_usd": 0.0,
+               "tokens": 0, "usage": None, "error": dead_msg,
+               "error_code": ErrorCode.ENV_BLOCK,
+               "raw": {"exit_code": None}, "kind": agent.get("kind", "generic"),
+               "model": agent.get("model")}
+        _finish_step_result(run_id, step, res, role, agent, start)
+        return res
     if agent.get("mode") == "mock":
         time.sleep(0.3)
         res = {"ok": True, "text": "[mock] %s" % prompt[:80], "json": None,
@@ -1601,12 +1634,19 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                 res = None
                 good = False
                 txt = ""
+                use_prompt = prompt
                 for draft_attempt in range(3):
                     if draft_attempt:
                         if ev is not None and ev.is_set():
                             break
                         time.sleep(30 * draft_attempt)   # 30s / 60s 退避
-                    res = _run_step(run_id, "draft-c%d" % i, modelhub.bind_agent(impl, difficulty), prompt,
+                    if draft_attempt and len(prompt) > 12000 and sk_block and sk_block in prompt:
+                        # 长提示词在容量受限通道（讯飞托管 35B 等）上会挂起/秒拒
+                        # ——降级重试：经验库块截到 4K 字，保留大纲/前情/本章要点
+                        # （2026-09-17 七猫实测：全量 30KB 对讯飞必挂）
+                        use_prompt = prompt.replace(
+                            sk_block, sk_block[:4000] + "\n\n（经验库已因通道容量限制精简）")
+                    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),
@@ -1626,15 +1666,23 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                             break
                     if ev is not None and ev.is_set():
                         break
-                # 同作者重试穷尽 → 起草换将（连载不断档优先，风格差异交评审门与
-                # 后续 revise 拉回）——与代码流程换将同款语义（2026-09-17 c34 实测）
+                # 同作者重试穷尽 → 起草换将：按路由分序逐个试备选（最多 2 个，
+                # 只试一个会让第二名没机会——2026-09-17 c35 实测 opencode 顶在
+                # 前面，能干活的 kimi 永远轮不上）。连载不断档优先，风格差异交
+                # 评审门与后续 revise 拉回。
                 if not good:
-                    other, other_reason = router.pick(
-                        agents, "implement", task.get("type") or "serial", None,
-                        exclude={impl["id"], "mock-a", "mock-b"})
-                    if other and other.get("mode") == "real":
+                    tried = {impl["id"], "mock-a", "mock-b"}
+                    for _alt in range(2):
+                        if good or (ev is not None and ev.is_set()):
+                            break
+                        other, other_reason = router.pick(
+                            agents, "implement", task.get("type") or "serial", None,
+                            exclude=tried)
+                        if not (other and other.get("mode") == "real"):
+                            break
+                        tried.add(other["id"])
                         res = _run_step(run_id, "draft-c%d" % i,
-                                        modelhub.bind_agent(other, difficulty), prompt,
+                                        modelhub.bind_agent(other, difficulty), use_prompt,
                                         step_wd, readonly=False, ev=ev, timeout=2400,
                                         images=_task_images(task, workdir),
                                         note="起草换将 %s → %s：%s" % (
@@ -1649,6 +1697,9 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                                 pass
                         if good:
                             draft_sid = ""   # 换将作者无本任会话，revise 另起
+                if not good:
+                    time.sleep(3)   # 落盘竞态宽限：CLI 崩溃退出前写的文件可能晚于
+                    good, txt = _chapter_state()   # 退出检查零点几秒才可见（c34 实测）
                 if not good:
                     store.update_run(run_id, status="failed",
                                      error="第 %d 章起草失败: %s" % (i, (res or {}).get("error")), ended_at=_now())
@@ -1668,53 +1719,68 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                 # 均分最高者为正稿。变体写隔离文件 chapter-XX-vK.md，赢家改名、
                 # 败稿删除；变体 0 = 本任作者（revise 会话沿用），其余取跨族优先的
                 # 其他真实智能体，不足时同作者开新会话凑数。
-                pool = [impl]
-                others = [a for a in agents if a.get("mode") == "real" and a["id"] != impl["id"]]
-                others.sort(key=lambda a: 0 if a.get("kind") != impl.get("kind") else 1)
-                pool += others[:n_variants - 1]
-                while len(pool) < n_variants:
-                    pool.append(impl)   # 不够就同作者再开一路（新会话天然出不同稿）
-                results = {}
-
-                def _draft_one(kk, agent):
-                    vfile = "chapter-%02d-v%d.md" % (i, kk)
-                    r = _run_step(run_id, "draft-c%d-v%d" % (i, kk),
-                                  modelhub.bind_agent(agent, difficulty),
-                                  _draft_prompt(vfile), step_wd, readonly=False, ev=ev,
-                                  timeout=2400,
-                                  # 赛马只在全新起草时启用（无续会话），每路都是新会话
-                                  images=_task_images(task, workdir),
-                                  note="赛马变体 %d/%d（%s）" % (kk + 1, len(pool), agent.get("id")))
-                    results[kk] = (vfile, agent, r)
-
-                threads = []
-                for kk, agent in enumerate(pool):
-                    th = threading.Thread(target=_draft_one, args=(kk, agent),
-                                          name="race-%s-c%d-v%d" % (run_id, i, kk), daemon=True)
-                    threads.append(th)
-                    th.start()
-                for th in threads:
-                    th.join(3000)
-                _check_cancel(ev)
-
                 scored_variants = []
-                for kk in range(len(pool)):
-                    vfile, agent, r = results.get(kk, (None, None, None))
-                    if vfile is None:
-                        continue
-                    txt = _read_variant(workdir, i, kk)
-                    ok_text = txt and _wc(txt) >= int(wpc * 0.6)
-                    if r is not None and not r["ok"] and not ok_text:
-                        continue   # 这一路彻底失败（无成品也不够长）
-                    if not ok_text:
-                        continue
-                    cj_map, sc, sids2 = run_critique(
-                        txt, 1, note_extra="（本稿为同章赛马变体 %d/%d，只评这一份）" % (kk + 1, len(pool)))
-                    m = means_of(cj_map)
-                    avg = round(sum(m.values()) / max(1, len(m)), 2) if m else 0.0
-                    scored_variants.append({"variant": kk, "agent": agent.get("id"),
-                                            "file": vfile, "means": m, "avg": avg,
-                                            "cj": cj_map, "scored": sc, "sids": sids2})
+                for race_round in range(2):
+                    # 全变体失败（网关突发限流）→ 60s 退避重赛一轮，别一章判死
+                    if race_round:
+                        if ev is not None and ev.is_set():
+                            break
+                        time.sleep(60)
+                        for kk in range(n_variants):
+                            # 清上一轮残稿：防陈旧半成品被本轮评分误认成新成品
+                            try:
+                                os.remove(os.path.join(workdir, "chapter-%02d-v%d.md" % (i, kk)))
+                            except OSError:
+                                pass
+                    pool = [impl]
+                    others = [a for a in agents if a.get("mode") == "real" and a["id"] != impl["id"]]
+                    others.sort(key=lambda a: 0 if a.get("kind") != impl.get("kind") else 1)
+                    pool += others[:n_variants - 1]
+                    while len(pool) < n_variants:
+                        pool.append(impl)   # 不够就同作者再开一路（新会话天然出不同稿）
+                    results = {}
+
+                    def _draft_one(kk, agent):
+                        vfile = "chapter-%02d-v%d.md" % (i, kk)
+                        r = _run_step(run_id, "draft-c%d-v%d" % (i, kk),
+                                      modelhub.bind_agent(agent, difficulty),
+                                      _draft_prompt(vfile), step_wd, readonly=False, ev=ev,
+                                      timeout=2400,
+                                      # 赛马只在全新起草时启用（无续会话），每路都是新会话
+                                      images=_task_images(task, workdir),
+                                      note="赛马变体 %d/%d（%s）" % (kk + 1, len(pool), agent.get("id")))
+                        results[kk] = (vfile, agent, r)
+
+                    threads = []
+                    for kk, agent in enumerate(pool):
+                        th = threading.Thread(target=_draft_one, args=(kk, agent),
+                                              name="race-%s-c%d-v%d" % (run_id, i, kk), daemon=True)
+                        threads.append(th)
+                        th.start()
+                    for th in threads:
+                        th.join(3000)
+                    _check_cancel(ev)
+
+                    scored_variants = []
+                    for kk in range(len(pool)):
+                        vfile, agent, r = results.get(kk, (None, None, None))
+                        if vfile is None:
+                            continue
+                        txt = _read_variant(workdir, i, kk)
+                        ok_text = txt and _wc(txt) >= int(wpc * 0.6)
+                        if r is not None and not r["ok"] and not ok_text:
+                            continue   # 这一路彻底失败（无成品也不够长）
+                        if not ok_text:
+                            continue
+                        cj_map, sc, sids2 = run_critique(
+                            txt, 1, note_extra="（本稿为同章赛马变体 %d/%d，只评这一份）" % (kk + 1, len(pool)))
+                        m = means_of(cj_map)
+                        avg = round(sum(m.values()) / max(1, len(m)), 2) if m else 0.0
+                        scored_variants.append({"variant": kk, "agent": agent.get("id"),
+                                                "file": vfile, "means": m, "avg": avg,
+                                                "cj": cj_map, "scored": sc, "sids": sids2})
+                    if scored_variants:
+                        break
                 if not scored_variants:
                     store.update_run(run_id, status="failed",
                                      error="第 %d 章赛马全部变体起草失败" % i, ended_at=_now())

package/app/core/registry.py

@@ -66,6 +66,10 @@ def _build_agent(entry):
         # 小时级 token 配额（可选，0/缺省=不限）：路由时对本小时用量超标的
         # 智能体降权（munder-difflin 式配额感知），订阅型 CLI 不至于被单任务打爆
         "quota_tokens_per_hour": int(orch.get("quota_tokens_per_hour") or 0),
+        # 整包透传 orch：per-agent 运行时开关（timeout_ms 5E、stall_timeout_s
+        # 看门狗等）都在 runner 侧读取——此前只挑字段，catalog 上配的
+        # timeout_ms/stall 根本流不到 runner（2026-09-17 连载 c35 实测）
+        "orch": orch,
     }
 
 

package/app/core/router.py

@@ -14,9 +14,10 @@ MAX_REPAIR_ROUNDS = 2  # 自动修复循环上限
 
 
 def _binding_bonus(agent_id):
-    """绑定链可用性加分/减分：链上有可用条目 +8，解析为空（回落 CLI 本机默认）
-    -25。2026-09-16 实测：静态能力基线让配额烧干的 codex 永远压过健康备用 CLI，
-    绑定空的 CLI 更是连用户配置的模型都没用上——先按「能不能按配置跑起来」校准。"""
+    """绑定链可用性加分/减分：链上有可用条目 +8，解析为空 -25。2026-09-16 实测：
+    静态能力基线让配额烧干的 codex 永远压过健康备用 CLI，绑定空的 CLI 更是连
+    用户配置的模型都没用上——先按「能不能按配置跑起来」校准。2026-09-17 起
+    空链步骤在 pipeline 直接判失败（不再静默回落本机默认），此处只管排序。"""
     try:
         from . import modelhub
         b = modelhub.resolve_binding(agent_id)
@@ -49,7 +50,7 @@ def score(agent, role, ttype, stats=None):
     if bb > 0:
         btxt = "，绑定链可用（+%s）" % bb
     elif bb < 0:
-        btxt = "，绑定链为空将回落 CLI 本机默认配置（%s）" % bb
+        btxt = "，绑定链为空：相关步骤将判失败（%s）" % bb
     hb = _history_bonus(stats, agent.get("id"), ttype)
     total = base + bb + hb
     hs = (stats.get(agent.get("id")) or {}).get(ttype)

package/app/core/runner.py

@@ -824,9 +824,18 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
     if orch_timeout_ms:
         timeout = float(orch_timeout_ms) / 1000.0
     kind = agent.get("kind", "generic")
-    stall_t = (_stall_timeout("TUTTI_CODEX_STALL_TIMEOUT", 600) if kind == "codex"
-               else _stall_timeout("TUTTI_CLAUDE_STALL_TIMEOUT", 600)
-               if kind == "claude" else 0)
+    if kind == "codex":
+        stall_t = _stall_timeout("TUTTI_CODEX_STALL_TIMEOUT", 600)
+    elif kind == "claude":
+        stall_t = _stall_timeout("TUTTI_CLAUDE_STALL_TIMEOUT", 600)
+    else:
+        # 数据驱动：catalog orch.stall_timeout_s——给 kimi 这类边写边吐进度行的
+        # CLI 配置后，静默挂死 10 分钟即杀（不必耗满总超时）；qwen/mimo 这类
+        # 结束才一次性输出的留 0（开了必误杀），靠总超时兜底
+        try:
+            stall_t = max(0, int((agent.get("orch") or {}).get("stall_timeout_s") or 0))
+        except Exception:
+            stall_t = 0
     # 5G：approval NEVER 一线（无人值守不静默降级）
     ok, reason = _check_approval(agent)
     if not ok:

package/app/core/selfupdate.py

@@ -76,7 +76,8 @@ def _npm_meta():
     """npm view <pkg> --json；返回 (latest, relnotes, err)。
 
     relnotes 来自 registry 元数据里的 README（与查新同一条 npm 通道，不依赖
-    GitHub 连通性），展示「新版本更新内容」用。"""
+    GitHub 连通性），展示「新版本更新内容」用。部分 npm 版本 --json 不带
+    readme 字段，此时回退到 `npm view <pkg> readme` 纯文本再提取。"""
     r = runner.run_process(
         argv=["cmd", "/c", "npm", "view", _PKG_NAME, "--json"], timeout=60)
     if not r["ok"]:
@@ -92,6 +93,11 @@ def _npm_meta():
     if not ver:  # 旧 npm --json 失败时退回纯文本解析
         m = re.search(r"\d+\.\d+\.\d+[\w.\-]*", r["stdout"] or "")
         ver = m.group(0) if m else ""
+    if ver and not notes:
+        r2 = runner.run_process(
+            argv=["cmd", "/c", "npm", "view", _PKG_NAME, "readme"], timeout=60)
+        if r2["ok"]:
+            notes = _relnotes(r2["stdout"] or "")
     return ver, notes, ("" if ver else "npm 输出无法解析")