codebee 0.1.7 → 0.1.8

package/app/core/store.py

@@ -61,30 +61,30 @@ def _safe_name(s):
 
 # ---------------------------------------------------------------- 任务
 
-def create_task(payload):
+def create_task(payload):
     """校验并创建任务。payload 至少含 type/goal/workdir。
 
     type 必须是 flows.py 里的有效流程 ID；流程参数（引擎/维度/阈值/轮数/产出
     文件/提示词覆盖）在创建时固化到任务上，之后修改流程定义不影响已建任务。
     """
-    if not isinstance(payload, dict):
-        raise ValueError("任务参数必须是 JSON 对象")
-
-    def _text(value, field):
-        if value is None:
-            return ""
-        if not isinstance(value, str):
-            raise ValueError("%s 必须是文本" % field)
-        return value.strip()
-
-    from . import flows as flows_mod
+    if not isinstance(payload, dict):
+        raise ValueError("任务参数必须是 JSON 对象")
+
+    def _text(value, field):
+        if value is None:
+            return ""
+        if not isinstance(value, str):
+            raise ValueError("%s 必须是文本" % field)
+        return value.strip()
+
+    from . import flows as flows_mod
     flow = flows_mod.get_flow(payload.get("type"))
     if flow is None:
         raise ValueError("未知任务类型：%s（可选：%s）"
                          % (payload.get("type"), "、".join(f["id"] for f in flows_mod.list_flows())))
-    title = _text(payload.get("title"), "title")
-    goal = _text(payload.get("goal"), "goal")
-    workdir = _text(payload.get("workdir"), "workdir")
+    title = _text(payload.get("title"), "title")
+    goal = _text(payload.get("goal"), "goal")
+    workdir = _text(payload.get("workdir"), "workdir")
     if not goal:
         raise ValueError("目标描述不能为空")
     title = title or goal.splitlines()[0][:30]  # 标题可省略，自动取目标首行
@@ -112,7 +112,7 @@ def create_task(payload):
     task = {
         "id": _new_id("t"), "type": flow["id"], "engine": flow["engine"],
         "title": title, "goal": goal,
-        "context": _text(payload.get("context"), "context"),
+        "context": _text(payload.get("context"), "context"),
         "workdir": str(wd),
         "mode": mode,
         "difficulty": difficulty,
@@ -123,7 +123,7 @@ def create_task(payload):
     }
     # 代码版本：仅当引用合法才固化（流水线执行前据此检出任务分支）
     from . import gitmod
-    git_rev = _text(payload.get("git_rev"), "git_rev")
+    git_rev = _text(payload.get("git_rev"), "git_rev")
     if git_rev:
         # 前端下拉值带 kind 前缀（branch:main / tag:v1 / commit:abc），此处归一为纯 rev；
         # git 分支/标签名本身允许含冒号（罕见），前缀剥离只认这三种已知 kind
@@ -132,12 +132,12 @@ def create_task(payload):
             raise ValueError("非法的代码版本引用：%s" % git_rev[:40])
         task["git_rev"] = git_rev
     if flow["engine"] == "code":
-        task["verify_command"] = _text(payload.get("verify_command"), "verify_command")
+        task["verify_command"] = _text(payload.get("verify_command"), "verify_command")
     elif flow["engine"] == "direct":
         pass  # 直连任务：无验证命令也无评审参数，目标+附件即全部输入
     else:
-        ms = _text(payload.get("manuscript") or flow.get("manuscript") or "manuscript.md",
-                   "manuscript")
+        ms = _text(payload.get("manuscript") or flow.get("manuscript") or "manuscript.md",
+                   "manuscript")
         ms = re.sub(r"[\\/]", "_", ms)  # 只允许工作目录内的相对文件名
         ms = re.sub(r"\.{2,}", "_", ms).lstrip(".")  # 顺带清掉残留的 ..
         task["manuscript"] = ms
@@ -145,6 +145,11 @@ def create_task(payload):
             task["rounds"] = max(1, min(5, int(payload.get("rounds") or flow.get("rounds") or 2)))
         except Exception:
             task["rounds"] = 2
+        try:
+            # Best-of-N 赛马候选数（非连载单稿；连载走 serial.variants 的同章赛马）
+            task["best_of"] = max(1, min(3, int(payload.get("best_of") or flow.get("best_of") or 1)))
+        except Exception:
+            task["best_of"] = 1
         try:
             task["threshold"] = max(1.0, min(10.0,
                                              float(payload.get("threshold") or flow.get("threshold") or 7.0)))
