codebee 0.1.73 → 0.1.76

package/CHANGELOG.md

@@ -6,6 +6,23 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 
 ## 未发布
 
+## v0.1.76（2026-10-03）
+
+- **连载「打磨永远不过」的三道结构性死闸拆了**（2026-10-03 不周山守村人 21–28 章脱纲空转实案：8 章章分全 8+ 全过、全局情节/节奏 5.0 不到线，两轮打磨重改的全是达标好章，病灶章没人碰，单轮 $12/6.9M tokens 打水漂）：
+  - **aider 全局评审恒拒答**：超长指令落文件后提示词让模型「用读文件工具读」，被 glm-5.3 当提示注入直接拒答（十秒白卷）——全局有效评审永远只有 1 名，低于门禁「≥2 名」要求，数学上不可能通过。现在 aider 的超长指令改走 `--read` 参数由 CLI 自己读入会话（语义同交互式 `aider file.md`），不再指挥模型读文件。
+  - **打磨选章永远选不中病灶章**：选章按章分挑，而脱纲章的章分往往全部达标（章级评审只看局部、看不到章纲），全局评审点名的病灶章（成稿与锁定章纲脱轨的那几章）永远进不了打磨面。现在全局评审 major 点名的章优先进入打磨面，且点名章放开「不得改主线」禁令——按本章大纲要点推翻重写自创情节才是脱纲章的唯一修法，保事实微调恰恰修不动；点名原话与本章节拍一并注入重改提示词。
+  - **重评达标旧账不撤**：三处评审账本（全局 issues / 打磨章 issues / 章内修订回路 issues）都是只增不减——重写修好了、重评也过了线，第一轮的旧 majors 仍压着 `publishable=false`。现在三处统一「重评出分即换新账、评审链全挂保留旧账」（评审链挂了不代表书变差）。
+- **续写批不再被「故事追踪漂移」误杀**：Windows 上章稿以 CRLF 入账（`_read_chapter` 保真读回），追踪文件再用文本模式落盘会把换行二次翻译成 `\r\r\n`，磁盘稿与状态摘要从此永久错位——下一批续写任务一开场就被漂移闸拦下「章节正文不一致」（0.1.71 引入起 Windows 全量中招，续写批无法续跑；test_continue_serial 自 09-30 起预存挂）。现在写侧归一 LF+字节落盘钉死换行，查侧按字节愈合比对、兼容新旧三种历史形态——已损坏的旧状态不用手工修复，同源即认；真被手工改过的内容照常拦截。
+- **续写批全书评审不再「失忆」**：前作章节发布后归档成单文件（chapter-NN.md 不在场）时，全书一致性评审只看得到本批——现在从「已成稿/」找回前文，且 60k 字预算优先保本批完整（前文从尾部截取，越靠近本批越要紧）；合并成书同样带回归档前文，续写批的「成书」不再静默丢掉此前所有章节；跨轮重复的问题清单去重，不再把同一处问题计成三四条 major。
+- 回归：tests/test_serial_outline_polish.py（9 项）+ tests/test_serial_polish_named.py（13 项）；tests/test_continue_serial.py 预存挂随 CRLF 修复转绿。
+
+## v0.1.75（2026-10-03）
+
+- **一键急停来了**：侧栏底部新增红色急停钮（有活跃任务才现身、确认框点名、busy 防双击）——`cancel_all` 全量扫描取消 queued/running 任务，终态不动，`cancelled_by_user` 先落防自动续跑续上（借鉴 hcom/amux 同类标配）。回归：tests/test_kill_all.py。
+- **成品文件长出「第 N 版」徽章**：多版本成品一眼分先后——头部徽章（run 总数-列表序位）、对比 chip「与第 N 版对比」、diff 弹窗副标「第 N 版 → 当前」（run_id 摘要降为审计尾注；total 缺失不编不显示，纯增强不加闸门）。i18n 四键；回归：tests/ui_ver_badge.mjs。
+- **作品信息「换名」按钮**：书名撞名只换名不重摇——排除名单=books.json 登记+全站 book_meta 书名，轻模型同步接口、成功才写盘；前端书名行换名钮+防双击+失败就地恢复。回归：tests/test_bookmeta_rename.py + tests/ui_bookmeta_rename.mjs。
+- **用户作品数据不再漏进 npm 包**：工作目录里生成的 `作品信息-*.md`（用户书目资料，非代码）此前会被 `npm pack` 打进发布包——发版冒烟校验当场拦下（tar 内路径含非 ASCII 段即拒）。现在 .npmignore 增补排除（根目录与 app/ 两处；app/.npmignore 就近生效），文件本体不动。
+- README 首屏 CLI 名册补齐 OpenClaw（catalog 14 条目中唯一漏列者）。
 - **扫榜选材报告逐条带「证据分级」了**：热门题材/高频人设/差异化切入建议每一条末尾标注【证据 A-E】——A=三平台及以上重合、B=两平台重合、C=单平台多次出现、D=单平台仅一次、E=素材无直接证据系推断（借鉴 career-ops 的分级报告交付形态）。此前 AI 选题洞察里的「大热题材」不区分三平台重合的真风口和单平台单次的孤证，读者无从判断该信几分；现在分级只认四源榜单素材的真实出现情况，组合条目按组成元素较低档取值、拿不准就降不升级，报告第一行自带图例。菜单/流程说明与 README 同步。回归：tests/test_rank_scan_grading.py（新增）+ tests/test_rank_scan_copy.py。
 - **作品信息「复制」按钮没用了的根因治了**：作品简介/书名/标签等字段旁的复制按钮点了只弹「已复制」、剪贴板却是空的——数据备份区在文件尾部又定义了一次 `copyText`（读 `data-copy` 属性的元素版），后定义覆盖了前定义，所有传字符串的复制入口（作品信息各字段、对话消息复制、详情页工作目录路径、预览页工作目录）一进函数就 TypeError 静默断掉，而 toast 照弹（async 函数把异常转成无人接的 rejected promise，不阻断后续代码），UI 测试只断言 toast 所以一直全绿。现在：重复定义移除，统一为单一字符串版 `copyText`（剪贴板 API 失败自动回退 execCommand 兜底——局域网 IP/远程地址打开页面时 `navigator.clipboard` 本就不存在，此前这条路也是死的）；「已复制」只在真实写进剪贴板后弹，失败明说。回归：tests/ui_bookmeta.mjs 复制断言升级为对账剪贴板真拿到文本（旧断言抓不住这类假成功）。
 - **禅道自动修复失败不再打扰业务流**：修复任务失败时此前会往禅道评论「自动修复未成功」并转派端负责人——失败只是中间态，不是修复结论，写回是拿工具故障打扰业务流，转派更是甩锅（2026-09-29 #27828 实案：评审器没跑起来也照评照转）。现在失败只记台账+群通知，回炉「待重试」状态等下轮扫描自动重试（只重建失败端、成功端不重跑，上限 3 次），到限置「修复失败」终态等人工；禅道页新增「立即处理」按钮，失败/需人工的记录不等下轮扫描随时手工重触发。全程零禅道写入，PUT 清空指派人的老坑彻底不再踩。回归：tests/test_zentao.py 53 项 + tests/ui_zentao.mjs。
