@modelzen/feishu-codex-bridge 0.5.0 → 0.6.0

package/dist/cli.js

@@ -1,31 +1,17 @@
-// src/cli/index.ts
-import { Command } from "commander";
-
-// src/core/version.ts
-import { readFileSync } from "fs";
-import { dirname, resolve } from "path";
-import { fileURLToPath } from "url";
-function bridgeVersion() {
-  try {
-    const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-    return JSON.parse(readFileSync(pkgPath, "utf8")).version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-
-// src/cli/commands/doctor.ts
-import { existsSync as existsSync5 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join9 } from "path";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/config/paths.ts
+import { createHash } from "crypto";
 import { homedir } from "os";
 import { join } from "path";
-var appDir = join(homedir(), ".feishu-codex-bridge");
-var larkCliDir = join(appDir, "lark-cli");
-var codexCliDir = join(appDir, "codex-cli");
-var currentBotDir = appDir;
 function botDir(appId) {
   return join(appDir, "bots", appId);
 }
@@ -42,71 +28,86 @@ function botPaths(appId) {
     processesFile: join(dir, "processes.json")
   };
 }
-var paths = {
-  appDir,
-  cacheDir: appDir,
-  /** bot 注册表：保存的全部 bot + 当前选中的 appId */
-  botsFile: join(appDir, "bots.json"),
-  /** app id / 租户 / 偏好（当前 bot；不含明文密钥） */
-  get configFile() {
-    return join(currentBotDir, "config.json");
-  },
-  /** thread(话题) → codex thread_id + cwd + 会话级配置（当前 bot） */
-  get sessionsFile() {
-    return join(currentBotDir, "sessions.json");
-  },
-  /** project(群) → cwd + 默认参数 注册表（当前 bot） */
-  get projectsFile() {
-    return join(currentBotDir, "projects.json");
-  },
-  /** 在跑的 start 进程注册中心（同 App 冲突检测；当前 bot） */
-  get processesFile() {
-    return join(currentBotDir, "processes.json");
-  },
-  secretsFile: join(appDir, "secrets.enc"),
-  keystoreSaltFile: join(appDir, ".keystore.salt"),
-  npmCacheDir: join(appDir, "npm-cache"),
-  /**
-   * 按需后端（npm-ondemand 包）私装目录：一个扁平
-   * `~/.feishu-codex-bridge/backends/node_modules` 放所有按需后端的 npm 包。
-   * （通用基础设施；当前内置后端 codex 是 external-cli，不落此目录，保留以备将来。）
-   * 永远在用户 HOME 下、用户可写（零 sudo/brew），与全局包目录的权限死结解耦。
-   * 解析靠 createRequire(backendsDir/...).resolve（见 agent/backend-loader）；
-   * 安装靠 `npm install --prefix backendsDir`（见 agent/installer）。 */
-  backendsDir: join(appDir, "backends"),
-  /** 空白项目默认落地目录 */
-  projectsRootDir: join(appDir, "projects"),
-  larkCliDir,
-  larkCliBinDir: join(larkCliDir, "node_modules", ".bin"),
-  codexCliDir,
-  codexCliBinDir: join(codexCliDir, "node_modules", ".bin"),
-  /**
-   * Thin shell wrapper that lark-cli invokes to resolve secrets from the
-   * bridge's encrypted store. Written user-owned and non-symlinked so it
-   * passes lark-cli's AssertSecurePath audit.
-   */
-  secretsGetterScript: join(appDir, "secrets-getter"),
-  mediaDir: join(appDir, "media"),
-  /** Inbound file attachments downloaded from chat, handed to codex by absolute
-   * path (codex has no native file input). TTL-pruned like {@link mediaDir}. */
-  inboundDir: join(appDir, "inbound"),
-  /** daemon 内嵌 Web 控制台的发现文件 {port, token, pid}（0600，daemon 退出
-   * 清理）——`web` 子命令据此直接打开 daemon 控制台而不是再起只读副本。 */
-  webConsoleFile: join(appDir, "web-console.json"),
-  /** 稳定的 Web 控制台 token（0600，**不随进程退出清理**）——让重启 / 预览→daemon
-   * 切换后浏览器里那条带 token 的 URL 始终有效，不再 401。删此文件即轮换 token。 */
-  webTokenFile: join(appDir, "web-token")
-};
-
-// src/config/bots.ts
-import { existsSync } from "fs";
-import { chmod as chmod2, mkdir as mkdir2, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname3, join as join2 } from "path";
-
-// src/config/store.ts
-import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
-import { randomUUID } from "crypto";
-import { dirname as dirname2 } from "path";
+var appDir, larkCliDir, codexCliDir, currentBotDir, paths;
+var init_paths = __esm({
+  "src/config/paths.ts"() {
+    "use strict";
+    appDir = join(homedir(), ".feishu-codex-bridge");
+    larkCliDir = join(appDir, "lark-cli");
+    codexCliDir = join(appDir, "codex-cli");
+    currentBotDir = appDir;
+    paths = {
+      appDir,
+      cacheDir: appDir,
+      /** bot 注册表：保存的全部 bot + 当前选中的 appId */
+      botsFile: join(appDir, "bots.json"),
+      /** app id / 租户 / 偏好（当前 bot；不含明文密钥） */
+      get configFile() {
+        return join(currentBotDir, "config.json");
+      },
+      /** thread(话题) → codex thread_id + cwd + 会话级配置（当前 bot） */
+      get sessionsFile() {
+        return join(currentBotDir, "sessions.json");
+      },
+      /** project(群) → cwd + 默认参数 注册表（当前 bot） */
+      get projectsFile() {
+        return join(currentBotDir, "projects.json");
+      },
+      /** 在跑的 start 进程注册中心（同 App 冲突检测；当前 bot） */
+      get processesFile() {
+        return join(currentBotDir, "processes.json");
+      },
+      /**
+       * Local CLI hook IPC endpoint for the current bot. macOS/Linux use a Unix
+       * domain socket file; Windows has none, so Node maps a `\\.\pipe\…` path to a
+       * named pipe. The pipe name is hashed from the per-bot dir so the daemon and
+       * the hook subprocess (both pointed at the same bot) derive the same name,
+       * while distinct bots/users on one machine can't collide in the global pipe
+       * namespace.
+       */
+      get cliBridgeSocket() {
+        if (process.platform === "win32") {
+          const tag = createHash("sha1").update(currentBotDir).digest("hex").slice(0, 16);
+          return `\\\\.\\pipe\\feishu-cli-bridge-${tag}`;
+        }
+        return join(currentBotDir, "cli-bridge.sock");
+      },
+      secretsFile: join(appDir, "secrets.enc"),
+      keystoreSaltFile: join(appDir, ".keystore.salt"),
+      npmCacheDir: join(appDir, "npm-cache"),
+      /**
+       * 按需后端（npm-ondemand 包）私装目录：一个扁平
+       * `~/.feishu-codex-bridge/backends/node_modules` 放所有按需后端的 npm 包。
+       * （通用基础设施；当前内置后端 codex 是 external-cli，不落此目录，保留以备将来。）
+       * 永远在用户 HOME 下、用户可写（零 sudo/brew），与全局包目录的权限死结解耦。
+       * 解析靠 createRequire(backendsDir/...).resolve（见 agent/backend-loader）；
+       * 安装靠 `npm install --prefix backendsDir`（见 agent/installer）。 */
+      backendsDir: join(appDir, "backends"),
+      /** 空白项目默认落地目录 */
+      projectsRootDir: join(appDir, "projects"),
+      larkCliDir,
+      larkCliBinDir: join(larkCliDir, "node_modules", ".bin"),
+      codexCliDir,
+      codexCliBinDir: join(codexCliDir, "node_modules", ".bin"),
+      /**
+       * Thin shell wrapper that lark-cli invokes to resolve secrets from the
+       * bridge's encrypted store. Written user-owned and non-symlinked so it
+       * passes lark-cli's AssertSecurePath audit.
+       */
+      secretsGetterScript: join(appDir, "secrets-getter"),
+      mediaDir: join(appDir, "media"),
+      /** Inbound file attachments downloaded from chat, handed to codex by absolute
+       * path (codex has no native file input). TTL-pruned like {@link mediaDir}. */
+      inboundDir: join(appDir, "inbound"),
+      /** daemon 内嵌 Web 控制台的发现文件 {port, token, pid}（0600，daemon 退出
+       * 清理）——`web` 子命令据此直接打开 daemon 控制台而不是再起只读副本。 */
+      webConsoleFile: join(appDir, "web-console.json"),
+      /** 稳定的 Web 控制台 token（0600，**不随进程退出清理**）——让重启 / 预览→daemon
+       * 切换后浏览器里那条带 token 的 URL 始终有效，不再 401。删此文件即轮换 token。 */
+      webTokenFile: join(appDir, "web-token")
+    };
+  }
+});
 
 // src/config/schema.ts
 function isComplete(cfg) {
@@ -142,8 +143,6 @@ function getMaxConcurrentRuns(cfg) {
 function getPendingPolicy(cfg) {
   return cfg.preferences?.pendingPolicy === "queue" ? "queue" : "steer";
 }
-var RUN_IDLE_TIMEOUT_MIN_SEC = 10;
-var RUN_IDLE_TIMEOUT_MAX_SEC = 3600;
 function getRunIdleTimeoutMs(cfg) {
   const raw = cfg.preferences?.runIdleTimeoutSeconds;
   if (raw === 0) return void 0;
@@ -171,8 +170,67 @@ function isUserAllowedInProject(cfg, project, senderId) {
   if (!list || list.length === 0) return true;
   return list.includes(senderId);
 }
+function boolOr(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function secondsOr(value, fallback, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function getCliBridgePreferences(cfg) {
+  const raw = cfg.preferences?.cliBridge;
+  return {
+    enabled: boolOr(raw?.enabled, false),
+    delivery: "away_only",
+    includeBridgeOwnedSessionsForDebugging: boolOr(raw?.includeBridgeOwnedSessionsForDebugging, false),
+    agents: {
+      claude: boolOr(raw?.agents?.claude, true),
+      codex: boolOr(raw?.agents?.codex, true)
+    },
+    notifyScope: raw?.notifyScope === "bound_projects" || raw?.notifyScope === "none" ? raw.notifyScope : "all",
+    keepAwake: {
+      enabled: boolOr(raw?.keepAwake?.enabled, true)
+    },
+    approval: {
+      enabled: boolOr(raw?.approval?.enabled, true),
+      timeoutSeconds: secondsOr(raw?.approval?.timeoutSeconds, 86400, 1, 86400)
+    },
+    taskCompletion: {
+      enabled: boolOr(raw?.taskCompletion?.enabled, true),
+      replyEnabled: boolOr(raw?.taskCompletion?.replyEnabled, true),
+      replyTimeoutSeconds: secondsOr(raw?.taskCompletion?.replyTimeoutSeconds, 600, 1, 86400)
+    },
+    allowCache: {
+      enabled: boolOr(raw?.allowCache?.enabled, true),
+      scope: "session"
+    },
+    presence: {
+      enabled: boolOr(raw?.presence?.enabled, true),
+      platform: raw?.presence?.platform === "macos" ? "macos" : "auto",
+      idleThresholdSeconds: secondsOr(raw?.presence?.idleThresholdSeconds, 120, 10, 3600)
+    }
+  };
+}
+function resolveCliBridgeTarget(cfg) {
+  const owner = resolveOwner(cfg);
+  return owner ? { receiveIdType: "open_id", receiveId: owner } : void 0;
+}
+function canEnableCliBridge(cfg) {
+  return resolveCliBridgeTarget(cfg) ? { ok: true } : { ok: false, reason: "missing_owner" };
+}
+var RUN_IDLE_TIMEOUT_MIN_SEC, RUN_IDLE_TIMEOUT_MAX_SEC;
+var init_schema = __esm({
+  "src/config/schema.ts"() {
+    "use strict";
+    RUN_IDLE_TIMEOUT_MIN_SEC = 10;
+    RUN_IDLE_TIMEOUT_MAX_SEC = 3600;
+  }
+});
 
 // src/config/store.ts
+import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { randomUUID } from "crypto";
+import { dirname as dirname2 } from "path";
 async function loadConfig(path = paths.configFile) {
   try {
     const text = await readFile(path, "utf8");
@@ -216,7 +274,6 @@ exec ${sq(node)} ${sq(bridgeEntry)} secrets get "$@"
   await rename(tmp, wrapperPath);
   return wrapperPath;
 }
-var saveChain = Promise.resolve();
 function saveConfig(cfg, path = paths.configFile) {
   const run = saveChain.then(async () => {
     await mkdir(dirname2(path), { recursive: true });
@@ -232,9 +289,20 @@ function saveConfig(cfg, path = paths.configFile) {
   );
   return run;
 }
+var saveChain;
+var init_store = __esm({
+  "src/config/store.ts"() {
+    "use strict";
+    init_paths();
+    init_schema();
+    saveChain = Promise.resolve();
+  }
+});
 
 // src/config/bots.ts
-var EMPTY = { version: 1, bots: [] };
+import { existsSync } from "fs";
+import { chmod as chmod2, mkdir as mkdir2, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join2 } from "path";
 async function loadBots() {
   try {
     const text = await readFile2(paths.botsFile, "utf8");
@@ -264,68 +332,1755 @@ async function ensureRegistry() {
   for (const file of ["config.json", "projects.json", "sessions.json", "processes.json"]) {
     await moveIfExists(join2(paths.appDir, file), join2(dest, file));
   }
-  const reg = {
-    version: 1,
-    current: appId,
-    bots: [{ name: "default", appId, tenant, createdAt: nowMs() }]
+  const reg = {
+    version: 1,
+    current: appId,
+    bots: [{ name: "default", appId, tenant, createdAt: nowMs() }]
+  };
+  await saveBots(reg);
+  return reg;
+}
+function findBot(reg, nameOrAppId) {
+  return reg.bots.find((b) => b.name === nameOrAppId || b.appId === nameOrAppId);
+}
+function currentBot(reg) {
+  return reg.current ? reg.bots.find((b) => b.appId === reg.current) : void 0;
+}
+function activeBots(reg) {
+  const configured = reg.bots.some((b) => b.active !== void 0);
+  if (configured) return reg.bots.filter((b) => b.active === true);
+  const cur = currentBot(reg);
+  return cur ? [cur] : [];
+}
+async function setActiveBots(appIds) {
+  const reg = await loadBots();
+  const want = new Set(appIds);
+  for (const b of reg.bots) b.active = want.has(b.appId);
+  const firstActive = reg.bots.find((b) => b.active);
+  if (firstActive) reg.current = firstActive.appId;
+  await saveBots(reg);
+  return reg;
+}
+async function addBot(entry) {
+  const reg = await loadBots();
+  reg.bots = reg.bots.filter((b) => b.appId !== entry.appId);
+  reg.bots.push(entry);
+  if (!reg.current) reg.current = entry.appId;
+  await saveBots(reg);
+  return reg;
+}
+async function removeBot(appId) {
+  const reg = await loadBots();
+  reg.bots = reg.bots.filter((b) => b.appId !== appId);
+  if (reg.current === appId) reg.current = reg.bots[0]?.appId;
+  await saveBots(reg);
+  return reg;
+}
+function uniqueName(reg, desired) {
+  const base = slugify(desired) || "bot";
+  if (!reg.bots.some((b) => b.name === base)) return base;
+  for (let i = 2; ; i++) {
+    const candidate = `${base}-${i}`;
+    if (!reg.bots.some((b) => b.name === candidate)) return candidate;
+  }
+}
+function slugify(s) {
+  return s.trim().toLowerCase().replace(/[^a-z0-9一-龥]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
+}
+function nowMs() {
+  return Date.now();
+}
+async function moveIfExists(src, dest) {
+  if (!existsSync(src)) return;
+  await rename2(src, dest);
+}
+var EMPTY;
+var init_bots = __esm({
+  "src/config/bots.ts"() {
+    "use strict";
+    init_paths();
+    init_store();
+    init_schema();
+    EMPTY = { version: 1, bots: [] };
+  }
+});
+
+// src/core/logger.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { createWriteStream, mkdirSync } from "fs";
+import { open, readdir, rm, stat } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+function todayKey() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function inTestEnv() {
+  return Boolean(process.env.VITEST) || process.env.NODE_ENV === "test";
+}
+function logsDir() {
+  return inTestEnv() ? TEST_LOGS_DIR : join4(paths.appDir, "logs");
+}
+function getStream() {
+  const today = todayKey();
+  if (stream && currentDate === today) return stream;
+  if (stream) {
+    try {
+      stream.end();
+    } catch {
+    }
+  }
+  try {
+    mkdirSync(logsDir(), { recursive: true });
+    stream = createWriteStream(join4(logsDir(), `${today}.log`), { flags: "a" });
+    currentDate = today;
+    return stream;
+  } catch {
+    return null;
+  }
+}
+function emit(level, phase, event, fields = {}) {
+  const ctx = als.getStore() ?? {};
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    phase,
+    event,
+    ...ctx
+  };
+  for (const [k2, v] of Object.entries(fields)) {
+    if (RESERVED_KEYS.has(k2)) {
+      entry[`_${k2}`] = v;
+    } else {
+      entry[k2] = v;
+    }
+  }
+  const s = getStream();
+  if (s) {
+    try {
+      s.write(`${JSON.stringify(entry)}
+`);
+    } catch {
+    }
+  }
+  const showOnStdout = level !== "info" || STDOUT_INFO_ALLOWLIST.has(`${phase}.${event}`);
+  if (!showOnStdout) return;
+  const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+  fn(formatStdout(level, phase, event, ctx, fields));
+}
+function formatStdout(level, phase, event, ctx, fields) {
+  if (phase === "ws") {
+    if (event === "connected") {
+      const bot2 = fields.bot ?? "-";
+      const appId = fields.appId ? ` (${fields.appId})` : "";
+      return `\u2713 \u5DF2\u8FDE\u63A5  bot: ${bot2}${appId}`;
+    }
+    if (event === "reconnecting") return "\u21BB \u6B63\u5728\u91CD\u8FDE\u2026";
+    if (event === "reconnected") return "\u2713 \u5DF2\u91CD\u8FDE";
+    if (event === "fail") return `\u2717 WS \u9519\u8BEF: ${fields.err ?? ""}`;
+  }
+  if (phase === "intake" && event === "enter") {
+    const c = ctx.chatId ? ctx.chatId.slice(-6) : "-";
+    const sender = fields.sender ?? "-";
+    const preview = fields.preview ?? "";
+    return `\u25B8 ${fields.chatType ?? "?"}/${c} ${sender}: ${preview}`;
+  }
+  if (phase === "card" && event === "final") {
+    const c = ctx.chatId ? ctx.chatId.slice(-6) : "-";
+    const t = fields.terminal;
+    const mark = t === "done" ? "\u2713" : t === "interrupted" ? "\u23F9" : "\u2717";
+    return `  ${mark} ${c} ${t}`;
+  }
+  const ctxBits = [];
+  if (ctx.traceId) ctxBits.push(`t=${ctx.traceId}`);
+  if (ctx.chatId) ctxBits.push(`c=${ctx.chatId.slice(-6)}`);
+  const ctxStr = ctxBits.length > 0 ? ` ${ctxBits.join(" ")}` : "";
+  const summary = formatFields(fields);
+  const tag = level === "error" ? "\u2717" : level === "warn" ? "\u26A0" : "\xB7";
+  return `${tag} [${phase}.${event}]${ctxStr}${summary ? ` ${summary}` : ""}`;
+}
+function formatFields(fields) {
+  const keys = Object.keys(fields);
+  if (keys.length === 0) return "";
+  const parts = [];
+  for (const k2 of keys) {
+    const v = fields[k2];
+    if (v === void 0 || v === null) continue;
+    if (k2 === "stack") continue;
+    if (typeof v === "string") {
+      parts.push(`${k2}=${v.length > 80 ? `${v.slice(0, 80)}\u2026` : v}`);
+    } else if (typeof v === "number" || typeof v === "boolean") {
+      parts.push(`${k2}=${v}`);
+    } else {
+      try {
+        const str = JSON.stringify(v);
+        parts.push(`${k2}=${str.length > 80 ? `${str.slice(0, 80)}\u2026` : str}`);
+      } catch {
+        parts.push(`${k2}=?`);
+      }
+    }
+  }
+  return parts.join(" ");
+}
+function withTrace(ctx, fn) {
+  const traceId = ctx.traceId ?? newTraceId();
+  return als.run({ ...ctx, traceId }, fn);
+}
+function newTraceId() {
+  return Math.random().toString(36).slice(2, 10);
+}
+async function readRecentLogs(opts) {
+  const today = todayKey();
+  const yesterday = new Date(Date.now() - 864e5).toISOString().slice(0, 10);
+  const tail = await readTail(join4(logsDir(), `${today}.log`), opts.maxBytes);
+  if (tail.length >= opts.maxBytes / 2) return tail;
+  const remaining = opts.maxBytes - Buffer.byteLength(tail, "utf8");
+  const earlier = await readTail(join4(logsDir(), `${yesterday}.log`), remaining);
+  return earlier + tail;
+}
+async function readTail(path, maxBytes) {
+  try {
+    const st = await stat(path);
+    const start = Math.max(0, st.size - maxBytes);
+    const handle = await open(path, "r");
+    try {
+      const buf = Buffer.alloc(st.size - start);
+      await handle.read(buf, 0, buf.length, start);
+      let content = buf.toString("utf8");
+      if (start > 0) {
+        const nl = content.indexOf("\n");
+        if (nl !== -1) content = content.slice(nl + 1);
+      }
+      return content;
+    } finally {
+      await handle.close();
+    }
+  } catch (err) {
+    if (err.code === "ENOENT") return "";
+    throw err;
+  }
+}
+var LOG_RETENTION_DAYS, STDOUT_INFO_ALLOWLIST, als, stream, currentDate, TEST_LOGS_DIR, RESERVED_KEYS, log;
+var init_logger = __esm({
+  "src/core/logger.ts"() {
+    "use strict";
+    init_paths();
+    LOG_RETENTION_DAYS = Math.max(
+      1,
+      Number(process.env.FEISHU_CODEX_LOG_DAYS ?? 7) || 7
+    );
+    STDOUT_INFO_ALLOWLIST = /* @__PURE__ */ new Set([
+      "ws.connected",
+      "ws.reconnecting",
+      "ws.reconnected",
+      "intake.enter",
+      "intake.recv",
+      "intake.reject",
+      "card.final",
+      "card.config",
+      "card.action",
+      "card.launch",
+      "agent.spawn",
+      "agent.exit",
+      // 自愈链路（kill -9 / 崩溃恢复）的关键节点——低频高信号，进终端便于 e2e 直读：
+      // 驱逐（轮间死 / 轮中死）与恢复来源（store resume / 重建 / 全新会话）。
+      "agent.dead-thread-evict",
+      "agent.session-evict",
+      "agent.resume-ok",
+      "agent.resume-recreate",
+      "agent.session-fresh"
+    ]);
+    als = new AsyncLocalStorage();
+    stream = null;
+    currentDate = "";
+    TEST_LOGS_DIR = join4(tmpdir(), "feishu-codex-bridge-test-logs");
+    RESERVED_KEYS = /* @__PURE__ */ new Set([
+      "ts",
+      "level",
+      "phase",
+      "event",
+      "traceId",
+      "chatId",
+      "msgId"
+    ]);
+    log = {
+      info(phase, event, fields) {
+        emit("info", phase, event, fields);
+      },
+      warn(phase, event, fields) {
+        emit("warn", phase, event, fields);
+      },
+      fail(phase, err, fields) {
+        const message = err instanceof Error ? err.message : String(err);
+        const stack = err instanceof Error ? err.stack : void 0;
+        const apiData = err?.response?.data;
+        const apiStatus = err?.response?.status;
+        emit("error", phase, "fail", {
+          ...fields,
+          err: message,
+          apiStatus,
+          apiData,
+          stack
+        });
+      }
+    };
+  }
+});
+
+// src/card/cards.ts
+function card(elements, opts = {}) {
+  const config = { update_multi: true };
+  if (opts.forward === false) config.enable_forward = false;
+  if (opts.streaming) {
+    config.streaming_mode = true;
+    config.streaming_config = {
+      print_frequency_ms: { default: 25 },
+      print_step: { default: 6 },
+      print_strategy: "fast"
+    };
+  }
+  if (opts.summary) config.summary = { content: opts.summary };
+  const obj = {
+    schema: "2.0",
+    config,
+    body: { elements }
+  };
+  if (opts.header) {
+    obj.header = {
+      template: opts.header.template ?? "blue",
+      title: { tag: "plain_text", content: opts.header.title },
+      ...opts.header.subtitle ? { subtitle: { tag: "plain_text", content: opts.header.subtitle } } : {},
+      ...opts.header.textTags?.length ? {
+        text_tag_list: opts.header.textTags.map((t) => ({
+          tag: "text_tag",
+          text: { tag: "plain_text", content: t.text },
+          color: t.color
+        }))
+      } : {}
+    };
+  }
+  return obj;
+}
+function md(content) {
+  return { tag: "markdown", content };
+}
+function mdStream(content, elementId) {
+  return { tag: "markdown", element_id: elementId, content };
+}
+function image(imgKey, alt = "") {
+  return {
+    tag: "img",
+    img_key: imgKey,
+    alt: { tag: "plain_text", content: alt },
+    mode: "fit_horizontal",
+    preview: true
+  };
+}
+function note(content) {
+  return { tag: "div", text: { tag: "lark_md", content, text_size: "notation", text_color: "grey" } };
+}
+function colorNote(content, color) {
+  return { tag: "div", text: { tag: "lark_md", content, text_size: "notation", text_color: color } };
+}
+function hr() {
+  return { tag: "hr" };
+}
+function noteMd(content) {
+  return { tag: "markdown", content, text_size: "notation" };
+}
+function collapsiblePanel(opts) {
+  return {
+    tag: "collapsible_panel",
+    expanded: opts.expanded,
+    header: {
+      title: { tag: "markdown", content: opts.title },
+      vertical_align: "center",
+      icon: { tag: "standard_icon", token: "down-small-ccm_outlined", size: "16px 16px" },
+      icon_position: "follow_text",
+      icon_expanded_angle: -180
+    },
+    border: { color: opts.border, corner_radius: "5px" },
+    vertical_spacing: "8px",
+    padding: "8px 8px 8px 8px",
+    elements: [{ tag: "markdown", content: opts.body, text_size: "notation" }]
+  };
+}
+function collapsiblePanelEl(opts) {
+  return {
+    tag: "collapsible_panel",
+    expanded: opts.expanded,
+    header: {
+      title: { tag: "markdown", content: opts.title },
+      vertical_align: "center",
+      icon: { tag: "standard_icon", token: "down-small-ccm_outlined", size: "16px 16px" },
+      icon_position: "follow_text",
+      icon_expanded_angle: -180
+    },
+    border: { color: opts.border, corner_radius: "5px" },
+    vertical_spacing: "8px",
+    padding: "8px 8px 8px 8px",
+    elements: opts.elements
+  };
+}
+function actions(items, elementId) {
+  return {
+    tag: "column_set",
+    ...elementId ? { element_id: elementId } : {},
+    flex_mode: "flow",
+    horizontal_spacing: "small",
+    columns: items.map((it) => ({ tag: "column", width: "auto", elements: [it] }))
+  };
+}
+function actionsFixed(items, width, elementId) {
+  return {
+    tag: "column_set",
+    ...elementId ? { element_id: elementId } : {},
+    flex_mode: "flow",
+    horizontal_spacing: "8px",
+    columns: items.map((it) => ({ tag: "column", width: "auto", elements: [{ ...it, width, size: "large" }] }))
+  };
+}
+function splitRow(left, right, elementId) {
+  return {
+    tag: "column_set",
+    ...elementId ? { element_id: elementId } : {},
+    flex_mode: "none",
+    horizontal_spacing: "medium",
+    columns: [
+      { tag: "column", width: "auto", vertical_align: "center", elements: [left] },
+      { tag: "column", width: "weighted", weight: 1, vertical_align: "center", elements: [right] }
+    ]
+  };
+}
+function button(label, value, type = "default") {
+  return {
+    tag: "button",
+    text: { tag: "plain_text", content: label },
+    type,
+    behaviors: [{ type: "callback", value }]
+  };
+}
+function linkButton(label, url, type = "default", size) {
+  return {
+    tag: "button",
+    text: { tag: "plain_text", content: label },
+    type,
+    ...size ? { size } : {},
+    behaviors: [{ type: "open_url", default_url: url }]
+  };
+}
+function input(opts) {
+  return {
+    tag: "input",
+    name: opts.name,
+    ...opts.label ? { label: { tag: "plain_text", content: opts.label } } : {},
+    ...opts.placeholder ? { placeholder: { tag: "plain_text", content: opts.placeholder } } : {},
+    ...opts.value ? { default_value: opts.value } : {},
+    required: Boolean(opts.required)
+  };
+}
+function form(name, elements) {
+  return { tag: "form", name, elements };
+}
+function submitButton(label, value, type = "primary", name = "submit") {
+  return {
+    tag: "button",
+    name,
+    text: { tag: "plain_text", content: label },
+    type,
+    form_action_type: "submit",
+    behaviors: [{ type: "callback", value }]
+  };
+}
+function selectStatic(opts) {
+  return {
+    tag: "select_static",
+    placeholder: { tag: "plain_text", content: opts.placeholder },
+    ...opts.initial ? { initial_option: opts.initial } : {},
+    options: opts.options.map((o) => ({
+      text: { tag: "plain_text", content: o.label },
+      value: o.value
+    })),
+    behaviors: [{ type: "callback", value: { a: opts.actionId } }]
+  };
+}
+function selectMenu(opts) {
+  return {
+    tag: "select_static",
+    name: opts.name,
+    placeholder: { tag: "plain_text", content: opts.placeholder },
+    ...opts.initial ? { initial_option: opts.initial } : {},
+    options: opts.options.map((o) => ({ text: { tag: "plain_text", content: o.label }, value: o.value }))
+  };
+}
+function multiSelectMenu(opts) {
+  return {
+    tag: "multi_select_static",
+    name: opts.name,
+    placeholder: { tag: "plain_text", content: opts.placeholder },
+    options: opts.options.map((o) => ({ text: { tag: "plain_text", content: o.label }, value: o.value }))
+  };
+}
+var init_cards = __esm({
+  "src/card/cards.ts"() {
+    "use strict";
+  }
+});
+
+// src/card/managed.ts
+function stampRenderToken(card2) {
+  const token = (++renderToken).toString(36);
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (!node || typeof node !== "object") return;
+    const obj = node;
+    const behaviors = obj.behaviors;
+    if (Array.isArray(behaviors)) {
+      for (const b of behaviors) {
+        if (b && typeof b === "object" && b.type === "callback") {
+          const v = b.value;
+          if (v && typeof v === "object") v.__r = token;
+        }
+      }
+    }
+    for (const k2 of Object.keys(obj)) visit(obj[k2]);
+  };
+  visit(card2);
+}
+function isCardIdNotReady(err) {
+  const data = err?.response?.data;
+  return data?.code === 230099 || /11310|cardid is invalid/i.test(data?.msg ?? "");
+}
+async function sendManagedCard(channel, to, card2, replyTo, replyInThread = false, receiveIdType = "chat_id") {
+  stampRenderToken(card2);
+  const data = JSON.stringify(card2);
+  const attempt = async () => {
+    const created = await channel.rawClient.cardkit.v1.card.create({ data: { type: "card_json", data } });
+    const cardId = created.data?.card_id;
+    if (!cardId) {
+      throw new Error(`cardkit.card.create returned no card_id: ${JSON.stringify(created).slice(0, 200)}`);
+    }
+    const content = JSON.stringify({ type: "card", data: { card_id: cardId } });
+    let messageId;
+    if (replyTo) {
+      const sent = await channel.rawClient.im.v1.message.reply({
+        path: { message_id: replyTo },
+        data: { msg_type: "interactive", content, reply_in_thread: replyInThread }
+      });
+      messageId = sent.data?.message_id;
+    } else {
+      const sent = await channel.rawClient.im.v1.message.create({
+        params: { receive_id_type: receiveIdType },
+        data: { receive_id: to, msg_type: "interactive", content }
+      });
+      messageId = sent.data?.message_id;
+    }
+    if (!messageId) {
+      throw new Error("send card-by-reference returned no message_id");
+    }
+    byMessageId.set(messageId, { cardId, sequence: 0 });
+    return { messageId, cardId };
+  };
+  for (let i = 0; ; i++) {
+    try {
+      return await attempt();
+    } catch (err) {
+      if (i >= 2 || !isCardIdNotReady(err)) throw err;
+      log.fail("card", err, { phase: "managed-send", attempt: i, retry: true });
+      await new Promise((r) => setTimeout(r, 400 * (i + 1)));
+    }
+  }
+}
+async function updateManagedCard(channel, messageId, card2) {
+  const entry = byMessageId.get(messageId);
+  if (!entry) {
+    log.info("card", "managed-update-no-entry", { messageId, known: byMessageId.size });
+    return false;
+  }
+  stampRenderToken(card2);
+  const data = JSON.stringify(card2);
+  const push = async () => {
+    entry.sequence += 1;
+    await channel.rawClient.cardkit.v1.card.update({
+      path: { card_id: entry.cardId },
+      data: { card: { type: "card_json", data }, sequence: entry.sequence, uuid: `u_${entry.cardId}_${entry.sequence}` }
+    });
+  };
+  try {
+    await push();
+    return true;
+  } catch (err) {
+    log.fail("card", err, { phase: "managed-update", cardId: entry.cardId, seq: entry.sequence, retry: true });
+    await new Promise((r) => setTimeout(r, 3200));
+    try {
+      await push();
+      return true;
+    } catch (err2) {
+      log.fail("card", err2, { phase: "managed-update-retry", cardId: entry.cardId, seq: entry.sequence });
+      return false;
+    }
+  }
+}
+var byMessageId, renderToken;
+var init_managed = __esm({
+  "src/card/managed.ts"() {
+    "use strict";
+    init_logger();
+    byMessageId = /* @__PURE__ */ new Map();
+    renderToken = 0;
+  }
+});
+
+// src/cli-bridge/cards.ts
+function pickCopy(pool, key) {
+  let h = 0;
+  for (let i = 0; i < key.length; i += 1) h = h * 31 + key.charCodeAt(i) >>> 0;
+  return pool[h % pool.length];
+}
+function sessionLabel(cwd) {
+  const base = (cwd || "").replace(/[/\\]+$/, "").split(/[/\\]/).pop();
+  return base || "session";
+}
+function titleEl(verb) {
+  return md(`**${BRAND} \xB7 ${verb}**`);
+}
+function metaLine(source, cwd, extra) {
+  const chips = "\u{1F916} `" + agentLabel[source] + "`\u3000\u{1F4AC} `" + sessionLabel(cwd) + "`" + (extra ? "\u3000" + extra : "");
+  return note(chips);
+}
+function clip(text, max = 3e3) {
+  return text.length > max ? text.slice(0, max) + "\n\u2026\uFF08\u5DF2\u622A\u65AD / truncated\uFF09" : text;
+}
+function codeBlock(content, language) {
+  const fence = content.includes("```") ? "````" : "```";
+  return `${fence}${language}
+${content}
+${fence}`;
+}
+function splitTextIntoChunks(value, chunkSize) {
+  const chunks = [];
+  for (let index = 0; index < value.length; index += chunkSize) chunks.push(value.slice(index, index + chunkSize));
+  return chunks.length > 0 ? chunks : [""];
+}
+function disabledButton(label, type = "default") {
+  return {
+    tag: "button",
+    text: { tag: "plain_text", content: label },
+    type,
+    disabled: true
+  };
+}
+function cliBridgeSettingsSection(input2) {
+  const scopeButton = (label, value) => button(label, { a: CLI.setNotifyScope, v: value }, input2.notifyScope === value ? "primary" : "default");
+  const agentButton = (label, agent, on) => button(`${label}\uFF1A${on ? "\u5F00" : "\u5173"}`, { a: CLI.toggleAgent, agent, v: on ? "off" : "on" }, on ? "primary" : "default");
+  return [
+    hr(),
+    md("**\u2615 \u5496\u5561\u4E00\u4E0B**"),
+    note("\u53BB\u5012\u676F\u5496\u5561\u7684\u5DE5\u592B\uFF0C\u6211\u66FF\u4F60\u76EF\u7740\u672C\u673A\u7684 Claude Code / Codex \u2014\u2014 \u5B83\u8981\u5BA1\u6279\u3001\u8981\u95EE\u4F60\u3001\u6216\u8DD1\u5B8C\u4E86\uFF0C\u90FD\u63A8\u5230\u8FD9\u4E2A\u79C1\u804A\uFF0C\u4F60\u5728\u624B\u673A\u4E0A\u63A5\u7740\u62CD\u677F\u5C31\u884C\u3002"),
+    actions([
+      button(input2.enabled ? "\u5496\u5561\u4E00\u4E0B\uFF1A\u5F00" : "\u5496\u5561\u4E00\u4E0B\uFF1A\u5173", { a: CLI.toggleEnabled, v: input2.enabled ? "off" : "on" }, input2.enabled ? "primary" : "default")
+    ]),
+    note("\u9501\u5C4F\u3001\u6216\u952E\u9F20\u7A7A\u95F2\u8D85\u8FC7\u8BBE\u5B9A\u65F6\u957F\uFF0C\u5C31\u5F53\u4F60\u53BB\u63A5\u5496\u5561\u4E86 \u2192 \u81EA\u52A8\u63A5\u7BA1\uFF1B\u56DE\u5230\u7535\u8111/\u89E3\u9501\u7ACB\u5373\u6536\u624B\u3002"),
+    // Shown only on win32 — macOS/Linux rendering is unchanged.
+    ...process.platform === "win32" ? [note("\u26A0\uFE0F Windows \u79BB\u5F00\u68C0\u6D4B\u4E3A\u5B9E\u9A8C\u6027\uFF08PowerShell\uFF09\uFF1B\u68C0\u6D4B\u4E0D\u53EF\u7528\u65F6\u4F1A\u76F4\u63A5\u8F6C\u53D1\u3002")] : [],
+    md("**\u{1F4E3} \u901A\u77E5\u8303\u56F4**"),
+    note("\u79BB\u5F00\u65F6\u628A\u54EA\u4E9B\u4F1A\u8BDD\u63A8\u5230\u98DE\u4E66\u3002"),
+    actions([
+      scopeButton("\u5168\u90E8", "all"),
+      scopeButton("\u4EC5\u7ED1\u5B9A\u9879\u76EE", "bound_projects"),
+      scopeButton("\u4E0D\u901A\u77E5", "none")
+    ]),
+    md("**\u{1F916} \u8F6C\u53D1\u54EA\u4E9B\u540E\u7AEF**"),
+    actions([
+      agentButton("Claude Code", "claude", input2.agents.claude),
+      agentButton("Codex", "codex", input2.agents.codex)
+    ]),
+    md("**\u{1F50B} \u79BB\u5F00\u4FDD\u6D3B**"),
+    note("\u79BB\u5F00\u4E14\u6709\u4EFB\u52A1\u5728\u8DD1\u65F6\u81EA\u52A8\u9876\u4F4F\u7CFB\u7EDF\u4F11\u7720\uFF08\u5C4F\u5E55\u7167\u5E38\u7184\u706D\uFF09\uFF0C\u56DE\u5230\u7535\u8111/\u89E3\u9501\u5373\u5173\u3002\u4EC5 macOS\u3002"),
+    actions([
+      button(input2.keepAwake ? "\u79BB\u5F00\u4FDD\u6D3B\uFF1A\u5F00" : "\u79BB\u5F00\u4FDD\u6D3B\uFF1A\u5173", { a: CLI.toggleKeepAwake, v: input2.keepAwake ? "off" : "on" }, input2.keepAwake ? "primary" : "default")
+    ]),
+    md(`**\u{1F527} hooks**\u3000Claude Code\uFF1A**${statusLabel[input2.statuses.claude.status]}**\u3000Codex\uFF1A**${statusLabel[input2.statuses.codex.status]}**`),
+    // Repair replaces any agent2lark hooks in place — say so before the user clicks,
+    // since it rewrites another tool's ~/.claude / ~/.codex hook config.
+    ...input2.statuses.claude.status === "conflict_agent2lark" || input2.statuses.codex.status === "conflict_agent2lark" ? [note("\u26A0\uFE0F \u68C0\u6D4B\u5230 agent2lark \u7684 hook\uFF1B\u70B9\u300C\u4FEE\u590D hooks\u300D\u4F1A\u7528\u672C bridge \u8986\u76D6\u5B83\u3002")] : [],
+    actions([button("\u4FEE\u590D hooks", { a: CLI.repairHooks }, "primary")]),
+    input2.canEnable.ok ? note("\u76EE\u6807\uFF1A\u673A\u5668\u4EBA owner \u79C1\u804A\u3000\xB7\u3000hooks \u4E3A\u672C\u673A\u5168\u5C40\uFF0C\u591A\u4E2A\u673A\u5668\u4EBA\u5171\u7528\u4E00\u5957\uFF08\u4FEE\u590D\u4E0D\u4F1A\u91CD\u590D\u5B89\u88C5\uFF09\u3002") : note("\u5F00\u542F\u300C\u2615 \u5496\u5561\u4E00\u4E0B\u300D\u524D\u8BF7\u5148\u8BBE\u7F6E\u673A\u5668\u4EBA owner\u3002")
+  ];
+}
+function buildCliBridgeAwayNoticeCard(input2) {
+  const k2 = input2.key ?? input2.cwd ?? "";
+  const c = pickCopy(COPY.away, k2);
+  return card(
+    [
+      titleEl(c.title),
+      metaLine(input2.source, input2.cwd),
+      note(c.body),
+      md(`\u{1F4C2} **\u5F53\u524D\u9879\u76EE**
+${input2.cwd || "unknown"}`),
+      note(pickCopy(COPY.footerAway, k2))
+    ],
+    { forward: false }
+  );
+}
+function buildCliBridgeApprovalCard(input2) {
+  const status = input2.status ?? "pending";
+  const verb = status === "approved" ? "\u2705 \u5DF2\u5141\u8BB8" : status === "denied" ? "\u26D4 \u5DF2\u62D2\u7EDD" : status === "local" ? "\u21A9\uFE0F \u5DF2\u8F6C\u4EA4\u672C\u673A" : status === "timeout" ? "\u23F0 \u5DF2\u8D85\u65F6" : pickCopy(COPY.permission, input2.id || input2.cwd);
+  const tool = input2.toolName ? "\u{1F6E0}\uFE0F `" + input2.toolName + "`" : void 0;
+  const elements = [
+    titleEl(verb),
+    metaLine(input2.source, input2.cwd, tool),
+    input2.command ? md(`\u{1F4BB} **\u547D\u4EE4**
+${codeBlock(clip(input2.command), "bash")}`) : note("\uFF08hook \u672A\u5E26\u547D\u4EE4\u6587\u672C\uFF09")
+  ];
+  if (status === "pending") {
+    elements.push(actions([
+      button("\u2705 \u5141\u8BB8", { a: CLI.approveOnce, id: input2.id }, "primary"),
+      ...input2.allowSession === false ? [] : [button("\u{1F501} \u59CB\u7EC8\u5141\u8BB8", { a: CLI.approveSession, id: input2.id })],
+      button("\u26D4 \u62D2\u7EDD", { a: CLI.deny, id: input2.id }, "danger")
+    ]));
+  }
+  return card(elements, { forward: false });
+}
+function questionChoiceField(index) {
+  return `q${index}_choice`;
+}
+function questionCustomField(index) {
+  return `q${index}_custom`;
+}
+function optionDisplay(o) {
+  if (!o.description) return o.label;
+  const desc = o.description.length > 36 ? o.description.slice(0, 36) + "\u2026" : o.description;
+  return `${o.label} \u2014 ${desc}`;
+}
+function buildCliBridgeQuestionCard(input2) {
+  const status = input2.status ?? "pending";
+  const questions = input2.questions ?? [];
+  const numbered = questions.length > 1;
+  const verb = status === "approved" ? "\u2705 \u5DF2\u56DE\u7B54" : status === "denied" ? "\u26D4 \u5DF2\u62D2\u7EDD" : status === "local" ? "\u21A9\uFE0F \u5DF2\u8F6C\u4EA4\u672C\u673A" : status === "timeout" ? "\u23F0 \u5DF2\u8D85\u65F6" : pickCopy(COPY.question, input2.id || input2.cwd);
+  const elements = [
+    titleEl(verb),
+    metaLine(input2.source, input2.cwd)
+  ];
+  if (status === "pending") {
+    const formEls = [];
+    questions.forEach((q, i) => {
+      const head = `${numbered ? `${i + 1}. ` : ""}${q.header || "\u8BF7\u4F60\u5B9A\u4E00\u4E0B"}`;
+      formEls.push(md(`\u{1F9E9} **${head}**
+${clip(q.question, 600)}${q.multiSelect ? "\u3000_(\u53EF\u591A\u9009)_" : ""}`));
+      const opts = q.options.map((o) => ({ label: optionDisplay(o), value: o.label }));
+      formEls.push(q.multiSelect ? multiSelectMenu({ name: questionChoiceField(i), placeholder: "\u53EF\u591A\u9009\u2026", options: opts }) : selectMenu({ name: questionChoiceField(i), placeholder: "\u9009\u4E00\u4E2A\u2026", options: opts }));
+      formEls.push(input({ name: questionCustomField(i), placeholder: "\u90FD\u4E0D\u5408\u9002\uFF1F\u76F4\u63A5\u5199\u8FD9\u91CC\uFF08\u586B\u4E86\u5C31\u7528\u4F60\u5199\u7684\uFF09" }));
+    });
+    formEls.push(actions([submitButton("\u2705 \u63D0\u4EA4", { a: CLI.questionSubmit, id: input2.id }, "primary", "submit")]));
+    elements.push(form(`cli_question_${input2.id}`, formEls));
+    elements.push(note("\u{1F419} \u9009\u9879\u548C\u300C\u81EA\u5DF1\u5199\u300D\u90FD\u5728\u5361\u7247\u91CC\uFF0C\u7B54\u5B8C\u70B9\u300C\u63D0\u4EA4\u300D\u5373\u53EF \u2014\u2014 \u4E0D\u7528\u56DE\u5230\u7535\u8111\u3002"));
+  } else if (status === "approved") {
+    const ans = input2.answers ?? {};
+    const lines = questions.length ? questions.map((q, i) => `**${numbered ? `${i + 1}. ` : ""}${q.header || "\u56DE\u7B54"}**\uFF1A${ans[q.question] ?? "\uFF08\u672A\u7B54\uFF09"}`).join("\n") : Object.entries(ans).map(([k2, v]) => `**${k2}**\uFF1A${v}`).join("\n");
+    elements.push(md(`\u2705 \u4F60\u7684\u56DE\u7B54
+${lines || "\uFF08\u65E0\uFF09"}`));
+  }
+  return card(elements, { forward: false });
+}
+function buildCliBridgeTaskCompletionCard(input2) {
+  const verb = input2.replyDoneAt ? "\u2705 \u5DF2\u786E\u8BA4\u5B8C\u6210" : input2.status === "failed" ? "\u274C \u4EFB\u52A1\u5931\u8D25" : pickCopy(COPY.completion, input2.id || input2.cwd);
+  const elements = [
+    titleEl(verb),
+    metaLine(input2.source, input2.cwd)
+  ];
+  const summary = input2.summary?.trim();
+  if (summary) {
+    for (const [index, chunk] of splitTextIntoChunks(clip(summary, 5600), TASK_OUTPUT_CHUNK_SIZE).entries()) {
+      const title = summary.length > TASK_OUTPUT_CHUNK_SIZE ? `Agent \u8F93\u51FA\uFF08${index + 1}\uFF09` : "Agent \u8F93\u51FA";
+      elements.push(md(`\u{1F4DD} **${title}**
+${codeBlock(chunk, "text")}`));
+    }
+  } else {
+    elements.push(note("\uFF08hook \u672A\u5E26\u6700\u7EC8\u56DE\u7B54\uFF09"));
+  }
+  if (input2.replyEnabled) {
+    const expiresAt = input2.replyExpiresAt ? `\uFF08\u6709\u6548\u671F\u81F3 ${new Date(input2.replyExpiresAt).toLocaleString("zh-CN")}\uFF09` : "";
+    elements.push(actions([button("\u23F3 \u7B49\u5F85\u786E\u8BA4", { a: CLI.taskCompletionDone, id: input2.id }, "primary")]));
+    elements.push(note(pickCopy(COPY.footerReply, input2.id || input2.cwd) + expiresAt));
+  } else if (input2.replyDoneAt) {
+    elements.push(actions([disabledButton("\u2705 \u5DF2\u5B8C\u6210", "primary")]));
+  }
+  return card(elements, { forward: false });
+}
+var CLI, BRAND, agentLabel, statusLabel, TASK_OUTPUT_CHUNK_SIZE, COPY;
+var init_cards2 = __esm({
+  "src/cli-bridge/cards.ts"() {
+    "use strict";
+    init_cards();
+    CLI = {
+      toggleEnabled: "cli.toggle.enabled",
+      setDelivery: "cli.set.delivery",
+      setNotifyScope: "cli.set.notifyScope",
+      toggleAgent: "cli.toggle.agent",
+      toggleKeepAwake: "cli.toggle.keepAwake",
+      toggleIncludeBridge: "cli.toggle.includeBridge",
+      repairHooks: "cli.hooks.repair",
+      approveOnce: "cli.approve.once",
+      approveSession: "cli.approve.session",
+      deny: "cli.deny",
+      // One submit for the whole multi-question form (dropdown + custom text per question).
+      questionSubmit: "cli.question.submit",
+      taskCompletionDone: "cli.taskCompletion.done"
+    };
+    BRAND = "\u{1F308} Vonvon Bridge";
+    agentLabel = { claude: "Claude Code", codex: "Codex" };
+    statusLabel = {
+      installed: "\u5DF2\u5B89\u88C5",
+      not_installed: "\u672A\u5B89\u88C5",
+      needs_repair: "\u9700\u4FEE\u590D",
+      conflict_agent2lark: "\u4E0E agent2lark \u51B2\u7A81"
+    };
+    TASK_OUTPUT_CHUNK_SIZE = 2800;
+    COPY = {
+      away: [
+        { title: "\u4F60\u6E9C\u5566?\u6865\u6211\u5148\u7ED9\u4F60\u67B6\u4E0A", body: "\u672C\u5730\u8FD8\u5728\u8DD1\u6D3B\u513F \u2014\u2014 \u63A5\u4E0B\u6765\u8981\u5BA1\u6279 / \u63D0\u95EE / \u6536\u5C3E,\u6211\u90FD\u987A\u7740\u6865\u9012\u7ED9\u4F60\u3002" },
+        { title: "\u4EBA\u8D70\u6865\u4E0D\u65AD,\u6211\u63A5\u7BA1\u4E86", body: "\u68C0\u6D4B\u5230\u4F60\u79BB\u5F00\u3002\u672C\u673A Claude / Codex \u7684\u5927\u5C0F\u4E8B\u6211\u63A5\u7740,\u8981\u7D27\u7684\u5C31\u558A\u4F60\u3002" },
+        { title: "\u4F60\u5FD9\u4F60\u7684,\u8FD9\u5934\u4EA4\u7ED9\u6211", body: "\u4F60\u4E0D\u5728\u952E\u76D8\u524D\u8FD9\u6BB5,\u672C\u5730\u7684\u5BA1\u6279 / \u63D0\u95EE / \u5B8C\u6210,\u6211\u90FD\u9001\u5230\u4F60\u624B\u4E0A\u3002" },
+        { title: "\u6865\u5DF2\u5C31\u4F4D,\u63A5\u7BA1\u6210\u529F", body: "\u672C\u673A\u7684\u6D3B\u513F\u8FD8\u8DD1\u7740\u5462,\u6211\u66FF\u4F60\u5B88\u5728\u8FD9\u5934,\u8BE5\u4F60\u62CD\u677F\u7684\u4E00\u4E2A\u90FD\u4E0D\u6F0F\u3002" }
+      ],
+      permission: [
+        "\u6865\u90A3\u5934\u60F3\u52A8\u624B,\u5148\u95EE\u4F60\u4E00\u58F0",
+        "\u6709\u6761\u547D\u4EE4\u60F3\u8DD1,\u7B49\u4F60\u70B9\u4E2A\u5934",
+        "\u5B83\u4E3E\u624B\u4E86:\u8FD9\u4E2A\u64CD\u4F5C\u80FD\u653E\u884C\u5417?",
+        "\u672C\u5730\u8981\u6267\u884C\u70B9\u4E1C\u897F,\u4F60\u6765\u62CD\u677F"
+      ],
+      question: [
+        "\u6865\u90A3\u5934\u5361\u4E86\u4E2A\u9009\u62E9,\u7B49\u4F60\u5B9A",
+        "\u6709\u9053\u9009\u62E9\u9898\u9001\u5230\u4F60\u9762\u524D\u5566",
+        "\u5B83\u62FF\u4E0D\u51C6,\u60F3\u542C\u542C\u4F60\u7684",
+        "\u5E2E\u4F60\u63A5\u4F4F\u4E00\u4E2A\u9009\u62E9,\u9009\u54EA\u4E2A?"
+      ],
+      completion: [
+        "\u6865\u90A3\u5934\u6536\u5DE5\u4E86,\u7784\u4E00\u773C?",
+        "\u6D3B\u513F\u5E72\u5B8C\u4E86,\u7B49\u4F60\u4E00\u53E5\u8BDD",
+        "\u641E\u5B9A!\u60F3\u63A5\u7740\u652F\u4F7F\u5C31\u56DE\u6211\u4E00\u53E5",
+        "\u8FD9\u4E00\u8F6E\u7ED3\u675F,\u770B\u770B\u6210\u679C?"
+      ],
+      footerAway: [
+        "\u4F60\u4E00\u56DE\u7535\u8111(\u89E3\u9501 / \u52A8\u952E\u9F20),\u6211\u7ACB\u523B\u6536\u6865,\u7EDD\u4E0D\u6253\u6270\u3002",
+        "\u56DE\u5230\u952E\u76D8\u6211\u5C31\u628A\u6865\u64A4\u4E86,\u534A\u70B9\u4E0D\u70E6\u4F60\u3002",
+        "\u4EBA\u5728\u684C\u524D\u6211\u5C31\u95ED\u5634,\u4E00\u5207\u56DE\u5F52\u7EC8\u7AEF\u3002"
+      ],
+      footerReply: [
+        "\u{1F4AC} \u76F4\u63A5\u56DE\u590D\u8FD9\u6761\u6D88\u606F,\u5C31\u80FD\u63A5\u7740\u652F\u4F7F\u5B83\u5E72\u6D3B;\u6216\u70B9\u300C\u7B49\u5F85\u786E\u8BA4\u300D\u8BA9\u5B83\u6536\u5DE5\u3002",
+        "\u{1F4AC} \u56DE\u6211\u4E00\u53E5\u8BDD,\u5B83\u7ACB\u523B\u63A5\u7740\u8DD1;\u4E0D\u60F3\u7EE7\u7EED\u5C31\u70B9\u300C\u7B49\u5F85\u786E\u8BA4\u300D\u3002"
+      ]
+    };
+  }
+});
+
+// src/core/stdin.ts
+function readStdin() {
+  return new Promise((resolve9) => {
+    if (process.stdin.isTTY) {
+      resolve9("");
+      return;
+    }
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => resolve9(data));
+  });
+}
+var init_stdin = __esm({
+  "src/core/stdin.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli-bridge/ipc.ts
+import { chmod as chmod5, rm as rm6 } from "fs/promises";
+import net from "net";
+async function startCliBridgeIpcServer(opts) {
+  if (process.platform !== "win32") {
+    await rm6(opts.socketPath, { force: true }).catch(() => void 0);
+  }
+  const sockets = /* @__PURE__ */ new Set();
+  const server = net.createServer((socket) => {
+    sockets.add(socket);
+    socket.on("close", () => sockets.delete(socket));
+    socket.on("error", () => sockets.delete(socket));
+    let data = "";
+    let handled = false;
+    socket.on("data", (chunk) => {
+      if (handled) return;
+      data += chunk.toString("utf8");
+      if (!data.includes("\n")) return;
+      handled = true;
+      const line = data.split("\n")[0] ?? "";
+      void (async () => {
+        try {
+          const msg = JSON.parse(line);
+          const response = await opts.handleMessage(msg);
+          socket.end(JSON.stringify(response) + "\n");
+        } catch (err) {
+          socket.end(JSON.stringify({ decision: "fallback_local", reason: err instanceof Error ? err.message : String(err) }) + "\n");
+        }
+      })();
+    });
+  });
+  await new Promise((resolve9, reject) => {
+    server.once("error", reject);
+    server.listen(opts.socketPath, () => {
+      server.off("error", reject);
+      if (process.platform === "win32") {
+        resolve9();
+        return;
+      }
+      chmod5(opts.socketPath, 384).then(resolve9, (err) => {
+        server.close(() => reject(err));
+      });
+    });
+  });
+  return {
+    close: () => new Promise((resolve9) => {
+      for (const socket of sockets) socket.destroy();
+      sockets.clear();
+      server.close(() => resolve9());
+    })
+  };
+}
+async function sendCliHookMessage(socketPath, msg) {
+  return new Promise((resolve9, reject) => {
+    const socket = net.createConnection(socketPath);
+    let data = "";
+    socket.setTimeout(864e5);
+    socket.on("connect", () => socket.write(JSON.stringify(msg) + "\n"));
+    socket.on("data", (chunk) => {
+      data += chunk.toString("utf8");
+      if (!data.includes("\n")) return;
+      socket.end();
+      try {
+        resolve9(JSON.parse(data.split("\n")[0] ?? ""));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    socket.on("timeout", () => {
+      socket.destroy();
+      reject(new Error("cli bridge IPC timeout"));
+    });
+    socket.on("error", reject);
+  });
+}
+var init_ipc = __esm({
+  "src/cli-bridge/ipc.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli-bridge/parser.ts
+function normalizeEventName(eventName) {
+  if (!eventName) return eventName;
+  if (["PermissionRequest", "permission_request", "permission.asked", "permission_requested"].includes(eventName)) return "PermissionRequest";
+  if (["PreToolUse", "pre_tool_use"].includes(eventName)) return "PreToolUse";
+  if (["PostToolUse", "post_tool_use"].includes(eventName)) return "PostToolUse";
+  if (["Stop", "stop", "SubagentStop", "subagent_stop", "session.idle", "session_idle"].includes(eventName)) return "TaskComplete";
+  if (["StopFailure", "stop_failure", "session.error", "session_error"].includes(eventName)) return "TaskCompleteFailure";
+  return eventName;
+}
+function stringifySummaryValue(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value.trim();
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return value.map(stringifySummaryValue).filter(Boolean).join("\n").trim();
+  if (typeof value === "object") {
+    const obj = value;
+    for (const key of ["last_assistant_message", "lastAssistantMessage", "assistant_message", "assistantMessage", "assistant", "final", "completion", "answer", "response", "output", "result", "content", "text", "message", "summary", "error"]) {
+      const text = stringifySummaryValue(obj[key]);
+      if (text) return text;
+    }
+  }
+  return "";
+}
+function parseHookPayload(source, rawPayload, env = process.env) {
+  let data = {};
+  try {
+    const parsed = JSON.parse(rawPayload);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) data = parsed;
+  } catch {
+    data = {};
+  }
+  const hookEventName = String(data.hook_event_name ?? data.event_type ?? "PermissionRequest");
+  const normalized = normalizeEventName(hookEventName);
+  const typeByEvent = {
+    PermissionRequest: "permission_request",
+    PostToolUse: "post_tool_use",
+    TaskComplete: "task_complete",
+    TaskCompleteFailure: "task_complete"
+  };
+  const type = typeByEvent[normalized ?? ""] ?? "pre_tool_use";
+  const toolInput = data.tool_input ?? data.toolInput ?? data.metadata ?? data.properties ?? {};
+  return {
+    type,
+    source,
+    sessionId: String(data.session_id ?? data.sessionId ?? ""),
+    cwd: String(data.cwd ?? ""),
+    toolName: String(data.tool_name ?? data.toolName ?? data.permission ?? ""),
+    toolInput: toolInput && typeof toolInput === "object" && !Array.isArray(toolInput) ? toolInput : {},
+    hookEventName,
+    stopHookActive: data.stop_hook_active === true || data.stopHookActive === true,
+    permissionMode: typeof data.permission_mode === "string" ? data.permission_mode : typeof data.permissionMode === "string" ? data.permissionMode : void 0,
+    permissionSuggestions: Array.isArray(data.permission_suggestions) ? data.permission_suggestions : Array.isArray(data.permissionSuggestions) ? data.permissionSuggestions : void 0,
+    taskStatus: normalized === "TaskCompleteFailure" ? "failed" : normalized === "TaskComplete" ? "completed" : void 0,
+    summary: type === "task_complete" ? stringifySummaryValue(data) : void 0,
+    bridgeOwned: env.FEISHU_CODEX_BRIDGE === "1",
+    rawPayloadBytes: Buffer.byteLength(rawPayload, "utf8")
+  };
+}
+function extractAskUserQuestion(toolInput) {
+  const rawQuestions = toolInput.questions;
+  if (!Array.isArray(rawQuestions) || rawQuestions.length < 1 || rawQuestions.length > 4) return void 0;
+  const questions = rawQuestions.flatMap((raw) => {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return [];
+    const obj = raw;
+    const question = typeof obj.question === "string" ? obj.question.trim() : "";
+    if (!question) return [];
+    const rawOptions = obj.options;
+    if (!Array.isArray(rawOptions) || rawOptions.length < 2) return [];
+    const options = rawOptions.flatMap((option) => {
+      if (!option || typeof option !== "object" || Array.isArray(option)) return [];
+      const o = option;
+      if (typeof o.label !== "string" || !o.label.trim()) return [];
+      return [{
+        label: o.label.trim(),
+        description: typeof o.description === "string" && o.description.trim() ? o.description.trim() : void 0,
+        preview: typeof o.preview === "string" && o.preview.trim() ? o.preview.trim() : void 0
+      }];
+    });
+    if (options.length !== rawOptions.length) return [];
+    return [{
+      question,
+      header: typeof obj.header === "string" && obj.header.trim() ? obj.header.trim() : void 0,
+      multiSelect: obj.multiSelect === true,
+      options
+    }];
+  });
+  if (questions.length !== rawQuestions.length) return void 0;
+  return { questions };
+}
+var init_parser = __esm({
+  "src/cli-bridge/parser.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli-bridge/protocol.ts
+function buildHookStdout(msg, response) {
+  if (response.stdout !== void 0) return response.stdout;
+  if (msg.type === "post_tool_use") return "{}";
+  if (response.decision === "fallback_local") return "";
+  if (msg.type === "task_complete") return "{}";
+  const decision = response.decision === "deny" ? "deny" : "allow";
+  if (msg.source === "codex") {
+    if (msg.hookEventName === "PermissionRequest") {
+      const decisionObj2 = { behavior: decision };
+      if (decision === "deny") decisionObj2.message = response.reason || "Denied by feishu-codex-bridge.";
+      return JSON.stringify({ hookSpecificOutput: { hookEventName: "PermissionRequest", decision: decisionObj2 } });
+    }
+    if (msg.hookEventName === "PreToolUse" && decision === "deny") {
+      return JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "deny",
+          permissionDecisionReason: response.reason || "Denied by feishu-codex-bridge."
+        }
+      });
+    }
+    return "{}";
+  }
+  const decisionObj = { behavior: decision };
+  if (decision === "allow" && response.updatedInput) decisionObj.updatedInput = response.updatedInput;
+  if (decision === "deny") {
+    decisionObj.message = response.reason || "Denied by feishu-codex-bridge.";
+    if (response.interrupt) decisionObj.interrupt = true;
+  }
+  return JSON.stringify({ hookSpecificOutput: { hookEventName: "PermissionRequest", decision: decisionObj } });
+}
+var init_protocol = __esm({
+  "src/cli-bridge/protocol.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli-bridge/store.ts
+import { randomUUID as randomUUID6 } from "crypto";
+function prunePending(now) {
+  for (const [id, item] of pending) {
+    if (now - item.createdAt <= STALE_PENDING_MS) continue;
+    pending.delete(id);
+    waiters.delete(id);
+    settled.delete(id);
+  }
+}
+function createPendingCliInteraction(input2) {
+  const now = Date.now();
+  prunePending(now);
+  const item = { ...input2, id: randomUUID6(), createdAt: now };
+  pending.set(item.id, item);
+  return item;
+}
+function setPendingCliMessageId(id, messageId) {
+  const item = pending.get(id);
+  if (item) pending.set(id, { ...item, messageId });
+}
+function getPendingCliInteraction(id) {
+  return pending.get(id);
+}
+function findPendingCliInteractionByMessageReply(input2) {
+  const targets = [input2.parentId, input2.rootId].filter((x) => Boolean(x));
+  for (const item of pending.values()) {
+    if (item.messageId && targets.includes(item.messageId)) return item;
+  }
+  return void 0;
+}
+function resolvePendingCliInteraction(id, response) {
+  const item = pending.get(id);
+  if (!item) return false;
+  pending.delete(id);
+  const waiter = waiters.get(id);
+  if (waiter) {
+    waiters.delete(id);
+    waiter(response);
+  } else {
+    settled.set(id, response);
+  }
+  return true;
+}
+function waitForPendingCliInteraction(id, timeoutMs) {
+  return new Promise((resolve9) => {
+    const buffered = settled.get(id);
+    if (buffered) {
+      settled.delete(id);
+      resolve9(buffered);
+      return;
+    }
+    if (!pending.has(id)) {
+      resolve9({ decision: "fallback_local", reason: "missing_pending" });
+      return;
+    }
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      waiters.delete(id);
+      settled.delete(id);
+      resolve9({ decision: "fallback_local", reason: "timeout" });
+    }, Math.max(timeoutMs, 0));
+    waiters.set(id, (response) => {
+      clearTimeout(timer);
+      resolve9(response);
+    });
+  });
+}
+var pending, waiters, settled, STALE_PENDING_MS;
+var init_store2 = __esm({
+  "src/cli-bridge/store.ts"() {
+    "use strict";
+    pending = /* @__PURE__ */ new Map();
+    waiters = /* @__PURE__ */ new Map();
+    settled = /* @__PURE__ */ new Map();
+    STALE_PENDING_MS = 25 * 60 * 6e4;
+  }
+});
+
+// src/cli-bridge/presence.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+async function resolveCliPresenceRoute(prefs) {
+  const activity = await resolveCliLocalActivity(prefs);
+  if (activity.localActive) return { routeToFeishu: false, reason: "local_active" };
+  if (activity.reason === "away") return { routeToFeishu: true, reason: "away" };
+  if (activity.reason === "presence_failed" && process.platform === "win32") {
+    return { routeToFeishu: true, reason: "presence_failed" };
+  }
+  return { routeToFeishu: false, reason: activity.reason };
+}
+async function readMacIdleSeconds() {
+  const now = Date.now();
+  if (idleCache && now - idleCache.at < IDLE_READ_TTL_MS) return idleCache.seconds;
+  const { stdout } = await execFileAsync2("/usr/sbin/ioreg", ["-c", "IOHIDSystem"]);
+  const match = stdout.match(/HIDIdleTime"\s*=\s*(\d+)/);
+  const seconds = Math.floor((match ? Number(match[1]) : 0) / 1e9);
+  idleCache = { seconds, at: now };
+  return seconds;
+}
+function parseScreenLocked(ioregStdout) {
+  return /CGSSessionScreenIsLocked"?\s*=\s*Yes/.test(ioregStdout);
+}
+async function readMacScreenLocked() {
+  const now = Date.now();
+  if (lockCache && now - lockCache.at < IDLE_READ_TTL_MS) return lockCache.locked;
+  const { stdout } = await execFileAsync2("/usr/sbin/ioreg", ["-n", "Root", "-d1", "-k", "IOConsoleUsers"]);
+  const locked = parseScreenLocked(stdout);
+  lockCache = { locked, at: now };
+  return locked;
+}
+async function readWindowsIdleSeconds() {
+  const now = Date.now();
+  if (idleCache && now - idleCache.at < IDLE_READ_TTL_MS) return idleCache.seconds;
+  const script = [
+    "Add-Type @'",
+    "using System;",
+    "using System.Runtime.InteropServices;",
+    "public class A2LIdle {",
+    "  [StructLayout(LayoutKind.Sequential)] struct LII { public uint cbSize; public uint dwTime; }",
+    '  [DllImport("user32.dll")] static extern bool GetLastInputInfo(ref LII p);',
+    "  public static uint Ms() { LII l = new LII(); l.cbSize = (uint)Marshal.SizeOf(l); GetLastInputInfo(ref l); return ((uint)Environment.TickCount) - l.dwTime; }",
+    "}",
+    "'@",
+    // Lock screen ⇒ LogonUI.exe is running ⇒ report a huge idle value so it counts
+    // as away immediately, without waiting out the idle threshold (mirrors macOS,
+    // where lock is instant-away). Also fires during login/UAC — harmless here.
+    "if (Get-Process LogonUI -ErrorAction SilentlyContinue) { 0x7FFFFFFF } else { [A2LIdle]::Ms() }"
+  ].join("\n");
+  const encoded = Buffer.from(script, "utf16le").toString("base64");
+  const { stdout } = await execFileAsync2("powershell", ["-NoProfile", "-NonInteractive", "-EncodedCommand", encoded]);
+  const ms = Number(stdout.trim());
+  if (!Number.isFinite(ms)) throw new Error(`unparseable idle output: ${stdout.slice(0, 50)}`);
+  const seconds = Math.floor(ms / 1e3);
+  idleCache = { seconds, at: now };
+  return seconds;
+}
+async function resolveCliLocalActivity(prefs) {
+  if (!prefs.presence.enabled) return { localActive: false, reason: "disabled" };
+  const useMacReaders = prefs.presence.platform === "macos" || prefs.presence.platform === "auto" && process.platform === "darwin";
+  const readIdleSeconds = useMacReaders ? readMacIdleSeconds : process.platform === "win32" ? readWindowsIdleSeconds : void 0;
+  if (!readIdleSeconds) return { localActive: false, reason: "presence_failed" };
+  if (useMacReaders && await readMacScreenLocked().catch(() => false)) {
+    return { localActive: false, reason: "away" };
+  }
+  try {
+    const idleSeconds = await readIdleSeconds();
+    return idleSeconds >= prefs.presence.idleThresholdSeconds ? { localActive: false, reason: "away" } : { localActive: true, reason: "local_active" };
+  } catch {
+    return { localActive: false, reason: "presence_failed" };
+  }
+}
+var execFileAsync2, IDLE_READ_TTL_MS, idleCache, lockCache;
+var init_presence = __esm({
+  "src/cli-bridge/presence.ts"() {
+    "use strict";
+    execFileAsync2 = promisify2(execFile2);
+    IDLE_READ_TTL_MS = 2e3;
+  }
+});
+
+// src/cli-bridge/keep-awake.ts
+import { spawn as spawn4 } from "child_process";
+function spawnCaffeinate() {
+  if (process.platform !== "darwin") return void 0;
+  const child = spawn4("/usr/bin/caffeinate", ["-i", "-w", String(process.pid)], { stdio: "ignore" });
+  child.on("error", () => void 0);
+  return child;
+}
+function createKeepAwakeController(opts = {}) {
+  const enabled = opts.enabled ?? (() => true);
+  const spawnProcess2 = opts.spawnProcess ?? spawnCaffeinate;
+  let count = 0;
+  let proc;
+  const stop = () => {
+    if (!proc) return;
+    try {
+      proc.kill();
+    } catch {
+    }
+    proc = void 0;
+  };
+  return {
+    acquire() {
+      count += 1;
+      if (!proc && enabled()) proc = spawnProcess2();
+    },
+    release() {
+      if (count === 0) return;
+      count -= 1;
+      if (count === 0) stop();
+    },
+    shutdown() {
+      count = 0;
+      stop();
+    },
+    isActive() {
+      return Boolean(proc);
+    }
+  };
+}
+var init_keep_awake = __esm({
+  "src/cli-bridge/keep-awake.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli-bridge/service.ts
+function createCliBridgeService(opts) {
+  let ipc;
+  const allowedSessions = /* @__PURE__ */ new Set();
+  const prefs = () => getCliBridgePreferences(opts.cfg);
+  const hasCustomPresence = Boolean(opts.presence);
+  const presence = opts.presence ?? (() => resolveCliPresenceRoute(prefs()));
+  const localActivity = opts.localActivity ?? (hasCustomPresence ? async () => !(await presence()).routeToFeishu : async () => (await resolveCliLocalActivity(prefs())).localActive);
+  const localReturnPollMs = opts.localReturnPollMs ?? 5e3;
+  const keepAwake = opts.keepAwake ?? createKeepAwakeController({ enabled: () => prefs().keepAwake.enabled });
+  async function notifyAllowedForCwd(cwd) {
+    const scope = prefs().notifyScope;
+    if (scope === "none") return false;
+    if (scope === "bound_projects") return opts.isBoundProject ? Boolean(await opts.isBoundProject(cwd)) : true;
+    return true;
+  }
+  const sessionKey = (input2) => `${input2.source}:${input2.sessionId}`;
+  const sendOwnerCard = (target, cardObject) => sendManagedCard(opts.channel, target.receiveId, cardObject, void 0, false, target.receiveIdType);
+  let replyReaction;
+  async function addTypingReaction(messageId) {
+    try {
+      const r = await opts.channel.rawClient.im.v1.messageReaction.create({
+        path: { message_id: messageId },
+        data: { reaction_type: { emoji_type: "Typing" } }
+      });
+      return r.data?.reaction_id;
+    } catch (err) {
+      log.fail("cli-bridge", err, { phase: "reply-typing-add" });
+      return void 0;
+    }
+  }
+  function armReplyTypingReaction(messageId) {
+    clearReplyTypingReaction();
+    replyReaction = { messageId, idPromise: addTypingReaction(messageId) };
+  }
+  function clearReplyTypingReaction() {
+    const r = replyReaction;
+    replyReaction = void 0;
+    if (!r) return;
+    void r.idPromise.then((id) => {
+      if (!id) return void 0;
+      return opts.channel.rawClient.im.v1.messageReaction.delete({ path: { message_id: r.messageId, reaction_id: id } }).catch((err) => log.fail("cli-bridge", err, { phase: "reply-typing-del" }));
+    }).catch(() => {
+    });
+  }
+  let awayNoticeSent = false;
+  const markLocalActive = () => {
+    awayNoticeSent = false;
+  };
+  async function ensureAwayNoticeSent(target, msg) {
+    if (awayNoticeSent) return;
+    awayNoticeSent = true;
+    await sendOwnerCard(target, buildCliBridgeAwayNoticeCard({ source: msg.source, cwd: msg.cwd, key: msg.sessionId })).catch(
+      (err) => log.fail("cli-bridge", err, { phase: "away-notice" })
+    );
+  }
+  const updatePendingCard = (pending2, cardObject) => {
+    if (!pending2.messageId) return;
+    void updateManagedCard(opts.channel, pending2.messageId, cardObject).catch(
+      (err) => log.fail("cli-bridge", err, { phase: "update-card" })
+    );
+  };
+  const closeCard = (messageId, cardObject, phase) => {
+    void updateManagedCard(opts.channel, messageId, cardObject).catch(
+      (err) => log.fail("cli-bridge", err, { phase })
+    );
+  };
+  function renderPendingCard(pending2, overrides = {}) {
+    if (pending2.kind === "permission") {
+      return buildCliBridgeApprovalCard({
+        id: pending2.id,
+        source: pending2.source,
+        cwd: pending2.cwd,
+        toolName: pending2.toolName,
+        command: pending2.command,
+        hookEventName: pending2.hookEventName,
+        sessionId: pending2.sessionId,
+        createdAt: pending2.createdAt,
+        allowSession: overrides.allowSession,
+        status: overrides.status
+      });
+    }
+    if (pending2.kind === "question") {
+      return buildCliBridgeQuestionCard({
+        id: pending2.id,
+        source: "claude",
+        cwd: pending2.cwd,
+        questions: pending2.questions ?? [],
+        hookEventName: pending2.hookEventName,
+        createdAt: pending2.createdAt,
+        status: overrides.status,
+        answers: overrides.answers
+      });
+    }
+    return buildCliBridgeTaskCompletionCard({
+      id: pending2.id,
+      source: pending2.source,
+      cwd: pending2.cwd,
+      sessionId: pending2.sessionId,
+      hookEventName: pending2.hookEventName,
+      status: pending2.taskStatus ?? "completed",
+      summary: pending2.summary,
+      replyEnabled: overrides.replyEnabled ?? false,
+      replyExpiresAt: overrides.replyExpiresAt,
+      replyDoneAt: overrides.replyDoneAt,
+      createdAt: pending2.createdAt
+    });
+  }
+  async function waitWithLocalReturn(id, timeoutMs, onLocalReturn) {
+    const waiter = waitForPendingCliInteraction(id, timeoutMs);
+    const checkLocalReturn = () => {
+      void localActivity().then((active) => {
+        if (!active) return;
+        markLocalActive();
+        if (getPendingCliInteraction(id)) resolvePendingCliInteraction(id, onLocalReturn);
+      }).catch(() => {
+      });
+    };
+    checkLocalReturn();
+    const poll = setInterval(checkLocalReturn, localReturnPollMs);
+    keepAwake.acquire();
+    try {
+      return await waiter;
+    } finally {
+      clearInterval(poll);
+      keepAwake.release();
+    }
+  }
+  async function handleMessage(msg) {
+    const p = prefs();
+    if (!p.enabled || !p.agents[msg.source]) return { decision: "fallback_local", reason: "disabled" };
+    if (msg.bridgeOwned && !p.includeBridgeOwnedSessionsForDebugging) {
+      return { decision: "fallback_local", reason: "bridge_owned_session" };
+    }
+    if (msg.type === "post_tool_use") return { decision: "allow" };
+    const route = await presence();
+    log.info("cli-bridge", "hook-recv", {
+      type: msg.type,
+      source: msg.source,
+      event: msg.hookEventName,
+      stopHookActive: msg.stopHookActive === true,
+      route: route.reason
+    });
+    if (route.reason === "local_active") markLocalActive();
+    if (msg.type === "task_complete") {
+      clearReplyTypingReaction();
+      if (!p.taskCompletion.enabled) return { decision: "fallback_local", reason: "task_completion_disabled" };
+      if (!route.routeToFeishu) return { decision: "fallback_local", reason: route.reason };
+      if (!await notifyAllowedForCwd(msg.cwd)) return { decision: "fallback_local", reason: "notify_scope" };
+      const target2 = resolveCliBridgeTarget(opts.cfg);
+      if (!target2) return { decision: "fallback_local", reason: "missing_owner" };
+      const canReplyFromFeishu = p.taskCompletion.replyEnabled && !await localActivity();
+      const replyExpiresAt = canReplyFromFeishu ? Date.now() + p.taskCompletion.replyTimeoutSeconds * 1e3 : void 0;
+      const pending3 = canReplyFromFeishu ? createPendingCliInteraction({
+        kind: "task_completion",
+        source: msg.source,
+        sessionId: msg.sessionId,
+        cwd: msg.cwd,
+        hookEventName: msg.hookEventName,
+        taskStatus: msg.taskStatus ?? "completed",
+        summary: msg.summary,
+        replyExpiresAt
+      }) : void 0;
+      if (route.reason === "away") await ensureAwayNoticeSent(target2, msg);
+      const sent2 = await sendOwnerCard(
+        target2,
+        buildCliBridgeTaskCompletionCard({
+          id: pending3?.id ?? "",
+          source: msg.source,
+          cwd: msg.cwd,
+          sessionId: msg.sessionId,
+          hookEventName: msg.hookEventName,
+          status: msg.taskStatus ?? "completed",
+          summary: msg.summary,
+          replyEnabled: canReplyFromFeishu,
+          replyExpiresAt,
+          createdAt: pending3?.createdAt
+        })
+      );
+      if (!pending3) return { decision: "allow" };
+      setPendingCliMessageId(pending3.id, sent2.messageId);
+      const result2 = await waitWithLocalReturn(pending3.id, p.taskCompletion.replyTimeoutSeconds * 1e3, { decision: "allow" });
+      if (result2.reason !== TASK_DONE_CLICKED) {
+        closeCard(sent2.messageId, renderPendingCard(pending3), "close-task-card");
+      }
+      return result2;
+    }
+    if (!route.routeToFeishu) return { decision: "fallback_local", reason: route.reason };
+    const target = resolveCliBridgeTarget(opts.cfg);
+    if (!target) return { decision: "fallback_local", reason: "missing_owner" };
+    if (msg.source === "claude" && msg.toolName === "AskUserQuestion") {
+      if (!await notifyAllowedForCwd(msg.cwd)) return { decision: "fallback_local", reason: "notify_scope" };
+      const ask = extractAskUserQuestion(msg.toolInput);
+      if (!ask) return { decision: "fallback_local", reason: "unsupported_ask_user_question" };
+      const pending3 = createPendingCliInteraction({
+        kind: "question",
+        source: msg.source,
+        sessionId: msg.sessionId,
+        cwd: msg.cwd,
+        questions: ask.questions,
+        // First question text doubles as the reply-match anchor / log label.
+        question: ask.questions[0]?.question,
+        hookEventName: msg.hookEventName,
+        toolInput: msg.toolInput
+      });
+      if (route.reason === "away") await ensureAwayNoticeSent(target, msg);
+      const sent2 = await sendOwnerCard(target, renderPendingCard(pending3));
+      setPendingCliMessageId(pending3.id, sent2.messageId);
+      const result2 = await waitWithLocalReturn(
+        pending3.id,
+        p.approval.timeoutSeconds * 1e3,
+        { decision: "fallback_local", reason: LOCAL_RETURN }
+      );
+      if (result2.reason === LOCAL_RETURN) {
+        closeCard(sent2.messageId, renderPendingCard(pending3, { status: "local" }), "close-question-card");
+      }
+      return result2;
+    }
+    if (!p.approval.enabled) return { decision: "fallback_local", reason: "approval_disabled" };
+    if (p.allowCache.enabled && allowedSessions.has(sessionKey(msg))) return { decision: "allow" };
+    if (!await notifyAllowedForCwd(msg.cwd)) return { decision: "fallback_local", reason: "notify_scope" };
+    const command = typeof msg.toolInput.command === "string" ? msg.toolInput.command : void 0;
+    const pending2 = createPendingCliInteraction({
+      kind: "permission",
+      source: msg.source,
+      sessionId: msg.sessionId,
+      cwd: msg.cwd,
+      toolName: msg.toolName,
+      command,
+      hookEventName: msg.hookEventName,
+      question: "Permission request"
+    });
+    if (route.reason === "away") await ensureAwayNoticeSent(target, msg);
+    const sent = await sendOwnerCard(target, renderPendingCard(pending2, { allowSession: p.allowCache.enabled }));
+    setPendingCliMessageId(pending2.id, sent.messageId);
+    const result = await waitWithLocalReturn(
+      pending2.id,
+      p.approval.timeoutSeconds * 1e3,
+      { decision: "fallback_local", reason: LOCAL_RETURN }
+    );
+    if (result.reason === LOCAL_RETURN) {
+      closeCard(sent.messageId, renderPendingCard(pending2, { status: "local" }), "close-approval-card");
+    }
+    return result;
+  }
+  function resolveAction(action) {
+    if (!action.id) return false;
+    if (action.actionId === CLI.approveOnce) {
+      const pending2 = getPendingCliInteraction(action.id);
+      if (!pending2 || pending2.kind !== "permission") return false;
+      updatePendingCard(pending2, renderPendingCard(pending2, { status: "approved" }));
+      return resolvePendingCliInteraction(action.id, { decision: "allow" });
+    }
+    if (action.actionId === CLI.approveSession) {
+      const pending2 = getPendingCliInteraction(action.id);
+      if (!pending2 || pending2.kind !== "permission") return false;
+      updatePendingCard(pending2, renderPendingCard(pending2, { status: "approved" }));
+      const ok = resolvePendingCliInteraction(action.id, { decision: "allow" });
+      if (ok && prefs().allowCache.enabled) allowedSessions.add(sessionKey(pending2));
+      return ok;
+    }
+    if (action.actionId === CLI.deny) {
+      const pending2 = getPendingCliInteraction(action.id);
+      if (!pending2 || pending2.kind !== "permission") return false;
+      updatePendingCard(pending2, renderPendingCard(pending2, { status: "denied" }));
+      return resolvePendingCliInteraction(action.id, { decision: "deny", interrupt: true, reason: "Denied from Feishu" });
+    }
+    if (action.actionId === CLI.taskCompletionDone) {
+      const pending2 = getPendingCliInteraction(action.id);
+      if (!pending2 || pending2.kind !== "task_completion") return false;
+      updatePendingCard(pending2, renderPendingCard(pending2, { replyDoneAt: Date.now() }));
+      return resolvePendingCliInteraction(action.id, { decision: "allow", reason: TASK_DONE_CLICKED });
+    }
+    return false;
+  }
+  function resolveQuestionSubmit(id, formValue) {
+    const pending2 = getPendingCliInteraction(id);
+    if (!pending2 || pending2.kind !== "question") return false;
+    const questions = pending2.questions ?? [];
+    const answers = {};
+    questions.forEach((q, i) => {
+      const custom = String(formValue[questionCustomField(i)] ?? "").trim();
+      if (custom) {
+        answers[q.question] = custom;
+        return;
+      }
+      const choice = formValue[questionChoiceField(i)];
+      if (Array.isArray(choice)) {
+        const picked = choice.map((c) => String(c).trim()).filter(Boolean);
+        if (picked.length) answers[q.question] = picked.join("\u3001");
+      } else if (typeof choice === "string" && choice.trim()) {
+        answers[q.question] = choice.trim();
+      }
+    });
+    if (Object.keys(answers).length === 0) return false;
+    updatePendingCard(pending2, renderPendingCard(pending2, { status: "approved", answers }));
+    return resolvePendingCliInteraction(id, {
+      decision: "allow",
+      // 必须保留原始 toolInput（含 questions），仅追加 answers——否则 Claude Code
+      // 用 updatedInput 整体替换入参后 questions 变 undefined，渲染时崩 "H.map"。
+      updatedInput: { ...pending2.toolInput ?? {}, answers }
+    });
+  }
+  function resolveReply(reply) {
+    const pending2 = findPendingCliInteractionByMessageReply(reply);
+    const text = reply.text?.trim();
+    if (!pending2 || pending2.kind !== "task_completion" || !text) return false;
+    const ok = resolvePendingCliInteraction(pending2.id, { decision: "allow", stdout: JSON.stringify({ decision: "block", reason: text }) });
+    if (ok && reply.messageId) armReplyTypingReaction(reply.messageId);
+    return ok;
+  }
+  return {
+    start: async () => {
+      if (ipc) return;
+      ipc = await startCliBridgeIpcServer({ socketPath: opts.socketPath, handleMessage });
+      log.info("cli-bridge", "started", { socketPath: opts.socketPath });
+    },
+    shutdown: async () => {
+      await ipc?.close();
+      ipc = void 0;
+      allowedSessions.clear();
+      keepAwake.shutdown();
+    },
+    handleMessage,
+    resolveAction,
+    resolveQuestionSubmit,
+    resolveReply,
+    onMessage: (msg) => {
+      const reply = { parentId: msg.parentId, rootId: msg.rootId, text: msg.text, messageId: msg.messageId };
+      if (resolveReply(reply)) return true;
+      return Boolean(findPendingCliInteractionByMessageReply(reply));
+    },
+    register: (dispatcher) => {
+      dispatcher.on(CLI.approveOnce, ({ value }) => {
+        resolveAction({ actionId: CLI.approveOnce, id: String(value.id ?? "") });
+      }).on(CLI.approveSession, ({ value }) => {
+        resolveAction({ actionId: CLI.approveSession, id: String(value.id ?? "") });
+      }).on(CLI.deny, ({ value }) => {
+        resolveAction({ actionId: CLI.deny, id: String(value.id ?? "") });
+      }).on(CLI.taskCompletionDone, ({ value }) => {
+        resolveAction({ actionId: CLI.taskCompletionDone, id: String(value.id ?? "") });
+      }).on(CLI.questionSubmit, ({ value, formValue }) => {
+        resolveQuestionSubmit(String(value.id ?? ""), formValue ?? {});
+      });
+    }
   };
-  await saveBots(reg);
-  return reg;
-}
-function findBot(reg, nameOrAppId) {
-  return reg.bots.find((b) => b.name === nameOrAppId || b.appId === nameOrAppId);
-}
-function currentBot(reg) {
-  return reg.current ? reg.bots.find((b) => b.appId === reg.current) : void 0;
-}
-function activeBots(reg) {
-  const configured = reg.bots.some((b) => b.active !== void 0);
-  if (configured) return reg.bots.filter((b) => b.active === true);
-  const cur = currentBot(reg);
-  return cur ? [cur] : [];
-}
-async function setActiveBots(appIds) {
-  const reg = await loadBots();
-  const want = new Set(appIds);
-  for (const b of reg.bots) b.active = want.has(b.appId);
-  const firstActive = reg.bots.find((b) => b.active);
-  if (firstActive) reg.current = firstActive.appId;
-  await saveBots(reg);
-  return reg;
-}
-async function addBot(entry) {
-  const reg = await loadBots();
-  reg.bots = reg.bots.filter((b) => b.appId !== entry.appId);
-  reg.bots.push(entry);
-  if (!reg.current) reg.current = entry.appId;
-  await saveBots(reg);
-  return reg;
-}
-async function removeBot(appId) {
-  const reg = await loadBots();
-  reg.bots = reg.bots.filter((b) => b.appId !== appId);
-  if (reg.current === appId) reg.current = reg.bots[0]?.appId;
-  await saveBots(reg);
-  return reg;
 }
-function uniqueName(reg, desired) {
-  const base = slugify(desired) || "bot";
-  if (!reg.bots.some((b) => b.name === base)) return base;
-  for (let i = 2; ; i++) {
-    const candidate = `${base}-${i}`;
-    if (!reg.bots.some((b) => b.name === candidate)) return candidate;
+function shouldStartCliBridge(cfg) {
+  const prefs = getCliBridgePreferences(cfg);
+  return prefs.enabled && Boolean(resolveCliBridgeTarget(cfg));
+}
+var TASK_DONE_CLICKED, LOCAL_RETURN;
+var init_service = __esm({
+  "src/cli-bridge/service.ts"() {
+    "use strict";
+    init_schema();
+    init_logger();
+    init_managed();
+    init_ipc();
+    init_cards2();
+    init_parser();
+    init_store2();
+    init_presence();
+    init_keep_awake();
+    TASK_DONE_CLICKED = "task_done_clicked";
+    LOCAL_RETURN = "local_return";
+  }
+});
+
+// src/cli-bridge/index.ts
+var cli_bridge_exports = {};
+__export(cli_bridge_exports, {
+  createCliBridgeService: () => createCliBridgeService,
+  runHookCommand: () => runHookCommand,
+  selectCliBridgeHookBot: () => selectCliBridgeHookBot,
+  shouldStartCliBridge: () => shouldStartCliBridge
+});
+import { join as join19 } from "path";
+async function selectCliBridgeHookBot(reg, opts = {}) {
+  const requested = opts.requested?.trim();
+  if (requested) {
+    return findBot(reg, requested) ?? { name: requested, appId: requested, tenant: "feishu", createdAt: 0 };
+  }
+  const loadConfigForBot = opts.loadConfigForBot ?? ((appId) => loadConfig(join19(botDir(appId), "config.json")));
+  const current = currentBot(reg);
+  const active = activeBots(reg);
+  const candidates = active.length > 0 ? active : current ? [current] : reg.bots;
+  let firstEnabled;
+  for (const bot2 of candidates) {
+    const cfg = await loadConfigForBot(bot2.appId).catch(() => void 0);
+    if (!cfg || !isComplete(cfg) || !getCliBridgePreferences(cfg).enabled) continue;
+    if (bot2.appId === current?.appId) return bot2;
+    firstEnabled ??= bot2;
+  }
+  return firstEnabled ?? current ?? candidates[0];
+}
+async function runHookCommand(agent, bot2) {
+  if (agent !== "claude" && agent !== "codex") {
+    process.stderr.write(`Unsupported hook agent: ${agent}
+`);
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const selected = await selectCliBridgeHookBot(await loadBots(), { requested: bot2 });
+    if (selected) useBotDir(selected.appId);
+  } catch {
+    if (bot2?.trim()) useBotDir(bot2.trim());
+  }
+  const raw = await readStdin();
+  const msg = parseHookPayload(agent, raw);
+  if (msg.type === "post_tool_use") {
+    process.stdout.write("{}\n");
+    return;
+  }
+  let response;
+  try {
+    response = await sendCliHookMessage(paths.cliBridgeSocket, msg);
+  } catch {
+    response = { decision: "fallback_local", reason: "daemon_unavailable" };
+  }
+  const stdout = buildHookStdout(msg, response);
+  if (stdout) process.stdout.write(stdout + (stdout.endsWith("\n") ? "" : "\n"));
+}
+var init_cli_bridge = __esm({
+  "src/cli-bridge/index.ts"() {
+    "use strict";
+    init_paths();
+    init_bots();
+    init_store();
+    init_schema();
+    init_stdin();
+    init_ipc();
+    init_parser();
+    init_protocol();
+    init_service();
+  }
+});
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/core/version.ts
+import { readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+function bridgeVersion() {
+  try {
+    const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    return JSON.parse(readFileSync(pkgPath, "utf8")).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
   }
 }
-function slugify(s) {
-  return s.trim().toLowerCase().replace(/[^a-z0-9一-龥]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
-}
-function nowMs() {
-  return Date.now();
-}
-async function moveIfExists(src, dest) {
-  if (!existsSync(src)) return;
-  await rename2(src, dest);
-}
+
+// src/cli/commands/doctor.ts
+init_paths();
+init_bots();
+init_store();
+init_schema();
+import { existsSync as existsSync5 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join9 } from "path";
 
 // src/config/secret-resolver.ts
 import { readFile as readFile4 } from "fs/promises";
@@ -351,6 +2106,7 @@ function mergeProcessEnv(base = process.env, overrides = {}) {
 }
 
 // src/config/keystore.ts
+init_paths();
 import { createCipheriv, createDecipheriv, pbkdf2Sync, randomBytes } from "crypto";
 import { chmod as chmod3, mkdir as mkdir3, readFile as readFile3, rename as rename3, writeFile as writeFile3 } from "fs/promises";
 import { hostname, userInfo } from "os";
@@ -445,6 +2201,8 @@ async function listSecretIds() {
 }
 
 // src/config/secret-resolver.ts
+init_paths();
+init_schema();
 var ENV_TEMPLATE_RE = /^\$\{([A-Z][A-Z0-9_]{0,127})\}$/;
 var DEFAULT_PROVIDER = "default";
 var DEFAULT_EXEC_TIMEOUT_MS = 5e3;
@@ -521,7 +2279,7 @@ async function spawnExecProvider(pc, ref) {
   const timeoutMs = pc.noOutputTimeoutMs ?? DEFAULT_EXEC_TIMEOUT_MS;
   const maxOutput = pc.maxOutputBytes ?? DEFAULT_EXEC_MAX_OUTPUT;
   const providerName = ref.provider ?? DEFAULT_PROVIDER;
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const env = {};
     if (pc.passEnv) for (const k2 of pc.passEnv) {
       const v = process.env[k2];
@@ -532,10 +2290,10 @@ async function spawnExecProvider(pc, ref) {
       env,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    let stdout = "", stderr = "", truncated = false, settled = false;
+    let stdout = "", stderr = "", truncated = false, settled2 = false;
     const timer = setTimeout(() => {
-      if (settled) return;
-      settled = true;
+      if (settled2) return;
+      settled2 = true;
       child.kill("SIGKILL");
       reject(new Error(`exec provider timed out after ${timeoutMs}ms`));
     }, timeoutMs);
@@ -552,14 +2310,14 @@ async function spawnExecProvider(pc, ref) {
       stderr += chunk.toString("utf8");
     });
     child.on("error", (err) => {
-      if (settled) return;
-      settled = true;
+      if (settled2) return;
+      settled2 = true;
       clearTimeout(timer);
       reject(new Error(`exec provider failed to start: ${err.message}`));
     });
     child.on("close", (code) => {
-      if (settled) return;
-      settled = true;
+      if (settled2) return;
+      settled2 = true;
       clearTimeout(timer);
       if (truncated) return reject(new Error(`exec provider stdout exceeded ${maxOutput} bytes`));
       if (code !== 0) {
@@ -569,7 +2327,7 @@ async function spawnExecProvider(pc, ref) {
       try {
         const parsed = JSON.parse(stdout);
         const value = parsed.values?.[ref.id];
-        if (typeof value === "string") return resolve8(value);
+        if (typeof value === "string") return resolve9(value);
         const err = parsed.errors?.[ref.id]?.message;
         reject(new Error(`exec provider did not return secret for ${ref.id}${err ? `: ${err}` : ""}`));
       } catch (err) {
@@ -822,243 +2580,32 @@ var BACKEND_CATALOG = [
       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() {
-  return BACKEND_CATALOG.filter((e) => !e.hidden);
-}
-function catalogById(id) {
-  return BACKEND_CATALOG.find((e) => e.id === id);
-}
-function catalogBackendIds() {
-  return BACKEND_CATALOG.map((e) => e.id);
-}
-function projectCreatableBackends(mode, isInstalled2) {
-  return BACKEND_CATALOG.filter((e) => {
-    if (e.hidden) return false;
-    const installed = e.id === DEFAULT_BACKEND_ID || isInstalled2(e);
-    if (!installed) return false;
-    if (e.supportedModes && !e.supportedModes.includes(mode)) return false;
-    return true;
-  });
-}
-
-// src/core/logger.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { createWriteStream, mkdirSync } from "fs";
-import { open, readdir, rm, stat } from "fs/promises";
-import { tmpdir } from "os";
-import { join as join4 } from "path";
-var LOG_RETENTION_DAYS = Math.max(
-  1,
-  Number(process.env.FEISHU_CODEX_LOG_DAYS ?? 7) || 7
-);
-var STDOUT_INFO_ALLOWLIST = /* @__PURE__ */ new Set([
-  "ws.connected",
-  "ws.reconnecting",
-  "ws.reconnected",
-  "intake.enter",
-  "intake.recv",
-  "intake.reject",
-  "card.final",
-  "card.config",
-  "card.action",
-  "card.launch",
-  "agent.spawn",
-  "agent.exit",
-  // 自愈链路（kill -9 / 崩溃恢复）的关键节点——低频高信号，进终端便于 e2e 直读：
-  // 驱逐（轮间死 / 轮中死）与恢复来源（store resume / 重建 / 全新会话）。
-  "agent.dead-thread-evict",
-  "agent.session-evict",
-  "agent.resume-ok",
-  "agent.resume-recreate",
-  "agent.session-fresh"
-]);
-var als = new AsyncLocalStorage();
-var stream = null;
-var currentDate = "";
-function todayKey() {
-  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-}
-function inTestEnv() {
-  return Boolean(process.env.VITEST) || process.env.NODE_ENV === "test";
-}
-var TEST_LOGS_DIR = join4(tmpdir(), "feishu-codex-bridge-test-logs");
-function logsDir() {
-  return inTestEnv() ? TEST_LOGS_DIR : join4(paths.appDir, "logs");
-}
-function getStream() {
-  const today = todayKey();
-  if (stream && currentDate === today) return stream;
-  if (stream) {
-    try {
-      stream.end();
-    } catch {
-    }
-  }
-  try {
-    mkdirSync(logsDir(), { recursive: true });
-    stream = createWriteStream(join4(logsDir(), `${today}.log`), { flags: "a" });
-    currentDate = today;
-    return stream;
-  } catch {
-    return null;
-  }
-}
-var RESERVED_KEYS = /* @__PURE__ */ new Set([
-  "ts",
-  "level",
-  "phase",
-  "event",
-  "traceId",
-  "chatId",
-  "msgId"
-]);
-function emit(level, phase, event, fields = {}) {
-  const ctx = als.getStore() ?? {};
-  const entry = {
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    level,
-    phase,
-    event,
-    ...ctx
-  };
-  for (const [k2, v] of Object.entries(fields)) {
-    if (RESERVED_KEYS.has(k2)) {
-      entry[`_${k2}`] = v;
-    } else {
-      entry[k2] = v;
-    }
-  }
-  const s = getStream();
-  if (s) {
-    try {
-      s.write(`${JSON.stringify(entry)}
-`);
-    } catch {
-    }
-  }
-  const showOnStdout = level !== "info" || STDOUT_INFO_ALLOWLIST.has(`${phase}.${event}`);
-  if (!showOnStdout) return;
-  const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
-  fn(formatStdout(level, phase, event, ctx, fields));
-}
-function formatStdout(level, phase, event, ctx, fields) {
-  if (phase === "ws") {
-    if (event === "connected") {
-      const bot2 = fields.bot ?? "-";
-      const appId = fields.appId ? ` (${fields.appId})` : "";
-      return `\u2713 \u5DF2\u8FDE\u63A5  bot: ${bot2}${appId}`;
-    }
-    if (event === "reconnecting") return "\u21BB \u6B63\u5728\u91CD\u8FDE\u2026";
-    if (event === "reconnected") return "\u2713 \u5DF2\u91CD\u8FDE";
-    if (event === "fail") return `\u2717 WS \u9519\u8BEF: ${fields.err ?? ""}`;
-  }
-  if (phase === "intake" && event === "enter") {
-    const c = ctx.chatId ? ctx.chatId.slice(-6) : "-";
-    const sender = fields.sender ?? "-";
-    const preview = fields.preview ?? "";
-    return `\u25B8 ${fields.chatType ?? "?"}/${c} ${sender}: ${preview}`;
-  }
-  if (phase === "card" && event === "final") {
-    const c = ctx.chatId ? ctx.chatId.slice(-6) : "-";
-    const t = fields.terminal;
-    const mark = t === "done" ? "\u2713" : t === "interrupted" ? "\u23F9" : "\u2717";
-    return `  ${mark} ${c} ${t}`;
-  }
-  const ctxBits = [];
-  if (ctx.traceId) ctxBits.push(`t=${ctx.traceId}`);
-  if (ctx.chatId) ctxBits.push(`c=${ctx.chatId.slice(-6)}`);
-  const ctxStr = ctxBits.length > 0 ? ` ${ctxBits.join(" ")}` : "";
-  const summary = formatFields(fields);
-  const tag = level === "error" ? "\u2717" : level === "warn" ? "\u26A0" : "\xB7";
-  return `${tag} [${phase}.${event}]${ctxStr}${summary ? ` ${summary}` : ""}`;
-}
-function formatFields(fields) {
-  const keys = Object.keys(fields);
-  if (keys.length === 0) return "";
-  const parts = [];
-  for (const k2 of keys) {
-    const v = fields[k2];
-    if (v === void 0 || v === null) continue;
-    if (k2 === "stack") continue;
-    if (typeof v === "string") {
-      parts.push(`${k2}=${v.length > 80 ? `${v.slice(0, 80)}\u2026` : v}`);
-    } else if (typeof v === "number" || typeof v === "boolean") {
-      parts.push(`${k2}=${v}`);
-    } else {
-      try {
-        const str = JSON.stringify(v);
-        parts.push(`${k2}=${str.length > 80 ? `${str.slice(0, 80)}\u2026` : str}`);
-      } catch {
-        parts.push(`${k2}=?`);
-      }
-    }
-  }
-  return parts.join(" ");
-}
-var log = {
-  info(phase, event, fields) {
-    emit("info", phase, event, fields);
-  },
-  warn(phase, event, fields) {
-    emit("warn", phase, event, fields);
-  },
-  fail(phase, err, fields) {
-    const message = err instanceof Error ? err.message : String(err);
-    const stack = err instanceof Error ? err.stack : void 0;
-    const apiData = err?.response?.data;
-    const apiStatus = err?.response?.status;
-    emit("error", phase, "fail", {
-      ...fields,
-      err: message,
-      apiStatus,
-      apiData,
-      stack
-    });
-  }
-};
-function withTrace(ctx, fn) {
-  const traceId = ctx.traceId ?? newTraceId();
-  return als.run({ ...ctx, traceId }, fn);
+    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() {
+  return BACKEND_CATALOG.filter((e) => !e.hidden);
 }
-function newTraceId() {
-  return Math.random().toString(36).slice(2, 10);
+function catalogById(id) {
+  return BACKEND_CATALOG.find((e) => e.id === id);
 }
-async function readRecentLogs(opts) {
-  const today = todayKey();
-  const yesterday = new Date(Date.now() - 864e5).toISOString().slice(0, 10);
-  const tail = await readTail(join4(logsDir(), `${today}.log`), opts.maxBytes);
-  if (tail.length >= opts.maxBytes / 2) return tail;
-  const remaining = opts.maxBytes - Buffer.byteLength(tail, "utf8");
-  const earlier = await readTail(join4(logsDir(), `${yesterday}.log`), remaining);
-  return earlier + tail;
+function catalogBackendIds() {
+  return BACKEND_CATALOG.map((e) => e.id);
 }
-async function readTail(path, maxBytes) {
-  try {
-    const st = await stat(path);
-    const start = Math.max(0, st.size - maxBytes);
-    const handle = await open(path, "r");
-    try {
-      const buf = Buffer.alloc(st.size - start);
-      await handle.read(buf, 0, buf.length, start);
-      let content = buf.toString("utf8");
-      if (start > 0) {
-        const nl = content.indexOf("\n");
-        if (nl !== -1) content = content.slice(nl + 1);
-      }
-      return content;
-    } finally {
-      await handle.close();
-    }
-  } catch (err) {
-    if (err.code === "ENOENT") return "";
-    throw err;
-  }
+function projectCreatableBackends(mode, isInstalled2) {
+  return BACKEND_CATALOG.filter((e) => {
+    if (e.hidden) return false;
+    const installed = e.id === DEFAULT_BACKEND_ID || isInstalled2(e);
+    if (!installed) return false;
+    if (e.supportedModes && !e.supportedModes.includes(mode)) return false;
+    return true;
+  });
 }
 
+// src/agent/codex-appserver/backend.ts
+init_logger();
+
 // src/agent/bridge-instructions.ts
 var BRIDGE_DEVELOPER_INSTRUCTIONS = [
   "\u4F60\u73B0\u5728\u901A\u8FC7\u300C\u98DE\u4E66\u6865\u300D\u4E0E\u7528\u6237\u5BF9\u8BDD\uFF1A\u4F60\u7684\u56DE\u590D\u4F1A\u88AB\u6E32\u67D3\u6210\u98DE\u4E66\u6D88\u606F\u3002\u8BF7\u9075\u5B88\u4E24\u6761\u8F93\u51FA\u7EA6\u5B9A\u3002",
@@ -1076,6 +2623,7 @@ var BRIDGE_DEVELOPER_INSTRUCTIONS = [
 ].join("\n");
 
 // src/agent/codex-appserver/app-server-client.ts
+init_logger();
 var AsyncQueue = class {
   items = [];
   waiters = [];
@@ -1100,7 +2648,7 @@ var AsyncQueue = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve8) => this.waiters.push(resolve8));
+      const next = await new Promise((resolve9) => this.waiters.push(resolve9));
       if (next.done) return;
       yield next.value;
     }
@@ -1171,8 +2719,8 @@ var AppServerClient = class {
     const id = ++this.nextId;
     const payload = `${JSON.stringify({ jsonrpc: "2.0", id, method, params: params ?? {} })}
 `;
-    return new Promise((resolve8, reject) => {
-      this.pending.set(id, { resolve: resolve8, reject });
+    return new Promise((resolve9, reject) => {
+      this.pending.set(id, { resolve: resolve9, reject });
       this.child.stdin.write(payload, (err) => {
         if (err) {
           this.pending.delete(id);
@@ -1203,13 +2751,13 @@ var AppServerClient = class {
     const child = this.child;
     if (!child || child.exitCode !== null) return;
     if (process.platform === "win32" && child.pid) {
-      await new Promise((resolve8) => {
-        let settled = false;
+      await new Promise((resolve9) => {
+        let settled2 = false;
         const done = () => {
-          if (settled) return;
-          settled = true;
+          if (settled2) return;
+          settled2 = true;
           clearTimeout(t);
-          resolve8();
+          resolve9();
         };
         const t = setTimeout(done, graceMs);
         child.once("exit", done);
@@ -1224,14 +2772,14 @@ var AppServerClient = class {
       return;
     }
     child.kill("SIGTERM");
-    await new Promise((resolve8) => {
+    await new Promise((resolve9) => {
       const t = setTimeout(() => {
         if (child.exitCode === null) child.kill("SIGKILL");
-        resolve8();
+        resolve9();
       }, graceMs);
       child.once("exit", () => {
         clearTimeout(t);
-        resolve8();
+        resolve9();
       });
     });
   }
@@ -1283,10 +2831,12 @@ var AppServerClient = class {
 };
 
 // src/agent/codex-appserver/client-pool.ts
+init_logger();
 import { statSync } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 
 // src/agent/codex-appserver/locate.ts
+init_paths();
 import { existsSync as existsSync2 } from "fs";
 import { extname, join as join5 } from "path";
 var IS_WIN = process.platform === "win32";
@@ -1333,12 +2883,12 @@ async function codexVersionAsync(bin, opts) {
     const hit = versionCache.get(bin);
     if (hit !== void 0) return hit;
   }
-  const out = await new Promise((resolve8) => {
+  const out = await new Promise((resolve9) => {
     let child;
     try {
       child = spawnProcess(bin, ["--version"], { stdio: ["ignore", "pipe", "ignore"] });
     } catch {
-      resolve8(null);
+      resolve9(null);
       return;
     }
     let stdout = "";
@@ -1346,8 +2896,8 @@ async function codexVersionAsync(bin, opts) {
     child.stdout?.on("data", (d) => {
       stdout += d;
     });
-    child.on("error", () => resolve8(null));
-    child.on("close", (code) => resolve8(code === 0 ? stdout.trim() : null));
+    child.on("error", () => resolve9(null));
+    child.on("close", (code) => resolve9(code === 0 ? stdout.trim() : null));
   });
   if (out !== null) versionCache.set(bin, out);
   return out;
@@ -1359,12 +2909,12 @@ var CONNECT_TIMEOUT_MS = 15e3;
 var PREWARM_TIMEOUT_MS = 6e4;
 var DEFAULT_UTILITY_TIMEOUT_MS = 3e4;
 function withDeadline(p, ms, label) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const t = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
     p.then(
       (v) => {
         clearTimeout(t);
-        resolve8(v);
+        resolve9(v);
       },
       (e) => {
         clearTimeout(t);
@@ -1616,8 +3166,8 @@ function countChange(c) {
 }
 function displayPath(p, cwd) {
   if (cwd) {
-    const sep2 = cwd.includes("\\") ? "\\" : "/";
-    const root = cwd.endsWith(sep2) ? cwd : cwd + sep2;
+    const sep3 = cwd.includes("\\") ? "\\" : "/";
+    const root = cwd.endsWith(sep3) ? cwd : cwd + sep3;
     return p.startsWith(root) && p.length > root.length ? p.slice(root.length) : p;
   }
   if (p.length <= PATH_TAIL_MAX || !p.includes("/")) return p;
@@ -1735,11 +3285,11 @@ var CodexThread = class {
     if (self.model) params.model = self.model;
     if (self.effort) params.effort = self.effort;
     let startError;
-    const startFailed = new Promise((resolve8) => {
+    const startFailed = new Promise((resolve9) => {
       self.client.request("turn/start", params).then(void 0, (err) => {
         startError = err instanceof Error ? err : new Error(String(err));
         log.fail("agent", startError, { phase: "turn/start" });
-        resolve8("start-failed");
+        resolve9("start-failed");
       });
     });
     async function* gen() {
@@ -1769,11 +3319,11 @@ var CodexThread = class {
     async function* gen() {
       await self.client.request("thread/goal/clear", { threadId: self.sessionId }).catch(() => void 0);
       let setError;
-      const setFailed = new Promise((resolve8) => {
+      const setFailed = new Promise((resolve9) => {
         self.client.request("thread/goal/set", { threadId: self.sessionId, objective }).then(void 0, (err) => {
           setError = err instanceof Error ? err : new Error(String(err));
           log.fail("agent", setError, { phase: "thread/goal/set" });
-          resolve8("set-failed");
+          resolve9("set-failed");
         });
       });
       const stream2 = self.client.stream()[Symbol.asyncIterator]();
@@ -1834,16 +3384,16 @@ var CodexThread = class {
   }
   async compact() {
     let startError;
-    const startFailed = new Promise((resolve8) => {
+    const startFailed = new Promise((resolve9) => {
       this.client.request("thread/compact/start", { threadId: this.sessionId }).then(void 0, (err) => {
         startError = err instanceof Error ? err : new Error(String(err));
         log.fail("agent", startError, { phase: "thread/compact/start" });
-        resolve8("start-failed");
+        resolve9("start-failed");
       });
     });
     let timer;
-    const timeout = new Promise((resolve8) => {
-      timer = setTimeout(() => resolve8("timeout"), COMPACT_TIMEOUT_MS);
+    const timeout = new Promise((resolve9) => {
+      timer = setTimeout(() => resolve9("timeout"), COMPACT_TIMEOUT_MS);
     });
     const stream2 = this.client.stream()[Symbol.asyncIterator]();
     let compacted = false;
@@ -2074,9 +3624,11 @@ var STATIC_MODELS = [
 ];
 
 // src/agent/claude-agent/backend.ts
+init_logger();
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/agent/backend-loader.ts
+init_paths();
 import { createRequire } from "module";
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { join as join6 } from "path";
@@ -2374,8 +3926,8 @@ 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;
+    const sep3 = cwd.includes("\\") ? "\\" : "/";
+    const root = cwd.endsWith(sep3) ? cwd : cwd + sep3;
     if (p.startsWith(root) && p.length > root.length) return p.slice(root.length);
   }
   if (p.length <= PATH_TAIL_MAX2 || !p.includes("/")) return p;
@@ -2512,6 +4064,7 @@ ${b.thinking}` : b.thinking;
 }
 
 // src/agent/claude-agent/thread.ts
+init_logger();
 var COMPACT_TIMEOUT_MS2 = 12e4;
 var ABORT_ESCALATE_MS = 4e3;
 var Inbox = class {
@@ -2525,7 +4078,7 @@ var Inbox = class {
   next() {
     const v = this.buf.shift();
     if (v !== void 0) return Promise.resolve(v);
-    return new Promise((resolve8) => this.waiters.push(resolve8));
+    return new Promise((resolve9) => this.waiters.push(resolve9));
   }
 };
 var PushablePrompt = class {
@@ -2550,7 +4103,7 @@ var PushablePrompt = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve8) => this.waiters.push(resolve8));
+      const next = await new Promise((resolve9) => this.waiters.push(resolve9));
       if (next == null) return;
       yield next;
     }
@@ -2824,8 +4377,8 @@ var ClaudeAgentThread = class {
     this.sink = mySink;
     this.interruptRequested = false;
     let timer;
-    const timeout = new Promise((resolve8) => {
-      timer = setTimeout(() => resolve8("timeout"), COMPACT_TIMEOUT_MS2);
+    const timeout = new Promise((resolve9) => {
+      timer = setTimeout(() => resolve9("timeout"), COMPACT_TIMEOUT_MS2);
     });
     let compacted = false;
     try {
@@ -3074,8 +4627,12 @@ async function effectiveDefaultBackend(opts) {
 import { mkdir as mkdir4, rm as rm2, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import { join as join8 } from "path";
+init_paths();
+init_logger();
 
 // src/agent/native-helpers.ts
+init_paths();
+init_logger();
 import { chmod as chmod4, readdir as readdir2 } from "fs/promises";
 import { join as join7 } from "path";
 async function fixNativeHelperPerms(rootDir = paths.backendsDir) {
@@ -3106,14 +4663,14 @@ async function fixNativeHelperPerms(rootDir = paths.backendsDir) {
 var NPM = "npm";
 async function latestNpmVersion(pkg, timeoutMs = 8e3) {
   const bare = stripVersion(pkg);
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     let child;
     try {
       child = spawnProcess(NPM, ["view", bare, "version", "--no-fund", "--no-audit"], {
         stdio: ["ignore", "pipe", "ignore"]
       });
     } catch {
-      resolve8(null);
+      resolve9(null);
       return;
     }
     let out = "";
@@ -3122,7 +4679,7 @@ async function latestNpmVersion(pkg, timeoutMs = 8e3) {
         child.kill("SIGTERM");
       } catch {
       }
-      resolve8(null);
+      resolve9(null);
     }, timeoutMs);
     child.stdout?.setEncoding("utf8");
     child.stdout?.on("data", (d) => {
@@ -3130,12 +4687,12 @@ async function latestNpmVersion(pkg, timeoutMs = 8e3) {
     });
     child.on("error", () => {
       clearTimeout(timer);
-      resolve8(null);
+      resolve9(null);
     });
     child.on("close", (code) => {
       clearTimeout(timer);
       const v = out.trim().split("\n").pop()?.trim() ?? "";
-      resolve8(code === 0 && /^\d+\.\d+\.\d+/.test(v) ? v : null);
+      resolve9(code === 0 && /^\d+\.\d+\.\d+/.test(v) ? v : null);
     });
   });
 }
@@ -3185,13 +4742,13 @@ async function installBackendDep(pkg, onProgress, signal, opts) {
   }
   const { command, args } = buildInstallCommand(pkg);
   log.info("agent", "backend-install-start", { pkg });
-  const result = await new Promise((resolve8) => {
+  const result = await new Promise((resolve9) => {
     let child;
     try {
       child = spawnProcess(command, args, { stdio: ["ignore", "pipe", "pipe"] });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      resolve8({ ok: false, code: null, aborted: false, tail: `spawn npm \u5931\u8D25\uFF1A${msg}` });
+      resolve9({ ok: false, code: null, aborted: false, tail: `spawn npm \u5931\u8D25\uFF1A${msg}` });
       return;
     }
     let out = "";
@@ -3214,11 +4771,11 @@ async function installBackendDep(pkg, onProgress, signal, opts) {
     }
     child.on("error", (e) => {
       if (signal) signal.removeEventListener("abort", onAbort);
-      resolve8({ ok: false, code: null, aborted, tail: (out + e.message).slice(-2e3) });
+      resolve9({ ok: false, code: null, aborted, tail: (out + e.message).slice(-2e3) });
     });
     child.on("close", (code) => {
       if (signal) signal.removeEventListener("abort", onAbort);
-      resolve8({ ok: code === 0 && !aborted, code, aborted, tail: out.slice(-2e3) });
+      resolve9({ ok: code === 0 && !aborted, code, aborted, tail: out.slice(-2e3) });
     });
   });
   if (!result.ok) {
@@ -3373,7 +4930,9 @@ function tryExec(cmd, args) {
 }
 
 // src/bot/onboarding.ts
+init_store();
 import { createInterface } from "readline/promises";
+init_schema();
 
 // src/bot/wizard.ts
 import { registerApp } from "@larksuiteoapi/node-sdk";
@@ -3532,6 +5091,9 @@ function openUrl(url) {
 }
 
 // src/bot/onboarding.ts
+init_logger();
+init_paths();
+init_bots();
 async function ensureAnyAgent() {
   const agents = await detectAgents().catch(() => []);
   const anyAvailable = agents.some((a) => a.backends.some((b) => b.available));
@@ -3741,9 +5303,15 @@ async function announceEventsWhenLive(result) {
 }
 
 // src/bot/bridge.ts
+init_logger();
 import { createLarkChannel, Domain } from "@larksuiteoapi/node-sdk";
+import { sep as sep2 } from "path";
+
+// src/card/dm-cards.ts
+init_schema();
 
 // src/project/registry.ts
+init_paths();
 import { mkdir as mkdir5, readFile as readFile6, rename as rename4, writeFile as writeFile5 } from "fs/promises";
 import { randomUUID as randomUUID3 } from "crypto";
 import { dirname as dirname5 } from "path";
@@ -3805,232 +5373,49 @@ async function getProjectByChatId(chatId) {
 async function getProjectByName(name) {
   return (await read()).find((p) => p.name === name);
 }
-async function addProject(p) {
-  return withLock(async () => {
-    const projects = await read();
-    if (projects.some((x) => x.name === p.name)) {
-      throw new Error(`\u9879\u76EE\u540D\u300C${p.name}\u300D\u5DF2\u5B58\u5728`);
-    }
-    if (p.chatId) {
-      const bound = projects.find((x) => x.chatId === p.chatId);
-      if (bound) throw new Error(`\u8BE5\u7FA4\u5DF2\u7ED1\u5B9A\u4E3A\u9879\u76EE\u300C${bound.name}\u300D`);
-    }
-    projects.push(p);
-    await write(projects);
-  });
-}
-async function updateProject(name, patch) {
-  return withLock(async () => {
-    const projects = await read();
-    const p = projects.find((x) => x.name === name);
-    if (!p) return;
-    const actual = typeof patch === "function" ? patch(p) : patch;
-    const target = p;
-    for (const [k2, v] of Object.entries(actual)) {
-      if (v !== void 0) target[k2] = v;
-    }
-    await write(projects);
-  });
-}
-async function removeProject(name) {
-  return withLock(async () => {
-    const projects = await read();
-    const idx = projects.findIndex((p) => p.name === name);
-    if (idx === -1) return void 0;
-    const [removed] = projects.splice(idx, 1);
-    await write(projects);
-    return removed;
-  });
-}
-
-// src/card/cards.ts
-function card(elements, opts = {}) {
-  const config = { update_multi: true };
-  if (opts.forward === false) config.enable_forward = false;
-  if (opts.streaming) {
-    config.streaming_mode = true;
-    config.streaming_config = {
-      print_frequency_ms: { default: 25 },
-      print_step: { default: 6 },
-      print_strategy: "fast"
-    };
-  }
-  if (opts.summary) config.summary = { content: opts.summary };
-  const obj = {
-    schema: "2.0",
-    config,
-    body: { elements }
-  };
-  if (opts.header) {
-    obj.header = {
-      template: opts.header.template ?? "blue",
-      title: { tag: "plain_text", content: opts.header.title },
-      ...opts.header.subtitle ? { subtitle: { tag: "plain_text", content: opts.header.subtitle } } : {},
-      ...opts.header.textTags?.length ? {
-        text_tag_list: opts.header.textTags.map((t) => ({
-          tag: "text_tag",
-          text: { tag: "plain_text", content: t.text },
-          color: t.color
-        }))
-      } : {}
-    };
-  }
-  return obj;
-}
-function md(content) {
-  return { tag: "markdown", content };
-}
-function mdStream(content, elementId) {
-  return { tag: "markdown", element_id: elementId, content };
-}
-function image(imgKey, alt = "") {
-  return {
-    tag: "img",
-    img_key: imgKey,
-    alt: { tag: "plain_text", content: alt },
-    mode: "fit_horizontal",
-    preview: true
-  };
-}
-function note(content) {
-  return { tag: "div", text: { tag: "lark_md", content, text_size: "notation", text_color: "grey" } };
-}
-function colorNote(content, color) {
-  return { tag: "div", text: { tag: "lark_md", content, text_size: "notation", text_color: color } };
-}
-function hr() {
-  return { tag: "hr" };
-}
-function noteMd(content) {
-  return { tag: "markdown", content, text_size: "notation" };
-}
-function collapsiblePanel(opts) {
-  return {
-    tag: "collapsible_panel",
-    expanded: opts.expanded,
-    header: {
-      title: { tag: "markdown", content: opts.title },
-      vertical_align: "center",
-      icon: { tag: "standard_icon", token: "down-small-ccm_outlined", size: "16px 16px" },
-      icon_position: "follow_text",
-      icon_expanded_angle: -180
-    },
-    border: { color: opts.border, corner_radius: "5px" },
-    vertical_spacing: "8px",
-    padding: "8px 8px 8px 8px",
-    elements: [{ tag: "markdown", content: opts.body, text_size: "notation" }]
-  };
-}
-function collapsiblePanelEl(opts) {
-  return {
-    tag: "collapsible_panel",
-    expanded: opts.expanded,
-    header: {
-      title: { tag: "markdown", content: opts.title },
-      vertical_align: "center",
-      icon: { tag: "standard_icon", token: "down-small-ccm_outlined", size: "16px 16px" },
-      icon_position: "follow_text",
-      icon_expanded_angle: -180
-    },
-    border: { color: opts.border, corner_radius: "5px" },
-    vertical_spacing: "8px",
-    padding: "8px 8px 8px 8px",
-    elements: opts.elements
-  };
-}
-function actions(items, elementId) {
-  return {
-    tag: "column_set",
-    ...elementId ? { element_id: elementId } : {},
-    flex_mode: "flow",
-    horizontal_spacing: "small",
-    columns: items.map((it) => ({ tag: "column", width: "auto", elements: [it] }))
-  };
-}
-function actionsFixed(items, width, elementId) {
-  return {
-    tag: "column_set",
-    ...elementId ? { element_id: elementId } : {},
-    flex_mode: "flow",
-    horizontal_spacing: "8px",
-    columns: items.map((it) => ({ tag: "column", width: "auto", elements: [{ ...it, width, size: "large" }] }))
-  };
-}
-function splitRow(left, right, elementId) {
-  return {
-    tag: "column_set",
-    ...elementId ? { element_id: elementId } : {},
-    flex_mode: "none",
-    horizontal_spacing: "medium",
-    columns: [
-      { tag: "column", width: "auto", vertical_align: "center", elements: [left] },
-      { tag: "column", width: "weighted", weight: 1, vertical_align: "center", elements: [right] }
-    ]
-  };
-}
-function button(label, value, type = "default") {
-  return {
-    tag: "button",
-    text: { tag: "plain_text", content: label },
-    type,
-    behaviors: [{ type: "callback", value }]
-  };
-}
-function linkButton(label, url, type = "default", size) {
-  return {
-    tag: "button",
-    text: { tag: "plain_text", content: label },
-    type,
-    ...size ? { size } : {},
-    behaviors: [{ type: "open_url", default_url: url }]
-  };
-}
-function input(opts) {
-  return {
-    tag: "input",
-    name: opts.name,
-    ...opts.label ? { label: { tag: "plain_text", content: opts.label } } : {},
-    ...opts.placeholder ? { placeholder: { tag: "plain_text", content: opts.placeholder } } : {},
-    ...opts.value ? { default_value: opts.value } : {},
-    required: Boolean(opts.required)
-  };
-}
-function form(name, elements) {
-  return { tag: "form", name, elements };
-}
-function submitButton(label, value, type = "primary", name = "submit") {
-  return {
-    tag: "button",
-    name,
-    text: { tag: "plain_text", content: label },
-    type,
-    form_action_type: "submit",
-    behaviors: [{ type: "callback", value }]
-  };
-}
-function selectStatic(opts) {
-  return {
-    tag: "select_static",
-    placeholder: { tag: "plain_text", content: opts.placeholder },
-    ...opts.initial ? { initial_option: opts.initial } : {},
-    options: opts.options.map((o) => ({
-      text: { tag: "plain_text", content: o.label },
-      value: o.value
-    })),
-    behaviors: [{ type: "callback", value: { a: opts.actionId } }]
-  };
+async function addProject(p) {
+  return withLock(async () => {
+    const projects = await read();
+    if (projects.some((x) => x.name === p.name)) {
+      throw new Error(`\u9879\u76EE\u540D\u300C${p.name}\u300D\u5DF2\u5B58\u5728`);
+    }
+    if (p.chatId) {
+      const bound = projects.find((x) => x.chatId === p.chatId);
+      if (bound) throw new Error(`\u8BE5\u7FA4\u5DF2\u7ED1\u5B9A\u4E3A\u9879\u76EE\u300C${bound.name}\u300D`);
+    }
+    projects.push(p);
+    await write(projects);
+  });
 }
-function selectMenu(opts) {
-  return {
-    tag: "select_static",
-    name: opts.name,
-    placeholder: { tag: "plain_text", content: opts.placeholder },
-    ...opts.initial ? { initial_option: opts.initial } : {},
-    options: opts.options.map((o) => ({ text: { tag: "plain_text", content: o.label }, value: o.value }))
-  };
+async function updateProject(name, patch) {
+  return withLock(async () => {
+    const projects = await read();
+    const p = projects.find((x) => x.name === name);
+    if (!p) return;
+    const actual = typeof patch === "function" ? patch(p) : patch;
+    const target = p;
+    for (const [k2, v] of Object.entries(actual)) {
+      if (v !== void 0) target[k2] = v;
+    }
+    await write(projects);
+  });
+}
+async function removeProject(name) {
+  return withLock(async () => {
+    const projects = await read();
+    const idx = projects.findIndex((p) => p.name === name);
+    if (idx === -1) return void 0;
+    const [removed] = projects.splice(idx, 1);
+    await write(projects);
+    return removed;
+  });
 }
 
+// src/card/dm-cards.ts
+init_cards();
+
 // src/card/command-cards.ts
+init_cards();
 var MC = {
   model: "model.set",
   effort: "model.effort"
@@ -4746,7 +6131,7 @@ function settingItem(name, desc, actionId, current, opts) {
     actions(opts.map((o) => button(o.label, { a: actionId, v: o.value }, o.value === current ? "primary" : "default")))
   ];
 }
-function buildSettingsCard(cfg) {
+function buildSettingsCard(cfg, localAgents = []) {
   const watchdogSec = cfg.preferences?.runIdleTimeoutSeconds ?? 120;
   return card(
     [
@@ -4804,6 +6189,7 @@ function buildSettingsCard(cfg) {
           { label: "20", value: "20" }
         ]
       ),
+      ...localAgents,
       hr(),
       actions([button("\u{1F46E} \u7BA1\u7406\u5458", { a: DM.admins }), button("\u2B05\uFE0F \u83DC\u5355", { a: DM.menu })])
     ],
@@ -5089,8 +6475,8 @@ async function probeBackends(backends, timeoutMs = BACKEND_PROBE_TIMEOUT_MS) {
   return Promise.all(
     backends.map(async (be) => {
       let timer;
-      const timeout = new Promise((resolve8) => {
-        timer = setTimeout(() => resolve8(void 0), timeoutMs);
+      const timeout = new Promise((resolve9) => {
+        timer = setTimeout(() => resolve9(void 0), timeoutMs);
       });
       const probe = await Promise.race([be.doctor({ force: true }).catch(() => void 0), timeout]).finally(
         () => clearTimeout(timer)
@@ -5189,7 +6575,12 @@ async function runAdminWriteOp(op, deps) {
   }
 }
 
+// src/bot/handle-message.ts
+init_schema();
+init_store();
+
 // src/card/dispatcher.ts
+init_logger();
 var CardDispatcher = class {
   constructor(channel, cfg) {
     this.channel = channel;
@@ -5236,105 +6627,8 @@ var CardDispatcher = class {
   };
 };
 
-// src/card/managed.ts
-var byMessageId = /* @__PURE__ */ new Map();
-var renderToken = 0;
-function stampRenderToken(card2) {
-  const token = (++renderToken).toString(36);
-  const visit = (node) => {
-    if (Array.isArray(node)) {
-      node.forEach(visit);
-      return;
-    }
-    if (!node || typeof node !== "object") return;
-    const obj = node;
-    const behaviors = obj.behaviors;
-    if (Array.isArray(behaviors)) {
-      for (const b of behaviors) {
-        if (b && typeof b === "object" && b.type === "callback") {
-          const v = b.value;
-          if (v && typeof v === "object") v.__r = token;
-        }
-      }
-    }
-    for (const k2 of Object.keys(obj)) visit(obj[k2]);
-  };
-  visit(card2);
-}
-function isCardIdNotReady(err) {
-  const data = err?.response?.data;
-  return data?.code === 230099 || /11310|cardid is invalid/i.test(data?.msg ?? "");
-}
-async function sendManagedCard(channel, to, card2, replyTo, replyInThread = false, receiveIdType = "chat_id") {
-  stampRenderToken(card2);
-  const data = JSON.stringify(card2);
-  const attempt = async () => {
-    const created = await channel.rawClient.cardkit.v1.card.create({ data: { type: "card_json", data } });
-    const cardId = created.data?.card_id;
-    if (!cardId) {
-      throw new Error(`cardkit.card.create returned no card_id: ${JSON.stringify(created).slice(0, 200)}`);
-    }
-    const content = JSON.stringify({ type: "card", data: { card_id: cardId } });
-    let messageId;
-    if (replyTo) {
-      const sent = await channel.rawClient.im.v1.message.reply({
-        path: { message_id: replyTo },
-        data: { msg_type: "interactive", content, reply_in_thread: replyInThread }
-      });
-      messageId = sent.data?.message_id;
-    } else {
-      const sent = await channel.rawClient.im.v1.message.create({
-        params: { receive_id_type: receiveIdType },
-        data: { receive_id: to, msg_type: "interactive", content }
-      });
-      messageId = sent.data?.message_id;
-    }
-    if (!messageId) {
-      throw new Error("send card-by-reference returned no message_id");
-    }
-    byMessageId.set(messageId, { cardId, sequence: 0 });
-    return { messageId, cardId };
-  };
-  for (let i = 0; ; i++) {
-    try {
-      return await attempt();
-    } catch (err) {
-      if (i >= 2 || !isCardIdNotReady(err)) throw err;
-      log.fail("card", err, { phase: "managed-send", attempt: i, retry: true });
-      await new Promise((r) => setTimeout(r, 400 * (i + 1)));
-    }
-  }
-}
-async function updateManagedCard(channel, messageId, card2) {
-  const entry = byMessageId.get(messageId);
-  if (!entry) {
-    log.info("card", "managed-update-no-entry", { messageId, known: byMessageId.size });
-    return false;
-  }
-  stampRenderToken(card2);
-  const data = JSON.stringify(card2);
-  const push = async () => {
-    entry.sequence += 1;
-    await channel.rawClient.cardkit.v1.card.update({
-      path: { card_id: entry.cardId },
-      data: { card: { type: "card_json", data }, sequence: entry.sequence, uuid: `u_${entry.cardId}_${entry.sequence}` }
-    });
-  };
-  try {
-    await push();
-    return true;
-  } catch (err) {
-    log.fail("card", err, { phase: "managed-update", cardId: entry.cardId, seq: entry.sequence, retry: true });
-    await new Promise((r) => setTimeout(r, 3200));
-    try {
-      await push();
-      return true;
-    } catch (err2) {
-      log.fail("card", err2, { phase: "managed-update-retry", cardId: entry.cardId, seq: entry.sequence });
-      return false;
-    }
-  }
-}
+// src/bot/handle-message.ts
+init_managed();
 
 // src/card/run-state.ts
 var initialState = {
@@ -5515,6 +6809,7 @@ var RunRender = class {
 };
 
 // src/card/history-card.ts
+init_cards();
 var USER_MAX = 300;
 var ASSIST_MAX = 800;
 var REASON_MAX = 600;
@@ -5658,7 +6953,11 @@ function truncateTail(s, n) {
   return t.length > n ? `\u2026${t.slice(t.length - n)}` : t;
 }
 
+// src/card/run-card.ts
+init_cards();
+
 // src/card/markdown-render.ts
+init_cards();
 var NO_IMAGES = /* @__PURE__ */ new Map();
 var IMG_RE = /!\[([^\]]*)\]\(\s*(<[^>]+>|[^)\s]+)(?:\s+(?:"[^"]*"|'[^']*'))?\s*\)/g;
 var FENCE_RE = /```feishu-card[^\n]*\n([\s\S]*?)```/g;
@@ -5780,6 +7079,7 @@ function escapeInline2(s) {
 }
 
 // src/card/context-gauge.ts
+init_cards();
 var CTX_WARN = 0.7;
 var CTX_HIGH = 0.85;
 var CTX_CRIT = 0.95;
@@ -6115,6 +7415,7 @@ function truncate4(s, n) {
 }
 
 // src/card/goal-card.ts
+init_cards();
 function fmtTokens(n) {
   return Math.max(0, Math.round(n)).toLocaleString("en-US");
 }
@@ -6155,6 +7456,8 @@ function buildGoalDoneCard(d) {
 }
 
 // src/card/run-card-stream.ts
+init_logger();
+init_managed();
 var STREAM_THROTTLE_MS = 150;
 var ERR_STREAMING_OFF = 300309;
 var ERR_SEQ_OUT_OF_ORDER = 300317;
@@ -6474,6 +7777,7 @@ function structureSig(card2, eid) {
 }
 
 // src/card/outbound-images.ts
+init_logger();
 import { readFile as readFile7, stat as stat2 } from "fs/promises";
 import { extname as extname2, isAbsolute, resolve as resolve2, sep } from "path";
 var MAX_IMAGES = 9;
@@ -6609,38 +7913,222 @@ async function uploadBuffer(channel, buffer) {
   return key;
 }
 
+// src/bot/handle-message.ts
+init_logger();
+init_cards2();
+
+// src/cli-bridge/hooks.ts
+import { mkdir as mkdir6, readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join10, resolve as resolve3 } from "path";
+var AGENT2LARK_MARKER = "agent2lark-hook";
+var CODEX_EVENTS = ["PermissionRequest", "Stop"];
+var CLAUDE_EVENTS = ["PermissionRequest", "Stop"];
+function resolveBridgeHookCommand(botAppId) {
+  const script = process.argv[1];
+  if (process.platform === "win32") {
+    const winBase = script ? `${win32Quote(process.execPath)} ${win32Quote(resolve3(script))} hook` : "feishu-codex-bridge hook";
+    return botAppId ? `${winBase} --bot ${win32Quote(botAppId)}` : winBase;
+  }
+  const base = script ? `"${process.execPath}" "${resolve3(script)}" hook` : "feishu-codex-bridge hook";
+  return botAppId ? `${base} --bot ${shellQuote(botAppId)}` : base;
+}
+async function inspectCliBridgeHooks(opts = {}) {
+  const home = resolveHome(opts.homeDir);
+  const claude = await readJson(join10(home, ".claude", "settings.json"));
+  const codex = await readJson(join10(home, ".codex", "hooks.json"));
+  let codexStatus = inspectAgent("codex", codex, [...CODEX_EVENTS]);
+  if (codexStatus.status === "installed") {
+    const toml = await readFile8(join10(home, ".codex", "config.toml"), "utf8").catch(() => "");
+    if (!hasCodexHooksFeature(toml)) {
+      codexStatus = {
+        agent: "codex",
+        status: "needs_repair",
+        details: [...codexStatus.details, "config.toml [features] hooks=true missing"]
+      };
+    }
+  }
+  return {
+    claude: inspectAgent("claude", claude, [...CLAUDE_EVENTS]),
+    codex: codexStatus
+  };
+}
+async function installCliBridgeHooks(opts) {
+  const home = resolveHome(opts.homeDir);
+  if (opts.agents.claude) {
+    const file = join10(home, ".claude", "settings.json");
+    const json = await readJson(file);
+    json.hooks = installAgentGroups(json.hooks, "claude", [...CLAUDE_EVENTS], opts.command);
+    await writeJson(file, json);
+  }
+  if (opts.agents.codex) {
+    const file = join10(home, ".codex", "hooks.json");
+    const json = await readJson(file);
+    json.hooks = installAgentGroups(json.hooks, "codex", [...CODEX_EVENTS], opts.command);
+    await writeJson(file, json);
+    const tomlPath = join10(home, ".codex", "config.toml");
+    const existing = await readFile8(tomlPath, "utf8").catch(() => "");
+    await mkdir6(join10(home, ".codex"), { recursive: true });
+    await writeFile6(tomlPath, withCodexHooksFeature(existing), "utf8");
+  }
+}
+function resolveHome(homeDir) {
+  return homeDir ?? homedir3();
+}
+async function readJson(path) {
+  const text = await readFile8(path, "utf8").catch(() => "{}");
+  const parsed = JSON.parse(text || "{}");
+  return typeof parsed === "object" && parsed ? parsed : {};
+}
+async function writeJson(path, value) {
+  await mkdir6(join10(path, ".."), { recursive: true });
+  await writeFile6(path, JSON.stringify(value, null, 2) + "\n", "utf8");
+}
+function inspectAgent(agent, root, events) {
+  const hooks = root.hooks ?? {};
+  const commands = Object.values(hooks).flatMap(
+    (groups) => groups.flatMap((group) => group.hooks ?? []).map((hook) => hook.command ?? "")
+  );
+  if (commands.some((command) => command.includes(AGENT2LARK_MARKER))) {
+    return { agent, status: "conflict_agent2lark", details: ["agent2lark hook command found"] };
+  }
+  const installedEvents = events.filter(
+    (event) => (hooks[event] ?? []).some(
+      (group) => (group.hooks ?? []).some((hook) => isBridgeAgentCommand(hook.command, agent))
+    )
+  );
+  if (installedEvents.length === events.length) {
+    return { agent, status: "installed", details: installedEvents };
+  }
+  if (installedEvents.length > 0 || commands.some((command) => isBridgeCommand(command))) {
+    return { agent, status: "needs_repair", details: installedEvents };
+  }
+  return { agent, status: "not_installed", details: [] };
+}
+function installAgentGroups(hooks, agent, events, command) {
+  const next = removeHookGroups(hooks ?? {}, (hook) => isBridgeCommand(hook.command) || isAgent2larkCommand(hook.command));
+  for (const event of events) {
+    const groups = next[event] ?? [];
+    next[event] = [
+      ...groups,
+      {
+        matcher: "*",
+        // timeout 必须 ≥ IPC 等待上限（24h）——否则 CLI 会在人到飞书点批准前先杀掉 hook。
+        // agent2lark 在每个 Claude/Codex hook 上都写了 86400(见 installer.ts)。
+        hooks: [{ type: "command", command: `${command} --agent ${agent}`, timeout: 86400 }]
+      }
+    ];
+  }
+  return next;
+}
+function removeHookGroups(hooks, shouldRemove) {
+  const next = {};
+  for (const [event, groups] of Object.entries(hooks)) {
+    const kept = groups.flatMap((group) => {
+      if (!group.hooks) return [group];
+      const keptHooks = group.hooks.filter((hook) => !shouldRemove(hook));
+      return keptHooks.length > 0 ? [{ ...group, hooks: keptHooks }] : [];
+    });
+    if (kept.length > 0) next[event] = kept;
+  }
+  return next;
+}
+function isBridgeAgentCommand(command, agent) {
+  return isBridgeCommand(command) && (command ?? "").includes(`--agent ${agent}`);
+}
+function isBridgeCommand(command) {
+  const raw = command ?? "";
+  return raw.includes(" hook") && raw.includes("--agent") && !raw.includes(AGENT2LARK_MARKER);
+}
+function isAgent2larkCommand(command) {
+  return Boolean(command?.includes(AGENT2LARK_MARKER));
+}
+function shellQuote(value) {
+  return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+function win32Quote(value) {
+  return `"${value.replace(/"/g, '\\"')}"`;
+}
+function hasCodexHooksFeature(text) {
+  let inFeatures = false;
+  for (const raw of text.split(/\r?\n/)) {
+    const trimmed = raw.trim();
+    if (/^\[features\]$/.test(trimmed)) {
+      inFeatures = true;
+      continue;
+    }
+    if (inFeatures && /^\[.+\]$/.test(trimmed)) {
+      inFeatures = false;
+      continue;
+    }
+    if (inFeatures && /^hooks\s*=\s*true\b/.test(trimmed)) return true;
+  }
+  return false;
+}
+function withCodexHooksFeature(text) {
+  const lines = text.split(/\r?\n/).filter((line, index, array) => index < array.length - 1 || line.length > 0);
+  let featuresIndex = -1;
+  let nextSectionIndex = lines.length;
+  let codexHooksIndex = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    const trimmed = (lines[index] ?? "").trim();
+    if (/^\[features\]$/.test(trimmed)) {
+      featuresIndex = index;
+      nextSectionIndex = lines.length;
+      continue;
+    }
+    if (featuresIndex >= 0 && index > featuresIndex && /^\[.+\]$/.test(trimmed)) {
+      nextSectionIndex = Math.min(nextSectionIndex, index);
+    }
+    if (featuresIndex >= 0 && index > featuresIndex && index < nextSectionIndex && /^hooks\s*=/.test(trimmed)) {
+      codexHooksIndex = index;
+    }
+  }
+  if (featuresIndex < 0) {
+    const prefix = lines.length > 0 ? [...lines, ""] : [];
+    return [...prefix, "[features]", "hooks = true", ""].join("\n");
+  }
+  if (codexHooksIndex >= 0) {
+    lines[codexHooksIndex] = "hooks = true";
+    return [...lines, ""].join("\n");
+  }
+  lines.splice(featuresIndex + 1, 0, "hooks = true");
+  return [...lines, ""].join("\n");
+}
+
 // src/service/update.ts
 import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname9, join as join14, resolve as resolve5 } from "path";
+import { dirname as dirname9, join as join15, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/service/launchd.ts
 import { spawn as spawn2, spawnSync } from "child_process";
 import { existsSync as existsSync6 } from "fs";
-import { mkdir as mkdir7, rm as rm3, writeFile as writeFile6 } from "fs/promises";
-import { homedir as homedir3, userInfo as userInfo2 } from "os";
-import { dirname as dirname7, join as join11, resolve as resolve4 } from "path";
+import { mkdir as mkdir8, rm as rm3, writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir4, userInfo as userInfo2 } from "os";
+import { dirname as dirname7, join as join12, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/service/common.ts
+init_paths();
 import { createReadStream, statSync as statSync2 } from "fs";
-import { appendFile, mkdir as mkdir6, readFile as readFile8 } from "fs/promises";
-import { dirname as dirname6, join as join10, resolve as resolve3 } from "path";
+import { appendFile, mkdir as mkdir7, readFile as readFile9 } from "fs/promises";
+import { dirname as dirname6, join as join11, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function serviceStdoutPath() {
-  return join10(paths.appDir, "service.log");
+  return join11(paths.appDir, "service.log");
 }
 function serviceStderrPath() {
-  return join10(paths.appDir, "service.err.log");
+  return join11(paths.appDir, "service.err.log");
 }
 async function ensureLogFiles() {
-  await mkdir6(paths.appDir, { recursive: true });
+  await mkdir7(paths.appDir, { recursive: true });
   await appendFile(serviceStdoutPath(), "");
   await appendFile(serviceStderrPath(), "");
 }
 function resolveCliBinPath() {
   const distDir = dirname6(fileURLToPath2(import.meta.url));
-  return resolve3(distDir, "..", "bin", "feishu-codex-bridge.mjs");
+  return resolve4(distDir, "..", "bin", "feishu-codex-bridge.mjs");
 }
 async function tailServiceLogs(follow) {
   await ensureLogFiles();
@@ -6686,7 +8174,7 @@ function fileSize(file) {
 }
 async function lastLines(file, n) {
   try {
-    const text = await readFile8(file, "utf8");
+    const text = await readFile9(file, "utf8");
     return text.split("\n").slice(-n - 1).join("\n").trimEnd();
   } catch {
     return "";
@@ -6696,11 +8184,11 @@ async function lastLines(file, n) {
 // src/service/launchd.ts
 var LAUNCHD_LABEL = "ai.feishu-codex-bridge.bot";
 function launchAgentPlistPath() {
-  return join11(homedir3(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+  return join12(homedir4(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
 }
 function resolveCliBinPath2() {
   const distDir = dirname7(fileURLToPath3(import.meta.url));
-  return resolve4(distDir, "..", "bin", "feishu-codex-bridge.mjs");
+  return resolve5(distDir, "..", "bin", "feishu-codex-bridge.mjs");
 }
 function escapeXml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
@@ -6740,9 +8228,9 @@ function buildPlist() {
 }
 async function installLaunchd() {
   const plistPath = launchAgentPlistPath();
-  await mkdir7(dirname7(plistPath), { recursive: true });
+  await mkdir8(dirname7(plistPath), { recursive: true });
   await ensureLogFiles();
-  await writeFile6(plistPath, buildPlist(), "utf8");
+  await writeFile7(plistPath, buildPlist(), "utf8");
   if (isLoaded()) {
     const bootout = runLaunchctl(["bootout", serviceTarget()]);
     if (!bootout.ok) throw launchctlError("launchctl bootout", bootout);
@@ -6845,21 +8333,22 @@ function launchctlError(command, result) {
 }
 
 // src/service/win-startup.ts
+init_paths();
 import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
 import { openSync, readFileSync as readFileSync3, rmSync, writeFileSync } from "fs";
-import { mkdir as mkdir8, writeFile as writeFile7 } from "fs/promises";
-import { join as join12 } from "path";
+import { mkdir as mkdir9, writeFile as writeFile8 } from "fs/promises";
+import { join as join13 } from "path";
 var RUN_KEY_PATH = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
 var RUN_KEY_NAME = "feishu-codex-bridge";
 var SERVICE_ENV_FLAG = "FEISHU_CODEX_BRIDGE_SERVICE";
 function launcherCmdPath() {
-  return join12(paths.appDir, "service-launcher.cmd");
+  return join13(paths.appDir, "service-launcher.cmd");
 }
 function launcherVbsPath() {
-  return join12(paths.appDir, "service-launcher.vbs");
+  return join13(paths.appDir, "service-launcher.vbs");
 }
 function servicePidFile() {
-  return join12(paths.appDir, "service.pid");
+  return join13(paths.appDir, "service.pid");
 }
 function buildLauncherCmd() {
   return [
@@ -6891,10 +8380,10 @@ function startNow() {
   child.unref();
 }
 async function installWinStartup() {
-  await mkdir8(paths.appDir, { recursive: true });
+  await mkdir9(paths.appDir, { recursive: true });
   await ensureLogFiles();
-  await writeFile7(launcherCmdPath(), buildLauncherCmd(), "utf8");
-  await writeFile7(launcherVbsPath(), buildLauncherVbs(), "utf8");
+  await writeFile8(launcherCmdPath(), buildLauncherCmd(), "utf8");
+  await writeFile8(launcherVbsPath(), buildLauncherVbs(), "utf8");
   const reg = spawnSync2(
     "reg",
     ["add", RUN_KEY_PATH, "/v", RUN_KEY_NAME, "/t", "REG_SZ", "/d", `wscript.exe "${launcherVbsPath()}"`, "/f"],
@@ -6985,13 +8474,13 @@ function killService() {
 // src/service/systemd.ts
 import { spawnSync as spawnSync3 } from "child_process";
 import { existsSync as existsSync7 } from "fs";
-import { mkdir as mkdir9, rm as rm4, writeFile as writeFile8 } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname8, join as join13 } from "path";
+import { mkdir as mkdir10, rm as rm4, writeFile as writeFile9 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname8, join as join14 } from "path";
 var SYSTEMD_UNIT_NAME = "feishu-codex-bridge.service";
 function systemdUnitPath() {
-  const base = process.env.XDG_CONFIG_HOME ?? join13(homedir4(), ".config");
-  return join13(base, "systemd", "user", SYSTEMD_UNIT_NAME);
+  const base = process.env.XDG_CONFIG_HOME ?? join14(homedir5(), ".config");
+  return join14(base, "systemd", "user", SYSTEMD_UNIT_NAME);
 }
 function buildUnit() {
   const esc = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
@@ -7045,9 +8534,9 @@ function ensureSystemdOrThrow() {
 async function installSystemd() {
   ensureSystemdOrThrow();
   const unitPath = systemdUnitPath();
-  await mkdir9(dirname8(unitPath), { recursive: true });
+  await mkdir10(dirname8(unitPath), { recursive: true });
   await ensureLogFiles();
-  await writeFile8(unitPath, buildUnit(), "utf8");
+  await writeFile9(unitPath, buildUnit(), "utf8");
   const reload = runSystemctl(["daemon-reload"]);
   if (!reload.ok) throw systemctlError("systemctl --user daemon-reload", reload);
   const enable = runSystemctl(["enable", "--now", SYSTEMD_UNIT_NAME]);
@@ -7147,11 +8636,11 @@ function isServiceRunning() {
 // src/service/update.ts
 var NPM2 = "npm";
 function pkgRoot() {
-  return resolve5(dirname9(fileURLToPath4(import.meta.url)), "..");
+  return resolve6(dirname9(fileURLToPath4(import.meta.url)), "..");
 }
 function pkgJson() {
   try {
-    return JSON.parse(readFileSync4(join14(pkgRoot(), "package.json"), "utf8"));
+    return JSON.parse(readFileSync4(join15(pkgRoot(), "package.json"), "utf8"));
   } catch {
     return {};
   }
@@ -7163,7 +8652,7 @@ function packageName() {
   return pkgJson().name ?? "@modelzen/feishu-codex-bridge";
 }
 function isDevSource() {
-  return existsSync8(join14(pkgRoot(), ".git"));
+  return existsSync8(join15(pkgRoot(), ".git"));
 }
 function isNewer(a, b) {
   const pa = a.split(".").map((n) => Number.parseInt(n, 10) || 0);
@@ -7227,9 +8716,10 @@ async function restartDaemon() {
 }
 
 // src/agent/codex-appserver/usage.ts
-import { readFile as readFile9 } from "fs/promises";
-import { homedir as homedir5 } from "os";
-import { join as join15 } from "path";
+init_logger();
+import { readFile as readFile10 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { join as join16 } from "path";
 var DEFAULT_BASE_URL = "https://chatgpt.com/backend-api";
 var HTTP_TIMEOUT_MS = 15e3;
 var REFRESH_TIMEOUT_MS = 2e4;
@@ -7237,15 +8727,15 @@ var EXP_SKEW_MS = 6e4;
 var PROFILE_CACHE_MS = 5 * 6e4;
 var USAGE_CACHE_MS = 3e4;
 function resolveCodexHome() {
-  return process.env.CODEX_HOME ?? join15(homedir5(), ".codex");
+  return process.env.CODEX_HOME ?? join16(homedir6(), ".codex");
 }
 async function readCodexAuth() {
-  const file = join15(resolveCodexHome(), "auth.json");
+  const file = join16(resolveCodexHome(), "auth.json");
   let lastErr;
   for (let i = 0; i < 3; i++) {
     let raw;
     try {
-      raw = await readFile9(file, "utf8");
+      raw = await readFile10(file, "utf8");
     } catch (err) {
       throw new UsageError("no-auth", `\u8BFB\u4E0D\u5230 ${file}\uFF1A${err instanceof Error ? err.message : String(err)}`);
     }
@@ -7274,7 +8764,7 @@ function jwtExpMs(token) {
 }
 async function chatgptBaseUrl() {
   try {
-    const raw = await readFile9(join15(resolveCodexHome(), "config.toml"), "utf8");
+    const raw = await readFile10(join16(resolveCodexHome(), "config.toml"), "utf8");
     for (const line of raw.split("\n")) {
       const t = line.trim();
       if (t.startsWith("[")) break;
@@ -7437,6 +8927,7 @@ async function fetchUsageBundle(force = false) {
 }
 
 // src/card/usage-cards.ts
+init_cards();
 function formatTokensZh(n) {
   if (n === void 0 || n === null || Number.isNaN(n)) return "\u2014";
   const fmt = (v) => {
@@ -7804,6 +9295,7 @@ function buildUsageShareCard(data, opts = {}) {
 }
 
 // src/web/discovery.ts
+init_paths();
 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";
@@ -7868,10 +9360,18 @@ function isAlive(pid) {
   }
 }
 
+// src/bot/handle-message.ts
+init_paths();
+
 // src/project/lifecycle.ts
-import { mkdir as mkdir10 } from "fs/promises";
+init_paths();
+init_logger();
+import { mkdir as mkdir11 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
-import { isAbsolute as isAbsolute2, join as join16, resolve as resolve6 } from "path";
+import { isAbsolute as isAbsolute2, join as join17, resolve as resolve7 } from "path";
+
+// src/project/announcement.ts
+init_logger();
 
 // src/project/git-info.ts
 import { execFile } from "child_process";
@@ -7971,6 +9471,7 @@ async function refreshBranch(channel, project) {
 }
 
 // src/project/onboarding.ts
+init_logger();
 function welcomeCaps(backend) {
   try {
     return createBackend(backend).capabilities;
@@ -8058,12 +9559,12 @@ function assertBackendUsable(backend, mode) {
 }
 async function resolveCwd(name, existingPath) {
   if (existingPath) {
-    const cwd2 = isAbsolute2(existingPath) ? existingPath : resolve6(existingPath);
+    const cwd2 = isAbsolute2(existingPath) ? existingPath : resolve7(existingPath);
     if (!existsSync9(cwd2)) throw new Error(`\u6587\u4EF6\u5939\u4E0D\u5B58\u5728\uFF1A${cwd2}`);
     return { cwd: cwd2, blank: false };
   }
-  const cwd = join16(paths.projectsRootDir, name);
-  await mkdir10(cwd, { recursive: true });
+  const cwd = join17(paths.projectsRootDir, name);
+  await mkdir11(cwd, { recursive: true });
   return { cwd, blank: true };
 }
 async function createProject(channel, input2) {
@@ -8129,6 +9630,7 @@ async function joinExistingGroup(channel, input2) {
 }
 
 // src/project/group-ops.ts
+init_logger();
 async function transferOwnership(channel, chatId, toOpenId) {
   await channel.rawClient.im.v1.chat.update({
     path: { chat_id: chatId },
@@ -8146,7 +9648,8 @@ 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";
+init_paths();
+import { mkdir as mkdir12, readFile as readFile11, rename as rename5, writeFile as writeFile10 } from "fs/promises";
 import { randomUUID as randomUUID5 } from "crypto";
 import { dirname as dirname11 } from "path";
 var FILE_VERSION3 = 2;
@@ -8165,7 +9668,7 @@ async function read2() {
 }
 async function listSessionsIn(file) {
   try {
-    const text = await readFile10(file, "utf8");
+    const text = await readFile11(file, "utf8");
     const parsed = JSON.parse(text);
     if (!Array.isArray(parsed.sessions)) return [];
     return parsed.sessions.map(migrate);
@@ -8184,10 +9687,10 @@ function withLock2(fn) {
   return run;
 }
 async function write2(sessions) {
-  await mkdir11(dirname11(paths.sessionsFile), { recursive: true });
+  await mkdir12(dirname11(paths.sessionsFile), { recursive: true });
   const tmp = `${paths.sessionsFile}.tmp-${process.pid}-${randomUUID5()}`;
   const body = { version: FILE_VERSION3, sessions };
-  await writeFile9(tmp, `${JSON.stringify(body, null, 2)}
+  await writeFile10(tmp, `${JSON.stringify(body, null, 2)}
 `, "utf8");
   await rename5(tmp, paths.sessionsFile);
 }
@@ -8222,6 +9725,9 @@ async function patchSession(threadId, patch) {
 }
 
 // src/bot/dm-console.ts
+init_schema();
+init_managed();
+init_logger();
 async function handleDmConsole(channel, cfg, msg) {
   await withTrace({ chatId: msg.chatId, msgId: msg.messageId }, async () => {
     if (!isAdmin(cfg, msg.senderId)) {
@@ -8236,8 +9742,10 @@ async function handleDmConsole(channel, cfg, msg) {
 }
 
 // src/bot/media.ts
-import { mkdir as mkdir12, readdir as readdir3, rm as rm5, stat as stat3 } from "fs/promises";
-import { join as join17 } from "path";
+init_paths();
+init_logger();
+import { mkdir as mkdir13, readdir as readdir3, rm as rm5, stat as stat3 } from "fs/promises";
+import { join as join18 } from "path";
 var MAX_IMAGES2 = 9;
 var MEDIA_TTL_MS = 60 * 6e4;
 var EXT_BY_CONTENT_TYPE = {
@@ -8266,7 +9774,7 @@ async function collectInboundImages(channel, msg) {
   if (refs.length === 0) return [];
   await pruneOldMedia(paths.mediaDir);
   try {
-    await mkdir12(paths.mediaDir, { recursive: true });
+    await mkdir13(paths.mediaDir, { recursive: true });
   } catch {
   }
   const out = [];
@@ -8342,7 +9850,7 @@ async function downloadOne(channel, ref, index) {
       params: { type: "image" }
     });
     const ext = extFromHeaders(res.headers);
-    const file = join17(paths.mediaDir, `${safeName(ref.fileKey)}-${index}.${ext}`);
+    const file = join18(paths.mediaDir, `${safeName(ref.fileKey)}-${index}.${ext}`);
     await res.writeFile(file);
     return file;
   } catch (err) {
@@ -8376,7 +9884,7 @@ async function pruneOldMedia(dir) {
   }
   const cutoff = Date.now() - MEDIA_TTL_MS;
   for (const name of entries) {
-    const file = join17(dir, name);
+    const file = join18(dir, name);
     try {
       const st = await stat3(file);
       if (st.mtimeMs < cutoff) await rm5(file, { force: true });
@@ -8401,7 +9909,7 @@ async function collectInboundFiles(channel, msg) {
   if (refs.length === 0) return [];
   await pruneOldMedia(paths.inboundDir);
   try {
-    await mkdir12(paths.inboundDir, { recursive: true });
+    await mkdir13(paths.inboundDir, { recursive: true });
   } catch {
   }
   const out = [];
@@ -8425,7 +9933,7 @@ async function downloadOneFile(channel, ref) {
     }
     const name = cleanFileName(ref.fileName) || "attachment";
     const onDisk = `${safeName(ref.fileKey)}-${name}`;
-    const file = join17(paths.inboundDir, onDisk);
+    const file = join18(paths.inboundDir, onDisk);
     await res.writeFile(file);
     try {
       const st = await stat3(file);
@@ -8464,6 +9972,7 @@ ${lines}
 }
 
 // src/bot/context-weave.ts
+init_logger();
 var QUOTE_MAX = 800;
 var LINE_MAX = 280;
 var THREAD_WEAVE_MAX = 20;
@@ -8669,6 +10178,7 @@ function weaveSender(text, sender) {
 }
 
 // src/bot/comments.ts
+init_logger();
 var SUPPORTED_FILE_TYPES = /* @__PURE__ */ new Set(["doc", "docx", "sheet", "file"]);
 var REPLY_MAX_CHARS = 2e3;
 function apiErrCode(err) {
@@ -8940,9 +10450,9 @@ var Semaphore = class {
     const acquired = new Promise((res) => {
       settle = res;
     });
-    let settled = false;
+    let settled2 = false;
     const grant = () => {
-      settled = true;
+      settled2 = true;
       this.active++;
       let released = false;
       settle(() => {
@@ -8966,11 +10476,11 @@ var Semaphore = class {
         return i >= 0 ? i + 1 : 0;
       },
       cancel: () => {
-        if (settled) return false;
+        if (settled2) return false;
         const i = this.waiters.indexOf(entry);
         if (i < 0) return false;
         this.waiters.splice(i, 1);
-        settled = true;
+        settled2 = true;
         settle(null);
         this.notifyAdvance(i);
         return true;
@@ -9121,7 +10631,7 @@ function pickIdleSessions(keys, touchedAt, isBusy, idleMs, now) {
   }
   return out;
 }
-function createOrchestrator(channel, cfg, fallbackCwd) {
+function createOrchestrator(channel, cfg, fallbackCwd, cliBridge) {
   const backends = /* @__PURE__ */ new Map();
   function backendFor(id) {
     const key = id && catalogById(id) ? id : DEFAULT_BACKEND_ID;
@@ -9230,6 +10740,14 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
       preview: msg.content.slice(0, 40)
     });
     if (msg.chatType === "p2p") {
+      if (cliBridge?.onMessage({
+        parentId: msg.replyToMessageId,
+        rootId: msg.threadId,
+        text: msg.content,
+        messageId: msg.messageId
+      })) {
+        return;
+      }
       await handleDmConsole(channel, cfg, msg);
       return;
     }
@@ -9828,6 +11346,7 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
     });
   }
   const dispatcher = new CardDispatcher(channel, cfg);
+  cliBridge?.register(dispatcher);
   const PENDING_TTL_MS = 30 * 6e4;
   const GOAL_IDLE_MS = 30 * 6e4;
   const CARD_SETTLE_MS = 500;
@@ -9985,13 +11504,27 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
     if (op?.openId && op.name && !m.has(op.openId)) m.set(op.openId, op.name);
     return m;
   };
-  function applyPref(evt, mut) {
+  function applyPref(evt, mut, opts) {
     if (!dmAdmin(evt.operator?.openId)) return;
     const prefs = { ...cfg.preferences ?? {} };
     mut(prefs);
     cfg.preferences = prefs;
     void saveConfig(cfg).catch((err) => log.fail("console", err, { phase: "save-config" }));
-    patch(evt, buildSettingsCard(cfg));
+    if (opts?.render !== false) void patch(evt, renderSettings);
+  }
+  let cliHookStatuses;
+  async function renderSettings(refreshHooks = false) {
+    if (refreshHooks || !cliHookStatuses) cliHookStatuses = await inspectCliBridgeHooks();
+    const cliPrefs = getCliBridgePreferences(cfg);
+    const localAgents = cliBridgeSettingsSection({
+      enabled: cliPrefs.enabled,
+      statuses: cliHookStatuses,
+      canEnable: canEnableCliBridge(cfg),
+      notifyScope: cliPrefs.notifyScope,
+      agents: cliPrefs.agents,
+      keepAwake: cliPrefs.keepAwake.enabled
+    });
+    return buildSettingsCard(cfg, localAgents);
   }
   const freshMenu = (evt) => {
     patch(evt, buildDmMenuCard({ webConsoleUrl: webConsoleUrl(), version: bridgeVersion() }));
@@ -10136,7 +11669,59 @@ function createOrchestrator(channel, cfg, fallbackCwd) {
     if (!dmAdmin(evt.operator?.openId)) return;
     patch(evt, renderProjectList);
   }).on(DM.settings, async ({ evt }) => {
-    if (dmAdmin(evt.operator?.openId)) await patch(evt, buildSettingsCard(cfg));
+    if (dmAdmin(evt.operator?.openId)) await patch(evt, () => renderSettings(true));
+  }).on(CLI.toggleEnabled, async ({ evt, value }) => {
+    if (!dmAdmin(evt.operator?.openId)) return;
+    const enabled = value.v === "on";
+    if (enabled && !canEnableCliBridge(cfg).ok) return;
+    try {
+      if (enabled) {
+        await cliBridge?.start?.();
+        applyPref(evt, (p) => {
+          p.cliBridge = { ...p.cliBridge ?? {}, enabled: true };
+        }, { render: false });
+      } else {
+        applyPref(evt, (p) => {
+          p.cliBridge = { ...p.cliBridge ?? {}, enabled: false };
+        }, { render: false });
+        await cliBridge?.shutdown?.();
+      }
+    } catch (err) {
+      log.fail("cli-bridge", err, { phase: enabled ? "enable" : "disable" });
+    }
+    void patch(evt, renderSettings);
+  }).on(CLI.repairHooks, async ({ evt }) => {
+    if (!dmAdmin(evt.operator?.openId)) return;
+    try {
+      await installCliBridgeHooks({
+        agents: { claude: true, codex: true },
+        command: resolveBridgeHookCommand(cfg.accounts.app.id)
+      });
+    } catch (err) {
+      log.fail("cli-bridge", err, { phase: "repair-hooks" });
+    }
+    await patch(evt, () => renderSettings(true));
+  }).on(CLI.setNotifyScope, ({ evt, value }) => {
+    if (!dmAdmin(evt.operator?.openId)) return;
+    const scope = value.v === "bound_projects" || value.v === "none" ? value.v : "all";
+    applyPref(evt, (p) => {
+      p.cliBridge = { ...p.cliBridge ?? {}, notifyScope: scope };
+    });
+  }).on(CLI.toggleAgent, ({ evt, value }) => {
+    if (!dmAdmin(evt.operator?.openId)) return;
+    const agent = value.agent === "codex" ? "codex" : "claude";
+    const on = value.v === "on";
+    applyPref(evt, (p) => {
+      const cur = p.cliBridge ?? {};
+      p.cliBridge = { ...cur, agents: { ...cur.agents ?? {}, [agent]: on } };
+    });
+  }).on(CLI.toggleKeepAwake, ({ evt, value }) => {
+    if (!dmAdmin(evt.operator?.openId)) return;
+    const on = value.v === "on";
+    applyPref(evt, (p) => {
+      const cur = p.cliBridge ?? {};
+      p.cliBridge = { ...cur, keepAwake: { ...cur.keepAwake ?? {}, enabled: on } };
+    });
   }).on(DM.doctor, async ({ evt }) => {
     if (!dmAdmin(evt.operator?.openId)) return;
     await sendManagedCard(channel, evt.chatId, buildDoctorCard(await buildDoctorInfo()), evt.messageId).catch(
@@ -11340,6 +12925,18 @@ async function getThreadId(channel, messageId, attempts = 1) {
 }
 
 // src/bot/bridge.ts
+init_paths();
+init_cli_bridge();
+async function cwdIsBoundProject(cwd) {
+  if (!cwd) return false;
+  const strip = (p) => p.replace(/[/\\]+$/, "");
+  const target = strip(cwd);
+  const projects = await listProjects().catch(() => []);
+  return projects.some((project) => {
+    const root = strip(project.cwd);
+    return root.length > 0 && (target === root || target.startsWith(root + sep2));
+  });
+}
 async function startBridge(opts) {
   const app = opts.cfg.accounts.app;
   const channel = createLarkChannel({
@@ -11365,7 +12962,13 @@ async function startBridge(opts) {
     // sends are already prevented by startReservedRun's synchronous booking.
     safety: { batch: { text: { delayMs: 0 } } }
   });
-  const orchestrator = createOrchestrator(channel, opts.cfg, opts.fallbackCwd);
+  const cliBridge = createCliBridgeService({
+    cfg: opts.cfg,
+    channel,
+    socketPath: paths.cliBridgeSocket,
+    isBoundProject: cwdIsBoundProject
+  });
+  const orchestrator = createOrchestrator(channel, opts.cfg, opts.fallbackCwd, cliBridge);
   channel.on("message", orchestrator.onMessage);
   channel.on("cardAction", orchestrator.dispatcher.handle);
   channel.on("comment", orchestrator.onComment);
@@ -11403,41 +13006,48 @@ async function startBridge(opts) {
   channel.on("reconnecting", () => log.info("ws", "reconnecting"));
   channel.on("reconnected", () => log.info("ws", "reconnected"));
   await channel.connect();
+  if (shouldStartCliBridge(opts.cfg)) {
+    await cliBridge.start().catch((err) => log.fail("cli-bridge", err, { phase: "start" }));
+  }
   log.info("ws", "connected", { appId: app.id, fallbackCwd: opts.fallbackCwd });
   let closed = false;
   const shutdown = async () => {
     if (closed) return;
     closed = true;
     await orchestrator.shutdown();
+    await cliBridge.shutdown().catch((err) => log.fail("cli-bridge", err, { phase: "shutdown" }));
     await channel.disconnect().catch((err) => log.fail("ws", err, { phase: "disconnect" }));
   };
   return { channel, adminExecute: orchestrator.adminExecute, shutdown };
 }
 
+// src/bot/supervisor.ts
+init_logger();
+
 // src/admin/ipc.ts
 var ADMIN_IPC_REQ = "fcb.admin.req";
 var ADMIN_IPC_RES = "fcb.admin.res";
 var ADMIN_IPC_TIMEOUT_MS = 15e3;
 function createAdminIpcCaller(send) {
   let nextId = 1;
-  const pending = /* @__PURE__ */ new Map();
+  const pending2 = /* @__PURE__ */ new Map();
   function settle(id) {
-    const entry = pending.get(id);
+    const entry = pending2.get(id);
     if (!entry) return void 0;
-    pending.delete(id);
+    pending2.delete(id);
     clearTimeout(entry.timer);
     return entry;
   }
   return {
     call(op, timeoutMs = ADMIN_IPC_TIMEOUT_MS) {
       const id = nextId++;
-      return new Promise((resolve8, reject) => {
+      return new Promise((resolve9, reject) => {
         const timer = setTimeout(() => {
-          pending.delete(id);
+          pending2.delete(id);
           reject(new Error(`bot \u8FDB\u7A0B ${timeoutMs}ms \u672A\u54CD\u5E94\uFF08\u53EF\u80FD\u6B63\u5FD9\u6216\u5DF2\u5047\u6B7B\uFF09`));
         }, timeoutMs);
         timer.unref?.();
-        pending.set(id, { resolve: resolve8, reject, timer });
+        pending2.set(id, { resolve: resolve9, reject, timer });
         try {
           send({ fcb: ADMIN_IPC_REQ, id, op });
         } catch (err) {
@@ -11458,7 +13068,7 @@ function createAdminIpcCaller(send) {
       entry.reject(msg.code === "ADMIN_WRITE_REJECTED" ? new AdminWriteError(reason) : new Error(reason));
     },
     rejectAll(reason) {
-      for (const id of [...pending.keys()]) {
+      for (const id of [...pending2.keys()]) {
         settle(id)?.reject(new Error(reason));
       }
     }
@@ -11493,9 +13103,19 @@ function createAdminIpcResponder(execute, send) {
 }
 
 // src/admin/service.ts
-import { readFile as readFile11, rm as rm6 } from "fs/promises";
+init_bots();
+init_paths();
+import { readFile as readFile12, rm as rm7 } from "fs/promises";
+init_schema();
+init_store();
+init_schema();
 
 // src/bot/register-bot.ts
+init_store();
+init_paths();
+init_schema();
+init_bots();
+init_logger();
 var APP_ID_RE = /^cli_[A-Za-z0-9]{6,}$/;
 async function registerBotFromCredentials(input2, validate = validateAppCredentials) {
   const appId = input2.appId?.trim() ?? "";
@@ -11552,9 +13172,13 @@ function withOwnerAdmin(base, ownerOpenId) {
   };
 }
 
+// src/admin/service.ts
+init_logger();
+
 // src/admin/host.ts
+init_paths();
 import { readdir as readdir4, stat as stat4 } from "fs/promises";
-import { dirname as dirname12, join as join18, resolve as resolve7 } from "path";
+import { dirname as dirname12, join as join20, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { arch, platform as platform2, release } from "os";
 function toDaemonStatus(opts) {
@@ -11583,7 +13207,7 @@ async function dirBytes(dir) {
     return 0;
   }
   for (const name of entries) {
-    const full = join18(dir, name);
+    const full = join20(dir, name);
     try {
       const st = await stat4(full);
       if (st.isDirectory()) total += await dirBytes(full);
@@ -11593,7 +13217,7 @@ async function dirBytes(dir) {
   }
   return total;
 }
-async function collectHostDoctor(logsDir2 = join18(paths.appDir, "logs")) {
+async function collectHostDoctor(logsDir2 = join20(paths.appDir, "logs")) {
   return {
     node: process.version,
     platform: platform2(),
@@ -11607,7 +13231,7 @@ async function collectHostDoctor(logsDir2 = join18(paths.appDir, "logs")) {
 }
 function resolveCliBinPath3() {
   const distDir = dirname12(fileURLToPath5(import.meta.url));
-  return resolve7(distDir, "..", "bin", "feishu-codex-bridge.mjs");
+  return resolve8(distDir, "..", "bin", "feishu-codex-bridge.mjs");
 }
 function buildDaemonControlCommand(action, binPath = resolveCliBinPath3(), nodePath = process.execPath) {
   return { command: nodePath, args: [binPath, "__daemon-control", action] };
@@ -11654,7 +13278,7 @@ function createAdminService(deps = {}) {
   }
   async function lockFileRunState(botId) {
     try {
-      const raw = await readFile11(botPaths(botId).processesFile, "utf8");
+      const raw = await readFile12(botPaths(botId).processesFile, "utf8");
       const rec = JSON.parse(raw);
       if (typeof rec.pid === "number" && isAlive2(rec.pid)) {
         return { running: true, pid: rec.pid, startedAt: rec.startedAt };
@@ -11970,7 +13594,7 @@ function createAdminService(deps = {}) {
       }
       await removeBot(appId);
       await removeSecret(secretKeyForApp(appId)).catch(() => void 0);
-      await rm6(botDir(appId), { recursive: true, force: true }).catch(() => void 0);
+      await rm7(botDir(appId), { recursive: true, force: true }).catch(() => void 0);
       return { ok: true };
     }
   };
@@ -12062,6 +13686,7 @@ function isAlive2(pid) {
 }
 
 // src/cli/commands/daemon-control.ts
+init_logger();
 function spawnDaemonControl(action) {
   const { command, args } = buildDaemonControlCommand(action);
   const child = spawnProcess(command, args, {
@@ -12122,7 +13747,7 @@ function pidAlive2(pid, kill) {
     return err.code === "EPERM";
   }
 }
-var napDefault = (ms) => new Promise((resolve8) => setTimeout(resolve8, ms));
+var napDefault = (ms) => new Promise((resolve9) => setTimeout(resolve9, ms));
 async function stopSelfHostedDaemon(deps = {}) {
   const readDaemonPid = deps.readDaemonPid ?? (() => readWebConsole()?.pid);
   const kill = deps.kill ?? ((p, s) => void process.kill(p, s));
@@ -12172,12 +13797,16 @@ async function doRestart(phase) {
   log.info("daemon-control", "restart-issued", { phase });
 }
 
+// src/web/mount.ts
+init_logger();
+
 // src/web/server.ts
+init_paths();
 import { createServer } from "http";
-import { randomUUID as randomUUID6, timingSafeEqual } from "crypto";
+import { randomUUID as randomUUID7, 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";
+import { join as join21 } from "path";
 
 // src/web/ui.ts
 var UI_PURE_JS = `
@@ -14850,9 +16479,9 @@ 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 ?? randomUUID6();
+  const token = opts.token ?? randomUUID7();
   const html = opts.html ?? UI_HTML;
-  const logDir = opts.logDir ?? join19(paths.appDir, "logs");
+  const logDir = opts.logDir ?? join21(paths.appDir, "logs");
   const sseCleanups = /* @__PURE__ */ new Set();
   const installJobs = /* @__PURE__ */ new Map();
   let qrSession = null;
@@ -15203,7 +16832,7 @@ function createWebServer(opts) {
   function handleRegisterQrStream(req, res) {
     qrSession?.abort.abort();
     const abort = new AbortController();
-    const session = { id: randomUUID6(), abort };
+    const session = { id: randomUUID7(), abort };
     qrSession = session;
     res.writeHead(200, {
       "Content-Type": "text/event-stream",
@@ -15347,7 +16976,7 @@ data: ${JSON.stringify(data)}
     let currentFile = todayLogFile(logDir);
     let offset = 0;
     let reading = false;
-    let pending = false;
+    let pending2 = false;
     let closed = false;
     const sendLines = (text) => {
       for (const line of text.split("\n")) {
@@ -15360,7 +16989,7 @@ data: ${JSON.stringify(data)}
     const pump = async () => {
       if (closed) return;
       if (reading) {
-        pending = true;
+        pending2 = true;
         return;
       }
       reading = true;
@@ -15385,8 +17014,8 @@ data: ${JSON.stringify(data)}
         }
       } finally {
         reading = false;
-        if (pending && !closed) {
-          pending = false;
+        if (pending2 && !closed) {
+          pending2 = false;
           void pump();
         }
       }
@@ -15436,19 +17065,19 @@ data: ${JSON.stringify(data)}
     server,
     token,
     listen(port) {
-      return new Promise((resolve8, reject) => {
+      return new Promise((resolve9, reject) => {
         server.once("error", reject);
         server.listen(port, "127.0.0.1", () => {
           const addr = server.address();
           const actual = typeof addr === "object" && addr ? addr.port : port;
-          resolve8({ port: actual, url: `http://127.0.0.1:${actual}/?token=${token}` });
+          resolve9({ port: actual, url: `http://127.0.0.1:${actual}/?token=${token}` });
         });
       });
     },
     close() {
       for (const cleanup of [...sseCleanups]) cleanup();
-      return new Promise((resolve8, reject) => {
-        server.close((err) => err ? reject(err) : resolve8());
+      return new Promise((resolve9, reject) => {
+        server.close((err) => err ? reject(err) : resolve9());
       });
     }
   };
@@ -15490,7 +17119,7 @@ function isLoopbackOrigin(origin) {
   }
 }
 function todayLogFile(dir) {
-  return join19(dir, `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.log`);
+  return join21(dir, `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.log`);
 }
 function clampInt(raw, min, max, fallback) {
   const n = Number(raw);
@@ -15664,7 +17293,7 @@ async function runSupervisor(bots) {
       console.log(`\u{1F310} Web \u63A7\u5236\u53F0\u5DF2\u5185\u5D4C\u542F\u52A8\uFF08127.0.0.1:${webConsole.port}\uFF09\uFF1A\u8FD0\u884C \`feishu-codex-bridge web\` \u83B7\u53D6\u767B\u5F55\u94FE\u63A5\u3002`);
     }
   }
-  await new Promise((resolve8) => {
+  await new Promise((resolve9) => {
     const stop = (sig) => {
       if (shuttingDown) return;
       shuttingDown = true;
@@ -15681,7 +17310,7 @@ async function runSupervisor(bots) {
         if (alive.length === 0 || Date.now() >= deadline) {
           clearInterval(poll);
           for (const c of alive) c.proc?.kill("SIGKILL");
-          resolve8();
+          resolve9();
         }
       }, 200);
     };
@@ -15691,6 +17320,7 @@ async function runSupervisor(bots) {
 }
 
 // src/core/single-instance.ts
+init_paths();
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync6, statSync as statSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname13 } from "path";
 var CLAIM_ATTEMPTS = 5;
@@ -15801,6 +17431,8 @@ function acquireSingleInstanceLock(appId, file = paths.processesFile) {
 }
 
 // src/cli/commands/run.ts
+init_bots();
+init_logger();
 async function runRun(botName) {
   if (botName) {
     await runSingle(botName);
@@ -15974,6 +17606,7 @@ async function runSingle(botName) {
 }
 
 // src/cli/commands/daemon.ts
+init_bots();
 async function runStart() {
   const active = activeBots(await loadBots());
   if (active.length === 0) {
@@ -16118,7 +17751,10 @@ async function runUpdate(opts = {}) {
 }
 
 // src/cli/commands/bot.ts
-import { rm as rm7 } from "fs/promises";
+import { rm as rm8 } from "fs/promises";
+init_bots();
+init_schema();
+init_paths();
 
 // src/cli/checkbox.ts
 import { emitKeypressEvents } from "readline";
@@ -16164,7 +17800,7 @@ async function checkboxSelect(title, items) {
   output.write(`${ALT_SCREEN_ON}${HIDE_CURSOR}`);
   process.once("exit", restore);
   redraw();
-  return await new Promise((resolve8) => {
+  return await new Promise((resolve9) => {
     const cleanup = () => {
       input2.off("keypress", onKey);
       input2.setRawMode?.(wasRaw);
@@ -16176,12 +17812,12 @@ async function checkboxSelect(title, items) {
       const name = key?.name;
       if (key?.ctrl && name === "c" || name === "escape" || name === "q") {
         cleanup();
-        resolve8(null);
+        resolve9(null);
         return;
       }
       if (name === "return" || name === "enter") {
         cleanup();
-        resolve8(checked.flatMap((on, i) => on ? [i] : []));
+        resolve9(checked.flatMap((on, i) => on ? [i] : []));
         return;
       }
       if (name === "up" || name === "k") {
@@ -16301,7 +17937,7 @@ async function runBotRm(name) {
   }
   const after = await removeBot(bot2.appId);
   await removeSecret(secretKeyForApp(bot2.appId));
-  await rm7(botDir(bot2.appId), { recursive: true, force: true });
+  await rm8(botDir(bot2.appId), { recursive: true, force: true });
   console.log(`\u2713 \u5DF2\u79FB\u9664\u673A\u5668\u4EBA\u300C${bot2.name}\u300D(${bot2.appId})\uFF1A\u6CE8\u518C\u8868 + \u5BC6\u94A5 + \u72B6\u6001\u76EE\u5F55(projects/sessions)\u3002`);
   if (after.bots.length === 0) {
     console.log("  \u5DF2\u65E0\u4EFB\u4F55\u673A\u5668\u4EBA\uFF0C`bot init` \u91CD\u65B0\u521B\u5EFA\u3002");
@@ -16369,6 +18005,7 @@ async function runWeb(opts = {}) {
 }
 
 // src/cli/commands/secrets.ts
+init_stdin();
 async function secretsGet() {
   const input2 = await readStdin();
   let ids = [];
@@ -16410,18 +18047,6 @@ async function secretsRemove(id) {
   const ok = await removeSecret(id);
   console.log(ok ? `\u2713 \u5DF2\u5220\u9664: ${id}` : `\u672A\u627E\u5230: ${id}`);
 }
-function readStdin() {
-  return new Promise((resolve8) => {
-    let data = "";
-    if (process.stdin.isTTY) {
-      resolve8("");
-      return;
-    }
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", (c) => data += c);
-    process.stdin.on("end", () => resolve8(data));
-  });
-}
 
 // src/cli/index.ts
 var program = new Command();
@@ -16482,6 +18107,10 @@ secrets.command("list").description("\u5217\u51FA\u5BC6\u94A5 id").action(async
 secrets.command("remove <id>").description("\u5220\u9664\u5BC6\u94A5").action(async (id) => {
   await secretsRemove(id);
 });
+program.command("hook", { hidden: true }).requiredOption("--agent <agent>", "claude or codex").option("--bot <nameOrAppId>", "target bot name or appId").action(async (options) => {
+  const { runHookCommand: runHookCommand2 } = await Promise.resolve().then(() => (init_cli_bridge(), cli_bridge_exports));
+  await runHookCommand2(options.agent, options.bot);
+});
 program.parseAsync(process.argv).catch((err) => {
   console.error(err instanceof Error ? err.message : String(err));
   process.exit(1);