codebee 0.1.20 → 0.1.22

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/task_compile.py

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+"""任务编译器：把用户任务和预置流程编译成统一、可审计的运行规格。"""
+from __future__ import annotations
+
+from . import dispatch, flows
+
+SCHEMA_VERSION = 1
+DIFFICULTIES = ("easy", "default", "hard")
+
+
+def _difficulty(task, flow):
+    explicit = str((task or {}).get("difficulty") or "").strip().lower()
+    if explicit in DIFFICULTIES:
+        return explicit, "用户指定"
+    try:
+        threshold = float((task or {}).get("threshold")
+                          if (task or {}).get("threshold") is not None
+                          else (flow or {}).get("threshold") or 7.0)
+    except (TypeError, ValueError):
+        threshold = 7.0
+    if threshold >= 8.5:
+        return "hard", "高质量门槛"
+    if threshold <= 6.0:
+        return "easy", "快速交付门槛"
+    if str((task or {}).get("type") or "").lower() in (
+            "research", "tech_proposal", "rank_scan"):
+        return "hard", "研究/方案类默认需要深度"
+    return "default", "标准难度"
+
+
+def _capabilities(task, dimension, engine):
+    caps = [dimension]
+    if engine == "code" or (task or {}).get("verify_command"):
+        caps.extend(["filesystem", "verification"])
+    if (task or {}).get("serial"):
+        caps.extend(["long_context", "continuity"])
+    if (task or {}).get("attachments"):
+        caps.append("attachments")
+    return list(dict.fromkeys(caps))
+
+
+def compile_task(task):
+    """返回统一任务规格；输入缺失或字段异常时保持可编排的安全兜底。"""
+    raw = dict(task or {})
+    ttype = str(raw.get("type") or "direct").strip().lower()
+    flow = flows.get_flow(ttype) or {}
+    engine = str(raw.get("engine") or flow.get("engine") or
+                 ("code" if ttype == "code" else "review")).strip()
+    if engine not in flows.ENGINES:
+        engine = flow.get("engine") or ("code" if ttype == "code" else "review")
+    difficulty, difficulty_reason = _difficulty(raw, flow)
+    dimension = dispatch.task_dimension(ttype, raw.get("role") or "")
+    rubric = raw.get("rubric") or flow.get("rubric") or []
+    if isinstance(rubric, str):
+        rubric = [x.strip() for x in rubric.replace("，", ",").split(",") if x.strip()]
+    rubric = [str(x).strip() for x in rubric if str(x).strip()][:8]
+    deliverable = str(raw.get("manuscript") or flow.get("manuscript") or "").strip()
+    serial = raw.get("serial") if isinstance(raw.get("serial"), dict) else None
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "type": ttype,
+        "title": str(raw.get("title") or "")[:120],
+        "goal": str(raw.get("goal") or "")[:2000],
+        "engine": engine,
+        "dimension": dimension,
+        "difficulty": difficulty,
+        "difficulty_reason": difficulty_reason,
+        "capabilities": _capabilities(raw, dimension, engine),
+        "deliverable": deliverable,
+        "quality_dimensions": rubric,
+        "serial": serial,
+        "explicit_agent": str(raw.get("implementer") or "").strip(),
+        "has_verification": bool(raw.get("verify_command")),
+    }
+
+
+def summary(spec):
+    """给运行日志/UI 的短说明，不包含用户正文。"""
+    spec = spec or {}
+    return "%s/%s/%s（能力：%s）" % (
+        spec.get("type") or "direct", spec.get("engine") or "direct",
+        spec.get("difficulty") or "default",
+        "、".join(spec.get("capabilities") or []) or "通用")

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

@@ -30,8 +30,10 @@ import http.client
 import json
 import math
 import os
+import queue
 import random
 import sys
+import threading
 import time
 import webbrowser
 from pathlib import Path
@@ -39,7 +41,8 @@ from pathlib import Path
 # --------------------------------------------------------------- 纯逻辑（可测试）
 
 ACTIVE_STATUSES = ("queued", "running")
-BAD_STATUSES = ("failed", "cancelled")
+GOOD_STATUSES = ("done",)
+BAD_STATUSES = ("failed", "cancelled", "timeout")
 POLL_MS = 4000          # 轮询间隔
 POLL_TIMEOUT = 2.5      # 单次拉取超时（秒）
 MAX_MISS = 15           # 连续拉不到服务 N 次后自离（约 1 分钟，防孤儿常驻）
@@ -49,20 +52,32 @@ HOVER_MS = 250          # 指针轮询周期
 HOVER_DELAY_MS = 350    # 悬停多久后才弹任务清单（扫过不弹）
 
 
+def _safe_int(value, default=0, minimum=0):
+    """外部状态里的计数可能是空值或脏字符串；统一兜底并限制为非负数。"""
+    try:
+        number = int(value)
+    except (TypeError, ValueError, OverflowError):
+        number = int(default)
+    return max(minimum, number)
+
+
 def parse_snapshot(raw):
     """把 /api/pet_state 响应裁成蜜蜂关心的最小集。字段缺失一律兜底，不抛。"""
     raw = raw if isinstance(raw, dict) else {}
-    st = raw.get("settings") or {}
+    st = raw.get("settings") if isinstance(raw.get("settings"), dict) else {}
+    workers = raw.get("workers") if isinstance(raw.get("workers"), dict) else {}
+    digest = raw.get("digest") if isinstance(raw.get("digest"), dict) else {}
+    task_rows = raw.get("tasks") if isinstance(raw.get("tasks"), list) else []
     tasks = []
-    for t in (raw.get("tasks") or [])[:300]:
+    for t in task_rows[:300]:
         if not isinstance(t, dict):
             continue
         tasks.append({
             "id": str(t.get("id") or ""),
             "title": str(t.get("title") or t.get("id") or ""),
             "run_status": str(t.get("run_status") or ""),
-            "steps_done": int(t.get("steps_done") or 0),
-            "steps_total": int(t.get("steps_total") or 0),
+            "steps_done": _safe_int(t.get("steps_done")),
+            "steps_total": _safe_int(t.get("steps_total")),
             "step_current": str(t.get("step_current") or ""),
             "error": str(t.get("error") or ""),
         })
@@ -73,15 +88,14 @@ def parse_snapshot(raw):
             "pet_skin": str(st.get("pet_skin") or DEFAULT_SKIN),
         },
         "workers": {
-            "running": int((raw.get("workers") or {}).get("running") or 0),
-            "queued": int((raw.get("workers") or {}).get("queued") or 0),
+            "running": _safe_int(workers.get("running")),
+            "queued": _safe_int(workers.get("queued")),
         },
         "tasks": tasks,
         "digest": {
-            "unseen": int((raw.get("digest") or {}).get("unseen") or 0),
-            "latest": (raw.get("digest") or {}).get("latest")
-                      if isinstance((raw.get("digest") or {}).get("latest"), dict)
-                      else None,
+            "unseen": _safe_int(digest.get("unseen")),
+            "latest": digest.get("latest")
+                      if isinstance(digest.get("latest"), dict) else None,
         },
     }
 
@@ -105,10 +119,12 @@ def derive_state(prev_active_ids, tasks):
         by_id = {t["id"]: t for t in tasks}
         for tid in prev_active_ids:
             t = by_id.get(tid)
-            if t is None or t["run_status"] not in BAD_STATUSES:
-                info["good"].append(t or {"id": tid, "title": tid})
-            else:
+            if t is None:
+                continue
+            if t["run_status"] in BAD_STATUSES:
                 info["bad"].append(t)
+            elif t["run_status"] in GOOD_STATUSES:
+                info["good"].append(t)
         if info["bad"]:
             return "alert", info
         if info["good"]:
@@ -117,7 +133,7 @@ def derive_state(prev_active_ids, tasks):
 
 
 def tooltip_lines(snap, lang="zh"):
-    """悬停清单：未读摘要 + 进行中 + 排队，最多 6 行。
+    """悬停清单：未读摘要 + 进行中 + 待启动/自动续跑，最多 6 行。
 
     只列「还在跑 / 待跑」的任务——历史失败项会刷满清单（截图实测十几条
     ✘ 把面板撑成一堵墙），失败已由警示气泡点名，这里不再重复。
