lark-kiro-bridge 0.3.1

package/dist/index.js

@@ -0,0 +1,4252 @@
+// src/lark/client.ts
+import * as lark from "@larksuiteoapi/node-sdk";
+
+// src/lark/parse.ts
+function normalizeChatType(s) {
+  switch (s) {
+    case "p2p":
+      return "p2p";
+    case "group":
+      return "group";
+    case "topic_group":
+      return "topic_group";
+    default:
+      return "unknown";
+  }
+}
+function extractText(messageType, contentJson) {
+  if (messageType !== "text" && messageType !== "post") return "";
+  let parsed;
+  try {
+    parsed = JSON.parse(contentJson);
+  } catch {
+    return "";
+  }
+  if (messageType === "text") {
+    const text = parsed.text;
+    return typeof text === "string" ? text : "";
+  }
+  const post = parsed;
+  const parts = [];
+  if (post.title) parts.push(post.title);
+  if (Array.isArray(post.content)) {
+    for (const para of post.content) {
+      if (!Array.isArray(para)) continue;
+      for (const seg of para) {
+        if (seg.tag === "text" && typeof seg.text === "string") {
+          parts.push(seg.text);
+        } else if (seg.tag === "at" && typeof seg.user_id === "string") {
+          parts.push(`@${seg.user_id}`);
+        }
+      }
+    }
+  }
+  return parts.join(" ").trim();
+}
+function parseIncomingMessage(ev) {
+  const m = ev.message;
+  const senderOpenId = ev.sender?.sender_id?.open_id ?? "";
+  const mentions = (m.mentions ?? []).map((x) => {
+    const mention = {
+      key: x.key,
+      name: x.name
+    };
+    if (x.id.open_id !== void 0) {
+      mention.openId = x.id.open_id;
+    }
+    return mention;
+  });
+  const result = {
+    eventId: ev.event_id ?? "",
+    messageId: m.message_id,
+    chatId: m.chat_id,
+    chatType: normalizeChatType(m.chat_type),
+    senderOpenId,
+    messageType: m.message_type,
+    rawContent: m.content,
+    text: extractText(m.message_type, m.content),
+    mentions,
+    receivedAt: Date.now()
+  };
+  if (m.thread_id !== void 0) {
+    result.threadId = m.thread_id;
+  }
+  return result;
+}
+function stripMentions(msg, botOpenId) {
+  let text = msg.text;
+  for (const m of msg.mentions) {
+    if (m.openId === botOpenId) {
+      text = text.split(m.key).join("");
+    }
+  }
+  return text.trim();
+}
+
+// src/lark/cardAction.ts
+function parseCardAction(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  const ev = r.event ?? r;
+  const op = ev.operator ?? r.operator ?? {};
+  const action = ev.action ?? r.action ?? {};
+  const ctx = ev.context ?? {};
+  const messageId = ctx.open_message_id ?? ev.open_message_id ?? r.open_message_id ?? "";
+  const chatId = ctx.open_chat_id ?? ev.open_chat_id ?? r.open_chat_id ?? "";
+  const senderOpenId = op.open_id ?? op.openId ?? "";
+  if (!messageId || !chatId || !senderOpenId) return null;
+  let value = {};
+  if (action.value && typeof action.value === "object" && !Array.isArray(action.value)) {
+    value = action.value;
+  }
+  const result = {
+    messageId,
+    chatId,
+    senderOpenId,
+    value,
+    receivedAt: Date.now()
+  };
+  const formValue = action.form_value ?? action.input_value;
+  if (formValue && typeof formValue === "object") {
+    result.formValue = formValue;
+  }
+  const token = ev.token ?? r.token;
+  if (token !== void 0) result.token = token;
+  return result;
+}
+
+// src/lark/client.ts
+var LarkClient = class {
+  appId;
+  appSecret;
+  log;
+  api;
+  wsClient = null;
+  botOpenIdCache = null;
+  constructor(opts) {
+    this.appId = opts.appId;
+    this.appSecret = opts.appSecret;
+    this.log = opts.logger.child({ module: "lark-client" });
+    this.api = new lark.Client({
+      appId: this.appId,
+      appSecret: this.appSecret,
+      disableTokenCache: false
+    });
+  }
+  /**
+   * 启动 WebSocket 长连接，注册事件 handler：
+   *   - im.message.receive_v1：用户发的消息
+   *   - card.action.trigger：用户点了卡片上的按钮
+   */
+  async startEventLoop(handlers) {
+    const wsClient = new lark.WSClient({
+      appId: this.appId,
+      appSecret: this.appSecret,
+      loggerLevel: lark.LoggerLevel.warn,
+      onReady: () => {
+        this.log.info("lark websocket connected");
+        handlers.onReady?.();
+      },
+      onReconnecting: () => {
+        this.log.warn("lark websocket reconnecting");
+      },
+      onReconnected: () => {
+        this.log.info("lark websocket reconnected");
+        handlers.onReconnected?.();
+      },
+      onError: (err) => {
+        this.log.error({ err }, "lark websocket error");
+      }
+    });
+    const dispatcher = new lark.EventDispatcher({}).register({
+      "im.message.receive_v1": async (data) => {
+        try {
+          const msg = parseIncomingMessage(data);
+          this.log.info(
+            {
+              event: "enter",
+              eventId: msg.eventId,
+              chatId: msg.chatId,
+              senderId: msg.senderOpenId,
+              chatType: msg.chatType,
+              messageType: msg.messageType
+            },
+            "incoming message"
+          );
+          Promise.resolve(handlers.onMessage(msg)).catch((e) => {
+            this.log.error({ err: e }, "onMessage handler threw");
+          });
+        } catch (e) {
+          this.log.error({ err: e }, "event parse failed");
+        }
+        return { code: 0 };
+      },
+      "card.action.trigger": async (data) => {
+        try {
+          const evt = parseCardAction(data);
+          if (!evt) {
+            this.log.debug({ raw: data }, "card.action.trigger: cannot parse, skip");
+            return { code: 0 };
+          }
+          this.log.info(
+            {
+              event: "card-action",
+              messageId: evt.messageId,
+              chatId: evt.chatId,
+              senderId: evt.senderOpenId,
+              valueKeys: Object.keys(evt.value)
+            },
+            "card action"
+          );
+          if (handlers.onCardAction) {
+            Promise.resolve(handlers.onCardAction(evt)).catch((e) => {
+              this.log.error({ err: e }, "onCardAction handler threw");
+            });
+          }
+        } catch (e) {
+          this.log.error({ err: e }, "card action parse failed");
+        }
+        return { code: 0 };
+      }
+    });
+    await wsClient.start({ eventDispatcher: dispatcher });
+    this.wsClient = wsClient;
+  }
+  close() {
+    this.wsClient?.close();
+    this.wsClient = null;
+  }
+  /**
+   * 查询当前机器人在租户里的 open_id（用来识别 @bot）。
+   * 应用启动时调用一次后缓存。
+   */
+  async getBotOpenId() {
+    if (this.botOpenIdCache) return this.botOpenIdCache;
+    return "";
+  }
+  /** 业务侧主动设置 botOpenId（一般从配置或第一次 @bot 学习而来）。 */
+  setBotOpenId(openId) {
+    this.botOpenIdCache = openId;
+  }
+  /**
+   * 发送一张飞书卡片（v2 协议）。
+   * 返回卡片所在消息的 message_id，后续用 patchCard 更新。
+   */
+  async sendCard(chatId, cardJson) {
+    const resp = await this.api.im.v1.message.create({
+      params: { receive_id_type: "chat_id" },
+      data: {
+        receive_id: chatId,
+        msg_type: "interactive",
+        content: JSON.stringify(cardJson)
+      }
+    });
+    const messageId = resp.data?.message_id;
+    if (!messageId) {
+      throw new Error(`sendCard failed, no message_id in response: ${JSON.stringify(resp)}`);
+    }
+    return messageId;
+  }
+  /**
+   * 回复一条消息（reply 卡片，让卡片挂在用户消息下面）。
+   */
+  async replyCard(messageId, cardJson) {
+    const resp = await this.api.im.v1.message.reply({
+      path: { message_id: messageId },
+      data: {
+        msg_type: "interactive",
+        content: JSON.stringify(cardJson)
+      }
+    });
+    const newMsgId = resp.data?.message_id;
+    if (!newMsgId) {
+      throw new Error(`replyCard failed, no message_id in response: ${JSON.stringify(resp)}`);
+    }
+    return newMsgId;
+  }
+  /**
+   * 用 patch 接口整体替换卡片内容。
+   * 飞书消息卡片支持通过 `im/v1/messages/:message_id` PATCH 来更新内容，
+   * 内容必须是合法的卡片 JSON 字符串。
+   */
+  async patchCard(messageId, cardJson) {
+    await this.api.im.v1.message.patch({
+      path: { message_id: messageId },
+      data: { content: JSON.stringify(cardJson) }
+    });
+  }
+  /** 发送纯文本消息（错误兜底用） */
+  async sendText(chatId, text) {
+    const resp = await this.api.im.v1.message.create({
+      params: { receive_id_type: "chat_id" },
+      data: {
+        receive_id: chatId,
+        msg_type: "text",
+        content: JSON.stringify({ text })
+      }
+    });
+    const messageId = resp.data?.message_id;
+    if (!messageId) {
+      throw new Error(`sendText failed, no message_id in response: ${JSON.stringify(resp)}`);
+    }
+    return messageId;
+  }
+};
+
+// src/store/sessions.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync } from "fs";
+import lockfile from "proper-lockfile";
+import { z } from "zod";
+
+// src/lib/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync } from "fs";
+var DATA_DIR = join(homedir(), ".lark-kiro-bridge");
+var LOGS_DIR = join(DATA_DIR, "logs");
+var MEDIA_DIR = join(DATA_DIR, "media");
+var CONFIG_FILE = join(DATA_DIR, "config.json");
+var SESSIONS_FILE = join(DATA_DIR, "sessions.json");
+var WORKSPACES_FILE = join(DATA_DIR, "workspaces.json");
+var PROCESSES_FILE = join(DATA_DIR, "processes.json");
+function ensureDataDirs() {
+  mkdirSync(DATA_DIR, { recursive: true, mode: 448 });
+  mkdirSync(LOGS_DIR, { recursive: true, mode: 448 });
+  mkdirSync(MEDIA_DIR, { recursive: true, mode: 448 });
+}
+
+// src/lib/logger.ts
+import pino from "pino";
+import { join as join2 } from "path";
+import { readdirSync, statSync, unlinkSync, readFileSync } from "fs";
+function todayLogFile() {
+  const d = /* @__PURE__ */ new Date();
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return join2(LOGS_DIR, `${yyyy}-${mm}-${dd}.log`);
+}
+function pruneOldLogs(retainDays) {
+  if (!Number.isFinite(retainDays) || retainDays <= 0) return;
+  const cutoff = Date.now() - retainDays * 24 * 60 * 60 * 1e3;
+  try {
+    const files = readdirSync(LOGS_DIR);
+    for (const f of files) {
+      if (!f.endsWith(".log")) continue;
+      const full = join2(LOGS_DIR, f);
+      try {
+        const st = statSync(full);
+        if (st.mtimeMs < cutoff) unlinkSync(full);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+var REDACT_PATHS = [
+  // App 凭证
+  "*.appSecret",
+  "*.app_secret",
+  "config.lark.appSecret",
+  "lark.appSecret",
+  // Tokens（access / tenant / app / refresh）
+  "*.accessToken",
+  "*.access_token",
+  "*.tenantAccessToken",
+  "*.tenant_access_token",
+  "*.appAccessToken",
+  "*.app_access_token",
+  "*.refreshToken",
+  "*.refresh_token",
+  // 通用 Auth header
+  "*.authorization",
+  "*.Authorization",
+  // 飞书卡片回调里的临时 token（30 分钟有效，泄露能伪造卡片更新）
+  "event.token",
+  "*.cardToken"
+];
+var cachedLogger = null;
+function getLogger() {
+  if (cachedLogger) return cachedLogger;
+  ensureDataDirs();
+  const isTty = process.stdout.isTTY;
+  const level = process.env["LARK_KIRO_LOG_LEVEL"] ?? (isTty ? "info" : "info");
+  if (isTty) {
+    cachedLogger = pino({
+      level,
+      redact: { paths: REDACT_PATHS, censor: "[REDACTED]" },
+      transport: {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "HH:MM:ss.l",
+          ignore: "pid,hostname"
+        }
+      }
+    });
+  } else {
+    cachedLogger = pino(
+      {
+        level,
+        base: { pid: process.pid },
+        redact: { paths: REDACT_PATHS, censor: "[REDACTED]" }
+      },
+      pino.destination({ dest: todayLogFile(), append: true, sync: false })
+    );
+  }
+  const envDays = Number(process.env["LARK_KIRO_LOG_DAYS"]);
+  if (Number.isFinite(envDays) && envDays > 0) {
+    pruneOldLogs(envDays);
+  } else {
+    pruneOldLogs(7);
+  }
+  return cachedLogger;
+}
+function readRecentLogLines(maxLines = 200) {
+  try {
+    const files = readdirSync(LOGS_DIR).filter((f) => f.endsWith(".log") && !f.startsWith("daemon-")).map((f) => ({ f, t: statSync(join2(LOGS_DIR, f)).mtimeMs })).sort((a, b) => b.t - a.t).slice(0, 3).map((x) => x.f);
+    const allLines = [];
+    for (const f of files) {
+      const full = join2(LOGS_DIR, f);
+      const raw = readFileSync(full, "utf-8");
+      for (const line of raw.split("\n")) {
+        if (!line) continue;
+        allLines.push(line.length > 1024 ? line.slice(0, 1024) + "\u2026[truncated]" : line);
+      }
+      if (allLines.length >= maxLines * 3) break;
+    }
+    return allLines.slice(-maxLines);
+  } catch {
+    return [];
+  }
+}
+
+// src/store/sessions.ts
+var ChatSessionSchema = z.object({
+  currentCwd: z.string(),
+  sessionsByCwd: z.record(z.string(), z.string()).default({}),
+  lastActiveAt: z.number().int().nonnegative().default(0),
+  /**
+   * per-chat idle watchdog 分钟数覆盖：
+   *   undefined → 用全局默认（preferences/kiro.idleTimeoutMinutes）
+   *   0         → 显式关闭
+   *   N>0       → 用 N 分钟
+   */
+  idleTimeoutMinutes: z.number().int().nonnegative().optional()
+});
+var SessionsFileSchema = z.object({
+  version: z.literal(1).default(1),
+  chats: z.record(z.string(), ChatSessionSchema).default({})
+});
+var log = () => getLogger().child({ module: "sessions" });
+function readFile() {
+  if (!existsSync(SESSIONS_FILE)) {
+    return SessionsFileSchema.parse({});
+  }
+  try {
+    const raw = readFileSync2(SESSIONS_FILE, "utf-8");
+    const parsed = SessionsFileSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success) {
+      log().warn({ err: parsed.error.issues }, "sessions.json validation failed, resetting");
+      return SessionsFileSchema.parse({});
+    }
+    return parsed.data;
+  } catch (e) {
+    log().warn({ err: e }, "sessions.json read failed, resetting");
+    return SessionsFileSchema.parse({});
+  }
+}
+function writeFile(data) {
+  ensureDataDirs();
+  writeFileSync(SESSIONS_FILE, JSON.stringify(data, null, 2) + "\n", { mode: 384 });
+}
+async function withLock(fn) {
+  ensureDataDirs();
+  if (!existsSync(SESSIONS_FILE)) {
+    writeFileSync(SESSIONS_FILE, "{}\n", { mode: 384 });
+  }
+  const release = await lockfile.lock(SESSIONS_FILE, {
+    retries: { retries: 5, minTimeout: 50, maxTimeout: 200 },
+    stale: 1e4
+  });
+  try {
+    return fn();
+  } finally {
+    await release();
+  }
+}
+var SessionStore = class {
+  /**
+   * 获取一个 chat 的会话状态；不存在则用 defaultCwd 初始化。
+   */
+  async get(chatId, defaultCwd) {
+    return withLock(() => {
+      const data = readFile();
+      let session = data.chats[chatId];
+      if (!session) {
+        session = {
+          currentCwd: defaultCwd,
+          sessionsByCwd: {},
+          lastActiveAt: Date.now()
+        };
+        data.chats[chatId] = session;
+        writeFile(data);
+      }
+      return session;
+    });
+  }
+  /**
+   * 切换 chat 的当前 cwd。该 cwd 下若已有 kiro session 会被自动延用。
+   */
+  async setCwd(chatId, cwd, defaultCwd) {
+    return withLock(() => {
+      const data = readFile();
+      const session = data.chats[chatId] ?? {
+        currentCwd: defaultCwd,
+        sessionsByCwd: {},
+        lastActiveAt: Date.now()
+      };
+      session.currentCwd = cwd;
+      session.lastActiveAt = Date.now();
+      data.chats[chatId] = session;
+      writeFile(data);
+      return session;
+    });
+  }
+  /**
+   * 关联当前 (chatId, cwd) 到一个 kiroSessionId（Kiro CLI 跑完返回的 sid）。
+   */
+  async setKiroSession(chatId, cwd, kiroSessionId) {
+    await withLock(() => {
+      const data = readFile();
+      const session = data.chats[chatId];
+      if (!session) return;
+      session.sessionsByCwd[cwd] = kiroSessionId;
+      session.lastActiveAt = Date.now();
+      writeFile(data);
+    });
+  }
+  /**
+   * 清空当前 cwd 下的 kiro session（用于 /new 命令）。
+   */
+  async clearKiroSession(chatId, cwd) {
+    await withLock(() => {
+      const data = readFile();
+      const session = data.chats[chatId];
+      if (!session) return;
+      delete session.sessionsByCwd[cwd];
+      session.lastActiveAt = Date.now();
+      writeFile(data);
+    });
+  }
+  /**
+   * 获取当前 (chatId, cwd) 对应的 kiroSessionId（可能不存在）。
+   */
+  async getKiroSession(chatId, cwd) {
+    return withLock(() => {
+      const data = readFile();
+      return data.chats[chatId]?.sessionsByCwd[cwd];
+    });
+  }
+  /**
+   * 设置 chat 的 idle watchdog 阈值（分钟）。
+   *   - undefined：清除覆盖，回归全局默认
+   *   - 0：关闭
+   *   - N>0：用 N 分钟
+   */
+  async setIdleTimeout(chatId, minutes, defaultCwd) {
+    await withLock(() => {
+      const data = readFile();
+      const session = data.chats[chatId] ?? {
+        currentCwd: defaultCwd,
+        sessionsByCwd: {},
+        lastActiveAt: Date.now()
+      };
+      if (minutes === void 0) {
+        delete session.idleTimeoutMinutes;
+      } else {
+        session.idleTimeoutMinutes = minutes;
+      }
+      session.lastActiveAt = Date.now();
+      data.chats[chatId] = session;
+      writeFile(data);
+    });
+  }
+};
+
+// src/store/workspaces.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import lockfile2 from "proper-lockfile";
+import { z as z2 } from "zod";
+var WorkspacesFileSchema = z2.object({
+  version: z2.literal(1).default(1),
+  workspaces: z2.record(z2.string(), z2.string()).default({})
+});
+var log2 = () => getLogger().child({ module: "workspaces" });
+function readFile2() {
+  if (!existsSync2(WORKSPACES_FILE)) {
+    return WorkspacesFileSchema.parse({});
+  }
+  try {
+    const raw = readFileSync3(WORKSPACES_FILE, "utf-8");
+    const parsed = WorkspacesFileSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success) {
+      log2().warn({ err: parsed.error.issues }, "workspaces.json validation failed, resetting");
+      return WorkspacesFileSchema.parse({});
+    }
+    return parsed.data;
+  } catch (e) {
+    log2().warn({ err: e }, "workspaces.json read failed, resetting");
+    return WorkspacesFileSchema.parse({});
+  }
+}
+function writeFile2(data) {
+  ensureDataDirs();
+  writeFileSync2(WORKSPACES_FILE, JSON.stringify(data, null, 2) + "\n", { mode: 384 });
+}
+async function withLock2(fn) {
+  ensureDataDirs();
+  if (!existsSync2(WORKSPACES_FILE)) {
+    writeFileSync2(WORKSPACES_FILE, "{}\n", { mode: 384 });
+  }
+  const release = await lockfile2.lock(WORKSPACES_FILE, {
+    retries: { retries: 5, minTimeout: 50, maxTimeout: 200 },
+    stale: 1e4
+  });
+  try {
+    return fn();
+  } finally {
+    await release();
+  }
+}
+var NAME_PATTERN = /^[a-zA-Z0-9_-]{1,64}$/;
+var WorkspaceStore = class {
+  async list() {
+    return withLock2(() => readFile2().workspaces);
+  }
+  async get(name) {
+    return withLock2(() => readFile2().workspaces[name]);
+  }
+  async save(name, absPath) {
+    if (!NAME_PATTERN.test(name)) {
+      throw new Error(
+        `Invalid workspace name "${name}". Use letters, digits, "-" or "_" only (1\u201364 chars).`
+      );
+    }
+    await withLock2(() => {
+      const data = readFile2();
+      data.workspaces[name] = absPath;
+      writeFile2(data);
+    });
+  }
+  async remove(name) {
+    return withLock2(() => {
+      const data = readFile2();
+      if (!(name in data.workspaces)) return false;
+      delete data.workspaces[name];
+      writeFile2(data);
+      return true;
+    });
+  }
+};
+
+// src/lib/config.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync3, chmodSync } from "fs";
+import { z as z3 } from "zod";
+var ConfigSchema = z3.object({
+  lark: z3.object({
+    appId: z3.string().min(1),
+    appSecret: z3.string().min(1)
+  }),
+  kiro: z3.object({
+    binPath: z3.string().default("kiro-cli"),
+    trustedTools: z3.array(z3.string()).default(["fs_read", "fs_write", "grep", "glob", "code"]),
+    timeoutMs: z3.number().int().positive().default(10 * 60 * 1e3),
+    /**
+     * 默认 idle watchdog（分钟）。0 = 关闭。
+     * stdout 连续这么久没新输出就当作 kiro-cli 假死，killTree。
+     * /timeout N 可以临时为某个 chat 覆盖。
+     */
+    idleTimeoutMinutes: z3.number().int().nonnegative().default(5),
+    model: z3.string().optional(),
+    agent: z3.string().optional()
+  }).default({}),
+  workspace: z3.object({
+    defaultCwd: z3.string().default("/Users/administrator/PycharmProjects"),
+    allowedRoots: z3.array(z3.string()).default(["/Users/administrator/PycharmProjects"])
+  }).default({}),
+  access: z3.object({
+    allowedUsers: z3.array(z3.string()).default([]),
+    allowedChats: z3.array(z3.string()).default([]),
+    admins: z3.array(z3.string()).default([])
+  }).default({}),
+  preferences: z3.object({
+    requireMentionInGroup: z3.boolean().default(true),
+    cardUpdateIntervalMs: z3.number().int().positive().default(800),
+    /** 启动时清理多少天之前的日志文件 */
+    logRetentionDays: z3.number().int().positive().default(7)
+  }).default({})
+});
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+function loadConfig() {
+  ensureDataDirs();
+  if (!existsSync3(CONFIG_FILE)) {
+    throw new ConfigError(
+      `Config file not found at ${CONFIG_FILE}. Run \`lark-kiro-bridge init\` to create one.`
+    );
+  }
+  const raw = readFileSync4(CONFIG_FILE, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new ConfigError(`Config file is not valid JSON: ${e.message}`);
+  }
+  const result = ConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ConfigError(
+      `Config validation failed:
+${result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}`
+    );
+  }
+  return result.data;
+}
+function saveConfig(cfg) {
+  ensureDataDirs();
+  writeFileSync3(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
+  chmodSync(CONFIG_FILE, 384);
+}
+function patchAndSaveConfig(cfg, mutator) {
+  const draft = JSON.parse(JSON.stringify(cfg));
+  mutator(draft);
+  const validated = ConfigSchema.parse(draft);
+  saveConfig(validated);
+  return validated;
+}
+function defaultConfig(appId, appSecret) {
+  return ConfigSchema.parse({
+    lark: { appId, appSecret }
+  });
+}
+
+// src/lark/media.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync4, existsSync as existsSync4, readdirSync as readdirSync2, statSync as statSync2, rmSync } from "fs";
+import { join as join3 } from "path";
+import "stream";
+var log3 = () => getLogger().child({ module: "media" });
+function sanitizeFilename(name, fallbackKey, defaultExt) {
+  let s = name.replace(/[/\\\x00-\x1f]/g, "_").trim();
+  if (!s) s = fallbackKey + defaultExt;
+  if (s.length > 80) {
+    const dotIdx = s.lastIndexOf(".");
+    if (dotIdx > 0 && dotIdx > s.length - 12) {
+      const ext = s.slice(dotIdx);
+      s = s.slice(0, 80 - ext.length) + ext;
+    } else {
+      s = s.slice(0, 80);
+    }
+  }
+  return s;
+}
+function ensureChatDir(chatId) {
+  const dir = join3(MEDIA_DIR, chatId);
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  return dir;
+}
+async function downloadMessageMedia(lark2, msg) {
+  const out = [];
+  const ts = Date.now();
+  let parsed;
+  try {
+    parsed = JSON.parse(msg.rawContent);
+  } catch {
+    return out;
+  }
+  if (msg.messageType === "image") {
+    const c = parsed;
+    if (c.image_key) {
+      const filename = sanitizeFilename("", `${ts}-${c.image_key.slice(0, 8)}`, ".jpg");
+      const path = await fetchResource(
+        lark2,
+        msg.messageId,
+        c.image_key,
+        "image",
+        chatPath(msg.chatId, filename)
+      );
+      if (path) out.push(path);
+    }
+  } else if (msg.messageType === "file") {
+    const c = parsed;
+    if (c.file_key) {
+      const filename = sanitizeFilename(
+        c.file_name ?? "",
+        `${ts}-${c.file_key.slice(0, 8)}`,
+        ".bin"
+      );
+      const path = await fetchResource(
+        lark2,
+        msg.messageId,
+        c.file_key,
+        "file",
+        chatPath(msg.chatId, filename)
+      );
+      if (path) out.push(path);
+    }
+  } else if (msg.messageType === "audio") {
+    const c = parsed;
+    if (c.file_key) {
+      const filename = sanitizeFilename("", `${ts}-${c.file_key.slice(0, 8)}`, ".opus");
+      const path = await fetchResource(
+        lark2,
+        msg.messageId,
+        c.file_key,
+        "file",
+        chatPath(msg.chatId, filename)
+      );
+      if (path) out.push(path);
+    }
+  }
+  return out;
+}
+function chatPath(chatId, filename) {
+  const dir = ensureChatDir(chatId);
+  let name = filename;
+  let full = join3(dir, name);
+  let i = 1;
+  while (existsSync4(full)) {
+    const dotIdx = filename.lastIndexOf(".");
+    name = dotIdx > 0 ? `${filename.slice(0, dotIdx)}-${i}${filename.slice(dotIdx)}` : `${filename}-${i}`;
+    full = join3(dir, name);
+    i++;
+    if (i > 1e3) break;
+  }
+  return { dir, full, name };
+}
+async function fetchResource(lark2, messageId, fileKey, resourceType, target) {
+  try {
+    const resp = await lark2.api.im.v1.messageResource.get({
+      path: { message_id: messageId, file_key: fileKey },
+      params: { type: resourceType }
+    });
+    if (typeof resp.writeFile === "function") {
+      await resp.writeFile(target.full);
+    } else {
+      const stream = resp.getReadableStream();
+      const chunks = [];
+      for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      }
+      writeFileSync4(target.full, Buffer.concat(chunks), { mode: 384 });
+    }
+    log3().info({ messageId, fileKey, resourceType, path: target.full }, "media downloaded");
+    return target.full;
+  } catch (e) {
+    log3().warn({ err: e.message, messageId, fileKey }, "media download failed");
+    return void 0;
+  }
+}
+function pruneOldMedia(retainHours = 24) {
+  if (!existsSync4(MEDIA_DIR)) return;
+  const cutoff = Date.now() - retainHours * 60 * 60 * 1e3;
+  try {
+    for (const chat of readdirSync2(MEDIA_DIR)) {
+      const chatDir = join3(MEDIA_DIR, chat);
+      let dirSt;
+      try {
+        dirSt = statSync2(chatDir);
+      } catch {
+        continue;
+      }
+      if (!dirSt.isDirectory()) continue;
+      let files = [];
+      try {
+        files = readdirSync2(chatDir);
+      } catch {
+        continue;
+      }
+      for (const f of files) {
+        const full = join3(chatDir, f);
+        try {
+          const st = statSync2(full);
+          if (st.mtimeMs < cutoff) rmSync(full, { force: true });
+        } catch {
+        }
+      }
+      try {
+        if (readdirSync2(chatDir).length === 0) rmSync(chatDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+
+// src/lark/asr.ts
+import { execa } from "execa";
+import { readFileSync as readFileSync5, statSync as statSync3, unlinkSync as unlinkSync2 } from "fs";
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+import { randomUUID } from "crypto";
+var log4 = () => getLogger().child({ module: "asr" });
+var MAX_DURATION_SEC = 60;
+var ffmpegAvailableCache;
+async function isFfmpegAvailable() {
+  if (ffmpegAvailableCache !== void 0) return ffmpegAvailableCache;
+  try {
+    await execa("ffmpeg", ["-version"], { reject: false, timeout: 3e3 });
+    ffmpegAvailableCache = true;
+  } catch {
+    ffmpegAvailableCache = false;
+  }
+  return ffmpegAvailableCache;
+}
+async function probeDurationSec(audioPath) {
+  try {
+    const r = await execa("ffmpeg", ["-i", audioPath, "-f", "null", "-"], {
+      reject: false,
+      timeout: 5e3
+    });
+    const stderr = r.stderr ?? "";
+    const m = stderr.match(/Duration:\s*(\d+):(\d+):(\d+(?:\.\d+)?)/);
+    if (!m) return -1;
+    const [, h, mm, ss] = m;
+    return Number(h) * 3600 + Number(mm) * 60 + Number(ss);
+  } catch {
+    return -1;
+  }
+}
+async function toPcm(audioPath) {
+  const out = join4(tmpdir(), `lkb-asr-${randomUUID()}.pcm`);
+  await execa(
+    "ffmpeg",
+    [
+      "-y",
+      "-i",
+      audioPath,
+      "-ar",
+      "16000",
+      // 16 kHz
+      "-ac",
+      "1",
+      // mono
+      "-f",
+      "s16le",
+      // 16-bit little-endian PCM, 飞书要求的格式
+      out
+    ],
+    { reject: true, timeout: 3e4 }
+  );
+  return out;
+}
+async function transcribeAudio(client, audioPath) {
+  if (!await isFfmpegAvailable()) {
+    log4().warn("ffmpeg not found in PATH; voice transcription disabled");
+    return { ok: false, reason: "ffmpeg-missing" };
+  }
+  const durSec = await probeDurationSec(audioPath);
+  if (durSec > MAX_DURATION_SEC) {
+    log4().info({ durSec, audioPath }, "audio too long for ASR API, skipping");
+    return {
+      ok: false,
+      reason: "too-long",
+      detail: `${durSec.toFixed(1)}s > ${MAX_DURATION_SEC}s`
+    };
+  }
+  let pcmPath;
+  try {
+    pcmPath = await toPcm(audioPath);
+  } catch (e) {
+    log4().warn({ err: e.message, audioPath }, "ffmpeg transcoding failed");
+    return { ok: false, reason: "ffmpeg-failed", detail: e.message };
+  }
+  try {
+    const pcm = readFileSync5(pcmPath);
+    if (pcm.length === 0) {
+      return { ok: false, reason: "empty", detail: "transcoded pcm is empty" };
+    }
+    const speech = pcm.toString("base64");
+    const fileId = randomUUID().replace(/-/g, "").slice(0, 16);
+    const resp = await client.api.speech_to_text.v1.speech.fileRecognize({
+      data: {
+        speech: { speech },
+        config: {
+          file_id: fileId,
+          format: "pcm",
+          engine_type: "16k_auto"
+        }
+      }
+    });
+    if (resp.code !== 0) {
+      log4().warn({ code: resp.code, msg: resp.msg }, "ASR API returned non-zero code");
+      return { ok: false, reason: "api-failed", detail: `code=${resp.code} msg=${resp.msg}` };
+    }
+    const text = (resp.data?.recognition_text ?? "").trim();
+    if (!text) {
+      return { ok: false, reason: "empty", detail: "recognition_text is empty" };
+    }
+    log4().info({ durSec, textLength: text.length }, "ASR success");
+    return { ok: true, text };
+  } catch (e) {
+    log4().warn({ err: e.message }, "ASR API call threw");
+    return { ok: false, reason: "api-failed", detail: e.message };
+  } finally {
+    try {
+      const st = statSync3(pcmPath);
+      if (st.isFile()) unlinkSync2(pcmPath);
+    } catch {
+    }
+  }
+}
+
+// src/commands/parse.ts
+var KIRO_INTERNAL_COMMANDS = /* @__PURE__ */ new Set([
+  "agent",
+  "tools",
+  "compact",
+  "login",
+  "logout",
+  "session",
+  "sessions",
+  "clear",
+  "usage",
+  "cost",
+  "profile"
+]);
+var COMMAND_ALIASES = {
+  // /model 系列
+  m: "model",
+  mod: "model",
+  mode: "model",
+  modle: "model",
+  models: "model",
+  // /help 系列
+  h: "help",
+  "?": "help",
+  // /status 系列
+  s: "status",
+  stat: "status",
+  // /new 系列
+  reset: "new",
+  clear: "new",
+  // 注意：覆盖 KIRO_INTERNAL_COMMANDS 里的 clear
+  // /stop 系列
+  abort: "stop",
+  cancel: "stop",
+  // /pwd 系列
+  cwd: "pwd",
+  // /reconnect
+  reconect: "reconnect",
+  rc: "reconnect",
+  // /timeout
+  to: "timeout"
+};
+function normalizeCommandHead(head) {
+  const lower = head.toLowerCase();
+  return COMMAND_ALIASES[lower] ?? lower;
+}
+function parseCommand(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const rest = trimmed.slice(1);
+  const [headRaw, ...tailParts] = rest.split(/\s+/);
+  const tail = tailParts.join(" ").trim();
+  const head = normalizeCommandHead(headRaw ?? "");
+  switch (head) {
+    case "new":
+    case "reset":
+      return { kind: "new" };
+    case "cd":
+      if (!tail) return { kind: "unknown", raw: trimmed };
+      return { kind: "cd", path: tail };
+    case "pwd":
+      return { kind: "pwd" };
+    case "status":
+      return { kind: "status" };
+    case "stop":
+      return { kind: "stop" };
+    case "reconnect":
+      return { kind: "reconnect" };
+    case "doctor":
+      return { kind: "doctor", description: tail };
+    case "config":
+    case "cfg":
+    case "settings":
+      return { kind: "config", mode: "show" };
+    case "model": {
+      if (!tail) return { kind: "model", mode: "show" };
+      const lower = tail.toLowerCase();
+      if (lower === "auto" || lower === "default" || lower === "reset")
+        return { kind: "model", mode: "reset" };
+      if (!/^[a-zA-Z0-9._-]{1,64}$/.test(tail)) {
+        return { kind: "unknown", raw: trimmed };
+      }
+      return { kind: "model", mode: "set", name: tail };
+    }
+    case "timeout": {
+      if (!tail) return { kind: "timeout", mode: "show" };
+      const lower = tail.toLowerCase();
+      if (lower === "off" || lower === "0" || lower === "disable")
+        return { kind: "timeout", mode: "off" };
+      if (lower === "default" || lower === "reset") return { kind: "timeout", mode: "default" };
+      const n = Number(lower);
+      if (Number.isFinite(n) && n > 0 && n <= 600) {
+        return { kind: "timeout", mode: "set", minutes: Math.floor(n) };
+      }
+      return { kind: "unknown", raw: trimmed };
+    }
+    case "help":
+      return { kind: "help" };
+    case "ws": {
+      const [sub, ...nameParts] = tail.split(/\s+/);
+      const name = nameParts.join(" ").trim();
+      if (sub === "list" || sub === "" || sub === void 0) return { kind: "ws-list" };
+      if (sub === "save" && name) return { kind: "ws-save", name };
+      if (sub === "use" && name) return { kind: "ws-use", name };
+      if ((sub === "remove" || sub === "rm" || sub === "delete") && name) {
+        return { kind: "ws-remove", name };
+      }
+      return { kind: "unknown", raw: trimmed };
+    }
+    default:
+      if (head && KIRO_INTERNAL_COMMANDS.has(head)) {
+        return { kind: "kiro-internal", name: head };
+      }
+      return { kind: "unknown", raw: trimmed };
+  }
+}
+
+// src/kiro/runner.ts
+import { execa as execa2 } from "execa";
+var log5 = () => getLogger().child({ module: "kiro-runner" });
+var ANSI_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\)|[ -/]*[0-9?])/g;
+function stripAnsi(input) {
+  return input.replace(ANSI_REGEX, "");
+}
+var PROMPT_PREFIX_REGEX = /^>\s*/;
+async function runKiro(opts) {
+  const {
+    prompt,
+    cwd,
+    resumeId,
+    binPath = "kiro-cli",
+    trustedTools = ["fs_read", "fs_write", "grep", "glob", "code"],
+    model,
+    agent,
+    timeoutMs = 10 * 60 * 1e3,
+    idleTimeoutMs = 0,
+    onChunk,
+    signal
+  } = opts;
+  const args = ["chat", "--no-interactive"];
+  if (resumeId) args.push("--resume-id", resumeId);
+  if (model) args.push("--model", model);
+  if (agent) args.push("--agent", agent);
+  if (trustedTools.length > 0) {
+    args.push(`--trust-tools=${trustedTools.join(",")}`);
+  } else {
+    args.push("--trust-tools=");
+  }
+  args.push(prompt);
+  log5().info({ cwd, resumeId, args: args.slice(0, 5) }, "spawning kiro-cli");
+  let timedOut = false;
+  let aborted = false;
+  let idleTimedOut = false;
+  let textBuf = "";
+  let lastChunkAt = Date.now();
+  const child = execa2(binPath, args, {
+    cwd,
+    reject: false,
+    stripFinalNewline: false,
+    buffer: false,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    detached: true,
+    env: { ...process.env, FORCE_COLOR: "0" }
+    // 尽量减少 ANSI（虽然没完全消除）
+  });
+  const killTree = (signal2) => {
+    const pid = child.pid;
+    if (pid === void 0) return;
+    try {
+      process.kill(-pid, signal2);
+    } catch (e) {
+      const code = e.code;
+      if (code !== "ESRCH") {
+        try {
+          child.kill(signal2);
+        } catch {
+        }
+      }
+    }
+  };
+  const timeoutHandle = setTimeout(() => {
+    timedOut = true;
+    log5().warn({ pid: child.pid, timeoutMs }, "kiro-cli timed out, sending SIGTERM");
+    killTree("SIGTERM");
+    setTimeout(() => {
+      killTree("SIGKILL");
+      child.stdout?.destroy();
+    }, 2e3);
+  }, timeoutMs);
+  let idleHandle = null;
+  if (idleTimeoutMs > 0) {
+    const checkInterval = Math.min(3e4, Math.max(5e3, Math.floor(idleTimeoutMs / 4)));
+    idleHandle = setInterval(() => {
+      if (Date.now() - lastChunkAt < idleTimeoutMs) return;
+      idleTimedOut = true;
+      log5().warn(
+        { pid: child.pid, idleTimeoutMs, sinceLastChunkMs: Date.now() - lastChunkAt },
+        "kiro-cli idle timeout, sending SIGTERM"
+      );
+      killTree("SIGTERM");
+      setTimeout(() => {
+        killTree("SIGKILL");
+        child.stdout?.destroy();
+      }, 2e3);
+      if (idleHandle) {
+        clearInterval(idleHandle);
+        idleHandle = null;
+      }
+    }, checkInterval);
+  }
+  const onAbort = () => {
+    aborted = true;
+    log5().info({ pid: child.pid }, "kiro-cli abort requested");
+    killTree("SIGTERM");
+    setTimeout(() => {
+      killTree("SIGKILL");
+      child.stdout?.destroy();
+    }, 2e3);
+  };
+  if (signal) {
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  }
+  if (child.stdout) {
+    child.stdout.setEncoding("utf-8");
+    child.stdout.on("data", (chunk) => {
+      lastChunkAt = Date.now();
+      const cleanRaw = stripAnsi(chunk).replace(PROMPT_PREFIX_REGEX, "");
+      if (!cleanRaw) return;
+      textBuf += cleanRaw;
+      try {
+        onChunk?.(cleanRaw);
+      } catch (e) {
+        log5().error({ err: e }, "onChunk callback threw");
+      }
+    });
+  }
+  if (child.stderr) {
+    child.stderr.setEncoding("utf-8");
+    child.stderr.on("data", (chunk) => {
+      log5().debug({ stderr: chunk.slice(0, 200) }, "kiro stderr");
+    });
+  }
+  const result = await child;
+  clearTimeout(timeoutHandle);
+  if (idleHandle) clearInterval(idleHandle);
+  if (signal) signal.removeEventListener("abort", onAbort);
+  log5().info(
+    { exitCode: result.exitCode, textLen: textBuf.length, aborted, timedOut, idleTimedOut },
+    "kiro-cli finished"
+  );
+  let newSessionId;
+  if (!aborted && !timedOut && !idleTimedOut && result.exitCode === 0) {
+    try {
+      newSessionId = await getLatestSessionId(cwd, binPath);
+    } catch (e) {
+      log5().warn({ err: e }, "failed to fetch latest session id");
+    }
+  }
+  return {
+    text: textBuf.trim(),
+    exitCode: result.exitCode ?? null,
+    newSessionId: newSessionId ?? resumeId,
+    aborted,
+    timedOut,
+    idleTimedOut
+  };
+}
+async function getLatestSessionId(cwd, binPath) {
+  const result = await execa2(binPath, ["chat", "--list-sessions"], {
+    cwd,
+    reject: false,
+    timeout: 1e4,
+    all: true
+  });
+  if (result.exitCode !== 0) return void 0;
+  const combined = result.all ?? result.stdout ?? "";
+  const text = stripAnsi(combined);
+  const m = text.match(/Chat SessionId:\s*([0-9a-f-]{36})/i);
+  return m?.[1];
+}
+
+// src/kiro/models.ts
+import { execa as execa3 } from "execa";
+var log6 = () => getLogger().child({ module: "kiro-models" });
+var cache = null;
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+async function listModels(binPath = "kiro-cli") {
+  if (cache && Date.now() - cache.at < CACHE_TTL_MS) return cache.data;
+  let r;
+  try {
+    r = await execa3(binPath, ["chat", "--list-models", "--format", "json"], {
+      reject: false,
+      timeout: 1e4,
+      all: true
+    });
+  } catch (e) {
+    log6().warn({ err: e.message }, "list-models spawn failed");
+    return void 0;
+  }
+  if (r.exitCode !== 0) {
+    log6().warn(
+      {
+        exitCode: r.exitCode,
+        stdoutSample: (r.stdout ?? "").slice(0, 200),
+        stderrSample: (r.stderr ?? "").slice(0, 200),
+        allSample: (r.all ?? "").slice(0, 200)
+      },
+      "list-models non-zero exit"
+    );
+    return void 0;
+  }
+  const text = stripAnsi((r.all ?? r.stdout ?? "").trim());
+  if (!text) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (e) {
+    log6().warn(
+      { err: e.message, sample: text.slice(0, 200) },
+      "list-models json parse failed"
+    );
+    return void 0;
+  }
+  if (!Array.isArray(parsed.models)) return void 0;
+  const data = {
+    defaultModel: parsed.default_model ?? "auto",
+    models: parsed.models.map((m) => ({
+      name: m.model_name,
+      description: m.description ?? "",
+      rateMultiplier: m.rate_multiplier ?? 1,
+      contextWindow: m.context_window_tokens ?? 0
+    }))
+  };
+  cache = { at: Date.now(), data };
+  return data;
+}
+function clearModelCache() {
+  cache = null;
+}
+
+// src/lib/debounce.ts
+var Debouncer = class {
+  constructor(delayMs) {
+    this.delayMs = delayMs;
+  }
+  delayMs;
+  timer = null;
+  pendingFn = null;
+  schedule(fn) {
+    this.pendingFn = fn;
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      const f = this.pendingFn;
+      this.pendingFn = null;
+      if (f) {
+        Promise.resolve(f()).catch((err) => {
+          console.error("[debouncer] task failed:", err);
+        });
+      }
+    }, this.delayMs);
+  }
+  /**
+   * 立刻执行最近一次 schedule 的任务（如果有），并取消计时器。
+   */
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    const f = this.pendingFn;
+    this.pendingFn = null;
+    if (f) await f();
+  }
+  cancel() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.pendingFn = null;
+  }
+};
+
+// src/card/schema.ts
+var HEADER_TEMPLATES = {
+  // pending/streaming 用蓝色，做出"进行中"的视觉信号
+  pending: { title: "\u23F3 \u601D\u8003\u4E2D", template: "blue" },
+  streaming: { title: "\u{1F4AC} \u56DE\u590D\u4E2D", template: "blue" },
+  // 完成态：标题极简就一个 "Kiro"，靠绿色模板色和 ✅ 头像传达成功
+  done: { title: "Kiro", template: "green" },
+  aborted: { title: "\u5DF2\u4E2D\u6B62", template: "orange" },
+  timedout: { title: "\u8D85\u65F6", template: "red" },
+  error: { title: "\u51FA\u9519", template: "red" }
+};
+function buildCard(state, body, ctx, traces) {
+  const header = HEADER_TEMPLATES[state];
+  const elements = [];
+  if (traces && traces.length > 0) {
+    const isProgressing = state === "pending" || state === "streaming";
+    elements.push({
+      tag: "collapsible_panel",
+      expanded: isProgressing,
+      vertical_spacing: "small",
+      padding: "4px 8px",
+      header: {
+        title: {
+          tag: "markdown",
+          content: `<font color='grey'>${isProgressing ? `\u2699\uFE0F \u5DE5\u5177\u8C03\u7528 \xB7 ${traces.length} \u6B65` : `\u5DE5\u5177\u8C03\u7528 \xB7 ${traces.length} \u6B65\uFF08\u70B9\u51FB\u67E5\u770B\uFF09`}</font>`
+        },
+        vertical_align: "center",
+        icon: {
+          tag: "standard_icon",
+          token: "down-small-ccm_outlined",
+          size: "12px 12px"
+        },
+        icon_position: "follow_text",
+        icon_expanded_angle: -180
+      },
+      elements: traces.map((t) => ({
+        tag: "markdown",
+        content: `<font color='grey'>${t}</font>`
+      }))
+    });
+  }
+  const bodyText = body.trim() || (state === "pending" || state === "streaming" ? "<font color='grey'>\u7B49\u5F85\u54CD\u5E94\u2026</font>" : "<font color='grey'>\u65E0\u8F93\u51FA</font>");
+  elements.push({
+    tag: "markdown",
+    content: bodyText
+  });
+  if (ctx.showFooter === true) {
+    const segs = [];
+    if (ctx.workspaceName) segs.push(`\u{1F5C2}\uFE0F ${ctx.workspaceName}`);
+    if (ctx.sessionStatus) segs.push(ctx.sessionStatus);
+    if (segs.length) {
+      elements.push({
+        tag: "markdown",
+        content: `<font color='grey'>${segs.join(" \xB7 ")}</font>`
+      });
+    }
+  }
+  const headerObj = {
+    title: { tag: "plain_text", content: header.title },
+    template: header.template
+  };
+  if (ctx.showFooter === true) {
+    const subtitleSegs = [];
+    if (ctx.workspaceName) subtitleSegs.push(`\u{1F5C2}\uFE0F ${ctx.workspaceName}`);
+    if (ctx.sessionStatus) subtitleSegs.push(ctx.sessionStatus);
+    const subtitle = subtitleSegs.join(" \xB7 ");
+    if (subtitle) {
+      headerObj["subtitle"] = { tag: "plain_text", content: subtitle };
+    }
+  }
+  return {
+    schema: "2.0",
+    header: headerObj,
+    body: { elements }
+  };
+}
+function truncateForCard(text, maxBytes = 2e4) {
+  const buf = Buffer.from(text, "utf-8");
+  if (buf.byteLength <= maxBytes) return text;
+  const cut = buf.subarray(0, maxBytes).toString("utf-8");
+  return cut + "\n\n<font color='grey'>\u2026\u5185\u5BB9\u8D85\u51FA\u5361\u7247\u4E0A\u9650\uFF0C\u5DF2\u622A\u65AD</font>";
+}
+
+// src/card/renderer.ts
+var CardRenderer = class {
+  lark;
+  chatId;
+  replyToMessageId;
+  debouncer;
+  log;
+  ctx;
+  messageId = null;
+  /** LLM 的真正回复文本（去掉 trace） */
+  accText = "";
+  /** 工具调用 trace 摘要（按出现顺序） */
+  traces = [];
+  currentState = "pending";
+  closed = false;
+  constructor(opts) {
+    this.lark = opts.lark;
+    this.chatId = opts.chatId;
+    if (opts.replyToMessageId !== void 0) {
+      this.replyToMessageId = opts.replyToMessageId;
+    }
+    this.debouncer = new Debouncer(opts.intervalMs);
+    this.log = opts.logger.child({ module: "card-renderer" });
+    this.ctx = opts.ctx;
+  }
+  /** 发出初始卡片。必须在 appendText 之前调用一次。 */
+  async open(initialState = "pending", initialText = "") {
+    this.currentState = initialState;
+    this.accText = initialText;
+    const card = buildCard(initialState, truncateForCard(this.accText), this.ctx, this.traces);
+    if (this.replyToMessageId) {
+      this.messageId = await this.lark.replyCard(this.replyToMessageId, card);
+    } else {
+      this.messageId = await this.lark.sendCard(this.chatId, card);
+    }
+    this.log.debug({ messageId: this.messageId, state: initialState }, "card opened");
+  }
+  /** 追加正文文本（LLM 真正的回复），触发节流更新。 */
+  appendText(chunk) {
+    if (this.closed) return;
+    this.accText += chunk;
+    if (this.currentState === "pending") {
+      this.currentState = "streaming";
+    }
+    this.debouncer.schedule(async () => {
+      await this.flush();
+    });
+  }
+  /** 追加一条工具调用 trace 摘要（如 "📖 读取 SKILL.md"）。 */
+  appendTrace(line) {
+    if (this.closed) return;
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    this.traces.push(trimmed);
+    if (this.currentState === "pending") {
+      this.currentState = "streaming";
+    }
+    this.debouncer.schedule(async () => {
+      await this.flush();
+    });
+  }
+  /** 把当前累积状态立即 patch 到飞书。 */
+  async flush() {
+    if (!this.messageId || this.closed) return;
+    const card = buildCard(this.currentState, truncateForCard(this.accText), this.ctx, this.traces);
+    try {
+      await this.lark.patchCard(this.messageId, card);
+    } catch (e) {
+      this.log.warn({ err: e }, "patchCard failed; will retry on next chunk");
+    }
+  }
+  /**
+   * 切到终态并最后更新一次。
+   * @param state 终态：done/aborted/timedout/error
+   * @param finalText 如果传入，覆盖现有累积文本（比如错误信息）
+   */
+  async finalize(state, finalText) {
+    if (this.closed) return;
+    this.closed = true;
+    this.debouncer.cancel();
+    if (finalText !== void 0) this.accText = finalText;
+    this.currentState = state;
+    if (!this.messageId) {
+      try {
+        await this.lark.sendText(this.chatId, this.accText.slice(0, 4e3));
+      } catch (e) {
+        this.log.error({ err: e }, "fallback sendText failed");
+      }
+      return;
+    }
+    const card = buildCard(state, truncateForCard(this.accText), this.ctx, this.traces);
+    try {
+      await this.lark.patchCard(this.messageId, card);
+    } catch (e) {
+      this.log.error({ err: e }, "finalize patchCard failed");
+    }
+  }
+  /** 中途切换上下文（比如 /cd 之后 cwd 变了） */
+  updateContext(ctx) {
+    this.ctx = { ...this.ctx, ...ctx };
+  }
+};
+
+// src/card/toolRender.ts
+import { homedir as homedir2 } from "os";
+var HEADER_SUMMARY_MAX = 80;
+var BODY_FIELD_MAX = 600;
+var OUTPUT_MAX = 1200;
+var BODY_TOTAL_MAX = 2500;
+function statusIcon(status) {
+  if (status === "done") return "\u2705";
+  if (status === "error") return "\u274C";
+  return "\u23F3";
+}
+function toolHeaderText(tool) {
+  const icon = statusIcon(tool.status);
+  const summary = summarizeInput(tool.name, tool.input);
+  return summary ? `${icon} **${tool.name}** \u2014 ${summary}` : `${icon} **${tool.name}**`;
+}
+function toolBodyMd(tool) {
+  const parts = [];
+  const inputMd = renderInput(tool);
+  if (inputMd) parts.push(inputMd);
+  if (tool.output) {
+    const truncated = truncate(tool.output, OUTPUT_MAX);
+    if (tool.status === "error") {
+      parts.push(`**Error**
+\`\`\`
+${truncated}
+\`\`\``);
+    } else if (tool.name === "Bash") {
+      parts.push(`**Output**
+\`\`\`
+${truncated}
+\`\`\``);
+    } else {
+      parts.push(`**Output**
+\`\`\`
+${truncated}
+\`\`\``);
+    }
+  } else if (tool.status === "running") {
+    parts.push("<font color='grey'>\u8FD0\u884C\u4E2D\u2026</font>");
+  }
+  const body = parts.join("\n\n");
+  if (body.length <= BODY_TOTAL_MAX) return body;
+  return `${body.slice(0, BODY_TOTAL_MAX)}\u2026
+
+<font color='grey'>\uFF08body \u5DF2\u622A\u65AD\uFF0C\u5B8C\u6574\u5185\u5BB9\u67E5 \`/doctor\` \u6216\u65E5\u5FD7\uFF09</font>`;
+}
+function summarizeInput(name, input) {
+  if (!input || typeof input !== "object") return "";
+  const rec = input;
+  const pick = (key, max = HEADER_SUMMARY_MAX) => {
+    const v = rec[key];
+    if (typeof v !== "string") return "";
+    const oneLine = v.replace(/\s+/g, " ").trim();
+    return oneLine.length > max ? `${oneLine.slice(0, max)}\u2026` : oneLine;
+  };
+  switch (name) {
+    case "Bash":
+      return pick("command");
+    case "Read":
+    case "Write":
+      return shortenPath(pick("file_path"));
+    case "Grep":
+    case "Glob":
+      return pick("pattern");
+    case "WebFetch":
+      return pick("url");
+    case "WebSearch":
+      return pick("query", 60);
+    default:
+      return pick("command") || pick("file_path") || pick("pattern") || pick("query");
+  }
+}
+function renderInput(tool) {
+  const input = tool.input;
+  if (!input || typeof input !== "object") return "";
+  const rec = input;
+  const str = (k) => typeof rec[k] === "string" ? rec[k] : "";
+  switch (tool.name) {
+    case "Bash": {
+      const cmd = str("command");
+      return cmd ? `**Command**
+\`\`\`bash
+${truncate(cmd, BODY_FIELD_MAX)}
+\`\`\`` : "";
+    }
+    case "Read":
+    case "Write": {
+      const fp = str("file_path");
+      const range = str("range");
+      const lines = [];
+      if (fp) lines.push(`**File** \`${shortenPath(fp)}\``);
+      if (range) lines.push(`**Range** ${range}`);
+      return lines.join("\n");
+    }
+    case "Grep":
+    case "Glob": {
+      const lines = [];
+      if (str("pattern")) lines.push(`**Pattern** \`${str("pattern")}\``);
+      if (str("path")) lines.push(`**Path** \`${shortenPath(str("path"))}\``);
+      return lines.join("\n");
+    }
+    case "WebFetch":
+      return str("url") ? `**URL** ${str("url")}` : "";
+    case "WebSearch":
+      return str("query") ? `**Query** \`${truncate(str("query"), BODY_FIELD_MAX)}\`` : "";
+    default:
+      return "";
+  }
+}
+function shortenPath(p) {
+  if (!p) return p;
+  const home = homedir2();
+  if (home && p.startsWith(home)) return `~${p.slice(home.length)}`;
+  return p;
+}
+function truncate(s, max) {
+  return s.length > max ? `${s.slice(0, max)}\u2026` : s;
+}
+
+// src/card/runRenderer.ts
+var REASONING_MAX = 1500;
+var COLLAPSE_TOOL_THRESHOLD = 3;
+function renderRunCard(state) {
+  const elements = [];
+  if (state.reasoning.content) {
+    elements.push(reasoningPanel(state.reasoning.content, state.reasoning.active));
+  }
+  for (const group of groupBlocks(state.blocks)) {
+    if (group.kind === "text") {
+      if (group.content.trim()) {
+        elements.push(markdown(group.content));
+      }
+    } else {
+      elements.push(...renderToolGroup(group.tools, state.terminal !== "running"));
+    }
+  }
+  if (state.terminal === "interrupted") {
+    elements.push(noteMd("<font color='grey'>\u23F9 \u5DF2\u88AB\u4E2D\u65AD</font>"));
+  } else if (state.terminal === "idle_timeout") {
+    const mins = state.idleTimeoutMinutes ?? 0;
+    elements.push(noteMd(`<font color='grey'>\u23F1 ${mins} \u5206\u949F\u65E0\u54CD\u5E94\uFF0C\u5DF2\u81EA\u52A8\u7EC8\u6B62</font>`));
+  } else if (state.terminal === "error" && state.errorMsg) {
+    elements.push(noteMd(`<font color='red'>\u26A0\uFE0F Kiro \u5931\u8D25\uFF1A${escapeMd(state.errorMsg)}</font>`));
+  } else if (state.terminal === "done" && elements.length === 0) {
+    elements.push(noteMd("<font color='grey'>\uFF08\u672A\u8FD4\u56DE\u5185\u5BB9\uFF09</font>"));
+  }
+  if (state.terminal === "running") {
+    if (state.footer) elements.push(footerStatus(state.footer));
+    elements.push(stopButton());
+  }
+  return {
+    schema: "2.0",
+    config: {
+      streaming_mode: state.terminal === "running",
+      summary: { content: summaryText(state) }
+    },
+    header: cardHeader(state),
+    body: { elements }
+  };
+}
+function cardHeader(state) {
+  const { title, template } = headerOf(state.terminal);
+  return {
+    title: { tag: "plain_text", content: title },
+    template
+  };
+}
+function headerOf(terminal) {
+  switch (terminal) {
+    case "running":
+      return { title: "\u{1F4AC} Kiro", template: "blue" };
+    case "done":
+      return { title: "\u2705 Kiro", template: "green" };
+    case "error":
+      return { title: "\u274C Kiro \u51FA\u9519", template: "red" };
+    case "interrupted":
+      return { title: "\u23F9 \u5DF2\u4E2D\u6B62", template: "orange" };
+    case "idle_timeout":
+      return { title: "\u23F1 \u8D85\u65F6", template: "red" };
+  }
+}
+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) {
+  const title = active ? "\u{1F9E0} **\u601D\u8003\u4E2D**" : "\u{1F9E0} **\u601D\u8003\u5B8C\u6210\uFF0C\u70B9\u51FB\u67E5\u770B**";
+  return collapsiblePanel({
+    title,
+    expanded: active,
+    border: "grey",
+    body: truncate2(content, REASONING_MAX)
+  });
+}
+function toolPanel(tool, expanded) {
+  return collapsiblePanel({
+    title: toolHeaderText(tool),
+    expanded,
+    border: tool.status === "error" ? "red" : "grey",
+    body: toolBodyMd(tool) || "<font color='grey'>\u65E0\u8F93\u51FA</font>"
+  });
+}
+function collapsedToolSummary(tools, finalized) {
+  const suffix = finalized ? "\uFF08\u5DF2\u7ED3\u675F\uFF09" : "";
+  const title = `\u2615 **${tools.length} \u4E2A\u5DE5\u5177\u8C03\u7528${suffix}**`;
+  const headerList = tools.map((t) => `- ${toolHeaderText(t)}`).join("\n");
+  return {
+    tag: "collapsible_panel",
+    expanded: false,
+    header: panelHeader(title),
+    border: { color: "blue", corner_radius: "5px" },
+    vertical_spacing: "8px",
+    padding: "8px 8px 8px 8px",
+    elements: [{ tag: "markdown", content: headerList, text_size: "notation" }]
+  };
+}
+function collapsiblePanel(opts) {
+  return {
+    tag: "collapsible_panel",
+    expanded: opts.expanded,
+    header: panelHeader(opts.title),
+    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 panelHeader(titleMd) {
+  return {
+    title: { tag: "markdown", content: titleMd },
+    vertical_align: "center",
+    icon: { tag: "standard_icon", token: "down-small-ccm_outlined", size: "16px 16px" },
+    icon_position: "follow_text",
+    icon_expanded_angle: -180
+  };
+}
+function markdown(content) {
+  return { tag: "markdown", content };
+}
+function noteMd(content) {
+  return { tag: "markdown", content, text_size: "notation" };
+}
+function stopButton() {
+  return {
+    tag: "button",
+    text: { tag: "plain_text", content: "\u23F9 \u7EC8\u6B62" },
+    type: "danger",
+    size: "small",
+    behaviors: [{ type: "callback", value: { action: "session.stop" } }]
+  };
+}
+function footerStatus(status) {
+  const text = status === "thinking" ? "<font color='grey'>\u{1F9E0} \u6B63\u5728\u601D\u8003</font>" : status === "tool_running" ? "<font color='grey'>\u{1F9F0} \u6B63\u5728\u8C03\u7528\u5DE5\u5177</font>" : "<font color='grey'>\u270D\uFE0F \u6B63\u5728\u8F93\u51FA</font>";
+  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 truncate2(s, max) {
+  return s.length > max ? `${s.slice(0, max)}\u2026` : s;
+}
+function escapeMd(s) {
+  return s.replace(/([*_`\\])/g, "\\$1");
+}
+
+// src/kiro/runState.ts
+function createInitialState(idleTimeoutMinutes) {
+  const state = {
+    blocks: [],
+    reasoning: { content: "", active: false },
+    terminal: "running",
+    footer: "thinking"
+  };
+  if (idleTimeoutMinutes !== void 0) {
+    state.idleTimeoutMinutes = idleTimeoutMinutes;
+  }
+  return state;
+}
+function findLastRunningTool(state) {
+  for (let i = state.blocks.length - 1; i >= 0; i--) {
+    const b = state.blocks[i];
+    if (b && b.kind === "tool" && b.tool.status === "running") return b.tool;
+  }
+  return void 0;
+}
+function pushTool(state, tool) {
+  state.blocks.push({ kind: "tool", tool });
+  state.footer = "tool_running";
+}
+function appendText(state, content) {
+  if (!content) return;
+  const last = state.blocks[state.blocks.length - 1];
+  if (last && last.kind === "text") {
+    last.content += content;
+  } else {
+    state.blocks.push({ kind: "text", content });
+  }
+  state.footer = "streaming";
+}
+function finishLastRunningTool(state, status, output) {
+  const tool = findLastRunningTool(state);
+  if (!tool) return;
+  tool.status = status;
+  tool.finishedAt = Date.now();
+  if (output !== void 0) tool.output = output;
+}
+function appendToolOutput(state, chunk) {
+  if (!chunk) return;
+  const tool = findLastRunningTool(state);
+  if (!tool) return;
+  tool.output = (tool.output ?? "") + chunk;
+}
+
+// src/kiro/runStreamParser.ts
+function detectToolStart(line) {
+  const t = line.trim();
+  let m = t.match(/^Reading file:\s*([^,(]+?)\s*(?:,([^()]+))?\s*\(using tool:/);
+  if (m) {
+    const input = { file_path: (m[1] ?? "").trim() };
+    const range = (m[2] ?? "").trim();
+    if (range) input["range"] = range;
+    return { name: "Read", input };
+  }
+  m = t.match(/^Writing file:\s*([^,(]+?)\s*\(using tool:/);
+  if (m) {
+    return { name: "Write", input: { file_path: (m[1] ?? "").trim() } };
+  }
+  m = t.match(/^I will run the following command:\s*(.+?)\s*\(using tool:/);
+  if (m) {
+    return { name: "Bash", input: { command: (m[1] ?? "").trim() } };
+  }
+  m = t.match(/^Searching for\s*[`"']?([^`"'\n]+?)[`"']?\s*\(using tool:\s*(grep|glob)/);
+  if (m) {
+    const tool = m[2] === "glob" ? "Glob" : "Grep";
+    return { name: tool, input: { pattern: (m[1] ?? "").trim() } };
+  }
+  m = t.match(/^(?:Fetching|Browsing)\s+(.+?)\s*\(using tool:\s*web_fetch/);
+  if (m) {
+    return { name: "WebFetch", input: { url: (m[1] ?? "").trim() } };
+  }
+  m = t.match(/^Searching the web for\s+(.+?)\s*\(using tool:\s*web_search/);
+  if (m) {
+    return { name: "WebSearch", input: { query: (m[1] ?? "").trim() } };
+  }
+  m = t.match(/\(using tool:\s*([a-z_]+)\)/);
+  if (m) {
+    return {
+      name: prettifyToolName(m[1] ?? "tool"),
+      input: { raw_line: t }
+    };
+  }
+  return null;
+}
+function prettifyToolName(name) {
+  switch (name) {
+    case "fs_read":
+    case "read":
+      return "Read";
+    case "fs_write":
+    case "write":
+      return "Write";
+    case "execute_bash":
+    case "shell":
+      return "Bash";
+    case "grep":
+      return "Grep";
+    case "glob":
+      return "Glob";
+    case "web_search":
+      return "WebSearch";
+    case "web_fetch":
+      return "WebFetch";
+    case "use_aws":
+      return "AWS";
+    case "use_subagent":
+      return "Subagent";
+    case "code":
+      return "Code";
+    default:
+      return name.split("_").map((s) => s ? s[0].toUpperCase() + s.slice(1) : "").join("");
+  }
+}
+function isSilent(t) {
+  return /^✓ Successfully /.test(t) || /^[▸▶]\s*Credits:/.test(t) || /^Purpose:/.test(t) || /^WARNING:/.test(t);
+}
+function createRunStreamParser() {
+  let buf = "";
+  let parserState = "normal";
+  let toolIdCounter = 0;
+  const newToolId = () => `t${Date.now().toString(36)}-${toolIdCounter++}`;
+  const processLine = (rawLine, state) => {
+    const line = rawLine;
+    const t = line.trim();
+    if (/^- Completed in /.test(t)) {
+      finishLastRunningTool(state, "done");
+      parserState = "normal";
+      return;
+    }
+    if (isSilent(t)) return;
+    if (parserState === "in-tool") {
+      appendToolOutput(state, line + "\n");
+      return;
+    }
+    const toolStart = detectToolStart(line);
+    if (toolStart) {
+      const tool = {
+        id: newToolId(),
+        name: toolStart.name,
+        input: toolStart.input,
+        status: "running",
+        startedAt: Date.now()
+      };
+      pushTool(state, tool);
+      parserState = "in-tool";
+      return;
+    }
+    if (t.startsWith("> ")) {
+      appendText(state, t.slice(2) + "\n");
+      return;
+    }
+    if (t === ">") {
+      appendText(state, "\n");
+      return;
+    }
+    if (line.length > 0 || state.blocks[state.blocks.length - 1]?.kind === "text") {
+      appendText(state, line + "\n");
+    }
+  };
+  return {
+    feed(chunk, state) {
+      buf += chunk;
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const line of lines) {
+        processLine(line, state);
+      }
+    },
+    flush(state) {
+      if (!buf) return;
+      processLine(buf, state);
+      buf = "";
+    }
+  };
+}
+
+// src/card/runCardController.ts
+var RunCardController = class {
+  lark;
+  chatId;
+  replyToMessageId;
+  debouncer;
+  log;
+  parser;
+  messageId = null;
+  state;
+  closed = false;
+  constructor(opts) {
+    this.lark = opts.lark;
+    this.chatId = opts.chatId;
+    if (opts.replyToMessageId !== void 0) {
+      this.replyToMessageId = opts.replyToMessageId;
+    }
+    this.debouncer = new Debouncer(opts.intervalMs);
+    this.log = opts.logger.child({ module: "run-card" });
+    this.parser = createRunStreamParser();
+    this.state = createInitialState(opts.idleTimeoutMinutes);
+  }
+  /** 发送初始卡片。必须在 feed 之前调用一次。 */
+  async open() {
+    const card = renderRunCard(this.state);
+    if (this.replyToMessageId) {
+      this.messageId = await this.lark.replyCard(this.replyToMessageId, card);
+    } else {
+      this.messageId = await this.lark.sendCard(this.chatId, card);
+    }
+    this.log.debug({ messageId: this.messageId }, "run card opened");
+  }
+  /**
+   * 喂入一段 stdout chunk（已 stripAnsi）。
+   * 内部经过 parser 更新 state，节流后 patchCard。
+   */
+  feed(chunk) {
+    if (this.closed) return;
+    this.parser.feed(chunk, this.state);
+    this.scheduleFlush();
+  }
+  /**
+   * 把卡片状态切到终态并立刻刷新。
+   *
+   * @param terminal 终态：done/error/interrupted/idle_timeout
+   * @param errorMsg 仅在 terminal=error 时使用
+   */
+  async finalize(terminal, errorMsg) {
+    if (this.closed) return;
+    this.closed = true;
+    this.debouncer.cancel();
+    this.parser.flush(this.state);
+    this.state.terminal = terminal;
+    this.state.footer = null;
+    if (errorMsg !== void 0) this.state.errorMsg = errorMsg;
+    if (!this.messageId) {
+      try {
+        const text = this.fallbackText();
+        await this.lark.sendText(this.chatId, text.slice(0, 4e3));
+      } catch (e) {
+        this.log.error({ err: e }, "fallback sendText failed");
+      }
+      return;
+    }
+    const card = renderRunCard(this.state);
+    try {
+      await this.lark.patchCard(this.messageId, card);
+    } catch (e) {
+      this.log.error({ err: e }, "finalize patchCard failed");
+    }
+  }
+  /** 当前是否还在跑（外部判断要不要 flush） */
+  isClosed() {
+    return this.closed;
+  }
+  // ----- 内部 -----
+  scheduleFlush() {
+    this.debouncer.schedule(async () => {
+      await this.flush();
+    });
+  }
+  async flush() {
+    if (!this.messageId || this.closed) return;
+    const card = renderRunCard(this.state);
+    try {
+      await this.lark.patchCard(this.messageId, card);
+    } catch (e) {
+      this.log.warn({ err: e }, "patchCard failed; will retry next chunk");
+    }
+  }
+  /** finalize 但 messageId 没发出来时的兜底纯文本 */
+  fallbackText() {
+    const parts = [];
+    for (const b of this.state.blocks) {
+      if (b.kind === "text") parts.push(b.content);
+    }
+    if (this.state.errorMsg) parts.push(`
+[\u9519\u8BEF] ${this.state.errorMsg}`);
+    return parts.join("") || "\uFF08\u65E0\u56DE\u590D\uFF09";
+  }
+};
+
+// src/card/builders.ts
+function buildHeader(h) {
+  const out = {
+    title: { tag: "plain_text", content: h.title },
+    template: h.template
+  };
+  if (h.subtitle) out["subtitle"] = { tag: "plain_text", content: h.subtitle };
+  return out;
+}
+function btn(opts) {
+  const out = {
+    tag: "button",
+    text: { tag: "plain_text", content: opts.text },
+    type: opts.type ?? "default",
+    size: opts.size ?? "small",
+    width: opts.width ?? "default",
+    behaviors: [{ type: "callback", value: opts.value }]
+  };
+  if (opts.hoverTip) {
+    out["hover_tips"] = { tag: "plain_text", content: opts.hoverTip };
+  }
+  if (opts.confirm) {
+    out["confirm"] = {
+      title: { tag: "plain_text", content: opts.confirm.title },
+      text: { tag: "plain_text", content: opts.confirm.text }
+    };
+  }
+  return out;
+}
+function md(content, textAlign = "left") {
+  return { tag: "markdown", content, text_align: textAlign };
+}
+function hr() {
+  return { tag: "hr" };
+}
+function column(opts) {
+  return {
+    tag: "column",
+    width: opts.width ?? "weighted",
+    weight: opts.weight ?? 1,
+    vertical_align: opts.vAlign ?? "center",
+    elements: opts.elements
+  };
+}
+function columnSet(opts) {
+  return {
+    tag: "column_set",
+    flex_mode: opts.flexMode ?? "none",
+    background_style: opts.background ?? "default",
+    horizontal_spacing: opts.horizontalSpacing ?? "default",
+    columns: opts.columns
+  };
+}
+function buildModelPickerCard(opts) {
+  const { current, list } = opts;
+  const groups = groupModels(list.models);
+  const elements = [];
+  const renderModelRow = (m) => {
+    const isCurrent = m.name === current;
+    const ctxLabel = m.contextWindow >= 1e6 ? "1M" : m.contextWindow >= 1e3 ? `${Math.round(m.contextWindow / 1e3)}K` : `${m.contextWindow}`;
+    const rateLabel = `${m.rateMultiplier}\xD7`;
+    const shortName = m.name.replace(/^claude-/, "");
+    const namePart = isCurrent ? `**\u2713 ${shortName}**` : `\u3000${shortName}`;
+    return columnSet({
+      flexMode: "none",
+      horizontalSpacing: "small",
+      columns: [
+        column({ weight: 5, elements: [md(namePart)] }),
+        column({
+          weight: 3,
+          elements: [md(`<font color='grey'>${rateLabel} \xB7 ${ctxLabel}</font>`, "right")]
+        }),
+        column({
+          weight: 2,
+          vAlign: "center",
+          elements: [
+            isCurrent ? md(`<font color='green'>**\u5F53\u524D**</font>`, "right") : btn({
+              text: "\u9009\u7528",
+              type: "primary",
+              size: "tiny",
+              value: { action: "model.set", name: m.name },
+              hoverTip: m.description || m.name
+            })
+          ]
+        })
+      ]
+    });
+  };
+  for (const m of groups.recommended) {
+    elements.push(renderModelRow(m));
+  }
+  const otherModels = [...groups.experimental, ...groups.legacy];
+  if (otherModels.length > 0) {
+    elements.push({
+      tag: "collapsible_panel",
+      expanded: false,
+      vertical_spacing: "small",
+      padding: "4px 8px",
+      header: {
+        title: {
+          tag: "markdown",
+          content: `<font color='grey'>\u5C55\u5F00\u5176\u4ED6 ${otherModels.length} \u4E2A\u6A21\u578B\uFF08\u5B9E\u9A8C\u6027 / \u7B2C\u4E09\u65B9 / \u65E7\u7248\uFF09</font>`
+        },
+        vertical_align: "center",
+        icon: {
+          tag: "standard_icon",
+          token: "down-small-ccm_outlined",
+          size: "14px 14px"
+        },
+        icon_position: "follow_text",
+        icon_expanded_angle: -180
+      },
+      elements: otherModels.map((m) => renderModelRow(m))
+    });
+  }
+  elements.push(
+    columnSet({
+      flexMode: "flow",
+      horizontalSpacing: "small",
+      columns: [
+        column({
+          width: "auto",
+          elements: [
+            btn({
+              text: "\u21BA \u6062\u590D\u9ED8\u8BA4",
+              type: "default",
+              size: "tiny",
+              value: { action: "model.reset" },
+              hoverTip: "\u6E05\u9664\u6A21\u578B\u8986\u76D6\uFF0C\u56DE\u5F52 kiro-cli \u9ED8\u8BA4\uFF08auto\uFF09"
+            })
+          ]
+        }),
+        column({
+          width: "auto",
+          elements: [
+            btn({
+              text: "\u{1F504} \u5237\u65B0",
+              type: "default",
+              size: "tiny",
+              value: { action: "model.refresh" },
+              hoverTip: "\u6E05\u7F13\u5B58\u91CD\u65B0\u67E5\u8BE2\u6A21\u578B\u5217\u8868"
+            })
+          ]
+        })
+      ]
+    })
+  );
+  return {
+    schema: "2.0",
+    header: buildHeader({
+      title: "\u{1F39B}\uFE0F \u9009\u62E9\u6A21\u578B",
+      template: "blue",
+      subtitle: `\u5F53\u524D \xB7 ${current.replace(/^claude-/, "")}`
+    }),
+    body: { elements }
+  };
+}
+function groupModels(models) {
+  const recommended = [];
+  const experimental = [];
+  const legacy = [];
+  for (const m of models) {
+    const name = m.name.toLowerCase();
+    const desc = (m.description || "").toLowerCase();
+    if (name === "auto") {
+      recommended.unshift(m);
+      continue;
+    }
+    if (desc.includes("experimental") || desc.includes("preview")) {
+      experimental.push(m);
+      continue;
+    }
+    if (name.startsWith("deepseek") || name.startsWith("minimax") || name.startsWith("glm") || name.startsWith("qwen")) {
+      experimental.push(m);
+      continue;
+    }
+    if (name === "claude-sonnet-4.6" || name === "claude-opus-4.6" || name === "claude-haiku-4.5") {
+      recommended.push(m);
+      continue;
+    }
+    legacy.push(m);
+  }
+  return { recommended, experimental, legacy };
+}
+function buildHelpCard() {
+  const sec = (items) => items.map(
+    ([cmd, desc]) => columnSet({
+      flexMode: "none",
+      horizontalSpacing: "small",
+      columns: [
+        column({ weight: 3, elements: [md(`\`${cmd}\``)] }),
+        column({
+          weight: 5,
+          elements: [md(`<font color='grey'>${desc}</font>`)]
+        })
+      ]
+    })
+  );
+  const collapsed = (title, items) => ({
+    tag: "collapsible_panel",
+    expanded: false,
+    vertical_spacing: "small",
+    padding: "4px 8px",
+    header: {
+      title: {
+        tag: "markdown",
+        content: `<font color='grey'>${title}</font>`
+      },
+      vertical_align: "center",
+      icon: {
+        tag: "standard_icon",
+        token: "down-small-ccm_outlined",
+        size: "14px 14px"
+      },
+      icon_position: "follow_text",
+      icon_expanded_angle: -180
+    },
+    elements: sec(items)
+  });
+  const elements = [
+    md("\u5728\u98DE\u4E66\u91CC\u8C03\u7528\u672C\u5730 Kiro CLI\uFF0C\u6BCF\u4E2A\u5BF9\u8BDD\u72EC\u7ACB session\u3002"),
+    ...sec([
+      ["/new", "\u91CD\u7F6E\u5F53\u524D\u4F1A\u8BDD"],
+      ["/status", "\u67E5\u770B cwd / session / watchdog"],
+      ["/stop", "\u505C\u6B62\u6B63\u5728\u8DD1\u7684\u4EFB\u52A1"],
+      ["/model \xB7 /m", "\u67E5\u770B / \u5207\u6362\u6A21\u578B"]
+    ]),
+    collapsed("\u5C55\u5F00\uFF1A\u5DE5\u4F5C\u76EE\u5F55 & \u5DE5\u4F5C\u533A", [
+      ["/pwd", "\u67E5\u770B\u5F53\u524D\u76EE\u5F55"],
+      ["/cd <path>", "\u5207\u6362\u76EE\u5F55\uFF08\u767D\u540D\u5355\u5185\uFF09"],
+      ["/ws list", "\u5217\u51FA\u547D\u540D\u5DE5\u4F5C\u533A"],
+      ["/ws save <name>", "\u628A\u5F53\u524D cwd \u5B58\u4E3A\u5DE5\u4F5C\u533A"],
+      ["/ws use <name>", "\u5207\u5230\u547D\u540D\u5DE5\u4F5C\u533A"]
+    ]),
+    collapsed("\u5C55\u5F00\uFF1A\u8FD0\u7EF4", [
+      ["/timeout [N|off]", "idle watchdog \u9608\u503C"],
+      ["/config", "\u67E5\u770B / \u7F16\u8F91\u8BBF\u95EE\u63A7\u5236 + \u504F\u597D\uFF08\u7BA1\u7406\u5458\uFF09"],
+      ["/reconnect", "\u91CD\u8FDE\u98DE\u4E66 WebSocket"],
+      ["/doctor [\u63CF\u8FF0]", "\u770B\u65E5\u5FD7\u81EA\u8BCA\u65AD"]
+    ]),
+    hr(),
+    columnSet({
+      flexMode: "flow",
+      horizontalSpacing: "small",
+      columns: [
+        column({
+          width: "auto",
+          elements: [
+            btn({
+              text: "\u{1F4CA} \u72B6\u6001",
+              type: "default",
+              size: "tiny",
+              value: { action: "session.status" }
+            })
+          ]
+        }),
+        column({
+          width: "auto",
+          elements: [
+            btn({
+              text: "\u{1F39B}\uFE0F \u6A21\u578B",
+              type: "default",
+              size: "tiny",
+              value: { action: "model.show" }
+            })
+          ]
+        }),
+        column({
+          width: "auto",
+          elements: [
+            btn({
+              text: "\u{1F5C2}\uFE0F \u5DE5\u4F5C\u533A",
+              type: "default",
+              size: "tiny",
+              value: { action: "ws.list" }
+            })
+          ]
+        }),
+        column({
+          width: "auto",
+          elements: [
+            btn({
+              text: "\u{1F504} \u91CD\u7F6E\u4F1A\u8BDD",
+              type: "default",
+              size: "tiny",
+              value: { action: "session.new" },
+              confirm: {
+                title: "\u91CD\u7F6E\u4F1A\u8BDD",
+                text: "\u5C06\u6E05\u7A7A\u5F53\u524D cwd \u4E0B\u7684 Kiro \u4F1A\u8BDD\u5386\u53F2\u3002\u4E0B\u6761\u6D88\u606F\u4F1A\u65B0\u5EFA session\u3002"
+              }
+            })
+          ]
+        })
+      ]
+    })
+  ];
+  return {
+    schema: "2.0",
+    header: buildHeader({ title: "\u{1F4D6} \u547D\u4EE4\u5E2E\u52A9", template: "blue" }),
+    body: { elements }
+  };
+}
+function buildWorkspaceListCard(opts) {
+  const entries = Object.entries(opts.workspaces);
+  const elements = [];
+  if (entries.length === 0) {
+    elements.push(
+      md(
+        "_\u5F53\u524D\u6CA1\u6709\u547D\u540D\u5DE5\u4F5C\u533A\u3002_\n\n\u7528 `/ws save <name>` \u628A\u5F53\u524D\u76EE\u5F55\u5B58\u4E3A\u5DE5\u4F5C\u533A\uFF0C\u65B9\u4FBF\u540E\u7EED `/ws use <name>` \u4E00\u952E\u5207\u6362\u3002"
+      )
+    );
+    return {
+      schema: "2.0",
+      header: buildHeader({ title: "\u{1F5C2}\uFE0F \u547D\u540D\u5DE5\u4F5C\u533A", template: "blue" }),
+      body: { elements }
+    };
+  }
+  for (const [name, path] of entries) {
+    const isCurrent = path === opts.currentCwd;
+    const shortPath = shortenPath2(path, 40);
+    elements.push(
+      columnSet({
+        flexMode: "none",
+        horizontalSpacing: "small",
+        columns: [
+          column({
+            weight: 3,
+            elements: [md(isCurrent ? `**\u2713 ${name}**` : `\u3000${name}`)]
+          }),
+          column({
+            weight: 4,
+            elements: [md(`<font color='grey'>${shortPath}</font>`, "right")]
+          }),
+          column({
+            weight: 2,
+            vAlign: "center",
+            elements: [
+              isCurrent ? md(`<font color='green'>**\u5F53\u524D**</font>`, "right") : btn({
+                text: "\u5207\u6362",
+                type: "primary",
+                size: "tiny",
+                value: { action: "ws.use", name },
+                hoverTip: path
+              })
+            ]
+          })
+        ]
+      })
+    );
+  }
+  elements.push(hr());
+  elements.push(
+    md('<font color="grey">\u{1F4A1} \u7528 `/ws save <name>` \u6DFB\u52A0\uFF0C`/ws remove <name>` \u5220\u9664\u3002</font>')
+  );
+  return {
+    schema: "2.0",
+    header: buildHeader({
+      title: "\u{1F5C2}\uFE0F \u547D\u540D\u5DE5\u4F5C\u533A",
+      template: "blue",
+      subtitle: `${entries.length} \u4E2A`
+    }),
+    body: { elements }
+  };
+}
+function buildStatusCard(opts) {
+  const elements = [];
+  const row = (label, val) => columnSet({
+    flexMode: "none",
+    horizontalSpacing: "small",
+    columns: [
+      column({
+        weight: 2,
+        elements: [md(`<font color='grey'>${label}</font>`)]
+      }),
+      column({ weight: 5, elements: [md(val)] })
+    ]
+  });
+  elements.push(row("\u5F53\u524D\u76EE\u5F55", `\`${opts.cwd}\``));
+  if (opts.workspaceName) {
+    elements.push(row("\u5DE5\u4F5C\u533A", `\u{1F5C2}\uFE0F \`${opts.workspaceName}\``));
+  }
+  elements.push(
+    row(
+      "Kiro session",
+      opts.kiroSessionId ? `\u21AA\uFE0F \`${opts.kiroSessionId.slice(0, 8)}\u2026\`` : "_\u672A\u5EFA\u7ACB\uFF0C\u4E0B\u6761\u6D88\u606F\u4F1A\u65B0\u5EFA_"
+    )
+  );
+  elements.push(row("\u4EFB\u52A1\u72B6\u6001", opts.hasActiveTask ? "\u{1F7E2} \u8FDB\u884C\u4E2D" : "\u26AA \u7A7A\u95F2"));
+  elements.push(
+    row(
+      "Idle watchdog",
+      opts.idleMinutes > 0 ? `${opts.idleMinutes} \u5206\u949F${opts.isPerChatOverride ? "\uFF08per-chat \u8986\u76D6\uFF09" : ""}` : "\u5173\u95ED"
+    )
+  );
+  elements.push(hr());
+  elements.push(
+    columnSet({
+      flexMode: "flow",
+      horizontalSpacing: "small",
+      columns: [
+        column({
+          width: "auto",
+          elements: [
+            btn({
+              text: "\u{1F504} \u91CD\u7F6E\u4F1A\u8BDD",
+              type: "default",
+              size: "tiny",
+              value: { action: "session.new" },
+              confirm: {
+                title: "\u91CD\u7F6E\u4F1A\u8BDD",
+                text: "\u5C06\u6E05\u7A7A\u5F53\u524D cwd \u4E0B\u7684 Kiro \u4F1A\u8BDD\u5386\u53F2\u3002\u4E0B\u6761\u6D88\u606F\u4F1A\u65B0\u5EFA session\u3002"
+              }
+            })
+          ]
+        }),
+        ...opts.hasActiveTask ? [
+          column({
+            width: "auto",
+            elements: [
+              btn({
+                text: "\u23F9 \u505C\u6B62\u4EFB\u52A1",
+                type: "danger",
+                size: "tiny",
+                value: { action: "session.stop" }
+              })
+            ]
+          })
+        ] : [],
+        column({
+          width: "auto",
+          elements: [
+            btn({
+              text: "\u{1F39B}\uFE0F \u6A21\u578B",
+              type: "default",
+              size: "tiny",
+              value: { action: "model.show" }
+            })
+          ]
+        }),
+        column({
+          width: "auto",
+          elements: [
+            btn({
+              text: "\u{1F5C2}\uFE0F \u5DE5\u4F5C\u533A",
+              type: "default",
+              size: "tiny",
+              value: { action: "ws.list" }
+            })
+          ]
+        })
+      ]
+    })
+  );
+  return {
+    schema: "2.0",
+    header: buildHeader({
+      title: "\u{1F4CA} \u5F53\u524D\u72B6\u6001",
+      template: "green",
+      ...opts.workspaceName ? { subtitle: `\u{1F5C2}\uFE0F ${opts.workspaceName}` } : {}
+    }),
+    body: { elements }
+  };
+}
+function buildAckCard(opts) {
+  const tmpl = {
+    done: { title: "\u2705 \u5DF2\u5B8C\u6210", template: "green" },
+    error: { title: "\u274C \u51FA\u9519", template: "red" },
+    aborted: { title: "\u23F9 \u5DF2\u4E2D\u6B62", template: "orange" }
+  };
+  const { template } = tmpl[opts.state];
+  const title = opts.title ?? tmpl[opts.state].title;
+  return {
+    schema: "2.0",
+    header: buildHeader({ title, template }),
+    body: { elements: [md(opts.body)] }
+  };
+}
+function buildLoadingCard(message = "\u5904\u7406\u4E2D\u2026", title = "\u23F3 \u5904\u7406\u4E2D") {
+  return {
+    schema: "2.0",
+    header: buildHeader({ title, template: "wathet" }),
+    body: { elements: [md(message)] }
+  };
+}
+function buildConfigViewCard(opts) {
+  const elements = [];
+  const list = (xs, emptyHint) => {
+    if (xs.length === 0) return `<font color='grey'>${emptyHint}</font>`;
+    return xs.map((x) => `\`${x}\``).join("\u3001");
+  };
+  const row = (label, value) => columnSet({
+    flexMode: "none",
+    horizontalSpacing: "small",
+    columns: [
+      column({ weight: 2, elements: [md(`<font color='grey'>${label}</font>`)] }),
+      column({ weight: 5, elements: [md(value)] })
+    ]
+  });
+  elements.push(md("**\u{1F510} \u8BBF\u95EE\u63A7\u5236**"));
+  elements.push(row("\u5141\u8BB8\u7684\u7528\u6237", list(opts.allowedUsers, "\u7A7A = \u6240\u6709\u7528\u6237")));
+  elements.push(row("\u5141\u8BB8\u7684\u7FA4", list(opts.allowedChats, "\u7A7A = \u6240\u6709\u7FA4\uFF08DM \u6C38\u8FDC\u8C41\u514D\uFF09")));
+  elements.push(row("\u7BA1\u7406\u5458", list(opts.admins, "\u7A7A = \u6240\u6709\u7528\u6237\u90FD\u662F admin")));
+  elements.push(hr());
+  elements.push(md("**\u2699\uFE0F \u504F\u597D**"));
+  elements.push(row("\u7FA4\u91CC\u9700\u8981 @bot", opts.requireMentionInGroup ? "\u2713 \u662F" : "\xD7 \u5426"));
+  elements.push(
+    row(
+      "Idle watchdog\uFF08\u9ED8\u8BA4\uFF09",
+      opts.idleTimeoutMinutes > 0 ? `${opts.idleTimeoutMinutes} \u5206\u949F` : "\u5173\u95ED"
+    )
+  );
+  elements.push(row("\u5361\u7247\u66F4\u65B0\u95F4\u9694", `${opts.cardUpdateIntervalMs}ms`));
+  elements.push(hr());
+  if (opts.isAdmin) {
+    elements.push(
+      columnSet({
+        flexMode: "flow",
+        horizontalSpacing: "small",
+        columns: [
+          column({
+            width: "auto",
+            elements: [
+              btn({
+                text: "\u270F\uFE0F \u7F16\u8F91\u914D\u7F6E",
+                type: "primary",
+                size: "tiny",
+                value: { action: "config.edit" }
+              })
+            ]
+          }),
+          column({
+            width: "auto",
+            elements: [
+              btn({
+                text: "\u{1F504} \u5237\u65B0",
+                type: "default",
+                size: "tiny",
+                value: { action: "config.show" }
+              })
+            ]
+          })
+        ]
+      })
+    );
+  } else {
+    elements.push(md('<font color="grey">\u4EC5\u7BA1\u7406\u5458\u53EF\u7F16\u8F91\u914D\u7F6E</font>'));
+  }
+  return {
+    schema: "2.0",
+    header: buildHeader({ title: "\u2699\uFE0F \u5F53\u524D\u914D\u7F6E", template: "wathet" }),
+    body: { elements }
+  };
+}
+function buildConfigFormCard(opts) {
+  const csv = (xs) => xs.join(", ");
+  const inputElement = (name, label, value, placeholder) => columnSet({
+    flexMode: "none",
+    horizontalSpacing: "small",
+    columns: [
+      column({ weight: 2, elements: [md(`<font color='grey'>${label}</font>`)] }),
+      column({
+        weight: 5,
+        elements: [
+          {
+            tag: "input",
+            name,
+            default_value: value,
+            placeholder: { tag: "plain_text", content: placeholder },
+            width: "fill"
+          }
+        ]
+      })
+    ]
+  });
+  const radioElement = (name, label, current) => columnSet({
+    flexMode: "none",
+    horizontalSpacing: "small",
+    columns: [
+      column({ weight: 2, elements: [md(`<font color='grey'>${label}</font>`)] }),
+      column({
+        weight: 5,
+        elements: [
+          {
+            tag: "select_static",
+            name,
+            initial_option: current,
+            options: [
+              { text: { tag: "plain_text", content: "\u662F" }, value: "yes" },
+              { text: { tag: "plain_text", content: "\u5426" }, value: "no" }
+            ],
+            width: "fill"
+          }
+        ]
+      })
+    ]
+  });
+  const elements = [
+    md("**\u{1F510} \u8BBF\u95EE\u63A7\u5236** \u2014 \u9017\u53F7\u5206\u9694\u591A\u4E2A ID\u3002\u7A7A = \u4E0D\u9650\u5236\u3002"),
+    inputElement("allowedUsers", "\u5141\u8BB8\u7684\u7528\u6237", csv(opts.allowedUsers), "ou_xxx, ou_yyy"),
+    inputElement(
+      "allowedChats",
+      "\u5141\u8BB8\u7684\u7FA4",
+      csv(opts.allowedChats),
+      "oc_xxx, oc_yyy\uFF08DM \u6C38\u8FDC\u8C41\u514D\uFF09"
+    ),
+    inputElement("admins", "\u7BA1\u7406\u5458", csv(opts.admins), "ou_xxx"),
+    hr(),
+    md("**\u2699\uFE0F \u504F\u597D**"),
+    radioElement("requireMentionInGroup", "\u7FA4\u91CC\u8981 @bot", opts.requireMentionInGroup ? "yes" : "no"),
+    inputElement(
+      "idleTimeoutMinutes",
+      "Idle watchdog\uFF08\u5206\u949F\uFF09",
+      String(opts.idleTimeoutMinutes),
+      "0 = \u5173\u95ED"
+    ),
+    hr(),
+    columnSet({
+      flexMode: "flow",
+      horizontalSpacing: "small",
+      columns: [
+        column({
+          width: "auto",
+          elements: [
+            {
+              tag: "button",
+              text: { tag: "plain_text", content: "\u{1F4BE} \u4FDD\u5B58" },
+              type: "primary_filled",
+              size: "small",
+              behaviors: [
+                {
+                  type: "callback",
+                  value: { action: "config.submit" }
+                }
+              ],
+              form_action_type: "submit"
+            }
+          ]
+        }),
+        column({
+          width: "auto",
+          elements: [
+            btn({
+              text: "\u53D6\u6D88",
+              type: "default",
+              size: "small",
+              value: { action: "config.show" }
+            })
+          ]
+        }),
+        column({
+          width: "auto",
+          elements: [
+            md('<font color="grey">\u{1F4A1} \u627E open_id\uFF1A\u53D1\u6761\u6D88\u606F\u540E\u67E5 `~/.lark-kiro-bridge/logs/`</font>')
+          ]
+        })
+      ]
+    })
+  ];
+  return {
+    schema: "2.0",
+    header: buildHeader({ title: "\u270F\uFE0F \u7F16\u8F91\u914D\u7F6E", template: "blue" }),
+    body: {
+      elements: [
+        {
+          tag: "form",
+          name: "config_form",
+          elements
+        }
+      ]
+    }
+  };
+}
+function shortenPath2(p, maxLen) {
+  if (p.length <= maxLen) return p;
+  const segs = p.split("/").filter(Boolean);
+  if (segs.length <= 2) return "\u2026" + p.slice(-(maxLen - 1));
+  return "\u2026/" + segs.slice(-2).join("/");
+}
+
+// src/core/pipeline.ts
+var ChatPipeline = class {
+  constructor(chatId, logger) {
+    this.chatId = chatId;
+    this.log = logger.child({ module: "pipeline", chatId });
+  }
+  chatId;
+  log;
+  currentAbort = null;
+  currentTaskId = null;
+  currentPromise = null;
+  /**
+   * 提交新任务。
+   * 如果当前有任务在跑：
+   *   - 先发 abort 信号
+   *   - 等旧任务收尾（旧 run() 应该 catch AbortError 并 finalize 卡片）
+   *   - 再启动新任务
+   */
+  async submit(task) {
+    if (this.currentAbort) {
+      this.log.info({ oldTask: this.currentTaskId, newTask: task.id }, "preempting current task");
+      this.currentAbort.abort();
+      try {
+        await this.currentPromise;
+      } catch {
+      }
+    }
+    const ctrl = new AbortController();
+    this.currentAbort = ctrl;
+    this.currentTaskId = task.id;
+    const p = (async () => {
+      try {
+        await task.run(ctrl.signal);
+      } catch (e) {
+        this.log.error({ err: e, taskId: task.id }, "task threw");
+      } finally {
+        if (this.currentAbort === ctrl) {
+          this.currentAbort = null;
+          this.currentTaskId = null;
+          this.currentPromise = null;
+        }
+      }
+    })();
+    this.currentPromise = p;
+    await p;
+  }
+  /** 主动中止当前任务（/stop 命令）。返回是否真的中止了某任务。 */
+  abortCurrent() {
+    if (this.currentAbort) {
+      this.log.info({ taskId: this.currentTaskId }, "aborting current task");
+      this.currentAbort.abort();
+      return true;
+    }
+    return false;
+  }
+  hasActiveTask() {
+    return this.currentAbort !== null;
+  }
+};
+
+// src/lib/security.ts
+import { resolve, normalize } from "path";
+import { existsSync as existsSync5, statSync as statSync4 } from "fs";
+import { homedir as homedir3 } from "os";
+var SecurityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SecurityError";
+  }
+};
+function resolvePath(p, baseCwd) {
+  let s = p.trim();
+  if (s.startsWith("~/") || s === "~") {
+    s = s.replace(/^~/, homedir3());
+  }
+  return normalize(resolve(baseCwd, s));
+}
+function isPathAllowed(absPath, allowedRoots) {
+  const target = normalize(absPath);
+  for (const root of allowedRoots) {
+    const r = normalize(resolve(root));
+    const rWithSep = r.endsWith("/") ? r : `${r}/`;
+    if (target === r || target.startsWith(rWithSep)) return true;
+  }
+  return false;
+}
+function validateCwd(targetPath, config, baseCwd) {
+  const abs = resolvePath(targetPath, baseCwd);
+  if (!isPathAllowed(abs, config.workspace.allowedRoots)) {
+    throw new SecurityError(
+      `\u8DEF\u5F84 \`${abs}\` \u4E0D\u5728\u767D\u540D\u5355\u5185\u3002
+\u767D\u540D\u5355\uFF1A
+${config.workspace.allowedRoots.map((r) => `  \u2022 \`${r}\``).join("\n")}`
+    );
+  }
+  if (!existsSync5(abs)) {
+    throw new SecurityError(`\u8DEF\u5F84\u4E0D\u5B58\u5728\uFF1A\`${abs}\``);
+  }
+  const stat = statSync4(abs);
+  if (!stat.isDirectory()) {
+    throw new SecurityError(`\u4E0D\u662F\u76EE\u5F55\uFF1A\`${abs}\``);
+  }
+  return abs;
+}
+function isUserAllowed(senderOpenId, chatId, chatType, config) {
+  const { allowedUsers, allowedChats } = config.access;
+  const userOk = allowedUsers.length === 0 || allowedUsers.includes(senderOpenId);
+  const chatOk = chatType === "p2p" || allowedChats.length === 0 || allowedChats.includes(chatId);
+  return userOk && chatOk;
+}
+function isAdmin(senderOpenId, config) {
+  const { admins } = config.access;
+  return admins.length === 0 || admins.includes(senderOpenId);
+}
+function validateAccessChange(opts) {
+  const errors = [];
+  const { submitterOpenId, next } = opts;
+  if (next.admins.length > 0 && !next.admins.includes(submitterOpenId)) {
+    errors.push(
+      `\u274C \u4F60\u7684 open_id\uFF08\`${submitterOpenId}\`\uFF09\u4E0D\u5728 admins \u5217\u8868\u91CC\uFF0C\u63D0\u4EA4\u540E\u4F60\u5C06\u65E0\u6CD5\u518D\u6539\u914D\u7F6E\u3002\u8BF7\u5148\u628A\u81EA\u5DF1\u52A0\u8FDB\u53BB\u3002`
+    );
+  }
+  if (next.allowedUsers.length > 0 && !next.allowedUsers.includes(submitterOpenId)) {
+    errors.push(
+      `\u274C \u4F60\u7684 open_id\uFF08\`${submitterOpenId}\`\uFF09\u4E0D\u5728 allowedUsers \u5217\u8868\u91CC\uFF0C\u63D0\u4EA4\u540E\u4F60\u7684\u4E0B\u4E00\u6761\u6D88\u606F\u4F1A\u88AB\u9759\u9ED8\u4E22\u5F03\u3002\u8BF7\u5148\u628A\u81EA\u5DF1\u52A0\u8FDB\u53BB\u3002`
+    );
+  }
+  return errors;
+}
+
+// src/core/dispatcher.ts
+var Dispatcher = class {
+  config;
+  lark;
+  sessions;
+  workspaces;
+  log;
+  pipelines = /* @__PURE__ */ new Map();
+  onReconnect;
+  constructor(opts) {
+    this.config = opts.config;
+    this.lark = opts.lark;
+    this.sessions = opts.sessions;
+    this.workspaces = opts.workspaces;
+    this.log = opts.logger.child({ module: "dispatcher" });
+    if (opts.onReconnect) this.onReconnect = opts.onReconnect;
+  }
+  getPipeline(chatId) {
+    let p = this.pipelines.get(chatId);
+    if (!p) {
+      p = new ChatPipeline(chatId, this.log);
+      this.pipelines.set(chatId, p);
+    }
+    return p;
+  }
+  /** eventId 去重缓存：飞书 at-least-once 投递保险 */
+  seenEventIds = /* @__PURE__ */ new Map();
+  EVENT_TTL_MS = 5 * 60 * 1e3;
+  /**
+   * rapid-fire 消息合并：同 chat 短时间连发时把多条消息拼成一次 Kiro 调用。
+   *
+   * 价值：用户在飞书 IM 里习惯连发短消息（"等等"、"还有"、"刚才那个改一下"），
+   * 不合并的话每条都跑一次 Kiro，浪费 token 还会被前面的 abort 打断；合并后
+   * 一次性给 Kiro 完整意图。
+   *
+   * 实现：每条消息进来先放 buffer，200ms 内有新消息就追加；到时一次性 submit。
+   *   - 第一条触发计时器、注册 buffer
+   *   - 后续消息往 buffer 里追加文本（+ 媒体路径）
+   *   - 200ms 静默期到 → flush，用第一条的 msg/eventId 作为 reply 锚点
+   */
+  mergeBuffers = /* @__PURE__ */ new Map();
+  MERGE_WINDOW_MS = 200;
+  isDuplicate(eventId) {
+    if (!eventId) return false;
+    const now = Date.now();
+    for (const [k, t] of this.seenEventIds) {
+      if (now - t > this.EVENT_TTL_MS) this.seenEventIds.delete(k);
+    }
+    if (this.seenEventIds.has(eventId)) return true;
+    this.seenEventIds.set(eventId, now);
+    return false;
+  }
+  /**
+   * 主入口：处理一条飞书消息。
+   */
+  async handle(msg) {
+    if (this.isDuplicate(msg.eventId)) {
+      this.log.info({ eventId: msg.eventId }, "duplicate event, skip");
+      return;
+    }
+    if (!this.lark["botOpenIdCache"]) {
+      const guess = msg.mentions.find((m) => m.name?.toLowerCase().includes("kiro"))?.openId;
+      if (guess) this.lark.setBotOpenId(guess);
+    }
+    if (!isUserAllowed(msg.senderOpenId, msg.chatId, msg.chatType, this.config)) {
+      this.log.debug(
+        { user: msg.senderOpenId, chat: msg.chatId, chatType: msg.chatType },
+        "message dropped by access control"
+      );
+      return;
+    }
+    if (msg.chatType === "group" || msg.chatType === "topic_group") {
+      if (this.config.preferences.requireMentionInGroup) {
+        const botMentioned = msg.mentions.some(
+          (m) => (m.name ?? "").toLowerCase().includes("kiro") || (m.name ?? "").toLowerCase().includes("bot")
+        );
+        if (!botMentioned && msg.mentions.length > 0) {
+          this.log.debug("group message without @bot, ignored");
+          return;
+        }
+        if (msg.mentions.length === 0) {
+          this.log.debug("group message has no mentions at all, ignored (requireMentionInGroup)");
+          return;
+        }
+      }
+    }
+    const supportedMedia = msg.messageType === "image" || msg.messageType === "file" || msg.messageType === "audio";
+    if (msg.messageType !== "text" && msg.messageType !== "post" && !supportedMedia) {
+      await this.sendInteractiveCard(
+        msg,
+        buildAckCard({
+          state: "error",
+          title: "\u26A0\uFE0F \u4E0D\u652F\u6301\u7684\u6D88\u606F\u7C7B\u578B",
+          body: `\u5F53\u524D\u7248\u672C\u4E0D\u652F\u6301 \`${msg.messageType}\` \u7C7B\u578B\uFF0C\u5DF2\u5FFD\u7565\u3002`
+        })
+      );
+      return;
+    }
+    const guessedBotOpenId = msg.mentions.find((m) => (m.name ?? "").toLowerCase().includes("kiro"))?.openId ?? "";
+    const cleanText = stripMentions(msg, guessedBotOpenId).trim();
+    let mediaPaths = [];
+    let asrText = "";
+    if (supportedMedia) {
+      try {
+        mediaPaths = await downloadMessageMedia(this.lark, msg);
+      } catch (e) {
+        this.log.warn({ err: e }, "media download error, will skip");
+      }
+      if (msg.messageType === "audio" && mediaPaths.length > 0) {
+        const audioPath = mediaPaths[0];
+        const r = await transcribeAudio(this.lark, audioPath);
+        if (r.ok) {
+          asrText = r.text;
+          mediaPaths = mediaPaths.filter((p) => p !== audioPath);
+          this.log.info({ textLen: r.text.length }, "audio transcribed");
+        } else {
+          this.log.warn({ reason: r.reason, detail: r.detail }, "audio transcription failed");
+          const hint = (() => {
+            switch (r.reason) {
+              case "ffmpeg-missing":
+                return "\u26A0\uFE0F \u672A\u68C0\u6D4B\u5230 `ffmpeg`\uFF0C\u65E0\u6CD5\u628A\u8BED\u97F3\u8F6C\u6210\u6587\u5B57\u3002\n\u8BF7\u5B89\u88C5\uFF1A`brew install ffmpeg`\uFF08macOS\uFF09\u6216\u5305\u7BA1\u7406\u5668\u5BF9\u5E94\u547D\u4EE4\u3002";
+              case "too-long":
+                return `\u26A0\uFE0F \u8BED\u97F3\u592A\u957F\uFF08${r.detail ?? "> 60s"}\uFF09\uFF0C\u98DE\u4E66 ASR \u4EC5\u652F\u6301 60 \u79D2\u4EE5\u5185\u3002\u8BF7\u5206\u6BB5\u91CD\u53D1\u3002`;
+              case "api-failed":
+                return `\u26A0\uFE0F \u8BED\u97F3\u8BC6\u522B\u5931\u8D25\uFF1A${r.detail ?? "\u8BF7\u7A0D\u540E\u91CD\u8BD5"}`;
+              case "ffmpeg-failed":
+                return "\u26A0\uFE0F \u8BED\u97F3\u8F6C\u7801\u5931\u8D25\uFF0C\u53EF\u80FD\u97F3\u9891\u6587\u4EF6\u635F\u574F\u3002";
+              case "empty":
+                return "\u26A0\uFE0F \u8BED\u97F3\u4E2D\u6CA1\u8BC6\u522B\u5230\u6709\u6548\u5185\u5BB9\u3002";
+              default:
+                return "\u26A0\uFE0F \u8BED\u97F3\u8BC6\u522B\u5931\u8D25\u3002";
+            }
+          })();
+          await this.sendInteractiveCard(
+            msg,
+            buildAckCard({ state: "error", title: "\u{1F399}\uFE0F \u8BED\u97F3\u8F6C\u5199\u5931\u8D25", body: hint })
+          );
+          if (!cleanText) return;
+        }
+      }
+      if (mediaPaths.length === 0 && !cleanText && !asrText) {
+        await this.sendInteractiveCard(
+          msg,
+          buildAckCard({
+            state: "error",
+            title: "\u274C \u8D44\u6E90\u4E0B\u8F7D\u5931\u8D25",
+            body: `\`${msg.messageType}\` \u8D44\u6E90\u4E0B\u8F7D\u5931\u8D25\uFF0C\u8BF7\u91CD\u53D1\u6216\u68C0\u67E5\u673A\u5668\u4EBA\u6743\u9650\u3002`
+          })
+        );
+        return;
+      }
+    }
+    if (!cleanText && !asrText && mediaPaths.length === 0) {
+      this.log.debug("empty text after strip and no media, ignored");
+      return;
+    }
+    const ASR_SYSTEM_HINT = '\uFF08\u4EE5\u4E0A\u7531\u8BED\u97F3\u8F6C\u5199\u5F97\u5230\uFF0C\u53EF\u80FD\u6709\u9519\u522B\u5B57\u3002\u8BF7\u6309\u7528\u6237\u65E5\u5E38\u5BF9\u8BDD\u7684\u53E3\u8BED\u610F\u56FE\u56DE\u7B54\uFF0C\u7B80\u77ED\u81EA\u7136\uFF0C\u4E0D\u8981\u8C08\u8BBA"\u8BED\u97F3"\u6216\u8F6C\u5199\u672C\u8EAB\u3002\uFF09';
+    const effectiveText = asrText ? cleanText ? `[\u8BED\u97F3] ${asrText}
+
+${cleanText}
+
+${ASR_SYSTEM_HINT}` : `[\u8BED\u97F3] ${asrText}
+
+${ASR_SYSTEM_HINT}` : cleanText;
+    const cmd = parseCommand(cleanText);
+    const session = await this.sessions.get(msg.chatId, this.config.workspace.defaultCwd);
+    const needAdmin = (() => {
+      if (!cmd) return false;
+      switch (cmd.kind) {
+        case "cd":
+        case "ws-save":
+        case "ws-use":
+        case "ws-remove":
+        case "reconnect":
+        case "config":
+          return true;
+        default:
+          return false;
+      }
+    })();
+    if (needAdmin && !isAdmin(msg.senderOpenId, this.config)) {
+      await this.sendInteractiveCard(
+        msg,
+        buildAckCard({
+          state: "error",
+          title: "\u{1F6AB} \u6743\u9650\u4E0D\u8DB3",
+          body: "\u6B64\u547D\u4EE4\u4EC5\u7BA1\u7406\u5458\u53EF\u7528\u3002"
+        })
+      );
+      return;
+    }
+    if (cmd) {
+      switch (cmd.kind) {
+        case "help":
+          await this.sendInteractiveCard(msg, buildHelpCard());
+          return;
+        case "pwd": {
+          const wsName = await this.workspaceNameOf(session.currentCwd);
+          const body = wsName ? `\u{1F4C1} \`${session.currentCwd}\`
+\u{1F5C2}\uFE0F \u5DE5\u4F5C\u533A\uFF1A\`${wsName}\`` : `\u{1F4C1} \`${session.currentCwd}\``;
+          await this.sendInteractiveCard(
+            msg,
+            buildAckCard({ state: "done", title: "\u{1F4C1} \u5F53\u524D\u76EE\u5F55", body })
+          );
+          return;
+        }
+        case "status": {
+          const kiroSid = await this.sessions.getKiroSession(msg.chatId, session.currentCwd);
+          const wsName = await this.workspaceNameOf(session.currentCwd);
+          const idleMin = this.effectiveIdleMinutes(session.idleTimeoutMinutes);
+          const cardOpts = {
+            cwd: session.currentCwd,
+            hasActiveTask: this.getPipeline(msg.chatId).hasActiveTask(),
+            idleMinutes: idleMin,
+            isPerChatOverride: session.idleTimeoutMinutes !== void 0
+          };
+          if (wsName !== void 0) cardOpts.workspaceName = wsName;
+          if (kiroSid !== void 0) cardOpts.kiroSessionId = kiroSid;
+          await this.sendInteractiveCard(msg, buildStatusCard(cardOpts));
+          return;
+        }
+        case "new": {
+          await this.sessions.clearKiroSession(msg.chatId, session.currentCwd);
+          await this.sendInteractiveCard(
+            msg,
+            buildAckCard({
+              state: "done",
+              title: "\u{1F504} \u4F1A\u8BDD\u5DF2\u91CD\u7F6E",
+              body: `\u4E0B\u6B21\u63D0\u95EE\u4F1A\u5728 \`${session.currentCwd}\` \u4E0B\u65B0\u5EFA Kiro session\u3002`
+            })
+          );
+          return;
+        }
+        case "stop": {
+          const ok = this.getPipeline(msg.chatId).abortCurrent();
+          await this.sendInteractiveCard(
+            msg,
+            buildAckCard({
+              state: ok ? "aborted" : "done",
+              title: ok ? "\u23F9 \u5DF2\u53D1\u51FA\u4E2D\u6B62\u4FE1\u53F7" : "\u2139\uFE0F \u6CA1\u6709\u8FDB\u884C\u4E2D\u7684\u4EFB\u52A1",
+              body: ok ? "\u5F53\u524D\u4EFB\u52A1\u6B63\u5728\u6536\u5C3E\uFF0C\u6700\u591A 2 \u79D2\u540E\u5207\u5230\u4E2D\u6B62\u6001\u3002" : "\u5F53\u524D chat \u6CA1\u6709\u6B63\u5728\u8DD1\u7684 Kiro \u4EFB\u52A1\u3002"
+            })
+          );
+          return;
+        }
+        case "cd": {
+          try {
+            const abs = validateCwd(cmd.path, this.config, session.currentCwd);
+            await this.sessions.setCwd(msg.chatId, abs, this.config.workspace.defaultCwd);
+            const wsName = await this.workspaceNameOf(abs);
+            await this.sendInteractiveCard(
+              msg,
+              buildAckCard({
+                state: "done",
+                title: "\u{1F4C1} \u76EE\u5F55\u5DF2\u5207\u6362",
+                body: wsName ? `\`${abs}\`
+\u{1F5C2}\uFE0F \u5DE5\u4F5C\u533A\uFF1A\`${wsName}\`` : `\`${abs}\``
+              })
+            );
+          } catch (e) {
+            const m = e instanceof SecurityError ? e.message : String(e.message);
+            await this.sendInteractiveCard(
+              msg,
+              buildAckCard({ state: "error", title: "\u274C \u5207\u6362\u5931\u8D25", body: m })
+            );
+          }
+          return;
+        }
+        case "ws-list": {
+          const all = await this.workspaces.list();
+          await this.sendInteractiveCard(
+            msg,
+            buildWorkspaceListCard({ workspaces: all, currentCwd: session.currentCwd })
+          );
+          return;
+        }
+        case "ws-save": {
+          await this.workspaces.save(cmd.name, session.currentCwd);
+          await this.sendInteractiveCard(
+            msg,
+            buildAckCard({
+              state: "done",
+              title: "\u{1F5C2}\uFE0F \u5DE5\u4F5C\u533A\u5DF2\u4FDD\u5B58",
+              body: `\`${cmd.name}\` \u2192 \`${session.currentCwd}\``
+            })
+          );
+          return;
+        }
+        case "ws-use": {
+          const target = await this.workspaces.get(cmd.name);
+          if (!target) {
+            await this.sendInteractiveCard(
+              msg,
+              buildAckCard({
+                state: "error",
+                title: "\u274C \u5DE5\u4F5C\u533A\u4E0D\u5B58\u5728",
+                body: `\u6CA1\u6709\u540D\u4E3A \`${cmd.name}\` \u7684\u5DE5\u4F5C\u533A\u3002\u7528 \`/ws list\` \u67E5\u770B\u5168\u90E8\u3002`
+              })
+            );
+            return;
+          }
+          try {
+            const abs = validateCwd(target, this.config, session.currentCwd);
+            await this.sessions.setCwd(msg.chatId, abs, this.config.workspace.defaultCwd);
+            await this.sendInteractiveCard(
+              msg,
+              buildAckCard({
+                state: "done",
+                title: "\u{1F5C2}\uFE0F \u5DE5\u4F5C\u533A\u5DF2\u5207\u6362",
+                body: `\`${cmd.name}\` \u2192 \`${abs}\``
+              })
+            );
+          } catch (e) {
+            const m = e instanceof SecurityError ? e.message : String(e.message);
+            await this.sendInteractiveCard(
+              msg,
+              buildAckCard({ state: "error", title: "\u274C \u5207\u6362\u5931\u8D25", body: m })
+            );
+          }
+          return;
+        }
+        case "ws-remove": {
+          const ok = await this.workspaces.remove(cmd.name);
+          await this.sendInteractiveCard(
+            msg,
+            buildAckCard({
+              state: ok ? "done" : "error",
+              title: ok ? "\u{1F5D1}\uFE0F \u5DE5\u4F5C\u533A\u5DF2\u5220\u9664" : "\u274C \u5DE5\u4F5C\u533A\u4E0D\u5B58\u5728",
+              body: ok ? `\u5DF2\u5220\u9664 \`${cmd.name}\`` : `\u6CA1\u6709\u540D\u4E3A \`${cmd.name}\` \u7684\u5DE5\u4F5C\u533A`
+            })
+          );
+          return;
+        }
+        case "timeout": {
+          await this.handleTimeoutCmd(msg, session, cmd);
+          return;
+        }
+        case "reconnect": {
+          await this.sendInteractiveCard(
+            msg,
+            buildAckCard({
+              state: "done",
+              title: "\u{1F504} \u6B63\u5728\u91CD\u8FDE",
+              body: "\u6B63\u5728\u91CD\u65B0\u5EFA\u7ACB\u98DE\u4E66 WebSocket \u8FDE\u63A5\u2026"
+            })
+          );
+          if (this.onReconnect) {
+            try {
+              await this.onReconnect();
+            } catch (e) {
+              this.log.warn({ err: e }, "reconnect failed");
+            }
+          }
+          return;
+        }
+        case "doctor": {
+          await this.handleDoctorCmd(msg, cmd.description, session.currentCwd);
+          return;
+        }
+        case "model": {
+          await this.handleModelCmd(msg, cmd, session.currentCwd);
+          return;
+        }
+        case "config": {
+          await this.handleConfigCmd(msg);
+          return;
+        }
+        case "kiro-internal": {
+          const body = [
+            `\u2753 \`/${cmd.name}\` \u662F kiro-cli \u7684**\u4EA4\u4E92\u5F0F TUI** \u547D\u4EE4\uFF0C\u6865\u63A5\u5668\u8DD1\u7684\u662F\u975E\u4EA4\u4E92\u6A21\u5F0F\uFF08\`--no-interactive\`\uFF09\uFF0C\u65E0\u6CD5\u6267\u884C\u3002`,
+            "",
+            "**\u600E\u4E48\u529E**",
+            cmd.name === "model" || cmd.name === "agent" ? `\u8981\u5207\u6362 ${cmd.name === "model" ? "\u6A21\u578B" : "agent"}\uFF0C\u8BF7\u7F16\u8F91 \`~/.lark-kiro-bridge/config.json\` \u91CC\u7684 \`kiro.${cmd.name}\` \u5B57\u6BB5\uFF0C\u7136\u540E \`/reconnect\` \u751F\u6548\u3002` : `\u8FD9\u6761\u547D\u4EE4\u53EA\u5728\u7EC8\u7AEF\u8DD1 \`kiro-cli\` \u65F6\u53EF\u7528\uFF0C\u6865\u63A5\u5668\u65E0\u6CD5\u4EE3\u7406\u3002`,
+            "",
+            "**\u6865\u63A5\u5668\u81EA\u8EAB\u7684\u547D\u4EE4** \u7528 `/help` \u67E5\u770B\u3002"
+          ].join("\n");
+          await this.replyErrorCard(msg, body, session.currentCwd);
+          return;
+        }
+        case "unknown":
+          break;
+      }
+    }
+    await this.runKiroTask(
+      msg,
+      effectiveText,
+      session.currentCwd,
+      mediaPaths,
+      session.idleTimeoutMinutes
+    );
+  }
+  async workspaceNameOf(cwd) {
+    const all = await this.workspaces.list();
+    for (const [name, p] of Object.entries(all)) {
+      if (p === cwd) return name;
+    }
+    return void 0;
+  }
+  /**
+   * 计算某个 chat 实际生效的 idle watchdog 分钟数。
+   *   - per-chat override 存在（包括 0）→ 优先用它
+   *   - 否则用 config.kiro.idleTimeoutMinutes
+   */
+  effectiveIdleMinutes(perChatOverride) {
+    if (perChatOverride !== void 0) return perChatOverride;
+    return this.config.kiro.idleTimeoutMinutes;
+  }
+  async handleTimeoutCmd(msg, session, cmd) {
+    if (cmd.mode === "show") {
+      const eff2 = this.effectiveIdleMinutes(session.idleTimeoutMinutes);
+      const body = [
+        `\u5F53\u524D\u9608\u503C\uFF1A**${eff2 > 0 ? `${eff2} \u5206\u949F` : "\u5173\u95ED"}**${session.idleTimeoutMinutes !== void 0 ? "\uFF08per-chat \u8986\u76D6\uFF09" : "\uFF08\u5168\u5C40\u9ED8\u8BA4\uFF09"}`,
+        "",
+        "<font color='grey'>\u7528\u6CD5</font>",
+        "`/timeout 10` \u2014 \u6539\u6210 10 \u5206\u949F",
+        "`/timeout off` \u2014 \u5173\u95ED",
+        "`/timeout default` \u2014 \u56DE\u5F52\u5168\u5C40\u9ED8\u8BA4"
+      ].join("\n");
+      await this.sendInteractiveCard(
+        msg,
+        buildAckCard({ state: "done", title: "\u23F1 Idle Watchdog", body })
+      );
+      return;
+    }
+    if (cmd.mode === "set") {
+      await this.sessions.setIdleTimeout(msg.chatId, cmd.minutes, this.config.workspace.defaultCwd);
+      await this.sendInteractiveCard(
+        msg,
+        buildAckCard({
+          state: "done",
+          title: "\u23F1 \u5DF2\u8BBE\u7F6E",
+          body: `idle watchdog \u2192 \`${cmd.minutes}\` \u5206\u949F`
+        })
+      );
+      return;
+    }
+    if (cmd.mode === "off") {
+      await this.sessions.setIdleTimeout(msg.chatId, 0, this.config.workspace.defaultCwd);
+      await this.sendInteractiveCard(
+        msg,
+        buildAckCard({
+          state: "done",
+          title: "\u23F1 \u5DF2\u5173\u95ED",
+          body: "\u5F53\u524D chat \u4E0D\u4F1A\u56E0\u4E3A\u957F\u65F6\u95F4\u65E0\u8F93\u51FA\u800C\u88AB\u81EA\u52A8\u7EC8\u6B62\u3002"
+        })
+      );
+      return;
+    }
+    await this.sessions.setIdleTimeout(msg.chatId, void 0, this.config.workspace.defaultCwd);
+    const eff = this.effectiveIdleMinutes(void 0);
+    await this.sendInteractiveCard(
+      msg,
+      buildAckCard({
+        state: "done",
+        title: "\u23F1 \u5DF2\u6062\u590D\u9ED8\u8BA4",
+        body: `\u56DE\u5F52\u5168\u5C40\u9ED8\u8BA4\uFF1A${eff > 0 ? `${eff} \u5206\u949F` : "\u5173\u95ED"}`
+      })
+    );
+  }
+  /**
+   * /doctor [描述]
+   * 把最近 200 行结构化日志 + 用户描述拼成 prompt 喂给 Kiro 自诊断。
+   * 走标准 runKiroTask 流程，享受所有流式卡片和 watchdog。
+   */
+  async handleDoctorCmd(msg, description, cwd) {
+    const lines = readRecentLogLines(200);
+    const userDesc = description.trim() || "\uFF08\u65E0\uFF09";
+    const prompt = [
+      "\u4F60\u662F lark-kiro-bridge \u7684\u8FD0\u7EF4\u52A9\u624B\u3002\u4E0B\u9762\u662F\u8FD9\u4E2A\u6865\u63A5\u5668\u6700\u8FD1\u7684\u7ED3\u6784\u5316\u65E5\u5FD7\uFF08NDJSON\uFF09\uFF0C",
+      "\u4EE5\u53CA\u7528\u6237\u63CF\u8FF0\u7684\u95EE\u9898\u3002\u8BF7\u57FA\u4E8E\u65E5\u5FD7\u627E\u51FA\u53EF\u80FD\u7684\u6545\u969C\u70B9\uFF0C\u7ED9\u51FA\u8BCA\u65AD\u7ED3\u8BBA\u548C\u4FEE\u590D\u5EFA\u8BAE\u3002",
+      "\u53EA\u770B\u65E5\u5FD7\uFF0C\u4E0D\u8981\u5047\u8BBE\u5176\u4ED6\u72B6\u6001\u3002",
+      "",
+      "**\u7528\u6237\u63CF\u8FF0**",
+      userDesc,
+      "",
+      "**\u6700\u8FD1\u65E5\u5FD7\uFF08\u6700\u591A 200 \u884C\uFF0C\u5DF2\u622A\u77ED\u957F\u884C\uFF09**",
+      "```",
+      lines.length > 0 ? lines.join("\n") : "\uFF08\u65E0\u65E5\u5FD7\uFF09",
+      "```"
+    ].join("\n");
+    const session = await this.sessions.get(msg.chatId, this.config.workspace.defaultCwd);
+    await this.runKiroTask(msg, prompt, cwd, [], session.idleTimeoutMinutes);
+  }
+  /**
+   * /model         → 列出所有模型 + 当前选中（漂亮按钮卡片）
+   * /model <name>  → 切换模型，写入 config.json，立即生效
+   * /model auto    → 清除模型覆盖，回归 kiro-cli 默认（auto）
+   *
+   * 短名容错：/model sonnet-4.6 → 自动补 claude- 前缀
+   *
+   * 设计取舍：
+   *   - 切模型只改全局 config.json，不做 per-chat 覆盖（先做最少必要）
+   *   - 切完不需要 reconnect，下一条消息直接生效（spawn kiro-cli 时读最新 config）
+   */
+  async handleModelCmd(msg, cmd, _cwd) {
+    if (cmd.mode === "show") {
+      await this.sendInteractiveCardAsync(
+        msg,
+        buildLoadingCard("\u67E5\u8BE2\u53EF\u7528\u6A21\u578B\u2026", "\u{1F39B}\uFE0F \u52A0\u8F7D\u6A21\u578B\u5217\u8868"),
+        async () => {
+          const list = await listModels(this.config.kiro.binPath);
+          if (!list) {
+            return buildAckCard({
+              state: "error",
+              body: "\u65E0\u6CD5\u83B7\u53D6\u6A21\u578B\u5217\u8868\uFF0C\u53EF\u80FD\u662F kiro-cli \u6CA1\u767B\u5F55\u6216\u4E0D\u5728 PATH\u3002\n\u7528 `/doctor` \u8BA9 Kiro \u81EA\u5DF1\u770B\u65E5\u5FD7\u3002"
+            });
+          }
+          const current = this.config.kiro.model ?? list.defaultModel ?? "auto";
+          return buildModelPickerCard({ current, list });
+        }
+      );
+      return;
+    }
+    if (cmd.mode === "reset") {
+      this.config = patchAndSaveConfig(this.config, (draft) => {
+        delete draft.kiro.model;
+      });
+      clearModelCache();
+      const list = await listModels(this.config.kiro.binPath);
+      const fallback = list?.defaultModel ?? "auto";
+      await this.sendInteractiveCard(
+        msg,
+        buildAckCard({
+          state: "done",
+          title: "\u2705 \u6A21\u578B\u5DF2\u6062\u590D\u9ED8\u8BA4",
+          body: `\u5DF2\u6E05\u9664\u6A21\u578B\u8986\u76D6\uFF0C\u56DE\u5F52 kiro-cli \u9ED8\u8BA4\uFF08\`${fallback}\`\uFF09`
+        })
+      );
+      return;
+    }
+    await this.sendInteractiveCardAsync(
+      msg,
+      buildLoadingCard(`\u5207\u6362\u5230 \`${cmd.name}\` \u2026`, "\u{1F39B}\uFE0F \u5207\u6362\u6A21\u578B"),
+      async () => {
+        const list = await listModels(this.config.kiro.binPath);
+        const target = this.resolveModelName(cmd.name, list);
+        if (list && target === void 0) {
+          const valid = list.models.map((m) => `\`${m.name}\``).join("\u3001");
+          return buildAckCard({
+            state: "error",
+            title: "\u274C \u6A21\u578B\u4E0D\u5B58\u5728",
+            body: `\u6CA1\u6709\u540D\u4E3A \`${cmd.name}\` \u7684\u6A21\u578B\u3002
+
+\u53EF\u7528\uFF1A${valid}
+
+\u7528 \`/model\` \u67E5\u770B\u5B8C\u6574\u5217\u8868\u3002`
+          });
+        }
+        const finalName = target ?? cmd.name;
+        this.config = patchAndSaveConfig(this.config, (draft) => {
+          draft.kiro.model = finalName;
+        });
+        return buildAckCard({
+          state: "done",
+          title: "\u2705 \u6A21\u578B\u5DF2\u5207\u6362",
+          body: `\u5DF2\u5207\u6362\u5230 \`${finalName}\`\uFF08\u4E0B\u4E00\u6761\u6D88\u606F\u751F\u6548\uFF09`
+        });
+      }
+    );
+  }
+  /**
+   * 模型名解析：
+   *   - 列表里精确匹配 → 直接返回
+   *   - 列表里有 "claude-<name>" → 返回带前缀的全名（短名容错）
+   *   - 都不匹配 → 返回 undefined（让上层报错）
+   * 列表为空（fetch 失败）时直接返回原名，不阻塞。
+   */
+  resolveModelName(name, list) {
+    if (!list) return name;
+    if (list.models.some((m) => m.name === name)) return name;
+    const prefixed = `claude-${name}`;
+    if (list.models.some((m) => m.name === prefixed)) return prefixed;
+    return void 0;
+  }
+  /**
+   * 发送一张飞书 v2 交互卡片（带按钮的那种）作为对原消息的回复。
+   * 跟 replyDoneCard 不同：不走 CardRenderer 的状态机，发一次就完事，
+   * 不会再 patch；按钮回调走 onCardAction 流程。
+   */
+  async sendInteractiveCard(msg, card) {
+    try {
+      await this.lark.replyCard(msg.messageId, card);
+    } catch (e) {
+      this.log.error({ err: e }, "sendInteractiveCard failed; falling back to text");
+      try {
+        await this.lark.sendText(msg.chatId, "\u274C \u5361\u7247\u53D1\u9001\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u65E5\u5FD7");
+      } catch {
+      }
+    }
+  }
+  /**
+   * 命令型卡片的"先占位再 patch"模式。
+   *
+   * 用于命令本身需要做异步工作（spawn kiro-cli 等）才能算出最终卡片内容的场景：
+   *   1. 先用 placeholderCard 立刻 reply 出去，让用户看到反馈
+   *   2. 异步跑 buildFinalCard()
+   *   3. 用 patchCard 替换成最终卡片
+   *
+   * 失败时直接发 fallback 错误卡片，不让用户卡在 placeholder。
+   */
+  async sendInteractiveCardAsync(msg, placeholderCard, buildFinalCard) {
+    let placeholderMessageId;
+    try {
+      placeholderMessageId = await this.lark.replyCard(msg.messageId, placeholderCard);
+    } catch (e) {
+      this.log.error({ err: e }, "placeholder card send failed");
+    }
+    let finalCard;
+    try {
+      finalCard = await buildFinalCard();
+    } catch (e) {
+      this.log.error({ err: e }, "buildFinalCard threw");
+      finalCard = buildAckCard({
+        state: "error",
+        body: `\u274C \u547D\u4EE4\u6267\u884C\u5931\u8D25\uFF1A${e.message}`
+      });
+    }
+    if (placeholderMessageId) {
+      try {
+        await this.lark.patchCard(placeholderMessageId, finalCard);
+      } catch (e) {
+        this.log.error({ err: e }, "patch final card failed; sending fresh");
+        await this.sendInteractiveCard(msg, finalCard);
+      }
+    } else {
+      await this.sendInteractiveCard(msg, finalCard);
+    }
+  }
+  /**
+   * 直接发卡片到 chatId（不 reply 任何特定消息）。
+   * cardAction handler 用这个——按钮触发时不 reply 那条卡片本身（嵌套体验差），
+   * 而是发新消息。
+   */
+  async sendCardToChat(chatId, card) {
+    try {
+      await this.lark.sendCard(chatId, card);
+    } catch (e) {
+      this.log.error({ err: e }, "sendCardToChat failed; falling back to text");
+      try {
+        await this.lark.sendText(chatId, "\u274C \u5361\u7247\u53D1\u9001\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u65E5\u5FD7");
+      } catch {
+      }
+    }
+  }
+  /**
+   * 处理用户点了卡片按钮的事件。
+   * value 约定字段：{ action: 'xxx.yyy', ...payload }
+   *
+   * 安全：button 触发的命令也会经过 admin 校验（调用 needAdminForAction）。
+   */
+  async handleCardAction(evt) {
+    const chatTypeGuess = "group";
+    if (!isUserAllowed(evt.senderOpenId, evt.chatId, chatTypeGuess, this.config)) {
+      this.log.debug({ user: evt.senderOpenId }, "card action dropped by access control");
+      return;
+    }
+    const action = String(evt.value["action"] ?? "");
+    if (!action) {
+      this.log.debug({ value: evt.value }, 'card action without "action" field, ignored');
+      return;
+    }
+    if (this.actionNeedsAdmin(action) && !isAdmin(evt.senderOpenId, this.config)) {
+      await this.sendCardToChat(
+        evt.chatId,
+        buildAckCard({ state: "error", body: "\u6B64\u64CD\u4F5C\u4EC5\u7BA1\u7406\u5458\u53EF\u7528" })
+      );
+      return;
+    }
+    const session = await this.sessions.get(evt.chatId, this.config.workspace.defaultCwd);
+    switch (action) {
+      case "model.show": {
+        const list = await listModels(this.config.kiro.binPath);
+        const current = this.config.kiro.model ?? list?.defaultModel ?? "auto";
+        if (!list) {
+          await this.sendCardToChat(
+            evt.chatId,
+            buildAckCard({ state: "error", body: "\u65E0\u6CD5\u83B7\u53D6\u6A21\u578B\u5217\u8868" })
+          );
+          return;
+        }
+        await this.sendCardToChat(evt.chatId, buildModelPickerCard({ current, list }));
+        return;
+      }
+      case "model.refresh": {
+        clearModelCache();
+        const list = await listModels(this.config.kiro.binPath);
+        const current = this.config.kiro.model ?? list?.defaultModel ?? "auto";
+        if (!list) {
+          await this.sendCardToChat(evt.chatId, buildAckCard({ state: "error", body: "\u5237\u65B0\u5931\u8D25" }));
+          return;
+        }
+        await this.sendCardToChat(evt.chatId, buildModelPickerCard({ current, list }));
+        return;
+      }
+      case "model.set": {
+        const name = String(evt.value["name"] ?? "").trim();
+        if (!name) return;
+        const list = await listModels(this.config.kiro.binPath);
+        const target = this.resolveModelName(name, list);
+        if (list && target === void 0) {
+          await this.sendCardToChat(
+            evt.chatId,
+            buildAckCard({ state: "error", body: `\u6CA1\u6709\u540D\u4E3A \`${name}\` \u7684\u6A21\u578B` })
+          );
+          return;
+        }
+        const finalName = target ?? name;
+        this.config = patchAndSaveConfig(this.config, (draft) => {
+          draft.kiro.model = finalName;
+        });
+        await this.sendCardToChat(
+          evt.chatId,
+          buildAckCard({
+            state: "done",
+            body: `\u5DF2\u5207\u6362\u6A21\u578B\uFF1A\`${finalName}\`\uFF08\u4E0B\u4E00\u6761\u6D88\u606F\u751F\u6548\uFF09`
+          })
+        );
+        return;
+      }
+      case "model.reset": {
+        this.config = patchAndSaveConfig(this.config, (draft) => {
+          delete draft.kiro.model;
+        });
+        clearModelCache();
+        const list = await listModels(this.config.kiro.binPath);
+        const fallback = list?.defaultModel ?? "auto";
+        await this.sendCardToChat(
+          evt.chatId,
+          buildAckCard({
+            state: "done",
+            body: `\u5DF2\u6E05\u9664\u6A21\u578B\u8986\u76D6\uFF0C\u56DE\u5F52 \`${fallback}\``
+          })
+        );
+        return;
+      }
+      case "session.new": {
+        await this.sessions.clearKiroSession(evt.chatId, session.currentCwd);
+        await this.sendCardToChat(
+          evt.chatId,
+          buildAckCard({
+            state: "done",
+            body: `\u5DF2\u91CD\u7F6E \`${session.currentCwd}\` \u4E0B\u7684\u4F1A\u8BDD`
+          })
+        );
+        return;
+      }
+      case "session.stop": {
+        const ok = this.getPipeline(evt.chatId).abortCurrent();
+        await this.sendCardToChat(
+          evt.chatId,
+          buildAckCard({
+            state: ok ? "aborted" : "done",
+            body: ok ? "\u5DF2\u53D1\u51FA\u4E2D\u6B62\u4FE1\u53F7" : "\u5F53\u524D\u6CA1\u6709\u8FDB\u884C\u4E2D\u7684\u4EFB\u52A1"
+          })
+        );
+        return;
+      }
+      case "session.status": {
+        const kiroSid = await this.sessions.getKiroSession(evt.chatId, session.currentCwd);
+        const wsName = await this.workspaceNameOf(session.currentCwd);
+        const idleMin = this.effectiveIdleMinutes(session.idleTimeoutMinutes);
+        const cardOpts = {
+          cwd: session.currentCwd,
+          hasActiveTask: this.getPipeline(evt.chatId).hasActiveTask(),
+          idleMinutes: idleMin,
+          isPerChatOverride: session.idleTimeoutMinutes !== void 0
+        };
+        if (wsName !== void 0) cardOpts.workspaceName = wsName;
+        if (kiroSid !== void 0) cardOpts.kiroSessionId = kiroSid;
+        await this.sendCardToChat(evt.chatId, buildStatusCard(cardOpts));
+        return;
+      }
+      case "ws.list": {
+        const all = await this.workspaces.list();
+        await this.sendCardToChat(
+          evt.chatId,
+          buildWorkspaceListCard({
+            workspaces: all,
+            currentCwd: session.currentCwd
+          })
+        );
+        return;
+      }
+      case "ws.use": {
+        const name = String(evt.value["name"] ?? "").trim();
+        if (!name) return;
+        const target = await this.workspaces.get(name);
+        if (!target) {
+          await this.sendCardToChat(
+            evt.chatId,
+            buildAckCard({ state: "error", body: `\u6CA1\u6709\u540D\u4E3A \`${name}\` \u7684\u5DE5\u4F5C\u533A` })
+          );
+          return;
+        }
+        try {
+          const abs = validateCwd(target, this.config, session.currentCwd);
+          await this.sessions.setCwd(evt.chatId, abs, this.config.workspace.defaultCwd);
+          await this.sendCardToChat(
+            evt.chatId,
+            buildAckCard({
+              state: "done",
+              body: `\u5DF2\u5207\u6362\u5230\u5DE5\u4F5C\u533A \`${name}\` \u2192 \`${abs}\``
+            })
+          );
+        } catch (e) {
+          const m = e instanceof SecurityError ? e.message : String(e.message);
+          await this.sendCardToChat(evt.chatId, buildAckCard({ state: "error", body: m }));
+        }
+        return;
+      }
+      case "config.show":
+      case "config.edit": {
+        const isEditMode = action === "config.edit";
+        const card = isEditMode ? buildConfigFormCard({
+          allowedUsers: this.config.access.allowedUsers,
+          allowedChats: this.config.access.allowedChats,
+          admins: this.config.access.admins,
+          requireMentionInGroup: this.config.preferences.requireMentionInGroup,
+          idleTimeoutMinutes: this.config.kiro.idleTimeoutMinutes
+        }) : buildConfigViewCard({
+          allowedUsers: this.config.access.allowedUsers,
+          allowedChats: this.config.access.allowedChats,
+          admins: this.config.access.admins,
+          requireMentionInGroup: this.config.preferences.requireMentionInGroup,
+          idleTimeoutMinutes: this.config.kiro.idleTimeoutMinutes,
+          cardUpdateIntervalMs: this.config.preferences.cardUpdateIntervalMs,
+          isAdmin: isAdmin(evt.senderOpenId, this.config)
+        });
+        await this.sendCardToChat(evt.chatId, card);
+        return;
+      }
+      case "config.submit": {
+        await this.handleConfigSubmit(evt);
+        return;
+      }
+      default:
+        this.log.debug({ action }, "unknown card action, ignored");
+    }
+  }
+  /** 哪些 action 是写操作，需要 admin */
+  actionNeedsAdmin(action) {
+    return action === "model.set" || action === "model.reset" || action === "ws.use" || action === "session.new" || action === "config.edit" || action === "config.submit";
+  }
+  /**
+   * /config 命令：展示当前配置（只读卡片，admin 可见编辑按钮）
+   */
+  async handleConfigCmd(msg) {
+    const card = buildConfigViewCard({
+      allowedUsers: this.config.access.allowedUsers,
+      allowedChats: this.config.access.allowedChats,
+      admins: this.config.access.admins,
+      requireMentionInGroup: this.config.preferences.requireMentionInGroup,
+      idleTimeoutMinutes: this.config.kiro.idleTimeoutMinutes,
+      cardUpdateIntervalMs: this.config.preferences.cardUpdateIntervalMs,
+      isAdmin: isAdmin(msg.senderOpenId, this.config)
+    });
+    await this.sendInteractiveCard(msg, card);
+  }
+  /**
+   * 处理 config 表单提交。
+   *
+   * 流程：
+   *   1. 解析 form_value（用户输入的逗号分隔列表 / 整数 / yes/no）
+   *   2. 用 validateAccessChange 校验，防止把自己锁出去
+   *   3. patchAndSaveConfig 落盘 + 立即生效
+   *   4. 回一张确认卡片（同时显示新的 config view）
+   */
+  async handleConfigSubmit(evt) {
+    const fv = evt.formValue ?? {};
+    const parseCsv = (raw) => String(raw ?? "").split(/[,，\s]+/).map((s) => s.trim()).filter((s) => s.length > 0);
+    const allowedUsers = parseCsv(fv["allowedUsers"]);
+    const allowedChats = parseCsv(fv["allowedChats"]);
+    const admins = parseCsv(fv["admins"]);
+    const requireMentionInGroup = String(fv["requireMentionInGroup"] ?? "yes") === "yes";
+    const idleRaw = String(fv["idleTimeoutMinutes"] ?? "5").trim();
+    const idleMin = Number(idleRaw);
+    if (!Number.isFinite(idleMin) || idleMin < 0 || idleMin > 600) {
+      await this.sendCardToChat(
+        evt.chatId,
+        buildAckCard({
+          state: "error",
+          body: `\u274C Idle watchdog \u5FC5\u987B\u662F 0~600 \u4E4B\u95F4\u7684\u6574\u6570\uFF0C\u6536\u5230 \`${idleRaw}\``
+        })
+      );
+      return;
+    }
+    const accessErrors = validateAccessChange({
+      submitterOpenId: evt.senderOpenId,
+      next: { allowedUsers, allowedChats, admins }
+    });
+    if (accessErrors.length > 0) {
+      await this.sendCardToChat(
+        evt.chatId,
+        buildAckCard({
+          state: "error",
+          title: "\u26A0\uFE0F \u914D\u7F6E\u4E0D\u5B89\u5168",
+          body: accessErrors.join("\n\n")
+        })
+      );
+      return;
+    }
+    this.config = patchAndSaveConfig(this.config, (draft) => {
+      draft.access.allowedUsers = allowedUsers;
+      draft.access.allowedChats = allowedChats;
+      draft.access.admins = admins;
+      draft.preferences.requireMentionInGroup = requireMentionInGroup;
+      draft.kiro.idleTimeoutMinutes = Math.floor(idleMin);
+    });
+    this.log.info(
+      {
+        allowedUsersN: allowedUsers.length,
+        allowedChatsN: allowedChats.length,
+        adminsN: admins.length,
+        requireMentionInGroup,
+        idleMin: Math.floor(idleMin),
+        by: evt.senderOpenId
+      },
+      "config updated via card form"
+    );
+    await this.sendCardToChat(
+      evt.chatId,
+      buildAckCard({
+        state: "done",
+        title: "\u2705 \u914D\u7F6E\u5DF2\u4FDD\u5B58",
+        body: "\u6539\u52A8\u7ACB\u5373\u751F\u6548\uFF0C\u65E0\u9700\u91CD\u542F\u3002"
+      })
+    );
+    await this.sendCardToChat(
+      evt.chatId,
+      buildConfigViewCard({
+        allowedUsers: this.config.access.allowedUsers,
+        allowedChats: this.config.access.allowedChats,
+        admins: this.config.access.admins,
+        requireMentionInGroup: this.config.preferences.requireMentionInGroup,
+        idleTimeoutMinutes: this.config.kiro.idleTimeoutMinutes,
+        cardUpdateIntervalMs: this.config.preferences.cardUpdateIntervalMs,
+        isAdmin: isAdmin(evt.senderOpenId, this.config)
+      })
+    );
+  }
+  async replyErrorCard(msg, body, cwd) {
+    const renderer = new CardRenderer({
+      lark: this.lark,
+      chatId: msg.chatId,
+      replyToMessageId: msg.messageId,
+      intervalMs: this.config.preferences.cardUpdateIntervalMs,
+      logger: this.log,
+      ctx: { cwd }
+    });
+    await renderer.open("error", body);
+    await renderer.finalize("error", body);
+  }
+  /**
+   * 把一条用户消息丢给 Kiro 处理。
+   *
+   * **包了一层 rapid-fire 合并**：先放 buffer，等 200ms 静默期再真正 submit；
+   * 期间若同 chat 又来新消息，就追加到同一个 buffer，不会触发 abort+rerun。
+   *
+   * 真正的 Kiro 调用在 executeKiroTask 里。
+   */
+  async runKiroTask(msg, prompt, cwd, mediaPaths = [], perChatIdleMin) {
+    const skipMerge = prompt.length > 500 || prompt.includes("**\u6700\u8FD1\u65E5\u5FD7");
+    if (skipMerge) {
+      await this.executeKiroTask(msg, prompt, cwd, mediaPaths, perChatIdleMin);
+      return;
+    }
+    const existing = this.mergeBuffers.get(msg.chatId);
+    if (existing) {
+      if (prompt) existing.texts.push(prompt);
+      existing.mediaPaths.push(...mediaPaths);
+      clearTimeout(existing.timer);
+      existing.timer = setTimeout(() => {
+        this.flushMergeBuffer(msg.chatId);
+      }, this.MERGE_WINDOW_MS);
+      this.log.debug(
+        { chatId: msg.chatId, accumulated: existing.texts.length },
+        "merging rapid-fire message"
+      );
+      return;
+    }
+    const timer = setTimeout(() => {
+      this.flushMergeBuffer(msg.chatId);
+    }, this.MERGE_WINDOW_MS);
+    this.mergeBuffers.set(msg.chatId, {
+      anchor: msg,
+      texts: prompt ? [prompt] : [],
+      mediaPaths: [...mediaPaths],
+      cwd,
+      perChatIdleMin,
+      timer
+    });
+  }
+  /**
+   * flush 当前 chat 的合并 buffer：把累计的文本拼一起，调 executeKiroTask。
+   */
+  flushMergeBuffer(chatId) {
+    const buf = this.mergeBuffers.get(chatId);
+    if (!buf) return;
+    this.mergeBuffers.delete(chatId);
+    clearTimeout(buf.timer);
+    const merged = buf.texts.filter((t) => t.length > 0).join("\n\n");
+    if (buf.texts.length > 1) {
+      this.log.info(
+        { chatId, mergedCount: buf.texts.length, totalLen: merged.length },
+        "flushing merged rapid-fire batch"
+      );
+    }
+    void this.executeKiroTask(
+      buf.anchor,
+      merged,
+      buf.cwd,
+      buf.mediaPaths,
+      buf.perChatIdleMin
+    ).catch((e) => this.log.error({ err: e, chatId }, "flush merge buffer execute failed"));
+  }
+  /**
+   * 真正把任务丢到 ChatPipeline 跑 Kiro 的实现（不含 rapid-fire 合并）。
+   * - 在 ChatPipeline 里跑（自动 preempt）
+   * - 用 RunCardController 流式刷新卡片（每个工具独立 panel）
+   * - mediaPaths 非空时，把绝对路径作为前缀加到 prompt 前面
+   * - perChatIdleMin 控制本次 idle watchdog 阈值
+   */
+  async executeKiroTask(msg, prompt, cwd, mediaPaths = [], perChatIdleMin) {
+    const pipeline = this.getPipeline(msg.chatId);
+    const taskId = `${msg.eventId || msg.messageId}-${Date.now().toString(36)}`;
+    const finalPrompt = mediaPaths.length ? mediaPaths.map((p) => `@${p}`).join(" ") + (prompt ? "\n\n" + prompt : "") : prompt;
+    const idleMin = this.effectiveIdleMinutes(perChatIdleMin);
+    const idleTimeoutMs = idleMin > 0 ? idleMin * 60 * 1e3 : 0;
+    await pipeline.submit({
+      id: taskId,
+      run: async (signal) => {
+        const ctrlOpts = {
+          lark: this.lark,
+          chatId: msg.chatId,
+          replyToMessageId: msg.messageId,
+          intervalMs: this.config.preferences.cardUpdateIntervalMs,
+          logger: this.log
+        };
+        if (idleMin > 0) ctrlOpts.idleTimeoutMinutes = idleMin;
+        const ctrl = new RunCardController(ctrlOpts);
+        try {
+          await ctrl.open();
+        } catch (e) {
+          this.log.error({ err: e }, "failed to open card; aborting task");
+          return;
+        }
+        const resumeId = await this.sessions.getKiroSession(msg.chatId, cwd);
+        const runOpts = {
+          prompt: finalPrompt,
+          cwd,
+          binPath: this.config.kiro.binPath,
+          trustedTools: this.config.kiro.trustedTools,
+          timeoutMs: this.config.kiro.timeoutMs,
+          idleTimeoutMs,
+          signal,
+          onChunk: (text) => ctrl.feed(text)
+        };
+        if (resumeId !== void 0) runOpts.resumeId = resumeId;
+        if (this.config.kiro.model !== void 0) runOpts.model = this.config.kiro.model;
+        if (this.config.kiro.agent !== void 0) runOpts.agent = this.config.kiro.agent;
+        let result;
+        try {
+          result = await runKiro(runOpts);
+        } catch (e) {
+          await ctrl.finalize("error", e.message);
+          return;
+        }
+        if (result.aborted) {
+          await ctrl.finalize("interrupted");
+          return;
+        }
+        if (result.idleTimedOut) {
+          await ctrl.finalize("idle_timeout");
+          return;
+        }
+        if (result.timedOut) {
+          await ctrl.finalize(
+            "error",
+            `\u8D85\u8FC7 ${this.config.kiro.timeoutMs / 1e3}s \u672A\u5B8C\u6210\uFF0C\u5DF2\u5F3A\u5236\u7EC8\u6B62`
+          );
+          return;
+        }
+        if (result.exitCode !== 0) {
+          await ctrl.finalize("error", `kiro-cli \u9000\u51FA\u7801 ${result.exitCode}`);
+          return;
+        }
+        if (result.newSessionId && result.newSessionId !== resumeId) {
+          await this.sessions.setKiroSession(msg.chatId, cwd, result.newSessionId);
+        }
+        await ctrl.finalize("done");
+      }
+    });
+  }
+};
+
+// src/daemon/registry.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync6 } from "fs";
+import lockfile3 from "proper-lockfile";
+import { z as z4 } from "zod";
+var ProcessEntrySchema = z4.object({
+  pid: z4.number().int().positive(),
+  appId: z4.string(),
+  startedAt: z4.number().int().nonnegative(),
+  cwd: z4.string(),
+  /** 自动生成的短 id（前 6 位 pid 哈希），方便 /exit 1 这种交互 */
+  shortId: z4.string()
+});
+var ProcessesFileSchema = z4.object({
+  version: z4.literal(1).default(1),
+  processes: z4.array(ProcessEntrySchema).default([])
+});
+var log7 = () => getLogger().child({ module: "process-registry" });
+function readFile3() {
+  if (!existsSync6(PROCESSES_FILE)) {
+    return ProcessesFileSchema.parse({});
+  }
+  try {
+    const raw = readFileSync6(PROCESSES_FILE, "utf-8");
+    const parsed = ProcessesFileSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success) return ProcessesFileSchema.parse({});
+    return parsed.data;
+  } catch {
+    return ProcessesFileSchema.parse({});
+  }
+}
+function writeFile3(data) {
+  ensureDataDirs();
+  writeFileSync5(PROCESSES_FILE, JSON.stringify(data, null, 2) + "\n", { mode: 384 });
+}
+async function withLock3(fn) {
+  ensureDataDirs();
+  if (!existsSync6(PROCESSES_FILE)) {
+    writeFileSync5(PROCESSES_FILE, "{}\n", { mode: 384 });
+  }
+  const release = await lockfile3.lock(PROCESSES_FILE, {
+    retries: { retries: 5, minTimeout: 50, maxTimeout: 200 },
+    stale: 1e4
+  });
+  try {
+    return fn();
+  } finally {
+    await release();
+  }
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    const code = e.code;
+    return code === "EPERM";
+  }
+}
+function shortIdOf(pid) {
+  return pid.toString(36).padStart(6, "0").slice(-6);
+}
+async function listProcesses() {
+  return withLock3(() => {
+    const data = readFile3();
+    const alive = data.processes.filter((p) => isAlive(p.pid));
+    if (alive.length !== data.processes.length) {
+      data.processes = alive;
+      writeFile3(data);
+    }
+    return alive;
+  });
+}
+async function registerSelf(appId) {
+  const entry = {
+    pid: process.pid,
+    appId,
+    startedAt: Date.now(),
+    cwd: process.cwd(),
+    shortId: shortIdOf(process.pid)
+  };
+  await withLock3(() => {
+    const data = readFile3();
+    data.processes = data.processes.filter((p) => p.pid !== process.pid && isAlive(p.pid));
+    data.processes.push(entry);
+    writeFile3(data);
+  });
+  log7().info({ pid: entry.pid, appId, shortId: entry.shortId }, "process registered");
+  return entry;
+}
+async function unregisterSelf() {
+  await withLock3(() => {
+    const data = readFile3();
+    const before = data.processes.length;
+    data.processes = data.processes.filter((p) => p.pid !== process.pid);
+    if (data.processes.length !== before) writeFile3(data);
+  });
+}
+
+// src/core/bootstrap.ts
+async function runBridge() {
+  const log8 = getLogger();
+  const config = loadConfig();
+  log8.info(
+    {
+      appId: config.lark.appId,
+      defaultCwd: config.workspace.defaultCwd,
+      allowedRoots: config.workspace.allowedRoots,
+      trustedTools: config.kiro.trustedTools,
+      idleTimeoutMinutes: config.kiro.idleTimeoutMinutes
+    },
+    "lark-kiro-bridge starting"
+  );
+  pruneOldLogs(config.preferences.logRetentionDays);
+  pruneOldMedia(24);
+  const others = (await listProcesses()).filter(
+    (p) => p.appId === config.lark.appId && p.pid !== process.pid
+  );
+  if (others.length > 0) {
+    log8.warn(
+      { others: others.map((p) => ({ pid: p.pid, shortId: p.shortId })) },
+      "another bridge process is running with the same appId; Lark events may be routed randomly between them"
+    );
+  }
+  await registerSelf(config.lark.appId);
+  const lark2 = new LarkClient({
+    appId: config.lark.appId,
+    appSecret: config.lark.appSecret,
+    logger: log8
+  });
+  const sessions = new SessionStore();
+  const workspaces = new WorkspaceStore();
+  const larkRef = lark2;
+  const startEventLoop = async () => {
+    await larkRef.startEventLoop({
+      onMessage: (msg) => dispatcher.handle(msg),
+      onCardAction: (evt) => dispatcher.handleCardAction(evt),
+      onReady: () => log8.info("\u{1F680} lark-kiro-bridge ready, waiting for messages")
+    });
+  };
+  const dispatcher = new Dispatcher({
+    config,
+    lark: lark2,
+    sessions,
+    workspaces,
+    logger: log8,
+    onReconnect: async () => {
+      log8.info("reconnect requested via /reconnect");
+      try {
+        larkRef.close();
+      } catch (e) {
+        log8.warn({ err: e }, "close before reconnect failed (ignored)");
+      }
+      await new Promise((r) => setTimeout(r, 500));
+      await startEventLoop();
+    }
+  });
+  await startEventLoop();
+  let stopped = false;
+  const stop = async () => {
+    if (stopped) return;
+    stopped = true;
+    log8.info("shutting down");
+    try {
+      larkRef.close();
+    } catch {
+    }
+    await unregisterSelf().catch(() => void 0);
+  };
+  const signalHandler = async (sig) => {
+    log8.info({ sig }, "received signal");
+    await stop();
+    process.exit(0);
+  };
+  process.once("SIGINT", signalHandler);
+  process.once("SIGTERM", signalHandler);
+  return { stop };
+}
+export {
+  ChatPipeline,
+  Dispatcher,
+  LarkClient,
+  SessionStore,
+  WorkspaceStore,
+  defaultConfig,
+  getLogger,
+  loadConfig,
+  runBridge,
+  runKiro,
+  saveConfig
+};
+//# sourceMappingURL=index.js.map