codebee 0.1.7 → 0.1.9

package/app/core/telemetry.py

@@ -0,0 +1,291 @@
+# -*- coding: utf-8 -*-
+"""遥测回传（L2）+ 版本 ping（L3）+ 诊断包构建（L1）。
+
+设计原则：
+- 默认只传「匿名错误元数据」：errorlog 台账里的结构化失败记录（厂商/模型/原因码/
+  脱敏摘录/版本/OS），不含任何任务正文、章节内容、密钥、绝对路径；
+- 上传前对每条记录再兜一道 scrub_text（不信任入台账时的第一道）；
+- 开关 settings.telemetry_errors（默认开）；关掉后什么都不出机器（含版本 ping）；
+- 网络失败静默吞掉：遥测永远不影响业务，也不制造新错误；
+- 端点：CloudBase HTTP 函数（国内可达、零运维），可用环境变量
+  TUTTI_TELEMETRY_URL 覆盖；端点为空/未配置时整个模块自动休眠。
+
+SSRF 防线（端点可被 env 覆盖，所以请求前必须自证安全）：
+  https 限定 + 域名后缀白名单 + 解析 IP 拒绝私网/环回/链路本地。
+
+线程模型：start_background() 起一条 daemon 线程，首轮延迟 45s（不挡启动），
+之后每 6 小时一轮（ping 每轮一次，错误按游标增量上传）。
+"""
+from __future__ import annotations
+
+import io
+import ipaddress
+import json
+import os
+import platform
+import socket
+import threading
+import time
+import urllib.request
+import zipfile
+
+from . import errorlog, paths, settings
+
+# 端点：部署后把 CloudBase HTTP 函数 URL 填到这里（见 cloudfunctions/telemetry-collect/）
+ENDPOINT = os.environ.get("TUTTI_TELEMETRY_URL", "").strip()
+
+# 请求只允许发往我们自己的收集域（后缀匹配，大小写不敏感）；
+# 测试需要假端点时 monkeypatch 本常量或直接 patch _post。
+ALLOWED_SUFFIXES = (".tcloudbase.com", ".tencentyun.com", ".tencentcs.com")
+
+FIRST_DELAY_S = 45
+INTERVAL_S = 6 * 3600
+BATCH_LIMIT = 200
+TIMEOUT_S = 10
+
+_thread_started = False
+
+
+def _cursor_path():
+    """游标文件路径惰性计算：测试会把 paths.ERRORS_DIR 重定向到临时目录，
+    import 期绑定会钉死在真实数据目录（与 settings._FILE 同一个坑）。"""
+    return paths.ERRORS_DIR / "upload.cursor"
+
+
+def enabled():
+    try:
+        return bool(settings.load().get("telemetry_errors", True))
+    except Exception:
+        return False
+
+
+def _os_tag():
+    return {"win32": "windows", "darwin": "macos"}.get(platform.system().lower(),
+                                                      platform.system().lower())
+
+
+def _version():
+    try:
+        from . import selfupdate
+        return str(selfupdate.package_version() or "dev")
+    except Exception:
+        return "dev"
+
+
+def _endpoint_safe(url):
+    """端点自证安全：https + 域名后缀白名单 + 解析 IP 全部公网。
+    不合格返回 ""（调用方静默跳过——遥测绝不为安全边界让步）。"""
+    if not url:
+        return ""
+    try:
+        from urllib.parse import urlparse
+        p = urlparse(url)
+        if p.scheme != "https" or not p.hostname:
+            return ""
+        host = p.hostname.lower()
+        if not any(host == s.lstrip(".") or host.endswith(s)
+                   for s in ALLOWED_SUFFIXES):
+            return ""
+        for info in socket.getaddrinfo(host, 443, proto=socket.IPPROTO_TCP):
+            ip = ipaddress.ip_address(str(info[4][0]))
+            if (ip.is_private or ip.is_loopback or ip.is_link_local
+                    or ip.is_reserved or ip.is_multicast or ip.is_unspecified):
+                return ""
+        return url
+    except Exception:
+        return ""
+
+
+def _post(url, payload):
+    """POST JSON 到已通过 _endpoint_safe 校验的 URL；返回状态码，异常返回 0。"""
+    safe = _endpoint_safe(url)
+    if not safe:
+        return 0
+    try:
+        req = urllib.request.Request(
+            safe, data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
+            headers={"Content-Type": "application/json",
+                     "User-Agent": "CodeBee-Telemetry/1"},
+            method="POST")
+        with urllib.request.urlopen(req, timeout=TIMEOUT_S) as resp:
+            return int(resp.status or 0)
+    except Exception:
+        return 0
+
+
+# ---------------------------------------------------------------- 上报循环
+
+def _read_cursor():
+    try:
+        return _cursor_path().read_text(encoding="utf-8").strip()
+    except Exception:
+        return ""
+
+
+def _write_cursor(v):
+    try:
+        p = _cursor_path()
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(str(v), encoding="utf-8")
+    except Exception:
+        pass
+
+
+def _sanitize_record(r):
+    """上传前的最后一道闸：只挑白名单字段，detail 再过一次 scrub。"""
+    keep = ("id", "ts", "day", "category", "reason", "provider", "model",
+            "tool", "role", "run_id", "task_id", "step", "exit_code",
+            "app_version", "os")
+    out = {k: r.get(k) for k in keep if k in r}
+    out["detail"] = errorlog.scrub_text(r.get("detail") or "", limit=600)
+    return out
+
+
+def run_once():
+    """一轮上报：版本 ping + 增量错误批量。返回 (ping_ok, uploaded_n)。"""
+    if not enabled() or not ENDPOINT:
+        return (False, 0)
+    ping_ok = _post(ENDPOINT, {
+        "kind": "ping", "app": "codebee", "version": _version(),
+        "os": _os_tag(), "python": "%d.%d" % platform.python_version_tuple()[:2],
+        "ts": time.strftime("%Y-%m-%d %H:%M:%S"),
+    }) == 200
+    uploaded = 0
+    cursor = _read_cursor()
+    batch, new_cursor = errorlog.pending_since(cursor, limit=BATCH_LIMIT)
+    if batch:
+        payload = {"kind": "errors", "records": [_sanitize_record(r) for r in batch]}
+        if _post(ENDPOINT, payload) == 200:
+            _write_cursor(new_cursor)
+            uploaded = len(batch)
+    return (ping_ok, uploaded)
+
+
+def _loop():
+    while True:
+        try:
+            run_once()
+        except Exception:
+            pass
+        time.sleep(INTERVAL_S)
+
+
+def start_background():
+    """启动上报线程（daemon，首轮延迟 45s）。重复调用安全；未配端点直接休眠。"""
+    global _thread_started
+    if _thread_started or not ENDPOINT:
+        return
+    _thread_started = True
+
+    def _delayed():
+        time.sleep(FIRST_DELAY_S)
+        try:
+            run_once()
+        except Exception:
+            pass
+        _loop()
+
+    threading.Thread(target=_delayed, name="telemetry-up", daemon=True).start()
+
+
+# ---------------------------------------------------------------- 诊断包（L1）
+
+def build_bundle_bytes(days=30):
+    """构建「诊断包」zip 字节流：脱敏错误台账 + 用量台账 + 环境元信息。
+
+    只装可安全外发的聚合数据——绝不打包 tasks/runs/models.json（后者含密钥）。
+    错误记录出包前再 scrub 一遍（与上传同一道闸，出机器的东西不过两道不放行）。
+    """
+    meta = {
+        "app": "CodeBee",
+        "version": _version(),
+        "os": _os_tag(),
+        "os_version": platform.platform(),
+        "python": platform.python_version(),
+        "telemetry_enabled": enabled(),
+        "generated_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "note": "此包只含匿名错误元数据与用量统计；已剥离密钥、路径与任务内容。",
+    }
+    errors = [_sanitize_record(r) for r in errorlog.iter_records(days)]
+    buf = io.BytesIO()
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as z:
+        z.writestr("codebee-diag-%s/meta.json" % stamp,
+                   json.dumps(meta, ensure_ascii=False, indent=2))
+        z.writestr("codebee-diag-%s/errors-%ddays.jsonl" % (stamp, days),
+                   "\n".join(json.dumps(r, ensure_ascii=False) for r in errors))
+        usage_lines = []
+        try:
+            from . import usage
+            for r in usage._iter_records(days):
+                usage_lines.append(json.dumps(r, ensure_ascii=False))
+        except Exception:
+            pass
+        z.writestr("codebee-diag-%s/usage-%ddays.jsonl" % (stamp, days),
+                   "\n".join(usage_lines))
+    return buf.getvalue()
+
+
+# ---------------------------------------------------------------- 一键反馈 Issue（免费通道）
+
+# 反馈目标仓库（Issue 预填正文，由用户在浏览器亲手提交——不自动回传）
+ISSUE_URL = "https://github.com/Vercel-By-WXP/CodeBee/issues/new"
+
+
+def issue_report(days=30, max_groups=8, max_recent=10, detail_chars=120):
+    """本地错误台账 → GitHub Issue 预填摘要。返回 {title, body}。
+
+    聚合 + 明细全部来自已脱敏的 errorlog 台账，出正文前再 scrub 一道
+    （与上传/诊断包同一纪律：出机器的东西过两道不放行）。明细压成单行，
+    方便 URL 预填。days=0 表示全部历史。
+    """
+    errors = errorlog.iter_records(days)
+    groups = {}
+    for r in errors:
+        key = (str(r.get("reason") or "UNKNOWN"),
+               str(r.get("provider") or "-"),
+               str(r.get("model") or "-"))
+        g = groups.setdefault(key, {"n": 0, "last": ""})
+        g["n"] += 1
+        if str(r.get("ts") or "") > g["last"]:
+            g["last"] = str(r.get("ts") or "")
+    top = sorted(groups.items(), key=lambda kv: -kv[1]["n"])[:max_groups]
+    version = _version()
+
+    if top:
+        t_reason, t_prov, t_model = top[0][0]
+        title = "错误反馈：%s ×%d（v%s / %s）" % (
+            t_reason, top[0][1]["n"], version, _os_tag())
+    else:
+        title = "CodeBee 错误反馈（无自动记录的错误）"
+
+    lines = [
+        "## CodeBee 错误反馈", "",
+        "- 版本：v%s（%s）" % (version, _os_tag()),
+        "- Python：%s" % platform.python_version(),
+        "- 生成时间：%s" % time.strftime("%Y-%m-%d %H:%M:%S"),
+        "",
+        ("近 %d 天失败聚合（原因 × 次数）" % days) if days
+        else "全部历史失败聚合（原因 × 次数）",
+    ]
+    if top:
+        lines.append("| 原因 | 供应商/模型 | 次数 | 最近一次 |")
+        lines.append("|---|---|---|---|")
+        for (reason, prov, model), g in top:
+            lines.append("| %s | %s/%s | %d | %s |" % (reason, prov, model,
+                                                       g["n"], g["last"]))
+    else:
+        lines.append("（本机错误台账为空）")
+    lines += ["", "## 最近失败明细（最多 %d 条，已脱敏）" % max_recent]
+    if errors:
+        for r in errors[-max_recent:]:
+            detail = errorlog.scrub_text(r.get("detail") or "", limit=detail_chars)
+            detail = detail.replace("\r", " ").replace("\n", " ")
+            lines.append("- `%s` %s [%s/%s] %s" % (
+                str(r.get("ts") or ""), str(r.get("reason") or "UNKNOWN"),
+                str(r.get("provider") or "-"), str(r.get("model") or "-"), detail))
+    else:
+        lines.append("（无）")
+    lines += ["", "> 提示：可在 设置 → 关于与更新 → 导出诊断包 生成 zip 附在本 Issue"
+              "（含更完整的脱敏错误记录与用量统计）。", ""]
+    return {"title": title, "body": "\n".join(lines)}