@@ -167,7 +183,7 @@ LANG = {
         "all_clear": "蜂群闲着，都在打盹…",
         "title": "蜂群动态",
         "n_running": "%d 个进行中",
-        "queued": "排队中",
+        "queued": "正在启动",
         "cheer": "🎉 %d 个任务完工！",
         "alert": "⚠️ 「%s」出岔子了，点我看看",
         "bye": "蜜蜂回巢啦",
@@ -276,7 +292,10 @@ def _http_json(port, path, body=None):
             method = "POST"
         conn.request(method, path, body=payload, headers=headers)
         resp = conn.getresponse()
-        return json.loads(resp.read().decode("utf-8"))
+        data = resp.read()
+        if not 200 <= resp.status < 300:
+            raise RuntimeError("CodeBee API 返回 HTTP %d" % resp.status)
+        return json.loads(data.decode("utf-8"))
     finally:
         conn.close()
 
@@ -405,6 +424,14 @@ class PetApp:
         self.hop_until = 0.0                        # 冒气泡时的蹦跶动作截止
         self.next_chatter = time.time() + random.uniform(90, 240)
         self.seen_digests = 0   # 本轮已通知过的摘要未读数（涨了才报，不重复轰炸）
+        self._polling = False
+        self._poll_results = queue.Queue(maxsize=1)
+        self._settings_lock = threading.Lock()
+        self._settings_pending = {}
+        self._settings_desired = {}
+        self._settings_confirmed = {}
+        self._settings_seq = 0
+        self._settings_worker_running = False
 
         if self.frames:
             self._build_sprite()
@@ -583,10 +610,7 @@ class PetApp:
             return
         self.skin = skin
         self._save_cfg(skin=skin)
-        try:
-            _http_json(self.port, "/api/settings", body={"pet_skin": skin})
-        except Exception:
-            pass
+        self._post_settings({"pet_skin": skin})
         self._rebuild_sprite()
 
     def _rebuild_sprite(self):
@@ -841,16 +865,92 @@ class PetApp:
         else:
             self._show([self.pbar_bg, self.pbar_fg], False)
 
-    # ---- 数据轮询（4s 一拍）----
+    def _post_settings(self, body):
+        """合并并串行发送设置，保证快速连点时最后一次选择最终生效。"""
+        patch = dict(body or {})
+        if not patch:
+            return
+        with self._settings_lock:
+            self._settings_seq += 1
+            seq = self._settings_seq
+            for key, value in patch.items():
+                self._settings_pending[key] = (seq, value)
+                self._settings_desired[key] = (seq, value)
+            if self._settings_worker_running:
+                return
+            self._settings_worker_running = True
+
+        def send():
+            while True:
+                with self._settings_lock:
+                    if not self._settings_pending:
+                        self._settings_worker_running = False
+                        return
+                    current = dict(self._settings_pending)
+                    self._settings_pending.clear()
+                try:
+                    _http_json(self.port, "/api/settings",
+                               body={key: item[1] for key, item in current.items()})
+                    with self._settings_lock:
+                        for key, item in current.items():
+                            self._settings_confirmed[key] = max(
+                                item[0], self._settings_confirmed.get(key, 0))
+                except Exception:
+                    # 新值优先；失败的旧值只补回尚未被新点击覆盖的键。
+                    with self._settings_lock:
+                        for key, item in current.items():
+                            self._settings_pending.setdefault(key, item)
+                    time.sleep(1.0)
+        threading.Thread(target=send, name="pet-settings", daemon=True).start()
+
+    def _reconcile_desired_settings(self, snap, confirmed_at_poll_start):
+        """只覆盖写入确认前已发出的旧轮询；确认后的快照以服务端为准。"""
+        with self._settings_lock:
+            for key, item in list(self._settings_desired.items()):
+                seq, value = item
+                if confirmed_at_poll_start.get(key, 0) >= seq:
+                    del self._settings_desired[key]
+                else:
+                    snap["settings"][key] = value
+
+    # ---- 数据轮询（4s 一拍；网络请求不占 Tk 主线程）----
     def _tick(self):
         self._touch_lock()
-        snap = None
+        if self._polling:
+            return
+        self._polling = True
+        with self._settings_lock:
+            confirmed_at_poll_start = dict(self._settings_confirmed)
+
+        def fetch():
+            snap = None
+            error = None
+            try:
+                snap = parse_snapshot(_http_json(self.port, "/api/pet_state"))
+            except Exception as exc:
+                error = exc
+            try:
+                self._poll_results.put_nowait(
+                    (snap, error, confirmed_at_poll_start))
+            except queue.Full:
+                pass
+
+        threading.Thread(target=fetch, name="pet-poll", daemon=True).start()
+        self.root.after(50, self._collect_poll)
+
+    def _collect_poll(self):
         try:
-            snap = parse_snapshot(_http_json(self.port, "/api/pet_state"))
-            self.miss = 0
-        except Exception:
+            snap, error, confirmed_at_poll_start = self._poll_results.get_nowait()
+        except queue.Empty:
+            self.root.after(50, self._collect_poll)
+            return
+        self._polling = False
+        if error is not None:
             self.miss += 1
+        else:
+            self.miss = 0
         if snap is not None:
+            self._reconcile_desired_settings(snap, confirmed_at_poll_start)
             if not snap["settings"]["pet_enabled"]:
                 return self._bye()
             self.snap = snap
@@ -1187,10 +1287,7 @@ class PetApp:
         return m
 
     def _set_mode(self, mode):
-        try:
-            _http_json(self.port, "/api/settings", body={"pet_mode": mode})
-        except Exception:
-            pass
+        self._post_settings({"pet_mode": mode})
 
     def _set_lang(self, lang):
         self.lang = lang