codebee 0.1.20 → 0.1.22

package/app/core/pipeline.py

@@ -19,7 +19,7 @@ import re
 import threading
 import time
 
-from . import aiflavor, catalog, history, jobs, knowledge, manager, modelhub, mocks, paihang, planner, registry, router, runner, skills, store, usage
+from . import aiflavor, catalog, history, jobs, knowledge, manager, modelhub, mocks, paihang, planner, registry, router, runner, skills, store, task_compile, usage
 from . import builtin_agent
 from . import diagnostics
 from . import paths as paths_mod
@@ -321,7 +321,7 @@ def _binding_dead_msg(agent):
         return modelhub.binding_dead_msg(agent.get("id") or "")
     except Exception:
         return ("绑定链全部失效，本步判失败、不回落 CLI 本机默认——"
-                "请在「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):
@@ -907,12 +907,18 @@ def _run_code(run, task, agents, ev, stats, mode):
     else:
         impl, route["implementer"] = router.pick(agents, "implement", "code", stats)
     if impl is None:
-        store.update_run(run_id, status="failed", error="没有可用智能体", ended_at=_now())
+        store.update_run(run_id, expected_status="running", status="failed",
+                         error="没有可用智能体", ended_at=_now())
         return
 
     # ---- 规划
     if mode == "auto":
         _wait_gate(run_id, ev)
+        # 项目记忆注入（借鉴 agentmemory 持久记忆）：同工作目录此前代码任务留下的
+        # 架构事实，让规划器不再对代码库一无所知
+        _pm = _read_project_memory(workdir)
+        if _pm:
+            task = dict(task, context=((task.get("context") or "") + "\n\n" + _pm)[:8000])
         plan_step, plan_log = store.add_step(run_id, "plan", impl["id"], impl.get("label"),
                                              note=route.get("implementer", ""))
         plan = planner.make_code_plan(_steered_task(run_id, task),
@@ -961,8 +967,13 @@ def _run_code(run, task, agents, ev, stats, mode):
                     register_default_namespaces()
                     if ss_get("cascade", "enabled"):
                         from . import capability
+                        mh_data = modelhub._load()
                         agt_b = capability.cascade_reorder(
-                            agt_b, capability.make_tier_lookup(modelhub.providers()))
+                            agt_b, capability.make_tier_lookup(modelhub.providers()),
+                            providers=modelhub.providers(),
+                            pricing=mh_data.get("pricing") or {},
+                            difficulty=difficulty, task_type=task.get("type") or "code",
+                            role="implement")
                 except Exception:
                     pass
             for i, sub in enumerate(subtasks):
@@ -1033,7 +1044,8 @@ def _run_code(run, task, agents, ev, stats, mode):
                 res_err = "实现步骤失败（无其他真实 CLI 可换将）: %s" % res.get("error")
         else:
             res_err = "实现步骤失败: %s" % res.get("error")
-        store.update_run(run_id, status="failed", error=res_err, ended_at=_now())
+        store.update_run(run_id, expected_status="running", status="failed",
+                         error=res_err, ended_at=_now())
         return False
 
     def review_and_score():
@@ -1129,7 +1141,21 @@ def _run_code(run, task, agents, ev, stats, mode):
     lines += ["", "## 评审总评", "", review_json.get("summary", ""), ""]
     store.write_report(run_id, "\n".join(lines))
     _write_task_evidence(run_id, task, workdir, _evidence_lines_from_run(run_id, task))
-    store.update_run(run_id, status="done", verdict=verdict,
+    # 项目记忆沉淀（借鉴 agentmemory 持久记忆）：代码任务成功后提取架构事实
+    # （改动文件/验收结果/修复轮数），追加到 .codebee/project-memory.md——
+    # 同目录后续 code 任务规划前自动注入，让编排者「知道这个代码库的脾气」
+    try:
+        _diff = _git_diff(workdir)
+        _files_touched = sorted(set(re.findall(
+            r"(?:^|\n)diff --git a/(\S+) b/(\S+)", _diff or "")))
+        _touched_str = "、".join(sorted(set(b for _, b in _files_touched)))[:500] if _files_touched else ""
+        _mem_lines = ["改动文件：%s" % (_touched_str or "（无 diff）"),
+                      "验收：%s" % ("通过" if verify_pass else "未通过"),
+                      "修复轮数：%d" % (len(repairs) - 1)]
+        _write_project_memory(task, workdir, _mem_lines)
+    except Exception:
+        pass
+    store.update_run(run_id, expected_status="running", status="done", verdict=verdict,
                      summary="代码任务%s（验证%s / 评审%s%s）" % (
                          "通过" if overall_pass else "未通过",
                          "通过" if verify_pass else "未通过",
@@ -1297,7 +1323,8 @@ def _run_direct(run, task, agents, ev, stats, mode):
     else:
         impl, route["implementer"] = router.pick(agents, "implement", task["type"], stats)
     if impl is None and bi is None:
-        store.update_run(run_id, status="failed", error="没有可用智能体", ended_at=_now())
+        store.update_run(run_id, expected_status="running", status="failed",
+                         error="没有可用智能体", ended_at=_now())
         return
     difficulty = task.get("difficulty") or "default"
     step_wd = _resume_workdir(resume_ctx, workdir) if resume_ctx else workdir
@@ -1371,7 +1398,7 @@ def _run_direct(run, task, agents, ev, stats, mode):
                             readonly=False, ev=ev, note=note,
                             resume=sid or None, images=images)
         if not res["ok"]:
-            store.update_run(run_id, status="failed",
+            store.update_run(run_id, expected_status="running", status="failed",
                              error="执行失败: %s" % res.get("error"), ended_at=_now())
             return
         turns += 1
@@ -1403,7 +1430,7 @@ def _run_direct(run, task, agents, ev, stats, mode):
         report += ["## 最近一轮输出", "", last_text[-5000:], ""]
     store.write_report(run_id, "\n".join(report))
     _write_task_evidence(run_id, task, workdir, _evidence_lines_from_run(run_id, task))
-    store.update_run(run_id, status="done", verdict=verdict,
+    store.update_run(run_id, expected_status="running", status="done", verdict=verdict,
                      summary="直连完成（%d 轮）：%s" % (turns, last_text[:160]),
                      ended_at=_now())
 
@@ -1886,7 +1913,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
         # 历史遗留：降级/模板大纲被继承时，真实任务宁可中止重生成，也不按空模板写全书
         if (outline.get("degraded") or outline.get("source") == "template") \
                 and impl.get("mode") != "mock":
-            store.update_run(run_id, status="failed",
+            store.update_run(run_id, expected_status="running", status="failed",
                              error="继承的大纲为降级模板（无真实情节），已中止以重新生成大纲",
                              ended_at=_now())
             return
@@ -1909,7 +1936,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
             store.finish_step(run_id, outline_step["n"], "failed",
                               summary="大纲降级：%s" % (outline.get("degraded_reason") or "编排者不可用"),
                               duration_s=None)
-            store.update_run(run_id, status="failed",
+            store.update_run(run_id, expected_status="running", status="failed",
                              error="%s，已中止以免按空模板写全书"
                                    % (outline.get("degraded_reason") or "编排者不可用"),
                              ended_at=_now())
@@ -2178,7 +2205,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                     time.sleep(3)   # 落盘竞态宽限：CLI 崩溃退出前写的文件可能晚于
                     good, txt = _chapter_state()   # 退出检查零点几秒才可见（c34 实测）
                 if not good:
-                    store.update_run(run_id, status="failed",
+                    store.update_run(run_id, expected_status="running", status="failed",
                                      error="第 %d 章起草失败: %s" % (i, (res or {}).get("error")), ended_at=_now())
                     return
                 if not res["ok"]:
@@ -2262,7 +2289,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                     if scored_variants:
                         break
                 if not scored_variants:
-                    store.update_run(run_id, status="failed",
+                    store.update_run(run_id, expected_status="running", status="failed",
                                      error="第 %d 章赛马全部变体起草失败" % i, ended_at=_now())
                     return
                 scored_variants.sort(key=lambda v: (-v["avg"], v["variant"]))
@@ -2273,7 +2300,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
                         os.replace(os.path.join(workdir, win["file"]),
                                    os.path.join(workdir, ch_file))
                     except OSError as e:
-                        store.update_run(run_id, status="failed",
+                        store.update_run(run_id, expected_status="running", status="failed",
                                          error="第 %d 章赛马收卷失败: %r" % (i, e), ended_at=_now())
                         return
                 for v in scored_variants[1:]:
@@ -2321,7 +2348,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
             if not scored:
                 # 「评不上」≠「评了 0 分」：全部评审失败时中止本轮，
                 # 让自动续跑换个时机重试，而不是以 0 分误判章稿质量。
-                store.update_run(run_id, status="failed",
+                store.update_run(run_id, expected_status="running", status="failed",
                                  error="第 %d 章评审全部失败（评审模型不可用或输出不可解析），"
                                        "已中止以免以 0 分误判质量" % i, ended_at=_now())
                 return
@@ -2452,7 +2479,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
             if gscored:
                 break
         if not gscored:
-            store.update_run(run_id, status="failed",
+            store.update_run(run_id, expected_status="running", status="failed",
                              error="全局一致性评审全部失败（评审模型不可用或输出不可解析），"
                                    "已中止以免把「无法评审」误判为「未达标」。"
                                    "各章稿件已全部落盘，修复评审链后续跑可直接收尾",
@@ -2621,7 +2648,7 @@ def _run_serial_review(run, task, agents, ev, stats, mode, critics, impl, route,
         lines.append("（无 major 问题）")
     store.write_report(run_id, "\n".join(lines))
     _write_task_evidence(run_id, task, workdir, _evidence_lines_from_run(run_id, task))
-    store.update_run(run_id, status="done", verdict=verdict,
+    store.update_run(run_id, expected_status="running", status="done", verdict=verdict,
                      summary="连载任务%s（%s，约 %d 字，综合 %.1f）" % (
                          "达标" if publishable else "未达标", scope_txt,
                          total_words, overall),
@@ -2768,7 +2795,8 @@ def _run_content_review(run, task, agents, ev, stats, mode):
         impl, route["author"] = router.pick(agents, "implement", task_type, stats)
         critics, route["critics"] = router.pick_critics(agents, task_type, stats, impl=impl)
     if impl is None:
-        store.update_run(run_id, status="failed", error="没有可用智能体", ended_at=_now())
+        store.update_run(run_id, expected_status="running", status="failed",
+                         error="没有可用智能体", ended_at=_now())
         return
     if resume_ctx is not None and mode == "auto":
         critics, route["critics"] = router.pick_critics(
@@ -2847,7 +2875,8 @@ def _run_content_review(run, task, agents, ev, stats, mode):
                                   resume=resume_ctx["session"] if resume_ctx else None,
                                   images=_task_images(task, workdir))
         if not draft_res["ok"]:
-            store.update_run(run_id, status="failed", error="起草失败: %s" % draft_res.get("error"),
+            store.update_run(run_id, expected_status="running", status="failed",
+                             error="起草失败: %s" % draft_res.get("error"),
                              ended_at=_now())
             return
 
@@ -2979,7 +3008,7 @@ def _run_content_review(run, task, agents, ev, stats, mode):
     lines += ["", "## 稿件位置", "", "`%s`" % ms_path, ""]
     store.write_report(run_id, "\n".join(lines))
     _write_task_evidence(run_id, task, workdir, _evidence_lines_from_run(run_id, task))
-    store.update_run(run_id, status="done", verdict=verdict,
+    store.update_run(run_id, expected_status="running", status="done", verdict=verdict,
                      summary="评审任务%s（综合 %.1f）" % ("达标" if publishable else "未达标", overall),
                      ended_at=_now())
 
@@ -3024,13 +3053,13 @@ def _run_serial_qa(run, task, agents, ev):
         res = _run_step(run_id, "qa", modelhub.bind_agent(agent, "default"),
                         prompt, workdir, readonly=True, ev=ev, timeout=1200)
         if res.get("ok") and (res.get("text") or "").strip():
-            store.update_run(run_id, status="done", ended_at=_now(),
+            store.update_run(run_id, expected_status="running", status="done", ended_at=_now(),
                              verdict={"qa": True,
                                       "answered_by": agent.get("id")})
             return
         errors.append("%s：%s" % (agent.get("id"),
                                   (res.get("error") or "无输出")[:120]))
-    store.update_run(run_id, status="failed", ended_at=_now(),
+    store.update_run(run_id, expected_status="running", status="failed", ended_at=_now(),
                      error="答疑失败（执行/评审链不可用）——" + "；".join(errors[-3:]))
 
 
@@ -3051,6 +3080,43 @@ def _read_constitution(workdir):
             "与其他要求冲突时以宪章为准）\n\n" + txt + "\n\n")
 
 
+def _write_project_memory(task, workdir, lines):
+    """项目记忆持久化（借鉴 agentmemory）：代码任务成功后把架构事实追加到
+    .codebee/project-memory.md——同目录后续 code 任务规划前自动注入，
+    让编排者「知道这个代码库的脾气」而非每次从零摸索。失败静默。"""
+    if not lines:
+        return ""
+    try:
+        pm = os.path.join(workdir, ".codebee", "project-memory.md")
+        os.makedirs(os.path.dirname(pm), exist_ok=True)
+        header_needed = not os.path.isfile(pm)
+        with open(pm, "a", encoding="utf-8") as f:
+            if header_needed:
+                f.write("# 项目记忆（每次代码任务完成后自动追加，供后续任务参考）\n\n")
+            f.write("### %s · %s\n" % (task.get("title") or "", _now()))
+            for ln in lines:
+                f.write("- %s\n" % str(ln)[:300])
+            f.write("\n")
+        return pm
+    except Exception:
+        return ""
+
+
+def _read_project_memory(workdir, cap=4000):
+    """读取项目记忆供规划提示词注入。超出上限截断到最新条目。"""
+    p = os.path.join(workdir or "", ".codebee", "project-memory.md")
+    if not _inside(workdir, p) or not os.path.isfile(p):
+        return ""
+    try:
+        txt = _read_text_any_enc(p)[:cap].strip()
+    except OSError:
+        return ""
+    if not txt:
+        return ""
+    return ("## 项目记忆（此前代码任务在此工作目录留下的架构事实，"
+            "规划时优先参考）\n\n" + txt + "\n\n")
+
+
 def _write_task_spec(task, workdir):
     """任务规格落盘 .codebee/spec.md（借鉴 agent-orchestrator 的 .spec/PROMPT.md 与
     planning-with-files 的文件化计划）：任务定义随工作目录留存、随任务分支版本化，
@@ -3201,11 +3267,26 @@ def execute_run(run_id):
                          error="排队期间被取消")
         return
     task = store.get_task(run.get("task_id"))
-    store.update_run(run_id, status="running", started_at=_now())
+    # 生产 enqueue 已完成 queued→running 认领；测试/兼容调用也可能直接从
+    # queued 进入。按初读状态做 CAS 起跑确认：取消若恰好落在读取之后，当前
+    # 状态已是 cancelled，写入会失败并立即退出，不产生 Git/文件副作用。
+    initial_status = run.get("status")
+    if initial_status not in ("queued", "running"):
+        return
+    if store.update_run(run_id, expected_status=initial_status, status="running",
+                        started_at=_now()) is None:
+        return
     if task is None:
-        store.update_run(run_id, status="failed", error="找不到任务 %s" % run.get("task_id"),
-                         ended_at=_now())
+        store.update_run(run_id, expected_status="running", status="failed",
+                         error="找不到任务 %s" % run.get("task_id"), ended_at=_now())
         return
+    # 统一任务编译：旧字段继续供各引擎读取，规格作为运行级诊断与调度输入落盘。
+    task_spec = task_compile.compile_task(task)
+    store.update_run(run_id, task_spec=task_spec,
+                     task_spec_summary=task_compile.summary(task_spec),
+                     difficulty=task_spec["difficulty"])
+    task = dict(task)
+    task["_compiled_spec"] = task_spec
     # 代码版本检出：任务指定了基线版本时，先检出任务分支 tutti/<task-id> 再跑流水线。
     # 显式意图不容静默降级——仓库缺失/脏工作区/引用不存在一律中止运行并报错，
     # 绝不带着用户未提交改动切分支、也不悄悄退回当前 HEAD。
@@ -3215,8 +3296,8 @@ def execute_run(run_id):
         ok, err, gitinfo = gitmod.prepare_checkout(
             task["workdir"], task["git_rev"], task["id"])
         if not ok:
-            store.update_run(run_id, status="failed", error="代码版本检出失败：%s" % err,
-                             ended_at=_now())
+            store.update_run(run_id, expected_status="running", status="failed",
+                             error="代码版本检出失败：%s" % err, ended_at=_now())
             return
         git_ctx = gitinfo
         store.update_run(run_id, git=gitinfo)
@@ -3240,6 +3321,16 @@ def execute_run(run_id):
         if extra:
             agents.append(extra)
     stats = history.agent_stats()
+    # 运行级任务画像：所有后续 bind_agent 调用共享同一预置类型，
+    # 模型级联因此覆盖 direct/code/review/serial/translation 等全部引擎。
+    for _agent in agents:
+        if isinstance(_agent, dict):
+            _agent["_dispatch_task_type"] = task.get("type") or "direct"
+    store.update_run(run_id, route_plan={
+        "task": task_spec,
+        "implement": router.route_plan(agents, "implement", task_spec, stats),
+        "review": router.route_plan(agents, "review", task_spec, stats),
+    })
     mode = task.get("mode") or ("manual" if task.get("implementer") else "auto")
     store.update_run(run_id, mode=mode)
     # engine 决定流水线：code=实现/验证/评审/修复；review=起草/多维评审/修订/门禁；
@@ -3272,7 +3363,8 @@ def execute_run(run_id):
                 impl, route["author"] = router.pick(agents, "implement", task["type"], stats)
                 critics, route["critics"] = router.pick_critics(agents, task["type"], stats, impl=impl)
             if impl is None:
-                store.update_run(run_id, status="failed", error="没有可用智能体", ended_at=_now())
+                store.update_run(run_id, expected_status="running", status="failed",
+                                 error="没有可用智能体", ended_at=_now())
                 return
             if resume_ctx is not None and mode == "auto":
                 critics, route["critics"] = router.pick_critics(agents, task["type"], stats, impl=impl)
@@ -3282,11 +3374,12 @@ def execute_run(run_id):
             else:
                 _run_content_review(run, task, agents, ev, stats, mode)
     except Cancelled:
-        store.update_run(run_id, status="cancelled", ended_at=_now())
+        store.update_run(run_id, expected_status="running",
+                         status="cancelled", ended_at=_now())
     except Exception as e:
         import traceback
-        store.update_run(run_id, status="failed", error=repr(e)[:500],
-                         ended_at=_now())
+        store.update_run(run_id, expected_status="running", status="failed",
+                         error=repr(e)[:500], ended_at=_now())
         try:
             err_path = store.run_dir(run_id) / "error.log"
             if _inside(str(store.run_dir(run_id).parent), str(err_path)):

package/app/core/router.py

@@ -2,7 +2,7 @@
 """智能路由：能力基线 × 历史胜率 × 角色约束 → 选智能体，并给出可解释的理由。"""
 from __future__ import annotations
 
-from . import history
+from . import dispatch, history
 
 # 各类智能体的能力基线（0-100）。真实 CLI 里官方双雄最高。
 CAPABILITY = {
@@ -10,18 +10,29 @@ CAPABILITY = {
     "aider": 70, "openclaw": 60, "generic": 55, "mock": 10,
 }
 
-MAX_REPAIR_ROUNDS = 2  # 自动修复循环上限
+MAX_REPAIR_ROUNDS = 2  # 自动修复循环上限
+
+
+def _task_type(ttype):
+    """兼容旧调用的字符串与新任务规格对象。"""
+    if isinstance(ttype, dict):
+        return str(ttype.get("type") or ttype.get("dimension") or "direct")
+    return str(ttype or "direct")
 
 
-def _binding_bonus(agent_id):
+def _binding_bonus(agent_id, dispatch_mode=False):
     """绑定链可用性加分/减分：链上有可用条目 +8，解析为空 -25。2026-09-16 实测：
     静态能力基线让配额烧干的 codex 永远压过健康备用 CLI，绑定空的 CLI 更是连
     用户配置的模型都没用上——先按「能不能按配置跑起来」校准。2026-09-17 起
     空链步骤在 pipeline 直接判失败（不再静默回落本机默认），此处只管排序。"""
     try:
         from . import modelhub
-        b = modelhub.resolve_binding(agent_id)
-        return 8.0 if (b and b.get("call_chain")) else -25.0
+        pref = modelhub._binding_for(agent_id)
+        configured = bool(modelhub._binding_chain(pref) or pref.get("provider_id"))
+        if not configured:
+            return 0.0 if dispatch_mode else -25.0
+        b = modelhub.resolve_binding(agent_id)
+        return 8.0 if (b and b.get("call_chain")) else -25.0
     except Exception:
         return 0.0
 
@@ -39,20 +50,27 @@ def _history_bonus(stats, agent_id, ttype):
     return round(18.0 * win_rate + min(6.0, runs) - loss_penalty, 1)
 
 
-def score(agent, role, ttype, stats=None):
+def score(agent, role, ttype, stats=None):
     """返回 (总分, 理由字符串)。配额惩罚：catalog 里配了
     quota_tokens_per_hour 的智能体，本小时用量越接近配额分越低
     （封顶 -45，足以盖过历史加分），满额后仅在没有其他选择时才会被选中。"""
-    stats = stats or {}
+    stats = stats or {}
+    ttype = _task_type(ttype)
     base = CAPABILITY.get(agent.get("kind"), 60)
-    bb = _binding_bonus(agent.get("id"))
+    use_dispatch = bool(agent.get("_dispatch_task_type") or
+                        agent.get("dispatch_enabled"))
+    bb = _binding_bonus(agent.get("id"), dispatch_mode=use_dispatch)
     btxt = ""
     if bb > 0:
         btxt = "，绑定链可用（+%s）" % bb
     elif bb < 0:
         btxt = "，绑定链为空：相关步骤将判失败（%s）" % bb
     hb = _history_bonus(stats, agent.get("id"), ttype)
-    total = base + bb + hb
+    # 保持公开 score() 的历史绝对分值；运行级候选由 pipeline 标记画像后
+    # 才启用能力亲和度，避免旧插件/测试调用被新权重悄然改变。
+    affinity, affinity_txt = (dispatch.agent_affinity(agent.get("kind"), ttype, role)
+                              if use_dispatch else (0.0, "兼容模式"))
+    total = base + bb + hb + affinity
     hs = (stats.get(agent.get("id")) or {}).get(ttype)
     htxt = ("，历史 %d/%d 胜（%s）" % (hs["wins"], hs["runs"], "%+.1f" % hb)) if hs else "，无历史记录"
     quota_txt = ""
@@ -69,10 +87,11 @@ def score(agent, role, ttype, stats=None):
             if penalty:
                 total += penalty
                 quota_txt = "，本小时 %d/%d tokens（%s）" % (used, quota, penalty)
-    return total, "能力基线 %d%s%s%s，总分 %s" % (base, btxt, htxt, quota_txt, round(total, 1))
+    return total, "能力基线 %d，%s%s%s%s，总分 %s" % (
+        base, affinity_txt, btxt, htxt, quota_txt, round(total, 1))
 
 
-def pick(agents, role, ttype, stats=None, exclude=()):
+def pick(agents, role, ttype, stats=None, exclude=()):
     """按分选出最优智能体。返回 (agent, 理由) 或 (None, "")。"""
     stats = stats or history.agent_stats()
     best, best_reason = None, ""
@@ -84,7 +103,33 @@ def pick(agents, role, ttype, stats=None, exclude=()):
             best, best_reason = (total, a), reason
     if best is None:
         return None, ""
-    return best[1], best_reason
+    return best[1], best_reason
+
+
+def route_plan(agents, role, task_spec, stats=None, exclude=()):
+    """生成可审计的候选排序，供运行详情展示和后续 fallback 使用。"""
+    if stats is None:
+        stats = history.agent_stats()
+    real = [a for a in agents or [] if a.get("mode") == "real"]
+    pool = real if real else list(agents or [])
+    rows = []
+    for index, agent in enumerate(pool):
+        if agent.get("id") in exclude:
+            continue
+        candidate = dict(agent)
+        if isinstance(task_spec, dict):
+            candidate["_dispatch_task_type"] = task_spec.get("type") or "direct"
+            candidate["_dispatch_role"] = role
+        total, reason = score(candidate, role, task_spec, stats)
+        rows.append({"agent_id": agent.get("id") or "",
+                     "label": agent.get("label") or agent.get("id") or "",
+                     "kind": agent.get("kind") or "generic",
+                     "score": round(total, 1), "reason": reason,
+                     "order": index})
+    rows.sort(key=lambda x: (-x["score"], x["order"]))
+    return {"role": role, "selected": rows[0]["agent_id"] if rows else "",
+            "candidates": rows,
+            "fallback": [x["agent_id"] for x in rows[1:]]}
 
 
 def pick_reviewer(agents, impl, ttype, stats=None):

package/app/core/runner.py

@@ -76,7 +76,8 @@ def _npm_shim_bypass(argv):
             and str(argv[2]).lower().endswith((".cmd", ".bat")):
         shim = argv[2]
         try:
-            text = open(shim, encoding="utf-8", errors="replace").read()
+            with open(shim, encoding="utf-8", errors="replace") as fh:
+                text = fh.read()
         except Exception:
             return argv
         m = re.search(r'%_prog%"\s+"?%dp0%(\\[^"\n]+?\.(?:mjs|js))"?', text)

package/app/core/selfupdate.py

@@ -176,16 +176,15 @@ def apply_upgrade():
     try:
         jobs.enqueue({"kind": "selfupgrade", "run_id": run["id"]})
     except Exception:
-        # The run is already durable when enqueue fails. Close it explicitly so
-        # the upgrade panel cannot remain in a misleading queued state.
-        log.exception("selfupdate: 升级任务入队失败 run=%s", run["id"])
+        # run 已持久化；启动失败时显式收口，版本页不能停在误导性的待启动状态。
+        log.exception("selfupdate: 升级任务启动失败 run=%s", run["id"])
         try:
             store.update_run(run["id"], status="failed",
-                             error="升级任务入队失败，请稍后重试",
+                             error="升级任务启动失败，本次未排队，请稍后重试",
                              ended_at=time.strftime("%Y-%m-%d %H:%M:%S"))
         except Exception:
             log.exception("selfupdate: 升级运行失败收口失败 run=%s", run["id"])
-        return {"error": "升级任务入队失败，请稍后重试", "run_id": run["id"]}
+        return {"error": "升级任务启动失败，本次未排队，请稍后重试", "run_id": run["id"]}
     return {"run_id": run["id"]}
 
 
@@ -210,23 +209,34 @@ def _log_note(log_path, text):
         pass
 
 
-def run_upgrade(run_id, log_path):
+def run_upgrade(run_id, log_path, cancel_event=None):
     """worker 线程里执行升级命令（run/step 生命周期由 jobs 层管）。
 
     包目录被其他进程占用（EBUSY/EPERM：打开包目录的资源管理器/终端窗口、
     杀毒或索引扫描）是升级失败的最常见原因，且多为暂时性——自动重试
     _RETRY_DELAYS 轮，仍败则给人话结论（原始 npm 输出在步骤日志里可查）。"""
-    res = {}
-    for attempt, delay in enumerate((0,) + _RETRY_DELAYS):
-        if delay:
-            _log_note(log_path, "目录被占用（EBUSY/EPERM），%d 秒后自动重试（第 %d/%d 次）"
-                      % (delay, attempt, len(_RETRY_DELAYS)))
-            time.sleep(delay)
-        res = runner.run_process(
+    res = {}
+    for attempt, delay in enumerate((0,) + _RETRY_DELAYS):
+        if cancel_event is not None and cancel_event.is_set():
+            return {"ok": False, "exit_code": None, "error": "用户主动取消",
+                    "cancelled": True}
+        if delay:
+            _log_note(log_path, "目录被占用（EBUSY/EPERM），%d 秒后自动重试（第 %d/%d 次）"
+                      % (delay, attempt, len(_RETRY_DELAYS)))
+            if cancel_event is not None and cancel_event.wait(delay):
+                return {"ok": False, "exit_code": None, "error": "用户主动取消",
+                        "cancelled": True}
+            if cancel_event is None:
+                time.sleep(delay)
+        res = runner.run_process(
             argv=_npm_argv("install", "-g", _PKG_NAME + "@latest"),
             # Windows 上 npm 换版本靠把包目录整体改名（codebee → .codebee-xxx）；
             # cwd 若落在本包内，目录被自身进程占用，rename 必报 EBUSY——钉在包外
-            cwd=str(Path.home()), timeout=900, log_path=log_path)
+            cwd=str(Path.home()), timeout=900, log_path=log_path,
+            cancel_event=cancel_event)
+        if res.get("cancelled"):
+            return {"ok": False, "exit_code": res.get("exit_code"),
+                    "error": "用户主动取消", "cancelled": True}
         if res["ok"] or not _locked_error(res):
             break
     if res["ok"]:

package/app/core/settings.py

@@ -21,7 +21,7 @@ _FILE = paths.DATA_DIR / "settings.json"
 # 运行时出现（空闲 90s 隐身）。
 # cleanup_enabled / cleanup_retention_days：每日垃圾清理（core/cleanup.py）——
 # 运行过程日志/发布截图/bak 残留等超期自动清理；retention 为保留天数。
-DEFAULTS = {"max_concurrent_jobs": 6, "default_workdir": "", "hooks_token": "",
+DEFAULTS = {"max_concurrent_jobs": 12, "default_workdir": "", "hooks_token": "",
             "telemetry_errors": True, "publish_daily_cap": 10,
             "publish_fail_streak": 3, "notify_webhook": "", "notify_base_url": "",
             "pet_enabled": True, "pet_mode": "always", "pet_skin": "plush",
@@ -29,8 +29,8 @@ DEFAULTS = {"max_concurrent_jobs": 6, "default_workdir": "", "hooks_token": "",
 # 桌宠形象白名单（与 app/pet.py 的 SKINS 对齐；这里不 import pet 模块，避免
 # core 反向依赖 app 根目录脚本）
 PET_SKINS = ("plush", "robot")
-# 并发上限 12：worker 只是拉起 CLI 子进程的调度位，跨任务无共享资源；
-# 同任务单飞守卫在 jobs 层。默认 6 对齐「多任务并行不排队」的使用预期。
+# 并发保护上限 12：任务有空位即直接启动，满载明确返回忙，不进入等待队列；
+# 同任务单飞守卫在 jobs 层。默认取上限，对齐「默认不排队」的使用预期。
 MIN_WORKERS, MAX_WORKERS = 1, 12
 
 

package/app/core/skills.py

@@ -390,11 +390,14 @@ def relevance_top(lessons, task, limit):
     if not probe:
         return lessons[:limit]
 
-    def rank(x):
-        grams = _text_bigrams(x.get("title")) | _text_bigrams(x.get("content"))
-        return (-len(probe & grams), x.get("id") or "")
-
-    return sorted(lessons, key=rank)[:limit]
+    # 使用反馈闭环（pmb「量化记忆真实帮助」借鉴）：被选中次数多的教训排前
+    def rank(x):
+        grams = _text_bigrams(x.get("title")) | _text_bigrams(x.get("content"))
+        overlap = -len(probe & grams)
+        lid = x.get("id") or ""
+        return (overlap, -int(x.get("hits") or 0), lid)
+
+    return sorted(lessons, key=rank)[:limit]
 
 
 def block_for(task, scope_override=None, *, stable_order=False):
@@ -407,7 +410,7 @@ def block_for(task, scope_override=None, *, stable_order=False):
     前缀缓存（同一任务 8 章应看到完全相同的技能块）。内容不变，只稳排序。
     """
     scope = scope_override or task.get("type") or "*"
-    parts, used = [], []
+    parts, used, lesson_ids = [], [], []
 
     for p in all_packs():
         if scope not in p["scopes"] and "*" not in p["scopes"]:
@@ -430,9 +433,10 @@ def block_for(task, scope_override=None, *, stable_order=False):
         if stable_order:
             lessons.sort(key=lambda x: x.get("id") or "")
         lines = []
-        for x in lessons:
-            lines.append("- **%s**：%s" % (x["title"], x["content"]))
-            used.append(x["id"])
+        for x in lessons:
+            lines.append("- **%s**：%s" % (x["title"], x["content"]))
+            used.append(x["id"])
+            lesson_ids.append(x["id"])
         parts.append("### 【本项目已沉淀的教训（历史评审反复出现，务必规避）】\n" + "\n".join(lines))
 
     if not parts:
@@ -440,8 +444,8 @@ def block_for(task, scope_override=None, *, stable_order=False):
     text = "## 经验库（写作/工程规范 + 历史教训，必须遵守）\n\n" + "\n\n".join(parts)
     if len(text) > MAX_INJECT_CHARS:
         text = text[:MAX_INJECT_CHARS] + "\n…（已截断）"
-    if used:
-        bump_hits(used)
+    if lesson_ids:
+        bump_hits(lesson_ids)  # 包 id 不参与教训热度，命中数据只保留一份真源
     return text, used