package/app/core/token_meter.py

@@ -121,6 +121,24 @@ class TokenMeter:
         cap = cap_table.get(m, cap_table.get("", 128_000))
         return self.used(run_id) / max(cap, 1)
 
+    def capacity(self, model: str = "") -> int:
+        """模型上下文容量（未命中用默认行）。"""
+        cap_table = self._capacity()
+        return cap_table.get(model or "", cap_table.get("", 128_000))
+
+    def last_context(self, run_id: str) -> int:
+        """最近一次调用的 input+output+reasoning——下个请求要重发的上下文锚点。
+
+        used() 是窗口累计（多次调用叠加，系统性偏大，适合做响应式预算闸）；
+        事前预检判断「这个请求会不会被拒」要用最近一次的真实上下文体量，
+        两者口径不同不可混用（借鉴 freebuff base-chat 每步容量重估）。"""
+        with self._lock:
+            window = self._windows.get(run_id)
+            if not window:
+                return 0
+            _, i, o, r, _ = window[-1]
+            return i + o + r
+
     def reset(self, run_id: str):
         with self._lock:
             self._windows.pop(run_id, None)

package/app/main.py

@@ -23,6 +23,7 @@ from urllib.parse import parse_qs, unquote, urlparse
 from core import automation, catalog, flows, jobs, manager, market, market_remote, registry, remote, settings, store
 from core import paths
 from core import health
+import pick_dialog
 
 log = logging.getLogger(__name__)
 
@@ -72,6 +73,13 @@ class RequestBodyError(ValueError):
 _SKIP_DIRS_SHARE = {".git", "node_modules", "__pycache__", ".venv", "venv",
                     ".idea", ".vscode", "_attachments"}
 
+# 原生「选择文件夹」对话框：Tk 必须活在自家进程的主线程里（HTTP 请求线程里
+# 建 root 在 macOS 上会崩，Windows 上反复建/销毁也不稳），pick_dialog.py
+# 同文件提供父端 ask_directory()（拉起自身为子进程，参数走 stdin、结果走
+# stdout），这里只持锁防重入。
+# 同时只允许一个原生对话框：对话框开着时第二个请求立即拿到 busy，不排队
+_PICK_LOCK = threading.Lock()
+
 
 class Handler(BaseHTTPRequestHandler):
     server_version = "CodeBee/1.0"
@@ -264,6 +272,18 @@ class Handler(BaseHTTPRequestHandler):
                 except ValueError:
                     edays = 90
                 return self._json(200, usage.estimate(task_type=ttype, days=edays))
+            if path == "/api/diagnostics/bundle":
+                # 诊断包（zip）：脱敏错误台账 + 用量台账 + 环境元信息，供用户贴 Issue
+                from core import telemetry
+                data = telemetry.build_bundle_bytes(days=30)
+                return self._send(200, data, ctype="application/zip", headers={
+                    "Content-Disposition":
+                        'attachment; filename="codebee-diag-%s.zip"'
+                        % time.strftime("%Y%m%d-%H%M%S")})
+            if path == "/api/diagnostics/issue-summary":
+                # 一键反馈 Issue 的预填摘要（标题+正文，全程脱敏，用户亲手提交）
+                from core import telemetry
+                return self._json(200, telemetry.issue_report(days=30))
             m = re.match(r"^/api/runs/([^/]+)$", path)
             if m:
                 run = store.get_run(m.group(1))
