codebee 0.1.4 → 0.1.6

package/app/core/gitmod.py

@@ -66,6 +66,11 @@ def repo_info(workdir):
             if h.strip():
                 recent.append({"hash": h.strip(), "subject": subj.strip()[:120]})
     br = (branch["stdout"] or "").strip() if branch["ok"] else ""
+    if br == "HEAD":
+        # 游离 HEAD 时 abbrev-ref 返回字面量 "HEAD"——统一成哨兵值。
+        # 否则「切回 from_branch」会把 "HEAD" 当分支名原样 checkout，
+        # 而 git checkout HEAD 是原地空转（退出码 0 但不换位），分支永远切不走。
+        br = "(游离 HEAD)"
     return {
         "repo": True,
         "branch": br or "(游离 HEAD)",
@@ -408,7 +413,7 @@ def finalize_run(workdir, gitinfo, message):
     # 切回原分支；原为游离 HEAD 时回到基线提交（同样游离）
     back = (gitinfo or {}).get("from_branch") or ""
     base = (gitinfo or {}).get("base_commit") or ""
-    target = back if (back and back != "(游离 HEAD)" and back != branch) else base
+    target = back if (back and back not in ("(游离 HEAD)", "HEAD") and back != branch) else base
     if target:
         co = _git(workdir, "checkout", "--quiet", target, timeout=60)
         if not co["ok"]:
@@ -472,6 +477,12 @@ def merge_task_branch(workdir, task):
             out = {"restore_error": ""}
             _restore_stash(wd, stash_sha, out)
         return refuse("无法确定任务分支的基线分支（找不到带检出信息的运行记录），请手工合并")
+    if origin in ("HEAD", "(游离 HEAD)"):
+        # 老数据里游离基线存的是字面量 "HEAD"：合并没有分支可落，显式拒绝
+        if stash_sha:
+            out = {"restore_error": ""}
+            _restore_stash(wd, stash_sha, out)
+        return refuse("任务分支从游离 HEAD 检出，没有可合并的基线分支；请手工合并")
     if cur != origin:
         if stash_sha:
             out = {"restore_error": ""}
@@ -516,11 +527,56 @@ def merge_task_branch(workdir, task):
     return True, "", info_out
 
 
+def _worktrees_on_branch(workdir, br):
+    """git worktree list --porcelain → 检出 br 的工作树路径列表。
+
+    porcelain 自 git 2.7 起可用；解析失败返回 None（调用方显式拒绝，
+    绝不带着「分支可能仍被占用」硬删）。
+    """
+    w = _git(workdir, "worktree", "list", "--porcelain")
+    if not w["ok"]:
+        return None
+    entries, cur = [], None
+    for ln in (w["stdout"] or "").splitlines():
+        if ln.startswith("worktree "):
+            cur = {"path": ln[len("worktree "):].strip(), "branch": ""}
+            entries.append(cur)
+        elif cur is not None and ln.startswith("branch refs/heads/"):
+            cur["branch"] = ln[len("branch refs/heads/"):].strip()
+    return [x for x in entries if x["branch"] == br]
+
+
+def _switch_off_branch(workdir, br, target):
+    """把工作树从 br 上切走，返回错误信息（成功为空串）。
+
+    先尝试切到 target；两种失败形态都兜底成游离：
+    - checkout 直接失败（如目标分支被别的工作树占用）→ --detach target；
+    - checkout「成功」却没换位（target 是 HEAD 这类原地引用，实测
+      git checkout HEAD 退出码 0 且停在原分支）→ 复查后强制游离。
+    最终以 rev-parse 复核 br 真的腾空为准，不信 checkout 的退出码。
+    """
+    co = _git(workdir, "checkout", "--quiet", target, timeout=60) if target \
+        else _git(workdir, "checkout", "--quiet", "--detach", timeout=60)
+    cur = _git(workdir, "rev-parse", "--abbrev-ref", "HEAD")
+    if (cur["stdout"] or "").strip() == br:
+        co = _git(workdir, "checkout", "--quiet", "--detach", target, timeout=60) \
+            if target else _git(workdir, "checkout", "--quiet", "--detach", timeout=60)
+        if not co["ok"]:
+            return "切离任务分支失败：%s" % (co["stderr"] or "")[-120:]
+    elif not co["ok"]:
+        return "切回 %s 失败：%s" % (target, (co["stderr"] or "")[-120:])
+    return ""
+
+
 def discard_task_branch(workdir, task):
     """丢弃任务分支（人审后的「否决」出口，不可恢复）。
 
     守卫同 merge（活跃任务/仓库缺失/分支不存在拒绝）；若工作区恰好停在
     任务分支上且干净（收尾出错的遗留现场），先切回基线再删分支。
+    分支也可能被**其它** worktree 检出（run 收尾被中断、任务分支滞留在
+    另一个工作树里）——git 拒绝删除被检出的分支，所以删前逐个清理：
+    干净的工作树切回基线（目标分支被占用就游离在那），有未提交改动的
+    不动、显式拒绝；目录已消失的残留登记由 worktree prune 清掉。
     返回 (ok, 错误信息)。
     """
     def refuse(msg):
@@ -536,19 +592,37 @@ def discard_task_branch(workdir, task):
     br = branch_name(tid)
     if not _git(wd, "rev-parse", "--verify", "--quiet", "refs/heads/" + br)["ok"]:
         return refuse("任务分支 %s 不存在（可能已被合并或丢弃）" % br)
+    latest = _latest_run_git(tid) or {}
+    back = latest.get("from_branch") or ""
+    base = latest.get("base_commit") or ""
+    target = back if (back and back not in ("(游离 HEAD)", "HEAD") and back != br) else base
     cur = info.get("branch") or ""
     if cur == br:
         if info.get("dirty"):
             return refuse("工作区停在任务分支上且有未提交改动，请先处理再丢弃")
-        latest = _latest_run_git(tid) or {}
-        back = latest.get("from_branch") or ""
-        base = latest.get("base_commit") or ""
-        target = back if (back and back != "(游离 HEAD)" and back != br) else base
         if not target:
             return refuse("工作区停在任务分支上且找不到可切回的基线，请手工切走后再丢弃")
-        co = _git(wd, "checkout", "--quiet", target, timeout=60)
-        if not co["ok"]:
-            return refuse("切回 %s 失败：%s" % (target, (co["stderr"] or "")[-160:]))
+        err = _switch_off_branch(wd, br, target)
+        if err:
+            return refuse(err)
+    wts = _worktrees_on_branch(wd, br)
+    if wts is None:
+        return refuse("无法枚举 worktree，请手工处理占用任务分支的工作树后再丢弃")
+    for wt in wts:
+        p = wt["path"]
+        if not os.path.isdir(p):
+            continue
+        st = _git(p, "status", "--porcelain")
+        dirty = [ln for ln in (st["stdout"] or "").splitlines()
+                 if ln.strip() and not _attach_entry(ln.strip())] if st["ok"] else []
+        if dirty:
+            return refuse("任务分支仍被工作树 %s 占用且其中有未提交改动，"
+                          "请先处理后再丢弃" % p)
+        err = _switch_off_branch(p, br, target)
+        if err:
+            return refuse("工作树 %s %s" % (p, err))
+    if wts:
+        _git(wd, "worktree", "prune")
     d = _git(wd, "branch", "-D", br)
     if not d["ok"]:
         return refuse("删除任务分支失败：%s" % (d["stderr"] or "")[-160:])

package/app/core/health.py

@@ -157,6 +157,58 @@ def report_failure(provider: str, error: str = "", *, model: str = "",
         _persist()
 
 
+# ------------------------------------------------- 静态死链告警（绑定层）
+
+def report_binding_dead(key: str, error: str = ""):
+    """静态死链告警：某 CLI 的绑定链在起跑前就已全部失效（厂商停用/删除/无密钥、
+    模型停用、协议不匹配）。与运行期 report_failure 的区别：不计数、不进探针，
+    立即置 down+告警（尊重静默）；绑定恢复后由 report_binding_ok 自动解除。
+    伪供应商名带「绑定链·」前缀，不会与真实厂商名相撞。"""
+    if not key:
+        return
+    with _LOCK:
+        name = "绑定链·%s" % key
+        st = _PROVIDERS.get(name)
+        if st is None:
+            st = _PROVIDERS.setdefault(name, {
+                "name": name, "provider_id": "", "model": "",
+                "status": "ok", "consecutive_failures": 0,
+                "first_fail_at": 0, "last_fail_at": 0, "last_ok_at": 0,
+                "last_error": "", "alerted": False, "silenced": False,
+                "silence_until": 0, "probe_next_at": 0, "probe_backoff_idx": 0,
+                "recovered_at": 0,
+            })
+        st["static"] = True
+        st["binding_key"] = str(key)
+        st["name"] = name
+        st["status"] = "down"
+        st["last_fail_at"] = _now()
+        st["last_error"] = str(error or "")[:300]
+        st["probe_next_at"] = 0
+        if not _effective_silenced(st) and not st.get("alerted"):
+            st["alerted"] = True
+            log.warning("[health] ⚠️ 绑定链告警：%s 全部失效（%s）",
+                        name, st["last_error"][:120])
+        _persist()
+
+
+def report_binding_ok(key: str):
+    """绑定链恢复可用：自动解除该 CLI 的静态死链告警（无记录时零开销）。"""
+    if not key:
+        return
+    with _LOCK:
+        st = _PROVIDERS.get("绑定链·%s" % key)
+        if not st or not st.get("static"):
+            return
+        st["status"] = "recovered"
+        st["alerted"] = False
+        st["silenced"] = False
+        st["silence_until"] = 0
+        st["recovered_at"] = _now()
+        log.info("[health] 绑定链 %s 已恢复（静态告警解除）", st["name"])
+        _persist()
+
+
 # ---------------------------------------------------------------- 手动操作
 
 def silence(provider: str, minutes: int = 0):
@@ -215,6 +267,7 @@ def snapshot():
                 "last_error": st.get("last_error") or "",
                 "alerting": alerting,
                 "silenced": silenced,
+                "static": bool(st.get("static")),
             })
         # 稳定排序：告警中 > 故障中 > 恢复 > 正常
         rank = {"down": 0, "failing": 1, "recovered": 2, "ok": 3}
@@ -271,7 +324,8 @@ def _probe_loop():
         try:
             with _LOCK:
                 targets = [(name, st) for name, st in _PROVIDERS.items()
-                           if st.get("status") in ("failing", "down")
+                           if not st.get("static")  # 静态死链无端点可探，绑定恢复时自动解除
+                           and st.get("status") in ("failing", "down")
                            and (st.get("probe_next_at") or 0) <= _now()]
                 for name, st in targets:
                     idx = int(st.get("probe_backoff_idx") or 0)

package/app/core/history.py

@@ -18,14 +18,20 @@ def agent_stats(limit=200):
             s["wins"] += 1
 
     for run in store.list_runs(limit):
-        if run.get("kind") != "orchestration" or run.get("status") != "done":
+        if run.get("kind") != "orchestration":
+            continue
+        # 失败运行也要进历史（记为全负）：以前只数 done——常挂的 CLI 永远
+        # 「无历史记录」满血参选，2026-09-17 opencode 当日秒挂 3 次仍被换将
+        # 选中。cancelled 不算（用户取消非智能体之过）。
+        if run.get("status") not in ("done", "failed"):
             continue
         verdict = run.get("verdict") or {}
         task = store.get_task(run.get("task_id")) if run.get("task_id") else None
         ttype = (task or {}).get("type") or verdict.get("type")
         if not ttype:
             continue
-        win = bool(verdict.get("pass") or verdict.get("publishable"))
+        win = run.get("status") == "done" and bool(
+            verdict.get("pass") or verdict.get("publishable"))
         for s in run.get("steps") or []:
             if s.get("role") in ("implement", "draft"):
                 bump(s.get("agent"), ttype, win)

package/app/core/jobs.py

@@ -134,7 +134,9 @@ def cancel_event_for(run_id):
     return ev
 
 
-AUTO_RESUME_MAX = 2      # 连载任务自动续跑上限（超时/中断后自动接着写，无需人工）
+AUTO_RESUME_MAX = 3      # 连载任务自动续跑上限（超时/中断后自动接着写，无需人工）
+AUTO_RESUME_DELAY_S = 300  # 自动续跑延迟入队秒数：网关限流/欠费窗口通常分钟级，
+                           # 立即重排会撞在同一堵墙上把续跑次数烧光（2026-09-17 七猫实测）
 
 
 def _maybe_auto_resume(run_id):
@@ -160,7 +162,13 @@ def _maybe_auto_resume(run_id):
             return False
         store.update_run(new_run["id"], auto_resumes=int(run.get("auto_resumes") or 0) + 1,
                          auto_resumed_from=run_id)
-        _QUEUE.put({"kind": "orchestration", "run_id": new_run["id"], "task_id": task["id"]})
+
+        def _enqueue():
+            _QUEUE.put({"kind": "orchestration",
+                        "run_id": new_run["id"], "task_id": task["id"]})
+        t = threading.Timer(AUTO_RESUME_DELAY_S, _enqueue)
+        t.daemon = True
+        t.start()
         return True
     except Exception:
         return False
@@ -205,6 +213,9 @@ def resume_interrupted(limit=3):
                 continue
             if run.get("cancelled_by_user"):
                 continue
+            if run.get("paused"):
+                continue   # 用户主动暂停的运行（重启收尸后 paused 标志保留）不自动续跑——
+                           # 「继续」由用户点「继续任务」决定，不替用户做主
             if not _recent(run):
                 continue
             if latest_by_task.get(run["task_id"]) != run["id"]:
@@ -320,8 +331,12 @@ def _do_mgmt(job, ev):
             store.finish_step(run_id, step["n"], "failed", summary="该智能体未安装或未启用编排")
             store.update_run(run_id, status="failed", error="未启用", ended_at=_now())
             return
-        res = _r.run_agent(agent, "连通性测试：请只回复两个字：OK", readonly=True,
-                           timeout=180, cancel_event=ev, log_path=str(log_abs))
+        res = _r.run_agent(agent, "连通性测试：请只回复两个字：OK",
+                           readonly=True,
+                           # 300s：codex CLI 启动要拉 5 个 MCP 服务器 + 注入约 13 万
+                           # token 技能上下文，首 token 常超 180s（2026-09-17 实测
+                           # 网关裸探 8s 就回，慢在 CLI 自身启动与上下文）。
+                           timeout=300, cancel_event=ev, log_path=str(log_abs))
         ok = res["ok"] and "OK" in (res.get("text") or "").upper()
         try:
             _usage.record(source="smoke", run_id=run_id, step=step["n"], role="smoke",

package/app/core/manager.py

@@ -69,6 +69,55 @@ def detect_entry(entry):
     return {"installed": False, "detail": ""}
 
 
+def sweep_orphan_cli_processes():
+    """启动清扫：服务重启会孤儿化正在跑的 CLI 孙进程（外部只杀服务 PID，不带
+    /T），僵尸 opencode 更会劫持后续会话——opencode 是客户端-服务端架构，新
+    `opencode run` 连上僵尸实例后 shell 全在僵尸的项目根里跑（2026-09-17
+    mo-so 实测：agent 在 Temp 里找代码，汇报「工作目录没有源码」）。
+
+    按「Tutti 调用签名 + 父进程已死」双条件匹配，不误杀用户自己在用的 CLI：
+      opencode：命令行含 opencode + --model（同步写入的 provider 固定 orch）
+      codex：命令行含 codex + --skip-git-repo-check（Tutti 专属 flag 组合）
+      kimi：命令行含 kimi-code/dist/main.mjs（node 直启路径，2026-09-17 实测
+      僵尸 kimi 会占住讯飞网关同钥请求队列，堵死后续所有 kimi 调用）
+    claude 不扫（签名与用户手动使用难区分）。返回清扫数量。"""
+    ps_exe = os.path.join(os.environ.get("SystemRoot", r"C:\Windows"),
+                          "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+    if not os.path.isfile(ps_exe):
+        ps_exe = "powershell"
+    ps = ("Get-CimInstance Win32_Process | "
+          "Where-Object { $_.Name -match '^(opencode|codex|node|cmd)\\.exe$' } | "
+          "Select-Object ProcessId,ParentProcessId,CommandLine | ConvertTo-Json -Compress")
+    try:
+        r = subprocess.run([ps_exe, "-NoProfile", "-Command", ps],
+                           capture_output=True, creationflags=CREATE_NO_WINDOW, timeout=60)
+        import json as _json
+        raw = r.stdout.decode("utf-8", "replace").strip()
+        items = _json.loads(raw) if raw else []
+        if isinstance(items, dict):
+            items = [items]
+        live = {i.get("ProcessId") for i in items}
+        killed = 0
+        for i in items:
+            cl = str(i.get("CommandLine") or "").lower()
+            ppid = i.get("ParentProcessId")
+            is_ours = (("opencode" in cl and "--model" in cl)
+                       or ("codex" in cl and "--skip-git-repo-check" in cl)
+                       or ("kimi-code" in cl and "main.mjs" in cl))
+            if not is_ours or ppid in live or not i.get("ProcessId"):
+                continue
+            try:
+                subprocess.run(["taskkill", "/F", "/T", "/PID", str(i["ProcessId"])],
+                               capture_output=True, creationflags=CREATE_NO_WINDOW,
+                               timeout=15)
+                killed += 1
+            except Exception:
+                pass
+        return killed
+    except Exception:
+        return 0
+
+
 def detect_all(force=False):
     """检测全部条目。检测（慢磁盘 IO）在锁外跑：shutil.which/isfile 在
     Windows 上遇到断链的 PATH 项可能卡数秒，持锁会把所有并发请求堵死
@@ -786,6 +835,11 @@ def _sync_codex_settings(entry, model, cp):
     name = cp.get("name", "orch")
     def q(v):
         return '"%s"' % str(v).replace("\\", "\\\\").replace('"', '\\"')
+    if (cp.get("wire_api") or "responses") == "chat":
+        # codex 0.154+ 起 chat wire 被官方移除，写进 config.toml 会让 CLI 连配置
+        # 都载入不了（Error loading config.toml）——宁可明确拒绝也不落坏配置。
+        return ("供应商只有 chat completions wire，codex 0.154+ 已移除支持，未写入"
+                " config.toml——请为 codex 绑定 responses 兼容的供应商")
     pairs = [("name", q(cp.get("name", name))),
              ("base_url", q(cp.get("base_url", ""))),
              ("env_key", q(cp.get("env_key", "ORCH_API_KEY"))),
@@ -1091,10 +1145,18 @@ def _sync_opencode_settings(entry, model, prov):
     全不存在时建 catalog 登记的那个。纯 JSON 走整体读改写；带注释的 JSONC 走
     文本级就地 patch（保留注释）。返回错误串或 None。"""
     npm = "@ai-sdk/anthropic" if prov.get("protocol") == "anthropic" else "@ai-sdk/openai-compatible"
+    base = prov.get("base_url") or ""
+    if prov.get("protocol") == "anthropic" and not base.rstrip("/").endswith("/v1"):
+        # @ai-sdk/anthropic 在 baseURL 后只拼 /messages（官方默认 baseURL 本身带
+        # /v1），而 models.json 里 anthropic 供应商的 base 不带 /v1（modelhub
+        # 发请求时自己补）——不补会打到 <host>/messages，网关回 "Not Allowed"
+        # （2026-09-17 公司Anthropic 实测）。
+        base = base.rstrip("/") + "/v1"
     block = {"npm": npm, "name": prov.get("name") or "CodeBee 绑定",
-             "options": {"baseURL": prov.get("base_url") or "",
+             "options": {"baseURL": base,
                          "apiKey": prov.get("api_key") or ""},
              "models": {model: {"name": model}} if model else {}}
+    top_perms = {"edit": "allow", "bash": "allow", "webfetch": "allow"}
     top_model = ("orch/" + model) if model else ""
     targets = [p for p in _opencode_config_candidates(entry) if os.path.isfile(p)] \
         or [_opencode_config_candidates(entry)[0]]
@@ -1130,6 +1192,10 @@ def _sync_opencode_settings(entry, model, prov):
                 data["provider"] = provs
                 if top_model:
                     data["model"] = top_model
+                # 无人值守必配：headless 下 opencode 工具调用默认要审批，全部被
+                # 拒（"The user rejected permission..."，2026-09-17 实测）——
+                # 按用户拍板的「默认给全部权限」写入放行段
+                data["permission"] = top_perms
                 new_text = json.dumps(data, ensure_ascii=False, indent=2) + "\n"
             else:  # JSONC（带注释）：文本级 patch
                 block_json = json.dumps(block, ensure_ascii=False)
@@ -1140,6 +1206,8 @@ def _sync_opencode_settings(entry, model, prov):
                 if top_model:
                     new_text, _ = _jsonc_set(new_text, ("model",),
                                              json.dumps(top_model))
+                new_text, _ = _jsonc_set(new_text, ("permission",),
+                                         json.dumps(top_perms))
             if os.path.isfile(path):
                 shutil.copyfile(path, path + ".bak")
             Path(path).write_bytes(new_text.encode("utf-8"))
@@ -1148,12 +1216,102 @@ def _sync_opencode_settings(entry, model, prov):
     return "；".join(errs) or None
 
 
+def _kimi_render(prov, model):
+    """渲染 kimi-code 的 CodeBee 托管块（顶层键在前，表在后——TOML 语义）。"""
+    import re as _re
+    ptype = "anthropic" if prov.get("protocol") == "anthropic" else "openai"
+    base = prov.get("base_url") or ""
+    alias = model or "default"
+    pname = (prov.get("name") or "CodeBee").replace("\"", "")
+    return (
+        "# >>> CodeBee managed (do not edit between markers) >>>\n"
+        "defaultProvider = \"orch\"\n"
+        "defaultModel = \"%s\"\n"
+        "yolo = true\n"
+        "defaultPermissionMode = \"yolo\"\n"
+        "\n"
+        "[providers.orch]\n"
+        "type = \"%s\"\n"
+        "name = \"%s\"\n"
+        "baseUrl = \"%s\"\n"
+        "apiKey = \"%s\"\n"
+        "\n"
+        "[models.\"%s\"]\n"
+        "provider = \"orch\"\n"
+        "model = \"%s\"\n"
+        "maxContextSize = 131072\n"
+        "displayName = \"%s · %s\"\n"
+        "# <<< CodeBee managed <<<\n"
+        % (alias, ptype, pname, base,
+           (prov.get("api_key") or "").replace("\"", ""),
+           alias, alias, pname, alias))
+
+
+def _sync_kimi_settings(entry, model, prov):
+    """kimi-code 专属：把绑定供应商写进 ~/.kimi-code/config.toml。
+
+    schema 从官方 bundle 反推（2026-09-17）：顶层 defaultProvider/defaultModel/
+    yolo/defaultPermissionMode（camelCase）+ [providers.<id>]（type/apiKey/
+    baseUrl）+ [models.<别名>]（provider/model/maxContextSize 必填）。无人值守
+    要 yolo——否则工具调用逐个要审批，headless 全被拒。文本级托管块（标记注释
+    之间）幂等重写，用户自有内容保留在外。"""
+    import re as _re
+    top_keys = ("defaultProvider", "defaultModel", "yolo", "defaultPermissionMode")
+    targets = [os.path.abspath(os.path.expanduser("~/.kimi-code/config.toml"))]
+    errs = []
+    for path in targets:
+        try:
+            Path(path).parent.mkdir(parents=True, exist_ok=True)
+            text = ""
+            if os.path.isfile(path):
+                text = open(path, encoding="utf-8", errors="replace", newline="").read()
+                shutil.copyfile(path, path + ".bak")
+            # 移除旧托管块与旧顶层键（防重复/防键落进别的表）
+            text = _re.sub(r"# >>> CodeBee managed.*?# <<< CodeBee managed <<<\n?",
+                           "", text, flags=_re.S)
+            for k in top_keys:
+                text = _re.sub(r"(?m)^%s\s*=.*$\n?" % k, "", text)
+            body = _re.sub(r"\n+$", "\n", text).lstrip("\n")
+            managed = _kimi_render(prov, model)
+            has_table = _re.search(r"(?m)^\[", body) is not None
+            top = "".join("%s\n" % ln for ln in managed.split("\n")
+                          if _re.match(r"^(%s)\s*=" % "|".join(top_keys), ln))
+            tables = "\n".join(ln for ln in managed.split("\n")
+                               if not _re.match(r"^(%s)\s*=" % "|".join(top_keys), ln))
+            if has_table:
+                new_text = top + "\n" + body + "\n" + tables
+            else:
+                new_text = (body + "\n" if body else "") + managed
+            Path(path).write_bytes(new_text.encode("utf-8"))
+        except Exception as e:
+            errs.append("%s: %r" % (path, e))
+    return "；".join(errs) or None
+
+
+def sync_cli_config_now(agent_id):
+    """运行期自愈：CLI 本体没配置（如 kimi「No model configured」）→ 立即把
+    绑定注入其自家配置，换将/下轮即可用。返回给日志的备注（空=无事发生）。"""
+    try:
+        from . import modelhub
+        entry = next((a for a in catalog.load() if a.get("id") == agent_id), None)
+        if not entry:
+            return ""
+        b = modelhub.bindings().get(agent_id) or {}
+        note = _sync_agent_injection(entry, b)
+        if note:
+            return "已自动注入 %s 配置：%s" % (agent_id, note)
+        return ""
+    except Exception as e:
+        return "自动注入失败: %r" % e
+
+
 # 打开前专属注入通道：{agent_id: (可注入协议, 注入器)}。交互 TUI 脱离编排链路，
 # 只认自家配置文件里的凭据，编排降级给的 env（ORCH_API_KEY 等）对它们无效。
 _AGENT_INJECTORS = {
     "claude-code": (("anthropic",), _sync_claude_settings),
     "opencode": (("anthropic", "openai"), _sync_opencode_settings),
     "qwencode": (("openai",), _sync_qwen_settings),
+    "kimi-code": (("openai", "anthropic"), _sync_kimi_settings),
 }
 
 # 无专属注入通道的专有协议 CLI：env 注入大概率无效，打开时明确告知而非静默废