codebee 0.1.69 → 0.1.70

package/app/main.py

@@ -34,6 +34,7 @@ if os.environ.get("TUTTI_ISOLATE_HOME", "").strip() == "1":
 from core import automation, board, catalog, flows, jobs, manager, market, market_remote, preview, registry, remote, settings, store
 from core import paths
 from core import health
+from core import usage as usage_ledger
 import pick_dialog
 import pet
 
@@ -267,6 +268,10 @@ class Handler(BaseHTTPRequestHandler):
                 return self._json(200, {"sources": modelhub.sources()})
             if path == "/api/flows":
                 return self._json(200, {"flows": flows.list_flows()})
+            if path == "/api/flows/versions":
+                qs = parse_qs(urlparse(self.path).query)
+                fid = (qs.get("id") or [""])[0]
+                return self._json(200, {"versions": flows.flow_versions(fid)})
             if path == "/api/skills":
                 from core import skills
                 return self._json(200, skills.view())
@@ -288,6 +293,9 @@ class Handler(BaseHTTPRequestHandler):
             if path == "/api/orchestrator":
                 from core import modelhub
                 return self._json(200, {"orchestrator": modelhub.orchestrator_view()})
+            if path == "/api/evalbench":
+                from core import evalbench
+                return self._json(200, evalbench.state())
             if path == "/api/catalog":
                 return self._json(200, {"catalog": manager.catalog_view(),
                                         "checking": manager.updates_checking()})
@@ -362,6 +370,19 @@ class Handler(BaseHTTPRequestHandler):
                     "Content-Disposition":
                         'attachment; filename="codebee-diag-%s.zip"'
                         % time.strftime("%Y%m%d-%H%M%S")})
+            if path == "/api/usage/export":
+                # 台账明细导出 CSV（UTF-8 BOM，Excel 直开；行数封顶防炸）
+                from core import usage as _usage
+                try:
+                    days = max(0, min(3650, int((parse_qs(urlparse(self.path).query)
+                                                .get("days") or ["30"])[0])))
+                except (TypeError, ValueError):
+                    days = 30
+                csv_bytes = _usage.export_csv(days=days)
+                return self._send(200, csv_bytes, ctype="text/csv; charset=utf-8",
+                                  headers={"Content-Disposition":
+                                           'attachment; filename="codebee-usage-%s.csv"'
+                                           % time.strftime("%Y%m%d-%H%M%S")})
             if path == "/api/diagnostics/issue-summary":
                 # 一键反馈 Issue 的预填摘要（标题+正文，全程脱敏，用户亲手提交）
                 from core import telemetry
@@ -514,8 +535,12 @@ class Handler(BaseHTTPRequestHandler):
             if m:
                 from core.publish import manager as pub
                 from core.publish import ledger as pub_ledger
-                return self._json(200, {"history": pub.history(task_id=m.group(1), limit=50),
-                                        "books": pub_ledger.load_books().get(m.group(1)) or {}})
+                tid = m.group(1)
+                books = pub_ledger.load_books().get(tid) or {}
+                return self._json(200, {"history": pub.history(task_id=tid, limit=50),
+                                        "books": books,
+                                        "published": {p: pub.published_local(tid, p)
+                                                      for p in books}})
             m = re.match(r"^/api/publish/task/([^/]+)/pending$", path)
             if m:
                 # 自动发布视图：待发清单统计 + 护栏状态 + 批量发布进度
@@ -665,7 +690,8 @@ class Handler(BaseHTTPRequestHandler):
         # /api/hooks/run 用自己的令牌鉴权（外部脚本没有设备控制权握手）。
         if path in ("/api/health/op", "/api/models/provider-op", "/api/models/model-op",
                     "/api/models/test-provider", "/api/models/test-model",
-                    "/api/models/probe-wire", "/api/models/key-op", "/api/hooks/run"):
+                    "/api/models/probe-wire", "/api/models/key-op", "/api/hooks/run",
+                    "/api/notify/test", "/api/models/set-price", "/api/models/model-caps"):
             pass                                    # 落到下方各自路由
         else:
             deny = self._deny_control()
@@ -690,6 +716,50 @@ class Handler(BaseHTTPRequestHandler):
             return self._json(200, {"ok": ok, "output": out})
         if path == "/api/tasks/clarify":
             return self._api_task_clarify()