@@ -436,9 +456,10 @@ class Handler(BaseHTTPRequestHandler):
         # 写操作需要控制权：空闲自动接管；他人持有时 423，由前端引导抢夺。
         # 例外（配置管理类操作全局生效，不被「哪台设备在操作」挡住，
         # 否则告警弹框里的按钮在多端场景会静默 423 失败）：
+        # /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/models/probe-wire", "/api/models/key-op", "/api/hooks/run"):
             pass                                    # 落到下方各自路由
         else:
             deny = self._deny_control()
@@ -446,6 +467,8 @@ class Handler(BaseHTTPRequestHandler):
                 return deny
         if path == "/api/tasks":
             return self._api_create_task()
+        if path == "/api/hooks/run":
+            return self._api_hook_run()
         if path == "/api/health/op":
             # 供应商健康告警的手动操作（silence 静默 / reset 手动恢复）
             from core import health
@@ -469,6 +492,8 @@ class Handler(BaseHTTPRequestHandler):
         if path == "/api/dir/save":
             # 「查看文件」弹窗编辑保存（本机 + 控制权 + 防穿越 + mtime 冲突检测）
             return self._api_dir_save()
+        if path == "/api/pick_folder":
+            return self._api_pick_folder()
         m = re.match(r"^/api/tasks/([^/]+)/(archive|delete|retry|rename|continue)$", path)
         if m:
             if m.group(2) == "archive":
@@ -661,6 +686,13 @@ class Handler(BaseHTTPRequestHandler):
             from core import modelhub
             n, err = modelhub.refresh_models(self._body().get("id") or "")
             return self._json(200, {"ok": bool(n), "count": n, "message": err})
+        if path == "/api/models/add":
+            # 手工添加模型：厂商列表接口调不通时直接填模型名进列表
+            from core import modelhub
+            body = self._body()
+            n, err = modelhub.add_model_manual(body.get("id") or "",
+                                               body.get("name") or "")
+            return self._json(200, {"ok": not err, "count": n, "message": err})
         if path == "/api/models/refresh-all":
             from core import modelhub
             n = modelhub.refresh_all_async()