@@ -158,18 +163,18 @@ def create_task(payload):
         for key in ("draft_prompt", "critique_prompt"):  # 自定义流程的提示词覆盖
             if flow.get(key):
                 task[key] = flow[key]
-        # 连载模式：逐章起草/评审/修订（任务级 serial 覆盖流程默认）。
-        # payload 中显式传 null 表示关闭流程默认连载；字段缺失才沿用流程默认，
-        # 这样前端把章节清空时不会被 serial_novel 的默认值悄悄重新打开。
-        serial_unset = object()
-        serial_value = payload.get("serial", serial_unset)
-        if serial_value is None or (isinstance(serial_value, dict) and
-                                    serial_value.get("enabled") is False):
-            serial = None
-        elif isinstance(serial_value, dict):
-            serial = serial_value
-        else:
-            serial = flow.get("serial")
+        # 连载模式：逐章起草/评审/修订（任务级 serial 覆盖流程默认）。
+        # payload 中显式传 null 表示关闭流程默认连载；字段缺失才沿用流程默认，
+        # 这样前端把章节清空时不会被 serial_novel 的默认值悄悄重新打开。
+        serial_unset = object()
+        serial_value = payload.get("serial", serial_unset)
+        if serial_value is None or (isinstance(serial_value, dict) and
+                                    serial_value.get("enabled") is False):
+            serial = None
+        elif isinstance(serial_value, dict):
+            serial = serial_value
+        else:
+            serial = flow.get("serial")
         if isinstance(serial, dict) and serial.get("chapters"):
             try:
                 s = {
@@ -201,17 +206,17 @@ def create_task(payload):
                     s["variants"] = v
                 task["serial"] = s
     critics = payload.get("critics")
-    if isinstance(critics, list) and critics:
-        task["critics"] = [str(c) for c in critics]
-    # 初始故事圣经必须在任务入队前落盘，保证首个章节步骤就能读到设定。
-    # 只对带连载引擎的任务接收；已有不同内容的圣经拒绝覆盖，避免新任务误伤旧书设定。
-    initial_bible = str(payload.get("story_bible") or "").strip()
-    if initial_bible:
-        if not task.get("serial"):
-            raise ValueError("初始故事圣经仅适用于连载小说任务")
-        if len(initial_bible) > BIBLE_MAX_CHARS:
-            raise ValueError("故事圣经超长（最大 %d 字符，当前 %d 字符）" %
-                             (BIBLE_MAX_CHARS, len(initial_bible)))
+    if isinstance(critics, list) and critics:
+        task["critics"] = [str(c) for c in critics]
+    # 初始故事圣经必须在任务入队前落盘，保证首个章节步骤就能读到设定。
+    # 只对带连载引擎的任务接收；已有不同内容的圣经拒绝覆盖，避免新任务误伤旧书设定。
+    initial_bible = str(payload.get("story_bible") or "").strip()
+    if initial_bible:
+        if not task.get("serial"):
+            raise ValueError("初始故事圣经仅适用于连载小说任务")
+        if len(initial_bible) > BIBLE_MAX_CHARS:
+            raise ValueError("故事圣经超长（最大 %d 字符，当前 %d 字符）" %
+                             (BIBLE_MAX_CHARS, len(initial_bible)))
     resume = payload.get("resume")
     if isinstance(resume, dict) and resume.get("agent") and resume.get("session"):
         task["resume"] = {"agent": str(resume["agent"])[:40],
@@ -221,16 +226,16 @@ def create_task(payload):
         proj = str(resume.get("project") or "")[:260]
         if proj:
             task["resume"]["project"] = proj
-    # 初始圣经先于附件提交：如果目录已有设定，尽早拒绝，避免附件已移动却
-    # 因故事圣经冲突导致任务创建失败。相同内容的重试是幂等的（例如附件
-    # 提交中断后重试），不会覆盖已有设定。
-    if initial_bible:
-        _write_initial_story_bible(str(wd), initial_bible)
-    # 附件：把待提交文件移入工作目录 _attachments/，清单注入 context（__CONTEXT__ 全链路可见）。
+    # 初始圣经先于附件提交：如果目录已有设定，尽早拒绝，避免附件已移动却
+    # 因故事圣经冲突导致任务创建失败。相同内容的重试是幂等的（例如附件
+    # 提交中断后重试），不会覆盖已有设定。
+    if initial_bible:
+        _write_initial_story_bible(str(wd), initial_bible)
+    # 附件：把待提交文件移入工作目录 _attachments/，清单注入 context（__CONTEXT__ 全链路可见）。
     # 两种形态：字符串 id = 待提交区文件（新建任务）；dict 清单 = 已落盘的附件
     # （继续连载/重试沿用同目录同文件，直接复制清单，不再移文件）。
     att_ids = payload.get("attachments")
-    if isinstance(att_ids, list) and att_ids:
+    if isinstance(att_ids, list) and att_ids:
         from . import attachments as att_mod
         items = [a for a in att_ids if isinstance(a, dict) and a.get("path")]
         if not items:  # 纯 id 形态 → 从待提交区移入工作目录
@@ -243,9 +248,9 @@ def create_task(payload):
             task["attachments"] = items
             blk = att_mod.context_block(items)
             # 复制清单场景下 context 已含附件块（随旧任务沿用），别重复追加
-            if blk and "## 附件材料" not in task["context"]:
-                task["context"] = (task["context"] + blk).strip()
-    with LOCK:
+            if blk and "## 附件材料" not in task["context"]:
+                task["context"] = (task["context"] + blk).strip()
+    with LOCK:
         _TASKS[task["id"]] = task
         _save_json(paths.TASKS_DIR / (task["id"] + ".json"), task)
     return task
@@ -419,20 +424,20 @@ def create_run(kind, title, task_id=None, entry_id=None, op=None):
         "started_at": None, "ended_at": None,
         "cost_usd": 0.0, "tokens": 0, "error": "",
         "verdict": None, "summary": "",
-    }
-    rdir = paths.RUNS_DIR / run["id"]
-    (rdir / "steps").mkdir(parents=True, exist_ok=True)
-    with LOCK:
-        # 先完成原子落盘，再发布到内存索引。旧顺序在 _save_json 失败时会
-        # 留下只存在于 _RUNS 的“幽灵 run”，后续 UI 看到排队记录却永远无法
-        # 读取/恢复其 run.json。
-        try:
-            _save_json(rdir / "run.json", run)
-        except Exception:
-            _RUNS.pop(run["id"], None)
-            raise
-        _RUNS[run["id"]] = run
-    return run
+    }
+    rdir = paths.RUNS_DIR / run["id"]
+    (rdir / "steps").mkdir(parents=True, exist_ok=True)
+    with LOCK:
+        # 先完成原子落盘，再发布到内存索引。旧顺序在 _save_json 失败时会
+        # 留下只存在于 _RUNS 的“幽灵 run”，后续 UI 看到排队记录却永远无法
+        # 读取/恢复其 run.json。
+        try:
+            _save_json(rdir / "run.json", run)
+        except Exception:
+            _RUNS.pop(run["id"], None)
+            raise
+        _RUNS[run["id"]] = run
+    return run
 
 
 def get_run(run_id):
@@ -657,6 +662,39 @@ def recover_orphaned_runs():
     return recovered
 
 
+def recover_interrupted_mgmt():
+    """启动时调用：把崩溃遗留的 queued 管理操作 run 标记为 failed。
+
+    running 的 mgmt run 已由 recover_orphaned_runs 统一收尸；queued 不在
+    其候选里——通用恢复故意留着 queued 给连载任务的 resume_interrupted
+    复活，但 mgmt job 只存在于内存队列，重启后永远没人认领，留着还会
+    堵住同条目的去重闸门。workers 尚未启动，此时 queued 必是遗留。
+    """
+    now = time.strftime("%Y-%m-%d %H:%M:%S")
+    with LOCK:
+        candidates = [r["id"] for r in _RUNS.values()
+                      if r.get("kind") == "mgmt" and r.get("status") == "queued"]
+    for run_id in candidates:
+        update_run(run_id, status="failed", ended_at=now,
+                   error="interrupted at startup (mgmt auto-recovered)")
+    return len(candidates)
+
+
+def active_mgmt_run(entry_id):
+    """该目录条目当前进行中（queued/running）的管理操作 run；没有则 None。
+
+    供「同条目同时只跑一个安装/升级/卸载」去重闸使用：两个同名全局 npm
+    并发装同一包会互锁（2026-09-18 codex 双开案）。内存索引即真源——
+    重启后 recover_* 已把遗留 run 收成终态。
+    """
+    with LOCK:
+        for r in _RUNS.values():
+            if r.get("kind") == "mgmt" and r.get("entry_id") == entry_id \
+                    and r.get("status") in ("queued", "running"):
+                return dict(r)
+    return None
+
+
 def run_workdir(run_id):
     """该 run 的工作目录（经其 task 关联）；无任务的 run（如管理操作）返回空串。"""
     run = get_run(run_id)
@@ -758,11 +796,11 @@ def task_step_count(task_id):
 
 # ---------------------------------------------------------------- 故事圣经（story-bible.md）
 
-BIBLE_FILE = "story-bible.md"
-BIBLE_MAX_CHARS = 20000
+BIBLE_FILE = "story-bible.md"
+BIBLE_MAX_CHARS = 20000
 
 
-def _bible_path(workdir):
+def _bible_path(workdir):
     """工作目录内圣经文件绝对路径；目录穿越直接返回 None（不读外面任何东西）。"""
     wd = str(workdir or "").strip()
     if not wd or not os.path.isdir(wd):
@@ -771,53 +809,53 @@ def _bible_path(workdir):
     p = (root / BIBLE_FILE).resolve()
     if root != p and root not in p.parents:
         return None
-    return p
-
-
-def _write_initial_story_bible(workdir, text):
-    """创建任务时安全播种故事圣经。
-
-    初始圣经写入发生在任务入队之前，多个请求可能同时指向同一个工作目录。
-    旧逻辑先在锁外检查、再在锁外写入，两个请求都能通过检查，后写请求会
-    覆盖先写的设定。这里把检查和写入放进同一进程锁，并在文件不存在时用
-    ``O_EXCL`` 做最后一道独占创建；已有不同内容的文件始终拒绝覆盖。
-    """
-    p = _bible_path(workdir)
-    if p is None:
-        raise ValueError("故事圣经写入失败：工作目录不可用")
-    with LOCK:
-        try:
-            p.parent.mkdir(parents=True, exist_ok=True)
-            if p.exists():
-                if not p.is_file():
-                    raise ValueError("故事圣经写入失败：目标路径不是文件")
-                existing = runner.read_text_any_enc(p).strip()
-                if existing:
-                    if existing == text:
-                        return
-                    raise ValueError("工作目录已有 story-bible.md，请清空初始圣经输入或先编辑已有设定")
-                # 空文件是合法的旧占位文件；在锁内覆盖，避免本服务内的并发写入。
-                p.write_text(text, encoding="utf-8")
-                return
-            try:
-                fd = os.open(str(p), os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644)
-            except FileExistsError:
-                # 其他进程可能刚创建了文件。相同内容可幂等返回；空文件仍可
-                # 完成播种，非空不同内容绝不静默覆盖。
-                if p.is_file():
-                    existing = runner.read_text_any_enc(p).strip()
-                    if existing == text:
-                        return
-                    if not existing:
-                        p.write_text(text, encoding="utf-8")
-                        return
-                raise ValueError("工作目录已有 story-bible.md，请清空初始圣经输入或先编辑已有设定")
-            with os.fdopen(fd, "w", encoding="utf-8") as fh:
-                fh.write(text)
-        except ValueError:
-            raise
-        except OSError as e:
-            raise ValueError("故事圣经写入失败：%s" % e)
+    return p
+
+
+def _write_initial_story_bible(workdir, text):
+    """创建任务时安全播种故事圣经。
+
+    初始圣经写入发生在任务入队之前，多个请求可能同时指向同一个工作目录。
+    旧逻辑先在锁外检查、再在锁外写入，两个请求都能通过检查，后写请求会
+    覆盖先写的设定。这里把检查和写入放进同一进程锁，并在文件不存在时用
+    ``O_EXCL`` 做最后一道独占创建；已有不同内容的文件始终拒绝覆盖。
+    """
+    p = _bible_path(workdir)
+    if p is None:
+        raise ValueError("故事圣经写入失败：工作目录不可用")
+    with LOCK:
+        try:
+            p.parent.mkdir(parents=True, exist_ok=True)
+            if p.exists():
+                if not p.is_file():
+                    raise ValueError("故事圣经写入失败：目标路径不是文件")
+                existing = runner.read_text_any_enc(p).strip()
+                if existing:
+                    if existing == text:
+                        return
+                    raise ValueError("工作目录已有 story-bible.md，请清空初始圣经输入或先编辑已有设定")
+                # 空文件是合法的旧占位文件；在锁内覆盖，避免本服务内的并发写入。
+                p.write_text(text, encoding="utf-8")
+                return
+            try:
+                fd = os.open(str(p), os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644)
+            except FileExistsError:
+                # 其他进程可能刚创建了文件。相同内容可幂等返回；空文件仍可
+                # 完成播种，非空不同内容绝不静默覆盖。
+                if p.is_file():
+                    existing = runner.read_text_any_enc(p).strip()
+                    if existing == text:
+                        return
+                    if not existing:
+                        p.write_text(text, encoding="utf-8")
+                        return
+                raise ValueError("工作目录已有 story-bible.md，请清空初始圣经输入或先编辑已有设定")
+            with os.fdopen(fd, "w", encoding="utf-8") as fh:
+                fh.write(text)
+        except ValueError:
+            raise
+        except OSError as e:
+            raise ValueError("故事圣经写入失败：%s" % e)
 
 
 def read_story_bible(task_id):