+        if path == "/api/notify/test":
+            # 设置页「发送测试」：向全部已配置推送通道发一条测试消息
+            from core import notify
+            res = notify.push_text_ex(
+                "🔔 CodeBee 测试推送\n收到这条消息说明推送通道连通正常（任务收尾会推同样格式的结果摘要）。")
+            if not res:
+                return self._json(400, {"error": "未配置任何推送通道（群 Webhook / Bark / ntfy / Server酱 / Telegram）"})
+            return self._json(200, {"ok": any(res.values()), "channels": res})
+        if path == "/api/evalbench/run":
+            # 评测基准台：样题 × 候选模型实跑 + 编排者裁判打分（后台线程）
+            from core import evalbench
+            body = self._body() or {}
+            info, err = evalbench.start(body.get("candidates"),
+                                        sample_ids=body.get("samples"))
+            if err:
+                return self._json(409 if "在跑" in err else 400, {"error": err})
+            return self._json(200, dict(ok=True, **info))
+        if path == "/api/evalbench/cancel":
+            from core import evalbench
+            return self._json(200, {"ok": evalbench.cancel()})
+        if path == "/api/evalbench/sample-op":
+            # 自定义样题增删：{op:add|delete, sample:{...}|sid}
+            from core import evalbench
+            body = self._body() or {}
+            res, err = evalbench.sample_op(body.get("op") or "",
+                                           sample=body.get("sample"),
+                                           sid=body.get("sid") or "")
+            if err:
+                return self._json(400, {"error": err})
+            return self._json(200, {"ok": True, "sample": res})
+        if path == "/api/evalbench/sample-export":
+            from core import evalbench
+            body = self._body() or {}
+            code, err = evalbench.export_sample_code(body.get("id") or "")
+            if err:
+                return self._json(400, {"error": err})
+            return self._json(200, {"ok": True, "code": code})
+        if path == "/api/evalbench/sample-import":
+            from core import evalbench
+            body = self._body() or {}
+            res, err = evalbench.import_sample_code(body.get("code"))
+            if err:
+                return self._json(400, {"error": err})
+            return self._json(200, dict(ok=True, **res))
         if path == "/api/hooks/run":
             return self._api_hook_run()
         if path == "/api/health/op":
@@ -811,7 +881,10 @@ class Handler(BaseHTTPRequestHandler):
                     _t = store.get_task(m.group(1)) or {}
                     return self._json(200, {"ok": True, "rev": _t.get("rev")})
             else:
-                ok, err = store.delete_task(m.group(1))
+                # actor 记进删除审计（store 落台账）；本地回环标 local 更可读
+                ip = self.client_address[0] if self.client_address else ""
+                ok, err = store.delete_task(
+                    m.group(1), actor="local" if ip in ("127.0.0.1", "::1") else ip)
             return self._json(400, {"error": err}) if not ok else self._json(200, {"ok": True})
         m = re.match(r"^/api/tasks/([^/]+)/bible$", path)
         if m:
@@ -839,6 +912,35 @@ class Handler(BaseHTTPRequestHandler):
         m = re.match(r"^/api/publish/task/([^/]+)/publish-all$", path)
         if m:
             return self._api_publish_auto(m.group(1))
+        m = re.match(r"^/api/publish/task/([^/]+)/sync-published$", path)
+        if m:
+            # 已发章数校准：数章节管理页的实况写回登记（后台线程）。
+            # manual=true（用户点「校准」）允许 attach-or-launch；自动触发
+            # 只 attach 在跑实例，绝不因打开页面弹出新浏览器窗口。
+            from core.publish import manager as pub
+            from core import store
+            from core.publish import ledger as pub_ledger
+            tid = m.group(1)
+            if not store.get_task(tid):
+                return self._json(404, {"error": "任务不存在"})
+            body = self._body() or {}
+            plat = str(body.get("platform") or "").strip()
+            books = pub_ledger.load_books().get(tid) or {}
+            if plat and plat not in books:
+                return self._json(400, {"error": "该平台未登记作品"})
+            plats = [plat] if plat else list(books)
+            if not plats:
+                return self._json(400, {"error": "该任务没有已登记作品"})
+            manual = bool(body.get("manual"))
+            started, skipped = [], {}
+            for p in plats:
+                ok, err = pub.sync_published_async(tid, p, manual=manual)
+                if ok:
+                    started.append(p)
+                else:
+                    skipped[p] = err
+            return self._json(200, {"ok": True, "started": started,
+                                    "skipped": skipped})
         m = re.match(r"^/api/tasks/([^/]+)/(git-merge|git-discard)$", path)
         if m:
             return self._api_git_verdict(m.group(1), m.group(2))