@@ -38,6 +55,12 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 - 调度层加固：绑定链上的「纯模型条目」（只配模型名、没挂供应商）起跑前即被点名——所有 CLI 起跑日志新增凭据模式审计行（绑定链注入/无注入/本机默认，密钥值绝不入日志），缺凭据+登录闸门类错误按 CLI 附修复指引；不再只有 claude 有这层观测（2026-09-25 Mac claude 实案的三层加固通用化）。
 - **Mac 桌宠不再是「白板蜜蜂」**：macOS 的 Tk 没有逐像素窗口透明（`-transparentcolor` 是 Windows 专属），蜜蜂的矩形底板整个露出来还带系统边框（实拍=一块白板）。现在非 Windows 平台把底板画成深色卡片（对齐悬停清单面板色），桌宠呈「桌面小组件」形态；睡觉/失联的状态滤镜改为只作用于蜂体（原先整帧压暗靠键色噪点兜底，卡片底兜不回来会浮出一块更暗的小框）。Windows 逐像素透明不受影响。
 
+## v0.1.74（2026-09-30）
+
+- 新增 `TOOL_LAUNCH` 错误码：本地 CLI 启动失败（找不到可执行文件）与供应商故障彻底区分——此前这类失败被记成供应商健康故障，把健康的 Bigmodel 评测作废、整链判死（claude 垫片被清实案）
+- runner：Popen 异常统一包裹前缀「启动失败」零误判识别，先于一切上游分类
+- 评测/重探间隔与失败探针刷新调优
+
 ## v0.1.73（2026-09-30）
 
 - **建书假「已建书」三修**（我的马甲藏不住实案）：建书未取得 book_id 先按书名对账补回、仍空则**不落台账**（空条目曾让界面亮「已建书」）；校准遇空 book_id 先对账、找不回明报「可能尚未建成」，不再盲跑作品列表页误报「可能改版」；七猫补齐对账通道（resolve_book_id）

package/README.md

@@ -11,7 +11,7 @@
 **AI 是引擎，你的经验是方向盘。** CodeBee 为你指挥一支跨厂商的执笔/编码小队：
 统一调度本机已装的 AI 编码 CLI（Codex CLI、Claude Code、Qwen Code、OpenCode、Aider、
 Kimi Code、MiMo Code、Grok Build、Pi、DeepSeek Harness、Gemini CLI、CodeBuddy CLI、
