codebee 0.1.19 → 0.1.21

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/覆写/乱码墙）：

package/app/core/zentao.py

@@ -1077,7 +1077,7 @@ def _goal_text(bug, side=None):
 
 
 def _launch_fix(bug, profile, side, cfg):
-    """为一个 bug 的某一端建修复任务并入队。与 automation._launch_run 同一条链。"""
+    """为一个 bug 的某一端建修复任务并立即启动。"""
     bid = bug.get("id")
     repo = _repo_of(profile, side)
     wd = str(repo.get("workdir") or "").strip() or settings.default_workdir()
@@ -1088,11 +1088,31 @@ def _launch_fix(bug, profile, side, cfg):
         payload["git_rev"] = str(repo["git_rev"]).strip()
     if str(repo.get("verify_command") or "").strip():
         payload["verify_command"] = str(repo["verify_command"]).strip()
-    task = store.create_task(payload)
-    run = store.create_run("orchestration", task["title"], task_id=task["id"])
-    store.update_task_status(task["id"], "queued")
-    jobs.enqueue({"kind": "orchestration", "run_id": run["id"], "task_id": task["id"]})
-    return task, run
+    task = None
+    run = None
+    try:
+        task = store.create_task(payload)
+        run = store.create_run("orchestration", task["title"], task_id=task["id"])
+        store.update_task_status(task["id"], "queued")
+        jobs.enqueue({"kind": "orchestration", "run_id": run["id"],
+                      "task_id": task["id"]})
+        return task, run
+    except Exception:
+        log.exception("zentao: 修复任务启动失败 bug=%s side=%s task=%s run=%s",
+                      bid, side, (task or {}).get("id"), (run or {}).get("id"))
+        if run:
+            try:
+                store.update_run(run["id"], status="failed",
+                                 error="禅道修复任务启动失败，本次未排队，请稍后重试",
+                                 ended_at=time.strftime("%Y-%m-%d %H:%M:%S"))
+            except Exception:
+                log.exception("zentao: 修复运行失败收口失败 run=%s", run.get("id"))
+        if task:
+            try:
+                store.update_task_status(task["id"], "failed")
+            except Exception:
+                log.exception("zentao: 修复任务失败收口失败 task=%s", task.get("id"))
+        raise
 
 
 # ---------------------------------------------------------------- 回写文本

package/app/main.py

@@ -972,7 +972,7 @@ class Handler(BaseHTTPRequestHandler):
         m = re.match(r"^/api/catalog/([^/]+)/launch$", path)
         if m:
             # 一键打开（web 类起服务+开浏览器 / console 类新终端窗口）。
-            # 即时返回不走任务队列；body 可传 {"open": false} 供测试免开浏览器
+            # 即时返回不走任务执行器；body 可传 {"open": false} 供测试免开浏览器
             entry = catalog.by_id(m.group(1))
             if not entry:
                 return self._json(404, {"error": "catalog 中无此条目"})
@@ -1713,9 +1713,13 @@ class Handler(BaseHTTPRequestHandler):
             ok, err, new_run = store.retry_task(run["task_id"])
             if ok:
                 store.update_run(new_run["id"], op="qa", qa_text=text)
-                self._enqueue_run(new_run["id"], run["task_id"],
-                                  {"kind": "orchestration", "run_id": new_run["id"],
-                                   "task_id": run["task_id"]})
+                started, start_err = self._enqueue_run(
+                    new_run["id"], run["task_id"],
+                    {"kind": "orchestration", "run_id": new_run["id"],
+                     "task_id": run["task_id"]})
+                if not started:
+                    return self._json(503, {"error": start_err,
+                                            "run_id": new_run["id"]})
                 return self._json(200, {"ok": True, "message": msg,
                                         "qa_run": new_run["id"]})
         return self._json(200, {"ok": True, "message": msg})
@@ -2100,15 +2104,17 @@ class Handler(BaseHTTPRequestHandler):
         return self._json(status, resp)
 
     def _enqueue_run(self, run_id, task_id, job):
-        """入队失败时把已持久化记录收口到 failed，避免 UI 永远显示排队中。"""
+        """立即启动失败时收口到 failed；系统默认没有等待队列。"""
         try:
             jobs.enqueue(job)
             return True, ""
-        except Exception:
+        except Exception as exc:
             # 不把异常文本（本机路径、命令行参数、供应商响应）返回给客户端；
             # 详细堆栈只进服务端日志，run 记录也保留稳定的用户可读文案。
             log.exception("任务入队失败 run=%s task=%s", run_id, task_id)
-            err = "任务入队失败，请稍后重试"
+            busy = isinstance(exc, jobs.JobsBusyError)
+            err = ("当前运行任务已达并发保护上限，本次未排队，请稍后重试"
+                   if busy else "任务启动失败，请稍后重试")
             try:
                 closed = store.update_run(run_id, status="failed", error=err,
                                           ended_at=time.strftime("%Y-%m-%d %H:%M:%S"))
@@ -2161,8 +2167,7 @@ def _state_payload(client_id="", ver=None):
         "control": remote.control_view(client_id),
         # 供应商健康/告警（顶栏横幅数据源；有告警时 bump_state 会推给所有端）
         "health": health.snapshot(),
-        # 任务队列观测（worker 池目标/存活 + 队列深度）：排队问题排障一眼定位
-        # 是「并发满载在等」还是「job 蒸发没人管」（后者由看门狗 2 分钟自愈）
+        # 直接执行观测：并发保护上限、运行数和可用位；queued 恒为 0。
         "jobs": jobs.workers_info(),
     }
 
@@ -2355,14 +2360,17 @@ def main():
         telemetry.start_background()  # 匿名错误回传+版本 ping（默认开可关；未配端点自动休眠，延迟 45s 不挡启动）
     except Exception:
         pass
-    _step("正在启动任务队列…")
+    _step("正在启动任务执行器…")
     jobs.start_worker()
+    n_wait = jobs.restore_deferred_resumes()
+    if n_wait:
+        print("[CodeBee] 已恢复 %d 个定时退避中的自动续跑任务" % n_wait)
     n_resume = jobs.resume_interrupted()   # 启动恢复：服务被杀中断的连载任务自动续跑
     if n_resume:
         print("[CodeBee] 已自动恢复 %d 个中断的连载任务（断点续跑）" % n_resume)
-    n_rq = jobs.requeue_pending()   # 启动补队：队列在内存里，重启会让排队项变僵尸
+    n_rq = jobs.requeue_pending()   # 兼容旧版本遗留的无退避 queued 记录
     if n_rq:
-        print("[CodeBee] 已重新入队 %d 个遗留排队运行" % n_rq)
+        print("[CodeBee] 已直接启动 %d 个遗留运行" % n_rq)
     _step("正在启动自动化调度…")
     n_auto = automation.start()   # 自动化：加载定时任务并拉起调度线程（错过的一次性任务不补跑）
     if n_auto:

package/app/pet.py

@@ -117,7 +117,7 @@ def derive_state(prev_active_ids, tasks):
 
 
 def tooltip_lines(snap, lang="zh"):
-    """悬停清单：未读摘要 + 进行中 + 排队，最多 6 行。
+    """悬停清单：未读摘要 + 进行中 + 待启动/自动续跑，最多 6 行。
 
     只列「还在跑 / 待跑」的任务——历史失败项会刷满清单（截图实测十几条
     ✘ 把面板撑成一堵墙），失败已由警示气泡点名，这里不再重复。
@@ -167,7 +167,7 @@ LANG = {
         "all_clear": "蜂群闲着，都在打盹…",
         "title": "蜂群动态",
         "n_running": "%d 个进行中",
-        "queued": "排队中",
+        "queued": "正在启动",
         "cheer": "🎉 %d 个任务完工！",
         "alert": "⚠️ 「%s」出岔子了，点我看看",
         "bye": "蜜蜂回巢啦",