@modelzen/feishu-codex-bridge 0.1.0

package/dist/cli.js

@@ -0,0 +1,4621 @@
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/commands/doctor.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+
+// src/config/paths.ts
+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);
+}
+function useBotDir(appId) {
+  currentBotDir = botDir(appId);
+}
+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"),
+  /** 空白项目默认落地目录 */
+  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")
+};
+
+// 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 dirname2, join as join2 } from "path";
+
+// src/config/store.ts
+import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname } from "path";
+
+// src/config/schema.ts
+function isComplete(cfg) {
+  const app = cfg.accounts?.app;
+  return Boolean(app?.id && hasSecret(app?.secret) && app?.tenant);
+}
+function hasSecret(s) {
+  if (!s) return false;
+  if (typeof s === "string") return s.length > 0;
+  return Boolean(s.source && s.id);
+}
+function isSecretRef(s) {
+  return typeof s === "object" && s !== null;
+}
+function secretKeyForApp(appId) {
+  return `app-${appId}`;
+}
+function getShowToolCalls(cfg) {
+  return cfg.preferences?.showToolCalls !== false;
+}
+function getMaxConcurrentRuns(cfg) {
+  const raw = cfg.preferences?.maxConcurrentRuns;
+  if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 1) return 10;
+  return Math.min(Math.floor(raw), 50);
+}
+function getPendingPolicy(cfg) {
+  return cfg.preferences?.pendingPolicy === "queue" ? "queue" : "steer";
+}
+function getRunIdleTimeoutMs(cfg) {
+  const raw = cfg.preferences?.runIdleTimeoutSeconds;
+  if (raw === 0) return void 0;
+  if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0) return 12e4;
+  const clamped = Math.min(Math.max(Math.floor(raw), 10), 1800);
+  return clamped * 1e3;
+}
+function isUserAllowed(cfg, senderId) {
+  const list = cfg.preferences?.access?.allowedUsers;
+  if (!list || list.length === 0) return true;
+  return list.includes(senderId);
+}
+function isChatAllowed(cfg, chatId) {
+  const list = cfg.preferences?.access?.allowedChats;
+  if (!list || list.length === 0) return true;
+  return list.includes(chatId);
+}
+function isAdmin(cfg, senderId) {
+  const list = cfg.preferences?.access?.admins;
+  if (!list || list.length === 0) return true;
+  return list.includes(senderId);
+}
+
+// src/config/store.ts
+async function loadConfig(path = paths.configFile) {
+  try {
+    const text = await readFile(path, "utf8");
+    return JSON.parse(text);
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+async function buildEncryptedAccountConfig(appId, tenant, preferences) {
+  const wrapperPath = await ensureSecretsGetterWrapper();
+  return {
+    accounts: {
+      app: {
+        id: appId,
+        secret: { source: "exec", provider: "bridge", id: secretKeyForApp(appId) },
+        tenant
+      }
+    },
+    secrets: {
+      providers: {
+        bridge: { source: "exec", command: wrapperPath, args: [] }
+      }
+    },
+    ...preferences ? { preferences } : {}
+  };
+}
+async function ensureSecretsGetterWrapper() {
+  const wrapperPath = paths.secretsGetterScript;
+  const node = process.execPath;
+  const bridgeEntry = process.argv[1] ?? "";
+  const sq = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+  const content = `#!/bin/sh
+# Auto-generated by feishu-codex-bridge. Do not edit.
+exec ${sq(node)} ${sq(bridgeEntry)} secrets get "$@"
+`;
+  await mkdir(dirname(wrapperPath), { recursive: true });
+  const tmp = `${wrapperPath}.tmp-${process.pid}`;
+  await writeFile(tmp, content, "utf8");
+  await chmod(tmp, 448);
+  await rename(tmp, wrapperPath);
+  return wrapperPath;
+}
+async function saveConfig(cfg, path = paths.configFile) {
+  await mkdir(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}`;
+  await writeFile(tmp, `${JSON.stringify(cfg, null, 2)}
+`, "utf8");
+  await chmod(tmp, 384);
+  await rename(tmp, path);
+}
+
+// src/config/bots.ts
+var EMPTY = { version: 1, bots: [] };
+async function loadBots() {
+  try {
+    const text = await readFile2(paths.botsFile, "utf8");
+    const reg = JSON.parse(text);
+    return { version: 1, current: reg.current, bots: Array.isArray(reg.bots) ? reg.bots : [] };
+  } catch (err) {
+    if (err.code === "ENOENT") return { ...EMPTY };
+    throw err;
+  }
+}
+async function saveBots(reg) {
+  await mkdir2(dirname2(paths.botsFile), { recursive: true });
+  const tmp = `${paths.botsFile}.tmp-${process.pid}`;
+  await writeFile2(tmp, `${JSON.stringify(reg, null, 2)}
+`, "utf8");
+  await chmod2(tmp, 384);
+  await rename2(tmp, paths.botsFile);
+}
+async function ensureRegistry() {
+  if (existsSync(paths.botsFile)) return loadBots();
+  const flatConfigPath = join2(paths.appDir, "config.json");
+  const flat = await loadConfig(flatConfigPath);
+  if (!isComplete(flat)) return { ...EMPTY };
+  const { id: appId, tenant } = flat.accounts.app;
+  const dest = botDir(appId);
+  await mkdir2(dest, { recursive: true });
+  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() }]
+  };
+  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;
+}
+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 setCurrent(appId) {
+  const reg = await loadBots();
+  reg.current = appId;
+  await saveBots(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);
+}
+
+// src/agent/codex-appserver/locate.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+function resolveCodexBin() {
+  const env = process.env.CODEX_BIN;
+  if (env && existsSync2(env)) return env;
+  const onPath = which("codex");
+  if (onPath) return onPath;
+  const priv = join3(paths.codexCliBinDir, "codex");
+  if (existsSync2(priv)) return priv;
+  const appBundle = "/Applications/Codex.app/Contents/Resources/codex";
+  if (process.platform === "darwin" && existsSync2(appBundle)) return appBundle;
+  return null;
+}
+function which(cmd) {
+  try {
+    const out = execFileSync(process.platform === "win32" ? "where" : "which", [cmd], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const first = out.split("\n").map((l) => l.trim()).find(Boolean);
+    return first && existsSync2(first) ? first : null;
+  } catch {
+    return null;
+  }
+}
+function codexVersion(bin) {
+  try {
+    return execFileSync(bin, ["--version"], { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/cli/commands/doctor.ts
+async function runDoctor() {
+  const checks = [];
+  const codexBin = resolveCodexBin();
+  if (codexBin) {
+    const v = codexVersion(codexBin) ?? "unknown";
+    checks.push({ name: "codex CLI", ok: true, detail: `${v} (${codexBin})` });
+  } else {
+    checks.push({
+      name: "codex CLI",
+      ok: false,
+      detail: "\u672A\u627E\u5230\u3002\u8BBE\u7F6E CODEX_BIN\uFF0C\u6216\u5B89\u88C5 @openai/codex\uFF0C\u6216\u88C5 Codex.app"
+    });
+  }
+  const codexAuth = join4(process.env.CODEX_HOME ?? join4(homedir2(), ".codex"), "auth.json");
+  checks.push(
+    existsSync3(codexAuth) ? { name: "codex \u767B\u5F55", ok: true, detail: codexAuth } : { name: "codex \u767B\u5F55", ok: false, detail: "\u672A\u767B\u5F55\uFF0C\u8FD0\u884C `codex login`" }
+  );
+  const larkVer = tryExec("lark-cli", ["--version"]);
+  checks.push(
+    larkVer ? { name: "lark-cli", ok: true, detail: larkVer } : { name: "lark-cli", ok: false, detail: "\u672A\u627E\u5230\uFF08onboarding \u4F1A\u88C5\u5230\u79C1\u6709\u76EE\u5F55\uFF09" }
+  );
+  const reg = await ensureRegistry();
+  const cur = currentBot(reg);
+  if (cur) useBotDir(cur.appId);
+  if (cur && existsSync3(paths.configFile)) {
+    checks.push({
+      name: "bridge \u914D\u7F6E",
+      ok: true,
+      detail: `\u5F53\u524D\u673A\u5668\u4EBA\u300C${cur.name}\u300D(${cur.appId})  \u5171 ${reg.bots.length} \u4E2A`
+    });
+  } else if (cur) {
+    checks.push({ name: "bridge \u914D\u7F6E", ok: false, detail: `\u914D\u7F6E\u6587\u4EF6\u7F3A\u5931\uFF1A${paths.configFile}` });
+  } else {
+    checks.push({
+      name: "bridge \u914D\u7F6E",
+      ok: false,
+      detail: "\u672A\u914D\u7F6E\uFF0C\u8FD0\u884C `feishu-codex-bridge run`\uFF08\u6216 `bot init`\uFF09\u626B\u7801\u521B\u5EFA"
+    });
+  }
+  console.log("\n\u{1FA7A} feishu-codex-bridge \u81EA\u68C0\n");
+  for (const c of checks) {
+    console.log(`  ${c.ok ? "\u2705" : "\u274C"} ${c.name.padEnd(12)} ${c.detail}`);
+  }
+  const failed = checks.filter((c) => !c.ok).length;
+  console.log(`
+${failed === 0 ? "\u5168\u90E8\u901A\u8FC7 \u2713" : `${failed} \u9879\u9700\u5904\u7406`}
+`);
+  process.exitCode = failed === 0 ? 0 : 1;
+}
+function tryExec(cmd, args) {
+  try {
+    return execFileSync2(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/bot/onboarding.ts
+import { createInterface } from "readline/promises";
+
+// src/config/keystore.ts
+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";
+import { dirname as dirname3 } from "path";
+var KEY_LEN = 32;
+var IV_LEN = 12;
+var TAG_LEN = 16;
+var PBKDF2_ITER = 1e5;
+var FILE_VERSION = 1;
+var EMPTY2 = { version: FILE_VERSION, entries: {} };
+async function readStore() {
+  try {
+    const text = await readFile3(paths.secretsFile, "utf8");
+    const parsed = JSON.parse(text);
+    if (parsed?.version !== FILE_VERSION || !parsed.entries) return { ...EMPTY2 };
+    return { version: parsed.version, entries: { ...parsed.entries } };
+  } catch (err) {
+    if (err.code === "ENOENT") return { ...EMPTY2 };
+    throw err;
+  }
+}
+async function writeStore(store) {
+  await mkdir3(dirname3(paths.secretsFile), { recursive: true });
+  const tmp = `${paths.secretsFile}.tmp-${process.pid}`;
+  await writeFile3(tmp, `${JSON.stringify(store, null, 2)}
+`, "utf8");
+  await chmod3(tmp, 384);
+  await rename3(tmp, paths.secretsFile);
+}
+async function loadOrCreateSalt() {
+  try {
+    const buf = await readFile3(paths.keystoreSaltFile);
+    if (buf.length === KEY_LEN) return buf;
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const salt = randomBytes(KEY_LEN);
+  await mkdir3(dirname3(paths.keystoreSaltFile), { recursive: true });
+  const tmp = `${paths.keystoreSaltFile}.tmp-${process.pid}`;
+  await writeFile3(tmp, salt);
+  await chmod3(tmp, 384);
+  await rename3(tmp, paths.keystoreSaltFile);
+  return salt;
+}
+async function deriveKey() {
+  const salt = await loadOrCreateSalt();
+  const seed = `${hostname()}|${userInfo().username}`;
+  return pbkdf2Sync(seed, salt, PBKDF2_ITER, KEY_LEN, "sha256");
+}
+function encrypt(key, plaintext) {
+  const iv = randomBytes(IV_LEN);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const enc = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return { iv: iv.toString("base64"), data: enc.toString("base64"), tag: tag.toString("base64") };
+}
+function decrypt(key, env) {
+  const iv = Buffer.from(env.iv, "base64");
+  const data = Buffer.from(env.data, "base64");
+  const tag = Buffer.from(env.tag, "base64");
+  if (iv.length !== IV_LEN) throw new Error("invalid IV length");
+  if (tag.length !== TAG_LEN) throw new Error("invalid auth tag length");
+  const decipher = createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(tag);
+  const dec = Buffer.concat([decipher.update(data), decipher.final()]);
+  return dec.toString("utf8");
+}
+async function getSecret(id) {
+  const store = await readStore();
+  const env = store.entries[id];
+  if (!env) return void 0;
+  const key = await deriveKey();
+  return decrypt(key, env);
+}
+async function setSecret(id, plaintext) {
+  const key = await deriveKey();
+  const env = encrypt(key, plaintext);
+  const store = await readStore();
+  store.entries[id] = env;
+  await writeStore(store);
+}
+async function removeSecret(id) {
+  const store = await readStore();
+  if (!(id in store.entries)) return false;
+  delete store.entries[id];
+  await writeStore(store);
+  return true;
+}
+async function listSecretIds() {
+  const store = await readStore();
+  return Object.keys(store.entries);
+}
+
+// src/config/secret-resolver.ts
+import { spawn } from "child_process";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join5 } from "path";
+var ENV_TEMPLATE_RE = /^\$\{([A-Z][A-Z0-9_]{0,127})\}$/;
+var DEFAULT_PROVIDER = "default";
+var DEFAULT_EXEC_TIMEOUT_MS = 5e3;
+var DEFAULT_EXEC_MAX_OUTPUT = 64 * 1024;
+async function resolveAppSecret(cfg) {
+  const appId = cfg.accounts.app.id;
+  return resolveSecretInput(cfg.accounts.app.secret, cfg.secrets, appId);
+}
+async function resolveSecretInput(input2, secretsCfg, appId) {
+  if (!input2) throw new Error("app secret is missing");
+  if (typeof input2 === "string") return resolvePlainOrTemplate(input2);
+  if (!isSecretRef(input2)) throw new Error(`unsupported secret form: ${JSON.stringify(input2)}`);
+  switch (input2.source) {
+    case "env":
+      return resolveEnvRef(input2, lookupProvider(secretsCfg, input2));
+    case "file":
+      return resolveFileRef(input2, lookupProvider(secretsCfg, input2));
+    case "exec":
+      return resolveExecRef(input2, lookupProvider(secretsCfg, input2), appId);
+    default:
+      throw new Error(`unknown secret source: ${input2.source}`);
+  }
+}
+function resolvePlainOrTemplate(value) {
+  if (!value) throw new Error("app secret is empty");
+  const m = ENV_TEMPLATE_RE.exec(value);
+  if (m) {
+    const name = m[1];
+    const v = process.env[name];
+    if (!v) throw new Error(`env var ${name} referenced by secret is not set`);
+    return v;
+  }
+  return value;
+}
+function lookupProvider(secretsCfg, ref) {
+  if (!secretsCfg?.providers) return void 0;
+  const name = ref.provider ?? secretsCfg.defaults?.[ref.source] ?? DEFAULT_PROVIDER;
+  return secretsCfg.providers[name];
+}
+function resolveEnvRef(ref, pc) {
+  if (pc?.allowlist && pc.allowlist.length > 0 && !pc.allowlist.includes(ref.id)) {
+    throw new Error(`env var ${ref.id} is not allowlisted in provider`);
+  }
+  const v = process.env[ref.id];
+  if (!v) throw new Error(`env var ${ref.id} is not set`);
+  return v;
+}
+async function resolveFileRef(ref, pc) {
+  const path = pc?.path ? join5(pc.path, ref.id) : ref.id;
+  return (await readFile4(path, "utf8")).trim();
+}
+async function resolveExecRef(ref, pc, appId) {
+  if (!pc?.command) throw new Error("exec provider missing `command`");
+  if (isSelfBridgeCommand(pc.command, pc.args)) {
+    const candidate = await getSecret(ref.id);
+    if (candidate !== void 0) return candidate;
+    const conventional = secretKeyForApp(appId);
+    const fallback = await getSecret(conventional);
+    if (fallback !== void 0) return fallback;
+    throw new Error(`keystore has no entry for "${ref.id}" or "${conventional}"`);
+  }
+  return spawnExecProvider(pc, ref);
+}
+function isSelfBridgeCommand(command, args) {
+  if (command === paths.secretsGetterScript) return true;
+  if (args && args.length >= 2) {
+    const a = args[args.length - 2];
+    const b = args[args.length - 1];
+    if (a === "secrets" && b === "get") return true;
+  }
+  return false;
+}
+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((resolve3, reject) => {
+    const env = {};
+    if (pc.passEnv) for (const k of pc.passEnv) {
+      const v = process.env[k];
+      if (v) env[k] = v;
+    }
+    if (pc.env) Object.assign(env, pc.env);
+    const child = spawn(pc.command, pc.args ?? [], { env, stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "", stderr = "", truncated = false, settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill("SIGKILL");
+      reject(new Error(`exec provider timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      if (truncated) return;
+      if (stdout.length + chunk.length > maxOutput) {
+        truncated = true;
+        child.kill("SIGKILL");
+        return;
+      }
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new Error(`exec provider failed to start: ${err.message}`));
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (truncated) return reject(new Error(`exec provider stdout exceeded ${maxOutput} bytes`));
+      if (code !== 0) {
+        const detail = stderr.trim() ? `: ${stderr.trim().slice(0, 200)}` : "";
+        return reject(new Error(`exec provider exited with code ${code}${detail}`));
+      }
+      try {
+        const parsed = JSON.parse(stdout);
+        const value = parsed.values?.[ref.id];
+        if (typeof value === "string") return resolve3(value);
+        const err = parsed.errors?.[ref.id]?.message;
+        reject(new Error(`exec provider did not return secret for ${ref.id}${err ? `: ${err}` : ""}`));
+      } catch (err) {
+        reject(new Error(`exec provider returned invalid JSON: ${err.message}`));
+      }
+    });
+    child.stdin.end(JSON.stringify({ protocolVersion: 1, provider: providerName, ids: [ref.id] }));
+  });
+}
+
+// src/bot/wizard.ts
+import { registerApp } from "@larksuiteoapi/node-sdk";
+import qrcode from "qrcode-terminal";
+async function runRegistrationWizard() {
+  console.log("\n\u672A\u68C0\u6D4B\u5230\u98DE\u4E66\u5E94\u7528\u914D\u7F6E\uFF0C\u8FDB\u5165\u626B\u7801\u521B\u5EFA\u5411\u5BFC\u3002\n");
+  const result = await registerApp({
+    onQRCodeReady: (info) => {
+      console.log("\u8BF7\u7528\u98DE\u4E66 App \u626B\u63CF\u4EE5\u4E0B\u4E8C\u7EF4\u7801\u5B8C\u6210\u5E94\u7528\u521B\u5EFA\uFF1A\n");
+      qrcode.generate(info.url, { small: true });
+      const mins = Math.max(1, Math.round(info.expireIn / 60));
+      console.log(`
+\u4E8C\u7EF4\u7801\u6709\u6548\u671F\uFF1A\u7EA6 ${mins} \u5206\u949F`);
+      console.log(`\u4E5F\u53EF\u4EE5\u76F4\u63A5\u5728\u6D4F\u89C8\u5668\u6253\u5F00\uFF1A${info.url}
+`);
+    },
+    onStatusChange: (info) => {
+      if (info.status === "domain_switched") {
+        console.log("\u8BC6\u522B\u5230\u56FD\u9645\u7248\u79DF\u6237\uFF0C\u5DF2\u5207\u6362\u5230 larksuite.com \u57DF\u540D\u3002");
+      } else if (info.status === "slow_down") {
+        console.log("\u8F6E\u8BE2\u901F\u5EA6\u8FC7\u5FEB\uFF0C\u5DF2\u81EA\u52A8\u964D\u901F\u3002");
+      }
+    }
+  });
+  const tenant = result.user_info?.tenant_brand ?? "feishu";
+  const operatorOpenId = result.user_info?.open_id;
+  console.log("\n\u2713 \u5E94\u7528\u521B\u5EFA\u6210\u529F");
+  console.log(`  App ID:  ${result.client_id}`);
+  console.log(`  Tenant:  ${tenant}`);
+  const cfg = {
+    accounts: { app: { id: result.client_id, secret: result.client_secret, tenant } }
+  };
+  if (operatorOpenId) {
+    cfg.preferences = { access: { admins: [operatorOpenId] } };
+    console.log(`  Admin:   ${operatorOpenId} (\u4F60\u81EA\u5DF1\uFF0C\u5DF2\u81EA\u52A8\u52A0\u5165\u7BA1\u7406\u5458\u540D\u5355)`);
+  } else {
+    console.log(
+      "  \u26A0\uFE0F \u672A\u62FF\u5230\u626B\u7801\u7528\u6237\u7684 open_id\uFF1B\u7BA1\u7406\u5458\u5217\u8868\u7559\u7A7A = \u6240\u6709\u7528\u6237\u90FD\u80FD\u79C1\u804A\u5EFA\u9879\u76EE\u3002\n     \u53EF\u7A0D\u540E\u5728 /config \u624B\u52A8\u8BBE\u7F6E\u7BA1\u7406\u5458\u3002"
+    );
+  }
+  console.log("");
+  return cfg;
+}
+
+// src/config/scopes.ts
+var REQUIRED_SCOPES = [
+  // Feishu has split the old umbrella scopes (`im:chat`, `im:message`) into
+  // fine-grained ones; new apps can only be granted the fine-grained names, so
+  // we list those — not the umbrellas (which would be un-grantable + would make
+  // the scope check false-positive).
+  "im:message.group_at_msg:readonly",
+  // @bot messages in project groups
+  "im:message.group_msg",
+  // ALL group messages (高敏感) — required for 免@ (respond without @)
+  "im:message.p2p_msg:readonly",
+  // DM console messages
+  "im:message:send_as_bot",
+  // reply_in_thread / send cards
+  "im:message.pins:write_only",
+  // Pin the welcome/command card to the group's Pins tab (im.v1.pin.create) — NOTE: plural `pins`
+  "im:message.reactions:write_only",
+  // ⏳/🫳 run-status emoji reactions (best-effort) — NOTE: plural `reactions`
+  "im:resource",
+  // upload/download images & resources
+  "im:chat:create",
+  // create the project group
+  "im:chat:update",
+  // transfer ownership on unbind
+  "im:chat.announcement:read",
+  // read group announcement blocks (list)
+  "im:chat.announcement:write_only",
+  // write group announcement blocks (create/delete)
+  "im:chat.top_notice:write_only",
+  // pin the announcement to the top banner
+  "im:chat.tabs:write_only",
+  // add the "👈 查看可使用的命令" chat tab on group create
+  "cardkit:card:write"
+  // interactive button cards (CardKit entities)
+];
+var COMMENT_SCOPES = [
+  "docs:document.comment:read",
+  "docs:document.comment:create",
+  "wiki:wiki:readonly"
+];
+var GRANT_SCOPES = [...REQUIRED_SCOPES, ...COMMENT_SCOPES];
+var HOSTS = {
+  feishu: "open.feishu.cn",
+  lark: "open.larksuite.com"
+};
+function buildScopeGrantUrl(appId, tenant, scopes = GRANT_SCOPES) {
+  const host = HOSTS[tenant];
+  const q = encodeURIComponent(scopes.join(","));
+  return `https://${host}/app/${encodeURIComponent(appId)}/auth?q=${q}`;
+}
+function buildEventConfigUrl(appId, tenant) {
+  return `https://${HOSTS[tenant]}/app/${encodeURIComponent(appId)}/event`;
+}
+
+// src/utils/feishu-auth.ts
+var ENDPOINTS = {
+  feishu: "https://open.feishu.cn",
+  lark: "https://open.larksuite.com"
+};
+async function validateAppCredentials(appId, appSecret, tenant) {
+  const base = ENDPOINTS[tenant];
+  let resp;
+  try {
+    resp = await fetch(`${base}/open-apis/auth/v3/tenant_access_token/internal`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ app_id: appId, app_secret: appSecret })
+    });
+  } catch (err) {
+    return { ok: false, reason: `\u7F51\u7EDC\u9519\u8BEF\uFF1A${err instanceof Error ? err.message : String(err)}` };
+  }
+  if (!resp.ok) return { ok: false, reason: `HTTP ${resp.status}` };
+  let data;
+  try {
+    data = await resp.json();
+  } catch {
+    return { ok: false, reason: "\u54CD\u5E94\u4E0D\u662F\u5408\u6CD5 JSON" };
+  }
+  if (data.code !== 0 || !data.tenant_access_token) {
+    return { ok: false, reason: `code=${data.code ?? "?"} msg=${data.msg ?? "<no msg>"}` };
+  }
+  const token = data.tenant_access_token;
+  const info = await fetchBotInfo(base, token).catch(() => void 0);
+  const missingScopes = await fetchMissingScopes(base, token).catch(() => void 0);
+  return { ok: true, botName: info?.bot?.app_name, botOpenId: info?.bot?.open_id, missingScopes };
+}
+async function fetchBotInfo(base, token) {
+  const resp = await fetch(`${base}/open-apis/bot/v3/info`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!resp.ok) return void 0;
+  return await resp.json();
+}
+async function fetchMissingScopes(base, token) {
+  const resp = await fetch(`${base}/open-apis/application/v6/scopes`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!resp.ok) return void 0;
+  const body = await resp.json();
+  if (!body.data?.scopes) return void 0;
+  const granted = new Set(body.data.scopes.filter((s) => s.grant_status === 1).map((s) => s.scope_name));
+  return REQUIRED_SCOPES.filter((s) => !granted.has(s));
+}
+
+// src/utils/open-url.ts
+import { spawn as spawn2 } from "child_process";
+import { platform } from "os";
+function openUrl(url) {
+  if (!process.stdout.isTTY) return false;
+  let cmd;
+  let args;
+  switch (platform()) {
+    case "darwin":
+      cmd = "open";
+      args = [url];
+      break;
+    case "win32":
+      cmd = "cmd";
+      args = ["/c", "start", "", url];
+      break;
+    default:
+      cmd = "xdg-open";
+      args = [url];
+  }
+  try {
+    const child = spawn2(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/logger.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { createWriteStream, mkdirSync } from "fs";
+import { open, readdir, rm, stat } from "fs/promises";
+import { join as join6 } 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"
+]);
+var als = new AsyncLocalStorage();
+var stream = null;
+var currentDate = "";
+function todayKey() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function logsDir() {
+  return join6(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(join6(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 [k, v] of Object.entries(fields)) {
+    if (RESERVED_KEYS.has(k)) {
+      entry[`_${k}`] = v;
+    } else {
+      entry[k] = 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 k of keys) {
+    const v = fields[k];
+    if (v === void 0 || v === null) continue;
+    if (k === "stack") continue;
+    if (typeof v === "string") {
+      parts.push(`${k}=${v.length > 80 ? `${v.slice(0, 80)}\u2026` : v}`);
+    } else if (typeof v === "number" || typeof v === "boolean") {
+      parts.push(`${k}=${v}`);
+    } else {
+      try {
+        const str = JSON.stringify(v);
+        parts.push(`${k}=${str.length > 80 ? `${str.slice(0, 80)}\u2026` : str}`);
+      } catch {
+        parts.push(`${k}=?`);
+      }
+    }
+  }
+  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);
+}
+function newTraceId() {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+// src/bot/onboarding.ts
+function ensureCodex() {
+  if (resolveCodexBin()) return true;
+  console.error(
+    "\u2717 \u672A\u627E\u5230 codex CLI\u3002\u8BF7\u5148\u5B89\u88C5 Codex \u5E76\u767B\u5F55\uFF1A\n    \u2022 \u5B89\u88C5\uFF1Anpm i -g @openai/codex\uFF08\u6216\u5B89\u88C5 Codex.app\uFF0C\u6216\u7528 CODEX_BIN \u6307\u5411\u5DF2\u6709\u4E8C\u8FDB\u5236\uFF09\n    \u2022 \u767B\u5F55\uFF1Acodex login\n  \u7136\u540E\u91CD\u8DD1\u3002\u53EF\u5148\u7528 `feishu-codex-bridge doctor` \u81EA\u68C0\u3002"
+  );
+  return false;
+}
+async function ensureOnboarded(opts = {}) {
+  if (!ensureCodex()) return null;
+  const reg = await ensureRegistry();
+  const entry = currentBot(reg);
+  if (!entry) {
+    if (!opts.allowCreate) {
+      console.error("\u2717 \u5C1A\u672A\u914D\u7F6E\u4EFB\u4F55\u98DE\u4E66\u673A\u5668\u4EBA\u3002\u8BF7\u5148\u8FD0\u884C `feishu-codex-bridge bot init`\uFF08\u6216\u524D\u53F0 `run`\uFF09\u626B\u7801\u521B\u5EFA\u3002");
+      return null;
+    }
+    return registerNewBot("default");
+  }
+  useBotDir(entry.appId);
+  const cfg = await loadConfig();
+  if (!isComplete(cfg)) {
+    console.error(`\u2717 \u5F53\u524D\u673A\u5668\u4EBA\u300C${entry.name}\u300D(${entry.appId}) \u914D\u7F6E\u7F3A\u5931\u6216\u635F\u574F\u3002\u53EF \`bot rm ${entry.name}\` \u540E\u91CD\u65B0 \`bot init\`\u3002`);
+    return null;
+  }
+  const r = await validateAndReport(cfg);
+  if (r === null) return null;
+  return { cfg, secret: r.secret, missingScopes: r.missingScopes };
+}
+async function registerNewBot(desiredName) {
+  if (!process.stdout.isTTY) {
+    console.error(
+      "\u2717 \u5F53\u524D\u4E0D\u662F\u4EA4\u4E92\u5F0F\u7EC8\u7AEF\uFF0C\u65E0\u6CD5\u626B\u7801\u521B\u5EFA\u98DE\u4E66\u5E94\u7528\u3002\n  \u8BF7\u5728\u7EC8\u7AEF\u524D\u53F0\u8FD0\u884C `feishu-codex-bridge bot init`\uFF08\u6216 `run` / `start`\uFF09\u626B\u7801 onboarding\u3002"
+    );
+    return null;
+  }
+  const wizardCfg = await runRegistrationWizard();
+  const app = wizardCfg.accounts.app;
+  if (typeof app.secret !== "string") {
+    console.error("\u2717 \u5411\u5BFC\u672A\u8FD4\u56DE\u660E\u6587\u5BC6\u94A5\uFF0C\u65E0\u6CD5\u7EE7\u7EED\u3002");
+    return null;
+  }
+  const v = await validateAppCredentials(app.id, app.secret, app.tenant);
+  if (!v.ok) {
+    console.error(`\u2717 \u5E94\u7528\u51ED\u636E\u6821\u9A8C\u5931\u8D25\uFF1A${v.reason}`);
+    return null;
+  }
+  await setSecret(secretKeyForApp(app.id), app.secret);
+  useBotDir(app.id);
+  const cfg = await buildEncryptedAccountConfig(app.id, app.tenant, wizardCfg.preferences);
+  await saveConfig(cfg);
+  const reg = await loadBots();
+  const name = uniqueName(reg, desiredName ?? v.botName ?? "default");
+  await addBot({ name, appId: app.id, tenant: app.tenant, botName: v.botName, createdAt: Date.now() });
+  console.log(`\u2713 \u5DF2\u521B\u5EFA\u673A\u5668\u4EBA\u300C${name}\u300D  bot: ${v.botName ?? "-"}  appId: ${app.id}`);
+  log.info("onboard", "bot-created", { name, appId: app.id, bot: v.botName ?? null });
+  showScopeGrant(cfg, v.missingScopes);
+  const secret = await resolveAppSecret(cfg);
+  return { cfg, secret, missingScopes: v.missingScopes };
+}
+async function validateAndReport(cfg) {
+  const secret = await resolveAppSecret(cfg);
+  const v = await validateAppCredentials(cfg.accounts.app.id, secret, cfg.accounts.app.tenant);
+  if (!v.ok) {
+    console.error(`\u2717 \u5E94\u7528\u51ED\u636E\u6821\u9A8C\u5931\u8D25\uFF1A${v.reason}`);
+    console.error("  \u5E94\u7528\u53EF\u80FD\u88AB\u7981\u7528/\u672A\u53D1\u5E03\uFF1B\u53EF\u91CD\u8DD1 `feishu-codex-bridge bot init` \u91CD\u65B0\u626B\u7801\u3002");
+    return null;
+  }
+  console.log(`\u2713 \u51ED\u636E\u6821\u9A8C\u901A\u8FC7  bot: ${v.botName ?? "-"}  appId: ${cfg.accounts.app.id}`);
+  log.info("onboard", "credentials-ok", { appId: cfg.accounts.app.id, bot: v.botName ?? null });
+  showScopeGrant(cfg, v.missingScopes);
+  return { secret, missingScopes: v.missingScopes };
+}
+async function confirmReadyForDaemon(result) {
+  if (!process.stdin.isTTY) return true;
+  const { app } = result.cfg.accounts;
+  let missing = result.missingScopes;
+  while (missing && missing.length > 0) {
+    const url = buildScopeGrantUrl(app.id, app.tenant);
+    console.log(`
+\u23F3 \u8FD8\u5DEE ${missing.length} \u9879\u6743\u9650\u672A\u5F00\u901A\uFF0C\u540E\u53F0\u670D\u52A1\u6682\u4E0D\u5B89\u88C5\u3002`);
+    console.log(`   \u5F00\u901A\u9875\uFF1A${url}`);
+    await promptEnter("   \u5728\u6D4F\u89C8\u5668\u52FE\u9009\u5168\u90E8\u6743\u9650\u5E76\u786E\u8BA4\u540E\uFF0C\u6309 Enter \u91CD\u65B0\u68C0\u6D4B\uFF08Ctrl+C \u53D6\u6D88\uFF09\u2026 ");
+    const v = await validateAppCredentials(app.id, result.secret, app.tenant);
+    if (!v.ok) {
+      console.error(`\u2717 \u51ED\u636E\u6821\u9A8C\u5931\u8D25\uFF1A${v.reason}`);
+      return false;
+    }
+    missing = v.missingScopes;
+    if (missing && missing.length > 0) console.log(`   \u4ECD\u7F3A\uFF1A${missing.join("  ")}`);
+  }
+  console.log("\u2713 \u6743\u9650\u5DF2\u5F00\u901A\u3002");
+  const eventUrl = buildEventConfigUrl(app.id, app.tenant);
+  const opened = openUrl(eventUrl);
+  console.log("\n\u6700\u540E\u8FD9\u51E0\u6B65\u98DE\u4E66\u6CA1\u6709 API/\u6DF1\u94FE\u53EF\u4EE3\u529E\uFF08\u8FDE\u67E5\u8BE2\u8BA2\u9605\u72B6\u6001\u7684\u63A5\u53E3\u90FD\u6CA1\u6709\uFF09\uFF0C\u9700\u4F60\u624B\u52A8\u70B9\uFF1A\n");
+  console.log(`  \u30101\u3011\u4E8B\u4EF6\u4E0E\u56DE\u8C03\uFF08${opened ? "\u5DF2\u81EA\u52A8\u6253\u5F00" : "\u6253\u5F00\u4E0B\u9762\u94FE\u63A5"}\uFF09\uFF1A${eventUrl}`);
+  console.log("       \u8FD9\u9875\u9876\u90E8\u6709\u4E09\u4E2A\u6807\u7B7E\uFF1A\u300C\u4E8B\u4EF6\u914D\u7F6E\u300D\u300C\u56DE\u8C03\u914D\u7F6E\u300D\u300C\u52A0\u5BC6\u7B56\u7565\u300D\u3002");
+  console.log("       \u2022 \u5207\u5230\u300C\u4E8B\u4EF6\u914D\u7F6E\u300D\u6807\u7B7E \u2192 \u300C\u8BA2\u9605\u65B9\u5F0F\u300D\u6539\u300C\u957F\u8FDE\u63A5\u300D\u2192 \u70B9\u300C\u6DFB\u52A0\u4E8B\u4EF6\u300D\u641C\u5E76\u52FE\u9009\uFF1A");
+  console.log("           im.message.receive_v1\uFF08\u63A5\u6536\u6D88\u606F\uFF09\u3001application.bot.menu_v6\uFF08\u673A\u5668\u4EBA\u83DC\u5355\uFF09");
+  console.log("       \u2022 \uFF08\u53EF\u9009\uFF09\u60F3\u8981\u300C\u5728\u98DE\u4E66\u6587\u6863\u8BC4\u8BBA\u91CC @\u673A\u5668\u4EBA\u5C31\u81EA\u52A8\u56DE\u590D\u300D\uFF0C\u518D\u52A0\u8FD9\u4E00\u4E2A\u4E8B\u4EF6\uFF1A");
+  console.log("           drive.notice.comment_add_v1\uFF08\u4E91\u6587\u6863\u65B0\u589E\u8BC4\u8BBA\uFF09");
+  console.log("           \u5B83\u4F9D\u8D56\u300C\u6587\u6863\u8BC4\u8BBA\u300D\u6743\u9650\uFF08docs:document.comment:read / :create\uFF0C\u6388\u6743\u94FE\u63A5\u5DF2\u9884\u52FE\u9009\uFF09\uFF1B\u4E0D\u52A0\u5219\u8BE5\u529F\u80FD\u9759\u9ED8\u5173\u95ED\u3002");
+  console.log("       \u2022 \u5207\u5230\u300C\u56DE\u8C03\u914D\u7F6E\u300D\u6807\u7B7E \u2192 \u300C\u8BA2\u9605\u65B9\u5F0F\u300D\u6539\u300C\u957F\u8FDE\u63A5\u300D\u2192 \u70B9\u300C\u6DFB\u52A0\u56DE\u8C03\u300D\u52FE\u9009\uFF1A");
+  console.log("           card.action.trigger\uFF08\u5361\u7247\u56DE\u4F20\u4EA4\u4E92\uFF09");
+  console.log("           \u26A0\uFE0F \u5B83\u662F\u300C\u56DE\u8C03\u300D\u4E0D\u662F\u300C\u4E8B\u4EF6\u300D\u2014\u2014\u5728\u4E0A\u9762\u300C\u6DFB\u52A0\u4E8B\u4EF6\u300D\u91CC\u641C\u4E0D\u5230\uFF0C\u5FC5\u987B\u5207\u5230\u300C\u56DE\u8C03\u914D\u7F6E\u300D\u8FD9\u4E2A\u6807\u7B7E\u3002");
+  console.log("  \u30102\u3011\u5DE6\u4FA7\u680F\u300C\u5E94\u7528\u53D1\u5E03 \u2192 \u7248\u672C\u7BA1\u7406\u4E0E\u53D1\u5E03\u300D\u2192 \u521B\u5EFA\u4E00\u4E2A\u7248\u672C\u5E76\u53D1\u5E03\u3002");
+  console.log("\n  \uFF08\u4FDD\u5B58\u300C\u957F\u8FDE\u63A5\u300D\u8BA2\u9605\u65B9\u5F0F\u8981\u6C42\u957F\u8FDE\u63A5\u5728\u7EBF\uFF1B\u82E5\u63D0\u793A\u8FDE\u63A5\u672A\u5EFA\u7ACB\uFF0C");
+  console.log("    \u5148\u5F00\u53E6\u4E00\u4E2A\u7EC8\u7AEF\u8DD1 `feishu-codex-bridge run` \u628A\u6865\u8FDE\u4E0A\uFF0C\u518D\u56DE\u8FD9\u9875\u4FDD\u5B58\u3002\uFF09");
+  await promptEnter("\n\u4EE5\u4E0A\u90FD\u70B9\u5B8C\u540E\u6309 Enter \u5B89\u88C5\u540E\u53F0\u670D\u52A1\uFF08Ctrl+C \u53D6\u6D88\uFF09\u2026 ");
+  return true;
+}
+async function promptEnter(message) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await rl.question(message);
+  } finally {
+    rl.close();
+  }
+}
+function showScopeGrant(cfg, missingScopes) {
+  if (missingScopes && missingScopes.length > 0) {
+    const url = buildScopeGrantUrl(cfg.accounts.app.id, cfg.accounts.app.tenant);
+    const rule = "\u2500".repeat(64);
+    const opened = openUrl(url);
+    console.log(`
+${rule}`);
+    console.log(`\u26A0\uFE0F  \u8FD8\u5DEE ${missingScopes.length} \u9879\u6743\u9650\u672A\u5F00\u901A \u2014\u2014 \u4E0D\u5F00\u901A\u5219\u6536\u4E0D\u5230\u6D88\u606F\u3001\u53D1\u4E0D\u51FA\u5361\u7247`);
+    console.log("   \u98DE\u4E66\u6CA1\u6709\u300C\u626B\u7801\u5373\u6388\u6743\u300D\u7684\u63A5\u53E3\uFF0C\u53EA\u80FD\u5728\u6D4F\u89C8\u5668\u5F00\u901A\uFF08\u5373\u65F6\u751F\u6548\uFF0C\u65E0\u9700\u91CD\u542F\uFF09\uFF1A");
+    console.log(
+      opened ? "\n   \u{1F310} \u5DF2\u81EA\u52A8\u6253\u5F00\u6D4F\u89C8\u5668\u6388\u6743\u9875\u3002\u82E5\u6CA1\u5F39\u51FA\uFF0C\u624B\u52A8\u590D\u5236\u4E0B\u9762\u94FE\u63A5\u6253\u5F00\uFF1A" : "\n   \u{1F310} \u5728\u6D4F\u89C8\u5668\u6253\u5F00\u4E0B\u9762\u94FE\u63A5\uFF0C\u52FE\u9009\u5168\u90E8\u6743\u9650 \u2192 \u786E\u8BA4\uFF1A"
+    );
+    console.log(`
+   \u{1F449} ${url}
+`);
+    console.log(`   \uFF08\u672C\u6B21\u7F3A\u5931\uFF1A${missingScopes.join("  ")}\uFF09`);
+    console.log(`${rule}
+`);
+  } else if (missingScopes === void 0) {
+    log.info("onboard", "scope-check-skipped", { reason: "scope list unavailable" });
+  }
+}
+
+// src/bot/bridge.ts
+import { createLarkChannel, Domain } from "@larksuiteoapi/node-sdk";
+
+// src/agent/codex-appserver/app-server-client.ts
+import { spawn as spawn3 } from "child_process";
+var AsyncQueue = class {
+  items = [];
+  waiters = [];
+  closed = false;
+  push(item) {
+    const w = this.waiters.shift();
+    if (w) w({ value: item, done: false });
+    else this.items.push(item);
+  }
+  close() {
+    this.closed = true;
+    while (this.waiters.length) this.waiters.shift()({ value: void 0, done: true });
+  }
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      if (this.items.length) {
+        yield this.items.shift();
+        continue;
+      }
+      if (this.closed) return;
+      const next = await new Promise((resolve3) => this.waiters.push(resolve3));
+      if (next.done) return;
+      yield next.value;
+    }
+  }
+};
+var AppServerClient = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  child = null;
+  buf = "";
+  nextId = 0;
+  pending = /* @__PURE__ */ new Map();
+  notifications = new AsyncQueue();
+  closed = false;
+  get pid() {
+    return this.child?.pid;
+  }
+  /** spawn + initialize handshake. Throws if spawn/handshake fails. */
+  async connect() {
+    const child = spawn3(this.opts.bin, ["app-server", "--listen", "stdio://"], {
+      cwd: this.opts.cwd,
+      env: { ...process.env, ...this.opts.env, FEISHU_CODEX_BRIDGE: "1" },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    log.info("agent", "spawn", { pid: child.pid ?? null, cwd: this.opts.cwd });
+    child.stdout.on("data", (d) => this.onStdout(d));
+    child.stderr.on("data", (d) => {
+      const line = d.toString("utf8").trim();
+      if (line) log.warn("agent", "stderr", { line: line.slice(0, 200) });
+    });
+    child.on("exit", (code, signal) => {
+      log.info("agent", "exit", { pid: child.pid ?? null, code, signal });
+      this.failAllPending(new Error(`app-server exited (code=${code} signal=${signal})`));
+      this.notifications.close();
+    });
+    child.on("error", (err) => this.failAllPending(err));
+    await this.request("initialize", {
+      clientInfo: { name: this.opts.clientName ?? "feishu-codex-bridge", version: "0.0.1" },
+      capabilities: null
+    });
+    this.notify("initialized");
+  }
+  request(method, params) {
+    if (this.closed || !this.child) return Promise.reject(new Error("app-server client closed"));
+    const id = ++this.nextId;
+    const payload = `${JSON.stringify({ jsonrpc: "2.0", id, method, params: params ?? {} })}
+`;
+    return new Promise((resolve3, reject) => {
+      this.pending.set(id, { resolve: resolve3, reject });
+      this.child.stdin.write(payload, (err) => {
+        if (err) {
+          this.pending.delete(id);
+          reject(err);
+        }
+      });
+    });
+  }
+  notify(method, params) {
+    if (this.closed || !this.child) return;
+    this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params: params ?? {} })}
+`);
+  }
+  /** async-iterate server notifications (closes when the process exits). */
+  stream() {
+    return this.notifications;
+  }
+  async close(graceMs = 4e3) {
+    if (this.closed) return;
+    this.closed = true;
+    const child = this.child;
+    if (!child || child.exitCode !== null) return;
+    child.kill("SIGTERM");
+    await new Promise((resolve3) => {
+      const t = setTimeout(() => {
+        if (child.exitCode === null) child.kill("SIGKILL");
+        resolve3();
+      }, graceMs);
+      child.once("exit", () => {
+        clearTimeout(t);
+        resolve3();
+      });
+    });
+  }
+  onStdout(d) {
+    this.buf += d.toString("utf8");
+    let nl;
+    while ((nl = this.buf.indexOf("\n")) !== -1) {
+      const line = this.buf.slice(0, nl);
+      this.buf = this.buf.slice(nl + 1);
+      if (!line.trim()) continue;
+      this.handleLine(line);
+    }
+  }
+  handleLine(line) {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      log.warn("agent", "nonjson", { line: line.slice(0, 120) });
+      return;
+    }
+    if (typeof msg.id === "number" && ("result" in msg || "error" in msg) && !("method" in msg)) {
+      const p = this.pending.get(msg.id);
+      if (!p) return;
+      this.pending.delete(msg.id);
+      if ("error" in msg && msg.error) {
+        const e = msg.error;
+        p.reject(new Error(e.message ?? "JSON-RPC error"));
+      } else {
+        p.resolve(msg.result);
+      }
+      return;
+    }
+    if (typeof msg.id === "number" && typeof msg.method === "string") {
+      this.child?.stdin.write(
+        `${JSON.stringify({ jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: "not handled" } })}
+`
+      );
+      return;
+    }
+    if (typeof msg.method === "string") {
+      this.notifications.push(msg);
+    }
+  }
+  failAllPending(err) {
+    for (const p of this.pending.values()) p.reject(err);
+    this.pending.clear();
+  }
+};
+
+// src/agent/codex-appserver/event-map.ts
+function mapNotification(n) {
+  switch (n.method) {
+    case "thread/started":
+      return { type: "system", threadId: n.params.thread.id };
+    case "turn/started":
+      return { type: "turn_started", turnId: n.params.turn.id };
+    case "item/agentMessage/delta":
+      return { type: "text_delta", itemId: n.params.itemId, delta: n.params.delta };
+    case "item/reasoning/textDelta":
+      return { type: "thinking_delta", itemId: n.params.itemId, delta: n.params.delta };
+    case "item/started":
+      return mapItemStart(n.params.item);
+    case "item/completed":
+      return mapItemComplete(n.params.item);
+    case "turn/completed":
+      return { type: "done", turnId: n.params.turn.id };
+    case "error":
+      return { type: "error", message: n.params.error.message, willRetry: n.params.willRetry };
+    default:
+      return null;
+  }
+}
+function mapItemStart(item) {
+  switch (item.type) {
+    case "commandExecution":
+      return { type: "tool_use", itemId: item.id, title: item.command, detail: String(item.cwd) };
+    case "fileChange":
+      return { type: "tool_use", itemId: item.id, title: "\u7F16\u8F91\u6587\u4EF6" };
+    case "webSearch":
+      return { type: "tool_use", itemId: item.id, title: "\u8054\u7F51\u641C\u7D22" };
+    case "mcpToolCall":
+    case "dynamicToolCall":
+      return { type: "tool_use", itemId: item.id, title: "\u5DE5\u5177\u8C03\u7528" };
+    default:
+      return null;
+  }
+}
+function mapItemComplete(item) {
+  switch (item.type) {
+    case "agentMessage":
+      return { type: "text", itemId: item.id, text: item.text };
+    case "reasoning": {
+      const text = item.content.length ? item.content.join("\n") : item.summary.join("\n");
+      return { type: "thinking", itemId: item.id, text };
+    }
+    case "commandExecution":
+      return {
+        type: "tool_result",
+        itemId: item.id,
+        output: item.aggregatedOutput ?? void 0,
+        exitCode: item.exitCode
+      };
+    case "fileChange":
+    case "webSearch":
+    case "mcpToolCall":
+    case "dynamicToolCall":
+      return { type: "tool_result", itemId: item.id };
+    default:
+      return null;
+  }
+}
+
+// src/agent/codex-appserver/backend.ts
+var APPROVAL_POLICY = "never";
+var SANDBOX = "danger-full-access";
+var READ_HISTORY_TIMEOUT_MS = 2e4;
+function withDeadline(p, ms, label) {
+  return new Promise((resolve3, reject) => {
+    const t = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    p.then(
+      (v) => {
+        clearTimeout(t);
+        resolve3(v);
+      },
+      (e) => {
+        clearTimeout(t);
+        reject(e);
+      }
+    );
+  });
+}
+function toUserInput(input2) {
+  const out = [];
+  if (input2.text) out.push({ type: "text", text: input2.text, text_elements: [] });
+  for (const path of input2.images ?? []) out.push({ type: "localImage", path });
+  return out;
+}
+var CodexThread = class {
+  constructor(client, codexThreadId, model, effort) {
+    this.client = client;
+    this.codexThreadId = codexThreadId;
+    this.model = model;
+    this.effort = effort;
+  }
+  client;
+  codexThreadId;
+  model;
+  effort;
+  currentTurnId;
+  runStreamed(input2, turn) {
+    const self = this;
+    this.currentTurnId = void 0;
+    if (turn?.model) this.model = turn.model;
+    if (turn?.effort) this.effort = turn.effort;
+    async function* gen() {
+      const params = {
+        threadId: self.codexThreadId,
+        input: toUserInput(input2)
+      };
+      if (self.model) params.model = self.model;
+      if (self.effort) params.effort = self.effort;
+      let startError;
+      const startFailed = new Promise((resolve3) => {
+        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" });
+          resolve3("start-failed");
+        });
+      });
+      const stream2 = self.client.stream()[Symbol.asyncIterator]();
+      while (true) {
+        const step = await Promise.race([stream2.next(), startFailed]);
+        if (step === "start-failed") {
+          yield { type: "error", message: startError?.message ?? "turn/start \u8BF7\u6C42\u5931\u8D25", willRetry: false };
+          return;
+        }
+        if (step.done) return;
+        const ev = mapNotification(step.value);
+        if (!ev) continue;
+        if (ev.type === "turn_started") self.currentTurnId = ev.turnId;
+        yield ev;
+        if (ev.type === "done") return;
+        if (ev.type === "error" && !ev.willRetry) return;
+      }
+    }
+    return { events: gen(), turnId: () => self.currentTurnId };
+  }
+  async steer(input2, expectedTurnId) {
+    await this.client.request("turn/steer", {
+      threadId: this.codexThreadId,
+      expectedTurnId,
+      input: toUserInput(input2)
+    });
+  }
+  async abort(turnId) {
+    await this.client.request("turn/interrupt", { threadId: this.codexThreadId, turnId });
+  }
+  async close() {
+    await this.client.close();
+  }
+};
+var CodexAppServerBackend = class {
+  id = "codex-appserver";
+  displayName = "Codex (app-server)";
+  modelCache = null;
+  async isAvailable() {
+    const bin = resolveCodexBin();
+    return bin !== null && codexVersion(bin) !== null;
+  }
+  async listModels() {
+    if (this.modelCache) return this.modelCache;
+    const bin = resolveCodexBin();
+    if (!bin) return STATIC_MODELS;
+    const client = new AppServerClient({ bin, cwd: process.cwd(), clientName: "feishu-codex-bridge-models" });
+    try {
+      await client.connect();
+      const res = await client.request("model/list", { limit: 50 });
+      const models = (res.data ?? []).map(mapModel);
+      this.modelCache = models.length ? models : STATIC_MODELS;
+      return this.modelCache;
+    } catch (err) {
+      log.fail("agent", err, { phase: "model/list" });
+      return STATIC_MODELS;
+    } finally {
+      await client.close();
+    }
+  }
+  async listThreads(cwd, limit = 15) {
+    const bin = resolveCodexBin();
+    if (!bin) return [];
+    const client = new AppServerClient({ bin, cwd, clientName: "feishu-codex-bridge-threads" });
+    try {
+      await client.connect();
+      const res = await client.request("thread/list", {
+        cwd,
+        limit,
+        sortKey: "created_at",
+        sortDirection: "desc"
+      });
+      return (res.data ?? []).filter((t) => !t.ephemeral).map((t) => ({
+        codexThreadId: t.id,
+        preview: t.preview ?? "",
+        createdAt: t.createdAt ?? 0,
+        updatedAt: t.updatedAt ?? t.createdAt ?? 0,
+        name: t.name ?? void 0
+      }));
+    } catch (err) {
+      log.fail("agent", err, { phase: "thread/list" });
+      return [];
+    } finally {
+      await client.close();
+    }
+  }
+  async readHistory(cwd, codexThreadId, maxTurns = 10) {
+    const empty = { turns: [], totalTurns: 0 };
+    const bin = resolveCodexBin();
+    if (!bin) return empty;
+    const client = new AppServerClient({ bin, cwd, clientName: "feishu-codex-bridge-history" });
+    try {
+      const read3 = (async () => {
+        await client.connect();
+        return client.request("thread/read", { threadId: codexThreadId, includeTurns: true });
+      })();
+      read3.catch(() => void 0);
+      const res = await withDeadline(read3, READ_HISTORY_TIMEOUT_MS, "thread/read");
+      const thread = res.thread;
+      const all = (Array.isArray(thread?.turns) ? thread.turns : []).map(mapTurn).filter((t) => t.userText || t.assistantText || t.tools.length);
+      const totalTurns = all.length;
+      const turns = totalTurns > maxTurns ? all.slice(totalTurns - maxTurns) : all;
+      return {
+        turns,
+        totalTurns,
+        name: thread?.name ?? void 0,
+        preview: thread?.preview ?? void 0,
+        createdAt: thread?.createdAt,
+        updatedAt: thread?.updatedAt
+      };
+    } catch (err) {
+      log.fail("agent", err, { phase: "thread/read", codexThreadId });
+      return empty;
+    } finally {
+      await client.close();
+    }
+  }
+  async startThread(opts) {
+    const client = await this.spawn(opts.cwd);
+    const res = await client.request("thread/start", {
+      cwd: opts.cwd,
+      approvalPolicy: APPROVAL_POLICY,
+      sandbox: SANDBOX,
+      ...opts.model ? { model: opts.model } : {}
+    });
+    return new CodexThread(client, res.thread.id, opts.model, opts.effort);
+  }
+  async resumeThread(opts) {
+    const client = await this.spawn(opts.cwd);
+    const res = await client.request("thread/resume", {
+      threadId: opts.codexThreadId,
+      cwd: opts.cwd,
+      approvalPolicy: APPROVAL_POLICY,
+      sandbox: SANDBOX,
+      ...opts.model ? { model: opts.model } : {}
+    });
+    return new CodexThread(client, res.thread.id, opts.model, opts.effort);
+  }
+  async spawn(cwd) {
+    const bin = resolveCodexBin();
+    if (!bin) throw new Error("codex CLI not found (set CODEX_BIN or install @openai/codex)");
+    const client = new AppServerClient({ bin, cwd });
+    await client.connect();
+    return client;
+  }
+};
+function isBoilerplateUserText(text) {
+  const t = text.trimStart();
+  return t.startsWith("<environment_context>") || t.startsWith("# AGENTS.md instructions");
+}
+function mapTurn(turn) {
+  const userParts = [];
+  const assistantParts = [];
+  const reasoningParts = [];
+  const tools = [];
+  for (const item of turn.items ?? []) {
+    switch (item.type) {
+      case "userMessage": {
+        const text = item.content.map((c) => c.type === "text" ? c.text : c.type === "mention" ? `@${c.name}` : "").join("").trim();
+        if (text && !isBoilerplateUserText(text)) userParts.push(text);
+        break;
+      }
+      case "agentMessage":
+        if (item.text.trim()) assistantParts.push(item.text);
+        break;
+      case "reasoning": {
+        const r = (item.content.length ? item.content : item.summary).join("\n").trim();
+        if (r) reasoningParts.push(r);
+        break;
+      }
+      case "commandExecution":
+        tools.push({
+          title: item.command,
+          output: item.aggregatedOutput ?? void 0,
+          exitCode: item.exitCode,
+          failed: item.status === "failed" || item.status === "declined" || (item.exitCode ?? 0) !== 0
+        });
+        break;
+      case "fileChange":
+        tools.push({ title: "\u7F16\u8F91\u6587\u4EF6", failed: item.status === "failed" || item.status === "declined" });
+        break;
+      case "webSearch":
+        tools.push({ title: `\u8054\u7F51\u641C\u7D22\uFF1A${item.query}` });
+        break;
+      case "mcpToolCall":
+        tools.push({ title: `${item.server} / ${item.tool}`, failed: item.status === "failed" || Boolean(item.error) });
+        break;
+      case "dynamicToolCall":
+        tools.push({ title: item.tool, failed: item.status === "failed" || item.success === false });
+        break;
+      // plan / contextCompaction / review-mode / image* — omitted from the digest
+      default:
+        break;
+    }
+  }
+  return {
+    userText: userParts.join("\n\n"),
+    assistantText: assistantParts.join("\n\n"),
+    reasoning: reasoningParts.join("\n\n"),
+    tools,
+    startedAt: turn.startedAt ?? void 0
+  };
+}
+function mapModel(m) {
+  return {
+    id: m.id,
+    displayName: m.displayName ?? m.id,
+    description: m.description ?? "",
+    hidden: m.hidden ?? false,
+    isDefault: m.isDefault ?? false,
+    supportedEfforts: (m.supportedReasoningEfforts ?? []).map((e) => e.reasoningEffort),
+    defaultEffort: m.defaultReasoningEffort ?? "medium"
+  };
+}
+var STATIC_MODELS = [
+  {
+    id: "gpt-5.5",
+    displayName: "GPT-5.5",
+    description: "\u9ED8\u8BA4\u6A21\u578B",
+    hidden: false,
+    isDefault: true,
+    supportedEfforts: ["low", "medium", "high"],
+    defaultEffort: "medium"
+  }
+];
+
+// src/agent/index.ts
+function createBackend() {
+  return new CodexAppServerBackend();
+}
+
+// src/card/dispatcher.ts
+var CardDispatcher = class {
+  constructor(channel, cfg) {
+    this.channel = channel;
+    this.cfg = cfg;
+  }
+  channel;
+  cfg;
+  handlers = /* @__PURE__ */ new Map();
+  /** Register a handler for an action id. Last registration wins. */
+  on(actionId, handler) {
+    this.handlers.set(actionId, handler);
+    return this;
+  }
+  /** Bound handler suitable for `channel.on('cardAction', ...)`. */
+  handle = async (evt) => {
+    const value = evt.action?.value ?? {};
+    const actionId = typeof value.a === "string" ? value.a : void 0;
+    if (!actionId) {
+      log.info("card", "action-unkeyed", { tag: evt.action?.tag });
+      return;
+    }
+    const handler = this.handlers.get(actionId);
+    if (!handler) {
+      log.info("card", "action-nohandler", { actionId });
+      return;
+    }
+    const formValue = evt.raw?.action?.form_value;
+    await withTrace({ chatId: evt.chatId, msgId: evt.messageId }, async () => {
+      log.info("card", "action", { actionId, by: evt.operator?.openId?.slice(-6) });
+      try {
+        await handler({
+          channel: this.channel,
+          cfg: this.cfg,
+          evt,
+          actionId,
+          option: evt.action?.option,
+          value,
+          formValue
+        });
+      } catch (err) {
+        log.fail("card", err, { actionId });
+      }
+    });
+  };
+};
+
+// 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 k of Object.keys(obj)) visit(obj[k]);
+  };
+  visit(card2);
+}
+async function sendManagedCard(channel, chatId, card2, replyTo, replyInThread = false) {
+  stampRenderToken(card2);
+  const created = await channel.rawClient.cardkit.v1.card.create({
+    data: { type: "card_json", data: JSON.stringify(card2) }
+  });
+  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: "chat_id" },
+      data: { receive_id: chatId, 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 };
+}
+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/card/run-state.ts
+var initialState = {
+  blocks: [],
+  reasoning: [],
+  reasoningActive: false,
+  footer: "thinking",
+  terminal: "running"
+};
+function reasoningContent(state) {
+  return state.reasoning.map((r) => r.text).filter((t) => t.trim()).join("\n\n");
+}
+function finalMessageText(state) {
+  for (let i = state.blocks.length - 1; i >= 0; i--) {
+    const b = state.blocks[i];
+    if (b && b.kind === "text" && b.content.trim()) return b.content.trim();
+  }
+  return "";
+}
+function closeStreamingText(blocks) {
+  return blocks.map((b) => b.kind === "text" && b.streaming ? { ...b, streaming: false } : b);
+}
+function upsertText(blocks, id, mutate) {
+  const idx = blocks.findIndex((b) => b.kind === "text" && b.id === id);
+  if (idx === -1) {
+    return [...blocks, { kind: "text", id, content: mutate(""), streaming: true }];
+  }
+  const prev = blocks[idx];
+  const next = { ...prev, content: mutate(prev.content) };
+  return [...blocks.slice(0, idx), next, ...blocks.slice(idx + 1)];
+}
+function upsertReasoning(items, id, mutate) {
+  const idx = items.findIndex((r) => r.id === id);
+  if (idx === -1) return [...items, { id, text: mutate("") }];
+  const prev = items[idx];
+  const next = { id: prev.id, text: mutate(prev.text) };
+  return [...items.slice(0, idx), next, ...items.slice(idx + 1)];
+}
+function reduce(state, evt) {
+  switch (evt.type) {
+    case "text_delta":
+      return {
+        ...state,
+        blocks: upsertText(state.blocks, evt.itemId, (prev) => prev + evt.delta),
+        reasoningActive: false,
+        footer: "streaming"
+      };
+    case "text": {
+      const idx = state.blocks.findIndex((b) => b.kind === "text" && b.id === evt.itemId);
+      const blocks = idx === -1 ? [...state.blocks, { kind: "text", id: evt.itemId, content: evt.text, streaming: false }] : [
+        ...state.blocks.slice(0, idx),
+        { kind: "text", id: evt.itemId, content: evt.text, streaming: false },
+        ...state.blocks.slice(idx + 1)
+      ];
+      return { ...state, blocks, reasoningActive: false };
+    }
+    case "thinking_delta":
+      return {
+        ...state,
+        reasoning: upsertReasoning(state.reasoning, evt.itemId, (prev) => prev + evt.delta),
+        reasoningActive: true,
+        footer: state.footer === "streaming" ? state.footer : "thinking"
+      };
+    case "thinking":
+      return {
+        ...state,
+        reasoning: upsertReasoning(state.reasoning, evt.itemId, () => evt.text)
+      };
+    case "tool_use": {
+      const tool = {
+        id: evt.itemId,
+        title: evt.title,
+        detail: evt.detail,
+        status: "running"
+      };
+      return {
+        ...state,
+        blocks: [...closeStreamingText(state.blocks), { kind: "tool", tool }],
+        reasoningActive: false,
+        footer: "tool_running"
+      };
+    }
+    case "tool_result": {
+      const isError = evt.exitCode != null && evt.exitCode !== 0;
+      const blocks = state.blocks.map((b) => {
+        if (b.kind !== "tool" || b.tool.id !== evt.itemId) return b;
+        return {
+          ...b,
+          tool: {
+            ...b.tool,
+            status: isError ? "error" : "done",
+            output: evt.output,
+            exitCode: evt.exitCode
+          }
+        };
+      });
+      return { ...state, blocks };
+    }
+    case "error":
+      return { ...state, terminal: "error", errorMsg: evt.message, footer: null };
+    case "done":
+      return {
+        ...state,
+        blocks: closeStreamingText(state.blocks),
+        reasoningActive: false,
+        terminal: "done",
+        footer: null
+      };
+    default:
+      return state;
+  }
+}
+function markInterrupted(state) {
+  return {
+    ...state,
+    blocks: closeStreamingText(state.blocks),
+    reasoningActive: false,
+    terminal: "interrupted",
+    footer: null
+  };
+}
+function markIdleTimeout(state, minutes) {
+  return {
+    ...state,
+    blocks: closeStreamingText(state.blocks),
+    reasoningActive: false,
+    terminal: "idle_timeout",
+    footer: null,
+    idleTimeoutMinutes: minutes
+  };
+}
+function finalizeIfRunning(state) {
+  if (state.terminal !== "running") return state;
+  return {
+    ...state,
+    blocks: closeStreamingText(state.blocks),
+    reasoningActive: false,
+    terminal: "done",
+    footer: null
+  };
+}
+
+// src/card/run-render.ts
+var RunRender = class {
+  state = initialState;
+  /** when false, tool blocks are dropped from the rendered card (pref) */
+  showTools = true;
+  apply(ev) {
+    this.state = reduce(this.state, ev);
+  }
+  /** Current structured state for rendering. */
+  snapshot() {
+    return this.state;
+  }
+  /** Lifecycle terminal, for the run loop's status/logging. */
+  terminal() {
+    return this.state.terminal;
+  }
+  /** Mark the run as watchdog-killed (idle timeout). */
+  timeout(minutes) {
+    this.state = markIdleTimeout(this.state, minutes);
+  }
+  /** Mark the run as user-interrupted (⏹). */
+  interrupt() {
+    this.state = markInterrupted(this.state);
+  }
+  /** Force a terminal state if the stream ended without done/error. */
+  finalize() {
+    this.state = finalizeIfRunning(this.state);
+  }
+};
+
+// src/card/cards.ts
+function card(elements, opts = {}) {
+  const config = { update_multi: true };
+  if (opts.streaming) {
+    config.streaming_mode = true;
+    config.streaming_config = {
+      print_frequency_ms: { default: 70 },
+      print_step: { default: 1 },
+      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 } } : {}
+    };
+  }
+  return obj;
+}
+function md(content) {
+  return { tag: "markdown", content };
+}
+function note(content) {
+  return { tag: "div", text: { tag: "lark_md", content, text_size: "notation", text_color: "grey" } };
+}
+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) {
+  return {
+    tag: "column_set",
+    flex_mode: "flow",
+    horizontal_spacing: "small",
+    columns: items.map((it) => ({ tag: "column", width: "auto", elements: [it] }))
+  };
+}
+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") {
+  return {
+    tag: "button",
+    text: { tag: "plain_text", content: label },
+    type,
+    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 } }]
+  };
+}
+
+// src/card/command-cards.ts
+var MC = {
+  model: "model.set",
+  effort: "model.effort"
+};
+var RES = {
+  pick: "resume.pick"
+};
+var EFFORT_LABEL = {
+  none: "\u65E0",
+  minimal: "\u6781\u7B80",
+  low: "\u4F4E",
+  medium: "\u4E2D",
+  high: "\u9AD8",
+  xhigh: "\u6781\u9AD8"
+};
+function buildModelCard(state) {
+  const visible = state.models.filter((m) => !m.hidden);
+  const cur = state.models.find((m) => m.id === state.model);
+  const efforts = cur?.supportedEfforts.length ? cur.supportedEfforts : ["low", "medium", "high"];
+  const elements = [
+    md("\u{1F9E0} **\u6A21\u578B / \u63A8\u7406\u5F3A\u5EA6**"),
+    note("\u9009\u62E9\u540E\u4E0B\u4E00\u8F6E\u751F\u6548"),
+    hr(),
+    actions([
+      selectStatic({
+        actionId: MC.model,
+        placeholder: "\u9009\u62E9\u6A21\u578B",
+        initial: state.model,
+        options: visible.map((m) => ({ label: m.displayName, value: m.id }))
+      }),
+      selectStatic({
+        actionId: MC.effort,
+        placeholder: "effort",
+        initial: state.effort,
+        options: efforts.map((e) => ({ label: `effort\uFF1A${EFFORT_LABEL[e]}`, value: e }))
+      })
+    ])
+  ];
+  if (state.note) elements.push(note(state.note));
+  return card(elements, { summary: "\u6A21\u578B\u8BBE\u7F6E" });
+}
+var RESUME_TITLE_MAX = 30;
+function buildResumeCard(state) {
+  const elements = [md("\u{1F558} **\u6062\u590D\u5386\u53F2\u4F1A\u8BDD**"), note(metaNote(state)), hr()];
+  if (state.threads.length === 0) {
+    elements.push(md("_\u8BE5\u76EE\u5F55\u4E0B\u8FD8\u6CA1\u6709\u5386\u53F2\u4F1A\u8BDD\u3002\u76F4\u63A5 @\u6211 \u5373\u53EF\u65B0\u5EFA\u3002_"));
+  } else {
+    elements.push(note("\u70B9\u4E00\u6761\u5373\u6062\u590D \u2014\u2014 \u5728\u65B0\u8BDD\u9898\u91CC\u6253\u5F00\u5386\u53F2\u3001\u53EF\u76F4\u63A5\u7EE7\u7EED\u3002"));
+    for (const t of state.threads) {
+      const title = (t.name?.trim() || t.preview.trim() || "(\u65E0\u6458\u8981)").replace(/\s+/g, " ");
+      const label = `\u21A9\uFE0F ${pickerTime(t.updatedAt || t.createdAt)} \xB7 ${truncate(title, RESUME_TITLE_MAX)}`;
+      elements.push(actions([button(label, { a: RES.pick, t: t.codexThreadId })]));
+    }
+  }
+  return card(elements, { summary: "\u6062\u590D\u5386\u53F2\u4F1A\u8BDD" });
+}
+function buildResumeLaunchingCard(state) {
+  return card([md("\u23F3 \u6B63\u5728\u6062\u590D\u5386\u53F2\u4F1A\u8BDD\u2026"), note(metaNote(state))], { summary: "\u6062\u590D\u4E2D" });
+}
+function buildResumeDoneCard(state) {
+  return card([md("\u2705 \u5DF2\u6062\u590D \u2014\u2014 \u5DF2\u5728\u4E0A\u65B9\u65B0\u8BDD\u9898\u6253\u5F00\uFF0C\u53EF\u76F4\u63A5\u7EE7\u7EED\u3002"), note(metaNote(state))], { summary: "\u5DF2\u6062\u590D" });
+}
+function buildResumeErrorCard(state, message) {
+  return card([md(`\u274C \u6062\u590D\u5931\u8D25\uFF1A${truncate(message, 200)}`), note(metaNote(state))], { summary: "\u6062\u590D\u5931\u8D25" });
+}
+function metaNote(state) {
+  const parts = [`\u{1F4C2} \`${state.cwd}\``];
+  if (state.projectName) parts.unshift(`\u{1F4C1} ${state.projectName}`);
+  return parts.join("   ");
+}
+function truncate(s, n) {
+  const t = s.trim();
+  return t.length > n ? `${t.slice(0, n)}\u2026` : t;
+}
+function relativeTime(unixSeconds) {
+  if (!unixSeconds) return "\u672A\u77E5\u65F6\u95F4";
+  const ms = unixSeconds < 1e12 ? unixSeconds * 1e3 : unixSeconds;
+  const diff = Date.now() - ms;
+  const min = Math.floor(diff / 6e4);
+  if (min < 1) return "\u521A\u521A";
+  if (min < 60) return `${min} \u5206\u949F\u524D`;
+  const hr2 = Math.floor(min / 60);
+  if (hr2 < 24) return `${hr2} \u5C0F\u65F6\u524D`;
+  const day = Math.floor(hr2 / 24);
+  if (day < 30) return `${day} \u5929\u524D`;
+  return new Date(ms).toLocaleDateString("zh-CN");
+}
+function pickerTime(unixSeconds) {
+  if (!unixSeconds) return "\u672A\u77E5\u65F6\u95F4";
+  const ms = unixSeconds < 1e12 ? unixSeconds * 1e3 : unixSeconds;
+  const min = Math.floor((Date.now() - ms) / 6e4);
+  if (min < 1) return "\u521A\u521A";
+  if (min < 60) return `${min}\u5206\u949F\u524D`;
+  const d = new Date(ms);
+  const now = /* @__PURE__ */ new Date();
+  const p2 = (n) => String(n).padStart(2, "0");
+  const hm = `${p2(d.getHours())}:${p2(d.getMinutes())}`;
+  const sameDay = d.getFullYear() === now.getFullYear() && d.getMonth() === now.getMonth() && d.getDate() === now.getDate();
+  if (sameDay) return `\u4ECA\u5929 ${hm}`;
+  const md2 = `${p2(d.getMonth() + 1)}-${p2(d.getDate())}`;
+  return d.getFullYear() === now.getFullYear() ? `${md2} ${hm}` : `${d.getFullYear()}-${md2} ${hm}`;
+}
+function buildHelpCard(scope) {
+  const elements = [];
+  if (scope === "single") {
+    elements.push(
+      md("\u{1F4AC} **\u5355\u4F1A\u8BDD\u7FA4** \u2014 \u6574\u7FA4\u5C31\u662F\u4E00\u4E2A\u4F1A\u8BDD\uFF0C\u4E0A\u4E0B\u6587\u8FDE\u7EED\u3002"),
+      hr(),
+      md(
+        "\xB7 \u76F4\u63A5\u53D1\u6D88\u606F\uFF08\u514D@\uFF09\u2192 \u4EA4\u7ED9\u6211\u5904\u7406\n\xB7 `/model` \u2192 \u5207\u6362\u6A21\u578B / \u63A8\u7406\u5F3A\u5EA6\n\xB7 `/settings` \u2192 \u7FA4\u8BBE\u7F6E\uFF08\u514D@ \u5F00\u5173\uFF09\n\xB7 `/help` \u2192 \u8FD9\u5F20\u901F\u67E5\u5361"
+      )
+    );
+  } else if (scope === "topic") {
+    elements.push(
+      md("\u{1F9F5} **\u8BDD\u9898\u5185** \u2014 \u6BCF\u4E2A\u8BDD\u9898\u662F\u4E00\u4E2A\u72EC\u7ACB\u4F1A\u8BDD\u3002"),
+      hr(),
+      md(
+        "\xB7 \u76F4\u63A5\u53D1\u6D88\u606F\uFF08\u514D@\uFF09\u2192 \u7EE7\u7EED\u5F53\u524D\u4F1A\u8BDD\n\xB7 `/model` \u2192 \u5207\u6362\u6A21\u578B / \u63A8\u7406\u5F3A\u5EA6\n\xB7 `/help` \u2192 \u8FD9\u5F20\u901F\u67E5\u5361"
+      ),
+      note("\u5F00\u65B0\u8BDD\u9898\uFF1A\u56DE\u5230\u4E3B\u7FA4\u533A @\u6211 + \u5185\u5BB9\u3002")
+    );
+  } else {
+    elements.push(
+      md("\u{1F465} **\u4E3B\u7FA4\u533A** \u2014 @\u6211\u5F00\u8BDD\u9898\uFF0C\u6BCF\u4E2A\u8BDD\u9898\u662F\u72EC\u7ACB\u4F1A\u8BDD\u3002"),
+      hr(),
+      md(
+        "\xB7 **@\u6211 + \u5185\u5BB9** \u2192 \u5F00\u4E00\u4E2A\u65B0\u8BDD\u9898\u5E76\u5F00\u59CB\n\xB7 `/resume` \u2192 \u6062\u590D\u5386\u53F2\u4F1A\u8BDD\n\xB7 `/settings` \u2192 \u7FA4\u8BBE\u7F6E\uFF08\u514D@ \u5F00\u5173\uFF09\n\xB7 `/model` \u2192 \u9700\u8981\u5728\u8BDD\u9898\u91CC\u7528\n\xB7 `/help` \u2192 \u8FD9\u5F20\u901F\u67E5\u5361"
+      )
+    );
+  }
+  return card(elements, { header: { title: "\u{1F916} \u53EF\u7528\u547D\u4EE4", template: "blue" }, summary: "\u53EF\u7528\u547D\u4EE4" });
+}
+function buildWelcomeCard(kind, docUrl) {
+  const elements = [
+    md("\u{1F44B} **\u6B22\u8FCE\u4F7F\u7528 Codex Bridge** \u2014 \u672C\u7FA4\u5DF2\u7ED1\u5B9A\u4E00\u4E2A\u9879\u76EE\u76EE\u5F55\uFF0C\u5728\u7FA4\u91CC\u5C31\u80FD\u9A71\u52A8\u672C\u673A Codex \u5E72\u6D3B\u3002"),
+    hr()
+  ];
+  if (kind === "single") {
+    elements.push(
+      md("\u{1F4AC} **\u5355\u4F1A\u8BDD\u7FA4**\uFF08\u6574\u7FA4\u4E00\u4E2A\u4F1A\u8BDD\uFF0C\u4E0A\u4E0B\u6587\u8FDE\u7EED\uFF09"),
+      md(
+        "\xB7 \u76F4\u63A5\u53D1\u6D88\u606F\uFF08\u514D@\uFF09\u2192 \u4EA4\u7ED9\u6211\u5904\u7406\n\xB7 `/model` \u2192 \u5207\u6362\u6A21\u578B / \u63A8\u7406\u5F3A\u5EA6\n\xB7 `/settings` \u2192 \u7FA4\u8BBE\u7F6E\uFF08\u514D@ \u5F00\u5173\uFF09\n\xB7 `/help` \u2192 \u547D\u4EE4\u901F\u67E5\u5361"
+      )
+    );
+  } else {
+    elements.push(
+      md("\u{1F465} **\u4E3B\u7FA4\u533A**"),
+      md(
+        "\xB7 **@\u6211 + \u5185\u5BB9** \u2192 \u5F00\u4E00\u4E2A\u65B0\u8BDD\u9898\u5E76\u5F00\u59CB\uFF08\u6BCF\u8BDD\u9898\u72EC\u7ACB\u4F1A\u8BDD\uFF09\n\xB7 `/resume` \u2192 \u6062\u590D\u5386\u53F2\u4F1A\u8BDD\n\xB7 `/settings` \u2192 \u7FA4\u8BBE\u7F6E\uFF08\u514D@ \u5F00\u5173\uFF09"
+      ),
+      md("\u{1F9F5} **\u8BDD\u9898\u5185**"),
+      md("\xB7 \u76F4\u63A5\u53D1\u6D88\u606F\uFF08\u514D@\uFF09\u2192 \u7EE7\u7EED\u5F53\u524D\u4F1A\u8BDD\n\xB7 `/model` \u2192 \u5207\u6362\u6A21\u578B / \u63A8\u7406\u5F3A\u5EA6"),
+      note("\u4EFB\u610F\u573A\u666F\u53D1 `/help` \u770B\u5F53\u524D\u53EF\u7528\u547D\u4EE4\u3002")
+    );
+  }
+  if (docUrl) {
+    elements.push(hr(), actions([linkButton("\u{1F4D6} \u67E5\u770B\u5B8C\u6574\u4F7F\u7528\u624B\u518C", docUrl, "primary")]));
+  }
+  return card(elements, { header: { title: "\u{1F916} \u672C\u7FA4\u4F7F\u7528\u8BF4\u660E", template: "turquoise" }, summary: "\u672C\u7FA4\u4F7F\u7528\u8BF4\u660E" });
+}
+
+// src/card/history-card.ts
+var USER_MAX = 300;
+var ASSIST_MAX = 800;
+var REASON_MAX = 600;
+var TOOL_TITLE_MAX = 90;
+var TOOLS_BODY_MAX = 700;
+var TOOLS_MAX_LINES = 12;
+var PREVIEW_MAX = 160;
+var TITLE_Q_MAX = 56;
+var PANEL_SHELL = 360;
+var BODY_BUDGET = 18e3;
+function buildHistoryCard(state) {
+  const { history } = state;
+  const elements = [metaNote2(state)];
+  if (history.turns.length === 0) {
+    elements.push(
+      hr(),
+      md("_\u8FD9\u4E2A\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u53EF\u663E\u793A\u7684\u5386\u53F2\uFF08\u53EF\u80FD\u662F\u7A7A\u4F1A\u8BDD\u6216\u521A\u521B\u5EFA\uFF09\u3002_"),
+      hr(),
+      resumedFooter()
+    );
+    return card(elements, { header: header(state), summary: "\u5DF2\u6062\u590D\u5386\u53F2\u4F1A\u8BDD" });
+  }
+  const dropped = history.totalTurns - history.turns.length;
+  if (dropped > 0) {
+    elements.push(note(`\u4EC5\u663E\u793A\u6700\u8FD1 ${history.turns.length} \u8F6E\uFF0C\u66F4\u65E9\u7684 ${dropped} \u8F6E Codex \u4ECD\u4FDD\u7559\u5728\u4E0A\u4E0B\u6587\u4E2D\u3002`));
+  }
+  elements.push(hr());
+  const panels = [];
+  let used = 0;
+  for (let i = history.turns.length - 1; i >= 0; i--) {
+    const turn = history.turns[i];
+    if (!turn) continue;
+    const title = turnTitle(turn);
+    const body = turnBody(turn);
+    const size = estimateSize(body) + PANEL_SHELL;
+    if (used + size > BODY_BUDGET && panels.length > 0) {
+      const stub = "_\uFF08\u5185\u5BB9\u5DF2\u7701\u7565\uFF0C\u5386\u53F2\u8F83\u957F\uFF09_";
+      panels.push(collapsiblePanel({ title, expanded: false, border: "grey", body: stub }));
+      used += title.length + stub.length + PANEL_SHELL;
+    } else {
+      panels.push(collapsiblePanelEl({ title, expanded: false, border: "grey", elements: body }));
+      used += size;
+    }
+  }
+  panels.reverse();
+  elements.push(...panels);
+  const last = history.turns[history.turns.length - 1];
+  const leftOff = last ? last.assistantText || last.userText || (last.tools.at(-1)?.title ?? "") : "";
+  if (leftOff.trim()) {
+    elements.push(hr(), noteMd(`\u{1F4CD} **\u4E0A\u6B21\u505C\u5728**\uFF1A${truncateTail(leftOff, PREVIEW_MAX)}`));
+  } else {
+    elements.push(hr());
+  }
+  elements.push(resumedFooter());
+  return card(elements, { header: header(state), summary: `\u5DF2\u6062\u590D\u5386\u53F2\u4F1A\u8BDD \xB7 \u5171 ${history.totalTurns} \u8F6E` });
+}
+function header(state) {
+  const { history } = state;
+  const bits = [
+    history.name?.trim() || state.projectName,
+    `\u5171 ${history.totalTurns} \u8F6E`,
+    history.updatedAt ? relativeTime(history.updatedAt) : void 0
+  ].filter(Boolean);
+  return { title: "\u{1F558} \u5DF2\u6062\u590D\u5386\u53F2\u4F1A\u8BDD", template: "turquoise", subtitle: bits.join(" \xB7 ") };
+}
+function metaNote2(state) {
+  const parts = [`\u{1F4C2} \`${state.cwd}\``];
+  if (state.projectName) parts.unshift(`\u{1F4C1} ${state.projectName}`);
+  return note(parts.join("   "));
+}
+function resumedFooter() {
+  return md("\u2705 **\u4F1A\u8BDD\u5DF2\u6062\u590D** \u2014\u2014 \u76F4\u63A5\u53D1\u6D88\u606F\u5373\u53EF\u7EE7\u7EED\u3002");
+}
+function turnTitle(turn) {
+  if (turn.userText.trim()) return `\u{1F464} ${escapeInline(truncate2(oneLine(turn.userText), TITLE_Q_MAX))}`;
+  return "\u2699\uFE0F \u7CFB\u7EDF / \u5DE5\u5177\u8C03\u7528";
+}
+function turnBody(turn) {
+  const out = [];
+  if (turn.userText.trim()) out.push(md(`**\u{1F464} \u4F60**
+${truncate2(turn.userText, USER_MAX)}`));
+  if (turn.assistantText.trim()) out.push(md(`**\u{1F916} Codex**
+${truncate2(turn.assistantText, ASSIST_MAX)}`));
+  if (!turn.assistantText.trim() && !turn.userText.trim() && turn.tools.length) {
+    out.push(noteMd("_\uFF08\u4EC5\u5DE5\u5177\u8C03\u7528\uFF0C\u65E0\u6587\u672C\u56DE\u590D\uFF09_"));
+  }
+  const detail = [];
+  if (turn.reasoning.trim()) detail.push(md(`\u{1F9E0} **\u601D\u8003**
+${truncate2(turn.reasoning, REASON_MAX)}`));
+  if (turn.tools.length) detail.push(md(toolsBlock(turn.tools)));
+  if (detail.length) {
+    out.push(collapsiblePanelEl({ title: detailTitle(turn), expanded: false, border: "blue", elements: detail }));
+  }
+  return out;
+}
+function detailTitle(turn) {
+  const parts = [];
+  if (turn.reasoning.trim()) parts.push("\u{1F9E0} \u601D\u8003");
+  if (turn.tools.length) parts.push(`\u{1F9F0} ${turn.tools.length} \u4E2A\u5DE5\u5177`);
+  return `\u{1F50E} ${parts.join(" \xB7 ")}`;
+}
+function toolsBlock(tools) {
+  const lines = [`\u{1F9F0} **\u5DE5\u5177\u8C03\u7528\uFF08${tools.length}\uFF09**`];
+  let body = 0;
+  let shown = 0;
+  for (const t of tools) {
+    if (shown >= TOOLS_MAX_LINES || body >= TOOLS_BODY_MAX) {
+      lines.push(`_\u2026\u8FD8\u6709 ${tools.length - shown} \u4E2A_`);
+      break;
+    }
+    const line = toolLine(t);
+    lines.push(line);
+    body += line.length;
+    shown += 1;
+  }
+  return lines.join("\n");
+}
+function toolLine(t) {
+  const title = escapeInline(truncate2(oneLine(t.title), TOOL_TITLE_MAX));
+  const mark = t.failed ? " \u2717" : "";
+  const exit = t.exitCode != null && t.exitCode !== 0 ? ` (exit ${t.exitCode})` : "";
+  return `- \`${title}\`${mark}${exit}`;
+}
+function estimateSize(els) {
+  let n = 0;
+  for (const el of els) n += JSON.stringify(el).length;
+  return n;
+}
+function oneLine(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function escapeInline(s) {
+  return s.replace(/`/g, "");
+}
+function truncate2(s, n) {
+  const t = s.trim();
+  return t.length > n ? `${t.slice(0, n)}\u2026` : t;
+}
+function truncateTail(s, n) {
+  const t = oneLine(s);
+  return t.length > n ? `\u2026${t.slice(t.length - n)}` : t;
+}
+
+// src/card/tool-render.ts
+var HEADER_TITLE_MAX = 80;
+var OUTPUT_MAX = 1200;
+var BODY_TOTAL_MAX = 2500;
+function toolHeaderText(tool) {
+  const icon = tool.status === "done" ? "\u2705" : tool.status === "error" ? "\u274C" : "\u23F3";
+  return `${icon} **${escapeInline2(truncate3(tool.title, HEADER_TITLE_MAX))}**`;
+}
+function toolBodyMd(tool) {
+  if (!tool.output) {
+    return tool.status === "running" ? "_\u8FD0\u884C\u4E2D\u2026_" : "";
+  }
+  const out = truncate3(tool.output, OUTPUT_MAX);
+  const label = tool.status === "error" ? "Error" : "Output";
+  const body = `**${label}**
+\`\`\`
+${out}
+\`\`\``;
+  if (body.length <= BODY_TOTAL_MAX) return body;
+  return `${body.slice(0, BODY_TOTAL_MAX)}\u2026
+
+_\uFF08\u5DF2\u622A\u65AD\uFF0C\u5B8C\u6574\u5185\u5BB9\u89C1\u65E5\u5FD7\uFF09_`;
+}
+function truncate3(s, max) {
+  return s.length > max ? `${s.slice(0, max)}\u2026` : s;
+}
+function escapeInline2(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+
+// src/card/run-card.ts
+var RC = {
+  stop: "run.stop"
+};
+var REASONING_MAX = 1500;
+var COLLAPSE_TOOL_THRESHOLD = 3;
+function buildRunCard(rc) {
+  const state = rc.rs;
+  const running = state.terminal === "running";
+  const elements = [];
+  const reasoning = reasoningContent(state);
+  if (reasoning) elements.push(reasoningPanel(reasoning, state.reasoningActive));
+  const blocks = rc.showTools === false ? state.blocks.filter((b) => b.kind !== "tool") : state.blocks;
+  for (const group of groupBlocks(blocks)) {
+    if (group.kind === "text") {
+      if (group.content.trim()) elements.push(md(group.content));
+    } else {
+      elements.push(...renderToolGroup(group.tools, !running));
+    }
+  }
+  if (state.terminal === "interrupted") {
+    elements.push(noteMd("_\u23F9 \u5DF2\u88AB\u4E2D\u65AD_"));
+  } else if (state.terminal === "idle_timeout") {
+    elements.push(noteMd(`_\u23F1 ${state.idleTimeoutMinutes ?? 0} \u5206\u949F\u65E0\u54CD\u5E94\uFF0C\u5DF2\u81EA\u52A8\u7EC8\u6B62_`));
+  } else if (state.terminal === "error" && state.errorMsg) {
+    elements.push(noteMd(`\u26A0\uFE0F agent \u5931\u8D25\uFF1A${state.errorMsg}`));
+  } else if (state.terminal === "done" && elements.length === 0) {
+    elements.push(noteMd("_\uFF08\u672A\u8FD4\u56DE\u5185\u5BB9\uFF09_"));
+  }
+  if (running) {
+    if (state.footer) elements.push(footerStatus(state.footer));
+    if (rc.cardKey) elements.push(actions([button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger")]));
+  }
+  return card(elements, { streaming: running, summary: summaryText(state) });
+}
+function buildRunCardPlain(rc) {
+  return buildRunCard({ ...rc, cardKey: void 0 });
+}
+function* groupBlocks(blocks) {
+  let toolBuf = [];
+  for (const b of blocks) {
+    if (b.kind === "tool") {
+      toolBuf.push(b.tool);
+    } else {
+      if (toolBuf.length > 0) {
+        yield { kind: "tools", tools: toolBuf };
+        toolBuf = [];
+      }
+      yield { kind: "text", content: b.content };
+    }
+  }
+  if (toolBuf.length > 0) yield { kind: "tools", tools: toolBuf };
+}
+function renderToolGroup(tools, finalized) {
+  if (tools.length === 0) return [];
+  if (tools.length < COLLAPSE_TOOL_THRESHOLD) {
+    return tools.map((t) => toolPanel(t, false));
+  }
+  if (finalized) return [collapsedToolSummary(tools, true)];
+  const prior = tools.slice(0, -1);
+  const latest = tools[tools.length - 1];
+  const out = [];
+  if (prior.length > 0) out.push(collapsedToolSummary(prior, false));
+  if (latest) out.push(toolPanel(latest, true));
+  return out;
+}
+function reasoningPanel(content, active) {
+  return collapsiblePanel({
+    title: active ? "\u{1F9E0} **\u601D\u8003\u4E2D**" : "\u{1F9E0} **\u601D\u8003\u5B8C\u6210\uFF0C\u70B9\u51FB\u67E5\u770B**",
+    expanded: active,
+    border: "grey",
+    body: truncate4(content, REASONING_MAX)
+  });
+}
+function toolPanel(tool, expanded) {
+  return collapsiblePanel({
+    title: toolHeaderText(tool),
+    expanded,
+    border: tool.status === "error" ? "red" : "grey",
+    body: toolBodyMd(tool) || "_\u65E0\u8F93\u51FA_"
+  });
+}
+function collapsedToolSummary(tools, finalized) {
+  const suffix = finalized ? "\uFF08\u5DF2\u7ED3\u675F\uFF09" : "";
+  return collapsiblePanel({
+    title: `\u2615 **${tools.length} \u4E2A\u5DE5\u5177\u8C03\u7528${suffix}**`,
+    expanded: false,
+    border: "blue",
+    body: tools.map((t) => `- ${toolHeaderText(t)}`).join("\n")
+  });
+}
+function footerStatus(status) {
+  const text = status === "thinking" ? "\u{1F9E0} \u6B63\u5728\u601D\u8003" : status === "tool_running" ? "\u{1F9F0} \u6B63\u5728\u8C03\u7528\u5DE5\u5177" : "\u270D\uFE0F \u6B63\u5728\u8F93\u51FA";
+  return noteMd(text);
+}
+function summaryText(state) {
+  if (state.terminal === "interrupted") return "\u5DF2\u4E2D\u65AD";
+  if (state.terminal === "idle_timeout") return "\u5DF2\u8D85\u65F6";
+  if (state.terminal === "error") return "\u51FA\u9519";
+  if (state.terminal === "done") return "\u5DF2\u5B8C\u6210";
+  if (state.footer === "tool_running") return "\u6B63\u5728\u8C03\u7528\u5DE5\u5177";
+  if (state.footer === "streaming") return "\u6B63\u5728\u8F93\u51FA";
+  return "\u601D\u8003\u4E2D";
+}
+function truncate4(s, n) {
+  return s.length > n ? `${s.slice(0, n)}\u2026` : s;
+}
+
+// src/card/run-card-stream.ts
+var STREAM_THROTTLE_MS = 250;
+var RunCardStream = class {
+  cardId = "";
+  _messageId = "";
+  seq = 0;
+  lastPush = 0;
+  lastContent = "";
+  get messageId() {
+    return this._messageId;
+  }
+  /** Create the entity from the initial (running) card and send a message
+   * referencing it by card_id. Returns the carrier message id. */
+  async create(channel, chatId, initialCard, opts) {
+    const created = await channel.rawClient.cardkit.v1.card.create({
+      data: { type: "card_json", data: JSON.stringify(initialCard) }
+    });
+    const cardId = created.data?.card_id;
+    if (!cardId) {
+      throw new Error(`cardkit.card.create returned no card_id: ${JSON.stringify(created).slice(0, 200)}`);
+    }
+    this.cardId = cardId;
+    this.lastContent = JSON.stringify(initialCard);
+    const content = JSON.stringify({ type: "card", data: { card_id: cardId } });
+    let messageId;
+    if (opts.replyTo) {
+      const r = await channel.rawClient.im.v1.message.reply({
+        path: { message_id: opts.replyTo },
+        data: { msg_type: "interactive", content, reply_in_thread: opts.replyInThread ?? false }
+      });
+      messageId = r.data?.message_id;
+    } else {
+      const r = await channel.rawClient.im.v1.message.create({
+        params: { receive_id_type: "chat_id" },
+        data: { receive_id: chatId, msg_type: "interactive", content }
+      });
+      messageId = r.data?.message_id;
+    }
+    if (!messageId) throw new Error("run card send returned no message_id");
+    this._messageId = messageId;
+    return messageId;
+  }
+  /** Throttled whole-card stream update. Skips identical/too-soon pushes;
+   * `force` flushes regardless (still de-duped on content). */
+  async streamCard(channel, fullCard, force = false) {
+    if (!this.cardId) return;
+    const data = JSON.stringify(fullCard);
+    if (data === this.lastContent) return;
+    const now = Date.now();
+    if (!force && now - this.lastPush < STREAM_THROTTLE_MS) return;
+    this.lastPush = now;
+    this.lastContent = data;
+    try {
+      await channel.rawClient.cardkit.v1.card.update({
+        path: { card_id: this.cardId },
+        data: { card: { type: "card_json", data }, sequence: ++this.seq, uuid: `s_${this.cardId}_${this.seq}` }
+      });
+    } catch (err) {
+      log.fail("card", err, { phase: "run-stream", cardId: this.cardId, seq: this.seq });
+    }
+  }
+  /** Forced whole-card replace for structural/terminal updates. A terminal
+   * card built with streaming off clears the typewriter cursor. */
+  async updateCard(channel, fullCard) {
+    if (!this.cardId) return;
+    const data = JSON.stringify(fullCard);
+    this.lastContent = data;
+    const push = async () => {
+      await channel.rawClient.cardkit.v1.card.update({
+        path: { card_id: this.cardId },
+        data: { card: { type: "card_json", data }, sequence: ++this.seq, uuid: `u_${this.cardId}_${this.seq}` }
+      });
+    };
+    try {
+      await push();
+    } catch (err) {
+      log.fail("card", err, { phase: "run-update", cardId: this.cardId, seq: this.seq, retry: true });
+      await new Promise((r) => setTimeout(r, 3200));
+      try {
+        await push();
+      } catch (err2) {
+        log.fail("card", err2, { phase: "run-update-retry", cardId: this.cardId, seq: this.seq });
+      }
+    }
+  }
+};
+
+// src/card/dm-cards.ts
+function openChatUrl(chatId) {
+  return `https://applink.feishu.cn/client/chat/open?openChatId=${encodeURIComponent(chatId)}`;
+}
+var DM = {
+  menu: "dm.menu",
+  newProject: "dm.newProject",
+  newProjectSubmit: "dm.newProject.submit",
+  projects: "dm.projects",
+  settings: "dm.settings",
+  doctor: "dm.doctor",
+  reconnect: "dm.reconnect",
+  rmConfirm: "dm.rmConfirm",
+  rmDo: "dm.rmDo",
+  rmCancel: "dm.rmCancel",
+  setTools: "dm.set.tools",
+  setWatchdog: "dm.set.watchdog",
+  setPending: "dm.set.pending",
+  setConcurrency: "dm.set.concurrency"
+};
+var GS = {
+  setNoMention: "gs.noMention"
+};
+function kindLabel(kind) {
+  return kind === "single" ? "\u{1F4AC} \u5355\u4F1A\u8BDD\u7FA4" : "\u{1F465} \u591A\u8BDD\u9898\u7FA4";
+}
+function buildDmMenuCard() {
+  return card(
+    [
+      md("\u79C1\u804A\u7528\u4E8E**\u5EFA\u9879\u76EE\u548C\u7BA1\u7406**\uFF1B\u5177\u4F53\u4EFB\u52A1\u8BF7\u5230\u9879\u76EE\u7FA4\u91CC @\u6211\u3002"),
+      hr(),
+      actions([
+        button("\u2795 \u65B0\u5EFA\u9879\u76EE", { a: DM.newProject }, "primary"),
+        button("\u{1F4C1} \u9879\u76EE\u5217\u8868", { a: DM.projects }),
+        button("\u2699\uFE0F \u8BBE\u7F6E", { a: DM.settings })
+      ]),
+      actions([
+        button("\u{1FA7A} \u8BCA\u65AD", { a: DM.doctor }),
+        button("\u{1F504} \u91CD\u8FDE", { a: DM.reconnect })
+      ])
+    ],
+    { header: { title: "\u{1F916} Codex Bridge \u7BA1\u7406\u53F0", template: "blue" } }
+  );
+}
+function buildNewProjectFormCard(opts = {}) {
+  const elements = [];
+  if (opts.error) elements.push(md(`\u274C **\u521B\u5EFA\u5931\u8D25**\uFF1A${opts.error}`));
+  elements.push(
+    md("\u586B\u9879\u76EE\u540D\uFF08\u5FC5\u586B\uFF09\u3002**\u6587\u4EF6\u5939\u8DEF\u5F84\u7559\u7A7A** = \u81EA\u52A8\u5728\u9ED8\u8BA4\u4F4D\u7F6E\u65B0\u5EFA\u4E00\u4E2A\u7A7A\u767D\u9879\u76EE\uFF1B**\u586B\u7EDD\u5BF9\u8DEF\u5F84** = \u7528\u7535\u8111\u4E0A\u5DF2\u6709\u7684\u6587\u4EF6\u5939\u3002"),
+    form("new_project", [
+      input({ name: "name", label: "\u9879\u76EE\u540D", placeholder: "my-app", value: opts.name, required: true }),
+      input({ name: "cwd", label: "\u6587\u4EF6\u5939\u8DEF\u5F84\uFF08\u9009\u586B\uFF0C\u7559\u7A7A\u81EA\u52A8\u65B0\u5EFA\uFF09", placeholder: "/Users/you/code/my-app", value: opts.cwd }),
+      note("\u9009\u7FA4\u7C7B\u578B(\u76F4\u63A5\u70B9\u5BF9\u5E94\u6309\u94AE\u521B\u5EFA)\uFF1A\u{1F465} \u591A\u8BDD\u9898\u7FA4 = @\u6211\u5F00\u8BDD\u9898\u3001\u6BCF\u8BDD\u9898\u72EC\u7ACB\u4F1A\u8BDD\uFF1B\u{1F4AC} \u5355\u4F1A\u8BDD\u7FA4 = \u6574\u7FA4\u4E00\u4E2A\u4F1A\u8BDD\u3001\u8FDE\u7EED\u4E0A\u4E0B\u6587\u3002"),
+      actions([
+        submitButton("\u{1F465} \u521B\u5EFA\xB7\u591A\u8BDD\u9898\u7FA4", { a: DM.newProjectSubmit, kind: "multi" }, "primary", "submit_multi"),
+        submitButton("\u{1F4AC} \u521B\u5EFA\xB7\u5355\u4F1A\u8BDD\u7FA4", { a: DM.newProjectSubmit, kind: "single" }, "primary", "submit_single")
+      ]),
+      actions([button("\u2B05\uFE0F \u83DC\u5355", { a: DM.menu })])
+    ])
+  );
+  return card(elements, { header: { title: "\u2795 \u65B0\u5EFA\u9879\u76EE", template: "turquoise" } });
+}
+function buildNewProjectDoneCard(p) {
+  const elements = [
+    md(`\u2705 \u5DF2\u521B\u5EFA\u9879\u76EE **${p.name}**${p.blank ? " _(\u7A7A\u767D\u9879\u76EE)_" : ""}`),
+    note(`\u{1F4C2} \`${p.cwd}\`   \xB7   ${kindLabel(p.kind)}`),
+    md(p.chatId ? "\u7FA4\u5DF2\u5EFA\u597D \u{1F449} \u53BB\u9879\u76EE\u7FA4\u91CC **@\u6211** \u5E72\u6D3B\u3002" : "\u53D1\u6211\u4EFB\u610F\u6D88\u606F\u53EF\u518D\u6B21\u6253\u5F00\u7BA1\u7406\u53F0\u3002")
+  ];
+  if (p.chatId) elements.push(actions([linkButton("\u{1F4AC} \u6253\u5F00\u7FA4\u804A", openChatUrl(p.chatId), "primary")]));
+  return card(elements, { header: { title: "\u2795 \u65B0\u5EFA\u9879\u76EE", template: "green" } });
+}
+function buildProjectListCard(projects, sessionsByChat = /* @__PURE__ */ new Map()) {
+  if (projects.length === 0) {
+    return card(
+      [md("\u8FD8\u6CA1\u6709\u9879\u76EE\u3002\u70B9 **\u2795 \u65B0\u5EFA\u9879\u76EE** \u6216\u76F4\u63A5\u53D1\u6211\u4E00\u4E2A\u9879\u76EE\u540D\u3002"), actions([button("\u2B05\uFE0F \u83DC\u5355", { a: DM.menu })])],
+      { header: { title: "\u{1F4C1} \u9879\u76EE\u5217\u8868", template: "wathet" } }
+    );
+  }
+  const elements = [];
+  for (const p of projects) {
+    elements.push(md(`**${p.name}**${p.blank ? " _(\u7A7A\u767D)_" : ""}`));
+    elements.push(note(`\u{1F4C2} \`${p.cwd}\`${p.branch && p.branch !== "\u2014" ? `   \u{1F33F} ${p.branch}` : ""}`));
+    elements.push(
+      note(
+        p.chatId ? `\u{1F4AC} \u7FA4\uFF1A**${p.name}**   \xB7   ${kindLabel(p.kind)}   \xB7   \u514D@\uFF1A${p.noMention ?? true ? "\u5F00" : "\u5173"}` : "\u26A0\uFE0F \u672A\u7ED1\u5B9A\u7FA4"
+      )
+    );
+    const sessions = (p.chatId ? sessionsByChat.get(p.chatId) : void 0) ?? [];
+    if (sessions.length === 0) {
+      elements.push(note("\uFF08\u6682\u65E0\u8BDD\u9898\uFF09"));
+    } else {
+      const sorted = [...sessions].sort((a, b) => b.updatedAt - a.updatedAt);
+      for (const s of sorted) {
+        const title = (s.summary || "(\u7A7A)").replace(/\s+/g, " ").slice(0, 40);
+        elements.push(note(`\xB7 ${title} \xB7 ${relativeTime(s.updatedAt)}`));
+      }
+    }
+    const row = [];
+    if (p.chatId) row.push(linkButton("\u{1F4AC} \u6253\u5F00\u7FA4\u804A", openChatUrl(p.chatId)));
+    row.push(button("\u{1F5D1} \u5220\u9664", { a: DM.rmConfirm, n: p.name }, "danger"));
+    elements.push(actions(row));
+    elements.push(hr());
+  }
+  elements.push(note(`\u5171 ${projects.length} \u4E2A\u9879\u76EE`));
+  elements.push(actions([button("\u2B05\uFE0F \u83DC\u5355", { a: DM.menu })]));
+  return card(elements, { header: { title: "\u{1F4C1} \u9879\u76EE\u5217\u8868", template: "wathet" } });
+}
+function buildRmConfirmCard(name) {
+  return card(
+    [
+      md(`\u786E\u5B9A\u5220\u9664\u9879\u76EE **${name}**\uFF1F`),
+      note("\u4EC5\u89E3\u7ED1\uFF08\u79FB\u9664\u6CE8\u518C + \u64A4\u9500\u7F6E\u9876\u6A2A\u5E45\uFF09\uFF0C**\u4E0D\u5220\u4EE3\u7801\u76EE\u5F55**\u3002\u7FA4\u4E3B\u4F1A\u8F6C\u7ED9\u4F60\uFF0C\u518D\u7531\u4F60\u81EA\u884C\u5728\u98DE\u4E66\u89E3\u6563\u7FA4\u3002"),
+      actions([
+        button("\u2705 \u786E\u8BA4\u5220\u9664", { a: DM.rmDo, n: name }, "danger"),
+        button("\u53D6\u6D88", { a: DM.rmCancel })
+      ])
+    ],
+    { header: { title: "\u{1F5D1} \u5220\u9664\u9879\u76EE", template: "red" } }
+  );
+}
+function optionRow(label, actionId, current, opts) {
+  return [
+    md(label),
+    actions(opts.map((o) => button(o.label, { a: actionId, v: o.value }, o.value === current ? "primary" : "default")))
+  ];
+}
+function buildSettingsCard(cfg) {
+  const watchdogSec = cfg.preferences?.runIdleTimeoutSeconds ?? 120;
+  return card(
+    [
+      md("**\u5168\u5C40\u8BBE\u7F6E**\uFF08\u7BA1\u7406\u5458\uFF09"),
+      ...optionRow("\u{1F527} \u5DE5\u5177\u8C03\u7528", DM.setTools, getShowToolCalls(cfg) ? "on" : "off", [
+        { label: "\u663E\u793A", value: "on" },
+        { label: "\u9690\u85CF", value: "off" }
+      ]),
+      ...optionRow("\u23F1 \u5047\u6B7B\u8D85\u65F6", DM.setWatchdog, String(watchdogSec), [
+        { label: "\u5173\u95ED", value: "0" },
+        { label: "60\u79D2", value: "60" },
+        { label: "120\u79D2", value: "120" },
+        { label: "300\u79D2", value: "300" }
+      ]),
+      ...optionRow("\u{1F4E5} \u8FD0\u884C\u4E2D\u65B0\u6D88\u606F", DM.setPending, getPendingPolicy(cfg), [
+        { label: "\u5F15\u5BFC", value: "steer" },
+        { label: "\u6392\u961F", value: "queue" }
+      ]),
+      ...optionRow("\u26A1 \u5E76\u53D1\u4E0A\u9650", DM.setConcurrency, String(getMaxConcurrentRuns(cfg)), [
+        { label: "1", value: "1" },
+        { label: "5", value: "5" },
+        { label: "10", value: "10" },
+        { label: "20", value: "20" }
+      ]),
+      note("\u26A0\uFE0F \u5047\u6B7B\u8D85\u65F6 / \u5E76\u53D1\u4E0A\u9650 \u6539\u540E\u9700**\u91CD\u542F**\u751F\u6548\uFF1B\u5DE5\u5177\u663E\u793A / \u8FD0\u884C\u4E2D\u65B0\u6D88\u606F \u5373\u65F6\u751F\u6548\u3002"),
+      actions([button("\u2B05\uFE0F \u83DC\u5355", { a: DM.menu })])
+    ],
+    { header: { title: "\u2699\uFE0F \u8BBE\u7F6E", template: "blue" } }
+  );
+}
+function buildGroupSettingsCard(project) {
+  const kind = project.kind ?? "multi";
+  const noMention = project.noMention ?? true;
+  const scopeNote = kind === "single" ? "\u5F00\u542F\u540E\uFF1A\u672C\u7FA4\u6240\u6709\u6D88\u606F(\u4E0D\u7528 @)\u90FD\u4EA4\u7ED9\u6211\u5904\u7406\u3002" : "\u5F00\u542F\u540E\uFF1A\u8BDD\u9898\u5185\u7684\u6D88\u606F(\u4E0D\u7528 @)\u90FD\u4EA4\u7ED9\u6211\u5904\u7406\uFF1B**\u5F00\u65B0\u8BDD\u9898\u4ECD\u9700 @\u6211**\u3002";
+  return card(
+    [
+      md(`**\u7FA4\u8BBE\u7F6E** \xB7 ${project.name}`),
+      note(`\u7FA4\u7C7B\u578B(\u5EFA\u7FA4\u65F6\u5B9A\uFF0C\u4E0D\u53EF\u6539)\uFF1A${kindLabel(kind)}`),
+      ...optionRow("\u270B \u514D@\uFF08\u4E0D\u7528 @ \u4E5F\u56DE\u590D\uFF09", GS.setNoMention, noMention ? "on" : "off", [
+        { label: "\u5F00", value: "on" },
+        { label: "\u5173", value: "off" }
+      ]),
+      note(scopeNote),
+      note("\u26A0\uFE0F \u514D@ \u9700\u5E94\u7528\u5DF2\u5F00\u901A\u300C\u63A5\u6536\u7FA4\u5185\u6240\u6709\u6D88\u606F\u300D(im:message.group_msg)\u6743\u9650\uFF0C\u5426\u5219\u6536\u4E0D\u5230\u975E @ \u6D88\u606F\u3002")
+    ],
+    { header: { title: "\u2699\uFE0F \u7FA4\u8BBE\u7F6E", template: "blue" } }
+  );
+}
+
+// src/project/registry.ts
+import { mkdir as mkdir4, readFile as readFile5, rename as rename4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4 } from "path";
+var FILE_VERSION2 = 1;
+async function read() {
+  try {
+    const text = await readFile5(paths.projectsFile, "utf8");
+    const parsed = JSON.parse(text);
+    return Array.isArray(parsed.projects) ? parsed.projects : [];
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+async function write(projects) {
+  await mkdir4(dirname4(paths.projectsFile), { recursive: true });
+  const tmp = `${paths.projectsFile}.tmp-${process.pid}`;
+  const body = { version: FILE_VERSION2, projects };
+  await writeFile4(tmp, `${JSON.stringify(body, null, 2)}
+`, "utf8");
+  await rename4(tmp, paths.projectsFile);
+}
+async function listProjects() {
+  return read();
+}
+async function getProjectByChatId(chatId) {
+  return (await read()).find((p) => p.chatId === chatId);
+}
+async function getProjectByName(name) {
+  return (await read()).find((p) => p.name === name);
+}
+async function addProject(p) {
+  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`);
+  }
+  projects.push(p);
+  await write(projects);
+}
+async function updateProject(name, patch) {
+  const projects = await read();
+  const p = projects.find((x) => x.name === name);
+  if (!p) return;
+  const target = p;
+  for (const [k, v] of Object.entries(patch)) {
+    if (v !== void 0) target[k] = v;
+  }
+  await write(projects);
+}
+async function removeProject(name) {
+  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/project/lifecycle.ts
+import { mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { isAbsolute, join as join7, resolve } from "path";
+
+// src/project/git-info.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function currentBranch(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd,
+      timeout: 3e3
+    });
+    const b = stdout.trim();
+    return b && b !== "HEAD" ? b : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/project/announcement.ts
+var PAGE_BLOCK_TYPE = 1;
+var TEXT_BLOCK_TYPE = 2;
+var LATEST_REVISION = -1;
+function buildAnnouncementLine(project, branch) {
+  const parts = [`\u{1F4C1} ${project.name}`];
+  if (!project.blank) parts.push(`\u{1F4C2} ${project.cwd}`);
+  if (branch) parts.push(`\u{1F33F} ${branch}`);
+  return parts.join("   \xB7   ");
+}
+async function withRetry(fn, attempts = 5) {
+  let lastErr;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (i < attempts - 1) await new Promise((r) => setTimeout(r, 800 * (i + 1)));
+    }
+  }
+  throw lastErr;
+}
+async function writeAnnouncement(channel, chatId, line) {
+  const docx = channel.rawClient.docx.v1;
+  await withRetry(async () => {
+    const listed = await docx.chatAnnouncementBlock.list({ path: { chat_id: chatId } });
+    const items = listed.data?.items ?? [];
+    const page = items.find((b) => b.block_type === PAGE_BLOCK_TYPE);
+    if (!page?.block_id) throw new Error("\u7FA4\u516C\u544A\u7F3A\u5C11 page block");
+    const existing = page.children?.length ?? 0;
+    if (existing > 0) {
+      await docx.chatAnnouncementBlockChildren.batchDelete({
+        path: { chat_id: chatId, block_id: page.block_id },
+        params: { revision_id: LATEST_REVISION },
+        data: { start_index: 0, end_index: existing }
+      });
+    }
+    await docx.chatAnnouncementBlockChildren.create({
+      path: { chat_id: chatId, block_id: page.block_id },
+      params: { revision_id: LATEST_REVISION },
+      data: {
+        index: 0,
+        children: [{ block_type: TEXT_BLOCK_TYPE, text: { elements: [{ text_run: { content: line } }] } }]
+      }
+    });
+  });
+}
+async function pinAnnouncement(channel, chatId) {
+  await withRetry(
+    () => channel.rawClient.im.v1.chatTopNotice.putTopNotice({
+      path: { chat_id: chatId },
+      data: { chat_top_notice: [{ action_type: "2" }] }
+    })
+  );
+}
+async function setAnnouncement(channel, project) {
+  const branch = await currentBranch(project.cwd);
+  await writeAnnouncement(channel, project.chatId, buildAnnouncementLine(project, branch));
+  try {
+    await pinAnnouncement(channel, project.chatId);
+  } catch (err) {
+    log.fail("project", err, { phase: "announcement-pin" });
+  }
+  await updateProject(project.name, { branch: branch ?? void 0 });
+}
+async function refreshBranch(channel, project) {
+  const branch = await currentBranch(project.cwd);
+  if ((branch ?? "\u2014") === (project.branch ?? "\u2014")) return;
+  log.info("project", "branch-change", { name: project.name, from: project.branch ?? "\u2014", to: branch ?? "\u2014" });
+  try {
+    await writeAnnouncement(channel, project.chatId, buildAnnouncementLine(project, branch));
+    await updateProject(project.name, { branch: branch ?? void 0 });
+  } catch (err) {
+    log.fail("project", err, { phase: "announcement-patch" });
+  }
+}
+
+// src/project/onboarding.ts
+var HELP_DOC_URL = "https://my.feishu.cn/wiki/PZ23wGr7JiKK5RkIG4rcZXzGn5g";
+async function onboardGroup(channel, project) {
+  const kind = project.kind ?? "multi";
+  const chatId = project.chatId;
+  try {
+    const content = JSON.stringify(buildWelcomeCard(kind, HELP_DOC_URL || void 0));
+    const sent = await channel.rawClient.im.v1.message.create({
+      params: { receive_id_type: "chat_id" },
+      data: { receive_id: chatId, msg_type: "interactive", content }
+    });
+    const messageId = sent.data?.message_id;
+    if (messageId) {
+      await channel.rawClient.im.v1.pin.create({ data: { message_id: messageId } });
+      log.info("project", "onboard-pin", { name: project.name });
+    }
+  } catch (err) {
+    log.fail("project", err, { phase: "onboard-welcome" });
+  }
+  if (HELP_DOC_URL) {
+    try {
+      await channel.rawClient.im.v1.chatTab.create({
+        path: { chat_id: chatId },
+        data: {
+          chat_tabs: [{ tab_name: "\u{1F448} \u4F7F\u7528\u8BF4\u660E", tab_type: "url", tab_content: { url: HELP_DOC_URL } }]
+        }
+      });
+      log.info("project", "onboard-tab", { name: project.name });
+    } catch (err) {
+      log.fail("project", err, { phase: "onboard-tab" });
+    }
+  }
+}
+
+// src/project/lifecycle.ts
+async function createProject(channel, input2) {
+  const name = input2.name.trim();
+  if (!name) throw new Error("\u9879\u76EE\u540D\u4E0D\u80FD\u4E3A\u7A7A");
+  if (await getProjectByName(name)) throw new Error(`\u9879\u76EE\u540D\u300C${name}\u300D\u5DF2\u5B58\u5728\uFF0C\u6362\u4E2A\u540D\u6216\u7528 /projects \u770B\u5DF2\u6709\u7684`);
+  let cwd;
+  let blank;
+  if (input2.existingPath) {
+    cwd = isAbsolute(input2.existingPath) ? input2.existingPath : resolve(input2.existingPath);
+    if (!existsSync4(cwd)) throw new Error(`\u6587\u4EF6\u5939\u4E0D\u5B58\u5728\uFF1A${cwd}`);
+    blank = false;
+  } else {
+    cwd = join7(paths.projectsRootDir, name);
+    await mkdir5(cwd, { recursive: true });
+    blank = true;
+  }
+  const res = await channel.rawClient.im.v1.chat.create({
+    params: { user_id_type: "open_id", set_bot_manager: true },
+    data: { name, user_id_list: [input2.ownerOpenId] }
+  });
+  const chatId = res.data?.chat_id;
+  if (!chatId) throw new Error(`\u5EFA\u7FA4\u5931\u8D25\uFF1A${JSON.stringify(res).slice(0, 200)}`);
+  const project = { name, chatId, cwd, blank, createdAt: Date.now(), kind: input2.kind ?? "multi" };
+  await addProject(project);
+  log.info("project", "create", { name, chatId, cwd, blank });
+  await setAnnouncement(channel, project).catch((err) => log.fail("project", err, { phase: "announcement" }));
+  await onboardGroup(channel, project).catch((err) => log.fail("project", err, { phase: "onboard" }));
+  return project;
+}
+
+// src/project/group-ops.ts
+async function transferOwnership(channel, chatId, toOpenId) {
+  await channel.rawClient.im.v1.chat.update({
+    path: { chat_id: chatId },
+    params: { user_id_type: "open_id" },
+    data: { owner_id: toOpenId }
+  });
+  log.info("project", "owner-transfer", { chatId: chatId.slice(-6), to: toOpenId.slice(-6) });
+}
+
+// src/bot/session-store.ts
+import { mkdir as mkdir6, readFile as readFile6, rename as rename5, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+var FILE_VERSION3 = 1;
+async function read2() {
+  try {
+    const text = await readFile6(paths.sessionsFile, "utf8");
+    const parsed = JSON.parse(text);
+    return Array.isArray(parsed.sessions) ? parsed.sessions : [];
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+async function write2(sessions) {
+  await mkdir6(dirname5(paths.sessionsFile), { recursive: true });
+  const tmp = `${paths.sessionsFile}.tmp-${process.pid}`;
+  const body = { version: FILE_VERSION3, sessions };
+  await writeFile5(tmp, `${JSON.stringify(body, null, 2)}
+`, "utf8");
+  await rename5(tmp, paths.sessionsFile);
+}
+async function listSessions() {
+  return read2();
+}
+async function getSession(threadId) {
+  return (await read2()).find((s) => s.threadId === threadId);
+}
+async function upsertSession(rec) {
+  const sessions = await read2();
+  const idx = sessions.findIndex((s) => s.threadId === rec.threadId);
+  if (idx === -1) sessions.push(rec);
+  else sessions[idx] = rec;
+  await write2(sessions);
+}
+async function patchSession(threadId, patch) {
+  const sessions = await read2();
+  const rec = sessions.find((s) => s.threadId === threadId);
+  if (!rec) return;
+  const target = rec;
+  for (const [k, v] of Object.entries(patch)) {
+    if (v !== void 0) target[k] = v;
+  }
+  rec.updatedAt = Date.now();
+  await write2(sessions);
+}
+
+// src/bot/dm-console.ts
+async function handleDmConsole(channel, cfg, msg) {
+  await withTrace({ chatId: msg.chatId, msgId: msg.messageId }, async () => {
+    if (!isAdmin(cfg, msg.senderId)) {
+      log.info("console", "deny", { sender: msg.senderId.slice(-6) });
+      await channel.send(msg.chatId, { markdown: "\u26D4 \u4EC5\u7BA1\u7406\u5458\u53EF\u5728\u79C1\u804A\u91CC\u7BA1\u7406\u9879\u76EE\u3002" }, { replyTo: msg.messageId }).catch(() => void 0);
+      return;
+    }
+    await sendManagedCard(channel, msg.chatId, buildDmMenuCard(), msg.messageId).catch(
+      (err) => log.fail("console", err, { cmd: "menu-send" })
+    );
+  });
+}
+
+// src/bot/comments.ts
+var SUPPORTED_FILE_TYPES = /* @__PURE__ */ new Set(["doc", "docx", "sheet", "file"]);
+var REPLY_MAX_CHARS = 2e3;
+function apiErrCode(err) {
+  return err?.response?.data?.code;
+}
+async function resolveComment(channel, evt) {
+  if (!SUPPORTED_FILE_TYPES.has(evt.fileType)) return null;
+  const direct = {
+    fileToken: evt.fileToken,
+    fileType: evt.fileType
+  };
+  const directCtx = await fetchCommentContext(channel, direct, evt).catch((err) => {
+    if (apiErrCode(err) === 1069307) log.warn("comment", "no-access", { token: direct.fileToken });
+    else log.fail("comment", err, { step: "fetch-direct" });
+    return null;
+  });
+  if (directCtx?.question) return { target: direct, ctx: directCtx };
+  const wiki = await resolveWikiNode(channel, evt.fileToken);
+  if (wiki) {
+    const wikiCtx = await fetchCommentContext(channel, wiki, evt).catch((err) => {
+      log.fail("comment", err, { step: "fetch-wiki" });
+      return null;
+    });
+    if (wikiCtx?.question) return { target: wiki, ctx: wikiCtx };
+  }
+  return null;
+}
+async function resolveWikiNode(channel, fileToken) {
+  try {
+    const r = await channel.rawClient.wiki.v2.space.getNode({ params: { token: fileToken } });
+    const node = r?.data?.node;
+    if (node?.obj_token && node.obj_type && SUPPORTED_FILE_TYPES.has(node.obj_type)) {
+      log.info("comment", "wiki-resolved", { objToken: node.obj_token, objType: node.obj_type });
+      return { fileToken: node.obj_token, fileType: node.obj_type };
+    }
+  } catch {
+  }
+  return null;
+}
+async function fetchCommentContext(channel, target, evt) {
+  let replies = [];
+  let quote;
+  let isWhole = false;
+  try {
+    const r = await channel.rawClient.drive.v1.fileComment.get({
+      params: { file_type: target.fileType },
+      path: { file_token: target.fileToken, comment_id: evt.commentId }
+    });
+    replies = r?.data?.reply_list?.replies ?? [];
+    quote = r?.data?.quote || void 0;
+    isWhole = Boolean(r?.data?.is_whole);
+  } catch (err) {
+    log.warn("comment", "get-failed-fallback-list", { code: apiErrCode(err) });
+    const found = await findCommentViaList(channel, target, evt.commentId);
+    replies = found?.reply_list?.replies ?? [];
+    quote = found?.quote || void 0;
+    isWhole = Boolean(found?.is_whole);
+  }
+  const targetReply = (evt.replyId ? replies.find((rr) => rr.reply_id === evt.replyId) : void 0) ?? replies[replies.length - 1];
+  const question = elementsToText(targetReply?.content?.elements ?? []);
+  return { question, quote, isWhole, targetReplyId: targetReply?.reply_id };
+}
+function elementsToText(elements) {
+  return elements.map((el) => {
+    if (el.type === "text_run") return el.text_run?.text ?? "";
+    if (el.type === "docs_link") return el.docs_link?.url ?? "";
+    return "";
+  }).join("").trim();
+}
+async function findCommentViaList(channel, target, commentId) {
+  let pageToken;
+  for (let page = 0; page < 10; page++) {
+    const r = await channel.rawClient.drive.v1.fileComment.list({
+      params: {
+        file_type: target.fileType,
+        page_size: 100,
+        ...pageToken ? { page_token: pageToken } : {}
+      },
+      path: { file_token: target.fileToken }
+    });
+    const items = r?.data?.items ?? [];
+    const hit = items.find((it) => it.comment_id === commentId);
+    if (hit) return hit;
+    if (!r?.data?.has_more || !r.data.page_token) {
+      return null;
+    }
+    pageToken = r.data.page_token;
+  }
+  log.warn("comment", "comment-not-found-after-paging", { commentId, pagesScanned: 10 });
+  return null;
+}
+var DOC_HOSTS = {
+  feishu: "feishu.cn",
+  lark: "larksuite.com"
+};
+function buildCommentPrompt(target, ctx, tenant) {
+  const docUrl = `https://${DOC_HOSTS[tenant]}/${target.fileType}/${target.fileToken}`;
+  const parts = [];
+  parts.push("\u6211\u5728\u98DE\u4E66\u4E91\u6587\u6863\u7684\u8BC4\u8BBA\u91CC\u88AB @\u4E86\uFF0C\u9700\u8981\u4F60\u56DE\u7B54\u8BC4\u8BBA\u4E2D\u7684\u95EE\u9898\u3002\u6587\u6863\u4FE1\u606F\uFF1A");
+  parts.push(`- \u94FE\u63A5\uFF1A${docUrl}`);
+  parts.push(`- file_token\uFF1A${target.fileToken}`);
+  parts.push(`- \u7C7B\u578B\uFF1A${target.fileType}`);
+  parts.push(`- \u8BC4\u8BBA\u8303\u56F4\uFF1A${ctx.isWhole ? "\u5168\u6587\u8BC4\u8BBA\uFF08\u9488\u5BF9\u6574\u7BC7\u6587\u6863\uFF09" : "\u884C\u5185\u8BC4\u8BBA\uFF08\u9488\u5BF9\u9009\u4E2D\u7684\u6587\u5B57\uFF09"}`);
+  if (ctx.quote) {
+    parts.push("");
+    parts.push(`\u7528\u6237\u9009\u4E2D\u7684\u539F\u6587\uFF1A
+> ${ctx.quote.replace(/\n/g, "\n> ")}`);
+  }
+  parts.push("");
+  parts.push(`\u7528\u6237\u7684\u95EE\u9898\uFF1A${ctx.question}`);
+  parts.push("");
+  parts.push(
+    `\u5982\u679C\u56DE\u7B54\u9700\u8981\u6587\u6863\u6B63\u6587\u5185\u5BB9\uFF0C\u53EF\u7528 lark-cli \u53EA\u8BFB\u5730\u83B7\u53D6\uFF08\u4EC5\u7528\u4E8E\u8BFB\u53D6\uFF0C\u4E0D\u8981\u7528\u5B83\u5199\u4EFB\u4F55\u4E1C\u897F\uFF09\uFF1A
+  lark-cli docs +fetch --doc ${target.fileToken} --api-version v2`
+  );
+  parts.push("");
+  parts.push("\u3010\u975E\u5E38\u91CD\u8981\uFF0C\u52A1\u5FC5\u9075\u5B88\u3011");
+  parts.push(
+    "1. \u4E0D\u8981\u81EA\u5DF1\u53BB\u53D1\u8868 / \u56DE\u590D / \u4FEE\u6539\u4EFB\u4F55\u98DE\u4E66\u8BC4\u8BBA\u6216\u6587\u6863\uFF08\u4E5F\u4E0D\u8981\u7528 lark-cli \u6216\u4EFB\u4F55\u5DE5\u5177\u53BB\u53D1\u8BC4\u8BBA\uFF09\u2014\u2014\u7CFB\u7EDF\u4F1A\u81EA\u52A8\u628A\u4F60\u4E0B\u9762\u7ED9\u51FA\u7684\u6700\u7EC8\u56DE\u590D\u53D1\u5230\u8FD9\u6761\u8BC4\u8BBA\u91CC\uFF0C\u4F60\u53EA\u7BA1\u628A\u7B54\u6848\u5199\u51FA\u6765\u3002"
+  );
+  parts.push("2. \u53EA\u8F93\u51FA\u8981\u53D1\u7ED9\u7528\u6237\u7684\u300C\u6700\u7EC8\u7B54\u6848\u300D\u672C\u8EAB\uFF0C\u4E0D\u8981\u590D\u8FF0\u5206\u6790\u8FC7\u7A0B\u3001\u6B65\u9AA4\u3001\u6216\u300C\u6211\u73B0\u5728\u53BB\u2026\u300D\u8FD9\u7C7B\u8BF4\u660E\u3002");
+  parts.push(
+    "3. \u7528\u7EAF\u6587\u672C\uFF0C\u4E0D\u8981\u7528 markdown \u6807\u8BB0\uFF08\u4E0D\u8981 ** __ # - * > ` \u4E4B\u7C7B\uFF09\uFF0C\u4E0D\u8981\u4EE3\u7801\u5757\uFF1B\u8BC4\u8BBA\u6846\u4E0D\u6E32\u67D3 markdown\uFF0C\u4F1A\u539F\u6837\u663E\u793A\u8FD9\u4E9B\u7B26\u53F7\u3002\u56DE\u7B54\u7B80\u6D01\u76F4\u63A5\u3002"
+  );
+  return parts.join("\n");
+}
+function stripMarkdown(s) {
+  return s.replace(/```[a-zA-Z]*\n?/g, "").replace(/```/g, "").replace(/^#{1,6}\s+/gm, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/(?<![*\w])\*(?!\s)([^*\n]+?)(?<!\s)\*(?!\w)/g, "$1").replace(/(?<![_\w])_(?!\s)([^_\n]+?)(?<!\s)_(?!\w)/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^[-*]\s+/gm, "").replace(/^>\s?/gm, "");
+}
+async function postCommentReply(channel, target, evt, text) {
+  try {
+    await channel.rawClient.drive.v1.fileCommentReply.create({
+      params: { file_type: target.fileType },
+      path: { file_token: target.fileToken, comment_id: evt.commentId },
+      data: { content: { elements: [{ type: "text_run", text_run: { text } }] } }
+    });
+    log.info("comment", "replied", { mode: "in-thread" });
+    return;
+  } catch (err) {
+    if (apiErrCode(err) !== 1069302) throw err;
+    log.warn("comment", "reply-rejected-fallback-create", { code: 1069302 });
+  }
+  if (target.fileType !== "doc" && target.fileType !== "docx") {
+    log.warn("comment", "whole-doc-reply-unsupported", { fileType: target.fileType });
+    return;
+  }
+  await channel.rawClient.drive.v1.fileComment.create({
+    params: { file_type: target.fileType },
+    path: { file_token: target.fileToken },
+    data: {
+      reply_list: { replies: [{ content: { elements: [{ type: "text_run", text_run: { text } }] } }] }
+    }
+  });
+  log.info("comment", "replied", { mode: "new-top-level" });
+}
+async function addCommentReaction(channel, target, replyId) {
+  return commentReaction(channel, target, replyId, "add");
+}
+async function removeCommentReaction(channel, target, replyId) {
+  await commentReaction(channel, target, replyId, "delete");
+}
+async function commentReaction(channel, target, replyId, action) {
+  try {
+    await channel.rawClient.drive.v2.commentReaction.updateReaction({
+      params: { file_type: target.fileType },
+      path: { file_token: target.fileToken },
+      data: { action, reply_id: replyId, reaction_type: "Typing" }
+    });
+    log.info("comment", `reaction-${action}`, { fileToken: target.fileToken, replyId });
+    return true;
+  } catch (err) {
+    log.warn("comment", `reaction-${action}-failed`, {
+      replyId,
+      err: err instanceof Error ? err.message : String(err)
+    });
+    return false;
+  }
+}
+
+// src/bot/watchdog.ts
+async function* withIdleTimeout(source, idleMs, onTimeout, stop) {
+  if ((!idleMs || idleMs <= 0) && !stop) {
+    yield* source;
+    return;
+  }
+  const iter = source[Symbol.asyncIterator]();
+  const stopRace = stop?.then(() => "__stop__");
+  while (true) {
+    let timer;
+    const races = [iter.next()];
+    if (idleMs && idleMs > 0) {
+      races.push(new Promise((res) => {
+        timer = setTimeout(() => res("__idle__"), idleMs);
+      }));
+    }
+    if (stopRace) races.push(stopRace);
+    const raced = await Promise.race(races);
+    if (timer) clearTimeout(timer);
+    if (raced === "__idle__") {
+      onTimeout();
+      return;
+    }
+    if (raced === "__stop__") return;
+    const r = raced;
+    if (r.done) return;
+    yield r.value;
+  }
+}
+var Semaphore = class {
+  constructor(max) {
+    this.max = max;
+  }
+  max;
+  active = 0;
+  waiters = [];
+  /** True if acquire() would grant a slot without queueing. */
+  hasFree() {
+    return this.active < this.max;
+  }
+  async acquire() {
+    if (this.active >= this.max) {
+      await new Promise((res) => this.waiters.push(res));
+    }
+    this.active++;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.active--;
+      const next = this.waiters.shift();
+      if (next) next();
+    };
+  }
+};
+
+// src/bot/handle-message.ts
+function createOrchestrator(channel, cfg, fallbackCwd) {
+  const backend = createBackend();
+  const sessions = /* @__PURE__ */ new Map();
+  const active = /* @__PURE__ */ new Map();
+  const docLocks = /* @__PURE__ */ new Map();
+  const sema = new Semaphore(getMaxConcurrentRuns(cfg));
+  const idleMs = getRunIdleTimeoutMs(cfg) ?? 0;
+  const resumePending = /* @__PURE__ */ new Map();
+  const modelPending = /* @__PURE__ */ new Map();
+  const runsByCard = /* @__PURE__ */ new Map();
+  const runCards = /* @__PURE__ */ new Map();
+  const runStreams = /* @__PURE__ */ new Map();
+  const lastRunCard = /* @__PURE__ */ new Map();
+  let modelsCache = null;
+  async function listModels() {
+    if (!modelsCache) modelsCache = await backend.listModels();
+    return modelsCache;
+  }
+  function pickDefault(models) {
+    const def = models.find((m) => m.isDefault && !m.hidden) ?? models.find((m) => !m.hidden) ?? models[0];
+    return { model: def?.id ?? "gpt-5.5", effort: def?.defaultEffort ?? "medium" };
+  }
+  async function addReaction(messageId, emoji) {
+    try {
+      const r = await channel.rawClient.im.v1.messageReaction.create({
+        path: { message_id: messageId },
+        data: { reaction_type: { emoji_type: emoji } }
+      });
+      return r.data?.reaction_id;
+    } catch (err) {
+      log.fail("card", err, { phase: "reaction-add", emoji });
+      return void 0;
+    }
+  }
+  function removeReaction(messageId, reactionId) {
+    void channel.rawClient.im.v1.messageReaction.delete({ path: { message_id: messageId, reaction_id: reactionId } }).catch((err) => log.fail("card", err, { phase: "reaction-del" }));
+  }
+  function runReaction(messageId, queued) {
+    let chain = addReaction(messageId, queued ? "OneSecond" : "Typing");
+    let phase = queued ? 0 : 1;
+    const swap = (emoji) => {
+      chain = chain.then(async (prevId) => {
+        if (prevId) removeReaction(messageId, prevId);
+        return addReaction(messageId, emoji);
+      });
+    };
+    return {
+      started: () => {
+        if (phase < 1) {
+          phase = 1;
+          swap("Typing");
+        }
+      },
+      done: () => {
+        if (phase < 2) {
+          phase = 2;
+          chain = chain.then((prevId) => {
+            if (prevId) removeReaction(messageId, prevId);
+            return void 0;
+          });
+        }
+      }
+    };
+  }
+  const onMessage = async (msg) => {
+    log.info("intake", "recv", {
+      chatType: msg.chatType,
+      mentionedBot: msg.mentionedBot,
+      threadId: msg.threadId ?? null,
+      preview: msg.content.slice(0, 40)
+    });
+    if (msg.chatType === "p2p") {
+      await handleDmConsole(channel, cfg, msg);
+      return;
+    }
+    const project = await getProjectByChatId(msg.chatId);
+    if (!msg.mentionedBot && !(project && shouldRespondWithoutMention(project, msg))) return;
+    if (!isChatAllowed(cfg, msg.chatId) || !isUserAllowed(cfg, msg.senderId)) {
+      log.info("intake", "reject", { reason: "not_allowed", chatId: msg.chatId.slice(-6) });
+      return;
+    }
+    const text = msg.content.trim();
+    const cmd = parseCommand(text);
+    if ((project?.kind ?? "multi") === "single") {
+      if (cmd === "help") {
+        await postHelpCard(msg, "single");
+        return;
+      }
+      if (cmd === "settings") {
+        await postGroupSettings(msg, project);
+        return;
+      }
+      if (cmd === "model") {
+        await postModelCard(msg, msg.chatId);
+        return;
+      }
+      handleTurn(msg, text, msg.chatId, true, project);
+      return;
+    }
+    if (msg.threadId) {
+      if (cmd === "help") {
+        await postHelpCard(msg, "topic", true);
+        return;
+      }
+      if (cmd === "model") {
+        await postModelCard(msg, msg.threadId);
+        return;
+      }
+      handleTurn(msg, text, msg.threadId, false, project);
+      return;
+    }
+    if (cmd === "help") {
+      await postHelpCard(msg, "main");
+      return;
+    }
+    if (cmd === "resume") {
+      await postResumeCard(msg);
+      return;
+    }
+    if (cmd === "settings") {
+      await postGroupSettings(msg, project);
+      return;
+    }
+    if (cmd === "model") {
+      await channel.send(msg.chatId, { markdown: "`/model` \u9700\u8981\u5728\u8BDD\u9898\u91CC\u4F7F\u7528\uFF08\u5148 @\u6211 \u5F00\u4E2A\u8BDD\u9898\uFF09\u3002" }, { replyTo: msg.messageId }).catch(() => void 0);
+      return;
+    }
+    startTopicDirectly(msg, text, project);
+  };
+  function parseCommand(text) {
+    const m = /^\/(\w+)/.exec(text);
+    const name = m?.[1]?.toLowerCase();
+    return name === "resume" || name === "model" || name === "settings" || name === "help" ? name : null;
+  }
+  function shouldRespondWithoutMention(project, msg) {
+    if (!(project.noMention ?? true)) return false;
+    if (msg.mentionAll || msg.mentions.some((m) => !m.isBot)) return false;
+    if ((project.kind ?? "multi") === "single") return true;
+    return Boolean(msg.threadId) || parseCommand(msg.content.trim()) !== null;
+  }
+  async function postGroupSettings(msg, project) {
+    if (!isAdmin(cfg, msg.senderId)) {
+      await channel.send(msg.chatId, { markdown: "\u4EC5\u7BA1\u7406\u5458\u53EF\u6539\u7FA4\u8BBE\u7F6E\u3002" }, { replyTo: msg.messageId }).catch(() => void 0);
+      return;
+    }
+    if (!project) {
+      await channel.send(msg.chatId, { markdown: "\u672C\u7FA4\u672A\u7ED1\u5B9A\u9879\u76EE\uFF0C\u8BF7\u5148\u5728\u79C1\u804A\u91CC\u65B0\u5EFA\u9879\u76EE\u3002" }, { replyTo: msg.messageId }).catch(() => void 0);
+      return;
+    }
+    await withTrace({ chatId: msg.chatId, msgId: msg.messageId }, async () => {
+      await sendManagedCard(channel, msg.chatId, buildGroupSettingsCard(project), msg.messageId);
+      log.info("card", "group-settings", { project: project.name });
+    });
+  }
+  async function handleTurn(msg, text, sessionKey, flat, project) {
+    const existing = active.get(sessionKey);
+    if (existing) {
+      if (getPendingPolicy(cfg) === "steer" && existing.run && existing.thread) {
+        const tid = existing.run.turnId();
+        if (tid) {
+          try {
+            await existing.thread.steer({ text }, tid);
+            log.info("intake", "steer", { tid });
+            return;
+          } catch (err) {
+            log.warn("intake", "steer-failed", { err: String(err) });
+          }
+        }
+      }
+      existing.queue.push(text);
+      log.info("intake", "queued", { depth: existing.queue.length });
+      return;
+    }
+    const reserved = { queue: [], requesterOpenId: msg.senderId };
+    active.set(sessionKey, reserved);
+    void withTrace({ chatId: msg.chatId, msgId: msg.messageId }, async () => {
+      const reaction = runReaction(msg.messageId, !sema.hasFree());
+      try {
+        let thread = await resolveThread(sessionKey, msg.chatId);
+        if (!thread) {
+          const cwd = project?.cwd ?? fallbackCwd;
+          thread = await backend.startThread({ cwd });
+          sessions.set(sessionKey, thread);
+          await upsertSession({
+            threadId: sessionKey,
+            chatId: msg.chatId,
+            cwd,
+            codexThreadId: thread.codexThreadId,
+            summary: text.slice(0, 80),
+            createdAt: Date.now(),
+            updatedAt: Date.now()
+          });
+        }
+        reserved.thread = thread;
+        await launchRun(
+          {
+            chatId: msg.chatId,
+            replyTo: msg.messageId,
+            replyInThread: !flat,
+            flat,
+            thread,
+            firstText: text,
+            knownThreadId: sessionKey,
+            requesterOpenId: msg.senderId
+          },
+          reaction
+        );
+      } catch (err) {
+        active.delete(sessionKey);
+        reaction.done();
+        log.fail("intake", err);
+        await channel.send(msg.chatId, { markdown: `\u274C ${err instanceof Error ? err.message : String(err)}` }, { replyTo: msg.messageId, replyInThread: !flat }).catch(() => void 0);
+      }
+    });
+  }
+  async function resolveThread(threadId, chatId) {
+    const live = sessions.get(threadId);
+    if (live) return live;
+    const rec = await getSession(threadId);
+    if (!rec) return void 0;
+    try {
+      const resumed = await backend.resumeThread({
+        cwd: rec.cwd,
+        codexThreadId: rec.codexThreadId,
+        model: rec.model,
+        effort: rec.effort
+      });
+      sessions.set(threadId, resumed);
+      return resumed;
+    } catch (err) {
+      log.fail("agent", err, { phase: "resume-on-turn", threadId });
+      const project = await getProjectByChatId(chatId);
+      const cwd = project?.cwd ?? rec.cwd ?? fallbackCwd;
+      const fresh = await backend.startThread({ cwd, model: rec.model, effort: rec.effort });
+      sessions.set(threadId, fresh);
+      return fresh;
+    }
+  }
+  function startTopicDirectly(msg, text, project) {
+    void withTrace({ chatId: msg.chatId, msgId: msg.messageId }, async () => {
+      const reaction = runReaction(msg.messageId, !sema.hasFree());
+      const cwd = project?.cwd ?? fallbackCwd;
+      if (project) void refreshBranch(channel, project).catch(() => void 0);
+      const { model, effort } = pickDefault(await listModels());
+      let thread;
+      try {
+        thread = await backend.startThread({ cwd, model, effort });
+      } catch (err) {
+        reaction.done();
+        log.fail("card", err, { phase: "start-topic" });
+        await channel.send(msg.chatId, { markdown: `\u274C \u542F\u52A8\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}` }, { replyTo: msg.messageId }).catch(() => void 0);
+        return;
+      }
+      const firstText = text || "\u4F60\u597D\uFF0C\u6211\u4EEC\u5F00\u59CB\u5427\u3002";
+      log.info("card", "start", { project: project?.name ?? "(unregistered)", model, effort });
+      await launchRun(
+        {
+          chatId: msg.chatId,
+          replyTo: msg.messageId,
+          replyInThread: true,
+          thread,
+          firstText,
+          model,
+          effort,
+          cwd,
+          summary: text.slice(0, 80) || "(\u7A7A)",
+          requesterOpenId: msg.senderId
+        },
+        reaction,
+        () => reaction.done()
+        // topic created → ✅ DONE (don't wait for the reply)
+      );
+    }).catch((err) => log.fail("intake", err));
+  }
+  async function postResumeCard(msg) {
+    await withTrace({ chatId: msg.chatId, msgId: msg.messageId }, async () => {
+      const project = await getProjectByChatId(msg.chatId);
+      const cwd = project?.cwd ?? fallbackCwd;
+      const threads = await backend.listThreads(cwd);
+      const state = {
+        chatId: msg.chatId,
+        originalMsgId: msg.messageId,
+        requesterOpenId: msg.senderId,
+        cwd,
+        projectName: project?.name,
+        threads,
+        createdAt: Date.now()
+      };
+      const res = await sendManagedCard(channel, msg.chatId, buildResumeCard(state), msg.messageId);
+      pruneResumePending();
+      resumePending.set(res.messageId, state);
+      log.info("card", "resume", { project: project?.name ?? "(unregistered)", threads: threads.length });
+    });
+  }
+  async function postModelCard(msg, sessionKey) {
+    await withTrace({ chatId: msg.chatId, msgId: msg.messageId }, async () => {
+      const [models, rec] = await Promise.all([listModels(), getSession(sessionKey)]);
+      const def = pickDefault(models);
+      const state = {
+        chatId: msg.chatId,
+        threadId: sessionKey,
+        requesterOpenId: msg.senderId,
+        models,
+        model: rec?.model ?? def.model,
+        effort: rec?.effort ?? def.effort,
+        createdAt: Date.now()
+      };
+      const res = await sendManagedCard(channel, msg.chatId, buildModelCard(state), msg.messageId, true);
+      pruneModelPending();
+      modelPending.set(res.messageId, state);
+      log.info("card", "model", { threadId: sessionKey, model: state.model, effort: state.effort });
+    });
+  }
+  async function postHelpCard(msg, scope, inThread = false) {
+    await withTrace({ chatId: msg.chatId, msgId: msg.messageId }, async () => {
+      await sendManagedCard(channel, msg.chatId, buildHelpCard(scope), msg.messageId, inThread).catch(
+        (err) => log.fail("card", err, { cmd: "help", scope })
+      );
+      log.info("card", "help", { scope });
+    });
+  }
+  const dispatcher = new CardDispatcher(channel, cfg);
+  const PENDING_TTL_MS = 30 * 6e4;
+  const CARD_SETTLE_MS = 500;
+  const settleUpdate = (msgId, c, fallbackChatId) => {
+    const armedAt = Date.now();
+    void (async () => {
+      await new Promise((r) => setTimeout(r, CARD_SETTLE_MS));
+      const card2 = typeof c === "function" ? await c() : c;
+      const ok = await updateManagedCard(channel, msgId, card2);
+      log.info("console", "settle-update", { msgId, ok, waitedMs: Date.now() - armedAt, fallback: !ok && !!fallbackChatId });
+      if (!ok && fallbackChatId) {
+        await sendManagedCard(channel, fallbackChatId, card2).catch(
+          (err) => log.fail("console", err, { phase: "settle-fallback" })
+        );
+      }
+    })();
+  };
+  function pruneResumePending() {
+    const now = Date.now();
+    for (const [k, s] of resumePending) if (now - s.createdAt > PENDING_TTL_MS) resumePending.delete(k);
+  }
+  function pruneModelPending() {
+    const now = Date.now();
+    for (const [k, s] of modelPending) if (now - s.createdAt > PENDING_TTL_MS) modelPending.delete(k);
+  }
+  function authPending(map, evt) {
+    const state = map.get(evt.messageId);
+    if (!state) return void 0;
+    if (Date.now() - state.createdAt > PENDING_TTL_MS) {
+      map.delete(evt.messageId);
+      return void 0;
+    }
+    const op = evt.operator?.openId ?? "";
+    if (op !== state.requesterOpenId || !isChatAllowed(cfg, state.chatId) || !isUserAllowed(cfg, op)) {
+      log.info("card", "action-denied", { reason: "not-allowed" });
+      return void 0;
+    }
+    return state;
+  }
+  dispatcher.on(MC.model, ({ evt, option }) => {
+    const state = authPending(modelPending, evt);
+    if (!state || !option) return;
+    settleUpdate(evt.messageId, async () => {
+      state.model = option;
+      const m = state.models.find((x) => x.id === option);
+      if (m && m.supportedEfforts.length && !m.supportedEfforts.includes(state.effort)) {
+        state.effort = m.defaultEffort;
+      }
+      await patchSession(state.threadId, { model: state.model, effort: state.effort });
+      state.note = `\u2705 \u5DF2\u5207\u6362\u6A21\u578B\u300C${m?.displayName ?? option}\u300D\uFF0C\u4E0B\u4E00\u8F6E\u751F\u6548`;
+      return buildModelCard(state);
+    });
+  }).on(MC.effort, ({ evt, option }) => {
+    const state = authPending(modelPending, evt);
+    if (!state || !option) return;
+    settleUpdate(evt.messageId, async () => {
+      state.effort = option;
+      await patchSession(state.threadId, { effort: state.effort });
+      state.note = "\u2705 \u5DF2\u8BBE\u7F6E effort\uFF0C\u4E0B\u4E00\u8F6E\u751F\u6548";
+      return buildModelCard(state);
+    });
+  }).on(RES.pick, ({ evt, value }) => {
+    const state = authPending(resumePending, evt);
+    const codexThreadId = typeof value.t === "string" ? value.t : void 0;
+    if (!state || !codexThreadId || state.launching) return;
+    state.launching = true;
+    settleUpdate(evt.messageId, buildResumeLaunchingCard(state));
+    void resumeFromCard(evt, state, codexThreadId);
+  });
+  const runAllowed = (evt) => isChatAllowed(cfg, evt.chatId) && isUserAllowed(cfg, evt.operator?.openId ?? "");
+  const runOwnerOrAdmin = (evt, ownerOpenId) => {
+    if (!runAllowed(evt)) return false;
+    const op = evt.operator?.openId ?? "";
+    return op === ownerOpenId || isAdmin(cfg, op);
+  };
+  dispatcher.on(RC.stop, ({ evt, value }) => {
+    const key = typeof value.m === "string" ? value.m : evt.messageId;
+    const st = runsByCard.get(key);
+    if (!st || !runOwnerOrAdmin(evt, st.requesterOpenId)) return;
+    st.interrupt?.();
+    log.info("card", "action", { actionId: "run.stop", stopped: Boolean(st.interrupt) });
+  });
+  const dmAdmin = (openId) => isAdmin(cfg, openId ?? "");
+  const patch = (evt, c) => settleUpdate(evt.messageId, c, evt.chatId);
+  function applyPref(evt, mut) {
+    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));
+  }
+  const freshMenu = (evt) => {
+    patch(evt, buildDmMenuCard());
+  };
+  const renderProjectList = async () => {
+    const [projects, sessions2] = await Promise.all([listProjects(), listSessions()]);
+    const byChat = /* @__PURE__ */ new Map();
+    for (const s of sessions2) {
+      const arr = byChat.get(s.chatId);
+      if (arr) arr.push(s);
+      else byChat.set(s.chatId, [s]);
+    }
+    return buildProjectListCard(projects, byChat);
+  };
+  dispatcher.on(DM.menu, ({ evt }) => {
+    if (dmAdmin(evt.operator?.openId)) freshMenu(evt);
+  }).on(DM.newProject, ({ evt }) => {
+    if (dmAdmin(evt.operator?.openId)) patch(evt, buildNewProjectFormCard());
+  }).on(DM.newProjectSubmit, ({ evt, formValue, value }) => {
+    const op = evt.operator?.openId;
+    if (!dmAdmin(op)) return;
+    const name = String(formValue?.name ?? "").trim();
+    const cwdIn = String(formValue?.cwd ?? "").trim();
+    const kind = value.kind === "single" ? "single" : "multi";
+    void (async () => {
+      let result;
+      if (!name) result = buildNewProjectFormCard({ cwd: cwdIn, error: "\u9879\u76EE\u540D\u4E0D\u80FD\u4E3A\u7A7A" });
+      else if (!op) result = buildNewProjectFormCard({ name, cwd: cwdIn, error: "\u65E0\u6CD5\u8BC6\u522B\u64CD\u4F5C\u8005\u8EAB\u4EFD" });
+      else {
+        try {
+          const p = await createProject(channel, { name, ownerOpenId: op, existingPath: cwdIn || void 0, kind });
+          log.info("console", "new-project", { name: p.name, blank: p.blank });
+          result = buildNewProjectDoneCard(p);
+        } catch (err) {
+          result = buildNewProjectFormCard({ name, cwd: cwdIn, error: err instanceof Error ? err.message : String(err) });
+        }
+      }
+      await sendManagedCard(channel, evt.chatId, result).catch(
+        (e) => log.fail("console", e, { phase: "new-project-result" })
+      );
+    })();
+  }).on(DM.projects, ({ evt }) => {
+    if (!dmAdmin(evt.operator?.openId)) return;
+    patch(evt, renderProjectList);
+  }).on(DM.settings, async ({ evt }) => {
+    if (dmAdmin(evt.operator?.openId)) await patch(evt, buildSettingsCard(cfg));
+  }).on(DM.doctor, async ({ evt }) => {
+    if (!dmAdmin(evt.operator?.openId)) return;
+    const ok = await backend.isAvailable().catch(() => false);
+    const conn = channel.getConnectionStatus?.()?.state ?? "unknown";
+    await channel.send(evt.chatId, { markdown: `\u{1FA7A} **\u8BCA\u65AD**
+- codex: ${ok ? "\u2705 \u53EF\u7528" : "\u274C \u4E0D\u53EF\u7528\uFF08\u68C0\u67E5 CODEX_BIN/PATH\uFF09"}
+- \u957F\u8FDE\u63A5: ${conn}` }, { replyTo: evt.messageId }).catch(() => void 0);
+  }).on(DM.reconnect, async ({ evt }) => {
+    if (!dmAdmin(evt.operator?.openId)) return;
+    const conn = channel.getConnectionStatus?.()?.state ?? "unknown";
+    await channel.send(evt.chatId, { markdown: `\u{1F504} \u957F\u8FDE\u63A5\u72B6\u6001\uFF1A**${conn}**
+SDK \u4F1A\u81EA\u52A8\u91CD\u8FDE\uFF1B\u82E5\u957F\u671F\u65AD\u5F00\uFF0C\u8BF7\u5728\u7EC8\u7AEF\u91CD\u8DD1 \`feishu-codex-bridge run\`\uFF08\u524D\u53F0\uFF09\u6216 \`feishu-codex-bridge restart\`\uFF08\u540E\u53F0\u5B88\u62A4\uFF09\u3002` }, { replyTo: evt.messageId }).catch(() => void 0);
+  }).on(DM.rmConfirm, async ({ evt, value }) => {
+    const name = typeof value.n === "string" ? value.n : void 0;
+    if (!dmAdmin(evt.operator?.openId) || !name) return;
+    await patch(evt, buildRmConfirmCard(name));
+  }).on(DM.rmCancel, ({ evt }) => {
+    if (!dmAdmin(evt.operator?.openId)) return;
+    patch(evt, renderProjectList);
+  }).on(DM.rmDo, ({ evt, value }) => {
+    const name = typeof value.n === "string" ? value.n : void 0;
+    const op = evt.operator?.openId;
+    if (!dmAdmin(op) || !name) return;
+    patch(evt, async () => {
+      const removed = await removeProject(name);
+      let transferred = false;
+      if (removed?.chatId && op) {
+        transferred = await transferOwnership(channel, removed.chatId, op).then(() => true).catch((err) => {
+          log.fail("console", err, { phase: "owner-transfer" });
+          return false;
+        });
+      }
+      log.info("console", "rm", { name, transferred });
+      const tail = transferred ? "\u7FA4\u4E3B\u5DF2\u8F6C\u7ED9\u4F60 \u2192 \u8BF7\u5728\u98DE\u4E66\u91CC**\u81EA\u884C\u89E3\u6563\u8BE5\u7FA4**\uFF08\u673A\u5668\u4EBA\u4E0D\u4E3B\u52A8\u89E3\u6563\uFF09\u3002" : "\u26A0\uFE0F \u7FA4\u4E3B\u8F6C\u8BA9\u5931\u8D25\uFF08\u53EF\u80FD bot \u975E\u7FA4\u4E3B\uFF09\uFF0C\u8BF7\u7528\u300C\u{1F6AA} \u7FA4\u7BA1\u7406\u300D\u624B\u52A8\u8F6C\u8BA9\u540E\u89E3\u6563\u3002";
+      await channel.send(evt.chatId, { markdown: `\u2705 \u5DF2\u5220\u9664\u9879\u76EE\u300C${name}\u300D\uFF08\u89E3\u7ED1\uFF0C\u672A\u5220\u4EE3\u7801\u76EE\u5F55\uFF09\u3002
+${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
+      return renderProjectList();
+    });
+  }).on(DM.setTools, ({ evt, value }) => {
+    applyPref(evt, (p) => p.showToolCalls = value.v === "on");
+  }).on(DM.setWatchdog, ({ evt, value }) => {
+    const n = Number(value.v);
+    if (Number.isFinite(n)) applyPref(evt, (p) => p.runIdleTimeoutSeconds = n);
+  }).on(DM.setPending, ({ evt, value }) => {
+    if (value.v === "steer" || value.v === "queue") applyPref(evt, (p) => p.pendingPolicy = value.v);
+  }).on(DM.setConcurrency, ({ evt, value }) => {
+    const n = Number(value.v);
+    if (Number.isFinite(n)) applyPref(evt, (p) => p.maxConcurrentRuns = n);
+  }).on(GS.setNoMention, ({ evt, value }) => {
+    if (!isAdmin(cfg, evt.operator?.openId ?? "")) return;
+    const on = value.v === "on";
+    patch(evt, async () => {
+      const project = await getProjectByChatId(evt.chatId);
+      if (project) {
+        await updateProject(project.name, { noMention: on });
+        log.info("console", "group-nomention", { project: project.name, on });
+        return buildGroupSettingsCard({ ...project, noMention: on });
+      }
+      return buildGroupSettingsCard({ name: "\u672C\u7FA4", kind: "multi", noMention: on });
+    });
+  });
+  async function resumeFromCard(evt, state, codexThreadId) {
+    try {
+      const history = await backend.readHistory(state.cwd, codexThreadId);
+      resumePending.delete(evt.messageId);
+      let bound = false;
+      await withTrace({ chatId: state.chatId, msgId: state.originalMsgId }, async () => {
+        const cardState = { cwd: state.cwd, projectName: state.projectName, history };
+        const sent = await sendManagedCard(channel, state.chatId, buildHistoryCard(cardState), state.originalMsgId, true);
+        let tid;
+        for (let attempt = 0; attempt < 4 && !tid; attempt++) {
+          if (attempt > 0) await new Promise((r) => setTimeout(r, 500));
+          tid = await getThreadId(channel, sent.messageId);
+        }
+        if (tid) {
+          const now = Date.now();
+          await upsertSession({
+            threadId: tid,
+            chatId: state.chatId,
+            cwd: state.cwd,
+            codexThreadId,
+            summary: history.name || history.preview || "(\u6062\u590D\u4F1A\u8BDD)",
+            createdAt: now,
+            updatedAt: now
+          });
+          bound = true;
+        } else {
+          log.warn("card", "resume-no-threadid", { messageId: sent.messageId });
+        }
+        log.info("card", "resume-done", { codexThreadId, threadId: tid ?? null, bound, turns: history.totalTurns });
+      });
+      settleUpdate(
+        evt.messageId,
+        bound ? buildResumeDoneCard(state) : buildResumeErrorCard(state, "\u5DF2\u5EFA\u8BDD\u9898\u4F46\u672A\u80FD\u7ED1\u5B9A\u4F1A\u8BDD\uFF0C\u8BF7\u91CD\u65B0 /resume")
+      );
+    } catch (err) {
+      state.launching = false;
+      log.fail("card", err, { phase: "resume-launch" });
+      settleUpdate(evt.messageId, buildResumeErrorCard(state, err instanceof Error ? err.message : String(err)));
+    }
+  }
+  async function launchRun(opts, reaction, onTopicCreated) {
+    const release = await sema.acquire();
+    reaction?.started();
+    let firstCardSent = false;
+    let activeKey = opts.knownThreadId ?? `pending:${opts.replyTo}`;
+    let topicThreadId = opts.knownThreadId;
+    const state = active.get(activeKey) ?? { queue: [], requesterOpenId: opts.requesterOpenId };
+    state.thread = opts.thread;
+    if (opts.requesterOpenId) state.requesterOpenId = opts.requesterOpenId;
+    active.set(activeKey, state);
+    if (opts.knownThreadId) sessions.set(opts.knownThreadId, opts.thread);
+    const persist = async (threadId) => {
+      await upsertSession({
+        threadId,
+        chatId: opts.chatId,
+        cwd: opts.cwd ?? fallbackCwd,
+        codexThreadId: opts.thread.codexThreadId,
+        model: opts.model,
+        effort: opts.effort,
+        summary: opts.summary ?? opts.firstText.slice(0, 80),
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      }).catch(() => void 0);
+    };
+    const promoteCard = (cardMsgId, rc) => {
+      if (!topicThreadId) return;
+      const prev = lastRunCard.get(topicThreadId);
+      if (prev && prev !== cardMsgId) {
+        const prevState = runCards.get(prev);
+        const prevStream = runStreams.get(prev);
+        if (prevState && prevStream) void prevStream.updateCard(channel, buildRunCardPlain(prevState));
+        runCards.delete(prev);
+        runStreams.delete(prev);
+      }
+      lastRunCard.set(topicThreadId, cardMsgId);
+      runCards.set(cardMsgId, rc);
+    };
+    let curCardKey;
+    try {
+      let turnText = opts.firstText;
+      let replyTo = opts.replyTo;
+      let replyInThread = opts.flat ? false : opts.replyInThread ?? Boolean(opts.knownThreadId);
+      for (; ; ) {
+        const rec = topicThreadId ? await getSession(topicThreadId) : void 0;
+        const turnModel = rec?.model ?? opts.model;
+        const turnEffort = rec?.effort ?? opts.effort;
+        const run = opts.thread.runStreamed({ text: turnText }, { model: turnModel, effort: turnEffort });
+        state.run = run;
+        const render = new RunRender();
+        render.showTools = getShowToolCalls(cfg);
+        let cardMsgId;
+        const rc = {
+          rs: render.snapshot(),
+          requesterOpenId: opts.requesterOpenId,
+          showTools: render.showTools
+        };
+        const adoptThreadId = async (messageId) => {
+          if (activeKey.startsWith("pending:")) {
+            const tid = await getThreadId(channel, messageId);
+            if (tid) {
+              active.delete(activeKey);
+              active.set(tid, state);
+              sessions.set(tid, opts.thread);
+              activeKey = tid;
+              topicThreadId = tid;
+              rc.threadId = tid;
+              await persist(tid);
+            }
+          } else {
+            topicThreadId = activeKey;
+            rc.threadId = activeKey;
+          }
+        };
+        const stream2 = new RunCardStream();
+        cardMsgId = await stream2.create(channel, opts.chatId, buildRunCard(rc), { replyTo, replyInThread });
+        curCardKey = cardMsgId;
+        rc.cardKey = cardMsgId;
+        runsByCard.set(cardMsgId, state);
+        runStreams.set(cardMsgId, stream2);
+        await adoptThreadId(cardMsgId);
+        if (!firstCardSent) {
+          firstCardSent = true;
+          try {
+            onTopicCreated?.();
+          } catch {
+          }
+        }
+        let timedOut = false;
+        let interrupted = false;
+        let resolveStop;
+        const stopSignal = new Promise((res) => {
+          resolveStop = res;
+        });
+        state.interrupt = () => {
+          if (interrupted) return;
+          interrupted = true;
+          resolveStop();
+        };
+        const guarded = withIdleTimeout(
+          run.events,
+          idleMs,
+          () => {
+            timedOut = true;
+          },
+          stopSignal
+        );
+        for await (const ev of guarded) {
+          render.apply(ev);
+          rc.rs = render.snapshot();
+          await stream2.streamCard(channel, buildRunCard(rc));
+        }
+        state.interrupt = void 0;
+        const killed = interrupted || timedOut;
+        if (timedOut) render.timeout(Math.max(1, Math.round(idleMs / 6e4)));
+        else if (interrupted) render.interrupt();
+        else render.finalize();
+        rc.rs = render.snapshot();
+        if (killed) {
+          void opts.thread.close().catch(() => void 0);
+          if (topicThreadId) sessions.delete(topicThreadId);
+        }
+        const finalMsgId = cardMsgId;
+        await adoptThreadId(finalMsgId);
+        rc.cardKey = finalMsgId;
+        await stream2.updateCard(channel, buildRunCard(rc));
+        runsByCard.delete(cardMsgId);
+        promoteCard(finalMsgId, rc);
+        if (topicThreadId) await patchSession(topicThreadId, { updatedAt: Date.now() });
+        replyTo = finalMsgId;
+        replyInThread = !opts.flat;
+        log.info("card", "final", { terminal: render.terminal() });
+        if (killed) break;
+        if (state.queue.length === 0) break;
+        turnText = state.queue.shift();
+      }
+    } catch (err) {
+      log.fail("intake", err);
+      await channel.send(opts.chatId, { markdown: `\u274C ${err instanceof Error ? err.message : String(err)}` }, { replyTo: opts.replyTo, replyInThread: !opts.flat }).catch(() => void 0);
+    } finally {
+      active.delete(activeKey);
+      if (curCardKey) runsByCard.delete(curCardKey);
+      reaction?.done();
+      release();
+    }
+  }
+  const onComment = async (evt) => {
+    await withTrace({ chatId: "comment" }, async () => {
+      log.info("comment", "enter", {
+        doc: evt.fileToken,
+        fileType: evt.fileType,
+        commentId: evt.commentId,
+        replyId: evt.replyId ?? null,
+        mentionedBot: evt.mentionedBot,
+        sender: evt.operator.openId
+      });
+      if (!evt.mentionedBot) return log.info("comment", "skip", { reason: "not-mentioned" });
+      if (!SUPPORTED_FILE_TYPES.has(evt.fileType))
+        return log.info("comment", "skip", { reason: "unsupported-fileType", fileType: evt.fileType });
+      if (!isUserAllowed(cfg, evt.operator.openId))
+        return log.info("comment", "skip", { reason: "not-allowed" });
+      const resolved = await resolveComment(channel, evt);
+      if (!resolved) return log.info("comment", "skip", { reason: "no-target-or-empty" });
+      const { target, ctx } = resolved;
+      log.info("comment", "parsed", { isWhole: ctx.isWhole, hasQuote: Boolean(ctx.quote) });
+      const prompt = buildCommentPrompt(target, ctx, cfg.accounts.app.tenant);
+      const sessionKey = `doc:${evt.fileToken}`;
+      const reacted = ctx.targetReplyId ? await addCommentReaction(channel, target, ctx.targetReplyId) : false;
+      try {
+        await withDocLock(sessionKey, async () => {
+          const release = await sema.acquire();
+          try {
+            const thread = await resolveDocThread(sessionKey, ctx.question);
+            const rec = await getSession(sessionKey);
+            const run = thread.runStreamed({ text: prompt }, { model: rec?.model, effort: rec?.effort });
+            let state = initialState;
+            let timedOut = false;
+            const guarded = withIdleTimeout(run.events, idleMs, () => {
+              timedOut = true;
+            });
+            for await (const ev of guarded) state = reduce(state, ev);
+            if (timedOut) {
+              const tid = run.turnId();
+              if (tid) void thread.abort(tid).catch(() => void 0);
+              void thread.close().catch(() => void 0);
+              sessions.delete(sessionKey);
+            } else {
+              await patchSession(sessionKey, { updatedAt: Date.now() });
+            }
+            let reply = stripMarkdown(finalMessageText(state)).trim();
+            if (state.terminal === "error" && state.errorMsg) reply = `\u26A0\uFE0F \u51FA\u9519\u4E86\uFF1A${state.errorMsg}`;
+            if (!reply) reply = timedOut ? "\uFF08\u5904\u7406\u8D85\u65F6\uFF0C\u8BF7\u91CD\u8BD5\u6216\u628A\u95EE\u9898\u95EE\u5F97\u66F4\u5177\u4F53\u4E9B\uFF09" : "\uFF08\u6CA1\u6709\u53EF\u56DE\u590D\u7684\u5185\u5BB9\uFF09";
+            if (reply.length > REPLY_MAX_CHARS) reply = `${reply.slice(0, REPLY_MAX_CHARS - 1)}\u2026`;
+            await postCommentReply(channel, target, evt, reply).catch(
+              (err) => log.fail("comment", err, { step: "postCommentReply" })
+            );
+            log.info("comment", "done", { terminal: state.terminal, timedOut, len: reply.length });
+          } finally {
+            release();
+          }
+        });
+      } catch (err) {
+        log.fail("comment", err, { step: "run" });
+      } finally {
+        if (reacted && ctx.targetReplyId)
+          await removeCommentReaction(channel, target, ctx.targetReplyId).catch(() => void 0);
+      }
+    }).catch((err) => log.fail("comment", err));
+  };
+  function withDocLock(key, fn) {
+    const prev = docLocks.get(key) ?? Promise.resolve();
+    const run = prev.then(fn, fn);
+    const tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    docLocks.set(key, tail);
+    void tail.then(() => {
+      if (docLocks.get(key) === tail) docLocks.delete(key);
+    });
+    return run;
+  }
+  async function resolveDocThread(sessionKey, question) {
+    const live = sessions.get(sessionKey);
+    if (live) return live;
+    const rec = await getSession(sessionKey);
+    if (rec) {
+      try {
+        const resumed = await backend.resumeThread({
+          cwd: rec.cwd,
+          codexThreadId: rec.codexThreadId,
+          model: rec.model,
+          effort: rec.effort
+        });
+        sessions.set(sessionKey, resumed);
+        return resumed;
+      } catch (err) {
+        log.fail("agent", err, { phase: "comment-resume", sessionKey });
+      }
+    }
+    const { model, effort } = pickDefault(await listModels());
+    const fresh = await backend.startThread({ cwd: fallbackCwd, model, effort });
+    sessions.set(sessionKey, fresh);
+    await upsertSession({
+      threadId: sessionKey,
+      chatId: sessionKey,
+      cwd: fallbackCwd,
+      codexThreadId: fresh.codexThreadId,
+      model,
+      effort,
+      summary: question.slice(0, 80),
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    });
+    return fresh;
+  }
+  async function shutdown() {
+    const live = [...sessions.values()];
+    sessions.clear();
+    await Promise.allSettled(live.map((t) => t.close()));
+    log.info("bridge", "shutdown", { closed: live.length });
+  }
+  return { onMessage, onComment, dispatcher, shutdown };
+}
+async function getThreadId(channel, messageId) {
+  try {
+    const res = await channel.rawClient.im.v1.message.get({ path: { message_id: messageId } });
+    const items = res.data?.items;
+    const tid = items?.[0]?.thread_id;
+    if (!tid) log.warn("intake", "threadid-missing", { messageId });
+    return tid;
+  } catch (err) {
+    log.warn("intake", "threadid-lookup-failed", { messageId, err: String(err) });
+    return void 0;
+  }
+}
+
+// src/bot/bridge.ts
+async function startBridge(opts) {
+  const app = opts.cfg.accounts.app;
+  const channel = createLarkChannel({
+    appId: app.id,
+    appSecret: opts.appSecret,
+    domain: app.tenant === "lark" ? Domain.Lark : Domain.Feishu,
+    source: "feishu-codex-bridge",
+    // surface raw events so card-action handlers can read form submissions
+    // (action.form_value) — used by the new-project form.
+    includeRawEvent: true,
+    // Deliver ALL group messages (not just @bot) to `onMessage`. The SDK's
+    // PolicyGate otherwise drops non-@ group messages with reason 'no_mention'
+    // before they reach us, which would make 免@ impossible. We turn the SDK
+    // filter off and let our per-project gate (shouldRespondWithoutMention in
+    // handle-message) be the single source of truth for 免@. Non-@ delivery
+    // still requires the im:message.group_msg scope (Feishu-side push).
+    policy: { requireMention: false }
+  });
+  const orchestrator = createOrchestrator(channel, opts.cfg, opts.fallbackCwd);
+  channel.on("message", orchestrator.onMessage);
+  channel.on("cardAction", orchestrator.dispatcher.handle);
+  channel.on("comment", orchestrator.onComment);
+  channel.on("reject", (evt) => log.info("intake", "reject", { reason: evt.reason, msgId: evt.messageId }));
+  channel.on("error", (err) => log.fail("ws", err));
+  channel.on("reconnecting", () => log.info("ws", "reconnecting"));
+  channel.on("reconnected", () => log.info("ws", "reconnected"));
+  await channel.connect();
+  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 channel.disconnect().catch((err) => log.fail("ws", err, { phase: "disconnect" }));
+  };
+  return { channel, shutdown };
+}
+
+// src/core/single-instance.ts
+import { mkdirSync as mkdirSync2, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { dirname as dirname6 } from "path";
+var BridgeAlreadyRunningError = class extends Error {
+  constructor(pid) {
+    super(
+      `\u53E6\u4E00\u4E2A bridge \u8FDB\u7A0B\u5DF2\u5728\u8FD0\u884C (PID ${pid})\u3002\u5148\u505C\u6389\u5B83\uFF08kill ${pid}\uFF09\u518D\u542F\u52A8\u2014\u2014\u4E24\u4E2A\u8FDB\u7A0B\u4F1A\u62A2\u540C\u4E00 App \u7684\u5361\u7247\u56DE\u8C03\uFF0C\u5BFC\u81F4\u6309\u94AE\u65F6\u7075\u65F6\u4E0D\u7075\u3002`
+    );
+    this.pid = pid;
+    this.name = "BridgeAlreadyRunningError";
+  }
+  pid;
+};
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireSingleInstanceLock(appId) {
+  const file = paths.processesFile;
+  try {
+    const rec = JSON.parse(readFileSync(file, "utf8"));
+    if (rec.pid && rec.pid !== process.pid && rec.appId === appId && isAlive(rec.pid)) {
+      throw new BridgeAlreadyRunningError(rec.pid);
+    }
+  } catch (err) {
+    if (err instanceof BridgeAlreadyRunningError) throw err;
+  }
+  mkdirSync2(dirname6(file), { recursive: true });
+  const record = { pid: process.pid, appId, startedAt: Date.now() };
+  writeFileSync(file, `${JSON.stringify(record)}
+`, "utf8");
+  const release = () => {
+    try {
+      const rec = JSON.parse(readFileSync(file, "utf8"));
+      if (rec.pid === process.pid) unlinkSync(file);
+    } catch {
+    }
+  };
+  process.once("exit", release);
+  return release;
+}
+
+// src/cli/commands/run.ts
+async function runRun() {
+  const ready = await ensureOnboarded({ allowCreate: true });
+  if (!ready) {
+    process.exitCode = 1;
+    return;
+  }
+  const { cfg, secret } = ready;
+  let releaseLock;
+  try {
+    releaseLock = acquireSingleInstanceLock(cfg.accounts.app.id);
+  } catch (err) {
+    if (err instanceof BridgeAlreadyRunningError) {
+      console.error(`\u2717 ${err.message}`);
+      log.info("run", "already-running", { pid: err.pid });
+      process.exitCode = 1;
+      return;
+    }
+    throw err;
+  }
+  const fallbackCwd = process.env.FEISHU_CODEX_CWD || process.cwd();
+  console.log("\n\u6B63\u5728\u542F\u52A8\u957F\u8FDE\u63A5 bot\u2026");
+  console.log("\u79C1\u804A\u6211 `/new <\u540D>` \u5EFA\u9879\u76EE\uFF1B\u5728\u9879\u76EE\u7FA4\u91CC @\u6211 \u5E72\u6D3B\u3002Ctrl+C \u9000\u51FA\u3002\n");
+  const handle = await startBridge({ cfg, appSecret: secret, fallbackCwd });
+  let stopping = false;
+  const stop = (sig) => {
+    if (stopping) return;
+    stopping = true;
+    console.log(`
+\u6536\u5230 ${sig}\uFF0C\u6B63\u5728\u4F18\u96C5\u9000\u51FA\uFF08\u5173\u95ED\u6240\u6709 codex \u4F1A\u8BDD\uFF09\u2026`);
+    void handle.shutdown().catch((err) => log.fail("run", err, { phase: "shutdown" })).finally(() => {
+      releaseLock();
+      process.exit(0);
+    });
+  };
+  for (const sig of ["SIGINT", "SIGTERM"]) {
+    process.once(sig, () => stop(sig));
+  }
+  await new Promise(() => {
+  });
+}
+
+// src/service/launchd.ts
+import { spawn as spawn4, spawnSync } from "child_process";
+import { existsSync as existsSync5 } from "fs";
+import { appendFile, mkdir as mkdir7, rm as rm2, writeFile as writeFile6 } from "fs/promises";
+import { homedir as homedir3, userInfo as userInfo2 } from "os";
+import { dirname as dirname7, join as join8, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+var LAUNCHD_LABEL = "ai.feishu-codex-bridge.bot";
+function launchAgentPlistPath() {
+  return join8(homedir3(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+}
+function serviceStdoutPath() {
+  return join8(paths.appDir, "service.log");
+}
+function serviceStderrPath() {
+  return join8(paths.appDir, "service.err.log");
+}
+function resolveCliBinPath() {
+  const distDir = dirname7(fileURLToPath(import.meta.url));
+  return resolve2(distDir, "..", "bin", "feishu-codex-bridge.mjs");
+}
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function buildPlist() {
+  const nodePath = process.execPath;
+  const cliBinPath = resolveCliBinPath();
+  const pathEnv = process.env.PATH ?? "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(nodePath)}</string>
+    <string>${escapeXml(cliBinPath)}</string>
+    <string>run</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(serviceStdoutPath())}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(serviceStderrPath())}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${escapeXml(pathEnv)}</string>
+  </dict>
+</dict>
+</plist>
+`;
+}
+async function installLaunchd() {
+  const plistPath = launchAgentPlistPath();
+  await mkdir7(dirname7(plistPath), { recursive: true });
+  await ensureLogFiles();
+  await writeFile6(plistPath, buildPlist(), "utf8");
+  if (isLoaded()) {
+    const bootout = runLaunchctl(["bootout", serviceTarget()]);
+    if (!bootout.ok) throw launchctlError("launchctl bootout", bootout);
+    await waitUntilUnloaded();
+  }
+  const bootstrap = runLaunchctl(["bootstrap", userTarget(), plistPath]);
+  if (!bootstrap.ok) throw launchctlError("launchctl bootstrap", bootstrap);
+  return statusLaunchd();
+}
+async function uninstallLaunchd() {
+  if (isLoaded()) {
+    const bootout = runLaunchctl(["bootout", serviceTarget()]);
+    if (!bootout.ok) throw launchctlError("launchctl bootout", bootout);
+    await waitUntilUnloaded();
+  }
+  await rm2(launchAgentPlistPath(), { force: true });
+}
+async function restartLaunchd() {
+  if (!existsSync5(launchAgentPlistPath())) {
+    throw new Error(`launchd service \u672A\u5B89\u88C5\uFF1A${launchAgentPlistPath()}`);
+  }
+  if (isLoaded()) {
+    const bootout = runLaunchctl(["bootout", serviceTarget()]);
+    if (!bootout.ok) throw launchctlError("launchctl bootout", bootout);
+    await waitUntilUnloaded();
+  }
+  const bootstrap = runLaunchctl(["bootstrap", userTarget(), launchAgentPlistPath()]);
+  if (!bootstrap.ok) throw launchctlError("launchctl bootstrap", bootstrap);
+  return statusLaunchd();
+}
+function statusLaunchd() {
+  const result = runLaunchctl(["print", serviceTarget()]);
+  const raw = result.stdout || result.stderr;
+  const parsed = parseLaunchdStatus(raw);
+  return {
+    installed: existsSync5(launchAgentPlistPath()),
+    loaded: result.ok,
+    plistPath: launchAgentPlistPath(),
+    stdoutPath: serviceStdoutPath(),
+    stderrPath: serviceStderrPath(),
+    pid: parsed.pid,
+    lastExit: parsed.lastExit,
+    raw
+  };
+}
+async function tailLaunchdLogs(follow) {
+  await ensureLogFiles();
+  const args = follow ? ["-f", serviceStdoutPath(), serviceStderrPath()] : ["-n", "100", serviceStdoutPath(), serviceStderrPath()];
+  await new Promise((resolvePromise, reject) => {
+    const child = spawn4("tail", args, { stdio: "inherit" });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0 || follow && code === null) {
+        resolvePromise();
+        return;
+      }
+      reject(new Error(`tail \u9000\u51FA\u7801 ${code ?? "unknown"}`));
+    });
+  });
+}
+function parseLaunchdStatus(text) {
+  return {
+    pid: text.match(/\bpid\s*=\s*(\d+)/)?.[1],
+    lastExit: text.match(/last exit code\s*=\s*(-?\d+)/i)?.[1]
+  };
+}
+function isLoaded() {
+  const result = spawnSync("launchctl", ["print", serviceTarget()], {
+    stdio: ["ignore", "ignore", "ignore"]
+  });
+  return result.status === 0;
+}
+async function waitUntilUnloaded(timeoutMs = 5e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isLoaded()) return;
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, 200));
+  }
+  throw new Error(`launchd service \u672A\u5728 ${timeoutMs}ms \u5185\u5378\u8F7D\u5B8C\u6210`);
+}
+async function ensureLogFiles() {
+  await mkdir7(paths.appDir, { recursive: true });
+  await appendFile(serviceStdoutPath(), "");
+  await appendFile(serviceStderrPath(), "");
+}
+function userTarget() {
+  return `gui/${userInfo2().uid}`;
+}
+function serviceTarget() {
+  return `${userTarget()}/${LAUNCHD_LABEL}`;
+}
+function runLaunchctl(args) {
+  const result = spawnSync("launchctl", args, { encoding: "utf8" });
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? ""
+  };
+}
+function launchctlError(command, result) {
+  const output = [result.stderr.trim(), result.stdout.trim()].filter(Boolean).join("\n");
+  return new Error(`${command} \u5931\u8D25\uFF08exit ${result.status ?? "unknown"}\uFF09${output ? `\uFF1A${output}` : ""}`);
+}
+
+// src/service/adapter.ts
+function getServiceAdapter() {
+  if (process.platform !== "darwin") {
+    throw new Error("service\uFF1A\u5F53\u524D\u5E73\u53F0\u6682\u4E0D\u652F\u6301\uFF0C\u540E\u7EED\u4F1A\u652F\u6301 Windows/systemd\u3002");
+  }
+  return {
+    install: installLaunchd,
+    uninstall: uninstallLaunchd,
+    status: async () => statusLaunchd(),
+    restart: restartLaunchd,
+    logs: tailLaunchdLogs
+  };
+}
+
+// src/cli/commands/daemon.ts
+async function runStart() {
+  const ready = await ensureOnboarded({ allowCreate: true });
+  if (!ready) {
+    process.exitCode = 1;
+    return;
+  }
+  if (!await confirmReadyForDaemon(ready)) {
+    process.exitCode = 1;
+    return;
+  }
+  const status = await getServiceAdapter().install();
+  console.log("\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u5B89\u88C5\u5E76\u542F\u52A8\uFF08\u5F00\u673A\u81EA\u542F\u3001\u5D29\u6E83\u81EA\u52A8\u62C9\u8D77\uFF09\u3002");
+  printStatus(status);
+}
+async function runStop() {
+  await getServiceAdapter().uninstall();
+  console.log("\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u505C\u6B62\uFF0C\u5E76\u5DF2\u5173\u95ED\u5F00\u673A\u81EA\u542F\uFF08\u5DF2\u79FB\u9664 launchd plist\uFF09\u3002");
+}
+async function runRestart() {
+  const status = await getServiceAdapter().restart();
+  console.log("\u2713 \u540E\u53F0\u670D\u52A1\u5DF2\u91CD\u542F\u3002");
+  printStatus(status);
+}
+async function runStatus() {
+  printStatus(await getServiceAdapter().status());
+}
+async function runLogs(follow) {
+  await getServiceAdapter().logs(follow);
+}
+function printStatus(status) {
+  console.log(`plist:     ${status.plistPath}`);
+  console.log(`installed: ${status.installed ? "yes" : "no"}`);
+  console.log(`loaded:    ${status.loaded ? "yes" : "no"}`);
+  console.log(`pid:       ${status.pid ?? "-"}`);
+  console.log(`last exit: ${status.lastExit ?? "-"}`);
+  console.log(`stdout:    ${status.stdoutPath}`);
+  console.log(`stderr:    ${status.stderrPath}`);
+  if (!status.installed) {
+    console.log("\u63D0\u793A\uFF1A\u540E\u53F0\u670D\u52A1\u5C1A\u672A\u5B89\u88C5\uFF0C\u8FD0\u884C `feishu-codex-bridge start`\u3002");
+  } else if (!status.loaded) {
+    console.log("\u63D0\u793A\uFF1Aplist \u5DF2\u5B58\u5728\uFF0C\u4F46 launchd \u5F53\u524D\u672A\u52A0\u8F7D\uFF08\u8BD5\u8BD5 `restart`\uFF09\u3002");
+  }
+}
+
+// src/cli/commands/bot.ts
+import { rm as rm3 } from "fs/promises";
+async function runBotInit(name) {
+  if (!ensureCodex()) {
+    process.exitCode = 1;
+    return;
+  }
+  const result = await registerNewBot(name);
+  if (!result) {
+    process.exitCode = 1;
+    return;
+  }
+  console.log("\n\u4E0B\u4E00\u6B65\uFF08\u98DE\u4E66\u5F00\u653E\u5E73\u53F0\u540E\u53F0\uFF0C\u9700\u624B\u52A8\u4E00\u6B21 https://open.feishu.cn/app \uFF09\uFF1A");
+  console.log("  1) \u4E8B\u4EF6\u4E0E\u56DE\u8C03 \u2192 \u957F\u8FDE\u63A5 \u2192 \u8BA2\u9605\uFF1Aim.message.receive_v1 / card.action.trigger / application.bot.menu_v6");
+  console.log("  2) \u521B\u5EFA\u5E76\u53D1\u5E03\u5E94\u7528\u7248\u672C");
+  console.log("\n`bot list` \u67E5\u770B\u5168\u90E8\uFF1B`bot use <\u540D>` \u5207\u6362\u5F53\u524D\uFF1B`run` \u524D\u53F0\u8DD1 / `start` \u540E\u53F0\u5E38\u9A7B\u3002\n");
+}
+async function runBotList() {
+  const reg = await loadBots();
+  if (reg.bots.length === 0) {
+    console.log("\uFF08\u8FD8\u6CA1\u6709\u6CE8\u518C\u4EFB\u4F55\u98DE\u4E66\u673A\u5668\u4EBA\u3002\u8FD0\u884C `feishu-codex-bridge bot init` \u521B\u5EFA\u3002\uFF09");
+    return;
+  }
+  console.log("\n\u5DF2\u6CE8\u518C\u7684\u98DE\u4E66\u673A\u5668\u4EBA\uFF1A\n");
+  for (const b of reg.bots) {
+    const cur = b.appId === reg.current ? "\u{1F449}" : "  ";
+    console.log(`${cur} ${b.name.padEnd(16)} ${b.appId}  [${b.tenant}]${b.botName ? `  ${b.botName}` : ""}`);
+  }
+  console.log("\n\u{1F449} = \u5F53\u524D\u9009\u4E2D\uFF08run / start \u542F\u52A8\u7684\u5C31\u662F\u5B83\uFF09\u3002`bot use <\u540D>` \u5207\u6362\u3002\n");
+}
+async function runBotUse(name) {
+  const reg = await loadBots();
+  const bot2 = findBot(reg, name);
+  if (!bot2) {
+    console.error(`\u2717 \u627E\u4E0D\u5230\u673A\u5668\u4EBA\u300C${name}\u300D\u3002\u5DF2\u6CE8\u518C\uFF1A${botNames(reg.bots)}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (reg.current === bot2.appId) {
+    console.log(`\u300C${bot2.name}\u300D\u5DF2\u7ECF\u662F\u5F53\u524D\u673A\u5668\u4EBA\u3002`);
+    return;
+  }
+  await setCurrent(bot2.appId);
+  console.log(`\u2713 \u5F53\u524D\u673A\u5668\u4EBA \u2192 \u300C${bot2.name}\u300D(${bot2.appId})\u3002\u524D\u53F0 \`run\` \u76F4\u63A5\u751F\u6548\uFF1B\u540E\u53F0\u8BF7 \`restart\`\u3002`);
+}
+async function runBotRm(name) {
+  const reg = await loadBots();
+  const bot2 = findBot(reg, name);
+  if (!bot2) {
+    console.error(`\u2717 \u627E\u4E0D\u5230\u673A\u5668\u4EBA\u300C${name}\u300D\u3002\u5DF2\u6CE8\u518C\uFF1A${botNames(reg.bots)}`);
+    process.exitCode = 1;
+    return;
+  }
+  const after = await removeBot(bot2.appId);
+  await removeSecret(secretKeyForApp(bot2.appId));
+  await rm3(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");
+  } else if (after.current) {
+    const cur = after.bots.find((b) => b.appId === after.current);
+    if (cur) console.log(`  \u5F53\u524D\u673A\u5668\u4EBA\u73B0\u4E3A\u300C${cur.name}\u300D\u3002`);
+  } else {
+    console.log("  \u5F53\u524D\u673A\u5668\u4EBA\u672A\u8BBE\u7F6E\uFF0C\u7528 `bot use <\u540D>` \u9009\u62E9\u3002");
+  }
+}
+function botNames(bots) {
+  return bots.map((b) => b.name).join(", ") || "\uFF08\u65E0\uFF09";
+}
+
+// src/cli/commands/secrets.ts
+async function secretsGet() {
+  const input2 = await readStdin();
+  let ids = [];
+  try {
+    const req = JSON.parse(input2);
+    ids = Array.isArray(req.ids) ? req.ids : [];
+  } catch {
+    process.stdout.write(JSON.stringify({ values: {}, errors: { _: { message: "invalid request JSON" } } }));
+    return;
+  }
+  const values = {};
+  const errors = {};
+  for (const id of ids) {
+    try {
+      const v = await getSecret(id);
+      if (v !== void 0) values[id] = v;
+      else errors[id] = { message: "not found" };
+    } catch (err) {
+      errors[id] = { message: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  process.stdout.write(JSON.stringify({ values, errors }));
+}
+async function secretsSet(id) {
+  const value = (await readStdin()).trim();
+  if (!value) {
+    console.error("\u65E0\u8F93\u5165\uFF1A\u628A\u5BC6\u94A5\u901A\u8FC7 stdin \u4F20\u5165\uFF0C\u5982 `echo <secret> | feishu-codex-bridge secrets set <id>`");
+    process.exitCode = 1;
+    return;
+  }
+  await setSecret(id, value);
+  console.log(`\u2713 \u5DF2\u5B58\u50A8\u5BC6\u94A5: ${id}`);
+}
+async function secretsList() {
+  const ids = await listSecretIds();
+  console.log(ids.length ? ids.join("\n") : "(\u7A7A)");
+}
+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((resolve3) => {
+    let data = "";
+    if (process.stdin.isTTY) {
+      resolve3("");
+      return;
+    }
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (c) => data += c);
+    process.stdin.on("end", () => resolve3(data));
+  });
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("feishu-codex-bridge").description("\u628A\u98DE\u4E66/Lark \u6865\u63A5\u5230\u672C\u673A Codex\uFF08\u9879\u76EE=\u7FA4, \u8BDD\u9898=\u4F1A\u8BDD\uFF09").version("0.0.1");
+program.command("run").description("\u524D\u53F0\u542F\u52A8 bot\uFF08\u6CA1\u914D\u7F6E\u5219\u5148\u626B\u7801 init\uFF1BCtrl+C \u4F18\u96C5\u9000\u51FA\uFF09").action(async () => {
+  await runRun();
+});
+program.command("start").description("\u540E\u53F0 daemon \u542F\u52A8\uFF08\u88C5 launchd \u5F00\u673A\u81EA\u542F\uFF1B\u6CA1\u914D\u7F6E\u5219\u5148\u626B\u7801 init\uFF09").action(async () => {
+  await runStart();
+});
+program.command("stop").description("\u505C\u6B62\u540E\u53F0 daemon \u5E76\u5173\u95ED\u5F00\u673A\u81EA\u542F").action(async () => {
+  await runStop();
+});
+program.command("restart").description("\u91CD\u542F\u540E\u53F0 daemon").action(async () => {
+  await runRestart();
+});
+program.command("status").description("\u540E\u53F0 daemon \u72B6\u6001\uFF08pid / \u65E5\u5FD7\u8DEF\u5F84 / \u4E0A\u6B21\u9000\u51FA\u7801\uFF09").action(async () => {
+  await runStatus();
+});
+program.command("logs").description("\u67E5\u770B\u540E\u53F0 daemon \u65E5\u5FD7").option("-f, --follow", "\u6301\u7EED\u8DDF\u968F\u65E5\u5FD7").action(async (options) => {
+  await runLogs(Boolean(options.follow));
+});
+var bot = program.command("bot").description("\u98DE\u4E66\u673A\u5668\u4EBA\u7BA1\u7406\uFF08\u591A\u673A\u5668\u4EBA\uFF09");
+bot.command("init [name]").description("\u6CE8\u518C\u4E00\u4E2A\u98DE\u4E66\u673A\u5668\u4EBA\u5E76\u6388\u6743\uFF08\u53EF\u9009\u77ED\u540D\uFF09").action(async (name) => {
+  await runBotInit(name);
+});
+bot.command("list").description("\u5217\u51FA\u5DF2\u6CE8\u518C\u7684\u98DE\u4E66\u673A\u5668\u4EBA").action(async () => {
+  await runBotList();
+});
+bot.command("use <name>").description("\u9009\u62E9 run / start \u542F\u52A8\u65F6\u4F7F\u7528\u7684\u673A\u5668\u4EBA").action(async (name) => {
+  await runBotUse(name);
+});
+bot.command("rm <name>").description("\u79FB\u9664\u4E00\u4E2A\u673A\u5668\u4EBA\u914D\u7F6E").action(async (name) => {
+  await runBotRm(name);
+});
+program.command("doctor").description("\u672C\u5730\u81EA\u68C0\uFF1Acodex / \u767B\u5F55 / lark-cli / \u5F53\u524D\u673A\u5668\u4EBA\u914D\u7F6E").action(async () => {
+  await runDoctor();
+});
+var secrets = program.command("secrets", { hidden: true }).description("\u672C\u5730\u52A0\u5BC6\u5BC6\u94A5\u5E93\uFF08\u5185\u90E8\uFF09");
+secrets.command("get").description("exec-provider \u7AEF\u70B9\uFF08\u4ECE stdin \u8BFB JSON \u8BF7\u6C42\uFF09").action(async () => {
+  await secretsGet();
+});
+secrets.command("set <id>").description("\u5B58\u50A8\u5BC6\u94A5\uFF08\u503C\u4ECE stdin \u8BFB\uFF09").action(async (id) => {
+  await secretsSet(id);
+});
+secrets.command("list").description("\u5217\u51FA\u5BC6\u94A5 id").action(async () => {
+  await secretsList();
+});
+secrets.command("remove <id>").description("\u5220\u9664\u5BC6\u94A5").action(async (id) => {
+  await secretsRemove(id);
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});