-Trae Agent……），提供
+Trae Agent、OpenClaw……），提供
 **目标 → 自动拆解 → 智能路由 → 执行 → 客观验证 → 跨厂商评审 → 自动修复/换将 → 汇总报告**
 的完整闭环。你不在时它们自动推进、自我打磨；需要你拍板的地方——质量闸门、任务分支的
 采纳与丢弃——它们会亮起「待裁决」等你，绝不静默替你决定。
@@ -33,10 +33,11 @@ Trae Agent……），提供
 ---
 
 <!-- relnotes:start -->
-### 最新版更新内容（v0.1.73）
+### 最新版更新内容（v0.1.76）
 
-- 建书假「已建书」三修：book_id 空时按书名对账补回、找不回不落台账不亮「已建书」、七猫补齐对账通道
-- 扫榜选材与排名扫描增强（flows/paihang）
+- 连载「打磨永远不过」死锁拆除：aider 全局评审拒答（恒 1 名评审 < 门禁 2 名）、打磨选章选不中脱纲病灶章、重评达标旧问题清单不撤——三道结构性死闸全修，全局点名章优先重改并放开禁改主线
+- 续写批不再被「故事追踪漂移」误杀：Windows 换行二次翻译（\r\r\n）致磁盘稿与摘要永久错位的 0.1.71 起预存病根拔除，旧损坏状态免手工修复自动兼容
+- 续写批全书评审找回前文（已成稿/归档）、合并成书不再静默丢掉此前章节
 <!-- relnotes:end -->
 
 

package/app/core/analytics.py

@@ -0,0 +1,38 @@
+"""Task cost/quality rollups for operator views."""
+from __future__ import annotations
+
+from collections import defaultdict
+
+
+def summary(store):
+    by_task = defaultdict(lambda: {"runs": 0, "done": 0, "failed": 0,
+                                   "tokens": 0, "cost_usd": 0.0, "quality_sum": 0.0,
+                                   "quality_count": 0})
+    for run in store.list_runs(limit=None):
+        tid = run.get("task_id") or "_unowned"
+        row = by_task[tid]
+        row["runs"] += 1
+        row["done"] += int(run.get("status") == "done")
+        row["failed"] += int(run.get("status") == "failed")
+        row["tokens"] += int(run.get("tokens") or 0)
+        row["cost_usd"] += float(run.get("cost_usd") or 0)
+        verdict = run.get("verdict") or {}
+        quality = verdict.get("overall")
+        if isinstance(quality, (int, float)):
+            row["quality_sum"] += float(quality)
+            row["quality_count"] += 1
+    rows = []
+    for task_id, row in by_task.items():
+        item = dict(row)
+        item["task_id"] = task_id
+        item["cost_usd"] = round(item["cost_usd"], 6)
+        item["quality_avg"] = round(item.pop("quality_sum") / item.pop("quality_count"), 2) \
+            if item["quality_count"] else None
+        item.pop("quality_count", None)
+        rows.append(item)
+    rows.sort(key=lambda x: (-x["cost_usd"], x["task_id"]))
+    return {"tasks": rows, "totals": {
+        "runs": sum(x["runs"] for x in rows),
+        "tokens": sum(x["tokens"] for x in rows),
+        "cost_usd": round(sum(x["cost_usd"] for x in rows), 6),
+    }}

package/app/core/bookmeta.py

@@ -31,20 +31,6 @@ def template_only():
     return str(os.environ.get("TUTTI_BOOKMETA_TEMPLATE_ONLY") or "").strip() in ("1", "true", "yes")
 
 
-def needs_book_meta(task):
-    """这本书是否需要开书资料：连载首批（start_chapter <= 1）才需要。
-
-    开书资料属于「这本书」而不是某一批章节——续写批次沿用第一批的书名/简介/
-    标签即可，重复生成只会覆盖成同内容的近义版本。非连载任务一律不需要。"""
-    serial = (task or {}).get("serial")
-    if not isinstance(serial, dict):
-        return False
-    try:
-        return int(serial.get("start_chapter") or 1) <= 1
-    except (TypeError, ValueError):
-        return True
-
-
 # 各平台建书表单的字段展示顺序（前端卡片与 Markdown 归档共用）。
 # 番茄官方表单（2026-09 实抓）：签约模式=连载模式/完本模式；阅读标签=主分类(必选1)
 # +主题/角色/情节(各≤2)；内容标签=情节(≤4)/情感(≤2)/人设(≤4)/世界观(≤1)。
@@ -795,6 +781,121 @@ def make_book_meta(task, platform, author_agent=None, log_path=None):
     return meta, _apply_fix_note(meta, meta["source"])
 
 
+# ---- 换名（2026-10-02 用户实案：生成的书名与本站已有作品重名，用户要的是
+# 「换一个名字」而不是整套重摇——重摇会覆盖已核对过的分类/标签/简介）
+
+RENAME_TIMEOUT = 120
+# 排除名单注入上限：全站书名可能上百个，超出的按序丢弃（提示词预算保护；
+# 排序后字母序前 80 个 + 调用方传入的近期撞名足够防撞，撞了还有重试兜底）
+RENAME_EXCLUDE_LIMIT = 80
+
+RENAME_PROMPT = """你是网文编辑。这本书《__OLD__》的书名与已有作品重名了，请另起一个新书名。
+
+书的基本情况：
+__MATERIAL__
+
+硬性要求：
+- 只输出一个 ```json 代码块：{"book_name": "新书名"}，不要输出其他内容；
+- 新书名不超过 15 个字，贴合题材、有网文点击欲，与旧书名同一题材但用词明显不同；
+- 严禁与下面任何一本书重名，也不得只加「2」「新」「之」等后缀敷衍：
+__EXCLUDE__"""
+
+
+def used_book_names():
+    """本站全部已用书名（换名排除名单）：已建书登记（books.json 的 title）
+    + 所有任务 book_meta 各平台 done 态的 book_name。读取异常只降级不阻断
+    （名单不全最坏结果是换出来的名字仍撞，用户再点一次）。"""
+    from .publish import ledger
+    names = set()
+    try:
+        # books.json 结构：{task_id: {platform: {book_id, title, url, ...}}}
+        for by_plat in (ledger.load_books() or {}).values():
+            if not isinstance(by_plat, dict):
+                continue
+            for rec in by_plat.values():
+                t = str((rec or {}).get("title") or "").strip()
+                if t:
+                    names.add(t)
+    except Exception:
+        pass
+    try:
+        from . import store
+        for task in store.list_tasks(limit=10 ** 9):
+            for entry in (task.get("book_meta") or {}).values():
+                if isinstance(entry, dict) and entry.get("status") == "done":
+                    n = str((entry.get("data") or {}).get("book_name") or "").strip()
+                    if n:
+                        names.add(n)
+    except Exception:
+        pass
+    return names
+
+
+def rename_book(task, platform, old_name, exclude_names=()):
+    """给已生成的作品信息换一个不重名的书名。返回 (new_name, "") 或 ("", 错误)。
+
+    只产出新名，不写盘——调用方负责更新 book_meta 与归档同步；这样模型失败
+    时现有数据原样保留（区别于整套生成的线程+状态机，轻调用同步返回即可）。
+    新名若仍撞排除名单，把撞名项并入名单重试一次。"""
+    from . import modelhub, planner, runner
+    old_name = str(old_name or "").strip()
+    exclude = {str(x).strip() for x in (exclude_names or ()) if str(x).strip()}
+    exclude.add(old_name)
+    goal_lines = [x.strip() for x in (task.get("goal") or "").splitlines() if x.strip()]
+    meta_lines = []
+    if goal_lines:
+        meta_lines.append("目标：" + goal_lines[0][:200])
+    try:
+        _, bible, _ = store_read_bible(task)
+        if bible:
+            meta_lines.append("故事圣经摘录：" + bible[:400])
+    except Exception:
+        pass
+    material = "\n".join(meta_lines) if meta_lines else "（素材缺失，按旧书名题材另起）"
+    orch = None
+    try:
+        orch = modelhub.resolve_orchestrator()
+    except Exception:
+        orch = None
+    if not orch:
+        return "", "编排者模型不可用，无法自动换名（可稍后重试）"
+    prov, model = orch
+    last = ""
+    for _ in range(2):                           # 首轮撞名单 → 带撞名项重试一次
+        ex_block = "\n".join("- " + n for n in sorted(exclude)[:RENAME_EXCLUDE_LIMIT])
+        prompt = (RENAME_PROMPT.replace("__OLD__", old_name)
+                  .replace("__MATERIAL__", material)
+                  .replace("__EXCLUDE__", ex_block or "（暂无）"))
+        # max_tokens 4000 对齐主生成（2026-10-03 实案：glm-5.3 思考计入
+        # max_tokens，给 400 三次全被思考烧穿 output 打满，JSON 没成形）
+        res = modelhub.chat(prov["id"], model, prompt, max_tokens=4000,
+                            timeout=RENAME_TIMEOUT)
+        planner._log_usage("bookmeta", "bookmeta-rename", task, res, model=model,
+                           provider=prov.get("name", prov.get("id", "")),
+                           provider_id=prov.get("id", ""))
+        if not res["ok"]:
+            last = str(res.get("error") or "模型调用失败")[:200]
+            continue
+        text = str(res.get("text") or "")
+        data = runner.extract_json(text)
+        new_name = _name(data.get("book_name") if isinstance(data, dict) else "", 15)
+        if not new_name:
+            # 兜底：思考烧预算时 JSON 可能没成形，正文里有《书名》/「书名」
+            # 形态就抠出来用——抠出的名字仍要过下面的排除名单检查
+            m = re.search(r"[《「]([^《》「」]{1,15})[》」]", text)
+            if m:
+                new_name = _name(m.group(1), 15)
+        if not new_name:
+            last = "返回内容无法解析出新书名"
+            continue
+        if new_name in exclude:
+            last = "新书名《%s》仍与本站已有作品重名" % new_name
+            exclude.add(new_name)
+            continue
+        return new_name, ""
+    return "", last or "换名失败，请稍后重试"
+
+
 def render_markdown(task, platform, meta):
     """落工作目录的归档 Markdown（与前端弹框同一份字段顺序）。"""
     plat = PLATFORMS[platform]["label"]