@@ -802,12 +834,21 @@ class Handler(BaseHTTPRequestHandler):
                 return self._json(400, {
                     "error": "无法推导卸载命令：请在 data/catalog.json 的 \"%s\" 里配置 uninstall 字段"
                              % entry["id"]})
+            if op in ("install", "upgrade", "uninstall"):
+                # 同条目去重闸：已有进行中的管理操作就把本次请求挂到那个 run 上。
+                # 两个同包全局 npm 并发装会互锁成双僵尸（2026-09-18 codex 双开案）
+                active = store.active_mgmt_run(entry["id"])
+                if active:
+                    return self._json(200, {"run_id": active["id"], "deduped": True})
             run = store.create_run("mgmt", "%s %s" % (titles[op], entry.get("name", entry["id"])),
                                    entry_id=entry["id"], op=op)
             queued, qerr = self._enqueue_run(
                 run["id"], None,
                 {"kind": "mgmt", "run_id": run["id"], "entry_id": entry["id"], "op": op})
             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"))
                 return self._json(503, {"error": qerr, "run_id": run["id"]})
             return self._json(200, {"run_id": run["id"]})
         m = re.match(r"^/api/catalog/([^/]+)/launch$", path)
@@ -1041,6 +1082,26 @@ class Handler(BaseHTTPRequestHandler):
         parent = "" if p.parent == p else str(p.parent)
         return self._json(200, {"path": str(p), "parent": parent, "dirs": dirs})
 
+    def _api_pick_folder(self):
+        """系统原生「选择文件夹」对话框（工作目录「选择…」/点输入框用）。仅限本机：
+        对话框弹在服务所在机器上，远端触发等于替别人开窗。pick_dialog.ask_directory
+        拉起子进程弹真窗口，选中绝对路径直接回给前端回填；用户取消回空 path。
+        机器没有 tkinter 时 fallback=true，前端回落网页目录弹框，不失去选目录能力。"""
+        ip, fw = self._forwarded_ip()
+        if ip not in ("127.0.0.1", "::1") or fw:
+            return self._json(403, {"error": "目录选择仅限本机使用，请手动输入路径"})
+        body = self._body()
+        if not _PICK_LOCK.acquire(blocking=False):
+            return self._json(200, {"path": "", "busy": True})
+        try:
+            path, err, fb = pick_dialog.ask_directory(str(body.get("initial") or ""),
+                                                      str(body.get("title") or "选择文件夹"))
+        finally:
+            _PICK_LOCK.release()
+        if err:
+            return self._json(200, {"path": "", "fallback": fb, "error": err})
+        return self._json(200, {"path": path or ""})
+
     def _api_dir_scan(self):
         """侧栏文件夹「查看文件」：递归列出该工作目录下的全部文件（左侧文件页树形展示）。
 
@@ -1243,6 +1304,19 @@ class Handler(BaseHTTPRequestHandler):
                                 attachments=saved_paths)
         if not msg:
             return self._json(400, {"error": "运行不存在或消息非法"})
+        # 终态连载 run 收到递话：自动起答疑轮（op=qa）。此前消息只会躺在信箱里
+        # 无人消费——向已完结的连载任务「下达指令」= 石沉大海（2026-09-18 实案）
+        task = store.get_task(run.get("task_id") or "") if run.get("task_id") else None
+        if (task and task.get("serial")
+                and (run.get("status") or "") not in ("queued", "running")):
+            ok, err, new_run = store.retry_task(run["task_id"])
+            if ok:
+                store.update_run(new_run["id"], op="qa", qa_text=text)
+                self._enqueue_run(new_run["id"], run["task_id"],
+                                  {"kind": "orchestration", "run_id": new_run["id"],
+                                   "task_id": run["task_id"]})
+                return self._json(200, {"ok": True, "message": msg,
+                                        "qa_run": new_run["id"]})
         return self._json(200, {"ok": True, "message": msg})
 
     def _api_run_timeline(self, run_id):
@@ -1322,6 +1396,7 @@ class Handler(BaseHTTPRequestHandler):
                 "note": s.get("note") or "",
                 "run": run_id_of_step,
                 "log": s.get("log") or "",
+                "followups": s.get("followups") or [],
             })
 
         for r in runs:
@@ -1389,17 +1464,20 @@ class Handler(BaseHTTPRequestHandler):
         }
 
     def _api_direct_chat(self, run_id):
-        """直连对话追话：往已结束的 direct run 追加一条消息并自动续跑。
+        """追话：往已结束的 run 追加一条消息并自动续跑。
 
-        机制：消息入旧 run 信箱 → retry_task 起新 run（未消费消息自动继承）
+        直连任务：消息入旧 run 信箱 → retry_task 起新 run（未消费消息自动继承）
         → 入队编排 → _run_direct 看到信箱积压走续轮档（DIRECT_FOLLOWUP）。
-        仅 direct 引擎任务可用；运行中的 run 走既有 /messages（轮间注入）。
+        连载任务：走答疑档（op=qa）——单步只读回答，不再整本重跑（一句
+        「为啥没有第九章」触发全量重评+连环自动续跑，2026-09-18 实案）。
+        运行中的 run 走既有 /messages（轮间注入）。
         写接口已在 do_POST 统一做过设备控制。"""
         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