@@ -838,33 +876,33 @@ def read_story_bible(task_id):
         return None, None, "读取失败: %s" % e
 
 
-def write_story_bible(task_id, text):
+def write_story_bible(task_id, text):
     """写入故事圣经到任务工作目录。守卫：
     - 任务不存在/工作目录越界 → 拒绝；
     - 任务正在运行（queued/running）→ 拒绝（圣经是中流砥柱，运行中不能换骨架）；
     - 文本超长（BIBLE_MAX_CHARS）→ 拒绝；
     - 写入失败 → 报错。
     返回 (ok, 错误信息)。"""
-    with LOCK:
-        task = get_task(task_id)
-        if not task:
-            return False, "任务不存在"
-        if task.get("status") in ("queued", "running"):
-            return False, "任务正在运行，不能修改故事圣经（请等运行结束后再编辑）"
-        p = _bible_path(task.get("workdir"))
-        if p is None:
-            return False, "工作目录不存在或路径越界"
-        text = (text or "").strip()
-        if len(text) > BIBLE_MAX_CHARS:
-            return False, "故事圣经超长（最大 %d 字符，当前 %d 字符）" % (BIBLE_MAX_CHARS, len(text))
-        try:
-            p.parent.mkdir(parents=True, exist_ok=True)
-            p.write_text(text, encoding="utf-8")
-        except OSError as e:
-            return False, "写入失败: %s" % e
-    # 故事圣经是提示词输入，写入后让 SSE/轮询端尽快看到新状态。
-    bump_state()
-    return True, ""
+    with LOCK:
+        task = get_task(task_id)
+        if not task:
+            return False, "任务不存在"
+        if task.get("status") in ("queued", "running"):
+            return False, "任务正在运行，不能修改故事圣经（请等运行结束后再编辑）"
+        p = _bible_path(task.get("workdir"))
+        if p is None:
+            return False, "工作目录不存在或路径越界"
+        text = (text or "").strip()
+        if len(text) > BIBLE_MAX_CHARS:
+            return False, "故事圣经超长（最大 %d 字符，当前 %d 字符）" % (BIBLE_MAX_CHARS, len(text))
+        try:
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_text(text, encoding="utf-8")
+        except OSError as e:
+            return False, "写入失败: %s" % e
+    # 故事圣经是提示词输入，写入后让 SSE/轮询端尽快看到新状态。
+    bump_state()
+    return True, ""
 
 
 def read_run_file(run_id, rel):
@@ -1235,7 +1273,8 @@ def add_step(run_id, role, agent_id, agent_label, note=""):
 
 
 def finish_step(run_id, n, status, summary="", exit_code=None,
-                cost_usd=0.0, tokens=0.0, duration_s=None, model=None, output=None):
+                cost_usd=0.0, tokens=0.0, duration_s=None, model=None, output=None,
+                followups=None):
     with LOCK:
         run = _RUNS.get(run_id)
         if not run:
@@ -1254,6 +1293,8 @@ def finish_step(run_id, n, status, summary="", exit_code=None,
                     s["duration_s"] = round(duration_s, 1)
                 if output is not None:
                     s["output"] = str(output)[:6000]
+                if followups:
+                    s["followups"] = list(followups)[:3]
                 break
         run["cost_usd"] = round(run.get("cost_usd", 0.0) + cost_usd, 4)
         run["tokens"] = run.get("tokens", 0) + tokens