package/app/core/contracts.py

@@ -0,0 +1,255 @@
+"""Durable task contracts, evidence, approvals and completion receipts."""
+from __future__ import annotations
+
+import json
+import re
+import threading
+import time
+import uuid
+from pathlib import Path
+
+from . import paths
+
+_DIR = paths.DATA_DIR / "contracts"
+_LOCK = threading.RLock()
+_ID_RE = re.compile(r"^[A-Za-z][0-9A-Za-z_-]{0,99}$")
+_CRITERIA_MAX = 40
+_EVIDENCE_MAX = 300
+_MISSING = object()
+_CASE_KEYWORDS = {
+    "correctness": ("正确", "验证", "测试", "质量", "correct", "test", "verify"),
+    "performance": ("性能", "耗时", "成本", "token", "performance", "latency", "cost"),
+    "boundary": ("边界", "极端", "boundary", "edge"),
+    "exception": ("异常", "失败处理", "容错", "exception", "error", "failure"),
+    "readability": ("可读", "文档", "表达", "readability", "documentation"),
+    "security": ("安全", "权限", "注入", "security", "auth", "injection"),
+}
+
+
+def _valid_id(task_id):
+    return bool(_ID_RE.fullmatch(str(task_id or "")))
+
+
+def _path(task_id):
+    if not _valid_id(task_id):
+        raise ValueError("任务 ID 无效")
+    return _DIR / (str(task_id) + ".json")
+
+
+def _now():
+    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+
+
+def _save(item):
+    p = _path(item["task_id"])
+    p.parent.mkdir(parents=True, exist_ok=True)
+    tmp = p.with_suffix(".tmp")
+    tmp.write_text(json.dumps(item, ensure_ascii=False, indent=2), encoding="utf-8")
+    tmp.replace(p)
+
+
+def _load(task_id):
+    try:
+        value = json.loads(_path(task_id).read_text(encoding="utf-8"))
+        return value if isinstance(value, dict) else None
+    except (OSError, ValueError):
+        return None
+
+
+def _actor(value):
+    return str(value or "local").strip()[:120] or "local"
+
+
+def create(task_id, payload=None):
+    """Create or update a task's contract, preserving evidence and audit history."""
+    payload = payload if isinstance(payload, dict) else {}
+    raw_criteria = payload.get("acceptance_criteria", _MISSING)
+    if raw_criteria is not _MISSING and not isinstance(raw_criteria, list):
+        raise ValueError("acceptance_criteria 必须是列表")
+    clean = []
+    for value in (raw_criteria if raw_criteria is not _MISSING else [])[:_CRITERIA_MAX]:
+        text = str(value or "").strip()[:500]
+        if text and text not in clean:
+            clean.append(text)
+    with _LOCK:
+        item = _load(task_id) or {
+            "version": 1, "task_id": str(task_id), "created_at": _now(),
+            "acceptance_criteria": [], "evidence": [], "approval_required": False,
+            "approval": None, "blocked_reason": "", "completion_receipt": None,
+            "audit": [], "status": "open",
+        }
+        # Partial updates must not erase an existing contract field merely
+        # because the caller omitted it (MCP/UI frequently send sparse patches).
+        if raw_criteria is not _MISSING:
+            item["acceptance_criteria"] = clean
+        if "approval_required" in payload:
+            approval_required = payload.get("approval_required")
+            if not isinstance(approval_required, bool):
+                raise ValueError("approval_required 必须是布尔值")
+            item["approval_required"] = approval_required
+        item["updated_at"] = _now()
+        item["audit"].append({"at": item["updated_at"], "actor": _actor(payload.get("actor")),
+                              "action": "contract_updated",
+                              "criteria_count": len(item.get("acceptance_criteria") or [])})
+        _save(item)
+        return item
+
+
+def get(task_id):
+    with _LOCK:
+        return _load(task_id)
+
+
+def add_evidence(task_id, evidence, actor="local"):
+    if not isinstance(evidence, dict):
+        raise ValueError("证据必须是对象")
+    status = str(evidence.get("status") or "unknown").lower()
+    if status not in ("passed", "failed", "unknown", "not_evaluated"):
+        raise ValueError("证据状态无效")
+    with _LOCK:
+        item = _load(task_id)
+        if not item:
+            item = create(task_id, {})
+        row = {"id": "ev-%s" % uuid.uuid4().hex[:20],
+               "criterion": str(evidence.get("criterion") or "")[:500], "status": status,
+               "summary": str(evidence.get("summary") or "")[:2000],
+               "source": str(evidence.get("source") or "manual")[:80], "at": _now(),
+               "actor": _actor(actor)}
+        item["evidence"].append(row)
+        item["evidence"] = item["evidence"][-_EVIDENCE_MAX:]
+        item["audit"].append({"at": row["at"], "actor": row["actor"],
+                              "action": "evidence_added", "evidence_id": row["id"]})
+        item["updated_at"] = row["at"]
+        _save(item)
+        return item
+
+
+def record_acceptance_cases(task_id, cases, actor="system"):
+    """Map acceptance-matrix cases onto matching user criteria.
+
+    Matching is deliberately conservative: only criteria containing a known
+    case keyword (or the explicit ``acceptance:<case>`` form) are linked. Any
+    unmatched criterion remains unverified rather than being guessed green.
+    """
+    if not isinstance(cases, list):
+        return get(task_id)
+    item = get(task_id)
+    if not item:
+        return None
+    criteria = item.get("acceptance_criteria") or []
+    for case in cases:
+        if not isinstance(case, dict):
+            continue
+        name = str(case.get("case") or "").strip().lower()
+        status = str(case.get("status") or "unknown").lower()
+        if name not in _CASE_KEYWORDS or status not in ("passed", "failed", "unknown", "not_evaluated"):
+            continue
+        for criterion in criteria:
+            text = str(criterion or "").strip()
+            low = text.lower()
+            explicit = low == "acceptance:" + name
+            matched = explicit or any(keyword.lower() in low for keyword in _CASE_KEYWORDS[name])
+            if not matched:
+                continue
+            add_evidence(task_id, {"criterion": text, "status": status,
+                                   "summary": case.get("reason") or
+                                             "acceptance matrix: " + name,
+                                   "source": "acceptance"}, actor=actor)
+    return get(task_id)
+
+
+def _decision(task_id, status, actor, note):
+    with _LOCK:
+        item = _load(task_id)
+        if not item:
+            return None, "任务契约不存在"
+        decision = {"status": status, "actor": _actor(actor),
+                    "note": str(note or "").strip()[:1000], "at": _now()}
+        item["approval"] = decision
+        item["status"] = "approved" if status == "approved" else "open"
+        item["audit"].append(dict(decision, action=status))
+        item["updated_at"] = decision["at"]
+        _save(item)
+        return item, None
+
+
+def approve(task_id, actor="local", note=""):
+    return _decision(task_id, "approved", actor, note)
+
+
+def reject(task_id, actor="local", note=""):
+    if not str(note or "").strip():
+        return None, "拒绝审批必须说明原因"
+    return _decision(task_id, "rejected", actor, note)
+
+
+def set_blocked(task_id, reason, actor="local"):
+    reason = str(reason or "").strip()[:1000]
+    if not reason:
+        return None, "Blocked 状态必须填写原因"
+    with _LOCK:
+        item = _load(task_id)
+        if not item:
+            return None, "任务契约不存在"
+        item["status"] = "blocked"
+        item["blocked_reason"] = reason
+        item["updated_at"] = _now()
+        item["audit"].append({"at": item["updated_at"], "actor": _actor(actor),
+                              "action": "blocked", "reason": reason})
+        _save(item)
+        return item, None
+
+
+def release_allowed(task_id):
+    item = get(task_id)
+    # Task creation persists the approval bit redundantly for backwards
+    # compatibility.  Combine both sources with OR so a damaged/tampered
+    # sidecar cannot downgrade an approval-protected task to releasable.
+    try:
+        from . import store
+        task = store.get_task(task_id) or {}
+    except Exception:
+        task = {}
+    requires = bool((item or {}).get("approval_required")) or bool(task.get("approval_required"))
+    if not requires:
+        return True
+    if item is None:
+        return False
+    approval = item.get("approval") or {}
+    return approval.get("status") == "approved"
+
+
+def complete(task_id, run):
+    if not isinstance(run, dict) or run.get("status") not in ("done", "failed", "cancelled", "timeout"):
+        return None, "完成回执只能关联终态运行"
+    with _LOCK:
+        item = _load(task_id)
+        if not item:
+            item = create(task_id, {})
+        criteria = item.get("acceptance_criteria") or []
+        evidence = item.get("evidence") or []
+        latest = {}
+        for row in evidence:
+            if row.get("criterion"):
+                latest[row["criterion"]] = row
+        checked = [latest.get(c) for c in criteria]
+        receipt = {"version": 1, "task_id": str(task_id), "run_id": run.get("id"),
+                   "run_status": run.get("status"), "criteria_total": len(criteria),
+                   "criteria_passed": sum(1 for row in checked if row and row.get("status") == "passed"),
+                   "criteria_failed": sum(1 for row in checked if row and row.get("status") == "failed"),
+                   "criteria_unverified": sum(1 for row in checked if not row or row.get("status") not in ("passed", "failed")),
+                   "evidence_ids": [row.get("id") for row in checked if row],
+                   "cost_usd": float(run.get("cost_usd") or 0), "tokens": int(run.get("tokens") or 0),
+                   "completed_at": _now()}
+        # Completion is idempotent for the same run.  A late duplicate status
+        # write must not manufacture a second audit event or mutate the
+        # original cost/token receipt.
+        previous = item.get("completion_receipt") or {}
+        if previous.get("run_id") == receipt["run_id"]:
+            return previous, None
+        item["completion_receipt"] = receipt
+        item["audit"].append({"at": receipt["completed_at"], "actor": "system",
+                              "action": "completion_receipt_created", "run_id": run.get("id")})
+        item["updated_at"] = receipt["completed_at"]
+        _save(item)
+        return receipt, None

package/app/core/error_codes.py

@@ -37,6 +37,7 @@ class ErrorCode(str, Enum):
     RATE_LIMIT = "RATE_LIMIT"              # 短时速率/并发限制（429）
     LOCAL_STATE = "LOCAL_STATE"            # 本地 CLI 状态/锁冲突
     CONTEXT_OVERFLOW = "CONTEXT_OVERFLOW"  # 触发压缩（与 MAX_TOKENS 不同）
+    TOOL_LAUNCH = "TOOL_LAUNCH"            # 本地 CLI 启动失败（找不到可执行文件）
 
     # === ok ===
     # "" 表示成功，不设枚举值
@@ -91,6 +92,11 @@ _NETWORK = ("stream disconnected", "stream closed", "connection reset", "connect
             "输出停滞")
 _LOCAL_STATE = ("database is locked", "database locked", "sqlite busy",
                 "unable to open database file")
+# run_process 对 Popen 异常的统一包裹前缀（"启动失败: %r"）。供应商侧任何
+# 报错都不会长这个样子，所以单靠前缀即可零误判地识别「本地工具链起不来」。
+# 2026-09-30 claude 垫片被清案：这类失败被记成供应商健康故障，把健康的
+# Bigmodel 评测作废、整链判死——必须先于一切上游分类识别。
+_TOOL_LAUNCH = ("启动失败",)
 _TRANSIENT_HINTS = ("stream closed before response.completed", "output stall", "timed out",
                     "timeout", "output stalled", "ENOTFOUND", "Reconnecting...",
                     "initialize", "[1211]")
