codebee 0.1.69 → 0.1.71

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
 
@@ -219,6 +220,19 @@ class Handler(BaseHTTPRequestHandler):
 
     # ------------------------------------------------------------ 路由
     def do_GET(self):
+        # 顶层兜底：任何路由裸抛以前=socketserver 直接掐断连接、零日志，
+        # 浏览器只见 "Failed to fetch"（2026-09-29 store 局部名遮蔽实案）。
+        # 现在统一落日志并回 500 JSON；对端已断开时无从回话，原样上抛。
+        try:
+            return self._route_get()
+        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError,
+                socket.timeout):
+            raise
+        except Exception:
+            log.exception("GET %s 处理异常", getattr(self, "path", "?"))
+            self._safe_500()
+
+    def _route_get(self):
         path = urlparse(self.path).path
         m = None
         # 静态页不设防（无敏感信息）：远程裸地址打开时由前端令牌门引导输入
@@ -267,6 +281,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 +306,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 +383,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 +548,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:
                 # 自动发布视图：待发清单统计 + 护栏状态 + 批量发布进度
@@ -642,6 +680,24 @@ class Handler(BaseHTTPRequestHandler):
         return self._json(404, {"error": "not found"})
 
     def do_POST(self):
+        # 同 do_GET：路由裸抛统一落日志并回 500，不再静默掐连接
+        try:
+            return self._route_post()
+        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError,
+                socket.timeout):
+            raise
+        except Exception:
+            log.exception("POST %s 处理异常", getattr(self, "path", "?"))
+            self._safe_500()
+
+    def _safe_500(self):
+        # 响应头可能已发出（流式路由半途抛），二次失败只能放弃
+        try:
+            self._json(500, {"error": "服务内部错误，详情见服务端日志"})
+        except Exception:
+            pass
+
+    def _route_post(self):
         path = urlparse(self.path).path
         m = None
         if not self._authed():
@@ -665,7 +721,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 +747,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 +912,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 +943,39 @@ 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.publish import ledger as pub_ledger
+            # 注意：这里绝不能再 `from core import store`——函数内 import 会把
+            # store 变成 do_POST 整个函数的局部名，同函数里其余路由（新建任务/
+            # 取消/升级全部等）一读 store 就是 UnboundLocalError，连接被静默
+            # 掐断，前端只见 "Failed to fetch"（0.1.70 实案，bisect 定位）。
+            # store 已在模块顶层导入，直接用。
+            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 +1037,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 +1166,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 +1207,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 +1492,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 +1558,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")
@@ -1720,7 +1951,7 @@ class Handler(BaseHTTPRequestHandler):
             # 服务换了个进程（升级重启）——旧蜜蜂自行退场让新服务 spawn 新蜜蜂
             # （旧形象常驻的根因：同端口轮询永远正常，旧进程从不自离）。
             "boot": _BOOT_TS,
-            "settings": {"pet_enabled": bool(st.get("pet_enabled", True)),
+            "settings": {"pet_enabled": bool(st.get("pet_enabled", False)),
                          "pet_mode": str(st.get("pet_mode") or "always"),
                          "pet_skin": str(st.get("pet_skin") or "plush")},
             "workers": {"running": n_run, "queued": n_q},
@@ -1997,7 +2228,7 @@ class Handler(BaseHTTPRequestHandler):
         return self._json(200, {"ok": True, "message": msg})
 
     def _api_run_timeline(self, run_id):
-        """直连对话视图的时间线：目标 + 用户消息 + 各步最终回答按序合并成气泡流。
+        """任务对话工作区时间线：目标 + 用户消息 + 各步最终回答按序合并成气泡流。
 
         形状：[任务目标] → [用户消息] → [assistant 输出] → [用户追问] → …。
         步骤正文只认 output/summary（干净回答），供详情页「对话」分区直读。
@@ -2007,14 +2238,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 +2256,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 +2304,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 +2365,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 +2428,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 +2453,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 +2541,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 +2557,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 +2567,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 +2820,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()},
         # 每个任务的运行次数/步骤总数（全量）：侧栏「查看全部」的计数来源
@@ -2651,7 +2913,7 @@ def _start_pet_keeper(port):
     def _loop():
         while True:
             try:
-                if settings.load().get("pet_enabled", True):
+                if settings.load().get("pet_enabled", False):
                     if _PET_PROC is None or _PET_PROC.poll() is not None:
                         # 全机唯一蜜蜂：别的服务实例（不同数据目录）已养蜂时
                         # 不再拉起，否则桌面会出现多只（用户实测踩坑）
@@ -2751,6 +3013,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: