codebee 0.1.51 → 0.1.53

package/CHANGELOG.md

@@ -23,6 +23,18 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 
 - **首选 KEY 超限自动切备用了**：同厂商多密钥此前只认欠费类文案——首选 KEY 撞上 429 限流（智谱「并发数超过限制」「每分钟Token数已超过上限」、claude 的 rate_limit_error、codex 的 "429 Too Many Requests" 等）只记一笔错误、不进冷却，每个新步骤仍从超限的首选 KEY 重新烧起。现在限流文案与欠费同口径：进冷却 30 分钟、密钥镜像自动切下一把、链展开跳过冷却中的 KEY（到期或「恢复」按钮一键回首选）。顺带补一处漏账：无显式链时「换模型回退」的链条目不带 KEY 标记，这类重试失败此前完全不记 KEY 账。
 
+## v0.1.53（2026-09-23）
+
+- 换将救活两类「假终态」：上游内容拒答（"can't help with this" 一类 refusal）与真超时，现在都会换绑定链上下一个候选再试——此前拒答直接判死整轮任务（链上异上游候选从未被尝试），超时能不能换全凭输出尾段碰巧带 "timeout" 字样；真实案：夜间知识库整理任务被网关 gemini 拒答后整 run 白烧
+- 同一慢上游连烧止损：链上候选连续两次相同超时即收手（换将=换壳不换命），最坏从 N×单步超时压到 2×；取消显式列为终态绝不降级
+- 网关模型漂移可见：请求 A 模型被网关实际映射成 B 模型时（真实案：请求 deepseek-v4.1-flash 实服 gemini-3.8-flash），失败信息与步骤日志明确标注「请求 X，上游实服 Y」，排查看对病根
+
+## v0.1.52（2026-09-22）
+
+- 手动指定执行者优先级全面收口：用户点名的 CLI 压过一切自动选择——路由不换将、旁观不抢占、绑定不覆盖；「手动指定执行者」作为一等偏好随任务走
+- 管理页执行者下拉可指定为对话执行者的真实 CLI（与新建任务两级菜单复用同一段逻辑）
+- runner 静默挂死看门狗对「等结束才一次性输出」的 CLI 保留原语义，防误杀
+
 ## v0.1.51（2026-09-22）
 
 - 智能路由：绑定链可用性细化为「有备胎」维度（解析出的调用链有第二条及以上的任务加分），静态能力基线不再把配额烧干的供应商顶在前面

package/README.md

@@ -21,11 +21,11 @@ Kimi Code、MiMo Code、Grok Build、Pi、DeepSeek Harness……），提供
 不会把你的任务内容交给任何第三方。
 
 <!-- relnotes:start -->
-### 最新版更新内容（v0.1.51）
+### 最新版更新内容（v0.1.53）
 
-- 智能路由识别「有备胎」的绑定链并加分；配额烧干的供应商不再霸占前排
-- 内置智能体尊重用户指定的实现者；推理思考 token 计入输出预算
-- 错误识别降噪：提示词回显不再被误判为执行错误
+- 换将救活两类「假终态」：上游内容拒答（refusal）与真超时都会换链上下一个候选再试，不再整轮白烧
+- 同一慢上游连烧止损：连续两次相同超时即收手；取消绝不降级
+- 网关模型漂移可见：请求与实际服务的模型不一致时，失败信息明确标注
 <!-- relnotes:end -->
 
 ---

package/app/core/automation.py

@@ -65,7 +65,7 @@ _DEFAULTS = {"id": "", "name": "", "prompt": "", "workdir": "", "kind": "", "tim
              "mode": "auto", "thinking": "standard",
              "direct_provider_id": "", "direct_model": "",
              "enabled": False, "created_at": "", "last_run": "", "next_run": "",
-             "run_count": 0, "last_status": ""}
+             "run_count": 0, "last_status": "", "last_run_id": ""}
 
 # 允许通过 update() 修改的字段（id/created_at/run_count 等运行痕迹不可改）
 _UPDATABLE = ("name", "prompt", "workdir", "kind", "time", "interval_hours",
@@ -386,8 +386,9 @@ def _fire(snapshot, now):
     """触发一个到期任务：拉起运行并推进 last_run/next_run/run_count/last_status。
     once 触发完自动停用。拉起失败只记 error，next_run 照常推进（下个周期重试）。"""
     status = "started"
+    run_id = ""
     try:
-        _launch_run(snapshot)
+        run_id = _launch_run(snapshot) or ""
     except Exception as e:
         log.warning("automation: 定时触发 %s 失败: %r", snapshot.get("id"), e)
         status = "error"
@@ -398,6 +399,8 @@ def _fire(snapshot, now):
         cur["last_run"] = _fmt_dt(now)
         cur["run_count"] = int(cur.get("run_count") or 0) + 1
         cur["last_status"] = status
+        if run_id:
+            cur["last_run_id"] = run_id
         if cur.get("kind") == "once":
             cur["enabled"] = False
             cur["next_run"] = ""
@@ -408,6 +411,49 @@ def _fire(snapshot, now):
 
 # ---------------------------------------------------------------- 调度线程
 
+def _default_run_status(rid):
+    """按 run_id 查运行状态（终态回写用）；查不到返回 None。"""
+    from . import store
+    try:
+        r = store.get_run(rid)
+    except Exception:
+        return None
+    return (r or {}).get("status") or None
+
+
+# 测试可替换的查态钩子
+_RUN_STATUS = _default_run_status
+
+_RUN_TERMINAL = ("done", "failed", "cancelled")
+
+
+def _reconcile_statuses():
+    """把 last_status 停在 started 的任务对账到真实运行终态。此前触发后永不
+    回写，任务卡片永远显示「运行中」（2026-09-23 实案：三个任务全部如此）。
+    store 查不到或还没到终态就保持原样，下一轮 tick 再看。"""
+    with _LOCK:
+        pending = {tid: t.get("last_run_id") for tid, t in _TASKS.items()
+                   if t.get("last_run_id") and t.get("last_status") == "started"}
+    if not pending:
+        return
+    settled = {}
+    for tid, rid in pending.items():
+        st = _RUN_STATUS(rid)
+        if st in _RUN_TERMINAL:
+            settled[tid] = st
+    if not settled:
+        return
+    with _LOCK:
+        dirty = False
+        for tid, st in settled.items():
+            t = _TASKS.get(tid)
+            if (t and t.get("last_run_id") == pending[tid]
+                    and t.get("last_status") == "started"):
+                t["last_status"] = st
+                dirty = True
+        if dirty:
+            _save_locked()
+
 def _tick():
     """扫描一遍到期任务并逐个触发。单任务异常只跳过该条，绝不上抛。"""
     now = datetime.now()
@@ -429,6 +475,11 @@ def _tick():
             _fire(dict(t), now)
         except Exception:
             log.exception("automation: tick 处理任务 %s 异常，已跳过", tid)
+    # 运行终态对账：last_status 停在 started 的任务查一次真实终态（见函数注）。
+    try:
+        _reconcile_statuses()
+    except Exception:
+        log.debug("automation: 运行终态对账跳过", exc_info=True)
     # 定时发布联动（P2.5）：任务级 auto_publish 标记到点触发批量发布。
     # 发布逻辑全在 publish/auto（护栏/幂等/单飞），这里只当调度宿主。
     try:
@@ -581,10 +632,11 @@ def run_now(tid):
     now = datetime.now()
     run_id = ""
     status = "started"
+    run_id = ""
     try:
         with _LOCK:
             snapshot = dict(_TASKS[tid])
-        run_id = _launch_run(snapshot)
+        run_id = _launch_run(snapshot) or ""
     except Exception as e:
         log.warning("automation: 手动触发 %s 失败: %r", tid, e)
         status = "error"
@@ -592,9 +644,17 @@ def run_now(tid):
         t = _TASKS.get(tid)
         if t is None:
             return None, None
-        t["last_run"] = _fmt_dt(now)
+        # interval 任务的 last_run 是 next_run 的计算锚点（compute_next_run 按
+        # last_run + N 小时向前滚），手动触发写进来会让重启重算把档期整体后移
+        # ——2026-09-23 实案：22:28 手动跑一轮 + 23:43 服务重启，本该 23:53
+        # 触发的档期被抹成 00:28。interval 只让调度触发推进 last_run；其余
+        # kind 的 next_run 由 time/weekday 决定，last_run 仅作展示，照旧写。
+        if t.get("kind") != "interval":
+            t["last_run"] = _fmt_dt(now)
         t["run_count"] = int(t.get("run_count") or 0) + 1
         t["last_status"] = status
+        if run_id:
+            t["last_run_id"] = run_id
         _save_locked()
         return dict(t), run_id
 

package/app/core/branching.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+"""多线剧情推演（inkos 借鉴 2026-09-23）：写章前一次调用生成 2-3 条分支
+节拍计划，自带推荐择优，选中分支注入本章 BEATS；全部分支追加审计文件
+.codebee/branch-plans.md 供回看。计划级赛马——比 prose 级 Best-of-N 省
+一个数量级的 token。"""
+from __future__ import annotations
+
+import logging
+import os
+
+log = logging.getLogger(__name__)
+
+BRANCH_PLAN_PROMPT = """你是网文剧情策划。基于全书设定与上一章结尾，为下一章生成 __N__ 条**彼此方向不同**的剧情分支计划。
+
+要求：
+- 每条分支给出：本章节拍（50-120 字：事件/冲突/推进）+ 章末钩子（一句话）+ 一句取舍理由（为什么选/不选它）
+- 分支之间要有真实的方向差异（不同冲突来源/不同人物决定/不同信息揭示），不是同一件事换措辞
+- 你是策划也是评委：综合大纲意图、前情、人物动机，推荐其中最有力的一条
+
+只输出一个 ```json 代码块：
+{"branches": [{"beats": "…", "hook": "…", "why": "…"}, …], "pick": 0}
+pick = 推荐分支的下标（0 起）。
+
+## 全书目标
+__GOAL__
+
+## 大纲上下文（本章前后）
+__OUTLINE__
+
+## 上一章结尾
+__PREV__
+"""
+
+
+def plan_branches(run_id, task, i, goal, outline_txt, prev, n, *, log_path=None):
+    """生成并择优一条分支计划。返回 (beats, hook) 或 None（失败/未启用走原大纲）。
+
+    编排者一次调用产 N 条+自荐 pick；失败静默回落原大纲节拍（推演是增强
+    不是闸门）。全部分支连同 pick 追加 .codebee/branch-plans.md 审计。"""
+    if n < 2:
+        return None
+    from . import modelhub, runner
+    if n < 2:
+        return None
+    orch = modelhub.resolve_orchestrator()
+    if not orch:
+        return None
+    prov, model = orch
+    prompt = (BRANCH_PLAN_PROMPT
+              .replace("__N__", str(n))
+              .replace("__GOAL__", goal[:600])
+              .replace("__OUTLINE__", outline_txt[:3000])
+              .replace("__PREV__", (prev or "（开篇）")[-1200:]))
+    res = modelhub.chat(prov["id"], model, prompt, max_tokens=4000, timeout=300)
+    if not res.get("ok"):
+        return None
+    data = runner.extract_json(res.get("text") or "")
+    branches = (data or {}).get("branches") if isinstance(data, dict) else None
+    if not isinstance(branches, list):
+        return None
+    usable = [b for b in branches
+              if isinstance(b, dict) and str(b.get("beats") or "").strip()]
+    if len(usable) < 2:
+        return None
+    try:
+        pick = int(data.get("pick") or 0)
+    except (TypeError, ValueError):
+        pick = 0
+    pick = max(0, min(pick, len(usable) - 1))
+    chosen = usable[pick]
+    try:
+        from . import store as _store
+        wd = _store.run_workdir(run_id) or ""
+    except Exception:
+        wd = ""
+    _append_audit(wd, i, usable, pick)
+    return (str(chosen["beats"]).strip()[:300],
+            str(chosen.get("hook") or "").strip()[:80] or None)
+
+
+def _append_audit(workdir, chapter, branches, pick):
+    """全部分支追加 .codebee/branch-plans.md（失败静默——审计是增强）。"""
+    if not workdir:
+        return
+    try:
+        p = os.path.abspath(os.path.join(str(workdir), ".codebee",
+                                         "branch-plans.md"))
+        root = os.path.abspath(str(workdir))
+        if root not in p.split(os.sep)[:-len([".codebee", "branch-plans.md"])]:
+            if not p.startswith(root + os.sep):
+                return
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        with open(p, "a", encoding="utf-8") as f:
+            if f.tell() == 0:
+                f.write("# 多线剧情推演（每章分支计划与择优，供回看）\n\n")
+            f.write("## 第 %d 章\n" % chapter)
+            for k, b in enumerate(branches):
+                mark = "✅ " if k == pick else ""
+                f.write("- %s%s（钩子：%s）——%s\n" % (
+                    mark, str(b.get("beats") or "")[:160],
+                    str(b.get("hook") or "")[:60],
+                    str(b.get("why") or "")[:120]))
+            f.write("\n")
+    except Exception:
+        pass

package/app/core/catalog.py

@@ -64,7 +64,10 @@ DEFAULT_CATALOG = [
         "note": "通义千问编码 CLI（gemini-cli 系）；无头走 stdin；绑定凭据经打开注入"
                 "写 settings.json 的 env 段（OPENAI_*，qwen 存在即优先 openai 兼容通道）",
         "detect": {"cli": "qwen"},
-        "orch": {"kind": "qwen", "command": "qwen"},
+        # stall_timeout_s：静默 15 分钟即杀（2026-09-22 全书总评实案：qwen 吐完
+        # 评审内容后卡在 MCP 收尾死锁，输出归零但进程活着，stall=0 时只能干等
+        # 2400s 总超时；900s 取「评审模型调用常见上限 5 分钟」的 3 倍，防误杀）
+        "orch": {"kind": "qwen", "command": "qwen", "stall_timeout_s": 900},
         # settings.json 顶层 "model" 已是 legacy（qwen 忽略并告警，新格式是
         # model.name）——模型落盘由打开注入器写 OPENAI_MODEL env 负责，
         # 这里不再走 write_model
@@ -154,7 +157,7 @@ DEFAULT_CATALOG = [
         "note": "DeepSeek 官方 agent harness（dsh，profile 插件架构）；无头是「一次性任务」——"
                 "答完即退、无交互后续、不支持会话恢复；任务只走位置参数（超长提示词受 Windows "
                 "命令行上限约 32k 约束）；模型写进 ~/.dsh/settings.yaml 的 agent-default-model.model；"
-                "密钥由运行时自动调度或「模型调度（可选）」注入 DEEPSEEK_API_KEY（优先级最高）；端点注入 DEEPSEEK_BASE_URL，"
+                "密钥由运行时自动调度或「模型调度（可选）」注入 DEEPSEEK_API_KEY（优先级最高）；端点注入 DEEPSEEK_BASE_URL，"
                 "但若 settings.yaml 已固定 llm-deepseek.baseURL，则以它为准（settings 高于 env）",
         "detect": {"cli": "dsh"},
         "orch": {"kind": "generic", "command": "dsh",
@@ -316,6 +319,21 @@ def _apply_config_patch(entries):
             e["config"] = dict(patch)
 
 
+def _apply_stall_patch(entries):
+    """存量数据幂等补齐：qwencode 补 stall_timeout_s=900（2026-09-22 实案）。
+
+    data/catalog.json 生成后不会再随版本重写，老清单里的 qwencode 没有
+    停滞看门狗配置（当时按「结束才一次性输出」留 0）；实际验证 qwen 评审
+    会先流式吐内容再卡死在 MCP 收尾，静默看门狗能兜住。用户手写过该字段的
+    不覆盖（包括显式写 0 关闭的）。"""
+    for e in entries:
+        if e.get("id") != "qwencode":
+            continue
+        orch = e.get("orch")
+        if isinstance(orch, dict) and "stall_timeout_s" not in orch:
+            orch["stall_timeout_s"] = 900
+
+
 def _apply_install_patch(entries):
     # Aider 渠道整体迁移到 uv tool（跨平台、含存量数据幂等修正）：anaconda 的
     # py -3.13 装 aider 必挂在 numpy 源码构建（老 setuptools 引用 py3.12 已删除
@@ -371,6 +389,7 @@ def load(force=False):
         _apply_launch_patch(entries)
         _apply_config_patch(entries)
         _apply_install_patch(entries)
+        _apply_stall_patch(entries)
         _CACHE["entries"] = entries
         return entries
 

package/app/core/knowledge.py

@@ -234,7 +234,10 @@ def block_for(task):
             grams = (skills._text_bigrams(x.get("title"))
                      | skills._text_bigrams(x.get("body"))
                      | set(x.get("tags") or []))
-            return (-len(probe & grams), x.get("id") or "")
+            # 过期降权（inkos 检索保留来源/位置的启发）：同等相关性下，
+            # 可能过期的事实排在新鲜事实之后——旧知识不该压过新知识
+            return (-len(probe & grams), 1 if _is_stale(x.get("as_of")) else 0,
+                    x.get("id") or "")
         entries = sorted(entries, key=rank)
     else:
         entries.sort(key=lambda x: x.get("id") or "")

package/app/core/pipeline.py

@@ -19,7 +19,7 @@ import re
 import threading
 import time
 
-from . import aiflavor, attachments, catalog, dispatch_log, history, hooks, jobs, knowledge, manager, modelhub, mocks, paihang, planner, registry, router, runner, skills, store, task_compile, usage, volumes
+from . import aiflavor, attachments, branching, catalog, dispatch_log, history, hooks, jobs, knowledge, manager, modelhub, mocks, paihang, planner, registry, router, runner, skills, store, task_compile, usage, volumes
 from . import builtin_agent
 from . import diagnostics
 from . import paths as paths_mod
@@ -1481,11 +1481,31 @@ def _run_direct(run, task, agents, ev, stats, mode):
     route = {}
     resume_ctx = _valid_resume(task, agents)
     bi = None
+    impl = None
     direct_provider = (task.get("direct_provider_id") or "").strip()
     direct_model = (task.get("direct_model") or "").strip()
+    direct_agent = (task.get("direct_agent") or "").strip()
     direct_difficulty = ("hard" if task.get("thinking") == "high" else
                          "easy" if task.get("thinking") == "low" else "default")
-    if resume_ctx is None and direct_provider:
+    if resume_ctx is None and direct_agent:
+        # 手动指定执行 CLI（2026-09-23）：用户点名压过一切自动（模型绑定/
+        # 自动推荐/路由）。目标未启用编排时按续会话语义注入（installed_agent
+        # 无视启停开关）——显式指定不该被「参与编排」开关否决。
+        impl = _pick(agents, direct_agent)
+        if impl is None:
+            extra = registry.installed_agent(direct_agent, catalog.load(),
+                                             manager.detect_all())
+            if extra:
+                agents.append(extra)
+                impl = extra
+        if impl is None:
+            store.update_run(run_id, expected_status="running", status="failed",
+                             error="指定的执行 CLI「%s」不可用（未安装或未检测到），"
+                                   "请在对话条改回自动推荐，或到目录页先安装" % direct_agent,
+                             ended_at=_now())
+            return
+        route["implementer"] = "%s（手动指定 CLI）" % (impl.get("label") or impl.get("id"))
+    elif resume_ctx is None and direct_provider:
         bi = builtin_agent.resolve(direct_provider, direct_model, direct_difficulty)
         if bi is None:
             store.update_run(run_id, expected_status="running", status="failed",
@@ -1507,6 +1527,8 @@ def _run_direct(run, task, agents, ev, stats, mode):
     elif resume_ctx is not None:
         impl = resume_ctx["agent"]
         route["implementer"] = resume_ctx["note"]
+    elif impl is not None:
+        pass          # 手动指定 CLI 已就位（route 亦已写）
     elif mode == "manual":
         impl, _ = _pick_implementer(agents, task.get("implementer"))
     else:
@@ -2534,6 +2556,20 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
             scope = ("本章 = 大纲第 %d 章" % i) if start == 1 else (
                 "本批为第 %d–%d 章，下列按全书章号列出各章要点" % (start, end))
 
+            # 多线剧情推演（inkos 借鉴 2026-09-23）：serial.branches>=2 时
+            # 写章前一次编排者调用生成 N 条分支节拍、自荐择优，选中分支替换
+            # 本章 BEATS/HOOK（计划级赛马，省 prose 级开销）；失败静默走原大纲。
+            branch_beats = branch_hook = None
+            try:
+                n_branch = max(1, min(3, int(serial.get("branches") or 1)))
+                if n_branch >= 2:
+                    got = branching.plan_branches(
+                        run_id, task, i, task["goal"], outline_txt, prev, n_branch)
+                    if got:
+                        branch_beats, branch_hook = got
+            except Exception:
+                branch_beats = None
+
             def _draft_prompt(vfile):
                 return (SERIAL_CHAPTER_PROMPT
                         .replace("__SKILLS__", sk_block)
@@ -2545,8 +2581,8 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                         .replace("__PREV__", prev)
                         .replace("__LEDGER__", ledger_txt)
                         .replace("__TITLE__", ch["title"])
-                        .replace("__BEATS__", ch["beats"] or "按大纲推进")
-                        .replace("__HOOK__", ch.get("hook") or "留下悬念")
+                        .replace("__BEATS__", branch_beats or ch["beats"] or "按大纲推进")
+                        .replace("__HOOK__", branch_hook or ch.get("hook") or "留下悬念")
                         .replace("__WORDS__", str(wpc)))
 
             n_variants = max(1, min(3, int(serial.get("variants") or 1)))

package/app/core/prefs.py

@@ -14,15 +14,20 @@ from . import paths
 
 _LOCK = threading.Lock()
 
-SAVE_KEYS = ("type", "rounds", "threshold", "best_of", "chapters",
-             "words_per_chapter", "variants", "mode", "thinking")
-_LIMITS = {"rounds": (1, 5), "threshold": (1.0, 10.0), "best_of": (1, 3),
-           "chapters": (1, 2000), "words_per_chapter": (200, 20000),
-           "variants": (1, 3)}
-_CHOICES = {
-    "mode": ("auto", "fast", "expert", "manual"),
-    "thinking": ("auto", "low", "standard", "high"),
-}
+SAVE_KEYS = ("type", "rounds", "threshold", "best_of", "chapters",
+             "words_per_chapter", "variants", "mode", "thinking",
+             # direct 类型的对话模型偏好（2026-09-23 补全偏好记忆覆盖面）：
+             # 厂商 id/模型名/推理档——下次新建 direct 任务沿用上次手选
+             "direct_provider", "direct_model", "direct_thinking")
+_LIMITS = {"rounds": (1, 5), "threshold": (1.0, 10.0), "best_of": (1, 3),
+           "chapters": (1, 2000), "words_per_chapter": (200, 20000),
+           "variants": (1, 3)}
+_CHOICES = {
+    "mode": ("auto", "fast", "expert", "manual"),
+    "thinking": ("auto", "low", "standard", "high"),
+    "direct_thinking": ("auto", "low", "standard", "high"),
+}
+_STR_KEYS = ("type", "direct_provider", "direct_model")   # 自由字符串截断白名单
 
 
 def _file():
@@ -51,17 +56,17 @@ def record(payload):
             v = payload.get(key)
             if v is None:
                 continue
-            if key == "type":
-                v = str(v)[:32]
-                if v:
-                    cur["type"] = v
-                continue
-            if key in _CHOICES:
-                v = str(v).strip().lower()
-                if v in _CHOICES[key]:
-                    cur[key] = v
-                continue
-            c = _clamp(key, v)
+            if key in _STR_KEYS:
+                v = str(v).strip()[:64]
+                if v:
+                    cur[key] = v
+                continue
+            if key in _CHOICES:
+                v = str(v).strip().lower()
+                if v in _CHOICES[key]:
+                    cur[key] = v
+                continue
+            c = _clamp(key, v)
             if c is not None:
                 cur[key] = c
         tmp = _file().with_suffix(".tmp")

package/app/core/runner.py

@@ -823,6 +823,10 @@ def _parse_claude_json(stdout):
         int(u.get("cache_creation_input_tokens") or 0)
     usage = {"input": inp, "output": out, "cached": cached, "reasoning": 0,
              "total": inp + out + cached}
+    # 网关实服模型：请求 deepseek-v4.1-flash 却被网关映射成 gemini-3.8-flash
+    # 之类（2026-09-23 夜班实案）——用量统计记错名、失败排查看错病根，都
+    # 靠 result 行的 modelUsage 对出来
+    served = sorted({str(k) for k in ((data.get("modelUsage") or {}) or {})})
     return {
         "text": data.get("result") or "",
         "cost_usd": data.get("total_cost_usd") or 0.0,
@@ -831,6 +835,7 @@ def _parse_claude_json(stdout):
         "is_error": bool(data.get("is_error")),
         # §07 T1.1：claude -p 返回本次会话 id，供 --resume 复用
         "sid": str(data.get("session_id") or ""),
+        "served_models": served,
     }
 
 
@@ -898,6 +903,55 @@ RATE_LIMIT_GRACE_S = 45      # 宽限等待时长：限流窗口通常按分钟
 RATE_LIMIT_GRACE_N = 1       # 每步宽限次数：只兜一次，防限流长拖整轮时间
 
 
+# 上游内容拒答（refusal）：claude CLI 把 refusal stop_reason 渲染成
+# "API Error: <model> can't help with this. Start a new session to continue."
+# 这是网关后面那个模型对本次会话内容的过滤决定，不是任务终态——换一家
+# 异上游候选常常就能跑通。2026-09-23 夜班实案：doc 起草被 gemini 拒答后
+# 判成非瞬态整链早死，链上云知声候选根本没被尝试。
+_REFUSAL = ("can't help with this", "couldn't help with this",
+            'stop_reason":"refusal"', "content policy", "content filtering")
+
+
+def _refusal_error(err):
+    err = (err or "").lower()
+    return any(k in err for k in _REFUSAL)
+
+
+def _fail_sig(err):
+    """错误串的病根特征（剥掉输出尾段/数字/会话 id 等易变片段），供换将
+    循环做同因连撞止损。与 jobs._err_signature 同思路的轻量版，避免 core
+    模块环。超时错误的尾段是每次被杀时刻的输出快照，必然不同，签名只取
+    头部（；分隔符之前）。"""
+    s = str(err or "")
+    for sep in ("；stderr/stdout", "；日志错误行"):
+        i = s.find(sep)
+        if i > 0:
+            s = s[:i]
+            break
+    s = re.sub(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}",
+               "<sid>", s)
+    s = re.sub(r"\d+", "N", s)
+    return re.sub(r"\s+", " ", s).strip()[:200]
+
+
+def _claude_drift_note(att_model, parsed):
+    """请求模型 vs 网关实服模型不一致时的注记；一致或无从判断返回空。"""
+    served = (parsed or {}).get("served_models") or []
+    if not served or not att_model or served == [att_model]:
+        return ""
+    return "[模型漂移] 请求 %s，上游实服 %s" % (att_model, ",".join(served))
+
+
+def _log_note(log_path, text):
+    if not log_path or not text:
+        return
+    try:
+        with open(log_path, "a", encoding="utf-8") as fh:
+            fh.write("\n[%s]\n" % text)
+    except OSError:
+        pass
+
+
 def _rate_limited(err):
     err = (err or "").lower()
     return any(k in err for k in _RATE_LIMIT)
@@ -1255,7 +1309,8 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
     防模型纯口头谎报「环境受限」蒙混过关（2026-09-17 mo-so 实测）。
 
     模型尝试顺序来自 _resolve_attempts：跨厂商链（每条独立 env）或
-    主模型 + 降级备选；瞬态错误才换下一条，取消/超时/解析失败不降级。
+    主模型 + 降级备选；瞬态/配额/超时/上游拒答换下一条，取消与解析
+    失败不降级；超时连续两次同签名即止损（同一慢上游换壳无用）。
 
     5E：catalog `orch.timeout_ms`（毫秒）优先于 caller 传入的 timeout。
     """
@@ -1276,9 +1331,9 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
     elif kind == "claude":
         stall_t = _stall_timeout("TUTTI_CLAUDE_STALL_TIMEOUT", 600)
     else:
-        # 数据驱动：catalog orch.stall_timeout_s——给 kimi 这类边写边吐进度行的
-        # CLI 配置后，静默挂死 10 分钟即杀（不必耗满总超时）；qwen/mimo 这类
-        # 结束才一次性输出的留 0（开了必误杀），靠总超时兜底
+        # 数据驱动：catalog orch.stall_timeout_s——给 kimi/qwen 这类评审用
+        # CLI 配置后，静默挂死即杀（qwen 900s：2026-09-22 MCP 收尾死锁案）；
+        # mimo 等结束才一次性输出的仍留 0（开了必误杀），靠总超时兜底
         try:
             stall_t = max(0, int((agent.get("orch") or {}).get("stall_timeout_s") or 0))
         except Exception:
@@ -1308,6 +1363,7 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
     attempts = _resolve_attempts(agent)
     out = None
     grace_left = RATE_LIMIT_GRACE_N  # 链尾限流宽限预算：整链撞 429 时原地等一个窗口再试一次
+    prev_sig = ""  # 上一次尝试的失败签名：同因连撞止损用
     for ai, att in enumerate(attempts):
         env = dict(base_env)
         env.update(att["env"])
@@ -1370,6 +1426,10 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                     parsed_err = _parse_claude_json(res["stdout"] or "")
                     if parsed_err and parsed_err.get("is_error") and parsed_err.get("text"):
                         out["error"] = "claude 返回 is_error: " + parsed_err["text"][:500]
+                        drift = _claude_drift_note(att.get("model"), parsed_err)
+                        if drift:
+                            out["error"] += "；" + drift
+                            _log_note(log_path, drift)
                 if kind == "codex" and att.get("provider_id"):
                     el = out["error"].lower()
                     if (("wire_api" in el and "no longer supported" in el)
@@ -1442,9 +1502,14 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                 out["tokens"] = parsed["tokens"]
                 out["usage"] = parsed["usage"]
                 out["sid"] = parsed.get("sid") or ""  # §07 T1.1
+                drift = _claude_drift_note(att.get("model"), parsed)
+                if drift:
+                    _log_note(log_path, drift)
                 if parsed["is_error"]:
                     out["ok"] = False
                     out["error"] = "claude 返回 is_error: " + parsed["text"][:500]
+                    if drift:
+                        out["error"] += "；" + drift
                     out["error_code"] = _classify_failure(res, kind="claude", parsed=parsed)
                     break
                 if not out["text"] and attempt == 0:
@@ -1471,10 +1536,30 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                     attempts.append(att)
                     continue
             return out
-        # 瞬态网络错误 → 换下一条；欠费/配额耗尽同样换（可能是同厂商的备用 KEY，
-        # 也可能是另一家厂商）——账单断了死磕同一把 KEY 没有任何意义。
-        if not (_transient_error(out.get("error")) or _quota_error(out.get("error"))):
-            return out  # 非瞬态（取消/超时/解析失败）不降级
+        # 换将闸门：什么失败值得烧链上下一个候选。
+        # · 瞬态/配额（文本特征，含 CLI 内部 api_retry 的 429/5xx 字样）照旧；
+        # · 超时：显式可换（看 res 标志位）——慢上游换快候选可能救回。
+        #   2026-09-23 夜班实案：旧逻辑里超时能否换将全赌输出尾部碰巧含有
+        #   "timeout" 字样（当时是步骤里读到的代码 timeout=900 撞的表）。
+        # · 上游内容拒答（refusal）：是那家模型的过滤决定，不是任务终态，
+        #   换异上游候选常常就活；判死则整 run 白烧（同案：gemini 拒答后
+        #   链上云知声候选从未被尝试）。
+        raw = out.get("raw") or {}
+        if (raw.get("cancelled")   # 取消是用户意志，绝不降级（尾段可能带瞬态字样）
+                or not (_transient_error(out.get("error")) or _quota_error(out.get("error"))
+                        or _refusal_error(out.get("error"))
+                        or raw.get("timed_out"))):
+            return out  # 取消/解析失败等真终态不降级
+        # 超时同因连撞止损：头部签名（超时/输出停滞）连续相同就收手——
+        # 链上候选绑同一上游时换将=换壳不换命（2026-09-22 429 集群教训；
+        # 2026-09-23 夜班实案同一慢上游连烧 3×20 分钟全超时零产出），最坏
+        # 情况从 N×步超时压到 2×。其余瞬态/拒答仍按链长全部尝试：各家病根
+        # 不同，每个候选都值得一次机会。
+        if raw.get("timed_out"):
+            sig = _fail_sig(out.get("error"))
+            if sig and sig == prev_sig:
+                return out
+            prev_sig = sig
     return out
 
 

package/app/core/skills.py

@@ -295,7 +295,11 @@ def list_lessons(scope=None, only_enabled=False, category=None):
                  if (x.get("category") or LESSON_UNCATEGORIZED) == category]
     if only_enabled:
         items = [x for x in items if x.get("enabled", True)]
-    items.sort(key=lambda x: (-int(x.get("hits") or 0), -int(x.get("seen") or 1),
+    # karma 感知排序（UI 列表用；注入排序在 relevance_top 不走这里）：
+    # 有效教训（won-lost 高）排最前——经验库页首屏即「真实帮上忙的」，
+    # 其次按注入热度；失守多的自然沉底（不隐藏——降权不删除）。
+    items.sort(key=lambda x: (-(int(x.get("won") or 0) - int(x.get("lost") or 0)),
+                              -int(x.get("hits") or 0), -int(x.get("seen") or 1),
                               x.get("created_at") or ""))
     return items
 

package/app/core/store.py

@@ -135,6 +135,11 @@ def create_task(payload):
         task["direct_model"] = _text(payload.get("direct_model"), "direct_model")[:160]
         if task["direct_model"] and not task["direct_provider_id"]:
             raise ValueError("指定对话模型时必须同时指定厂商")
+        # 手动指定执行 CLI（2026-09-23）：优先级高于模型绑定——运行时走该 CLI
+        # 的会话链而非内置智能体。存 id（如 codex-cli），可用性在运行时校验
+        da = _text(payload.get("direct_agent"), "direct_agent")[:80]
+        if da:
+            task["direct_agent"] = da
     # 代码版本：仅当引用合法才固化（流水线执行前据此检出任务分支）
     from . import gitmod
     git_rev = _text(payload.get("git_rev"), "git_rev")
@@ -218,6 +223,15 @@ def create_task(payload):
                     v = 1
                 if v > 1:
                     s["variants"] = v
+                # 多线剧情推演（inkos 借鉴 2026-09-23）：2-3 = 写章前生成
+                # N 条分支节拍计划择优注入（计划级赛马，省 prose 级开销）；
+                # 越界钳到 3（与 variants 同口径：上限仍可用，1=不启用不落键）
+                try:
+                    br = max(1, min(3, int(serial.get("branches") or 1)))
+                except Exception:
+                    br = 1
+                if br > 1:
+                    s["branches"] = br
                 # 分卷：显式卷表优先（新建任务时用户明确给出的分卷信息），
                 # 其次每卷章数等长切卷。卷边界一律由 volumes 模块从「章号」
                 # 确定性推导——续写批次沿用同一份卷表/每卷章数即自动接上同一卷，
@@ -1511,6 +1525,12 @@ def update_task_params(task_id, patch):
                 task["direct_provider_id"] = pv
                 task["direct_model"] = mv
                 changed = True
+            # 执行 CLI 可改/可清（清空 = 回内置智能体或模型绑定）；与模型绑定
+            # 允许共存，运行时 CLI 优先
+            av = str((patch or {}).get("direct_agent") or "").strip()[:80]
+            if task.get("direct_agent") != av and (av or task.get("direct_agent")):
+                task["direct_agent"] = av
+                changed = True
         if changed:
             _save_json(paths.TASKS_DIR / (task_id + ".json"), task)
             bump_state()

package/app/ui/app.js

@@ -105,28 +105,59 @@ window.syncCmpSelFace = syncCmpSelFace;   // applyI18n 重译 option 后同步
  * 菜单只改它们的值——既有提交流 / onTypeChange 显隐 / 测试全兼容。 */
 let cmpModelProv = "";   // ""=厂商级；否则=已钻入的厂商 id（模型级）
 
+/* 可指定为对话执行者的真实 CLI（手动指定 CLI，2026-09-23）：
+ * state.agents 即 effective_agents（已装+启用编排），mode=real 排掉 mock */
+function realCliAgents() {
+  return ((S.state && S.state.agents) || []).filter((a) => a && a.mode === "real");
+}
+
+function cmpDirectAgentVal() {
+  const el = $("f-direct-agent");
+  return el ? String(el.value || "").trim() : "";
+}
+
 function cmpDirectBtnSync() {
   const btn = $("f-direct-btn");
   if (!btn) return;
+  const av = cmpDirectAgentVal();
+  if (av) {
+    const a = realCliAgents().find((x) => x.id === av);
+    btn.textContent = (a ? (a.label || a.id) : av) + " · CLI";
+    return;
+  }
   const pv = $("f-direct-provider").value, mv = $("f-direct-model-name").value;
   if (!pv) { btn.textContent = t("自动推荐"); return; }
   const p = directProviders().find((x) => x.id === pv);
   btn.textContent = (p ? (p.name || p.id) : pv) + (mv ? "/" + mv : "/" + t("推荐"));
 }
 
+/* 菜单里「指定 CLI」分组（两级菜单复用同一段，差别只在真源变量）：
+ * entriesHtml(选中id, 空文案) 返回分组 HTML；空列表返回 "" */
+function cliMenuSectionHtml(selectedId) {
+  const clis = realCliAgents();
+  if (!clis.length) return "";
+  const chk = '<svg class="ico ti-check" aria-hidden="true"><use href="#i-check"></use></svg>';
+  return '<div class="type-menu-cap">' + t("指定 CLI") + "</div>" +
+    clis.map((a) =>
+      '<button type="button" class="type-item" data-cli="' + esc(a.id) + '"><span class="ti-body"><span class="ti-name">' +
+      esc(a.label || a.id) + "</span></span>" + (selectedId === a.id ? chk : "") + "</button>").join("");
+}
+
 function cmpModelMenuRender() {
   const menu = $("cmp-model-menu");
   if (!menu) return;
   const pv = $("f-direct-provider").value, mv = $("f-direct-model-name").value;
+  const av = cmpDirectAgentVal();
   const chk = '<svg class="ico ti-check" aria-hidden="true"><use href="#i-check"></use></svg>';
   const arr = '<svg class="ico ti-check" aria-hidden="true"><use href="#i-chevron-r"></use></svg>';
   if (!cmpModelProv) {
     menu.innerHTML =
       '<button type="button" class="type-item" data-p="" data-m=""><span class="ti-body"><span class="ti-name">' +
-        t("自动推荐") + "</span></span>" + (!pv ? chk : "") + "</button>" +
+        t("自动推荐") + "</span></span>" + (!pv && !av ? chk : "") + "</button>" +
       directProviders().map((p) =>
         '<button type="button" class="type-item" data-p="' + esc(p.id) + '"><span class="ti-body"><span class="ti-name">' +
-        esc(p.name || p.id) + "</span></span>" + (pv === p.id ? chk : arr) + "</button>").join("") +
+        esc(p.name || p.id) + "</span></span>" + (pv === p.id && !av ? chk : arr) + "</button>").join("") +
+      cliMenuSectionHtml(av) +
       '<div class="type-menu-foot"><button type="button" class="type-item" data-manage="1"><span class="ti-body"><span class="ti-name">' +
         t("管理模型…") + "</span></span></button></div>";
   } else {
@@ -162,10 +193,17 @@ window.toggleModelMenu = toggleModelMenu;
     // innerHTML 重写后 e.target 是已脱离 DOM 的旧节点，wrap.contains 会误判
     // false 而把刚钻取的菜单收掉（真机「点厂商没反应」根因）
     e.stopPropagation();
-    const b = e.target.closest("[data-p],[data-back],[data-manage]");
+    const b = e.target.closest("[data-p],[data-back],[data-manage],[data-cli]");
     if (!b) return;
     if (b.dataset.manage) { toggleModelMenu(false); switchTab("models"); return; }
     if (b.dataset.back) { cmpModelProv = ""; cmpModelMenuRender(); return; }
+    if (b.dataset.cli !== undefined) {
+      // 手动指定执行 CLI：写真源即可，模型绑定保留在任务上（运行时 CLI 优先）
+      $("f-direct-agent").value = b.dataset.cli;
+      cmpDirectBtnSync();
+      toggleModelMenu(false);
+      return;
+    }
     if (b.dataset.m === undefined) {
       // 点厂商 = 只钻取到模型级（用户拍板 2026-09-21：模型必须亲手点，
       // 不要自动带推荐）。真源不动——用户点了具体模型才写 provider/model。
@@ -175,7 +213,9 @@ window.toggleModelMenu = toggleModelMenu;
     }
     // 选定：写回隐藏 select 真源（提交流/回归测试全走原路径）。顺序关键：
     // 先让 provider 的 option 就位再赋值，否则 select.value 静默失效（真机
-    // 「没法选模型」根因：options 由 poll 重建，可能仍是残缺态）
+    // 「没法选模型」根因：options 由 poll 重建，可能仍是残缺态）。
+    // 选定模型/自动推荐同时清除 CLI 指定（三者互斥，模型生效=走内置智能体）
+    $("f-direct-agent").value = "";
     renderDirectModelPicker();
     $("f-direct-provider").value = b.dataset.p;
     renderDirectModelPicker();
@@ -2466,9 +2506,11 @@ async function createTask() {
   if (_eng === "code") {
     payload.verify_command = $("f-verify").value.trim();
   } else if (_eng === "direct") {
-    // 直连：目标+附件即全部输入，不带验证/评审参数
+    // 直连：目标+附件即全部输入，不带验证/评审参数；direct_agent 为空时走
+    // 内置智能体/模型绑定（后端按空串处理）
     payload.direct_provider_id = $("f-direct-provider").value;
     payload.direct_model = $("f-direct-model-name").value;
+    payload.direct_agent = cmpDirectAgentVal();
   } else {
     payload.manuscript = $("f-manuscript").value.trim() || "manuscript.md";
     payload.rounds = parseInt($("f-rounds").value, 10) || 2;
@@ -3153,6 +3195,8 @@ function newFromTask(id) {
     $("f-direct-provider").value = tk.direct_provider_id || "";
     renderDirectModelPicker();
     $("f-direct-model-name").value = tk.direct_model || "";
+    $("f-direct-agent").value = tk.direct_agent || "";
+    cmpDirectBtnSync();
   } else {
     $("f-manuscript").value = tk.manuscript || "manuscript.md";
     $("f-rounds").value = tk.rounds || 2;
@@ -7318,6 +7362,7 @@ function renderDetailOverview(run, runs, task) {
  * 回填自当前任务；改动即写任务（空闲态），发送 /chat 前再兜底同步一次。 */
 let rdPrefsTaskId = "";
 let rdModelPv = "", rdModelMv = "";   // 对话条当前模型选择（厂商 id + 模型名）
+let rdModelAgent = "";                // 手动指定的执行 CLI（空 = 不指定）
 
 function rdPrefsFill(task) {
   if (!task) return;
@@ -7328,6 +7373,7 @@ function rdPrefsFill(task) {
     rdPrefsTaskId = task.id;
     rdModelPv = task.direct_provider_id || "";
     rdModelMv = task.direct_model || "";
+    rdModelAgent = task.direct_agent || "";
   }
   ["rd-mode", "rd-thinking"].forEach((id) => syncCmpSelFace(id));
   rdModelFaceSync();
@@ -7336,6 +7382,11 @@ function rdPrefsFill(task) {
 function rdModelFaceSync() {
   const face = $("rd-model-btn");
   if (!face) return;
+  if (rdModelAgent) {
+    const a = realCliAgents().find((x) => x.id === rdModelAgent);
+    face.textContent = (a ? (a.label || a.id) : rdModelAgent) + " · CLI";
+    return;
+  }
   if (!rdModelPv) { face.textContent = t("自动推荐"); return; }
   const p = directProviders().find((x) => x.id === rdModelPv);
   face.textContent = (p ? (p.name || p.id) : rdModelPv) +
@@ -7353,10 +7404,11 @@ function rdModelMenuRender() {
   if (!rdMenuProv) {
     menu.innerHTML =
       '<button type="button" class="type-item" data-p="" data-m=""><span class="ti-body"><span class="ti-name">' +
-        t("自动推荐") + "</span></span>" + (!rdModelPv ? chk : "") + "</button>" +
+        t("自动推荐") + "</span></span>" + (!rdModelPv && !rdModelAgent ? chk : "") + "</button>" +
       directProviders().map((p) =>
         '<button type="button" class="type-item" data-p="' + esc(p.id) + '"><span class="ti-body"><span class="ti-name">' +
-        esc(p.name || p.id) + "</span></span>" + (rdModelPv === p.id ? chk : arr) + "</button>").join("") +
+        esc(p.name || p.id) + "</span></span>" + (rdModelPv === p.id && !rdModelAgent ? chk : arr) + "</button>").join("") +
+      cliMenuSectionHtml(rdModelAgent) +
       '<div class="type-menu-foot"><button type="button" class="type-item" data-manage="1"><span class="ti-body"><span class="ti-name">' +
         t("管理模型…") + "</span></span></button></div>";
   } else {
@@ -7389,13 +7441,21 @@ window.toggleRdModelMenu = toggleRdModelMenu;
   menu.dataset.rdBound = "1";
   menu.addEventListener("click", (e) => {
     e.stopPropagation();   // 同 cmp-model-menu：防「点外面收起」误判（DOM 重写竞态）
-    const b = e.target.closest("[data-p],[data-back],[data-manage]");
+    const b = e.target.closest("[data-p],[data-back],[data-manage],[data-cli]");
     if (!b) return;
     if (b.dataset.manage) { toggleRdModelMenu(false); switchTab("models"); return; }
     if (b.dataset.back) { rdMenuProv = ""; rdModelMenuRender(); return; }
+    if (b.dataset.cli !== undefined) {
+      rdModelAgent = b.dataset.cli;
+      rdModelFaceSync();
+      toggleRdModelMenu(false);
+      rdPrefsPush("model");
+      return;
+    }
     if (b.dataset.m === undefined) { rdMenuProv = b.dataset.p; rdModelMenuRender(); return; }
     rdModelPv = b.dataset.p;
     rdModelMv = b.dataset.m;
+    rdModelAgent = "";   // 选定模型/自动推荐：CLI 指定随之清除（互斥）
     rdModelFaceSync();
     toggleRdModelMenu(false);
     rdPrefsPush("model");
@@ -7420,6 +7480,7 @@ async function rdPrefsPush(what) {
   if (what === "model") {
     patch.direct_provider_id = rdModelPv;
     patch.direct_model = rdModelMv;
+    patch.direct_agent = rdModelAgent;
   }
   try {
     await api("/api/tasks/" + encodeURIComponent(task.id) + "/params", {
@@ -8884,6 +8945,8 @@ function renderSkills() {
     '<span class="tag">' + esc(x.scope === "*" ? t("通用") : x.scope) + "</span>" +
     (x.seen > 1 ? '<span class="tag">' + t("出现 ") + x.seen + t(" 次") + "</span>" : "") +
     (x.hits ? '<span class="tag">' + t("已注入 ") + x.hits + t(" 次") + "</span>" : "") +
+    (x.won > 0 ? '<span class="tag ok" title="' + t("注入后任务过审的次数（真实帮上忙）") + '">' + t("有效 ") + x.won + "</span>" : "") +
+    (x.lost > 0 ? '<span class="tag" style="color:var(--bad)" title="' + t("注入后任务仍失败的次数（没防住）") + '">' + t("失守 ") + x.lost + "</span>" : "") +
     (x.enabled === false ? '<span class="tag">' + t("已停用") + "</span>" : "") + "</div>" +
     '<div class="note">' + esc(t(x.content)) + "</div>" +
     '<div class="ops">' +
@@ -9115,6 +9178,11 @@ function autoPrefTags(tsk) {
   if (tsk.thinking && tsk.thinking !== "standard" && TH[tsk.thinking]) {
     out.push(t("思考程度") + t("：") + t(TH[tsk.thinking]));
   }
+  if (tsk.direct_agent) {
+    const a = realCliAgents().find((x) => x.id === tsk.direct_agent) ||
+      ((S.state && S.state.agents) || []).find((x) => x.id === tsk.direct_agent);
+    out.push(t("执行 CLI") + t("：") + (a ? (a.label || a.id) : tsk.direct_agent));
+  }
   if (tsk.direct_provider_id) {
     const p = directProviders().find((x) => x.id === tsk.direct_provider_id);
     out.push(t("对话模型") + t("：") + (p ? (p.name || p.id) : tsk.direct_provider_id) +

package/app/ui/i18n.js

@@ -42,6 +42,9 @@
     "对话厂商": "Chat provider",
     "对话模型": "Chat model",
     "随厂商推荐": "Provider default",
+    "指定 CLI": "Run via CLI",
+    "执行 CLI": "Agent CLI",
+    "执行 CLI：": "Agent CLI: ",
     "只对本次对话生效，不会修改全局绑定；指定渠道不可用时会明确报错。": "Applies only to this chat and does not change global bindings. An unavailable selected route returns an explicit error.",
     "推荐任务类型": "Recommended task type",
     "切换类型": "Switch type",
@@ -869,6 +872,10 @@
     "自定义 CLI": "Custom CLI",
     "已归档": "Archived",
     "已停用": "Disabled",
+    "有效 ": "Helped ",
+    "失守 ": "Missed ",
+    "注入后任务过审的次数（真实帮上忙）": "Times tasks passed review with this lesson injected (actually helped)",
+    "注入后任务仍失败的次数（没防住）": "Times tasks still failed with this lesson injected (didn't prevent it)",
     "正在刷新模型列表…": "Refreshing model list…",
     "无任务": "No tasks yet",
     "暂无任务": "No tasks yet",

package/app/ui/index.html

@@ -424,7 +424,7 @@
               <div id="f-direct-model" class="field hidden"><label data-i18n="对话模型（可选）">对话模型（可选）</label><div class="grid-2">
                 <select id="f-direct-provider" aria-label="对话厂商" data-i18n-aria="对话厂商"><option data-i18n="自动推荐">自动推荐</option></select>
                 <select id="f-direct-model-name" aria-label="对话模型" data-i18n-aria="对话模型"><option data-i18n="随厂商推荐">随厂商推荐</option></select>
-              </div><p class="hint" data-i18n="只对本次对话生效，不会修改全局绑定；指定渠道不可用时会明确报错。">只对本次对话生效，不会修改全局绑定；指定渠道不可用时会明确报错。</p></div>
+              </div><input type="hidden" id="f-direct-agent" value=""><p class="hint" data-i18n="只对本次对话生效，不会修改全局绑定；指定渠道不可用时会明确报错。">只对本次对话生效，不会修改全局绑定；指定渠道不可用时会明确报错。</p></div>
               <div class="grid-2">
                 <div class="field">
                   <label data-i18n="继续会话">继续会话</label>

package/app/ui/style.css

@@ -6076,3 +6076,13 @@ button.request-busy > * { opacity: .18; }
   display: block; width: 100%; height: min(72vh, 660px);
   border: none; border-radius: 10px; background: #fff;
 }
+
+/* 对话模型菜单里的 CLI 分组标题（2026-09-23 手动指定 CLI）：与底部
+ * 「管理模型…」同款弱化字重，但不可点，仅作分组界碑。 */
+.type-menu-cap {
+  padding: 7px 14px 3px;
+  font-size: 11px; font-weight: 600; letter-spacing: .04em;
+  color: var(--muted);
+  border-top: 1px solid var(--line, rgba(127,127,127,.18));
+  margin-top: 4px;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebee",
-  "version": "0.1.51",
+  "version": "0.1.53",
   "description": "CodeBee · 多智能体编排台 — 统一编排本机 AI 编码 CLI（Codex / Claude Code / QwenCode / OpenCode / Aider…）：目标→拆解→路由→执行→验证→跨厂商评审→修复→报告。纯 Python 标准库实现，本地 Web UI。",
   "license": "MIT",
   "bin": {