@@ -900,6 +1002,30 @@ class Handler(BaseHTTPRequestHandler):
             n = manager.check_updates_async(force=force)
             return self._json(200, {"ok": True, "count": n,
                                     "checking": manager.updates_checking()})
+        if path == "/api/catalog/upgrade-all":
+            # 一键升级：把所有可升级条目逐个送进 mgmt 队列（选条见
+            # manager.upgrade_all_targets）。同条目去重闸与单条升级共用——
+            # 忙着的条目跳过并在响应里点名，前端 toast 汇报
+            started, busy, failed = [], [], []
+            for e in manager.upgrade_all_targets():
+                if store.active_mgmt_run(e["id"]):
+                    busy.append(e.get("name", e["id"]))
+                    continue
+                run = store.create_run("mgmt", "升级 %s" % e.get("name", e["id"]),
+                                       entry_id=e["id"], op="upgrade")
+                queued, qerr = self._enqueue_run(
+                    run["id"], None,
+                    {"kind": "mgmt", "run_id": run["id"], "entry_id": e["id"], "op": "upgrade"})
+                if not queued:
+                    # 入队失败必须落终态：queued 僵尸会永久堵住去重闸
+                    store.update_run(run["id"], status="failed", error=qerr or "enqueue 失败",
+                                     ended_at=time.strftime("%Y-%m-%d %H:%M:%S"))
+                    failed.append(e.get("name", e["id"]))
+                    continue
+                started.append({"id": e["id"], "name": e.get("name", e["id"]),
+                                "run_id": run["id"]})
+            return self._json(200, {"ok": True, "started": started,
+                                    "busy": busy, "failed": failed})
         if path == "/api/selfupdate/apply":
             from core import selfupdate
             try:
@@ -1005,6 +1131,15 @@ class Handler(BaseHTTPRequestHandler):
                                           body.get("name") or "",
                                           body.get("image_in"))
             return self._json(400, {"error": err}) if err else self._json(200, {"ok": True})
+        if path == "/api/models/set-price":
+            # 手标模型单价（¥/百万 tokens）：台账记账与花费预算按此折算
+            from core import modelhub
+            body = self._body()
+            err = modelhub.set_model_price(body.get("provider_id") or "",
+                                           body.get("name") or "",
+                                           body.get("price_in"),
+                                           body.get("price_out"))
+            return self._json(400, {"error": err}) if err else self._json(200, {"ok": True})
         if path == "/api/models/test-provider":
             from core import modelhub
             return self._json(200, modelhub.test_provider(self._body().get("id") or ""))
@@ -1037,6 +1172,33 @@ class Handler(BaseHTTPRequestHandler):
             if err:
                 return self._json(400, {"error": err})
             return self._json(200, {"ok": True, "flow": flow})
+        if path == "/api/flows/restore":
+            # 版本历史恢复：把历史版重新 upsert 回来（当前版先入史，可再回滚）
+            body = self._body() or {}
+            flow, err = flows.restore_flow_version(body.get("id") or "",
+                                                   body.get("ts") or "")
+            if err:
+                return self._json(400, {"error": err})
+            return self._json(200, {"ok": True, "flow": flow})
+        if path == "/api/flows/export":
+            # 流程分享码：导出一段可粘贴的码，对端「导入分享码」一键安装
+            body = self._body() or {}
+            code, err = flows.export_flow_code(body.get("id") or "")
+            if err:
+                return self._json(400, {"error": err})
+            return self._json(200, {"ok": True, "code": code,
+                                    "name": (flows.get_flow(body.get("id") or "") or {}).get("name")})
+        if path == "/api/flows/preview":
+            # 分享码两步导入第一步：解析预览，不落盘
+            res, err = flows.preview_flow_code((self._body() or {}).get("code"))
+            if err:
+                return self._json(400, {"error": err})
+            return self._json(200, dict(ok=True, **res))
+        if path == "/api/flows/import":
+            res, err = flows.import_flow_code((self._body() or {}).get("code"))
+            if err:
+                return self._json(400, {"error": err})
+            return self._json(200, dict(ok=True, **res))
         if path == "/api/skills/lesson-op":
             from core import skills
             body = self._body()