-        if not task or task.get("engine") != "direct":
+        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 (run.get("status") or "") in ("queued", "running"):
             return self._json(400, {"error": "运行中：消息会随下一步自动送达，无需追话"})
@@ -1424,6 +1502,10 @@ class Handler(BaseHTTPRequestHandler):
         ok, err, new_run = store.retry_task(task["id"])
         if not ok:
             return self._json(400, {"error": err or "无法续跑"})
+        if is_serial:
+            # 答疑档：问题文本显式带上（真实调用失败会把信箱消息 drain 掉，
+            # 换将重试时不能丢问题）；retry_task 只认终态任务，active 已挡
+            store.update_run(new_run["id"], op="qa", qa_text=text)
         queued, qerr = self._enqueue_run(
             new_run["id"], task["id"],
             {"kind": "orchestration", "run_id": new_run["id"], "task_id": task["id"]})
@@ -1487,12 +1569,15 @@ class Handler(BaseHTTPRequestHandler):
         except Exception:
             pass  # 客户端断开是常态，线程随进程退出
 
-    def _api_create_task(self):
-        body = self._body()
+    def _create_and_start(self, body):
+        """建任务并起跑（UI /api/tasks 与外部 webhook /api/hooks/run 共用一条链）。
+
+        返回 (http_status, response_dict)；失败路径都已收口（run/任务状态不会
+        永久卡在排队中）。"""
         try:
             task = store.create_task(body)
         except ValueError as e:
-            return self._json(400, {"error": str(e)})
+            return 400, {"error": str(e)}
         run = None
         try:
             run = store.create_run("orchestration", task["title"], task_id=task["id"])
@@ -1513,13 +1598,52 @@ class Handler(BaseHTTPRequestHandler):
                 store.update_task_status(task["id"], "failed")
             except Exception:
                 log.exception("收口失败的任务状态失败 task=%s", task.get("id"))
-            return self._json(503, {"error": "运行记录创建失败，请稍后重试"})
+            return 503, {"error": "运行记录创建失败，请稍后重试"}
         queued, qerr = self._enqueue_run(
             run["id"], task["id"],
             {"kind": "orchestration", "run_id": run["id"], "task_id": task["id"]})
         if not queued:
-            return self._json(503, {"error": qerr, "run_id": run["id"]})
-        return self._json(200, {"task_id": task["id"], "run_id": run["id"]})
+            return 503, {"error": qerr, "run_id": run["id"]}
+        return 200, {"task_id": task["id"], "run_id": run["id"]}
+
+    def _api_create_task(self):
+        status, resp = self._create_and_start(self._body())
+        return self._json(status, resp)
+
+    def _api_hook_run(self):
+        """外部触发开任务（webhook，借鉴 emdash/mission-control 的外部集成面）。
+
+        POST /api/hooks/run，头 X-CodeBee-Token；体 {goal 必填, type, workdir,
+        context, title}。令牌取设置 hooks_token（data/settings.json，UI/文件均可
+        配置）：已配置则必须精确匹配；未配置仅放行本机回环。任务链与 UI 完全相同。"""
+        try:
+            tok = str(settings.load().get("hooks_token") or "")
+        except Exception:
+            tok = ""
+        given = (self.headers.get("X-CodeBee-Token") or "").strip()
+        if tok:
+            if given != tok:
+                return self._json(401, {"error": "令牌不匹配"})
+        else:
+            host = str(self.client_address[0]) if self.client_address else ""
+            if host not in ("127.0.0.1", "::1", "::ffff:127.0.0.1"):
+                return self._json(403, {
+                    "error": "未配置 hooks.token，仅允许本机触发；请先在设置中配置令牌"})
+        raw = self._body()
+        payload = {}
+        for k, cap in (("goal", 4000), ("context", 4000), ("type", 40),
+                       ("workdir", 300), ("title", 80)):
+            v = str(raw.get(k) or "").strip()
+            if v:
+                payload[k] = v[:cap]
+        if not payload.get("goal"):
+            return self._json(400, {"error": "goal 必填"})
+        if not payload.get("type"):
+            payload["type"] = "direct"
+        if not payload.get("title"):
+            payload["title"] = payload["goal"][:30]
+        status, resp = self._create_and_start(payload)
+        return self._json(status, resp)
 
     def _enqueue_run(self, run_id, task_id, job):
         """入队失败时把已持久化记录收口到 failed，避免 UI 永远显示排队中。"""
@@ -1666,13 +1790,27 @@ def main():
     n_rc = store.recover_orphaned_runs()
     if n_rc:
         print("[CodeBee] 崩溃恢复：%d 个遗留运行标记为 failed（interrupted at startup）" % n_rc)
+    n_mg = store.recover_interrupted_mgmt()
+    if n_mg:
+        print("[CodeBee] 崩溃恢复：%d 个遗留管理操作标记为 failed（interrupted at startup）" % n_mg)
     try:
+        # 孤儿 CLI 清扫走后台线程：PowerShell Get-CimInstance 在部分机器上会慢满
+        # timeout（真实装机 60s，启动被白拖一分钟且无任何提示——看门狗堆栈抓到）。
+        # 清扫是尽力而为的旁路；60s timeout 保证它终会结束，但不能挡服务就绪。
         from core import manager as _mgr
-        n_z = _mgr.sweep_orphan_cli_processes()
-        if n_z:
-            # 服务重启孤儿化的 CLI 孙进程：僵尸 opencode 会劫持后续会话的项目根，
-            # 必须在恢复运行之前清掉（2026-09-17 mo-so「工作目录是 Temp」真凶）
-            print("[CodeBee] 崩溃恢复：清扫 %d 个孤儿 CLI 进程（opencode/codex）" % n_z)
+
+        def _sweep_async():
+            try:
+                n_z = _mgr.sweep_orphan_cli_processes()
+                if n_z:
+                    # 服务重启孤儿化的 CLI 孙进程：僵尸 opencode 会劫持后续会话
+                    # 的项目根（2026-09-17 mo-so「工作目录是 Temp」真凶）
+                    print("[CodeBee] 后台清扫：%d 个孤儿 CLI 进程（opencode/codex/kimi）"
+                          % n_z, flush=True)
+            except Exception:
+                pass
+        threading.Thread(target=_sweep_async, name="orphan-sweep",
+                         daemon=True).start()
     except Exception:
         pass
     from core import bookmeta
@@ -1684,11 +1822,19 @@ def main():
         settings_schema.register_default_namespaces()  # budget/cascade/compaction 配置就绪（幂等）
     except Exception:
         pass
+    try:
+        from core import telemetry
+        telemetry.start_background()  # 匿名错误回传+版本 ping（默认开可关；未配端点自动休眠，延迟 45s 不挡启动）
+    except Exception:
+        pass
     _step("正在启动任务队列…")
     jobs.start_worker()
     n_resume = jobs.resume_interrupted()   # 启动恢复：服务被杀中断的连载任务自动续跑
     if n_resume:
         print("[CodeBee] 已自动恢复 %d 个中断的连载任务（断点续跑）" % n_resume)
+    n_rq = jobs.requeue_pending()   # 启动补队：队列在内存里，重启会让排队项变僵尸
+    if n_rq:
+        print("[CodeBee] 已重新入队 %d 个遗留排队运行" % n_rq)
     _step("正在启动自动化调度…")
     n_auto = automation.start()   # 自动化：加载定时任务并拉起调度线程（错过的一次性任务不补跑）
     if n_auto: