codebee 0.1.20 → 0.1.21

package/app/core/pipeline.py

@@ -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,10 +3267,18 @@ 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
     # 代码版本检出：任务指定了基线版本时，先检出任务分支 tutti/<task-id> 再跑流水线。
     # 显式意图不容静默降级——仓库缺失/脏工作区/引用不存在一律中止运行并报错，
@@ -3215,8 +3289,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 +3314,11 @@ 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"
     mode = task.get("mode") or ("manual" if task.get("implementer") else "auto")
     store.update_run(run_id, mode=mode)
     # engine 决定流水线：code=实现/验证/评审/修复；review=起草/多维评审/修订/门禁；
@@ -3272,7 +3351,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 +3362,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 = {
@@ -13,15 +13,19 @@ CAPABILITY = {
 MAX_REPAIR_ROUNDS = 2  # 自动修复循环上限
 
 
-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
 
@@ -45,14 +49,20 @@ def score(agent, role, ttype, stats=None):
     （封顶 -45，足以盖过历史加分），满额后仅在没有其他选择时才会被选中。"""
     stats = stats or {}
     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,7 +79,8 @@ 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=()):

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

@@ -394,9 +394,50 @@ def relevance_top(lessons, task, limit):
         grams = _text_bigrams(x.get("title")) | _text_bigrams(x.get("content"))
         return (-len(probe & grams), x.get("id") or "")
 
+    # 使用反馈闭环（pmb「量化记忆真实帮助」借鉴）：被选中次数多的教训排前
+    hits = _load_hits()
+    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, -hits.get(lid, 0), lid)
+
     return sorted(lessons, key=rank)[:limit]
 
 
+def _hits_path():
+    return paths.DATA_DIR / "skill_hits.json"
+
+
+def _load_hits():
+    """读取教训使用计数（{lesson_id: 次数}）。文件缺失/损坏返回空 dict。"""
+    try:
+        p = _hits_path()
+        if p.is_file():
+            import json
+            return json.loads(p.read_text(encoding="utf-8"))
+    except Exception:
+        pass
+    return {}
+
+
+def _bump_hits(ids):
+    """注入后递增使用计数并持久化（fire-and-forget，失败静默）。"""
+    try:
+        import json
+        p = _hits_path()
+        hits = _load_hits()
+        for lid in ids:
+            if lid:
+                hits[lid] = hits.get(lid, 0) + 1
+        p.parent.mkdir(parents=True, exist_ok=True)
+        tmp = p.with_suffix(".tmp")
+        tmp.write_text(json.dumps(hits, ensure_ascii=False), encoding="utf-8")
+        tmp.replace(p)
+    except Exception:
+        pass
+
+
 def block_for(task, scope_override=None, *, stable_order=False):
     """生成注入提示词的经验块。命中即计数。返回 (文本, 命中的 id 列表)。
 
@@ -440,6 +481,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 used:
         bump_hits(used)
     return text, used

package/app/core/store.py

@@ -448,11 +448,16 @@ def load_all():
                 # 错误串（`[91m[1mError:`、U+FFFD 乱码墙），读盘时统一洗一遍——
                 # 老运行不必等重跑才干净（2026-09-20「咋还有乱码」实测）
                 _sanitize_run_text(r)
-                # 队列不跨进程持久化：磁盘上仍是 queued/running 的运行必是上次进程中断的残骸
-                if r.get("status") in ("queued", "running"):
-                    r["status"] = "failed"
-                    r["error"] = r.get("error") or "服务重启中断，可重试"
-                    _save_json(p, r)
+                # 直接执行线程不跨进程：running 与无截止时间的 queued 是上次
+                # 进程中断残骸。带 resume_enqueue_at 的 queued 是有意的自动续跑
+                # 退避，保留给 jobs.restore_deferred_resumes 重建 Timer。
+                interrupted = (r.get("status") == "running" or
+                               (r.get("status") == "queued" and
+                                not r.get("resume_enqueue_at")))
+                if interrupted:
+                    r["status"] = "failed"
+                    r["error"] = r.get("error") or "服务重启中断，可重试"
+                    _save_json(p, r)
                 _RUNS[r["id"]] = r
             except Exception:
                 pass
@@ -507,10 +512,11 @@ def get_run(run_id):
         return _RUNS.get(run_id)
 
 
-def list_runs(limit=60):
-    with LOCK:
-        ids = sorted(_RUNS.keys(), reverse=True)
-        return [_RUNS[i] for i in ids[:limit]]
+def list_runs(limit=60):
+    with LOCK:
+        ids = sorted(_RUNS.keys(), reverse=True)
+        selected = ids if limit is None else ids[:limit]
+        return [_RUNS[i] for i in selected]
 
 
 def latest_run_by_task():
@@ -635,17 +641,17 @@ def task_side(task_id):
     }
 
 
-def update_run(run_id, expected_status=None, **fields):
+def update_run(run_id, expected_status=None, **fields):
     """更新运行字段。expected_status 非 None 时做 CAS（§2C）：
     当前状态不等于 expected_status 则拒绝写入并返回 None，
     防止陈旧执行方（被取消的 worker、崩溃恢复前的旧线程）覆盖新状态
     ——防御模式「异步状态不是同步状态」。不传则保持原行为。"""
     with LOCK:
         run = _RUNS.get(run_id)
-        if not run:
-            return None
-        if expected_status is not None and run.get("status") != expected_status:
-            return None
+        if not run:
+            return None
+        if expected_status is not None and run.get("status") != expected_status:
+            return None
         for k in ("error", "summary"):
             if isinstance(fields.get(k), str):
                 # 错误串多是我们自己拼的 CLI 尾巴（含 ANSI/覆写/乱码墙）：