codebee 0.1.50 → 0.1.51

package/app/core/jobs.py

@@ -2,8 +2,14 @@
 """任务执行器：直接启动、无等待队列地执行编排任务与管理操作。
 
 每个 job 一条独立线程，run/step 数据按 run_id 隔离，store 层有全局锁。
-设置中的并发数是保护上限：有空位就立即启动，满载则明确失败并提示稍后重试，
-绝不把任务留在内存队列里无限等待。安装/升级失败时自动触发 AI 诊断修复：
+设置中的并发数是保护上限：有空位就立即启动。满载时 orchestration 任务
+（用户/自动化任务）回滚 queued 排队等下一个空位——补跑 Timer 到点重试，
+封顶 BUSY_WAIT_MAX 拍，超时才判失败（满载秒判失败会逼用户原话重发，
+侧栏堆同题重复任务，2026-09-22 纸枪对话实案）；升级排水与其余 kind
+仍明确失败并提示稍后重试。并发保护保护的是本机资源（CLI 子进程数），
+与各 API 厂商的限流无关——厂商侧 429 由 runner 冷却换将兜底。direct
+对话（内置智能体直连 API，本机几乎零开销）走独立轻量池，不与编排任务
+抢全局槽。安装/升级失败时自动触发 AI 诊断修复：
 由真实智能体读取失败日志与本机环境给出修正命令；仅当命令命中白名单前缀
 （npm/winget/brew/pip 安装类，按平台取对应渠道）才自动执行，否则把建议命令
 记录在运行记录里等人工确认。
@@ -22,12 +28,16 @@ _started = False
 _alive = 0            # 已获执行位、尚未结束的 job 数
 _restart_drain = False  # 升级重启前原子停止接单；不排队、不打断已运行任务
 _target = 12          # 并发保护上限（settings.max_concurrent_jobs）
+_chat_alive = 0       # 轻量池：direct 对话在跑数（独立于全局池计数）
 _pool_lock = threading.Lock()
 _idle_cond = threading.Condition(_pool_lock)
 _timer_lock = threading.Lock()
 _deferred_timers = {}
 _seq = 0
-MAX_POOL = 12
+MAX_POOL = 24
+CHAT_POOL = 4         # 轻量池上限：direct 对话直连 API 本机开销极小，4 个足够
+BUSY_WAIT_S = 15.0    # 满载排队后的补跑轮询间隔（秒）；测试可调小
+BUSY_WAIT_MAX = 40    # 补跑拍数封顶：15s × 40 = 10 分钟，超时才判失败
 
 
 class JobsBusyError(RuntimeError):
@@ -80,7 +90,7 @@ def _repair_command_allowed(cmd, platform=None):
 
 
 def configure(max_workers):
-    """设置并发保护上限（1-12）；只影响后续启动，不中断已运行任务。"""
+    """设置并发保护上限（1-24）；只影响后续启动，不中断已运行任务。"""
     global _target
     _target = max(1, min(MAX_POOL, int(max_workers)))
     return _target
@@ -112,23 +122,33 @@ def start_worker():
     configure(12)
 
 
-def enqueue(job):
-    """立即为 job 预留执行位并启动独立线程；从不进入等待队列。
+def _job_is_light(run):
+    """direct 对话走轻量池：内置智能体直连模型 API，本机无 CLI 子进程，
+    开销与编排任务（每步起一个 CLI）差几个量级，不该抢全局槽。判定按
+    run 所属任务的 type，入口侧零改动（自动化/webhook 等新入口自动跟随）。
+    run 缺失或类型未知时保守走全局池。direct 极少数回落 CLI 的场景，轻量
+    池上限也只有 CHAT_POOL 个，本机压力可控。"""
+    try:
+        task_id = (run or {}).get("task_id")
+        if not task_id:
+            return False
+        from . import store
+        task = store.get_task(task_id)
+        return str((task or {}).get("type") or "") == "direct"
+    except Exception:
+        return False
 
