@modelzen/feishu-codex-bridge 0.4.2 → 0.5.0

package/dist/cli.js

@@ -127,6 +127,13 @@ function secretKeyForApp(appId) {
 function getShowToolCalls(cfg) {
   return cfg.preferences?.showToolCalls !== false;
 }
+function getModelDisplay(cfg) {
+  const v = cfg.preferences?.showModel;
+  if (v === "running" || v === "always" || v === "off") return v;
+  if (v === true) return "always";
+  if (v === false) return "off";
+  return "running";
+}
 function getMaxConcurrentRuns(cfg) {
   const raw = cfg.preferences?.maxConcurrentRuns;
   if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 1) return 10;
@@ -798,6 +805,25 @@ var BACKEND_CATALOG = [
     },
     // supportedModes undefined ⇒ 全档（qa/write/full）。
     blurb: "\u80FD\u529B\u6700\u5168\uFF08goal/steer/compact/resume + \u771F\u6C99\u7BB1\u53EA\u8BFB\u6863\uFF09"
+  },
+  {
+    id: "claude-agent",
+    agentFamily: "claude",
+    displayName: "Claude",
+    access: "sdk",
+    dep: {
+      // SDK 是桥的硬依赖（随桥内置），isBackendDepInstalled 路径①经 bridge 自身
+      // node_modules 的 require.resolve 恒命中 → 在 picker 里始终判为「已装」可选。
+      kind: "npm-ondemand",
+      pkg: "@anthropic-ai/claude-agent-sdk",
+      // 实测 SDK + 依赖装到用户目录约 265MB（含自带 Claude Code 运行时）；首次下载较久。
+      approxSizeMB: 265,
+      detectHint: "\u6309\u9700\u4E0B\u8F7D @anthropic-ai/claude-agent-sdk\uFF08\u7EA6 265MB\uFF0C\u590D\u7528\u672C\u673A Claude \u767B\u5F55\u6001\uFF09",
+      installCmd: "\u968F\u6865\u5DF2\u5185\u7F6E\uFF08\u5982\u7F3A\u5931\uFF1Anpm i @anthropic-ai/claude-agent-sdk\uFF09"
+    },
+    // 必须与 ClaudeAgentBackend.supportedModes 完全一致（单测强制）。
+    supportedModes: ["qa", "write", "full"],
+    blurb: "Claude Code\uFF08SDK \u5185\u7F6E\uFF0C\u590D\u7528\u672C\u673A\u767B\u5F55\uFF1Bqa/write \u8D70 OS \u6C99\u7BB1\uFF0C\u80FD\u529B\u8F83 Codex \u7CBE\u7B80\uFF09"
   }
 ];
 function visibleCatalog() {
@@ -2043,7 +2069,960 @@ var STATIC_MODELS = [
     hidden: false,
     isDefault: true,
     supportedEfforts: ["low", "medium", "high"],
-    defaultEffort: "medium"
+    defaultEffort: "medium"
+  }
+];
+
+// src/agent/claude-agent/backend.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/agent/backend-loader.ts
+import { createRequire } from "module";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join6 } from "path";
+import { pathToFileURL } from "url";
+var BackendNotInstalledError = class extends Error {
+  constructor(pkg) {
+    super(`\u540E\u7AEF\u4F9D\u8D56\u300C${pkg}\u300D\u672A\u5B89\u88C5\uFF08bridge \u81EA\u8EAB\u4E0E\u7528\u6237\u79C1\u88C5\u76EE\u5F55\u5747\u672A\u627E\u5230\uFF09`);
+    this.pkg = pkg;
+    this.name = "BackendNotInstalledError";
+  }
+  pkg;
+};
+function userAnchor() {
+  return join6(paths.backendsDir, "__backend_anchor__.cjs");
+}
+var NOT_FOUND_CODES = /* @__PURE__ */ new Set(["ERR_MODULE_NOT_FOUND", "MODULE_NOT_FOUND", "ERR_PACKAGE_PATH_NOT_EXPORTED"]);
+function isNotFound(err) {
+  const code = err?.code;
+  if (code !== void 0 && NOT_FOUND_CODES.has(code)) return true;
+  const msg = err?.message ?? "";
+  return /Failed to (load|resolve) (url|import)/i.test(msg);
+}
+async function loadBackendDep(pkg) {
+  try {
+    return await import(pkg);
+  } catch (err) {
+    if (!isNotFound(err)) throw err;
+  }
+  let resolved;
+  try {
+    resolved = createRequire(userAnchor()).resolve(pkg);
+  } catch {
+    throw new BackendNotInstalledError(pkg);
+  }
+  return await import(pathToFileURL(resolved).href);
+}
+function isBackendDepInstalled(pkg) {
+  try {
+    createRequire(import.meta.url).resolve(pkg);
+    return true;
+  } catch {
+  }
+  try {
+    createRequire(userAnchor()).resolve(pkg);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function backendsBinPath(binName) {
+  const dir = join6(paths.backendsDir, "node_modules", ".bin");
+  const candidates = process.platform === "win32" ? [join6(dir, `${binName}.cmd`), join6(dir, binName)] : [join6(dir, binName)];
+  return candidates.find((p) => existsSync3(p)) ?? null;
+}
+function isBackendBinInstalled(binName) {
+  return backendsBinPath(binName) !== null;
+}
+function isBackendEntryInstalled(entry) {
+  const { kind, binName, pkg } = entry.dep;
+  if (kind === "external-cli") return false;
+  if (binName) return isBackendBinInstalled(binName);
+  return pkg ? isBackendDepInstalled(pkg) : false;
+}
+function isBackendInstalledInUserDir(entry) {
+  const { binName, pkg } = entry.dep;
+  if (binName) return isBackendBinInstalled(binName);
+  if (!pkg) return false;
+  try {
+    createRequire(userAnchor()).resolve(pkg);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installedBackendVersion(pkg) {
+  const readVer = (file) => {
+    try {
+      const j = JSON.parse(readFileSync2(file, "utf8"));
+      return typeof j.version === "string" ? j.version : null;
+    } catch {
+      return null;
+    }
+  };
+  const inUser = join6(paths.backendsDir, "node_modules", ...pkg.split("/"), "package.json");
+  const v1 = readVer(inUser);
+  if (v1) return v1;
+  try {
+    const resolved = createRequire(import.meta.url).resolve(`${pkg}/package.json`);
+    return readVer(resolved);
+  } catch {
+    return null;
+  }
+}
+
+// src/agent/claude-agent/permission.ts
+var WRITE_TOOLS = ["Write", "Edit", "NotebookEdit"];
+var NETWORK_TOOLS = ["WebFetch", "WebSearch"];
+function permissionOptions(mode, network, cwd) {
+  const tier = mode ?? "full";
+  if (tier === "full") {
+    return { permissionMode: "bypassPermissions", allowDangerouslySkipPermissions: true };
+  }
+  const sandbox = {
+    enabled: true,
+    failIfUnavailable: true,
+    // fail-closed: error out instead of running unsandboxed.
+    autoAllowBashIfSandboxed: true,
+    // sandboxed Bash needn't prompt — the sandbox is the gate.
+    allowUnsandboxedCommands: false,
+    // CRITICAL: block the dangerouslyDisableSandbox escape.
+    ...tier === "qa" ? { filesystem: { denyWrite: [cwd] } } : {}
+  };
+  const disallowedTools = [];
+  if (tier === "qa") disallowedTools.push(...WRITE_TOOLS);
+  if (!network) disallowedTools.push(...NETWORK_TOOLS);
+  return {
+    // bypassPermissions = never prompt; the sandbox (above) is the real boundary.
+    permissionMode: "bypassPermissions",
+    allowDangerouslySkipPermissions: true,
+    sandbox,
+    ...disallowedTools.length ? { disallowedTools } : {}
+  };
+}
+
+// src/agent/claude-agent/event-map.ts
+function createTurnMapper(ctx = {}) {
+  let blockSeq = 0;
+  const open3 = /* @__PURE__ */ new Map();
+  let systemEmitted = false;
+  let initModel;
+  function map(msg) {
+    const m = msg;
+    switch (m.type) {
+      case "system":
+        if (m.subtype === "init") {
+          if (typeof m.model === "string") initModel = m.model;
+          if (!systemEmitted) {
+            systemEmitted = true;
+            return [{ type: "system", threadId: String(m.session_id ?? "") }];
+          }
+        }
+        if (m.subtype === "compact_boundary") return [{ type: "context_compacted" }];
+        return [];
+      case "stream_event":
+        return mapStreamEvent(m.event);
+      case "assistant": {
+        const content = m.message?.content ?? [];
+        const out = [];
+        for (const b of content) {
+          if (b.type === "tool_use" || b.type === "server_tool_use") {
+            out.push({
+              type: "tool_use",
+              itemId: String(b.id ?? `tool${++blockSeq}`),
+              title: toolTitle(b.name ?? "\u5DE5\u5177", b.input ?? {}, ctx.cwd),
+              detail: toolDetail(b.name ?? "", b.input ?? {})
+            });
+          }
+        }
+        return out;
+      }
+      case "user": {
+        const content = m.message?.content;
+        if (!Array.isArray(content)) return [];
+        const out = [];
+        for (const b of content) {
+          if (b.type === "tool_result") {
+            out.push({
+              type: "tool_result",
+              itemId: String(b.tool_use_id ?? ""),
+              output: toolResultText(b.content),
+              exitCode: b.is_error ? 1 : 0
+            });
+          }
+        }
+        return out;
+      }
+      case "result": {
+        const out = [];
+        const usage = m.usage;
+        if (usage) {
+          out.push({
+            type: "usage",
+            inputTokens: usage.input_tokens,
+            outputTokens: usage.output_tokens
+          });
+          const used = (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+          if (used > 0) {
+            out.push({ type: "context_usage", usedTokens: used, contextWindow: contextWindowFor(initModel) });
+          }
+        }
+        return out;
+      }
+      // Transient API hiccup the SDK auto-retries — surface a retrying footer
+      // (run-state keeps the ⏹ button and lets the next deltas overwrite it).
+      case "system_api_retry":
+      case "api_retry":
+        return [{ type: "error", message: "\u7F51\u7EDC\u6CE2\u52A8\uFF0C\u6B63\u5728\u91CD\u8BD5\u2026", willRetry: true }];
+      default:
+        return [];
+    }
+  }
+  function mapStreamEvent(ev) {
+    if (!ev || typeof ev.type !== "string") return [];
+    switch (ev.type) {
+      case "content_block_start": {
+        const idx = ev.index;
+        const cb = ev.content_block ?? {};
+        const kind = cb.type === "thinking" || cb.type === "redacted_thinking" ? "thinking" : cb.type === "text" ? "text" : cb.type === "tool_use" || cb.type === "server_tool_use" ? "tool_use" : "other";
+        open3.set(idx, { itemId: `b${++blockSeq}`, kind, acc: "" });
+        return [];
+      }
+      case "content_block_delta": {
+        const b = open3.get(ev.index);
+        if (!b) return [];
+        const d = ev.delta ?? {};
+        if (d.type === "text_delta" && typeof d.text === "string") {
+          b.acc += d.text;
+          return [{ type: "text_delta", itemId: b.itemId, delta: d.text }];
+        }
+        if (d.type === "thinking_delta" && typeof d.thinking === "string") {
+          b.acc += d.thinking;
+          return [{ type: "thinking_delta", itemId: b.itemId, delta: d.thinking }];
+        }
+        return [];
+      }
+      case "content_block_stop": {
+        const idx = ev.index;
+        const b = open3.get(idx);
+        open3.delete(idx);
+        if (!b || !b.acc) return [];
+        if (b.kind === "text") return [{ type: "text", itemId: b.itemId, text: b.acc }];
+        if (b.kind === "thinking") return [{ type: "thinking", itemId: b.itemId, text: b.acc }];
+        return [];
+      }
+      default:
+        return [];
+    }
+  }
+  return { map };
+}
+function toolTitle(name, input2, cwd) {
+  const s = (k2) => typeof input2[k2] === "string" ? input2[k2] : "";
+  switch (name) {
+    case "Bash":
+    case "BashOutput":
+      return s("command") || "Shell \u547D\u4EE4";
+    case "Read":
+      return `\u8BFB\u53D6 ${displayPath2(s("file_path"), cwd)}`;
+    case "Write":
+      return `\u5199\u5165 ${displayPath2(s("file_path"), cwd)}`;
+    case "Edit":
+    case "MultiEdit":
+      return `\u7F16\u8F91 ${displayPath2(s("file_path"), cwd)}`;
+    case "NotebookEdit":
+      return `\u7F16\u8F91\u7B14\u8BB0\u672C ${displayPath2(s("notebook_path"), cwd)}`;
+    case "Glob":
+      return `\u67E5\u627E ${s("pattern")}`.trim();
+    case "Grep":
+      return `\u641C\u7D22 ${s("pattern")}`.trim();
+    case "WebFetch":
+      return `\u6293\u53D6\u7F51\u9875 ${s("url")}`.trim();
+    case "WebSearch":
+      return `\u8054\u7F51\u641C\u7D22 ${s("query")}`.trim();
+    case "Task":
+      return `\u5B50\u4EFB\u52A1\uFF1A${s("description") || s("subagent_type") || ""}`.trim();
+    case "TodoWrite":
+      return "\u66F4\u65B0\u5F85\u529E\u6E05\u5355";
+    case "ExitPlanMode":
+      return "\u63D0\u4EA4\u65B9\u6848";
+    default:
+      return name || "\u5DE5\u5177\u8C03\u7528";
+  }
+}
+function toolDetail(name, input2) {
+  if (name === "Bash" && typeof input2.description === "string" && input2.description) {
+    return input2.description;
+  }
+  return void 0;
+}
+function toolResultText(content) {
+  if (content == null) return void 0;
+  if (typeof content === "string") return content || void 0;
+  if (Array.isArray(content)) {
+    const text = content.map((b) => {
+      const x = b;
+      if (x?.type === "text" && typeof x.text === "string") return x.text;
+      if (x?.type === "image") return "[\u56FE\u7247]";
+      return "";
+    }).join("").trim();
+    return text || void 0;
+  }
+  return void 0;
+}
+var PATH_TAIL_MAX2 = 40;
+function displayPath2(p, cwd) {
+  if (!p) return "\u6587\u4EF6";
+  if (cwd) {
+    const sep2 = cwd.includes("\\") ? "\\" : "/";
+    const root = cwd.endsWith(sep2) ? cwd : cwd + sep2;
+    if (p.startsWith(root) && p.length > root.length) return p.slice(root.length);
+  }
+  if (p.length <= PATH_TAIL_MAX2 || !p.includes("/")) return p;
+  const segs = p.split("/");
+  let out = segs[segs.length - 1] ?? p;
+  for (let i = segs.length - 2; i >= 0; i--) {
+    const cand = `${segs[i]}/${out}`;
+    if (cand.length > PATH_TAIL_MAX2) break;
+    out = cand;
+  }
+  return `\u2026/${out}`;
+}
+function contextWindowFor(model) {
+  const id = typeof model === "string" ? model.toLowerCase() : "";
+  if (!id) return null;
+  if (id.includes("1m") || id.includes("[1m]")) return 1e6;
+  return 2e5;
+}
+function resultErrorText(m) {
+  const result = m.result;
+  if (typeof result === "string" && result.trim()) return result.trim();
+  const subtype = m.subtype;
+  if (typeof subtype === "string") {
+    if (subtype === "error_max_turns") return "\u5DF2\u8FBE\u5230\u6700\u5927\u8F6E\u6B21\u9650\u5236";
+    if (subtype === "error_max_budget_usd") return "\u5DF2\u8FBE\u5230\u9884\u7B97\u4E0A\u9650";
+    return `\u8FD0\u884C\u51FA\u9519\uFF08${subtype}\uFF09`;
+  }
+  return "\u8FD0\u884C\u51FA\u9519";
+}
+
+// src/agent/claude-agent/history.ts
+function mapSessionSummary(s) {
+  const preview = (s.customTitle || s.summary || s.firstPrompt || "").trim();
+  return {
+    sessionId: s.sessionId,
+    preview,
+    createdAt: msToSec(s.createdAt ?? s.lastModified),
+    updatedAt: msToSec(s.lastModified),
+    name: s.customTitle || void 0
+  };
+}
+function msToSec(ms) {
+  return ms && ms > 0 ? Math.floor(ms / 1e3) : 0;
+}
+function blocksOf(message) {
+  const content = message?.content;
+  if (typeof content === "string") return [{ type: "text", text: content }];
+  if (Array.isArray(content)) return content;
+  return [];
+}
+function isBoilerplateUserText2(text) {
+  const t = text.trimStart();
+  return t.startsWith("<environment_context>") || t.startsWith("# AGENTS.md") || t.startsWith("<system-reminder>") || t.startsWith("Caveat:");
+}
+function toolResultText2(content) {
+  if (content == null) return void 0;
+  if (typeof content === "string") return content || void 0;
+  if (Array.isArray(content)) {
+    const text = content.map((b) => {
+      const x = b;
+      return x?.type === "text" && typeof x.text === "string" ? x.text : "";
+    }).join("").trim();
+    return text || void 0;
+  }
+  return void 0;
+}
+function foldSessionMessages(messages, maxTurns, cwd) {
+  const turns = [];
+  const toolById = /* @__PURE__ */ new Map();
+  let cur = null;
+  const flush = () => {
+    if (cur && cur._hasContent) {
+      const { _hasContent, ...turn } = cur;
+      void _hasContent;
+      turns.push(turn);
+    }
+    cur = null;
+  };
+  const ensure = () => {
+    if (!cur) cur = { userText: "", assistantText: "", reasoning: "", tools: [], _hasContent: false };
+    return cur;
+  };
+  for (const msg of messages) {
+    const blocks = blocksOf(msg.message);
+    if (msg.type === "user") {
+      const texts = [];
+      let attachedResult = false;
+      for (const b of blocks) {
+        if (b.type === "text" && b.text && !isBoilerplateUserText2(b.text)) texts.push(b.text);
+        else if (b.type === "tool_result" && b.tool_use_id) {
+          const tool = toolById.get(b.tool_use_id);
+          if (tool) {
+            tool.output = toolResultText2(b.content);
+            if (b.is_error) tool.failed = true;
+            attachedResult = true;
+          }
+        }
+      }
+      const userText = texts.join("\n").trim();
+      if (userText) {
+        flush();
+        const t = ensure();
+        t.userText = userText;
+        t._hasContent = true;
+      } else if (attachedResult) {
+        ensure()._hasContent = true;
+      }
+    } else if (msg.type === "assistant") {
+      const t = ensure();
+      for (const b of blocks) {
+        if (b.type === "text" && b.text) {
+          t.assistantText = t.assistantText ? `${t.assistantText}
+
+${b.text}` : b.text;
+          t._hasContent = true;
+        } else if (b.type === "thinking" && b.thinking) {
+          t.reasoning = t.reasoning ? `${t.reasoning}
+
+${b.thinking}` : b.thinking;
+          t._hasContent = true;
+        } else if ((b.type === "tool_use" || b.type === "server_tool_use") && b.id) {
+          const tool = { title: toolTitle(b.name ?? "\u5DE5\u5177", b.input ?? {}, cwd) };
+          t.tools.push(tool);
+          toolById.set(b.id, tool);
+          t._hasContent = true;
+        }
+      }
+    }
+  }
+  flush();
+  const totalTurns = turns.length;
+  const kept = totalTurns > maxTurns ? turns.slice(totalTurns - maxTurns) : turns;
+  return { turns: kept, totalTurns };
+}
+
+// src/agent/claude-agent/thread.ts
+var COMPACT_TIMEOUT_MS2 = 12e4;
+var ABORT_ESCALATE_MS = 4e3;
+var Inbox = class {
+  buf = [];
+  waiters = [];
+  push(v) {
+    const w = this.waiters.shift();
+    if (w) w(v);
+    else this.buf.push(v);
+  }
+  next() {
+    const v = this.buf.shift();
+    if (v !== void 0) return Promise.resolve(v);
+    return new Promise((resolve8) => this.waiters.push(resolve8));
+  }
+};
+var PushablePrompt = class {
+  buf = [];
+  waiters = [];
+  closed = false;
+  push(msg) {
+    if (this.closed) return;
+    const w = this.waiters.shift();
+    if (w) w(msg);
+    else this.buf.push(msg);
+  }
+  close() {
+    this.closed = true;
+    while (this.waiters.length) this.waiters.shift()(null);
+  }
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      const v = this.buf.shift();
+      if (v !== void 0) {
+        yield v;
+        continue;
+      }
+      if (this.closed) return;
+      const next = await new Promise((resolve8) => this.waiters.push(resolve8));
+      if (next == null) return;
+      yield next;
+    }
+  }
+};
+function toSdkEffort(e) {
+  if (!e) return void 0;
+  if (e === "none" || e === "minimal") return "low";
+  return e;
+}
+function toUserMessage(input2) {
+  const text = input2.text ?? "";
+  return {
+    type: "user",
+    message: { role: "user", content: text },
+    parent_tool_use_id: null
+  };
+}
+function goalPrompt(objective) {
+  return [
+    "\u3010\u81EA\u4E3B\u76EE\u6807\u3011\u8BF7\u8FDE\u7EED\u3001\u81EA\u4E3B\u5730\u5B8C\u6210\u4E0B\u9762\u7684\u76EE\u6807\uFF1A\u6309\u9700\u4F7F\u7528\u5DE5\u5177\uFF0C\u4E00\u6B65\u6B65\u505A\u5230\u5B8C\u6210\u4E3A\u6B62\uFF0C",
+    "\u4E2D\u9014\u4E0D\u8981\u505C\u4E0B\u6765\u7B49\u6211\u786E\u8BA4\uFF1B\u5B8C\u6210\u540E\u7528\u4E00\u6BB5\u8BDD\u603B\u7ED3\u505A\u4E86\u4EC0\u4E48\u3002",
+    "",
+    `\u76EE\u6807\uFF1A${objective}`
+  ].join("\n");
+}
+function goalStatusFromResult(subtype) {
+  if (subtype === "error_max_budget_usd") return "budgetLimited";
+  return "blocked";
+}
+var ClaudeAgentThread = class {
+  sessionId;
+  cwd;
+  model;
+  effort;
+  input = new PushablePrompt();
+  query;
+  abortController = new AbortController();
+  dead = false;
+  interruptRequested = false;
+  /** true while a runGoal() turn is in flight — clearGoal() only hard-stops then. */
+  goalRunning = false;
+  /** true while ANY turn (runStreamed/runGoal) is in flight — gates abort escalation. */
+  turnInFlight = false;
+  escalateTimer;
+  turnSeq = 0;
+  currentTurnId;
+  lastActivityAt = Date.now();
+  sink;
+  constructor(cfg) {
+    this.sessionId = cfg.sessionId;
+    this.cwd = cfg.cwd;
+    this.model = cfg.model;
+    this.effort = cfg.effort;
+    const options = {
+      cwd: cfg.cwd,
+      abortController: this.abortController,
+      includePartialMessages: true,
+      ...cfg.model ? { model: cfg.model } : {},
+      ...toSdkEffort(cfg.effort) ? { effort: toSdkEffort(cfg.effort) } : {},
+      ...cfg.resume ? { resume: cfg.sessionId } : { sessionId: cfg.sessionId },
+      ...cfg.systemPromptAppend ? { systemPrompt: { type: "preset", preset: "claude_code", append: cfg.systemPromptAppend } } : {},
+      // permission tier (permissionMode / sandbox / canUseTool / disallowedTools)
+      ...cfg.permission,
+      stderr: (d) => {
+        const s = String(d).trim();
+        if (s) log.info("agent", "sdk-stderr", { backend: "claude-agent", line: s.slice(0, 300) });
+      }
+    };
+    this.query = cfg.query({ prompt: this.input, options });
+    void this.pump();
+  }
+  /** Single background consumer: route every query message to the current turn. */
+  async pump() {
+    try {
+      for await (const msg of this.query) {
+        this.lastActivityAt = Date.now();
+        this.sink?.({ kind: "msg", msg });
+      }
+      this.dead = true;
+      this.sink?.({ kind: "end" });
+    } catch (err) {
+      this.dead = true;
+      log.fail("agent", err, { backend: "claude-agent", phase: "pump" });
+      this.sink?.({ kind: "error", err });
+    }
+  }
+  runStreamed(input2, turn) {
+    const turnId = `t${++this.turnSeq}`;
+    this.currentTurnId = turnId;
+    this.interruptRequested = false;
+    this.turnInFlight = true;
+    if (turn?.model && turn.model !== this.model) {
+      this.model = turn.model;
+      this.query.setModel(turn.model).catch((err) => log.fail("agent", err, { phase: "setModel" }));
+    }
+    if (turn?.effort) this.effort = turn.effort;
+    const mapper = createTurnMapper({ cwd: this.cwd });
+    const inbox = new Inbox();
+    const mySink = (item) => inbox.push(item);
+    this.sink = mySink;
+    this.input.push(toUserMessage(input2));
+    const self = this;
+    async function* gen() {
+      yield { type: "turn_started", turnId };
+      try {
+        while (true) {
+          const item = await inbox.next();
+          if (item.kind === "end" || item.kind === "error") {
+            if (self.interruptRequested) {
+              yield { type: "done", turnId };
+              return;
+            }
+            const msg2 = item.kind === "error" && item.err instanceof Error ? item.err.message : "Claude \u4F1A\u8BDD\u8FDB\u7A0B\u5DF2\u9000\u51FA";
+            yield { type: "error", message: msg2 || "Claude \u4F1A\u8BDD\u51FA\u9519", willRetry: false };
+            return;
+          }
+          const msg = item.msg;
+          self.lastActivityAt = Date.now();
+          for (const ev of mapper.map(item.msg)) yield ev;
+          if (msg.type === "result") {
+            const ok = msg.subtype === "success" || self.interruptRequested;
+            if (ok) {
+              try {
+                const cu = await self.query.getContextUsage();
+                if (cu && typeof cu.totalTokens === "number" && typeof cu.maxTokens === "number") {
+                  yield { type: "context_usage", usedTokens: cu.totalTokens, contextWindow: cu.maxTokens };
+                }
+              } catch (err) {
+                log.fail("agent", err, { backend: "claude-agent", phase: "getContextUsage" });
+              }
+              yield { type: "done", turnId };
+            } else {
+              yield { type: "error", message: resultErrorText(msg), willRetry: false };
+            }
+            return;
+          }
+        }
+      } finally {
+        self.endTurn();
+        if (self.sink === mySink) self.sink = void 0;
+      }
+    }
+    return {
+      events: gen(),
+      turnId: () => self.currentTurnId,
+      lastActivity: () => self.lastActivityAt
+    };
+  }
+  /** End-of-turn bookkeeping: clear the in-flight flag + any pending ⏹ escalation. */
+  endTurn() {
+    this.turnInFlight = false;
+    if (this.escalateTimer) {
+      clearTimeout(this.escalateTimer);
+      this.escalateTimer = void 0;
+    }
+  }
+  /**
+   * /goal —— Claude 没有 codex 那种「目标引擎 + 多轮自动续跑」，但 Claude Code 的
+   * agent loop 本身就能在 ONE query turn 内自主多步跑完一个目标。所以这里把目标当作
+   * 「一个自主轮」：发带自主提示的目标 → 流式跑 → 合成 goal_update 状态（active 起、
+   * complete/blocked/budgetLimited 收）。
+   *
+   * ── 与 codex 的差异（如实）──────────────────────────────────────────────
+   *  - codex：N 个自动续跑的 turn（N 张卡片）+ 原生状态机（active/paused/complete/
+   *    budgetLimited/usageLimited/blocked）+ token 预算。
+   *  - claude：1 个自主 turn（1 张卡片，内部多步）+ 合成状态（仅 active→complete/
+   *    blocked/budgetLimited）。无 paused/usageLimited、无预算。
+   *  - ⏹ 终止 / 🎯 结束：经 clearGoal() 用 abortController 硬停（spike 实测 ~2s 停，
+   *    且 abort 后会话可 resume 续聊）——比工具执行中途的 interrupt() 可靠。
+   */
+  runGoal(objective) {
+    const turnId = `g${++this.turnSeq}`;
+    this.currentTurnId = turnId;
+    this.interruptRequested = false;
+    this.goalRunning = true;
+    this.turnInFlight = true;
+    const startedAt = Date.now();
+    const mapper = createTurnMapper({ cwd: this.cwd });
+    const inbox = new Inbox();
+    const mySink = (item) => inbox.push(item);
+    this.sink = mySink;
+    this.input.push(toUserMessage({ text: goalPrompt(objective) }));
+    const self = this;
+    async function* gen() {
+      yield { type: "goal_update", status: "active", objective, tokensUsed: 0, timeUsedSeconds: 0, tokenBudget: null };
+      yield { type: "turn_started", turnId };
+      let tokensUsed = 0;
+      const finishGoal = (status) => ({
+        type: "goal_update",
+        status,
+        objective,
+        tokensUsed,
+        timeUsedSeconds: Math.round((Date.now() - startedAt) / 1e3),
+        tokenBudget: null
+      });
+      try {
+        while (true) {
+          const item = await inbox.next();
+          if (item.kind === "end" || item.kind === "error") {
+            if (self.interruptRequested) {
+              yield { type: "done", turnId };
+            } else {
+              const m = item.kind === "error" && item.err instanceof Error ? item.err.message : "Claude \u4F1A\u8BDD\u8FDB\u7A0B\u5DF2\u9000\u51FA";
+              yield finishGoal("blocked");
+              yield { type: "error", message: m, willRetry: false };
+            }
+            return;
+          }
+          const msg = item.msg;
+          self.lastActivityAt = Date.now();
+          for (const ev of mapper.map(item.msg)) {
+            if (ev.type === "usage") tokensUsed = (ev.inputTokens ?? 0) + (ev.outputTokens ?? 0);
+            yield ev;
+          }
+          if (msg.type === "result") {
+            self.goalRunning = false;
+            const status = msg.subtype === "success" || self.interruptRequested ? "complete" : goalStatusFromResult(msg.subtype);
+            try {
+              const cu = await self.query.getContextUsage();
+              if (cu && typeof cu.totalTokens === "number" && typeof cu.maxTokens === "number") {
+                yield { type: "context_usage", usedTokens: cu.totalTokens, contextWindow: cu.maxTokens };
+              }
+            } catch {
+            }
+            yield finishGoal(status);
+            yield { type: "done", turnId };
+            return;
+          }
+        }
+      } finally {
+        self.goalRunning = false;
+        self.endTurn();
+        if (self.sink === mySink) self.sink = void 0;
+      }
+    }
+    return { events: gen(), turnId: () => self.currentTurnId, lastActivity: () => self.lastActivityAt };
+  }
+  /**
+   * Clear/terminate the goal. Claude has no goal engine, so "clear" = hard-stop the
+   * in-flight goal turn via the AbortController (interrupt() can hang mid-tool;
+   * abort reliably stops in ~2s and the session stays resumable, so chat continues
+   * via resolveThread's resume on the next message). No-op when no goal is running
+   * (this is also the orchestrator's idempotent end-of-run cleanup — keep the warm
+   * query alive on natural completion).
+   */
+  async clearGoal() {
+    if (!this.goalRunning) return;
+    this.goalRunning = false;
+    this.interruptRequested = true;
+    this.dead = true;
+    try {
+      this.abortController.abort();
+    } catch {
+    }
+  }
+  async steer() {
+    throw new Error("claude-agent \u540E\u7AEF\u6682\u4E0D\u652F\u6301\u98DE\u884C\u4E2D\u5F15\u5BFC\uFF08steer\uFF09\uFF0C\u5C06\u81EA\u52A8\u6539\u4E3A\u4E0B\u4E00\u8F6E\u53D1\u9001");
+  }
+  /**
+   * Manual /compact. Claude Code's `/compact` IS a real slash command (verified:
+   * `supportedCommands()` lists it, and sending "/compact" as input is intercepted
+   * and executed, not echoed). We send it through the persistent query and drain to
+   * the result; a `compact_boundary`(trigger:manual) means it actually compacted —
+   * "Not enough messages to compact." just ends with no boundary (compacted=false).
+   */
+  async compact() {
+    if (this.dead) throw new Error("Claude \u4F1A\u8BDD\u5DF2\u7ED3\u675F\uFF0C\u65E0\u6CD5\u538B\u7F29");
+    const inbox = new Inbox();
+    const mySink = (item) => inbox.push(item);
+    this.sink = mySink;
+    this.interruptRequested = false;
+    let timer;
+    const timeout = new Promise((resolve8) => {
+      timer = setTimeout(() => resolve8("timeout"), COMPACT_TIMEOUT_MS2);
+    });
+    let compacted = false;
+    try {
+      this.input.push(toUserMessage({ text: "/compact" }));
+      while (true) {
+        const step = await Promise.race([inbox.next(), timeout]);
+        if (step === "timeout") throw new Error(`\u538B\u7F29\u8D85\u65F6\uFF08Claude \u672A\u5728 ${COMPACT_TIMEOUT_MS2 / 1e3}s \u5185\u5B8C\u6210\uFF09`);
+        if (step.kind === "end") throw new Error("Claude \u4F1A\u8BDD\u8FDB\u7A0B\u5DF2\u9000\u51FA");
+        if (step.kind === "error") throw step.err instanceof Error ? step.err : new Error(String(step.err));
+        const msg = step.msg;
+        this.lastActivityAt = Date.now();
+        if (msg.type === "system" && msg.subtype === "compact_boundary") compacted = true;
+        if (msg.type === "result") break;
+      }
+    } finally {
+      if (timer) clearTimeout(timer);
+      if (this.sink === mySink) this.sink = void 0;
+    }
+    let usage = null;
+    try {
+      const cu = await this.query.getContextUsage();
+      if (cu && typeof cu.totalTokens === "number" && typeof cu.maxTokens === "number") {
+        usage = { usedTokens: cu.totalTokens, contextWindow: cu.maxTokens };
+      }
+    } catch {
+    }
+    return { compacted, usage };
+  }
+  async abort(_turnId) {
+    this.interruptRequested = true;
+    try {
+      await this.query.interrupt();
+    } catch (err) {
+      log.fail("agent", err, { backend: "claude-agent", phase: "interrupt" });
+    }
+    if (this.escalateTimer || !this.turnInFlight) return;
+    this.escalateTimer = setTimeout(() => {
+      this.escalateTimer = void 0;
+      if (this.dead || !this.turnInFlight) return;
+      log.info("agent", "interrupt-escalate", { backend: "claude-agent" });
+      this.dead = true;
+      try {
+        this.abortController.abort();
+      } catch {
+      }
+    }, ABORT_ESCALATE_MS);
+  }
+  isAlive() {
+    return !this.dead;
+  }
+  async close() {
+    this.dead = true;
+    this.endTurn();
+    try {
+      this.input.close();
+    } catch {
+    }
+    try {
+      this.abortController.abort();
+    } catch {
+    }
+    try {
+      this.query.close?.();
+    } catch {
+    }
+  }
+};
+
+// src/agent/claude-agent/backend.ts
+var SDK_PKG = "@anthropic-ai/claude-agent-sdk";
+var sdkPromise;
+function loadSdk() {
+  sdkPromise ??= loadBackendDep(SDK_PKG);
+  return sdkPromise;
+}
+var ClaudeAgentBackend = class {
+  id = "claude-agent";
+  displayName = "Claude";
+  capabilities = {
+    // /goal：goal-like —— 一个自主轮跑完目标 + 合成状态 + abort 硬停可终止续聊
+    // （非 codex 的多轮目标引擎，差异见 thread.runGoal）。
+    goal: true,
+    steer: false,
+    // /compact：Claude Code 原生斜杠命令（发 "/compact" 即触发，见 thread.compact）。
+    compact: true,
+    // resume 历史卡：读 ~/.claude/projects 会话存储（与 `claude -r` 同源，双向可见）。
+    resume: true,
+    approvals: false
+  };
+  // Claude's sandbox supports macOS (Seatbelt) and Linux (bubblewrap), so all
+  // three tiers are offered; qa/write fail-closed at runtime if the sandbox can't
+  // start (permission.ts sets sandbox.failIfUnavailable). See the security delta
+  // documented in permission.ts / CLAUDE_AGENT_PROGRESS.md.
+  supportedModes = ["qa", "write", "full"];
+  async isAvailable() {
+    return (await this.doctor()).ok;
+  }
+  async doctor() {
+    if (!isBackendDepInstalled(SDK_PKG)) {
+      return {
+        ok: false,
+        version: null,
+        installable: true,
+        depState: "not-installed",
+        hint: "\u70B9\u300C\u4E0B\u8F7D\u300D\u5B89\u88C5 Claude Agent SDK\uFF08\u96F6 sudo\uFF0C\u88C5\u5230\u7528\u6237\u76EE\u5F55\uFF09"
+      };
+    }
+    return {
+      ok: true,
+      version: installedBackendVersion(SDK_PKG),
+      location: SDK_PKG,
+      depState: "installed",
+      hint: "\u590D\u7528\u672C\u673A Claude \u767B\u5F55\u6001\uFF08\u672A\u767B\u5F55\u8BF7\u5148 `claude` \u767B\u5F55\uFF0C\u6216\u8BBE\u7F6E ANTHROPIC_API_KEY\uFF09"
+    };
+  }
+  async listModels() {
+    return STATIC_MODELS2;
+  }
+  /** 最近会话（newest first），读 ~/.claude/projects/<cwd-hash> 的 JSONL 存储——
+   * 与 `claude -r` 同源，故能列出本机用 `claude` 手开的会话。绝不抛错（契约）。 */
+  async listThreads(cwd, limit = 15) {
+    try {
+      const sdk = await loadSdk();
+      const sessions = await sdk.listSessions({ dir: cwd, limit });
+      return sessions.map(mapSessionSummary).sort((a, b) => b.updatedAt - a.updatedAt);
+    } catch (err) {
+      log.fail("agent", err, { backend: "claude-agent", phase: "listSessions" });
+      return [];
+    }
+  }
+  /** 某会话的转写摘要（resume 历史卡）——读 getSessionMessages 折叠成 turns，不起会话、
+   * 无 token 成本。绝不抛错（返回空）。 */
+  async readHistory(cwd, sessionId, maxTurns = 10) {
+    try {
+      const sdk = await loadSdk();
+      const messages = await sdk.getSessionMessages(sessionId, { dir: cwd });
+      return foldSessionMessages(messages, maxTurns, cwd);
+    } catch (err) {
+      log.fail("agent", err, { backend: "claude-agent", phase: "getSessionMessages", sessionId });
+      return { turns: [], totalTurns: 0 };
+    }
+  }
+  async startThread(opts) {
+    const sdk = await loadSdk();
+    return new ClaudeAgentThread({
+      sessionId: randomUUID2(),
+      resume: false,
+      cwd: opts.cwd,
+      model: opts.model,
+      effort: opts.effort,
+      permission: permissionOptions(opts.mode, opts.network, opts.cwd),
+      systemPromptAppend: BRIDGE_DEVELOPER_INSTRUCTIONS,
+      query: sdk.query
+    });
+  }
+  async resumeThread(opts) {
+    const sdk = await loadSdk();
+    return new ClaudeAgentThread({
+      sessionId: opts.sessionId,
+      resume: true,
+      cwd: opts.cwd,
+      model: opts.model,
+      effort: opts.effort,
+      permission: permissionOptions(opts.mode, opts.network, opts.cwd),
+      systemPromptAppend: BRIDGE_DEVELOPER_INSTRUCTIONS,
+      query: sdk.query
+    });
+  }
+};
+var EFFORTS = ["low", "medium", "high", "xhigh"];
+var STATIC_MODELS2 = [
+  {
+    id: "claude-opus-4-8",
+    displayName: "Claude Opus 4.8",
+    description: "\u6700\u5F3A\uFF0C\u590D\u6742\u63A8\u7406 / \u957F\u7A0B agentic",
+    supportedEfforts: EFFORTS,
+    defaultEffort: "high",
+    isDefault: true,
+    hidden: false
+  },
+  {
+    id: "claude-sonnet-4-6",
+    displayName: "Claude Sonnet 4.6",
+    description: "\u5747\u8861\uFF0C\u65E5\u5E38\u7F16\u7801",
+    supportedEfforts: EFFORTS,
+    defaultEffort: "medium",
+    isDefault: false,
+    hidden: false
+  },
+  {
+    id: "claude-haiku-4-5",
+    displayName: "Claude Haiku 4.5",
+    description: "\u6700\u5FEB\uFF0C\u8F7B\u91CF\u4EFB\u52A1",
+    supportedEfforts: ["low", "medium", "high"],
+    defaultEffort: "low",
+    isDefault: false,
+    hidden: false
   }
 ];
 
@@ -2091,72 +3070,6 @@ async function effectiveDefaultBackend(opts) {
   return defaultCache;
 }
 
-// src/agent/backend-loader.ts
-import { createRequire } from "module";
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join6 } from "path";
-import { pathToFileURL } from "url";
-function userAnchor() {
-  return join6(paths.backendsDir, "__backend_anchor__.cjs");
-}
-function isBackendDepInstalled(pkg) {
-  try {
-    createRequire(import.meta.url).resolve(pkg);
-    return true;
-  } catch {
-  }
-  try {
-    createRequire(userAnchor()).resolve(pkg);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function backendsBinPath(binName) {
-  const dir = join6(paths.backendsDir, "node_modules", ".bin");
-  const candidates = process.platform === "win32" ? [join6(dir, `${binName}.cmd`), join6(dir, binName)] : [join6(dir, binName)];
-  return candidates.find((p) => existsSync3(p)) ?? null;
-}
-function isBackendBinInstalled(binName) {
-  return backendsBinPath(binName) !== null;
-}
-function isBackendEntryInstalled(entry) {
-  const { kind, binName, pkg } = entry.dep;
-  if (kind === "external-cli") return false;
-  if (binName) return isBackendBinInstalled(binName);
-  return pkg ? isBackendDepInstalled(pkg) : false;
-}
-function isBackendInstalledInUserDir(entry) {
-  const { binName, pkg } = entry.dep;
-  if (binName) return isBackendBinInstalled(binName);
-  if (!pkg) return false;
-  try {
-    createRequire(userAnchor()).resolve(pkg);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function installedBackendVersion(pkg) {
-  const readVer = (file) => {
-    try {
-      const j = JSON.parse(readFileSync2(file, "utf8"));
-      return typeof j.version === "string" ? j.version : null;
-    } catch {
-      return null;
-    }
-  };
-  const inUser = join6(paths.backendsDir, "node_modules", ...pkg.split("/"), "package.json");
-  const v1 = readVer(inUser);
-  if (v1) return v1;
-  try {
-    const resolved = createRequire(import.meta.url).resolve(`${pkg}/package.json`);
-    return readVer(resolved);
-  } catch {
-    return null;
-  }
-}
-
 // src/agent/installer.ts
 import { mkdir as mkdir4, rm as rm2, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
@@ -2338,6 +3251,7 @@ async function rollback(bareName) {
   const target = join8(paths.backendsDir, "node_modules", ...bareName.split("/"));
   await rm2(target, { recursive: true, force: true }).catch(() => void 0);
   await removeBackendsDep(bareName);
+  await rm2(join8(paths.backendsDir, "package-lock.json"), { force: true }).catch(() => void 0);
 }
 async function removeBackendsDep(bareName) {
   const pkgFile = join8(paths.backendsDir, "package.json");
@@ -2359,7 +3273,8 @@ function stripVersion(pkg) {
 
 // src/agent/index.ts
 var REGISTRY = /* @__PURE__ */ new Map([
-  ["codex-appserver", () => new CodexAppServerBackend()]
+  ["codex-appserver", () => new CodexAppServerBackend()],
+  ["claude-agent", () => new ClaudeAgentBackend()]
 ]);
 function backendIds() {
   return catalogBackendIds();
@@ -2830,7 +3745,7 @@ import { createLarkChannel, Domain } from "@larksuiteoapi/node-sdk";
 
 // src/project/registry.ts
 import { mkdir as mkdir5, readFile as readFile6, rename as rename4, writeFile as writeFile5 } from "fs/promises";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { dirname as dirname5 } from "path";
 function defaultNoMention(p) {
   return !((p.origin ?? "created") === "joined" && (p.kind ?? "multi") === "single");
@@ -2875,7 +3790,7 @@ function withLock(fn) {
 }
 async function write(projects) {
   await mkdir5(dirname5(paths.projectsFile), { recursive: true });
-  const tmp = `${paths.projectsFile}.tmp-${process.pid}-${randomUUID2()}`;
+  const tmp = `${paths.projectsFile}.tmp-${process.pid}-${randomUUID3()}`;
   const body = { version: FILE_VERSION2, projects };
   await writeFile5(tmp, `${JSON.stringify(body, null, 2)}
 `, "utf8");
@@ -3274,14 +4189,14 @@ function buildHelpCard(scope, noMention = true, isAdmin2 = false, caps) {
   }
   return card(elements, { header: { title: "\u{1F916} \u53EF\u7528\u547D\u4EE4", template: "blue" }, summary: "\u53EF\u7528\u547D\u4EE4" });
 }
-function buildWelcomeCard(kind, docUrl, noMention = true, caps) {
+function buildWelcomeCard(kind, docUrl, noMention = true, caps, agentName = "Codex") {
   const showGoal = caps?.goal ?? true;
   const showCompact = caps?.compact ?? true;
   const showResume = caps?.resume ?? true;
   const goalLine = "\xB7 `/goal <\u76EE\u6807>` \u2192 \u81EA\u4E3B\u591A\u8F6E\u8DD1\u5230\u5B8C\u6210\uFF08\u5361\u4E0A \u23F9 \u7EC8\u6B62 / \u{1F3AF} \u7ED3\u675F\u76EE\u6807\uFF09";
   const ctxLine = showCompact ? "\xB7 `/context` \xB7 `/compact` \u2192 \u770B / \u538B\u7F29\u4E0A\u4E0B\u6587" : "\xB7 `/context` \u2192 \u770B\u4E0A\u4E0B\u6587\u5360\u6BD4";
   const elements = [
-    md("\u{1F44B} **\u6B22\u8FCE\u4F7F\u7528 Codex Bridge** \u2014 \u672C\u7FA4\u5DF2\u7ED1\u5B9A\u4E00\u4E2A\u9879\u76EE\u76EE\u5F55\uFF0C\u5728\u7FA4\u91CC\u5C31\u80FD\u9A71\u52A8\u672C\u673A Codex \u5E72\u6D3B\u3002"),
+    md(`\u{1F44B} **\u6B22\u8FCE\u4F7F\u7528 ${agentName} Bridge** \u2014 \u672C\u7FA4\u5DF2\u7ED1\u5B9A\u4E00\u4E2A\u9879\u76EE\u76EE\u5F55\uFF0C\u5728\u7FA4\u91CC\u5C31\u80FD\u9A71\u52A8\u672C\u673A ${agentName} \u5E72\u6D3B\u3002`),
     hr()
   ];
   if (kind === "single") {
@@ -3347,6 +4262,7 @@ var DM = {
   rmDo: "dm.rmDo",
   rmCancel: "dm.rmCancel",
   setTools: "dm.set.tools",
+  setShowModel: "dm.set.showModel",
   setWatchdog: "dm.set.watchdog",
   // 假死超时「自定义…」：watchdogCustom 打开输入卡，watchdogCustomSubmit 保存任意秒数
   watchdogCustom: "dm.set.watchdog.custom",
@@ -3503,6 +4419,17 @@ function buildUpdateCard(state) {
       );
   }
 }
+function buildReconnectCard(conn) {
+  const template = conn === "connected" ? "green" : "orange";
+  return card(
+    [
+      md(`\u957F\u8FDE\u63A5\u72B6\u6001\uFF1A**${conn}**`),
+      note("SDK \u4F1A\u81EA\u52A8\u91CD\u8FDE\uFF1B\u82E5\u957F\u671F\u65AD\u5F00\uFF0C\u8BF7\u5728\u7EC8\u7AEF\u91CD\u8DD1 `feishu-codex-bridge run`\uFF08\u524D\u53F0\uFF09\u6216 `feishu-codex-bridge restart`\uFF08\u540E\u53F0\u5B88\u62A4\uFF09\u3002"),
+      backToMenu()
+    ],
+    { header: { title: "\u{1F504} \u957F\u8FDE\u63A5", template } }
+  );
+}
 function connLabel(state) {
   switch (state) {
     case "connected":
@@ -3672,7 +4599,7 @@ function buildNewProjectFormCard(opts = {}) {
   ];
   if (backends.length > 1) {
     formItems.push(
-      note("\u{1F9E0} \u540E\u7AEF Agent\uFF08\u521B\u5EFA\u540E**\u56FA\u5B9A\u4E0D\u53EF\u5207\u6362**\uFF1B\u672A\u4E0B\u8F7D\u7684\u4E0D\u5728\u5217\u8868 \u2192 \u53BB Web\u300C\u540E\u7AEF Agent\u300D\u9875\u4E0B\u8F7D\uFF09"),
+      note("\u{1F9E0} \u540E\u7AEF Agent\uFF08\u521B\u5EFA\u540E**\u56FA\u5B9A\u4E0D\u53EF\u5207\u6362**\uFF1B\u6807\u6CE8\u300C\u672A\u4E0B\u8F7D\u300D\u7684\u9700\u5148\u53BB Web\u300C\u540E\u7AEF Agent\u300D\u9875\u4E0B\u8F7D\uFF0C\u9009\u5B83\u4F1A\u63D0\u793A\uFF09"),
       selectMenu({ name: "backend", placeholder: "\u9009\u62E9\u540E\u7AEF Agent", options: backends, initial: backends[0]?.value })
     );
   } else if (backends.length === 1) {
@@ -3809,38 +4736,78 @@ function optionRow(label, actionId, current, opts) {
     actions(opts.map((o) => button(o.label, { a: actionId, v: o.value }, o.value === current ? "primary" : "default")))
   ];
 }
+function settingSection(title) {
+  return { tag: "markdown", content: `**${title}**`, text_size: "notation", text_color: "grey" };
+}
+function settingItem(name, desc, actionId, current, opts) {
+  return [
+    md(`**${name}**`),
+    note(desc),
+    actions(opts.map((o) => button(o.label, { a: actionId, v: o.value }, o.value === current ? "primary" : "default")))
+  ];
+}
 function buildSettingsCard(cfg) {
   const watchdogSec = cfg.preferences?.runIdleTimeoutSeconds ?? 120;
   return card(
     [
-      md("**\u5168\u5C40\u8BBE\u7F6E**\uFF08\u7BA1\u7406\u5458\uFF09"),
-      ...optionRow("\u{1F527} \u5DE5\u5177\u8C03\u7528", DM.setTools, getShowToolCalls(cfg) ? "on" : "off", [
-        { label: "\u663E\u793A", value: "on" },
-        { label: "\u9690\u85CF", value: "off" }
-      ]),
-      md(`\u23F1 \u5047\u6B7B\u8D85\u65F6\uFF08\u5F53\u524D **${watchdogSec === 0 ? "\u5173\u95ED" : `${watchdogSec} \u79D2`}**\uFF09`),
+      settingSection("\u{1F4E4} \u8F93\u51FA\u5C55\u793A"),
+      ...settingItem(
+        "\u{1F527} \u5DE5\u5177\u8C03\u7528",
+        "\u8F93\u51FA\u65F6\u663E\u793A\u6267\u884C\u7684\u547D\u4EE4 / \u5DE5\u5177\u8C03\u7528\uFF1B\u5173\u6389\u53EA\u770B\u6700\u7EC8\u56DE\u7B54\u3002",
+        DM.setTools,
+        getShowToolCalls(cfg) ? "on" : "off",
+        [
+          { label: "\u663E\u793A", value: "on" },
+          { label: "\u9690\u85CF", value: "off" }
+        ]
+      ),
+      ...settingItem(
+        "\u{1F9E0} \u6A21\u578B\u663E\u793A",
+        "\u6BCF\u6761\u56DE\u590D\u53F3\u4E0B\u89D2\u663E\u793A\u300C\u6A21\u578B \xB7 \u63A8\u7406\u5F3A\u5EA6\u300D\u3002\u4EC5\u8F93\u51FA\u65F6\uFF1D\u53EA\u5728\u751F\u6210\u4E2D\u663E\u793A\uFF1B\u59CB\u7EC8\uFF1D\u751F\u6210\u5B8C\u540E\u5361\u7247\u4E5F\u4FDD\u7559\u3002",
+        DM.setShowModel,
+        getModelDisplay(cfg),
+        [
+          { label: "\u5173\u95ED", value: "off" },
+          { label: "\u4EC5\u8F93\u51FA\u65F6", value: "running" },
+          { label: "\u59CB\u7EC8", value: "always" }
+        ]
+      ),
+      hr(),
+      settingSection("\u23F1 \u8FD0\u884C\u63A7\u5236"),
+      md(`**\u23F1 \u5047\u6B7B\u8D85\u65F6** \xB7 \u5F53\u524D **${watchdogSec === 0 ? "\u5173\u95ED" : `${watchdogSec} \u79D2`}**`),
+      note("\u591A\u4E45\u6CA1\u6709\u4EFB\u4F55\u8F93\u51FA\u5C31\u81EA\u52A8\u7EC8\u6B62\u672C\u8F6E\uFF08\u9632\u5361\u6B7B\uFF09\u3002"),
       actions([
         ...[0, 120, 300].map(
           (v) => button(v === 0 ? "\u5173\u95ED" : `${v}\u79D2`, { a: DM.setWatchdog, v: String(v) }, v === watchdogSec ? "primary" : "default")
         ),
         button("\u81EA\u5B9A\u4E49\u2026", { a: DM.watchdogCustom })
       ]),
-      ...optionRow("\u{1F4E5} \u8FD0\u884C\u4E2D\u65B0\u6D88\u606F", DM.setPending, getPendingPolicy(cfg), [
-        { label: "\u5F15\u5BFC", value: "steer" },
-        { label: "\u6392\u961F", value: "queue" }
-      ]),
-      ...optionRow("\u26A1 \u5E76\u53D1\u4E0A\u9650", DM.setConcurrency, String(getMaxConcurrentRuns(cfg)), [
-        { label: "1", value: "1" },
-        { label: "5", value: "5" },
-        { label: "10", value: "10" },
-        { label: "20", value: "20" }
-      ]),
-      note("\u26A1 \u5E76\u53D1\u6C60\u4E3A**\u6240\u6709\u7FA4/\u8BDD\u9898\u5168\u5C40\u5171\u4EAB**\uFF1A\u6EE1\u4E86\u65B0\u4EFB\u52A1\u6309\u5148\u6765\u540E\u5230\u6392\u961F\uFF08\u6392\u961F\u5361\u53EF\u89C1\u3001\u53EF \u23F9 \u53D6\u6D88\uFF09\u3002"),
-      note("\u26A0\uFE0F \u5E76\u53D1\u4E0A\u9650 \u6539\u540E\u9700**\u91CD\u542F**\u751F\u6548\uFF1B\u5176\u4F59\u8BBE\u7F6E\uFF08\u542B\u5047\u6B7B\u8D85\u65F6\uFF09\u5373\u65F6\u751F\u6548\uFF0C\u6240\u6709\u7FA4\u7ACB\u5373\u5957\u7528\u3002"),
+      ...settingItem(
+        "\u{1F4E5} \u8FD0\u884C\u4E2D\u6765\u65B0\u6D88\u606F",
+        "\u6B63\u5728\u8DD1\u65F6\u4F60\u53C8\u53D1\u6D88\u606F\uFF1A\u5F15\u5BFC\uFF1D\u63D2\u8FDB\u5F53\u524D\u8F6E\u7EA0\u504F\uFF1B\u6392\u961F\uFF1D\u7B49\u8FD9\u8F6E\u8DD1\u5B8C\u518D\u5904\u7406\u3002",
+        DM.setPending,
+        getPendingPolicy(cfg),
+        [
+          { label: "\u5F15\u5BFC", value: "steer" },
+          { label: "\u6392\u961F", value: "queue" }
+        ]
+      ),
+      ...settingItem(
+        "\u26A1 \u5E76\u53D1\u4E0A\u9650",
+        "\u6240\u6709\u7FA4 / \u8BDD\u9898\u5168\u5C40\u540C\u65F6\u6700\u591A\u8DD1\u51E0\u4E2A\uFF0C\u6EE1\u4E86\u6392\u961F\uFF08\u6392\u961F\u5361\u53EF \u23F9 \u53D6\u6D88\uFF09\u3002\u6539\u540E\u9700\u91CD\u542F\u751F\u6548\u3002",
+        DM.setConcurrency,
+        String(getMaxConcurrentRuns(cfg)),
+        [
+          { label: "1", value: "1" },
+          { label: "5", value: "5" },
+          { label: "10", value: "10" },
+          { label: "20", value: "20" }
+        ]
+      ),
       hr(),
       actions([button("\u{1F46E} \u7BA1\u7406\u5458", { a: DM.admins }), button("\u2B05\uFE0F \u83DC\u5355", { a: DM.menu })])
     ],
-    { header: { title: "\u2699\uFE0F \u8BBE\u7F6E", template: "blue" } }
+    { header: { title: "\u2699\uFE0F \u5168\u5C40\u8BBE\u7F6E", template: "blue" } }
   );
 }
 function buildWatchdogCustomCard(cfg) {
@@ -4904,24 +5871,6 @@ function buildRunCard(rc) {
 }
 function renderRunning(state, rc) {
   const elements = [];
-  if (rc.cardKey && rc.goalControls) {
-    if (rc.goalEnding) {
-      elements.push(actions([button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger")], CONTROLS_EID));
-      elements.push(noteMd("_\u{1F3AF} \u76EE\u6807\u5DF2\u89E3\u9664\uFF0C\u672C\u8F6E\u8F93\u51FA\u5B8C\u6210\u540E\u505C\u6B62_"));
-    } else {
-      elements.push(
-        actions(
-          [
-            button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger"),
-            button("\u{1F3AF} \u7ED3\u675F\u76EE\u6807", { a: RC.endGoal, m: rc.cardKey }, "default")
-          ],
-          CONTROLS_EID
-        )
-      );
-    }
-  } else if (rc.cardKey && !rc.hideStop) {
-    elements.push(actions([button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger")], CONTROLS_EID));
-  }
   const reasoning = reasoningContent(state);
   if (reasoning) elements.push(reasoningPanel(reasoning, state.reasoningActive));
   const showTools = rc.showTools !== false;
@@ -4937,9 +5886,30 @@ function renderRunning(state, rc) {
   if (tools.length > 0) elements.push(...renderToolGroup(tools, false));
   const answer = textParts.join("\n\n");
   if (answer) elements.push(mdStream(answer, ANSWER_EID));
-  if (state.footer) elements.push(footerStatus(state.footer));
+  const mEl = modelEl(rc);
+  if (state.footer && mEl) elements.push(splitRow(footerStatus(state.footer), mEl));
+  else if (state.footer) elements.push(footerStatus(state.footer));
+  else if (mEl) elements.push(mEl);
   const gauge = gaugeEl(state);
   if (gauge) elements.push(gauge);
+  if (rc.cardKey && rc.goalControls) {
+    if (rc.goalEnding) {
+      elements.push(noteMd("_\u{1F3AF} \u76EE\u6807\u5DF2\u89E3\u9664\uFF0C\u672C\u8F6E\u8F93\u51FA\u5B8C\u6210\u540E\u505C\u6B62_"));
+      elements.push(actions([button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger")], CONTROLS_EID));
+    } else {
+      elements.push(
+        actions(
+          [
+            button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger"),
+            button("\u{1F3AF} \u7ED3\u675F\u76EE\u6807", { a: RC.endGoal, m: rc.cardKey }, "default")
+          ],
+          CONTROLS_EID
+        )
+      );
+    }
+  } else if (rc.cardKey && !rc.hideStop) {
+    elements.push(actions([button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger")], CONTROLS_EID));
+  }
   return elements;
 }
 function renderTerminal(state, rc) {
@@ -4977,6 +5947,8 @@ function renderTerminal(state, rc) {
   }
   const gauge = gaugeEl(state);
   if (gauge) elements.push(gauge);
+  const mEl = rc.modelOnTerminal ? modelEl(rc) : null;
+  if (mEl) elements.push(mEl);
   return elements;
 }
 function errorAdvice(msg) {
@@ -5098,9 +6070,35 @@ function collapsedToolSummary(tools, finalized) {
     body: tools.map((t) => `- ${toolHeaderText(t)}`).join("\n")
   });
 }
+function footerStatusText(status) {
+  return status === "thinking" ? "\u{1F9E0} \u6B63\u5728\u601D\u8003" : status === "tool_running" ? "\u{1F9F0} \u6B63\u5728\u8C03\u7528\u5DE5\u5177" : status === "retrying" ? "\u26A0\uFE0F \u77AC\u65AD\uFF0C\u81EA\u52A8\u91CD\u8BD5\u4E2D\u2026" : "\u270D\uFE0F \u6B63\u5728\u8F93\u51FA";
+}
 function footerStatus(status) {
-  const text = status === "thinking" ? "\u{1F9E0} \u6B63\u5728\u601D\u8003" : status === "tool_running" ? "\u{1F9F0} \u6B63\u5728\u8C03\u7528\u5DE5\u5177" : status === "retrying" ? "\u26A0\uFE0F \u77AC\u65AD\uFF0C\u81EA\u52A8\u91CD\u8BD5\u4E2D\u2026" : "\u270D\uFE0F \u6B63\u5728\u8F93\u51FA";
-  return noteMd(text);
+  return noteMd(footerStatusText(status));
+}
+var EFFORT_TIER = {
+  none: { label: "\u65E0", color: "grey" },
+  minimal: { label: "\u6781\u7B80", color: "grey" },
+  low: { label: "\u4F4E", color: "yellow" },
+  medium: { label: "\u4E2D", color: "green" },
+  high: { label: "\u9AD8", color: "violet" },
+  xhigh: { label: "\u6781\u9AD8", color: "purple" }
+};
+function modelEffortMd(model, effort) {
+  if (!effort) return model;
+  const t = EFFORT_TIER[effort];
+  if (!t) return `${model} \xB7 ${effort}`;
+  return `${model} \xB7 <font color='${t.color}'>${t.label}</font>`;
+}
+function modelEl(rc) {
+  if (!rc.model) return null;
+  return {
+    tag: "markdown",
+    content: modelEffortMd(rc.model, rc.effort),
+    text_size: "notation",
+    text_color: "grey",
+    text_align: "right"
+  };
 }
 function summaryText(state) {
   if (state.terminal === "interrupted") return "\u5DF2\u4E2D\u65AD";
@@ -6806,7 +7804,7 @@ function buildUsageShareCard(data, opts = {}) {
 }
 
 // src/web/discovery.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { dirname as dirname10 } from "path";
 function publishWebConsole(rec, file = paths.webConsoleFile) {
@@ -6848,7 +7846,7 @@ function stableWebConsoleToken(file = paths.webTokenFile) {
     if (t) return t;
   } catch {
   }
-  const token = randomUUID3();
+  const token = randomUUID4();
   try {
     mkdirSync2(dirname10(file), { recursive: true });
     try {
@@ -6980,6 +7978,9 @@ function welcomeCaps(backend) {
     return void 0;
   }
 }
+function welcomeAgentName(backend) {
+  return backend && catalogById(backend)?.displayName || "Codex";
+}
 var HELP_DOC_URL = "https://my.feishu.cn/wiki/PZ23wGr7JiKK5RkIG4rcZXzGn5g";
 function sidebarPcUrl(url) {
   return `https://applink.feishu.cn/client/web_url/open?mode=sidebar-semi&url=${encodeURIComponent(url)}`;
@@ -6987,10 +7988,13 @@ function sidebarPcUrl(url) {
 async function onboardGroup(channel, project) {
   const kind = project.kind ?? "multi";
   const chatId = project.chatId;
+  const agentName = welcomeAgentName(project.backend);
   const decorate = (project.origin ?? "created") !== "joined";
   try {
     const noMention = project.noMention ?? defaultNoMention(project);
-    const content = JSON.stringify(buildWelcomeCard(kind, HELP_DOC_URL || void 0, noMention, welcomeCaps(project.backend)));
+    const content = JSON.stringify(
+      buildWelcomeCard(kind, HELP_DOC_URL || void 0, noMention, welcomeCaps(project.backend), agentName)
+    );
     const sent = await channel.rawClient.im.v1.message.create({
       params: { receive_id_type: "chat_id" },
       data: { receive_id: chatId, msg_type: "interactive", content }
@@ -7026,7 +8030,7 @@ async function onboardGroup(channel, project) {
               {
                 chat_menu_item: {
                   action_type: "REDIRECT_LINK",
-                  name: "\u{1F916} Codex",
+                  name: `\u{1F916} ${agentName}`,
                   redirect_link: { common_url: HELP_DOC_URL, pc_url: sidebarPcUrl(HELP_DOC_URL) }
                 }
               }
@@ -7045,7 +8049,12 @@ async function onboardGroup(channel, project) {
 function assertBackendUsable(backend, mode) {
   if (!backend) return;
   const ok = projectCreatableBackends(mode, isBackendEntryInstalled).some((e) => e.id === backend);
-  if (!ok) throw new Error(`\u6240\u9009\u540E\u7AEF\u300C${backend}\u300D\u5F53\u524D\u4E0D\u53EF\u7528\uFF08\u672A\u4E0B\u8F7D\u6216\u4E0D\u652F\u6301\u8BE5\u6743\u9650\u6863\uFF09\uFF0C\u8BF7\u56DE\u5361\u7247\u91CD\u65B0\u9009\u62E9`);
+  if (ok) return;
+  const entry = catalogById(backend);
+  if (entry && isInstallable(entry)) {
+    throw new Error(`\u300C${entry.displayName}\u300D\u5C1A\u672A\u4E0B\u8F7D\u2014\u2014\u8BF7\u5230 Web \u63A7\u5236\u53F0\u300C\u540E\u7AEF Agent\u300D\u9875\u70B9\u300C\u4E0B\u8F7D\u300D\u88C5\u597D\u540E\uFF0C\u518D\u56DE\u5361\u7247\u9009\u7528\u3002`);
+  }
+  throw new Error(`\u6240\u9009\u540E\u7AEF\u300C${backend}\u300D\u5F53\u524D\u4E0D\u53EF\u7528\uFF08\u672A\u4E0B\u8F7D\u6216\u4E0D\u652F\u6301\u8BE5\u6743\u9650\u6863\uFF09\uFF0C\u8BF7\u56DE\u5361\u7247\u91CD\u65B0\u9009\u62E9`);
 }
 async function resolveCwd(name, existingPath) {
   if (existingPath) {
@@ -7138,7 +8147,7 @@ async function leaveChat(channel, chatId) {
 
 // src/bot/session-store.ts
 import { mkdir as mkdir11, readFile as readFile10, rename as rename5, writeFile as writeFile9 } from "fs/promises";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { dirname as dirname11 } from "path";
 var FILE_VERSION3 = 2;
 var LEGACY_V1_SESSION_FIELD = "codexThreadId";
@@ -7176,7 +8185,7 @@ function withLock2(fn) {
 }
 async function write2(sessions) {
   await mkdir11(dirname11(paths.sessionsFile), { recursive: true });
-  const tmp = `${paths.sessionsFile}.tmp-${process.pid}-${randomUUID4()}`;
+  const tmp = `${paths.sessionsFile}.tmp-${process.pid}-${randomUUID5()}`;
   const body = { version: FILE_VERSION3, sessions };
   await writeFile9(tmp, `${JSON.stringify(body, null, 2)}
 `, "utf8");
@@ -8044,7 +9053,10 @@ function asTier(v) {
   return v === "qa" || v === "write" || v === "full" ? v : void 0;
 }
 function backendOptionsFor(mode) {
-  const opts = projectCreatableBackends(mode, isBackendEntryInstalled).map((e) => ({ label: e.displayName, value: e.id }));
+  const opts = visibleCatalog().filter((e) => !e.supportedModes || e.supportedModes.includes(mode)).map((e) => {
+    const installed = e.id === DEFAULT_BACKEND_ID || isBackendEntryInstalled(e);
+    return { label: installed ? e.displayName : `${e.displayName}\uFF08\u672A\u4E0B\u8F7D\xB7\u53BB\u63A7\u5236\u53F0\u4E0B\u8F7D\uFF09`, value: e.id };
+  });
   return opts.length > 1 ? opts : [];
 }
 function bindModeFor(backend) {
@@ -9034,6 +10046,35 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
     }
     return buildProjectListCard(projects, byChat);
   };
+  const buildDoctorInfo = async () => {
+    const codexProbe = await backend.doctor({ force: true });
+    const app = cfg.accounts.app;
+    const secret = await getSecret(secretKeyForApp(app.id)).catch(() => void 0);
+    const scopeCheck = secret ? await validateAppCredentials(app.id, secret, app.tenant).catch(() => void 0) : void 0;
+    const missingScopes = scopeCheck?.missingScopes;
+    const missingJoinScopes = scopeCheck?.missingJoinScopes;
+    return {
+      codexOk: codexProbe.ok,
+      codexVer: codexProbe.version,
+      conn: channel.getConnectionStatus?.()?.state ?? "unknown",
+      bridgeVer: bridgeVersion(),
+      node: process.version,
+      platform: `${process.platform}-${process.arch}`,
+      logStdout: serviceStdoutPath(),
+      logStderr: serviceStderrPath(),
+      configFile: paths.configFile,
+      missingScopes,
+      // 缺失时预选缺失项（精准开通）；查不到/全开通时预选全部必需 scope 供核对。
+      scopeGrantUrl: buildScopeGrantUrl(
+        app.id,
+        app.tenant,
+        missingScopes && missingScopes.length ? missingScopes : void 0
+      ),
+      missingJoinScopes,
+      // 「加入存量群」按钮恒预选这两项 opt-in scope（它们不在必需清单里）。
+      joinScopeGrantUrl: buildScopeGrantUrl(app.id, app.tenant, JOIN_GROUP_SCOPES)
+    };
+  };
   dispatcher.on(DM.menu, ({ evt }) => {
     if (dmAdmin(evt.operator?.openId)) freshMenu(evt);
   }).on(DM.newProject, ({ evt }) => {
@@ -9098,41 +10139,15 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
     if (dmAdmin(evt.operator?.openId)) await patch(evt, buildSettingsCard(cfg));
   }).on(DM.doctor, async ({ evt }) => {
     if (!dmAdmin(evt.operator?.openId)) return;
-    const codexProbe = await backend.doctor({ force: true });
-    const app = cfg.accounts.app;
-    const secret = await getSecret(secretKeyForApp(app.id)).catch(() => void 0);
-    const scopeCheck = secret ? await validateAppCredentials(app.id, secret, app.tenant).catch(() => void 0) : void 0;
-    const missingScopes = scopeCheck?.missingScopes;
-    const missingJoinScopes = scopeCheck?.missingJoinScopes;
-    const info = {
-      codexOk: codexProbe.ok,
-      codexVer: codexProbe.version,
-      conn: channel.getConnectionStatus?.()?.state ?? "unknown",
-      bridgeVer: bridgeVersion(),
-      node: process.version,
-      platform: `${process.platform}-${process.arch}`,
-      logStdout: serviceStdoutPath(),
-      logStderr: serviceStderrPath(),
-      configFile: paths.configFile,
-      missingScopes,
-      // 缺失时预选缺失项（精准开通）；查不到/全开通时预选全部必需 scope 供核对。
-      scopeGrantUrl: buildScopeGrantUrl(
-        app.id,
-        app.tenant,
-        missingScopes && missingScopes.length ? missingScopes : void 0
-      ),
-      missingJoinScopes,
-      // 「加入存量群」按钮恒预选这两项 opt-in scope（它们不在必需清单里）。
-      joinScopeGrantUrl: buildScopeGrantUrl(app.id, app.tenant, JOIN_GROUP_SCOPES)
-    };
-    await sendManagedCard(channel, evt.chatId, buildDoctorCard(info), evt.messageId).catch(
+    await sendManagedCard(channel, evt.chatId, buildDoctorCard(await buildDoctorInfo()), evt.messageId).catch(
       (err) => log.fail("console", err, { cmd: "doctor" })
     );
   }).on(DM.reconnect, async ({ evt }) => {
     if (!dmAdmin(evt.operator?.openId)) return;
     const conn = channel.getConnectionStatus?.()?.state ?? "unknown";
-    await channel.send(evt.chatId, { markdown: `\u{1F504} \u957F\u8FDE\u63A5\u72B6\u6001\uFF1A**${conn}**
-SDK \u4F1A\u81EA\u52A8\u91CD\u8FDE\uFF1B\u82E5\u957F\u671F\u65AD\u5F00\uFF0C\u8BF7\u5728\u7EC8\u7AEF\u91CD\u8DD1 \`feishu-codex-bridge run\`\uFF08\u524D\u53F0\uFF09\u6216 \`feishu-codex-bridge restart\`\uFF08\u540E\u53F0\u5B88\u62A4\uFF09\u3002` }, { replyTo: evt.messageId }).catch(() => void 0);
+    await sendManagedCard(channel, evt.chatId, buildReconnectCard(conn), evt.messageId).catch(
+      (err) => log.fail("console", err, { cmd: "reconnect" })
+    );
   }).on(DM.update, ({ evt }) => {
     if (!dmAdmin(evt.operator?.openId)) return;
     void (async () => {
@@ -9239,6 +10254,10 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
     });
   }).on(DM.setTools, ({ evt, value }) => {
     applyPref(evt, (p) => p.showToolCalls = value.v === "on");
+  }).on(DM.setShowModel, ({ evt, value }) => {
+    applyPref(evt, (p) => {
+      p.showModel = value.v === "running" ? "running" : value.v === "always" ? "always" : "off";
+    });
   }).on(DM.setWatchdog, ({ evt, value }) => {
     const n = Number(value.v);
     if (Number.isFinite(n)) applyPref(evt, (p) => p.runIdleTimeoutSeconds = n);
@@ -9553,6 +10572,7 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
         firstRec = void 0;
         const turnModel = rec?.model ?? opts.model;
         const turnEffort = rec?.effort ?? opts.effort;
+        const modelDisp = getModelDisplay(cfg);
         const run = opts.thread.runStreamed(turnInput, { model: turnModel, effort: turnEffort });
         const turnStartAt = Date.now();
         state.run = run;
@@ -9562,7 +10582,9 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
         const rc = {
           rs: render.snapshot(),
           requesterOpenId: opts.requesterOpenId,
-          showTools: render.showTools
+          showTools: render.showTools,
+          // 模型显示档位：footnote 本轮 model·推理强度；always 档终态卡也保留。
+          ...modelDisp !== "off" && turnModel ? { model: turnModel, effort: turnEffort, modelOnTerminal: modelDisp === "always" } : {}
         };
         const adoptThreadId = async (messageId) => {
           if (activeKey.startsWith("pending:")) {
@@ -9841,7 +10863,14 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
     const startTurn = () => {
       const render = new RunRender();
       render.showTools = getShowToolCalls(cfg);
-      const rc = { rs: render.snapshot(), requesterOpenId: opts.requesterOpenId, showTools: render.showTools, goalControls: true };
+      const goalModelDisp = getModelDisplay(cfg);
+      const rc = {
+        rs: render.snapshot(),
+        requesterOpenId: opts.requesterOpenId,
+        showTools: render.showTools,
+        goalControls: true,
+        ...goalModelDisp !== "off" && opts.model ? { model: opts.model, effort: opts.effort, modelOnTerminal: goalModelDisp === "always" } : {}
+      };
       return { render, rc, stream: null, cardMsgId: null };
     };
     const ensureCard = async (ctx) => {
@@ -10208,9 +11237,60 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
       }).catch(() => void 0);
       return;
     }
-    await sendManagedCard(channel, op, buildDmMenuCard({ webConsoleUrl: webConsoleUrl(), version: bridgeVersion() }), void 0, false, "open_id").catch(
-      (err) => log.fail("console", err, { cmd: "menu-card" })
-    );
+    const sendDm = (c) => sendManagedCard(channel, op, c, void 0, false, "open_id");
+    try {
+      switch (evt.eventKey) {
+        case DM.newProject:
+          await sendDm(buildNewProjectFormCard({ backends: backendOptionsFor("full") }));
+          break;
+        case DM.projects:
+          await sendDm(await renderProjectList());
+          break;
+        case DM.settings:
+          await sendDm(buildSettingsCard(cfg));
+          break;
+        case DM.doctor:
+          await sendDm(buildDoctorCard(await buildDoctorInfo()));
+          break;
+        case DM.reconnect:
+          await sendDm(buildReconnectCard(channel.getConnectionStatus?.()?.state ?? "unknown"));
+          break;
+        case DM.usage: {
+          const { messageId } = await sendDm(buildUsageCard({ phase: "loading" }));
+          let state;
+          try {
+            state = { phase: "ready", data: await fetchUsageBundle(false) };
+          } catch (e) {
+            log.fail("console", e, { phase: "usage", via: "menu" });
+            state = {
+              phase: "error",
+              kind: e instanceof UsageError ? e.kind : "transient",
+              message: e instanceof Error ? e.message : String(e)
+            };
+          }
+          const ok = await updateManagedCard(channel, messageId, buildUsageCard(state)).catch(() => false);
+          if (!ok) await sendDm(buildUsageCard(state));
+          break;
+        }
+        case DM.update: {
+          const { messageId } = await sendDm(buildUpdateCard({ phase: "checking" }));
+          const current = currentVersion();
+          const latest = await latestVersion().catch(() => null);
+          const hasUpdate = !!latest && isNewer(latest, current);
+          log.info("console", "update-check", { current, latest, hasUpdate, via: "menu" });
+          await updateManagedCard(
+            channel,
+            messageId,
+            buildUpdateCard({ phase: "checked", current, latest, hasUpdate, dev: isDevSource() })
+          ).catch((e) => log.fail("console", e, { phase: "update-check", via: "menu" }));
+          break;
+        }
+        default:
+          await sendDm(buildDmMenuCard({ webConsoleUrl: webConsoleUrl(), version: bridgeVersion() }));
+      }
+    } catch (err) {
+      log.fail("console", err, { cmd: "menu-card", key: evt.eventKey });
+    }
   };
   const reaper = setInterval(() => {
     const now = Date.now();
@@ -11094,7 +12174,7 @@ async function doRestart(phase) {
 
 // src/web/server.ts
 import { createServer } from "http";
-import { randomUUID as randomUUID5, timingSafeEqual } from "crypto";
+import { randomUUID as randomUUID6, timingSafeEqual } from "crypto";
 import { mkdirSync as mkdirSync3, watch } from "fs";
 import { open as open2, stat as stat5 } from "fs/promises";
 import { join as join19 } from "path";
@@ -11635,6 +12715,9 @@ var UI_HTML = `<!doctype html>
   .iconbtn svg { width: 15px; height: 15px; }
   .menu { position: absolute; top: 28px; right: 0; background: #1c1c21; border: 1px solid var(--border-2); border-radius: 10px; padding: 5px; min-width: 152px; box-shadow: var(--shadow-md); z-index: 25; display: none; }
   .menu.open { display: block; }
+  /* \u672B\u884C\u7684\u4E0B\u62C9\u5411\u4E0A\u5C55\u5F00\uFF1A\u8868\u683C .bka-tbl \u7528 overflow:hidden \u505A\u5706\u89D2\uFF0C\u4F1A\u88C1\u6389\u6700\u540E\u4E00\u884C
+     \u5411\u4E0B\u5C55\u5F00\u7684\u83DC\u5355\uFF08\u5982 Claude \u884C\u7684\u300C\u68C0\u67E5\u66F4\u65B0\u300D\u88AB\u5207\u6389\uFF09\u2014\u2014\u672B\u884C\u6539\u4E3A\u5411\u4E0A\u5F39\u51FA\u5373\u53EF\u907F\u5F00\u3002 */
+  .bka-row:last-child .menu { top: auto; bottom: 30px; }
   .mi { display: flex; align-items: center; gap: 9px; padding: 7px 9px; border-radius: 7px; font-size: 12.5px; color: var(--text); cursor: pointer; }
   .mi svg { width: 14px; height: 14px; color: var(--text-2); }
   .mi:hover { background: var(--hover); }
@@ -13767,10 +14850,11 @@ var DEFAULT_WEB_PORT = 51847;
 var COOKIE_NAME = "fcb_console_token";
 var SSE_INITIAL_TAIL_BYTES = 16 * 1024;
 function createWebServer(opts) {
-  const token = opts.token ?? randomUUID5();
+  const token = opts.token ?? randomUUID6();
   const html = opts.html ?? UI_HTML;
   const logDir = opts.logDir ?? join19(paths.appDir, "logs");
   const sseCleanups = /* @__PURE__ */ new Set();
+  const installJobs = /* @__PURE__ */ new Map();
   let qrSession = null;
   const server = createServer((req, res) => {
     void handle(req, res).catch((err) => {
@@ -14119,7 +15203,7 @@ function createWebServer(opts) {
   function handleRegisterQrStream(req, res) {
     qrSession?.abort.abort();
     const abort = new AbortController();
-    const session = { id: randomUUID5(), abort };
+    const session = { id: randomUUID6(), abort };
     qrSession = session;
     res.writeHead(200, {
       "Content-Type": "text/event-stream",
@@ -14181,35 +15265,68 @@ data: ${JSON.stringify(data)}
       "X-Accel-Buffering": "no"
     });
     res.write(": connected\n\n");
-    const heartbeat = setInterval(() => res.write(": ka\n\n"), 15e3);
-    const abort = new AbortController();
+    const heartbeat = setInterval(() => {
+      try {
+        res.write(": ka\n\n");
+      } catch {
+      }
+    }, 15e3);
     let ended = false;
-    const sendData = (data) => {
-      if (ended) return;
-      res.write(`data: ${JSON.stringify(data)}
+    const conn = {
+      send: (data) => {
+        if (ended) return;
+        try {
+          res.write(`data: ${JSON.stringify(data)}
 
 `);
+        } catch {
+        }
+      },
+      done: () => {
+        if (ended) return;
+        ended = true;
+        clearInterval(heartbeat);
+        sseCleanups.delete(conn.done);
+        try {
+          res.end();
+        } catch {
+        }
+      }
     };
-    const finish = () => {
-      if (ended) return;
-      ended = true;
-      clearInterval(heartbeat);
-      sseCleanups.delete(cleanup);
-      res.end();
-    };
-    const cleanup = () => {
-      abort.abort();
-      finish();
+    sseCleanups.add(conn.done);
+    const key = `${id}|${update ? 1 : 0}`;
+    const running = installJobs.get(key);
+    if (running && !running.settled) {
+      running.buffer.forEach(conn.send);
+      running.conns.add(conn);
+      req.on("close", () => {
+        running.conns.delete(conn);
+        conn.done();
+      });
+      return;
+    }
+    const job = { buffer: [], conns: /* @__PURE__ */ new Set([conn]), abort: new AbortController(), settled: false };
+    installJobs.set(key, job);
+    req.on("close", () => {
+      job.conns.delete(conn);
+      conn.done();
+    });
+    const emit2 = (data) => {
+      if (data.type === "log") job.buffer.push(data);
+      for (const c of [...job.conns]) c.send(data);
     };
-    sseCleanups.add(cleanup);
-    req.on("close", cleanup);
-    void opts.service.installBackend(id, (chunk) => sendData({ type: "log", chunk }), abort.signal, { update }).then((result) => {
-      if (result.ok) sendData({ type: "done" });
-      else sendData({ type: "error", code: result.aborted ? "aborted" : "install_failed", message: result.tail });
+    void opts.service.installBackend(id, (chunk) => emit2({ type: "log", chunk }), job.abort.signal, { update }).then((result) => {
+      emit2(
+        result.ok ? { type: "done" } : { type: "error", code: result.aborted ? "aborted" : "install_failed", message: result.tail }
+      );
     }).catch((err) => {
       const code = err instanceof NotWiredYetError ? "not_wired_yet" : "unknown";
-      sendData({ type: "error", code, message: err instanceof Error ? err.message : String(err) });
-    }).finally(finish);
+      emit2({ type: "error", code, message: err instanceof Error ? err.message : String(err) });
+    }).finally(() => {
+      job.settled = true;
+      installJobs.delete(key);
+      for (const c of [...job.conns]) c.done();
+    });
   }
   async function handleDiagnosis(res, botParam) {
     const botId = botParam ?? await defaultBotId();