@modelzen/feishu-codex-bridge 0.4.3 → 0.5.0

package/dist/cli.js

@@ -805,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() {
@@ -2054,58 +2073,46 @@ var STATIC_MODELS = [
   }
 ];
 
-// src/agent/detect.ts
-async function probeCodexAgent() {
-  const entry = BACKEND_CATALOG.find((e) => e.id === "codex-appserver");
-  const bin = resolveCodexBin({ force: true });
-  const version = bin ? await codexVersionAsync(bin, { force: true }) : null;
-  const installed = !!bin && !!version;
-  return {
-    id: "codex",
-    displayName: "Codex",
-    installed,
-    version,
-    installHint: installed ? void 0 : entry.dep.detectHint,
-    backends: [
-      {
-        backendId: "codex-appserver",
-        available: installed,
-        reason: !bin ? entry.dep.detectHint : !version ? "codex --version \u5931\u8D25" : void 0,
-        version,
-        supportedModes: entry.supportedModes,
-        installable: false
-      }
-    ]
-  };
-}
-async function detectAgents() {
-  return Promise.all([probeCodexAgent()]);
-}
-function pickDefaultBackend(agents) {
-  const find = (id) => agents.flatMap((a) => a.backends).find((b) => b.backendId === id);
-  const pickable = (id) => !catalogById(id)?.hidden && find(id)?.available;
-  if (pickable("codex-appserver")) return "codex-appserver";
-  return DEFAULT_BACKEND_ID;
-}
-var defaultCache;
-async function effectiveDefaultBackend(opts) {
-  if (!opts?.force && defaultCache !== void 0) return defaultCache;
-  try {
-    defaultCache = pickDefaultBackend(await detectAgents());
-  } catch {
-    defaultCache = DEFAULT_BACKEND_ID;
-  }
-  return defaultCache;
-}
+// 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);
@@ -2164,6 +2171,905 @@ function installedBackendVersion(pkg) {
   }
 }
 
+// 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
+  }
+];
+
+// src/agent/detect.ts
+async function probeCodexAgent() {
+  const entry = BACKEND_CATALOG.find((e) => e.id === "codex-appserver");
+  const bin = resolveCodexBin({ force: true });
+  const version = bin ? await codexVersionAsync(bin, { force: true }) : null;
+  const installed = !!bin && !!version;
+  return {
+    id: "codex",
+    displayName: "Codex",
+    installed,
+    version,
+    installHint: installed ? void 0 : entry.dep.detectHint,
+    backends: [
+      {
+        backendId: "codex-appserver",
+        available: installed,
+        reason: !bin ? entry.dep.detectHint : !version ? "codex --version \u5931\u8D25" : void 0,
+        version,
+        supportedModes: entry.supportedModes,
+        installable: false
+      }
+    ]
+  };
+}
+async function detectAgents() {
+  return Promise.all([probeCodexAgent()]);
+}
+function pickDefaultBackend(agents) {
+  const find = (id) => agents.flatMap((a) => a.backends).find((b) => b.backendId === id);
+  const pickable = (id) => !catalogById(id)?.hidden && find(id)?.available;
+  if (pickable("codex-appserver")) return "codex-appserver";
+  return DEFAULT_BACKEND_ID;
+}
+var defaultCache;
+async function effectiveDefaultBackend(opts) {
+  if (!opts?.force && defaultCache !== void 0) return defaultCache;
+  try {
+    defaultCache = pickDefaultBackend(await detectAgents());
+  } catch {
+    defaultCache = DEFAULT_BACKEND_ID;
+  }
+  return defaultCache;
+}
+
 // 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";
@@ -2345,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");
@@ -2366,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();
@@ -2837,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");
@@ -2882,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");
@@ -3281,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") {
@@ -3691,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) {
@@ -6896,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) {
@@ -6938,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 {
@@ -7070,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)}`;
@@ -7077,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 }
@@ -7116,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) }
                 }
               }
@@ -7135,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) {
@@ -7228,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";
@@ -7266,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");
@@ -8134,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) {
@@ -11252,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";
@@ -11793,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); }
@@ -13925,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) => {
@@ -14277,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",
@@ -14339,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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelzen/feishu-codex-bridge",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "Bridge Feishu/Lark messenger with local Codex via app-server (project=group, thread=session)",
   "type": "module",
   "bin": {
@@ -34,6 +34,7 @@
     "qrcode-terminal": "^0.12.0"
   },
   "devDependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.178",
     "@types/cross-spawn": "^6.0.6",
     "@types/node": "^22.10.0",
     "@types/qrcode-terminal": "^0.12.2",