-    返回前先把持久化 run 从 queued 原子切到 running，因此 HTTP/自动化调用方
-    不会看到“已接受但仍排队”。满载、重复 run、线程创建失败都会明确抛错；
-    满载与启动失败还会就地把 run 收口为 failed，任何入口都不会留下僵尸。
-    """
-    global _alive, _seq
-    if not _started:
-        start_worker()
-    if not isinstance(job, dict):
-        raise ValueError("job 必须是对象")
-    run_id = job.get("run_id")
-    if not run_id:
-        raise ValueError("job.run_id 必填")
 
+def _try_start_once(job):
+    """CAS 认领持久化 run → 占并发位 → 起执行线程，一次直接启动尝试。
+
+    返回 True=已起跑；False=并发位满载未启动（run 停在 running，由调用方
+    决定回滚排队还是收口失败）。run 已非 queued（被取消/接管/收口）时抛
+    DuplicateJobError；线程创建失败就地收口后原样上抛。升级排水在这里视作
+    满载的一种（返回 False），快速失败还是排队的语义由调用方区分。"""
+    global _alive, _chat_alive, _seq
     from . import store
+    run_id = job.get("run_id")
     current = store.get_run(run_id)
     if current:
         # 先 CAS 认领持久化 run，再碰并发位。若先占位，两个调用可能分别看到
@@ -142,55 +162,95 @@ def enqueue(job):
                                     (run_id, latest.get("status")))
     cancel_event_for(run_id)
 
-    # CAS 认领后检查并发保护位。_alive 在 Thread.start 前递增，消除旧实现中线程尚未
-    # 回写 alive、扩容循环一次造出几十条 worker 的竞态。
+    # CAS 认领后检查并发保护位。占位在 Thread.start 前递增，消除旧实现中线程尚未
+    # 回写 alive、扩容循环一次造出几十条 worker 的竞态。direct 对话占轻量池，
+    # 其余任务占全局池；job["light"] 随副本传给执行线程，结束时按原池释放。
+    light = _job_is_light(current)
     with _pool_lock:
         if _restart_drain:
-            busy_limit = -1
-        elif _alive >= _target:
-            busy_limit = _target
+            busy = True
+        elif light:
+            busy = _chat_alive >= CHAT_POOL
+            if not busy:
+                _chat_alive += 1
+                job["light"] = True
         else:
-            busy_limit = 0
-            _alive += 1
+            busy = _alive >= _target
+            if not busy:
+                _alive += 1
+        if not busy:
             _seq += 1
             seq = _seq
-    if busy_limit:
+    if busy:
         CANCELS.pop(run_id, None)
-        if busy_limit < 0:
-            message = "服务正在完成升级重启；本次未排队，请稍后重试"
-        else:
-            message = "当前运行任务已达并发保护上限（%d）；本次未排队，请稍后重试" % busy_limit
-        _close_unstarted(job, message,
-                         statuses=("running",))
-        raise JobsBusyError(message)
+        return False
 
     try:
         threading.Thread(target=_run_job, args=(dict(job),),
                          name="job-direct-%d" % seq, daemon=True).start()
     except Exception:
-        _release_slot()
+        _release_slot(job)
         CANCELS.pop(run_id, None)
         _close_unstarted(job, "任务执行线程启动失败；本次未排队，请稍后重试",
                          statuses=("queued", "running"))
         raise
+    return True
 
+
+def enqueue(job):
+    """立即为 job 预留执行位并启动独立线程；从不进入内存等待队列。
+
+    返回前先把持久化 run 从 queued 原子切到 running，因此 HTTP/自动化调用方
+    不会看到“已接受但仍排队”。满载时 orchestration 任务转排队等待空位（对
+    调用方视作受理成功，见 _requeue_await_slot）；重复 run、线程创建失败、
+    升级排水满载都会明确抛错，并就地把 run 收口为 failed，任何入口都不会
+    留下无人认领的僵尸。
+    """
+    if not _started:
+        start_worker()
+    if not isinstance(job, dict):
+        raise ValueError("job 必须是对象")
+    run_id = job.get("run_id")
+    if not run_id:
+        raise ValueError("job.run_id 必填")
+
+    if not _try_start_once(job):
+        if _restart_drain:
+            # 升级排水：接单通道已在关闭，排队只会排进一次注定重启的进程——
+            # 照旧快速失败。
+            message = "服务正在完成升级重启；本次未排队，请稍后重试"
+            _close_unstarted(job, message,
+                             statuses=("running",))
+            raise JobsBusyError(message)
+        if str(job.get("kind") or "") != "orchestration" or not _requeue_await_slot(job):
+            # mgmt 与回滚失败（run 已被取消/收口）维持快速失败原语义；
+            # orchestration 已转排队，对调用方视作受理成功。
+            message = ("当前运行任务已达并发保护上限（%d）；本次未排队，请稍后重试"
+                       % _target)
+            _close_unstarted(job, message,
+                             statuses=("running",))
+            raise JobsBusyError(message)
     return True
 
 
-def _release_slot():
-    global _alive
+def _release_slot(job=None):
+    """释放执行位：按 job 的 light 标记归还对应池，两池全空才唤醒等待方。"""
+    global _alive, _chat_alive
     with _idle_cond:
-        _alive = max(0, _alive - 1)
-        if _alive == 0:
+        if job is not None and job.get("light"):
+            _chat_alive = max(0, _chat_alive - 1)
+        else:
+            _alive = max(0, _alive - 1)
+        if _alive == 0 and _chat_alive == 0:
             _idle_cond.notify_all()
 
 
 def wait_for_idle(timeout=10):
-    """测试/停机辅助：等待所有直接执行任务结束。"""
+    """测试/停机辅助：等待所有直接执行任务（含轻量池）结束。"""
     import time as _t
     end = _t.time() + max(0, float(timeout))
     with _idle_cond:
-        while _alive:
+        while _alive or _chat_alive:
             left = end - _t.time()
             if left <= 0:
                 return False
@@ -228,6 +288,72 @@ def _close_unstarted(job, message, statuses=("queued",)):
         pass
 
 
+def _requeue_await_slot(job, waits_left=None):
+    """满载转排队：run 回滚 queued 并挂补跑 Timer，等下一个并发空位。
+
+    只服务 orchestration 任务（用户/自动化任务）。enqueue 起手已把 run CAS
+    成 running，这里再 CAS 回 queued（清 started_at，别让「排队中」顶着起跑
+    时间），并同步任务状态回排队。返回 True=已转排队（调用方视作受理成功，
+    不再向调用方抛忙）；False=回滚失败（run 已被取消/收口），走原快速失败
+    路径。取消/重启/超时的收口：
+    - 用户取消 → run 已非 running，回滚 CAS 落空，或补跑 enqueue 撞
+      DuplicateJobError，链条自然断掉；
+    - 服务重启 → Timer 随进程消失，启动时 requeue_pending() 接管 queued 记录；
+    - 等满 BUSY_WAIT_MAX 拍仍无空位 → 判失败并给出可读原因。
+    """
+    run_id = job.get("run_id")
+    if waits_left is None:
+        waits_left = BUSY_WAIT_MAX
+    try:
+        from . import store
+        changed = store.update_run(run_id, expected_status="running",
+                                   status="queued", started_at="")
+        if changed is None:
+            return False
+        if job.get("task_id"):
+            try:
+                store.update_task_status(job["task_id"], "queued")
+            except Exception:
+                pass
+    except Exception:
+        return False
+
+    def _fire():
+        # 补跑心跳：直接尝试一次启动（不走 enqueue 的排队分支，否则每拍都会
+        # 带着全新重试额度重新入队，封顶永远打不中）。仍满载则续下一拍。
+        with _timer_lock:
+            _deferred_timers.pop(run_id, None)
+        try:
+            started = _try_start_once(job)
+        except DuplicateJobError:
+            return   # 已被取消/接管/收口：补跑链到此为止
+        except Exception:
+            return   # 线程启动失败等异常路径已就地收口，不续棒
+        if started:
+            return
+        if _restart_drain:
+            _close_unstarted(job, "服务正在完成升级重启；本次未排队，请稍后重试",
+                             statuses=("running",))
+        elif waits_left > 0:
+            _requeue_await_slot(job, waits_left - 1)
+        else:
+            _close_unstarted(job, "并发位已满，排队等待超时仍未起跑，请稍后重试",
+                             statuses=("running",))
+
+    with _timer_lock:
+        if run_id in _deferred_timers:
+            return True   # 已有补跑在等：别叠 Timer（防与续跑退避串台）
+        timer = threading.Timer(max(0.0, float(BUSY_WAIT_S)), _fire)
+        timer.daemon = True
+        _deferred_timers[run_id] = timer
+        try:
+            timer.start()
+        except Exception:
+            _deferred_timers.pop(run_id, None)
+            return False
+    return True
+
+
 def _schedule_enqueue(job, delay_s):
     """按明确截止时间延迟启动；同一 run 只保留一个 Timer。"""
     run_id = job.get("run_id")
@@ -342,7 +468,7 @@ def _run_job(job):
                 notify.push_run_async(run_id)
             except Exception:
                 pass
-        _release_slot()
+        _release_slot(job)
 
 
 def cancel(run_id):
@@ -648,7 +774,9 @@ def requeue_pending(limit=10, max_age_s=None):
 
 def workers_info():
     with _pool_lock:
-        return {"target": _target, "alive": _alive, "queued": 0,
+        return {"target": _target, "alive": _alive,
+                "chat_alive": _chat_alive, "chat_pool": CHAT_POOL,
+                "queued": 0,
                 "available": 0 if _restart_drain else max(0, _target - _alive),
                 "mode": "restart-drain" if _restart_drain else "direct"}
 

package/app/core/manager.py

@@ -192,21 +192,38 @@ def sweep_orphan_cli_processes():
 
 
 def detect_all(force=False):
-    """检测全部条目。检测（慢磁盘 IO）在锁外跑：shutil.which/isfile 在
-    Windows 上遇到断链的 PATH 项可能卡数秒，持锁会把所有并发请求堵死
-    （曾导致 SSE 多连接时服务假死）。等待方有界等待 30s 后拿旧结果。
-    """
+    """检测全部条目。快照用途（force=False）热路径永不等检测：缓存新鲜直接
+    返回；过期返回旧快照、同时把刷新踢到后台线程（stale-while-revalidate）。
+
+    检测是慢磁盘 IO：shutil.which/isfile 在 Windows 上遇到断链的 PATH 项
+    可能卡数秒。此前「领队请求自己跑检测、其余请求 ev.wait(30) 排队」，每
+    60s 缓存周期都有一个 /api/catalog、/api/state（含 SSE 推送）一起卡数秒
+    的窗口；前端无超时轮询把浏览器 6 连接池塞满后整个界面假死（2026-09-22
+    用户实测「左栏点不动、右栏不刷新」）。冷启动首轮与 force=True（显式
+    重载/安装回调）仍同步跑拿新鲜结果。"""
     with _LOCK:
         if not force and _STATE["detected"] and time.time() - _STATE["detect_ts"] < 60:
             return _STATE["detected"]
         ev = _STATE["detect_ev"]
-        lead = ev is None  # 我是本次检测的执行者
+        lead = ev is None  # 我是本次刷新的发起人
         if lead:
             ev = _STATE["detect_ev"] = threading.Event()
+        cold = not _STATE["detected"]   # 冷启动首轮：还没有任何快照
     if not lead:
-        ev.wait(30)  # 检测完成或超时；两种情况都拿当前最新快照
+        if not cold:
+            return dict(_STATE["detected"])   # 过期快照也比卡请求强
+        ev.wait(30)  # 冷启动窗口内并发首查：等首轮检测完成（一次性）
         with _LOCK:
             return dict(_STATE["detected"])
+    if not cold and not force:
+        threading.Thread(target=_detect_refresh, args=(ev,),
+                         name="catalog-detect", daemon=True).start()
+        return dict(_STATE["detected"])
+    return _detect_refresh(ev)
+
+
+def _detect_refresh(ev):
+    """跑一轮全量检测并落快照；完成后置时间戳、清在飞标记、放行等待者。"""
     try:
         detected = {}
         for entry in catalog.load():
@@ -217,12 +234,12 @@ def detect_all(force=False):
         if detected:
             with _LOCK:
                 _STATE["detected"] = detected
+        return dict(_STATE["detected"])
     finally:
         with _LOCK:
             _STATE["detect_ts"] = time.time()
             _STATE["detect_ev"] = None
         ev.set()
-    return detected
 
 
 def _uwp_version(package_dir):

package/app/core/market.py

@@ -290,8 +290,34 @@ def install_files(pack_id, name, files, extra=None):
                 record.update(extra)
             installed[pack_id] = record
         _save_registry(reg)
+    # 装后冒烟验证（SkillForge 证据驱动借鉴）：装完重新走 skills 的解析链，
+    # 证明该包能被加载、名字对得上、正文非空——写盘成功 ≠ 技能可用，
+    # frontmatter 缺失/正文为空都能在这里当场暴露，而不是下次任务注入时静默丢失。
+    smoke = ""
+    try:
+        with skills._LOCK:
+            skills._user_pack_cache.clear()
+            skills._user_dir_mtime["ts"] = 0.0
+            skills._user_dir_mtime["ids"] = None
+        up = next((p for p in skills.user_packs()
+                   if str(p.get("file") or "").replace("\\", "/").endswith("/" + target)), None)
+        if up is None:
+            smoke = "装后冒烟未找到已装包（解析失败？）"
+        elif (up.get("name") or "").strip() != name.strip():
+            smoke = "装后冒烟名字不符：%s ≠ %s" % (up.get("name"), name)
+        elif not str(up.get("body") or "").strip():
+            smoke = "装后冒烟正文为空"
+        else:
+            smoke = "ok:%d字" % len(str(up.get("body") or ""))
+    except Exception as e:
+        smoke = "装后冒烟异常: %s" % str(e)[:120]
+    with _LOCK:
+        reg = _load_registry()
+        if pack_id in (reg.get("installed") or {}):
+            reg["installed"][pack_id]["smoke"] = smoke
+            _save_registry(reg)
     return {"ok": True, "id": pack_id, "name": name, "file": target,
-            "already": already, "scan": scan_note}, None
+            "already": already, "scan": scan_note, "smoke": smoke}, None
 
 
 def remove(pack_id):

package/app/core/pipeline.py

@@ -1114,29 +1114,53 @@ def _run_code(run, task, agents, ev, stats, mode):
                 and _code_bestof(run, task, impl_agent, difficulty, ev)):
             return True
         # 实现步失败不立刻判死：2026-09-16 实测配额烧干时 5 连跑全在同一条 CLI 上
-        # 失败收场，而健康的 opencode 一直在旁观望——跨 CLI 换将重试一次
-        # （mode=manual 尊重用户指定，不换）。
+        # 失败收场，而健康的 opencode 一直在旁观望——跨 CLI 换将重试
+        # （mode=manual 尊重用户指定，不换）。2026-09-22 续修：配额/限流类死亡
+        # 是确定性秒死，允许继续走查候选名单（同上游让位异上游）；其余死因
+        # （超时等）仍只换一次，防着在坏候选上再烧一整个超时。
         if mode == "auto" and impl_agent.get("mode") == "real":
-            ex = {impl_agent["id"], "mock-a", "mock-b"}
-            other, other_reason = router.pick(agents, "implement", "code", stats,
-                                              exclude=ex)
-            if other is not None and other.get("mode") == "real":
+            tried = {impl_agent["id"], "mock-a", "mock-b"}
+            notes = []
+            dead_ups = []  # 配额死亡候选的上游集合：换将优先异上游
+            prev_id = impl_agent["id"]
+            other = None
+            while True:
+                other, other_reason = router.pick_switch_candidate(
+                    agents, "implement", "code", stats,
+                    exclude=tried, dead_upstreams=dead_ups)
+                if other is None or other.get("mode") != "real":
+                    other = None
+                    break
                 note = "实现步失败自动换将 %s → %s：%s。失败原因：%s" % (
-                    impl_agent["id"], other["id"], other_reason,
+                    prev_id, other["id"], other_reason,
                     (res.get("error") or "")[:200])
                 ok2, res = _run_one(other)
                 if ok2:
-                    store.update_run(run_id, error="", route_note=note)
+                    route_note = "；".join(notes + [note])
+                    store.update_run(run_id, error="", route_note=route_note)
                     _record_actual_route(
                         run_id, task, agents, stats, other,
                         implementers=[other], reviewer=reviewer,
-                        implement_reason=note,
+                        implement_reason=route_note,
                         review_reason=route.get("reviewer", ""),
                         direct=not workflow["review_required"])
                     return True
-                res_err = "%s；换将后仍失败：%s" % (note, (res.get("error") or "")[:200])
+                notes.append(note)
+                tried.add(other["id"])
+                prev_id = other["id"]
+                if runner._quota_error(res.get("error") or ""):
+                    ups = router.agent_upstreams(other["id"])
+                    if ups:
+                        dead_ups.append(ups)
+                else:
+                    break  # 非配额死因：只换一次就收手
+            tail_err = (res.get("error") or "")[:200]
+            if notes:
+                res_err = "；".join(notes) + "；换将后仍失败：%s" % tail_err
+            elif other is None:
+                res_err = "实现步骤失败（无其他真实 CLI 可换将）: %s" % tail_err
             else:
-                res_err = "实现步骤失败（无其他真实 CLI 可换将）: %s" % res.get("error")
+                res_err = "实现步骤失败: %s" % tail_err
         else:
             res_err = "实现步骤失败: %s" % res.get("error")
         store.update_run(run_id, expected_status="running", status="failed",

package/app/core/planner.py

@@ -114,13 +114,16 @@ def _log_usage(source, role, task, res, agent=None, tool="", model="", provider=
     except Exception:
         pass
 
-CODE_PLAN_PROMPT = """你是技术负责人。请把下面的开发目标拆解为 __N__ 个以内、按顺序执行的子任务，
-并判定任务难度和后续质量步骤。只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
+CODE_PLAN_PROMPT = """你是技术负责人。请先判定任务难度，再按难度拆解为按顺序执行的子任务，
+并给出后续质量步骤。只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
 {"difficulty": "easy 或 hard", "workflow": {"review_required": true, "max_repair_rounds": 0, "allow_switch": false}, "subtasks": [{"title": "简短标题", "detail": "具体要做什么，给执行工程师的直接指令", "files": ["涉及的文件路径"]}]}
-难度判定：常规增删改查/小函数/格式调整 = easy；跨模块改动/架构调整/复杂算法/安全相关 = hard。
+难度判定：宁易勿难，绝大多数任务都是 easy——常规增删改查/小函数/格式调整/单点 bug 修复/
+配置调整 = easy；只有跨模块改动/架构调整/复杂算法/安全相关才算 hard，拿不准时一律按 easy。
 质量步骤判定：涉及安全、数据迁移、并发、权限、公共 API 或跨模块改动时必须评审；
 有明确自动验收的低风险小改可不做模型评审。max_repair_rounds 取 0-2，只有复杂任务才建议换将。
-子任务粒度要可独立验证；最后一个子任务必须包含整体联调/收尾。
+子任务拆分：easy 一律只拆 1 个子任务——一个子任务把目标完整做完并自检通过即收尾，
+禁止拆出独立的核查/联调/收尾子任务；只有 hard 才允许多个子任务（至多 __N__ 个），
+粒度要可独立验证，且最后一个子任务必须包含整体联调/收尾。
 
 ## 先探索再计划（重要，借鉴 OpenSpec explore）
 拆解之前先用你的读文件/搜索工具**实际查看工作目录**，找到目标相关的真实文件与函数，再据此拆解。
@@ -527,7 +530,13 @@ def _norm_subtasks(data):
             if clean:
                 step["files"] = clean
         steps.append(step)
-    return steps or None
+    if not steps:
+        return None
+    # easy 任务执行层钉死单子任务：编排者提示词不服从多拆时，截掉只留首步
+    # （联调/收尾要求仅对 hard 生效，easy 单步自检即收尾）。
+    if _plan_difficulty(data) == "easy":
+        steps = steps[:1]
+    return steps
 
 
 def _plan_difficulty(data):