@@ -116,6 +122,8 @@ def classify_error_text(error):
     text = str(error or "").lower()
     if not text:
         return None
+    if any(marker in text for marker in _TOOL_LAUNCH):
+        return ErrorCode.TOOL_LAUNCH
     if re.search(r"(?:http(?:/\d(?:\.\d)?)?\s*|status(?:\s+code)?\s*[:=]?\s*)401\b", text):
         return ErrorCode.AUTH
     # An explicit HTTP 403 is authoritative even when the provider describes the
@@ -196,6 +204,7 @@ _SAFE_ERROR_SUMMARIES = {
     ErrorCode.RATE_LIMIT: "上游触发速率或并发限制",
     ErrorCode.LOCAL_STATE: "CLI 本地状态或数据库锁冲突",
     ErrorCode.CONTEXT_OVERFLOW: "输入上下文超出模型容量",
+    ErrorCode.TOOL_LAUNCH: "本地 CLI 启动失败（可执行文件不存在，与供应商无关）",
 }
 
 

package/app/core/health.py

@@ -141,11 +141,26 @@ def report_success(provider: str):
         _persist()
 
 
+# run_process 包裹 Popen 启动异常的固定前缀。与 error_codes._TOOL_LAUNCH 的
+# 判定标记同源双写（error_codes 在 L0，health 在 L1，策略禁止 L1→L0 import；
+# 供应商侧任何报错都不会带这个前缀，单靠前缀即可零误判）。
+_LAUNCH_FAILURE_PREFIX = "启动失败"
+
+
 def report_failure(provider: str, error: str = "", *, model: str = "",
                    provider_id: str = ""):