@@ -1295,7 +1457,31 @@ class Handler(BaseHTTPRequestHandler):
             except Exception as e:
                 log.exception("backup: 导出失败")
                 return self._json(500, {"error": "导出失败：%s" % e})
+            # 远程备份通道：启用即自动推送（失败不挡导出，结果并进响应）
+            try:
+                from core import remotesync
+                info["remote"] = remotesync.push_remote(info.get("path") or "")
+            except Exception:
+                info["remote"] = {"ok": False, "error": "推送异常"}
             return self._json(200, {"ok": True, **info})
+        if path == "/api/data/test-remote":
+            # 远程备份连通性测试：PUT 一个探针文件
+            from core import remotesync
+            return self._json(200, {"ok": True, **remotesync.test_remote()})
+        if path == "/api/data/remote-list":
+            # 远程备份包列举（WebDAV PROPFIND）
+            from core import remotesync
+            names, err = remotesync.list_remote()
+            if err:
+                return self._json(400, {"error": err})
+            return self._json(200, {"ok": True, "files": names})
+        if path == "/api/data/remote-pull":
+            # 拉远程备份包到 imports 目录（之后走既有导入预览/应用向导）
+            from core import remotesync
+            p, err = remotesync.pull_remote((self._body() or {}).get("name"))
+            if err:
+                return self._json(400, {"error": err})
+            return self._json(200, {"ok": True, "path": p})
         if path == "/api/data/import":
             # op=inspect 预览（不落盘）；op=apply 应用（merge/replace + 路径重映射）
             from core import backup
@@ -1337,6 +1523,16 @@ class Handler(BaseHTTPRequestHandler):
             from core import zentao
             res = zentao.scan_now()      # 网络操作同步做（ThreadingHTTPServer 不堵别的请求）
             return self._json(200, dict(res, ok=bool(res.get("ok"))))
+        if path == "/api/zentao/claims/archive":
+            from core import zentao
+            body = self._body() or {}
+            try:
+                c = zentao.archive_claim(body.get("bug_id"),
+                                         bool(body.get("archived")),
+                                         str(body.get("reason") or ""))
+            except zentao.ZenError as e:
+                return self._json(404, {"error": str(e)})
+            return self._json(200, {"ok": True, "claim": c})
         if path == "/api/zentao/modules":
             from core import zentao
             pid = (self._body() or {}).get("product")
@@ -1997,7 +2193,7 @@ class Handler(BaseHTTPRequestHandler):
         return self._json(200, {"ok": True, "message": msg})
 
     def _api_run_timeline(self, run_id):
-        """直连对话视图的时间线：目标 + 用户消息 + 各步最终回答按序合并成气泡流。
+        """任务对话工作区时间线：目标 + 用户消息 + 各步最终回答按序合并成气泡流。
 
         形状：[任务目标] → [用户消息] → [assistant 输出] → [用户追问] → …。
         步骤正文只认 output/summary（干净回答），供详情页「对话」分区直读。
@@ -2007,14 +2203,17 @@ class Handler(BaseHTTPRequestHandler):
         回放单个 run 会把历史轮的回答全丢掉（2026-09-17 实测：一发消息，
         之前智能体输出从时间线消失）。继承的消息是同 id 副本，跨 run 按
         (id, 时间, 文本) 去重；每个 run 内先消息后步骤（消息总是先于本轮
-        回答送达）。非 direct 任务保持单 run 步骤流（视图未启用）。"""
+        回答送达）。没有任务归属的管理运行保持单 run 步骤流。"""
         run = store.get_run(run_id)
         if not run:
             return self._json(404, {"error": "not found"})
         task = store.get_task(run.get("task_id") or "") if run.get("task_id") else None
         engine = (task or {}).get("engine") or ""
         items = []
-        if engine == "direct":
+        # 对话工作区按任务回放，而不是按某个引擎特判：编排类任务也会
+        # 产生多轮运行（重试、连载续跑、用户反馈），用户需要看到完整的
+        # 智能体输出历史。没有任务归属的管理运行仍只展示自己这一轮。
+        if task:
             runs = list(reversed(store.task_runs(run["task_id"])))   # 旧→新
         else:
             runs = [run]
@@ -2022,7 +2221,7 @@ class Handler(BaseHTTPRequestHandler):
         # 附件归一成 _attachments/ 相对路径：前端展示仍取文件名（attName 剥目录），
         # 但「点击查看」需要相对路径走 /api/runs/<id>/file 通道——只下发文件名的话
         # 点开永远 404。时间取任务创建时刻（对话的开场是任务本身，不是某一轮续跑的起始时间）
-        if task and engine == "direct":
+        if task:
             from core import attachments as _att
             atts = [p for p in (_att.norm_rel(a) for a in (task.get("attachments") or [])) if p]
             items.append({
@@ -2070,6 +2269,7 @@ class Handler(BaseHTTPRequestHandler):
                 "role": s.get("role") or "",
                 "n": s.get("n"),
                 "status": s.get("status") or "",
+                "partial": bool(s.get("partial")),
                 "text": body,
                 "note": s.get("note") or "",
                 "run": run_id_of_step,
@@ -2130,13 +2330,23 @@ class Handler(BaseHTTPRequestHandler):
         成没成、跑多久、谁执行的、产出了哪些文件。模型最后一轮回答可能只是
         寒暄/追问（用户反馈：输入"1"跑完 55 秒只见一句"消息可能发错了"），
         执行结果不能依赖模型自觉交代，由产品明示。"""
-        if engine != "direct" or not latest:
+        # 对话工作区现在覆盖所有有任务归属的运行（编排、直连、连载等）。
+        # `engine` 仅保留给调用方展示/兼容，不能再把编排任务的结果卡过滤掉。
+        # 没有关联任务的管理运行仍在 _api_run_timeline 中走孤立运行路径，
+        # 不会误显示可续聊的结果卡。
+        if not latest:
             return None
         st = latest.get("status") or ""
         if st not in ("done", "failed", "cancelled", "timeout"):
             return None
         verdict = latest.get("verdict") or {}
         route = latest.get("route") or {}
+        # 非直连编排路径可能只在步骤收尾记录 partial，而没有统一的
+        # run-level verdict。结果卡必须保留这个事实，不能把已执行一部分
+        # 的运行显示成完整成功。
+        partial = bool(verdict.get("partial")) or any(
+            isinstance(step, dict) and bool(step.get("partial"))
+            for step in (latest.get("steps") or []))
 
         def _seconds(value):
             try:
@@ -2183,7 +2393,10 @@ class Handler(BaseHTTPRequestHandler):
             wd, files = "", []
         return {
             "status": st,
-            "error": (latest.get("error") or "") if st in ("failed", "timeout") else "",
+            "partial": partial,
+            "error": ((latest.get("error") or "") if st in ("failed", "timeout")
+                       else "部分完成：已执行部分操作，但最终总结未完整生成"
+                       if partial else ""),
             "executor": route.get("implementer") or verdict.get("impl") or "",
             "turns": verdict.get("turns") or 0,
             "duration_s": duration_s,
@@ -2205,8 +2418,8 @@ class Handler(BaseHTTPRequestHandler):
             return self._json(404, {"error": "not found"})
         task = store.get_task(run.get("task_id") or "") if run.get("task_id") else None
         is_serial = bool(task and task.get("serial"))
-        if not task or (task.get("engine") != "direct" and not is_serial):
-            return self._json(400, {"error": "该任务不是直连任务，请用「下达指令」"})
+        if not task:
+            return self._json(400, {"error": "运行没有关联任务，无法进入对话工作区"})
         if (run.get("status") or "") in ("queued", "running"):
             return self._json(400, {"error": "运行中：消息会随下一步自动送达，无需追话"})
         body = self._body() or {}
@@ -2293,6 +2506,7 @@ class Handler(BaseHTTPRequestHandler):
             pass
         cid = self._client_id()
         ver = store.state_version()
+        uver = usage_ledger.usage_version()
         sent_ctrl = None
         last_send = 0.0
         try:
@@ -2308,8 +2522,9 @@ class Handler(BaseHTTPRequestHandler):
             last_send = time.time()
             while True:
                 ver = store.wait_state_change(ver, 2.0)
+                uver_now = usage_ledger.usage_version()
                 ctrl = remote.control_view(cid)
-                if ver == store.state_version() and ctrl == sent_ctrl:
+                if ver == store.state_version() and ctrl == sent_ctrl and uver_now == uver:
                     # 空闲心跳：真发出去的字节让中间层不掐空闲流，也让半死
                     # 连接在下一次写时尽早报错（注释行，EventSource 不派发事件）
                     if time.time() - last_send >= SSE_PING_S:
@@ -2317,6 +2532,18 @@ class Handler(BaseHTTPRequestHandler):
                         self.wfile.flush()
                         last_send = time.time()
                     continue  # 超时醒来且无变化
+                if uver_now != uver:
+                    # 用量条实时化：台账有新记账（哪怕状态没变，如内置智能体
+                    # 同一工具循环内多次模型调用）只发一个几十字节的 usage
+                    # 事件，前端据此刷新左下角用量条，不构建/推送全量状态。
+                    # 2s 醒来才查一次版本号：两次醒来之间落多少条记录都合并
+                    # 成一个事件，推送频率天然有上界。
+                    self.wfile.write(("event: usage\ndata: " +
+                                      json.dumps({"v": uver_now}) + "\n\n").encode("utf-8"))
+                    uver = uver_now
+                    last_send = time.time()
+                if ver == store.state_version() and ctrl == sent_ctrl:
+                    continue  # 只需要补 usage 事件，状态与控制权都没变
                 payload = json.dumps(_state_payload(cid, ver), ensure_ascii=False)
                 self.wfile.write(("data: " + payload + "\n\n").encode("utf-8"))
                 self.wfile.flush()
@@ -2558,9 +2785,9 @@ def _state_payload(client_id="", ver=None):
     return {
         "v": ver,
         "agents": agents,
-        "tasks": store.list_tasks(30, archived=False),
+        "tasks": store.list_tasks(archived=False),
         # 归档任务默认隐藏；目标/上下文可能很大，只有查看或恢复时再按需读取。
-        "archived_tasks": [_state_task_summary(t) for t in store.list_tasks(30, archived=True)],
+        "archived_tasks": [_state_task_summary(t) for t in store.list_tasks(archived=True)],
         # 每个任务的最近一次运行（不受 runs 窗口限制）：侧栏靠它展示各任务真实近况
         "task_latest": {tid: _state_run_summary(run) for tid, run in latest.items()},
         # 每个任务的运行次数/步骤总数（全量）：侧栏「查看全部」的计数来源
@@ -2751,6 +2978,43 @@ def main():
     from core import usage
     store.set_run_estimator(usage.estimate)
     store.set_run_auditor(usage.audit_run)   # 终态把预估与真实用量逐条对账
+    flows.set_runs_provider(store.list_runs)  # 版本战绩对账用 run 遍历器（防 flows→store 静态环）
+    from core import evalbench as _evalbench
+    automation.register_tick_hook(_evalbench.fire_due)  # 评测台定时回归挂自动化 tick
+    from core import notify as _notify
+    usage_ledger.set_alert_push(_notify.push_text)  # 花费预警推送注入（防 usage→notify 静态环）
+    from core import mcp_client as _mcp
+    def _mcp_servers_text():
+        """settings 清单 + 已启用插件的 MCP 服务器合成（plugin 名隔离防撞名）。"""
+        import json as _json
+        try:
+            raw = str(settings.load().get("mcp_servers") or "")
+            configured = _json.loads(raw) if raw.strip() else []
+        except Exception:
+            return raw or ""
+        if not isinstance(configured, list):
+            return raw or ""
+        try:
+            from core import plugins as _plugins
+            plugin_servers = _plugins.active_mcp_servers()
+        except Exception:
+            plugin_servers = []          # 坏插件不能连累用户显式配置的服务器
+        import hashlib as _hashlib
+        import re as _re
+        for item in plugin_servers or []:
+            if not isinstance(item, dict):
+                continue
+            plugin_id = str(item.pop("plugin_id", "plugin"))
+            server_name = str(item.get("name") or "server")
+            digest = _hashlib.sha256(
+                (plugin_id + ":" + server_name).encode("utf-8")).hexdigest()[:6]
+            safe = _re.sub(r"[^a-z0-9_-]", "-", plugin_id.lower())
+            item["name"] = ("plg_" + safe[:11] + "_" + digest)[:24]
+            if not any(x.get("name") == item["name"] for x in configured
+                       if isinstance(x, dict)):
+                configured.append(item)
+        return _json.dumps(configured, ensure_ascii=False)
+    _mcp.set_settings_text(_mcp_servers_text)  # MCP 清单注入（防 mcp_client→settings 边）
     _step("正在回填用量台账…")
     n_bf = usage.backfill_from_runs()  # 历史运行 token 回填台账（幂等，仅补缺失步骤）
     if n_bf:

package/app/mcp_server.py

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+"""CodeBee 的 MCP 服务器形态：其他 AI 客户端（Claude Code / ZCode / Cursor）
+把这里当工具服务器挂载，即可直接创建任务、查状态、看用量与评测榜单——
+CodeBee 从编排工具变成可以被别的智能体调度的生态节点。
+
+stdio JSON-RPC 2.0（按行分帧，与 core/mcp_client 同一传输约定）。启动：
+  python -X utf8 <CodeBee目录>/app/mcp_server.py
+客户端配置示例（Claude Code / 兼容客户端）：
+  {"mcpServers": {"codebee": {"command": "python",
+                              "args": ["-X", "utf8", "<CodeBee目录>/app/mcp_server.py"]}}}
+仅本机 stdio，无网络监听，凭据不经过此通道；create_task 会真实调度智能体
+执行（与界面上建任务同一条链）。
+"""
+from __future__ import annotations
+
+import json
+import sys
+
+PROTOCOL_VERSION = "2024-11-05"
+SERVER_INFO = {"name": "codebee", "version": "1.0"}
+
+TOOLS = [
+    {"name": "create_task", "description": "创建并启动一个 CodeBee 编排任务（真实调度智能体执行，与界面建任务同链）。返回 task_id 与 run_id。",
+     "inputSchema": {"type": "object", "properties": {
+         "goal": {"type": "string", "description": "任务目标（一句话说清要做什么）"},
+         "type": {"type": "string", "description": "任务类型 id（如 code/novel/doc/direct），默认 doc"},
+         "workdir": {"type": "string", "description": "工作目录绝对路径；留空用 CodeBee 默认保存路径"},
+         "title": {"type": "string", "description": "任务标题；留空取目标前 30 字"}},
+         "required": ["goal"]}},
+    {"name": "get_status", "description": "查任务与最近一次运行的状态：进度、当前步骤、评分、错误。",
+     "inputSchema": {"type": "object", "properties": {
+         "task_id": {"type": "string", "description": "任务 ID"}}, "required": ["task_id"]}},
+    {"name": "list_recent", "description": "列出最近的运行（id/标题/状态/时间）。",
+     "inputSchema": {"type": "object", "properties": {
+         "limit": {"type": "integer", "description": "条数，默认 10，最大 30"}}}},
+    {"name": "usage_summary", "description": "用量台账汇总：今日/本月花费（¥）与 token 总量。",
+     "inputSchema": {"type": "object", "properties": {}}},
+    {"name": "bench_leaderboard", "description": "模型评测基准台能力榜（综合分 Top N）。",
+     "inputSchema": {"type": "object", "properties": {
+         "top": {"type": "integer", "description": "取前 N，默认 5"}}}},
+]
+
+
+def _enqueue(job):
+    """thin wrapper：便于单测 mock（真链会拉起 worker 执行）。"""
+    from core import jobs
+    jobs.enqueue(job)
+
+
+def _tool_create_task(args):
+    from core import settings as settings_mod, store
+    goal = str(args.get("goal") or "").strip()
+    if not goal:
+        return {"isError": True, "content": "goal 不能为空"}
+    payload = {"type": str(args.get("type") or "doc").strip()[:40] or "doc",
+               "title": (str(args.get("title") or "").strip() or goal[:30])[:40],
+               "goal": goal[:4000],
+               "workdir": str(args.get("workdir") or "").strip()
+               or settings_mod.default_workdir()}
+    task = store.create_task(payload)
+    run = store.create_run("orchestration", task["title"], task_id=task["id"])
+    store.update_task_status(task["id"], "queued")
+    _enqueue({"kind": "orchestration", "run_id": run["id"], "task_id": task["id"]})
+    return {"content": "已创建并排队：task_id=%s run_id=%s（可用 get_status 查进度）"
+            % (task["id"], run["id"])}
+
+
+def _tool_get_status(args):
+    from core import store
+    task = store.get_task(str(args.get("task_id") or "").strip())
+    if not task:
+        return {"isError": True, "content": "任务不存在"}
+    lines = ["任务：%s（%s）" % (task.get("title"), task.get("status"))]
+    run = store.latest_run_by_task().get(task["id"])
+    if run:
+        lines.append("最近运行：%s（%s）" % (run.get("id"), run.get("status")))
+        steps = [s for s in (run.get("steps") or []) if isinstance(s, dict)]
+        if steps:
+            cur = steps[-1]
+            lines.append("步骤 %d/%d：%s（%s）" % (len(steps), run.get("total_steps") or len(steps),
+                                                  cur.get("title"), cur.get("status")))
+        v = run.get("verdict") or {}
+        if v.get("overall") is not None:
+            lines.append("评分 %.1f（%s）" % (float(v["overall"]),
+                                             "达标" if v.get("publishable") else "未达标"))
+        if run.get("error"):
+            lines.append("错误：%s" % str(run["error"])[:200])
+    if task.get("git_state") == "isolated":
+        lines.append("⚠ 任务分支待裁决（合并/丢弃）")
+    return {"content": "\n".join(lines)}
+
+
+def _tool_list_recent(args):
+    from core import store
+    try:
+        limit = max(1, min(30, int(args.get("limit") or 10)))
+    except (TypeError, ValueError):
+        limit = 10
+    rows = [{"id": r.get("id"), "title": r.get("title"), "status": r.get("status"),
+             "ts": r.get("started_at") or ""} for r in store.list_runs(limit=limit)]
+    return {"content": json.dumps(rows, ensure_ascii=False, indent=1)}
+
+
+def _tool_usage_summary(args):
+    from core import usage
+    today, month = usage.cost_snapshot()
+    tokens = sum(int(r.get("total") or 0) for r in usage._iter_records(31))
+    return {"content": "今日花费 ¥%.2f\n本月花费 ¥%.2f\n近 31 天 tokens：%d（未标定单价的调用不计钱）"
+            % (today, month, tokens)}
+
+
+def _tool_bench(args):
+    from core import evalbench
+    try:
+        top = max(1, min(10, int(args.get("top") or 5)))
+    except (TypeError, ValueError):
+        top = 5
+    board = evalbench.state().get("leaderboard") or []
+    rows = [{"rank": r["rank"], "model": r["model"], "overall": r["overall"],
+             "provider": r.get("provider_name")} for r in board[:top]]
+    return {"content": json.dumps(rows, ensure_ascii=False, indent=1)}
+
+
+_TOOL_IMPL = {"create_task": _tool_create_task, "get_status": _tool_get_status,
+              "list_recent": _tool_list_recent, "usage_summary": _tool_usage_summary,
+              "bench_leaderboard": _tool_bench}
+
+
+def handle_request(msg):
+    """处理一条客户端请求，返回响应 dict（通知返回 None）。"""
+    if not isinstance(msg, dict) or msg.get("method") is None:
+        return None
+    rid = msg.get("id")
+    method = str(msg["method"])
+    if method == "initialize":
+        return {"jsonrpc": "2.0", "id": rid, "result": {
+            "protocolVersion": PROTOCOL_VERSION, "capabilities": {"tools": {}},
+            "serverInfo": SERVER_INFO}}
+    if method.startswith("notifications/"):
+        return None
+    if method == "tools/list":
+        return {"jsonrpc": "2.0", "id": rid, "result": {"tools": TOOLS}}
+    if method == "tools/call":
+        params = msg.get("params") or {}
+        name = str(params.get("name") or "")
+        fn = _TOOL_IMPL.get(name)
+        if fn is None:
+            return {"jsonrpc": "2.0", "id": rid, "result": {
+                "isError": True, "content": "未知工具: %s" % name}}
+        try:
+            out = fn(params.get("arguments") or {})
+        except Exception as e:
+            out = {"isError": True, "content": "工具执行失败: %s" % e}
+        return {"jsonrpc": "2.0", "id": rid, "result": out}
+    return {"jsonrpc": "2.0", "id": rid,
+            "error": {"code": -32601, "message": "no such method: %s" % method}}
+
+
+def main():
+    for raw in sys.stdin:
+        line = raw.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            msg = json.loads(line)
+        except Exception:
+            continue
+        resp = handle_request(msg)
+        if resp is not None:
+            sys.stdout.write(json.dumps(resp, ensure_ascii=False) + "\n")
+            sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()