codebee 0.1.67 → 0.1.69

package/CHANGELOG.md

@@ -4,6 +4,17 @@ CodeBee 的用户可感知变更记录。发布新版时：最上面加一节，
 `<!-- relnotes:start -->…<!-- relnotes:end -->` 段（那段会被 `npm view` 的
 README 元数据带回，供老版本在「发现新版本」时展示新版更新内容）。
 
+## v0.1.69（2026-09-25）
+
+- **智能体目录新增三款 CLI（第三批接入）**：Google **Gemini CLI**（每日 1000 次免费请求额度，凭据走个人 Google 账号登录）、腾讯云 **CodeBuddy CLI**（`cbc`，claude 兼容系）、字节开源 **Trae Agent**（`trae-cli`，PyPI 无包故走 uv 从 GitHub 直装）。三者均支持目录管理、一键安装/升级与无头编排（走各 CLI 自带登录态）；因其凭据环境变量与 CodeBee 的两种 wire 协议不对应，暂不支持「CLI 绑定」链——配置了也会被明确拦截提示，不会出现「链显示活着、实际走 CLI 默认模型」的假绑定。
+- 美团侧经调研无官方 CLI 产品（LongCat 是模型家族+CatPaw 平台）；LongCat-2.0 模型可经支持自定义 provider 的现有 CLI 作为上游接入，无需新条目。
+
+## v0.1.68（2026-09-25）
+
+- **小说任务初稿不再「边写边自我审查」**：起草契约新增「成文分三步」——先把不设限的情节/画面/台词念头快速倾倒成素材清单（狂人），再挑主线组织结构（建筑师），最后按结构成文（木匠）；初稿期不做质量审判，质量把关仍由既有评审链承担。此前契约两条全是收敛导向，发散步骤缺失，点子容易在起草半路被掐死。
+- **商务邮件回复不再漏答对方的问题**：邮件契约新增线程级交付规则——回复往来邮件时逐条回应对方提出的每个问题与请求（可用清单），不漏问、不回避；行动项落到具体动作+负责人+截止时间。此前只有我方发件视角的请求规则，缺收件回复视角。
+- **README 任务类型清单过时修正**：「15 种」→17 种（补缺陷复盘/标书编制）、扫榜选材平台描述从两平台更正为七猫/番茄/起点/纵横四平台——24 班扩源与 22/25 班加类型后文档未跟上。
+
 ## v0.1.67（2026-09-24）
 
 - **连载任务超时不再要人守着手动重试**：「任务总时限已到」此前是死终态——总时限默认 1 小时，供应商只剩慢链时一批十二章天然跑不完，用户只能反复点重试（2026-09-24 戍边骑奴 9-20 案）。现在超时的连载任务与失败一样自动续跑（继承已完成章、延迟 5 分钟退避、次数上限照旧）；同因止损对超时做了进度感知——错误签名恒为同一句，但本轮比上轮多过审了章就不算「退避没换来结果」，两轮一章未进才止损。

package/README.md

@@ -10,7 +10,8 @@
 
 **AI 是引擎，你的经验是方向盘。** CodeBee 为你指挥一支跨厂商的执笔/编码小队：
 统一调度本机已装的 AI 编码 CLI（Codex CLI、Claude Code、Qwen Code、OpenCode、Aider、
-Kimi Code、MiMo Code、Grok Build、Pi、DeepSeek Harness……），提供
+Kimi Code、MiMo Code、Grok Build、Pi、DeepSeek Harness、Gemini CLI、CodeBuddy CLI、
+Trae Agent……），提供
 **目标 → 自动拆解 → 智能路由 → 执行 → 客观验证 → 跨厂商评审 → 自动修复/换将 → 汇总报告**
 的完整闭环。你不在时它们自动推进、自我打磨；需要你拍板的地方——质量闸门、任务分支的
 采纳与丢弃——它们会亮起「待裁决」等你，绝不静默替你决定。
@@ -29,6 +30,16 @@ Kimi Code、MiMo Code、Grok Build、Pi、DeepSeek Harness……），提供
 
 
 
+---
+
+<!-- relnotes:start -->
+### 最新版更新内容（v0.1.69）
+
+- 智能体目录新增三款 CLI：Google **Gemini CLI**、腾讯云 **CodeBuddy CLI**（`cbc`）、字节开源 **Trae Agent**（`trae-cli`）——目录页一键安装/升级与无头编排，凭据走各 CLI 自带登录态
+- 防假绑定：这三款暂不支持「CLI 绑定」链（走本机凭据），配置了供应商链会被明确拦截提示，不再出现「链显示活着、实际走 CLI 默认模型」
+<!-- relnotes:end -->
+
+
 ---
 
 ## 功能速览
@@ -121,9 +132,9 @@ OpenCode / Continue / Cursor / Trae 十种工具的配置，一次带入全部
 
 ### 更多内置能力
 
-- **15 种任务类型**：直接执行、代码、小说、连载小说、自媒体文章、短视频脚本、
-  文档、翻译、扫榜选材、调研报告、演讲稿、工作汇报、商务邮件、技术方案、简历；全部支持自定义流程
-  （引擎 / 评审维度 / 阈值 / 轮数 / 提示词覆盖）；
+- **17 种任务类型**：直接执行、代码、小说、连载小说、自媒体文章、短视频脚本、
+  文档、翻译、扫榜选材、缺陷复盘、调研报告、演讲稿、工作汇报、商务邮件、技术方案、简历、标书编制；
+  全部支持自定义流程（引擎 / 评审维度 / 阈值 / 轮数 / 提示词覆盖）；
 - **质量闸门与裁决**：评审失败≠0 分照过、降级大纲不开写、超时但已落盘的稿件照常
   送评审；需要人拍板的事项进「待裁决」队列（徽章 + 提示音），`tools/bee.py`
   命令行不开浏览器也能过裁决；
@@ -228,7 +239,7 @@ python tools\bee.py discard <task>    :: 否决——删除任务分支（需输
 ## 任务类型与自定义流程
 
 主表单的「类型」下拉即流程列表，点「管理」可新增/编辑自定义流程（引擎、评审维度、
-阈值、轮数、产出文件名、起草/评审提示词覆盖）。内置 15 种；禅道工单是自动转成
+阈值、轮数、产出文件名、起草/评审提示词覆盖）。内置 17 种；禅道工单是自动转成
 `code` 修复任务的集成入口，不另占菜单类型：
 
 | 类型 | 引擎 | 流程 |
@@ -241,10 +252,12 @@ python tools\bee.py discard <task>    :: 否决——删除任务分支（需输
 | 🎬 短视频脚本 | review | 画面 + 口播 + 字幕/音效 → 多维评审 → 修订 → 发布门禁 |
 | 📝 文档 | review | 起草 → 多维评审（准确性/结构/表达/实用）→ 修订 → 门禁 |
 | 🌐 翻译 | review | 起草 → 多维评审（忠实度/流畅度/术语/风格）→ 修订 → 门禁 |
-| 📈 扫榜选材 | direct | 抓七猫 + 番茄公开榜单 → 跨平台题材/人设/切入点洞察 |
+| 📈 扫榜选材 | direct | 抓七猫/番茄/起点/纵横四平台榜单 → 跨平台题材/人设/切入点洞察 |
+| 🕓 缺陷复盘 | direct | 读禅道/Jira 导出 → 产品/开发/测试三视角复盘报告 |
 | 🔍 调研报告 | review | 起草 → 多维评审（全面性/深度/论据/结论）→ 修订 → 门禁 |
 | 🎤 演讲稿 | review | 起草 → 多维评审（主题/结构/感染力/语言）→ 修订 → 门禁 |
 | 📅 工作汇报 / ✉️ 商务邮件 / 📋 技术方案 / 📄 简历 | review | 各自专属角色、交付约束与评审维度 |
+| 📑 标书编制 | review | 招标文件对齐评分点 → 多维评审（应答/合规/针对性）→ 修订 → 门禁 |
 
 三种引擎：
 - **direct 引擎**：单智能体直接执行目标，保留会话上下文，适合问答、探索和无需评审链的快捷任务；
@@ -425,7 +438,8 @@ CLI 默认冒烟、供应商可达性、wire 适配、单模型生成、绑定
   CodeBee 编排运行时用哪个供应商 / 模型统一在「CLI 绑定」页配置；
 - **编排开关**：决定哪些 CLI 参与任务路由。
 
-Kimi Code / MiMo Code / Grok Build / Pi / DeepSeek Harness 的安装命令已内置（均取自
+Kimi Code / MiMo Code / Grok Build / Pi / DeepSeek Harness / Gemini CLI / CodeBuddy CLI /
+Trae Agent 的安装命令已内置（均取自
 各工具官方渠道）。若某个条目的安装命令缺失，直接编辑 `data/catalog.json` 补上
 `install` 字段保存后点"重新加载 catalog"即可；点"恢复默认 catalog"可回滚。
 

package/app/core/catalog.py

@@ -172,6 +172,45 @@ DEFAULT_CATALOG = [
         "upgrade": "npm install -g @deepseek-ai/dsh@latest",
         "default_enabled": False,
     },
+    {
+        "id": "gemini-cli", "name": "Gemini CLI", "cli_group": "installable",
+        "note": "Google 官方编码 CLI；无头 gemini -p \"提示词\"；默认模型在 "
+                "~/.gemini/settings.json 顶层 model；凭据走个人 Google 账号 OAuth "
+                "（浏览器登录，免费额度）或 GOOGLE_API_KEY/GEMINI_API_KEY 环境变量",
+        "detect": {"cli": "gemini"},
+        "orch": {"kind": "generic", "command": "gemini", "argv_template": ["-p", "{prompt}"]},
+        "config": {"path": "~/.gemini/settings.json", "format": "json", "model_key": "model"},
+        "install": "npm install -g @google/gemini-cli",
+        "upgrade": "npm install -g @google/gemini-cli@latest",
+        "default_enabled": False,
+    },
+    {
+        "id": "codebuddy", "name": "CodeBuddy CLI", "cli_group": "installable",
+        "note": "腾讯云 CodeBuddy Code（claude 兼容系，需 Node ≥18.20）；可执行名 cbc"
+                "（codebuddy 是全名别名）；无头 cbc -p \"提示词\"；配置在 "
+                "~/.codebuddy/settings.json（claude 形态三级作用域，模型走顶层 model 键）",
+        "detect": {"cli": "cbc"},
+        "orch": {"kind": "generic", "command": "cbc", "argv_template": ["-p", "{prompt}"]},
+        "config": {"path": "~/.codebuddy/settings.json", "format": "json", "model_key": "model"},
+        "install": "npm install -g @tencent-ai/codebuddy-code",
+        "upgrade": "npm install -g @tencent-ai/codebuddy-code@latest",
+        "default_enabled": False,
+    },
+    {
+        "id": "trae-agent", "name": "Trae Agent", "cli_group": "installable",
+        "note": "字节跳动开源 trae-agent；可执行名 trae-cli；PyPI 无包，uv tool 从 "
+                "GitHub 直装（Python ≥3.12）；无头 trae-cli run \"提示词\"（一次性任务"
+                "形态）；配置 trae_config.yaml 默认找当前工作目录（TRAE_CONFIG_FILE "
+                "可指定），默认模型是 agents.trae_agent.model 指向 models 表别名的两层"
+                "引用，CodeBee 暂不托管其模型落盘——绑定模型请在 trae_config.yaml 自配",
+        "detect": {"cli": "trae-cli"},
+        "orch": {"kind": "generic", "command": "trae-cli", "argv_template": ["run", "{prompt}"]},
+        "config": {"path": "~/.trae/trae_config.yaml", "format": None, "model_key": None},
+        "install": "uv tool install --python 3.12 git+https://github.com/bytedance/trae-agent",
+        "upgrade": "uv tool install --force --python 3.12 git+https://github.com/bytedance/trae-agent",
+        "uninstall": "uv tool uninstall trae-agent",
+        "default_enabled": False,
+    },
 ]
 
 _LOCK = threading.RLock()
@@ -195,6 +234,9 @@ LAUNCH_PATCH = {    "codex-cli": {"kind": "console", "command": "codex"},
     "mimo-code": {"kind": "console", "command": "mimo"},
     "grok-build": {"kind": "console", "command": "grok"},
     "pi": {"kind": "console", "command": "pi"},
+    "gemini-cli": {"kind": "console", "command": "gemini"},
+    "codebuddy": {"kind": "console", "command": "cbc"},
+    "trae-agent": {"kind": "console", "command": "trae-cli"},
     # dsh 自带浏览器 UI（dsh web）；端口固定以便「已在运行就直接开页面」的复用
     # 判断，18790 避开 CodeBee 自身与常用测试端口。--no-open 关掉 dsh 自己开浏览器
     # 的行为（否则它会和 CodeBee 就绪后各开一个标签页）

package/app/core/dispatch_log.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import hashlib
 import threading
 import time
 
@@ -40,7 +41,7 @@ def _candidate(row):
 def record_event(run_id="", task_id="", task_type="", difficulty="", role="",
                  phase="selected", selected="", participants=(), candidates=(),
                  fallback=(), selection_reason="", result="", verify_pass=None,
-                 review_pass=None):
+                 review_pass=None, trace_id="", span_id="", parent_event_id=""):
     """追加一条事件；仅保存路由元数据，不保存正文、提示词、密钥或文件内容。"""
     try:
         day = time.strftime("%Y-%m-%d")
@@ -57,6 +58,20 @@ def record_event(run_id="", task_id="", task_type="", difficulty="", role="",
             "selection_reason": _text(selection_reason, 400),
             "result": _text(result, 32),
         }
+        # Trace identifiers are routing metadata only.  They deliberately do
+        # not carry prompt/output contents and remain optional for old callers.
+        if run_id:
+            from . import tracing
+            event["trace_id"] = _text(trace_id or tracing.trace_id(run_id), 64)
+        if span_id:
+            event["span_id"] = _text(span_id, 32)
+        if parent_event_id:
+            event["parent_event_id"] = _text(parent_event_id, 64)
+        event["event_id"] = hashlib.sha256(
+            ("%s|%s|%s|%s|%s|%s" % (
+                time.time_ns(), run_id, phase, role, selected, result
+            )).encode("utf-8")
+        ).hexdigest()[:24]
         if verify_pass is not None:
             event["verify_pass"] = bool(verify_pass)
         if review_pass is not None:

package/app/core/flows.py

@@ -78,7 +78,7 @@ BUILTIN_FLOWS = [
     {"id": "rank_scan", "name": "扫榜选材", "icon": "i-chart", "engine": "direct", "builtin": True,
      "goal_hint": "想写哪个方向（一句话，可留空默认分析总榜热门题材）",
      "note": "抓取七猫/番茄/起点/纵横四平台排行榜公开数据 → AI 提炼跨平台热门题材/人设/差异化切入点（快档直出报告）"},
-    {"id": "defect_retro", "name": "缺陷复盘", "icon": "i-clipboard", "engine": "direct", "builtin": True,
+    {"id": "defect_retro", "name": "缺陷复盘", "icon": "i-history", "engine": "direct", "builtin": True,
      "goal_hint": "复盘哪个版本/时间段的缺陷（建议附带禅道或 Jira 导出 CSV）",
      "note": "读取附带的缺陷导出数据 → AI 输出产品/开发/测试三视角复盘报告：整体画像、根因聚类、漏测分析、改进动作（快档直出报告）"},
     {"id": "research", "name": "调研报告", "icon": "i-file-search", "engine": "review", "builtin": True,
@@ -117,7 +117,7 @@ BUILTIN_FLOWS = [
      "threshold": 7.0, "rounds": 2,
      "goal_hint": "目标岗位 + 个人经历（可贴旧简历附件），几年经验投什么职级",
      "note": "简历优化/定制：起草 → 多维评审 → 修订循环 → 发布门禁"},
-    {"id": "bid_doc", "name": "标书编制", "icon": "i-file-search", "engine": "review", "builtin": True,
+    {"id": "bid_doc", "name": "标书编制", "icon": "i-tasks", "engine": "review", "builtin": True,
      "manuscript": "bid.md",
      "rubric": ["应答完整性", "合规符合度", "方案针对性", "评分点覆盖", "商务清晰度"],
      "threshold": 7.5, "rounds": 2,

package/app/core/jobs.py

@@ -186,6 +186,21 @@ def _try_start_once(job):
         CANCELS.pop(run_id, None)
         return False
 
+    # A queued run may have spent minutes waiting for a slot or resume timer.
+    # Only the successful slot owner starts the execution clock.  The CAS
+    # prevents a cancellation between slot claim and launch from being revived.
+    if current and current.get("task_id"):
+        task = store.get_task(current["task_id"])
+        if task:
+            budget_s = store._task_timeout_s(current.get("timeout_budget_s") or
+                                             task.get("timeout_s"))
+            if store.update_run(run_id, expected_status="running",
+                                timeout_budget_s=budget_s,
+                                deadline_at=time.time() + budget_s) is None:
+                _release_slot(job)
+                CANCELS.pop(run_id, None)
+                raise DuplicateJobError("运行 %s 已在启动前结束" % run_id)
+
     try:
         threading.Thread(target=_run_job, args=(dict(job),),
                          name="job-direct-%d" % seq, daemon=True).start()
@@ -324,16 +339,6 @@ def _requeue_await_slot(job, waits_left=None):
         # 带着全新重试额度重新入队，封顶永远打不中）。仍满载则续下一拍。
         with _timer_lock:
             _deferred_timers.pop(run_id, None)
-        try:
-            from . import store
-            run = store.get_run(run_id) or {}
-            deadline_at = run.get("deadline_at")
-            if deadline_at is not None and float(deadline_at) <= time.time():
-                store.update_run(run_id, expected_status="queued", status="timeout",
-                                 ended_at=_now(), error="任务总时限已到（排队等待期间）")
-                return
-        except (TypeError, ValueError, AttributeError):
-            pass
         try:
             started = _try_start_once(job)
         except DuplicateJobError:
@@ -577,9 +582,8 @@ def _maybe_auto_resume(run_id):
 
     真实长篇单次运行常因供应商拥堵超时中断；这里在执行线程收尾时自动续跑一次
     续跑（store.retry_task 会带上 inherit），让整个流程真正无人值守。
-    2026-09-24 戍边骑奴 9-20 案：「任务总时限已到」终态此前不续跑，而总时限
-    预算默认 1 小时、慢链天 12 章天然跑不完，用户只能守着手动点重试——超时
-    恰恰是最该自动接着写的一种中断，纳入。
+    2026-09-24 戍边骑奴 9-20 案：「任务总时限已到」终态此前不续跑，
+    长篇在慢链天仍可能超过单次预算；超时也是应自动接着写的一种中断。
     同因连撞止损：续跑副本再失败时与本次失败的错误签名比对（2026-09-18
     重写任务 kimi 403 欠费案），一模一样说明退避没换来不同结果，直接落
     终态写明死因，不再烧剩余的退避次数。超时例外：错误签名恒为同一句

package/app/core/knowledge.py

@@ -154,6 +154,13 @@ def upsert_entry(scope, title, body, tags=None, source="", source_file="",
         if hit is not None:
             it = hit
             it["seen"] = int(it.get("seen") or 1) + 1
+            # 合并不吞变体标题（与教训库同款记忆卫生）：近似题吸收留痕——
+            # 溯源可见、变体措辞的后续检索有据；去重+封顶 8。
+            if title != str(it.get("title") or ""):
+                mt = it.setdefault("merged_titles", [])
+                if title not in mt:
+                    mt.append(title)
+                    del mt[:-8]
             old_body = str(it.get("body") or "")
             old_rev = it.get("revision_id") or ""
             new_rev = revisions.make_revision("kbrev", body, source=source)

package/app/core/modelhub.py

@@ -2419,9 +2419,19 @@ def bindable_protocols(agent_kind_or_id):
         return ("openai",)
     if agent_kind_or_id in ("claude-code", "claude"):
         return ("anthropic",)
+    if agent_kind_or_id in _LOCAL_CRED_ONLY_TARGETS:
+        return ()
     return tuple(_BINDABLE_PROTOCOLS)
 
 
+# 只吃 CLI 本机凭据、不吃 Tutti 两种 wire env 的目标：gemini 本尊只认
+# GOOGLE_API_KEY/GEMINI_API_KEY（Google AI 协议，Tutti 无此协议面）；codebuddy
+# （claude 兼容系）与 trae-agent 的凭据 env 语义未实机验证。注入它们不认的 env
+# 只会造出「链显示活着、实际走 CLI 默认模型」的静默假绑定——宁可返回空协议集，
+# 链上条目全跳过、回落 CLI 本机登录态（recommend_binding 同口径，返回 None）。
+_LOCAL_CRED_ONLY_TARGETS = ("gemini-cli", "codebuddy", "trae-agent")
+
+
 def binding_dead_msg(cli_id):
     """死链失败/告警文案（pipeline 死链闸门与本模块 sync 共用）：说明为什么
     不回落本机默认 + 该 CLI 需要什么协议的供应商。"""
@@ -2429,7 +2439,10 @@ def binding_dead_msg(cli_id):
         protos = bindable_protocols(cli_id)
     except Exception:
         protos = ()
-    hint = ("该 CLI 仅接受 %s 协议的已启用供应商；" % "、".join(protos)) if protos else ""
+    if not protos:
+        return ("该 CLI 暂不支持绑定链（凭据注入尚未适配，使用 CLI 本机登录态与"
+                "默认模型）；请勿为其配置供应商链")
+    hint = "该 CLI 仅接受 %s 协议的已启用供应商；" % "、".join(protos)
     return ("绑定链全部失效（链上供应商已停用/删除/无密钥，或模型已停用），"
             "本步判失败、不回落 CLI 本机默认——%s请在「模型调度（可选）」页为该 CLI 指定已启用的供应商" % hint)
 
@@ -2442,6 +2455,12 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
     → 整体回落 CLI 默认（None）。纯链条目（无供应商）不注入 env，只传 -m。
     难度路由只在无显式链时生效。
     """
+    # Local-credential-only CLIs must never expose a binding, including legacy
+    # model-only entries that have no provider_id.  The generic runner cannot
+    # inject those model names, so returning a partial chain would make the UI
+    # report a bound model while the CLI silently uses its own default.
+    if agent_kind_or_id in _LOCAL_CRED_ONLY_TARGETS:
+        return None
     b = _binding_for(agent_kind_or_id)
     chain = _binding_chain(b)
     provs = {p.get("id"): p for p in providers()}

package/app/core/pipeline.py

@@ -829,6 +829,7 @@ __CONTEXT__
   不要自造评分标准或质量闸门；超出任务目标的「顺手加固」一律不做。
   真实风险照样要找：发现就写进总结，由人决定要不要修。
 - 完成后只用 3-5 句话总结你改了什么、为什么。
+- 交付物从简：回复不写开场白、不复述任务、不堆与改动无关的解释——代码、说明、总结直接给干货（借鉴 claude-token-efficient：输出 token 也是真金白银）。
 __VERIFY_HINT__"""
 
 CODE_FIX_PROMPT = """你是一名高级工程师。你之前的实现没有通过验收，请在当前工作目录中直接修复（直接修改/创建文件）。创建/写入的文件一律以 UTF-8 编码保存（PowerShell 显式加 -Encoding UTF8，禁止依赖系统默认编码）。
@@ -2088,6 +2089,10 @@ CONTENT_DELIVERY_CONTRACTS = {
     "novel": ("小说作者", [
         "遵守用户给定的题材、篇幅、视角和风格；未给出的核心设定不要擅自扩张。",
         "用场景、行动和对话推进冲突，人物动机与前后因果保持一致。",
+        # Madman-Architect-Carpenter 写作框架（writing-with-agents 借鉴；Judge=评审链已有）：
+        # 先发散倾倒念头再组织结构成文，不要边写边自我审查把点子掐死在半路
+        "成文分三步：先把不设限的情节/画面/台词念头快速倾倒成素材清单，再挑出主线组织成"
+        "结构，最后按结构成文——初稿期不做质量审判。",
     ]),
     "article": ("平台内容主编", [
         "标题、开头钩子、正文层级和结尾行动建议要适配目标平台与读者。",
@@ -2129,6 +2134,9 @@ CONTENT_DELIVERY_CONTRACTS = {
         # sepia 分场合规则（PR 回复体裁）：先答再铺陈；篇幅与利害成正比
         "第一句/第一段先给结论或答复（对方要做什么、答应还是不答应），再给必要背景。",
         "请求具体到动作与截止时间；篇幅与事情轻重成正比，删掉礼节性空话与自我表扬。",
+        # agentic-inbox 借鉴（线程级交付契约）：回复是对话不是独白
+        "回复往来邮件时逐条回应对方提出的每个问题与请求（可用清单），不漏问、不回避；"
+        "行动项落到具体动作+负责人+截止时间。",
     ]),
     "tech_proposal": ("解决方案架构师", [
         "覆盖现状与目标、约束、候选方案对比、推荐架构、实施阶段、风险与回滚、验收指标。",
@@ -2167,7 +2175,9 @@ def _content_contract(task):
     return "\n\n## 本类型交付约束\n" + "\n".join("- " + item for item in spec[1])
 
 # 调研报告类稿件的追加要求（借鉴 gpt-researcher 迭代深研）：有网络/读文件工具时
-# 多源交叉验证，单源结论降权——调研的可信度来自证据链而非文采
+# 多源交叉验证，单源结论降权——调研的可信度来自证据链而非文采。
+# 来源冲突裁决借鉴 deepresearch-agent 记忆层矛盾检测（Majority/Source-Weight 消解）；
+# 子问题缺口补查借鉴 dzhng/deep-research 迭代循环
 RESEARCH_APPENDIX = """
 
 ## 调研要求（证据链）
@@ -2175,6 +2185,11 @@ RESEARCH_APPENDIX = """
   单源信息要标注「仅单一来源」。
 - 引用来源在文中用行内链接或脚注标明（域名即可，不编造 URL）。
 - 区分「事实」与「观点」：数据/时间/版本号给来源，预测/评价标明是分析。
+- 来源冲突显式裁决：同一事实多个来源说法不一致时，写明分歧点与各方依据，给出
+  倾向判断和理由（多数来源一致取多数，权威差异按来源可信度加权）——不各说一半，
+  也不悄悄只取其一。
+- 缺口驱动补查：起草前先列出报告要回答的子问题清单，逐个核对证据是否到位；
+  没找到答案的子问题明确标注「证据不足」，不用泛泛而谈填空。
 - 结构硬性要求：报告第一段必须是「**核心结论**」三行以内的要点摘要（结论先行），
   之后才展开分层论证 → 风险与局限（说明哪些结论证据不足）。"""
 

package/app/core/planner.py

@@ -140,6 +140,8 @@ hard 也不做任务没要的防御性扩展子任务（缓存/重试/监控/通
 拆解之前先用你的读文件/搜索工具**实际查看工作目录**，找到目标相关的真实文件与函数，再据此拆解。
 detail 必须点名真实存在的文件路径；files 列出该子任务会改动的文件（新建的写目标路径）。
 **没探索过就不要凭想象编路径**——计划的可执行性取决于它对真实代码库的贴合度。
+detail 的清晰度按「初级工程师测试」校验：假设执行者没有项目上下文、不做隐含判断，
+只读 detail 就能照做不跑偏（借鉴 superpowers）。
 若工作目录为空（全新项目），files 写计划新建的文件路径。
 
 ## 开发目标

package/app/core/publish/flows-qimao-calibrated.json

@@ -1,5 +1,5 @@
 {
- "_note": "七猫真机校准（2026-09-19 凌晨定稿）：建书=book-manage「新建小说」→站点弹层(click_match+确认)→information 表单(fill_label/radio/级联分类/tags 四组各1-3个+确定/主角名平铺/简介)；书名仅允许，：！？中文标点（·被拦）。发章=编辑器填好后「立即发布」落草稿箱（未签约书限制）→草稿行「立即发布」→「更正序号去发布」→「确认发布」三层弹窗→章节待审核。正文下限 1000 字（min_chapter_chars）。book-upload?id=<书id> 直达编辑器。；2026-09-24 加固：二级分类选完 settle 1s 再点「添加标签」（下拉关闭动画吞点击致标签弹层未开、组名切换失败案）",
+ "_note": "七猫真机校准（2026-09-19 凌晨定稿）：建书=book-manage「新建小说」→站点弹层(click_match+确认)→information 表单(fill_label/radio/级联分类/tags 四组各1-3个+确定/主角名平铺/简介)；书名仅允许，：！？中文标点（·被拦）。发章=编辑器填好后「立即发布」落草稿箱（未签约书限制）→草稿行「立即发布」→「更正序号去发布」→「确认发布」三层弹窗→章节待审核。正文下限 1000 字（min_chapter_chars）。book-upload?id=<书id> 直达编辑器。；2026-09-24 加固：二级分类选完 settle 1s 再点「添加标签」（下拉关闭动画吞点击致标签弹层未开、组名切换失败案）；2026-09-24 夜修：平台编辑器「立即发布」变为弹重型确认框（点后页面假死、章节未提交、草稿箱亦空——旧「立即发布落草稿箱」语义过时），改点「存草稿」再走草稿箱三层发布（草稿行立即发布→更正序号→确认发布，22:47 实证成功路径）",
  "probe_form": [
   {
    "do": "navigate",
@@ -180,9 +180,13 @@
   },
   {
    "do": "click_real",
-   "text": "立即发布",
+   "text": "存草稿",
    "tries": 25
   },
+  {
+   "do": "sleep",
+   "s": 2
+  },
   {
    "do": "navigate",
    "url": "about:blank"
@@ -234,4 +238,4 @@
    ]
   }
  ]
-}
+}

package/app/core/runner.py

@@ -2030,16 +2030,18 @@ def as_scores(gj):
 def extract_scores_from_text(text):
     """评审解析第四道网（借鉴 BAML 的宽容提取）：模型把分数写成散文键值对
     完全不出 JSON 时（2026-09-18 真实案例：kimi 正文提分），从文本直接抓
-    「维度：N 分」模式。返回 scores dict 或 {}。"""
+    「维度：N 分」模式。返回 scores dict 或 {}。
+    2026-09-25 批1 补：分隔符不止冒号——短横线「正确性 - 9 分」、全角等号
+    「＝」、箭头「→」三种真实输出形态此前全漏，格式错被误判质量差白烧修复轮。"""
     if not text:
         return {}
     scores = {}
     for m in re.finditer(
-            r"[\u4e00-\u9fa5A-Za-z][\u4e00-\u9fa5A-Za-z0-9 ]{0,11}"
-            r"[:：]\s*(\d{1,2}(?:\.\d)?)\s*分?", text):
-        dim = m.group(0).rsplit(":", 1)[0].rsplit("：", 1)[0].strip()
+            r"([\u4e00-\u9fa5A-Za-z][\u4e00-\u9fa5A-Za-z0-9 ]{0,11})"
+            r"\s*[:：\-＝=→]\s*(\d{1,2}(?:\.\d)?)\s*分?", text):
+        dim = m.group(1).strip()
         try:
-            val = float(m.group(1))
+            val = float(m.group(2))
         except ValueError:
             continue
         if not dim or dim in scores or not (1.0 <= val <= 10.0):

package/app/core/skill_scan.py

@@ -37,6 +37,14 @@ _PATTERNS = [
     (r"\bcrontab\b|schtasks|LaunchAgents|CurrentVersion\\Run|StartupItems",
      "持久化", "注册定时任务/自启动项（持久化驻留特征）"),
     (r"stratum\+tcp|xmrig|cryptonight", "可疑意图", "加密货币挖矿特征"),
+    # 云元数据/内网端点探测（批4 治理 09-25：169.254.169.254 窃取云凭据是
+    # 真实攻击面，此前零覆盖）。只认高信号形态：链路本地元数据地址/云元数据
+    # 主机名，或私网地址搭配凭据路径——本地起服务提 127.0.0.1:3000 不误报。
+    (r"169\.254\.169\.254|169\.254\.\d{1,3}\.\d{1,3}|metadata\.google\.internal",
+     "可疑意图", "触碰云元数据端点（窃取云凭据特征）"),
+    (r"(?:192\.168\.\d{1,3}\.\d{1,3}|10\.\d{1,3}\.\d{1,3}\.\d{1,3})[^。\n]{0,40}"
+     r"(?:meta-data|credentials|secret|token|\.ssh)",
+     "可疑意图", "私网地址搭配凭据路径（内网探测特征）"),
     # 敏感信息读取
     (r"os\.environ|process\.env|getenv", "环境读取", "读取环境变量（可能带走密钥）"),
     (r"\.ssh/|\.aws/|\.npmrc|\.gitconfig|credentials|\.env\b", "敏感文件", "触碰凭据/密钥文件路径"),

package/app/core/skills.py

@@ -410,6 +410,14 @@ def upsert_lesson(scope, title, content, source="", category=None, dim=None):
             it.update({k: new_rev[k] for k in ("revision_id", "content_sha256")})
             it["seen"] = int(it.get("seen") or 1) + 1
             it["updated_at"] = _now()
+            # 合并不吞变体标题（批2 记忆卫生）：近似题被吸收时留痕——溯源可见，
+            # 且后续按变体措辞检索也能命中（bigram 检索只看 survivor 自己的题）。
+            # 去重+封顶 8 条，防止长跑自动化把字段撑成第二正文。
+            if title != str(it.get("title") or ""):
+                mt = it.setdefault("merged_titles", [])
+                if title not in mt:
+                    mt.append(title)
+                    del mt[:-8]
             # 合并时不降级已有分类：除非本次归到了明确类别，或该条原本没有分类
             if cat != LESSON_UNCATEGORIZED or not it.get("category"):
                 it["category"] = cat
@@ -599,7 +607,13 @@ def block_for(task, scope_override=None, *, stable_order=False, run_id=None):
         for x in lessons:
             # 编号可见：复盘官据此点名「哪条已沉淀教训没防住本次问题」，
             # 归因才能落到单条而不是整批（见 note_outcome）。
-            lines.append("- [%s] **%s**：%s" % (x["id"], x["title"], x["content"]))
+            # karma 标注（批5 对称补齐）：won≥2 才标——1 次可能是巧合，噪音为零；
+            # 与知识库［有据］置信标同构，模型可按实证强度校准采信。
+            # run 内稳定：won 只在 run 收尾回写，任务中途字节不变。
+            karma = ""
+            if int(x.get("won") or 0) >= 2:
+                karma = "（已验证有效 %d 次）" % int(x.get("won") or 0)
+            lines.append("- [%s] **%s**%s：%s" % (x["id"], x["title"], karma, x["content"]))
             used.append(x["id"])
             lesson_ids.append(x["id"])
         lesson_part = ("### 【本项目已沉淀的教训（历史评审反复出现，务必规避；方括号内为教训编号）】\n"

package/app/core/store.py

@@ -18,7 +18,7 @@ import threading
 import time
 from pathlib import Path
 
-from . import artifacts, paths, runner, volumes
+from . import artifacts, paths, runner, tracing, volumes
 
 LOCK = threading.RLock()
 _TASKS = {}
@@ -33,6 +33,9 @@ LIVE_TEXT_MAX = 20000   # 单步骤实时思考/正文的保留上限（与 buil
 DEFAULT_TASK_TIMEOUT_S = 3600
 MIN_TASK_TIMEOUT_S = 1
 MAX_TASK_TIMEOUT_S = 7 * 24 * 3600
+REVIEW_TASK_TIMEOUT_S = 7200
+LONG_TASK_TIMEOUT_S = 14400
+SERIAL_EXTRA_CHAPTER_S = 1800
 
 # ---------------------------------------------------------------- 状态版本（SSE 事件驱动）
 # 任何落盘写都算状态变化：SSE 连接等版本号变化才构建/推送全量状态，
@@ -95,6 +98,26 @@ def _task_timeout_s(value=None):
     return max(MIN_TASK_TIMEOUT_S, min(MAX_TASK_TIMEOUT_S, seconds))
 
 
+def _default_timeout_s(task):
+    """Choose a bounded default from the amount of work, not one hour for all."""
+    env_value = os.environ.get("TUTTI_TASK_TIMEOUT_S")
+    if env_value not in (None, ""):
+        return _task_timeout_s(env_value)
+    serial = task.get("serial")
+    if isinstance(serial, dict) and serial.get("chapters"):
+        try:
+            chapters = max(1, min(20, int(serial["chapters"])))
+        except (TypeError, ValueError):
+            chapters = 8
+        return min(MAX_TASK_TIMEOUT_S,
+                   LONG_TASK_TIMEOUT_S + max(0, chapters - 8) * SERIAL_EXTRA_CHAPTER_S)
+    if task.get("engine") == "code":
+        return LONG_TASK_TIMEOUT_S
+    if task.get("engine") == "review":
+        return REVIEW_TASK_TIMEOUT_S
+    return DEFAULT_TASK_TIMEOUT_S
+
+
 # ---------------------------------------------------------------- 任务
 
 def create_task(payload):
@@ -159,7 +182,6 @@ def create_task(payload):
     }
     thinking = str(payload.get("thinking") or "standard").strip().lower()
     task["thinking"] = thinking if thinking in ("auto", "low", "standard", "high") else "auto"
-    task["timeout_s"] = _task_timeout_s(payload.get("timeout_s"))
     # 流程修订出处（借鉴 WorkDSH ADR-0010）：创建时钉住当时流程定义的指纹。
     # 固化参数已保证「改流程不影响本任务」，digest 再补上可对账的一面——
     # 续跑/重试时若流程已改，flows.flow_drift 能给出明确诊断而非静默换新。
@@ -293,6 +315,9 @@ def create_task(payload):
                 if vper:
                     s["volume_chapters"] = vper
                 task["serial"] = s
+    raw_timeout = payload.get("timeout_s")
+    task["timeout_s"] = (_task_timeout_s(raw_timeout)
+                         if raw_timeout not in (None, "") else _default_timeout_s(task))
     critics = payload.get("critics")
     if isinstance(critics, list) and critics:
         task["critics"] = [str(c) for c in critics]
@@ -717,9 +742,17 @@ def create_run(kind, title, task_id=None, entry_id=None, op=None):
         "cost_usd": 0.0, "tokens": 0, "error": "",
         "verdict": None, "summary": "",
     }
+    # Persist trace identity at run creation so replay remains stable across
+    # process restarts and legacy readers can still use the normal run shape.
+    run["trace_schema_version"] = tracing.SCHEMA_VERSION
+    run["trace_id"] = tracing.trace_id(run["id"])
+    run["root_span_id"] = tracing.root_span_id(run["id"])
     if kind == "orchestration" and task_id:
         task = get_task(task_id) or {}
-        run["deadline_at"] = time.time() + _task_timeout_s(task.get("timeout_s"))
+        run["timeout_budget_s"] = _task_timeout_s(task.get("timeout_s"))
+        # Provisional for direct callers; jobs resets it at worker claim so
+        # queued/backoff time does not shorten the actual execution budget.
+        run["deadline_at"] = time.time() + run["timeout_budget_s"]
         run["execution_snapshot"] = _execution_snapshot(task)
         try:
             eta = _RUN_ESTIMATOR(
@@ -1746,10 +1779,9 @@ def update_task_params(task_id, patch):
             if task.get("direct_agent") != av and (av or task.get("direct_agent")):
                 task["direct_agent"] = av
                 changed = True
-        # 任务总时限（秒）：建任务时写入，此后靠这里改——下次重试/续跑的
-        # create_run 会按它重新给满预算（2026-09-24 戍边骑奴案：12 章连载
-        # 默认 1 小时在慢链天跑不完，只能人工反复重试）。走 _task_timeout_s
-        # 统一钳制 [1s, 7天]，脏值回落默认；空闲时才可改（与三件套同闸）。
+        # 任务总时限（秒）：建任务时按工作量给默认值，此处支持空闲时显式改。
+        # 下次重试/续跑按新值重新给预算；已在跑的 run 保持原截止时间。
+        # 统一钳制 [1s, 7天]，脏值回落基础默认。
         raw_ts = patch.get("timeout_s")
         if raw_ts not in (None, ""):
             new_ts = _task_timeout_s(raw_ts)
@@ -1780,6 +1812,11 @@ def add_step(run_id, role, agent_id, agent_label, note="", model="", provider=""
             # 只记身份不记密钥；老数据无此键，读取一律 .get
             "provider": str(provider or "")[:120],
             "status": "running", "started_at": time.strftime("%H:%M:%S"),
+            "started_at_epoch": time.time(),
+            "trace_id": str(run.get("trace_id") or tracing.trace_id(run_id)),
+            "span_id": tracing.span_id(run_id, n),
+            "parent_span_id": str(run.get("root_span_id") or
+                                   tracing.root_span_id(run_id)),
             "ended_at": None, "duration_s": None, "exit_code": None,
             "summary": "", "log": None, "cost_usd": 0.0, "tokens": 0,
         }
@@ -1852,6 +1889,7 @@ def finish_step(run_id, n, status, summary="", exit_code=None,
             if s["n"] == n:
                 s["status"] = status
                 s["ended_at"] = time.strftime("%H:%M:%S")
+                s["ended_at_epoch"] = time.time()
                 # 步骤摘要是 CLI 文本的汇聚点（失败时=错误尾巴，成功时=智能体结论）：
                 # 落盘前统一清洗，避免 ANSI/覆写/乱码墙进 UI 与报告
                 s["summary"] = runner.clean_cli_text(summary)
@@ -1862,6 +1900,9 @@ def finish_step(run_id, n, status, summary="", exit_code=None,
                     s["model"] = str(model)[:80]
                 if duration_s is not None:
                     s["duration_s"] = round(duration_s, 1)
+                elif s.get("started_at_epoch") is not None:
+                    s["duration_s"] = round(max(
+                        0.0, s["ended_at_epoch"] - s["started_at_epoch"]), 1)
                 if output is not None:
                     # output 是智能体正文（对话气泡直读）：只剥 ANSI，不做噪声折叠
                     # ——正文里的装饰性长串是作者写的，不能替它省略

package/app/core/tracing.py

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+"""Run/step/event tracing primitives.
+
+The shape intentionally follows OpenTelemetry/OpenInference's trace -> span
+relationship without adding a third-party dependency.  It is a read model of
+the existing run and dispatch ledgers: no prompt, stdout, stderr, credentials,
+or artifact contents are copied into the trace.
+"""
+from __future__ import annotations
+
+import hashlib
+from datetime import datetime
+
+from .redact import scrub_text
+
+
+SCHEMA_VERSION = 1
+
+
+def _stable(prefix: str, *parts: object, length: int = 32) -> str:
+    raw = prefix + ":" + ":".join(str(part or "") for part in parts)
+    return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:length]
+
+
+def trace_id(run_id: object) -> str:
+    """Return a deterministic 128-bit trace id for a run."""
+    return _stable("codebee.trace", run_id, length=32)
+
+
+def root_span_id(run_id: object) -> str:
+    return _stable("codebee.root", run_id, length=16)
+
+
+def span_id(run_id: object, step_no: object) -> str:
+    return _stable("codebee.step", run_id, step_no, length=16)
+
+
+def event_id(run_id: object, event: dict) -> str:
+    """Stable event id used for deduplication during replay."""
+    return _stable(
+        "codebee.event",
+        run_id,
+        event.get("ts"),
+        event.get("phase"),
+        event.get("role"),
+        event.get("selected"),
+        event.get("result"),
+        length=24,
+    )
+
+
+def _epoch(value):
+    if value is None or isinstance(value, (int, float)):
+        return value
+    text = str(value).strip()
+    if not text:
+        return None
+    try:
+        return datetime.fromisoformat(text.replace("Z", "+00:00")).timestamp()
+    except (TypeError, ValueError, OverflowError):
+        return None
+
+
+def _duration(step: dict):
+    try:
+        value = float(step.get("duration_s"))
+        return round(max(0.0, value), 3)
+    except (TypeError, ValueError):
+        started = _epoch(step.get("started_at_epoch"))
+        ended = _epoch(step.get("ended_at_epoch"))
+        if started is not None and ended is not None:
+            return round(max(0.0, ended - started), 3)
+    return None
+
+
+def _safe_event(event: dict, run_id: str) -> dict:
+    """Keep only routing metadata from a dispatch event."""
+    allowed = (
+        "ts", "task_id", "task_type", "difficulty", "role", "phase",
+        "selected", "participants", "candidates", "fallback",
+        "selection_reason", "result", "verify_pass", "review_pass",
+        "trace_id", "span_id", "parent_event_id", "event_id",
+    )
+    item = {key: event[key] for key in allowed if key in event}
+    item.setdefault("trace_id", trace_id(run_id))
+    item.setdefault("event_id", event_id(run_id, item))
+    return _redact(item)
+
+
+def _redact(value, limit=600):
+    """Redact strings even when a legacy event predates dispatch_log scrub."""
+    if isinstance(value, dict):
+        return {key: _redact(item, 240) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_redact(item, 240) for item in value]
+    if isinstance(value, str):
+        return scrub_text(value, limit=limit)
+    return value
+
+
+def build_trace(run: dict, events=()) -> dict:
+    """Build a stable, redacted trace view from an existing run dictionary."""
+    run_id = str(run.get("id") or "")
+    tid = str(run.get("trace_id") or trace_id(run_id))
+    rid = str(run.get("root_span_id") or root_span_id(run_id))
+    spans = []
+    for step in run.get("steps") or ():
+        if not isinstance(step, dict):
+            continue
+        try:
+            number = int(step.get("n"))
+        except (TypeError, ValueError):
+            continue
+        span = {
+            "trace_id": tid,
+            "span_id": str(step.get("span_id") or span_id(run_id, number)),
+            "parent_span_id": str(step.get("parent_span_id") or rid),
+            "name": "agent.%s" % str(step.get("role") or "step")[:80],
+            "step": number,
+            "status": str(step.get("status") or "unknown"),
+            "agent": str(step.get("agent") or "")[:80],
+            "model": str(step.get("model") or "")[:120],
+            "provider": str(step.get("provider") or "")[:120],
+            "started_at": step.get("started_at_epoch"),
+            "ended_at": step.get("ended_at_epoch"),
+            "duration_s": _duration(step),
+            "tokens": step.get("tokens", 0),
+            "cost_usd": step.get("cost_usd", 0.0),
+            "exit_code": step.get("exit_code"),
+        }
+        spans.append(span)
+    safe_events = [_safe_event(item, run_id) for item in (events or ())
+                   if isinstance(item, dict)]
+    return {
+        "version": SCHEMA_VERSION,
+        "trace_id": tid,
+        "root_span_id": rid,
+        "run_id": run_id,
+        "status": str(run.get("status") or "unknown"),
+        "started_at": run.get("started_at"),
+        "ended_at": run.get("ended_at"),
+        "spans": spans,
+        "events": safe_events,
+    }

package/app/core/usage.py

@@ -478,13 +478,14 @@ def routing_stats(task_type="", role="", agent="", model="", provider="",
 
 
 def _group(records, key):
-    """按 key 聚合：{name: {calls, ok, tokens, input, output, cached, cache_rate, cost_usd, duration_s}}。"""
+    """按 key 聚合：{name: {calls, ok, tokens, input, output, cached, cache_rate, cost_usd, duration_s, saved}}。"""
     groups = {}
     for r in records:
         name = str(r.get(key) or "") or "unknown"
         g = groups.setdefault(name, {"calls": 0, "ok": 0, "tokens": 0,
                                      "input": 0, "output": 0, "cached": 0,
-                                     "cost_usd": 0.0, "duration_s": 0.0})
+                                     "cost_usd": 0.0, "duration_s": 0.0,
+                                     "saved": 0})
         g["calls"] += 1
         if r.get("ok"):
             g["ok"] += 1
@@ -492,6 +493,7 @@ def _group(records, key):
         g["input"] += _num(r, "input")
         g["output"] += _num(r, "output")
         g["cached"] += _num(r, "cached")
+        g["saved"] += _num(r, "saved")
         g["cost_usd"] = round(g["cost_usd"] + float(r.get("cost_usd") or 0.0), 4)
         g["duration_s"] = round(g["duration_s"] + float(r.get("duration_s") or 0.0), 1)
     # §07 验收指标：缓存命中率（cached / (input + cached)），与 totals.cache_rate 同口径
@@ -606,6 +608,7 @@ def summary(days=30, recent_limit=30):
                            "cached": g.get("cached", 0),
                            "cache_rate": g.get("cache_rate", 0.0),
                            "duration_s": g.get("duration_s", 0.0),
+                           "saved": g.get("saved", 0),
                            "cost_usd": round(g.get("cost_usd", 0.0), 4)})
     else:
         for d in sorted(day_groups):
@@ -616,6 +619,7 @@ def summary(days=30, recent_limit=30):
                            "cached": g.get("cached", 0),
                            "cache_rate": g.get("cache_rate", 0.0),
                            "duration_s": g.get("duration_s", 0.0),
+                           "saved": g.get("saved", 0),
                            "cost_usd": g["cost_usd"]})
 
     # 按日按模型 tokens（范围内；与 by_day 同一天序列，无数据天给空表）

package/app/main.py

@@ -47,6 +47,19 @@ MIME = {".html": "text/html; charset=utf-8", ".js": "text/javascript; charset=ut
         ".webmanifest": "application/manifest+json; charset=utf-8"}
 
 
+def _has_task_plan(wd):
+    """活计划存在性（批3）：task_plan.md 落 .codebee/ 不进成品扫描，
+    前端据此给「任务计划」入口（file 端点按名可取）。resolve+parents 守卫。"""
+    try:
+        if not wd:
+            return False
+        root = Path(wd).resolve()
+        p = (root / ".codebee" / "task_plan.md").resolve()
+        return (root in p.parents) and p.is_file()
+    except Exception:
+        return False
+
+
 def _utf8_bytes(data):
     """文本预览出口的编码守卫：字节流非合法 UTF-8 时按 GBK 解码后重编码为
     UTF-8 再发。子代理在中文 Windows 上可能把工作区文件落成 GBK，直接透传
@@ -433,13 +446,24 @@ class Handler(BaseHTTPRequestHandler):
                 # 文件变动是并行活动的噪音，不算这个任务的成品
                 if files and not store.task_step_count(run.get("task_id") or ""):
                     files = []
+                # 活计划入口（批3）：存在性单列标志
+                has_plan = _has_task_plan(wd)
                 return self._json(200, {"workdir": wd, "files": files,
-                                        "task_id": run.get("task_id") or ""})
+                                        "task_id": run.get("task_id") or "",
+                                        "has_plan": has_plan})
             m = re.match(r"^/api/runs/([^/]+)/assets$", path)
             if m:
                 if not store.get_run(m.group(1)):
                     return self._json(404, {"error": "not found"})
                 return self._json(200, {"assets": store.run_asset_refs(m.group(1))})
+            m = re.match(r"^/api/runs/([^/]+)/trace$", path)
+            if m:
+                run = store.get_run(m.group(1))
+                if not run:
+                    return self._json(404, {"error": "not found"})
+                from core import dispatch_log, tracing
+                return self._json(200, {"trace": tracing.build_trace(
+                    run, dispatch_log.replay(run_id=m.group(1), limit=200))})
             m = re.match(r"^/api/runs/([^/]+)/preview$", path)
             if m:
                 # 网页成品预览：入口 HTML + 同目录代码文件（前端渲染「预览」页签）

package/app/ui/app.js

@@ -6582,8 +6582,18 @@ function fmtSize(n) {
 /* 成品文件行（检查器「成品文件」与主栏「成果」分区共用一套标记）：
  * fc-row：文件行 + 弹窗预览按钮同行排布，避免按钮独占一行参差不齐。
  * 点文件名与点「预览」同款 artPopup 弹窗，行为一致不 surprise。 */
-function artifactsChips(runId, files, prevRun) {
-  return files.map((f) => {
+function artifactsChips(runId, files, prevRun, hasPlan) {
+  // 活计划入口（批3）：task_plan.md 不进成品扫描，存在时首行给「任务计划」
+  // 独立入口（file 端点按名可取，浏览器直接看勾选进度）。
+  const planChip = hasPlan
+    ? '<span class="fc-row">' +
+      '<a class="file-chip artifact-file-open" href="' + urlAuth("/api/runs/" + encodeURIComponent(runId) + "/file?name=" +
+      encodeURIComponent(".codebee/task_plan.md")) + '" target="_blank" rel="noopener" ' +
+      'title=".codebee/task_plan.md">' +
+      '<svg class="ico" aria-hidden="true"><use href="#i-git-branch"/></svg>' +
+      '<span class="p">' + t("任务计划") + "</span><i>plan</i></a></span>"
+    : "";
+  return planChip + files.map((f) => {
     const isTxt = FP_TXT.has(_fpExt(f.name));   // 文本/代码都有弹窗预览（按代码格式展示）
     // 与上一版对比（OpenCreator「版本化对比」借鉴）：同名文本文件在上一版
     // run 也存在时给 diff 入口；prevRun=null（无历史/清单拉取失败）静默不给
@@ -6679,9 +6689,10 @@ async function loadArtifacts(runId) {
   const mainBox = detailOwns ? $("rd-arts") : null;
   // 成果分区徽章：文件数（终态才有产出，运行中不计）；只随 detailOwns 一起刷
   const fb = detailOwns ? document.querySelector('#rd-tabs .rd-tab[data-tab="result"] .rd-badge') : null;
-  if (fb) { fb.textContent = files.length ? String(files.length) : "";
-    fb.className = "rd-badge" + (files.length ? "" : " hidden"); }
-  if (!files.length) {
+  if (fb) { const cnt = files.length + (d.has_plan ? 1 : 0);
+    fb.textContent = cnt ? String(cnt) : "";
+    fb.className = "rd-badge" + (cnt ? "" : " hidden"); }
+  if (!files.length && !d.has_plan) {
     if (box) box.innerHTML = '<span class="insp-hint">' + esc(t("本次运行没有在工作目录里产出新文件。")) + "</span>";
     if (mainBox) { mainBox.classList.add("hidden"); mainBox.innerHTML = ""; }
     return;
@@ -6701,7 +6712,7 @@ async function loadArtifacts(runId) {
       } catch (e) { /* 上一版清单不可用就不给对比 */ }
     }
   }
-  const chips = artifactsChips(runId, files, prevRun);
+  const chips = artifactsChips(runId, files, prevRun, d.has_plan);
   if (box) box.innerHTML = head + '<div class="file-chips">' + chips + "</div>";
   if (mainBox) { mainBox.classList.remove("hidden");
     mainBox.innerHTML = head + '<div class="file-chips">' + chips + "</div>"; }
@@ -9820,6 +9831,7 @@ function renderSkills() {
       'onclick="skillCatFilter(\'' + esc(x.category) + '\')" title="' + t("只看该类") + '">' + esc(t(x.category)) + "</span>" : "") +
     '<span class="tag">' + esc(x.scope === "*" ? t("通用") : x.scope) + "</span>" +
     (x.seen > 1 ? '<span class="tag">' + t("出现 ") + x.seen + t(" 次") + "</span>" : "") +
+    ((x.merged_titles || []).length ? '<span class="tag" title="' + t("被近似题合并吸收的变体标题数") + '">' + t("吸收 ") + x.merged_titles.length + t(" 个近似题") + "</span>" : "") +
     (x.hits ? '<span class="tag">' + t("已注入 ") + x.hits + t(" 次") + "</span>" : "") +
     (x.won > 0 ? '<span class="tag ok" title="' + t("注入后任务过审的次数（真实帮上忙）") + '">' + t("有效 ") + x.won + "</span>" : "") +
     (x.lost > 0 ? '<span class="tag" style="color:var(--bad)" title="' + t("注入后任务仍失败的次数（没防住）") + '">' + t("失守 ") + x.lost + "</span>" : "") +
@@ -9910,6 +9922,7 @@ function kbCard(x) {
     (x.confidence === "high" ? '<span class="tag ok" title="' + esc(t("产出材料中有明确来源或数据支撑")) + '">' + esc(t("有据")) + "</span>" : "") +
     '<span class="tag">' + esc(x.scope === "*" ? t("通用") : x.scope) + "</span>" +
     (x.seen > 1 ? '<span class="tag">' + t("出现 ") + x.seen + t(" 次") + "</span>" : "") +
+    ((x.merged_titles || []).length ? '<span class="tag" title="' + t("被近似题合并吸收的变体标题数") + '">' + t("吸收 ") + x.merged_titles.length + t(" 个近似题") + "</span>" : "") +
     (x.hits ? '<span class="tag">' + t("已注入 ") + x.hits + t(" 次") + "</span>" : "") +
     (x.enabled === false ? '<span class="tag">' + t("已停用") + "</span>" : "");
   const tags = (x.tags || []).map((tg) =>
@@ -12717,6 +12730,7 @@ function renderUsage() {
   // 用量页不做环比：范围由用户任选（含「全部」），没有等长上一期可比，硬算会是假数。
   const dayTok = (u.by_day || []).map((d) => d.tokens || 0);
   const dayDur = (u.by_day || []).map((d) => d.duration_s || 0);
+  const daySaved = (u.by_day || []).map((d) => d.saved || 0);
   // 首字延迟只有内置直连的流式调用可测（CLI 事件流没有逐 token 时刻）：
   // perf_samples=0 时显示"暂无可测数据"，不能显示成 0ms。
   const fmtMs = (x) => (x >= 1000 ? (x / 1000).toFixed(1) + "s" : Math.round(x) + "ms");
@@ -12746,7 +12760,8 @@ function renderUsage() {
     kpiCard(t("压缩省量"), tot.compaction_saved ? fmtTok(tot.compaction_saved) : "—",
       tot.compaction_saved
         ? t("上下文折叠净省，与消耗并列成账")
-        : t("长对话压力压缩后在此累计"), false, "i-cpu", { tone: "ok" }),
+        : t("长对话压力压缩后在此累计"), false, "i-cpu",
+      { tone: "ok", spark: daySaved }),
   ].join("");
   const note = $("usage-note");
   if (note) {

package/app/ui/i18n.js

@@ -1593,6 +1593,9 @@
     "知道了": "Got it",
     "新版本更新内容": "What's new in the new version",
     "已注入 ": "injected ",
+    "吸收 ": "absorbed ",
+    " 个近似题": " near-dup titles",
+    "被近似题合并吸收的变体标题数": "Variant titles absorbed by near-duplicate merging",
     "做法": "Best practice",
     "已验证有效的做法（程序性记忆）": "Verified working procedure (procedural memory)",
     "已清除 ": "Cleared ",
@@ -1906,6 +1909,7 @@
     "丢弃该文件的全部未提交改动？此操作不可恢复。": "Discard all uncommitted changes of this file? This cannot be undone.",
     "删除这个未跟踪文件？此操作不可恢复。": "Delete this untracked file? This cannot be undone.",
     "任务分支": "Task branch",
+    "任务计划": "Task plan",
     "已配置代码版本隔离，但任务分支尚未创建（检出失败见运行错误）。": "Code-version isolation is configured, but the task branch has not been created yet (see run error if checkout failed).",
     "藏青底色 + 天蓝强调，夜间长时间盯任务更沉静（默认）": "Navy base + sky-blue accent; calmer for long night sessions (default)",
     "黑白灰 + 蓝色强调，ChatGPT 式清爽配色": "Black/white/gray + blue accent — the clean ChatGPT-style palette",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebee",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "description": "CodeBee · 多智能体编排台 — 统一编排本机 AI 编码 CLI（Codex / Claude Code / QwenCode / OpenCode / Aider…）：目标→拆解→路由→执行→验证→跨厂商评审→修复→报告。纯 Python 标准库实现，本地 Web UI。",
   "license": "MIT",
   "bin": {