-    """一次真实失败调用。provider 用展示名（与 usage 台账一致）。"""
+    """一次真实失败调用。provider 用展示名（与 usage 台账一致）。
+
+    本地 CLI 启动失败（找不到可执行文件等）与供应商无关，记进来会把健康
+    供应商的评测结论作废、链被解析层过滤成死链——2026-09-30 claude 垫片被
+    清案：Bigmodel 全程健康却被连续启动失败拖进 down。只打日志提醒修本地
+    环境，不进健康台账。"""
     if not provider:
         return
+    if _LAUNCH_FAILURE_PREFIX in str(error or "")[:80]:
+        log.warning("[health] 本地 CLI 启动失败（与供应商 %s 无关，不记健康故障）：%s",
+                    provider, str(error or "")[:160])
+        return
 
     # A failed live call invalidates capability evidence for this upstream.
     # Keep this hook lazy and best-effort: health telemetry must never make a

package/app/core/jobs.py

@@ -422,6 +422,56 @@ def _schedule_enqueue(job, delay_s):
     return True
 
 
+def enqueue_now(run_id):
+    """立即重试：退避窗口内的续跑副本跳过等待马上入队（详情页按钮触发）。
+
+    返回 (ok, err)。先摘到点 Timer 再直接 enqueue——CAS 认领保证与 Timer
+    竞态时只有一方生效，Timer 抢先起跑按目的已达成处理。resume_enqueue_at
+    同步清空：副本一旦入队/起跑，UI 不该再显示「将于 HH:MM 自动续跑」；
+    满载转排队后由补跑心跳接管，巡检也把它当普通排队记录。跳过退避是
+    用户的主动选择（等效于手动重试），不受「别烧退避窗口」的巡检约束。"""
+    from . import store
+    run = store.get_run(run_id)
+    if not run:
+        return False, "运行不存在"
+    if run.get("status") != "queued":
+        return False, "该运行已不在排队等待中"
+    if not str(run.get("resume_enqueue_at") or ""):
+        return False, "该运行不在自动续跑等待中"
+    if str(run.get("kind") or "orchestration") != "orchestration" or not run.get("task_id"):
+        return False, "该运行不支持立即重试"
+    resume_at = str(run.get("resume_enqueue_at") or "")
+    with _timer_lock:
+        old = _deferred_timers.pop(run_id, None)
+    if old is not None:
+        old.cancel()
+    if store.update_run(run_id, resume_enqueue_at="") is None:
+        if old is not None:
+            _schedule_enqueue({"kind": "orchestration", "run_id": run_id,
+                               "task_id": run.get("task_id")}, 1.0)
+        return False, "运行状态已变化，请刷新后重试"
+    try:
+        enqueue({"kind": "orchestration", "run_id": run_id,
+                 "task_id": run.get("task_id")})
+    except DuplicateJobError:
+        pass   # 到点 Timer 抢先起跑/运行已被取消接管：无需再排
+    except Exception as exc:
+        # A non-duplicate enqueue failure must not strand the run with the
+        # backoff marker cleared and its original timer removed.
+        current = store.get_run(run_id)
+        if current and current.get("status") == "queued":
+            store.update_run(run_id, resume_enqueue_at=resume_at)
+            try:
+                import time as _time
+                due = _time.mktime(_time.strptime(resume_at, "%Y-%m-%d %H:%M:%S"))
+                _schedule_enqueue({"kind": "orchestration", "run_id": run_id,
+                                   "task_id": run.get("task_id")}, max(0.0, due - _time.time()))
+            except Exception:
+                pass
+        return False, "立即重试失败，已恢复自动续跑：%s" % str(exc)[:160]
+    return True, ""
+
+
 def restore_deferred_resumes(limit=None, now=None):
     """重建重启前的自动续跑退避 Timer；返回成功恢复的数量。"""
     import time as _t
@@ -551,6 +601,28 @@ def cancel(run_id):
     return False
 
 
+def cancel_all():
+    """急停（kill switch）：取消全部 queued/running 运行，返回实际取消数。
+
+    逐跑走 cancel() 同一条链路（事件置位 + 终态落盘 + 退避定时器清理），
+    单跑失败不影响其余。cancelled_by_user 先落——与单跑取消端点同一语义，
+    自动续跑不得把急停的任务又续上。
+    """
+    from . import store
+    n = 0
+    for r in store.list_runs(limit=None):
+        rid = r.get("id")
+        if not rid or (r.get("status") or "") not in ("queued", "running"):
+            continue
+        try:
+            store.update_run(rid, cancelled_by_user=True)
+        except Exception:
+            pass
+        if cancel(rid):
+            n += 1
+    return n
+
+
 def cancel_event_for(run_id):
     ev = CANCELS.get(run_id)
     if ev is None: