larkway 0.3.13 → 0.3.14

package/README.md

@@ -8,7 +8,7 @@
 
 You @ the bot in a Feishu thread. It runs on your machine — reading your real codebase, executing commands, opening MRs — and posts the result back. You define what the agent knows and what it can do. Larkway just carries the messages.
 
-**Current release: v0.3.13**
+**Current release: v0.3.14**
 
 ---
 

package/README.zh.md

@@ -8,7 +8,7 @@
 
 你在飞书话题里 @ bot，它在你的机器上运行——读真实代码库、执行命令、开 MR——把结果贴回飞书。你定义 agent 知道什么、能做什么。Larkway 只负责传递消息。
 
-**当前版本：v0.3.13**
+**当前版本：v0.3.14**
 
 ---
 

package/dist/cli/index.js

@@ -107550,6 +107550,7 @@ var channelClient_exports = {};
 __export(channelClient_exports, {
   ChannelClient: () => ChannelClient,
   channelMsgToLarkEvent: () => channelMsgToLarkEvent,
+  resolveRecoveredThreadId: () => resolveRecoveredThreadId,
   synthesizeCardActionEvent: () => synthesizeCardActionEvent
 });
 import { execFile as execFileCallback } from "node:child_process";
@@ -107633,6 +107634,16 @@ function expandMessagesWithThreadReplies(messages) {
   }
   return expanded;
 }
+function resolveRecoveredThreadId(m) {
+  const explicit = nonEmptyStringField(m, "thread_id") ?? nonEmptyStringField(m, "root_id");
+  if (explicit) return explicit;
+  const link = nonEmptyStringField(m, "message_app_link");
+  if (link) {
+    const match = link.match(/open_thread_id=(omt_[A-Za-z0-9_-]+)/);
+    if (match) return match[1] ?? null;
+  }
+  return null;
+}
 function cardActionChoice(value) {
   if (value && typeof value === "object") {
     const choice = value["larkway_choice"];
@@ -107682,7 +107693,7 @@ function channelMsgToLarkEvent(msg) {
     create_time: m?.["create_time"] ?? String(msg.createTime ?? Date.now())
   };
 }
-var import_node_sdk, execFile4, LEARNED_CHATS_LIMIT, SEEN_MESSAGES_LIMIT, OPEN_CHAT_DISCOVERY_LOOKBACK_MS, OPEN_CHAT_DISCOVERY_BOOTSTRAP_LOOKBACK_MS, PROCESSING_REACTION_EMOJI, DEFAULT_CONNECT_GRACE_MS, ChannelClient;
+var import_node_sdk, execFile4, LEARNED_CHATS_LIMIT, SEEN_MESSAGES_LIMIT, MAX_MESSAGE_ATTEMPTS, OPEN_CHAT_DISCOVERY_LOOKBACK_MS, OPEN_CHAT_DISCOVERY_BOOTSTRAP_LOOKBACK_MS, PROCESSING_REACTION_EMOJI, DEFAULT_CONNECT_GRACE_MS, ChannelClient;
 var init_channelClient = __esm({
   "src/lark/channelClient.ts"() {
     "use strict";
@@ -107692,6 +107703,7 @@ var init_channelClient = __esm({
     execFile4 = promisify4(execFileCallback);
     LEARNED_CHATS_LIMIT = 100;
     SEEN_MESSAGES_LIMIT = 1e3;
+    MAX_MESSAGE_ATTEMPTS = 5;
     OPEN_CHAT_DISCOVERY_LOOKBACK_MS = 9e4;
     OPEN_CHAT_DISCOVERY_BOOTSTRAP_LOOKBACK_MS = 30 * 60 * 1e3;
     PROCESSING_REACTION_EMOJI = "Typing";
@@ -107713,14 +107725,42 @@ var init_channelClient = __esm({
        */
       lastDisconnectAt = 0;
       /**
-       * Set of message_ids that have been dispatched (pushed onto the inbound queue)
-       * during this process lifetime. Used by gapFill to avoid dispatching the same
-       * message twice — once from the live WS handler, once from history catch-up.
-       * Bounded: we only add live-delivered messages here (not synthetics like
-       * cardAction turns), and Feishu message_id space is stable and non-recycling
-       * within any reasonable bridge uptime.
+       * Message_ids that have reached a terminal SUCCESS (handler.markHandled) OR
+       * were explicitly acknowledged. These are persisted so open-chat recovery
+       * does not replay an already-completed message after a restart. gap-fill
+       * skips anything in this set.
+       *
+       * Bounded: we only add completed/acknowledged messages here (not synthetics
+       * like cardAction turns), and Feishu message_id space is stable and
+       * non-recycling within any reasonable bridge uptime.
        */
       seenMessageIds = /* @__PURE__ */ new Set();
+      /**
+       * Message_ids that have been DISPATCHED (pushed onto the inbound queue) but
+       * whose turn has not yet reached a terminal outcome. This is the no-duplicate
+       * guard: gap-fill (and the WS path) skip a message that is already in-flight,
+       * so a message delivered live is never also gap-filled, and two overlapping
+       * gap-fill windows never double-dispatch the same message.
+       *
+       * CRITICAL (the core self-heal): a message stays here only while its turn is
+       * running. handler.markHandled() promotes it into {@link seenMessageIds} on
+       * SUCCESS; handler.markUnhandled() REMOVES it on FAILURE so the next gap-fill
+       * window re-dispatches it — one transient blip (e.g. a TLS timeout creating
+       * the card) no longer swallows the @ forever. NOT persisted: an in-flight
+       * message interrupted by a restart SHOULD be re-dispatchable.
+       */
+      inFlightMessageIds = /* @__PURE__ */ new Set();
+      /**
+       * Per-message (re-)dispatch counter for the poison-message guard. Incremented
+       * every time a message_id is pushed onto the inbound queue (live WS or either
+       * gap-fill branch) and once more when a turn is released as unhandled. When the
+       * count reaches {@link MAX_MESSAGE_ATTEMPTS}, markUnhandled GIVES UP: it
+       * promotes the message to seen (so it stops being re-dispatched) and logs a
+       * warning. markHandled clears the entry on terminal success. Not persisted:
+       * post-restart, an interrupted message starts fresh — same policy as
+       * inFlightMessageIds.
+       */
+      messageAttempts = /* @__PURE__ */ new Map();
       /**
        * Chats observed from live WS events during this process lifetime.
        *
@@ -107822,7 +107862,11 @@ var init_channelClient = __esm({
             return;
           }
           this.noteSeenChat(ev.chat_id);
-          this.noteSeenMessage(ev.message_id);
+          if (this.seenMessageIds.has(ev.message_id) || this.inFlightMessageIds.has(ev.message_id)) {
+            return;
+          }
+          this.inFlightMessageIds.add(ev.message_id);
+          this.noteDispatchAttempt(ev.message_id);
           log(`dispatching (channel-sdk): message_id=${ev.message_id} thread=${ev.thread_id ?? "?"}`);
           this.queue.push(ev);
         });
@@ -107972,7 +108016,7 @@ var init_channelClient = __esm({
               const m = raw;
               const messageId = m["message_id"];
               if (!messageId) continue;
-              if (this.seenMessageIds.has(messageId)) continue;
+              if (this.seenMessageIds.has(messageId) || this.inFlightMessageIds.has(messageId)) continue;
               const mentions = m["mentions"];
               const mentionsBot = Array.isArray(mentions) && mentions.some(
                 (mn) => {
@@ -107981,6 +108025,11 @@ var init_channelClient = __esm({
                 }
               );
               if (!mentionsBot) continue;
+              const recoveredThread = resolveRecoveredThreadId(m);
+              const isThreadReply = recoveredThread !== null && recoveredThread !== messageId;
+              if (isThreadReply && !nonEmptyStringField(m, "root_id")) {
+                m["root_id"] = recoveredThread;
+              }
               const ev = channelMsgToLarkEvent({
                 raw: {
                   event: {
@@ -107999,21 +108048,23 @@ var init_channelClient = __esm({
                     message_id: mid,
                     chat_id: cid,
                     chat_type: m["chat_type"] ?? "group",
-                    thread_id: m["thread_id"] ?? m["root_id"] ?? mid,
-                    root_id: m["root_id"],
+                    thread_id: m["thread_id"] ?? (isThreadReply ? recoveredThread ?? void 0 : void 0) ?? m["root_id"] ?? mid,
+                    root_id: m["root_id"] ?? (isThreadReply ? recoveredThread ?? void 0 : void 0),
                     sender_id: sid,
                     content: typeof m["content"] === "string" ? m["content"] : JSON.stringify({ text: "" }),
                     create_time: m["create_time"] ?? String(Date.now())
                   };
                 })();
                 if (!fallbackEv) continue;
-                this.noteSeenMessage(fallbackEv.message_id);
+                this.inFlightMessageIds.add(fallbackEv.message_id);
+                this.noteDispatchAttempt(fallbackEv.message_id);
                 log(`gap-fill dispatching (fallback): message_id=${fallbackEv.message_id} chat=${chatId}`);
                 this.queue.push(fallbackEv);
                 totalDispatched++;
                 continue;
               }
-              this.noteSeenMessage(ev.message_id);
+              this.inFlightMessageIds.add(ev.message_id);
+              this.noteDispatchAttempt(ev.message_id);
               log(`gap-fill dispatching: message_id=${ev.message_id} thread=${ev.thread_id ?? "?"} chat=${chatId}`);
               this.queue.push(ev);
               totalDispatched++;
@@ -108237,8 +108288,52 @@ var init_channelClient = __esm({
        * already handled message after a restart.
        */
       acknowledgeMessage(messageId) {
+        this.markHandled(messageId);
+      }
+      /**
+       * Terminal SUCCESS: promote a message out of the in-flight set into the
+       * persisted seen set. After this, neither the WS path nor any gap-fill window
+       * (this process or post-restart) re-dispatches it. Persistence flows through
+       * {@link noteSeenMessage} (the same channel-seen-messages json the success
+       * set has always used), so post-restart recovery skips completed messages.
+       */
+      markHandled(messageId) {
+        this.inFlightMessageIds.delete(messageId);
+        this.messageAttempts.delete(messageId);
         this.noteSeenMessage(messageId);
       }
+      /**
+       * Terminal FAILURE/ABORT: release a message from the in-flight set WITHOUT
+       * marking it seen, so the next gap-fill window can re-dispatch it (the core
+       * self-heal — one transient blip no longer swallows the @ forever). Does not
+       * touch persisted seen state.
+       *
+       * Poison-message guard: count this failed turn as one more attempt. If the
+       * message has now failed {@link MAX_MESSAGE_ATTEMPTS} times, GIVE UP — promote
+       * it to seen (so it stops being re-dispatched on every gap-fill) and log a
+       * visible warning instead of silently looping forever.
+       */
+      markUnhandled(messageId) {
+        this.inFlightMessageIds.delete(messageId);
+        const attempts = (this.messageAttempts.get(messageId) ?? 0) + 1;
+        this.messageAttempts.set(messageId, attempts);
+        if (attempts >= MAX_MESSAGE_ATTEMPTS) {
+          console.warn(
+            `[channel.client] giving up on message_id=${messageId} after ${attempts} failed attempts \u2014 promoting to seen so it is no longer re-dispatched (poison-message guard)`
+          );
+          this.messageAttempts.delete(messageId);
+          this.noteSeenMessage(messageId);
+        }
+      }
+      /**
+       * Increment the per-message dispatch counter (poison-message guard). Called
+       * each time a message_id is pushed onto the inbound queue. The counter is also
+       * bumped in {@link markUnhandled} so both dispatch and failed settlement
+       * contribute toward the cap.
+       */
+      noteDispatchAttempt(messageId) {
+        this.messageAttempts.set(messageId, (this.messageAttempts.get(messageId) ?? 0) + 1);
+      }
       async close() {
         this.closed = true;
         if (this.openChatDiscoveryTimer) {

package/dist/main.js

@@ -111778,6 +111778,7 @@ var ChannelCardClient = class {
 var execFile = promisify(execFileCallback);
 var LEARNED_CHATS_LIMIT = 100;
 var SEEN_MESSAGES_LIMIT = 1e3;
+var MAX_MESSAGE_ATTEMPTS = 5;
 var OPEN_CHAT_DISCOVERY_LOOKBACK_MS = 9e4;
 var OPEN_CHAT_DISCOVERY_BOOTSTRAP_LOOKBACK_MS = 30 * 60 * 1e3;
 var PROCESSING_REACTION_EMOJI = "Typing";
@@ -111859,6 +111860,16 @@ function expandMessagesWithThreadReplies(messages) {
   }
   return expanded;
 }
+function resolveRecoveredThreadId(m) {
+  const explicit = nonEmptyStringField(m, "thread_id") ?? nonEmptyStringField(m, "root_id");
+  if (explicit) return explicit;
+  const link = nonEmptyStringField(m, "message_app_link");
+  if (link) {
+    const match = link.match(/open_thread_id=(omt_[A-Za-z0-9_-]+)/);
+    if (match) return match[1] ?? null;
+  }
+  return null;
+}
 function cardActionChoice(value) {
   if (value && typeof value === "object") {
     const choice = value["larkway_choice"];
@@ -111925,14 +111936,42 @@ var ChannelClient = class {
    */
   lastDisconnectAt = 0;
   /**
-   * Set of message_ids that have been dispatched (pushed onto the inbound queue)
-   * during this process lifetime. Used by gapFill to avoid dispatching the same
-   * message twice — once from the live WS handler, once from history catch-up.
-   * Bounded: we only add live-delivered messages here (not synthetics like
-   * cardAction turns), and Feishu message_id space is stable and non-recycling
-   * within any reasonable bridge uptime.
+   * Message_ids that have reached a terminal SUCCESS (handler.markHandled) OR
+   * were explicitly acknowledged. These are persisted so open-chat recovery
+   * does not replay an already-completed message after a restart. gap-fill
+   * skips anything in this set.
+   *
+   * Bounded: we only add completed/acknowledged messages here (not synthetics
+   * like cardAction turns), and Feishu message_id space is stable and
+   * non-recycling within any reasonable bridge uptime.
    */
   seenMessageIds = /* @__PURE__ */ new Set();
+  /**
+   * Message_ids that have been DISPATCHED (pushed onto the inbound queue) but
+   * whose turn has not yet reached a terminal outcome. This is the no-duplicate
+   * guard: gap-fill (and the WS path) skip a message that is already in-flight,
+   * so a message delivered live is never also gap-filled, and two overlapping
+   * gap-fill windows never double-dispatch the same message.
+   *
+   * CRITICAL (the core self-heal): a message stays here only while its turn is
+   * running. handler.markHandled() promotes it into {@link seenMessageIds} on
+   * SUCCESS; handler.markUnhandled() REMOVES it on FAILURE so the next gap-fill
+   * window re-dispatches it — one transient blip (e.g. a TLS timeout creating
+   * the card) no longer swallows the @ forever. NOT persisted: an in-flight
+   * message interrupted by a restart SHOULD be re-dispatchable.
+   */
+  inFlightMessageIds = /* @__PURE__ */ new Set();
+  /**
+   * Per-message (re-)dispatch counter for the poison-message guard. Incremented
+   * every time a message_id is pushed onto the inbound queue (live WS or either
+   * gap-fill branch) and once more when a turn is released as unhandled. When the
+   * count reaches {@link MAX_MESSAGE_ATTEMPTS}, markUnhandled GIVES UP: it
+   * promotes the message to seen (so it stops being re-dispatched) and logs a
+   * warning. markHandled clears the entry on terminal success. Not persisted:
+   * post-restart, an interrupted message starts fresh — same policy as
+   * inFlightMessageIds.
+   */
+  messageAttempts = /* @__PURE__ */ new Map();
   /**
    * Chats observed from live WS events during this process lifetime.
    *
@@ -112034,7 +112073,11 @@ var ChannelClient = class {
         return;
       }
       this.noteSeenChat(ev.chat_id);
-      this.noteSeenMessage(ev.message_id);
+      if (this.seenMessageIds.has(ev.message_id) || this.inFlightMessageIds.has(ev.message_id)) {
+        return;
+      }
+      this.inFlightMessageIds.add(ev.message_id);
+      this.noteDispatchAttempt(ev.message_id);
       log(`dispatching (channel-sdk): message_id=${ev.message_id} thread=${ev.thread_id ?? "?"}`);
       this.queue.push(ev);
     });
@@ -112184,7 +112227,7 @@ var ChannelClient = class {
           const m = raw;
           const messageId = m["message_id"];
           if (!messageId) continue;
-          if (this.seenMessageIds.has(messageId)) continue;
+          if (this.seenMessageIds.has(messageId) || this.inFlightMessageIds.has(messageId)) continue;
           const mentions = m["mentions"];
           const mentionsBot = Array.isArray(mentions) && mentions.some(
             (mn) => {
@@ -112193,6 +112236,11 @@ var ChannelClient = class {
             }
           );
           if (!mentionsBot) continue;
+          const recoveredThread = resolveRecoveredThreadId(m);
+          const isThreadReply = recoveredThread !== null && recoveredThread !== messageId;
+          if (isThreadReply && !nonEmptyStringField(m, "root_id")) {
+            m["root_id"] = recoveredThread;
+          }
           const ev = channelMsgToLarkEvent({
             raw: {
               event: {
@@ -112211,21 +112259,23 @@ var ChannelClient = class {
                 message_id: mid,
                 chat_id: cid,
                 chat_type: m["chat_type"] ?? "group",
-                thread_id: m["thread_id"] ?? m["root_id"] ?? mid,
-                root_id: m["root_id"],
+                thread_id: m["thread_id"] ?? (isThreadReply ? recoveredThread ?? void 0 : void 0) ?? m["root_id"] ?? mid,
+                root_id: m["root_id"] ?? (isThreadReply ? recoveredThread ?? void 0 : void 0),
                 sender_id: sid,
                 content: typeof m["content"] === "string" ? m["content"] : JSON.stringify({ text: "" }),
                 create_time: m["create_time"] ?? String(Date.now())
               };
             })();
             if (!fallbackEv) continue;
-            this.noteSeenMessage(fallbackEv.message_id);
+            this.inFlightMessageIds.add(fallbackEv.message_id);
+            this.noteDispatchAttempt(fallbackEv.message_id);
             log(`gap-fill dispatching (fallback): message_id=${fallbackEv.message_id} chat=${chatId}`);
             this.queue.push(fallbackEv);
             totalDispatched++;
             continue;
           }
-          this.noteSeenMessage(ev.message_id);
+          this.inFlightMessageIds.add(ev.message_id);
+          this.noteDispatchAttempt(ev.message_id);
           log(`gap-fill dispatching: message_id=${ev.message_id} thread=${ev.thread_id ?? "?"} chat=${chatId}`);
           this.queue.push(ev);
           totalDispatched++;
@@ -112449,8 +112499,52 @@ var ChannelClient = class {
    * already handled message after a restart.
    */
   acknowledgeMessage(messageId) {
+    this.markHandled(messageId);
+  }
+  /**
+   * Terminal SUCCESS: promote a message out of the in-flight set into the
+   * persisted seen set. After this, neither the WS path nor any gap-fill window
+   * (this process or post-restart) re-dispatches it. Persistence flows through
+   * {@link noteSeenMessage} (the same channel-seen-messages json the success
+   * set has always used), so post-restart recovery skips completed messages.
+   */
+  markHandled(messageId) {
+    this.inFlightMessageIds.delete(messageId);
+    this.messageAttempts.delete(messageId);
     this.noteSeenMessage(messageId);
   }
+  /**
+   * Terminal FAILURE/ABORT: release a message from the in-flight set WITHOUT
+   * marking it seen, so the next gap-fill window can re-dispatch it (the core
+   * self-heal — one transient blip no longer swallows the @ forever). Does not
+   * touch persisted seen state.
+   *
+   * Poison-message guard: count this failed turn as one more attempt. If the
+   * message has now failed {@link MAX_MESSAGE_ATTEMPTS} times, GIVE UP — promote
+   * it to seen (so it stops being re-dispatched on every gap-fill) and log a
+   * visible warning instead of silently looping forever.
+   */
+  markUnhandled(messageId) {
+    this.inFlightMessageIds.delete(messageId);
+    const attempts = (this.messageAttempts.get(messageId) ?? 0) + 1;
+    this.messageAttempts.set(messageId, attempts);
+    if (attempts >= MAX_MESSAGE_ATTEMPTS) {
+      console.warn(
+        `[channel.client] giving up on message_id=${messageId} after ${attempts} failed attempts \u2014 promoting to seen so it is no longer re-dispatched (poison-message guard)`
+      );
+      this.messageAttempts.delete(messageId);
+      this.noteSeenMessage(messageId);
+    }
+  }
+  /**
+   * Increment the per-message dispatch counter (poison-message guard). Called
+   * each time a message_id is pushed onto the inbound queue. The counter is also
+   * bumped in {@link markUnhandled} so both dispatch and failed settlement
+   * contribute toward the cap.
+   */
+  noteDispatchAttempt(messageId) {
+    this.messageAttempts.set(messageId, (this.messageAttempts.get(messageId) ?? 0) + 1);
+  }
   async close() {
     this.closed = true;
     if (this.openChatDiscoveryTimer) {
@@ -112786,6 +112880,30 @@ function extractRawMessageId(raw) {
   const id = msg["id"];
   return typeof id === "string" ? id : null;
 }
+async function createCardWithRetry(outbound, replyToMessageId, cardJson, opts, maxAttempts = 3) {
+  let lastErr;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await outbound.createCard(replyToMessageId, cardJson, opts);
+    } catch (err) {
+      lastErr = err;
+      if (attempt === maxAttempts) {
+        console.error(
+          `[lark.card] createCard failed after ${attempt} attempts:`,
+          err
+        );
+        throw err;
+      }
+      const delay = 400 * Math.pow(2, attempt - 1);
+      console.warn(
+        `[lark.card] createCard attempt ${attempt} failed, retrying in ${delay}ms:`,
+        err.message
+      );
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastErr;
+}
 var CardRenderer = class {
   /**
    * Transport for the two OUTBOUND card calls (create + patch). Injected
@@ -112827,7 +112945,8 @@ var CardRenderer = class {
       status: "thinking"
     });
     const replyInThread = opts?.replyInThread ?? true;
-    const { messageId } = await this.outbound.createCard(
+    const { messageId } = await createCardWithRetry(
+      this.outbound,
       replyToMessageId,
       initialCardJson,
       { replyInThread, threadId: opts?.threadId }
@@ -114699,383 +114818,395 @@ var BridgeHandler = class {
   // Private: single-event lifecycle
   // ---------------------------------------------------------------------------
   async handleOne(event) {
-    const parsed = parseMessage(event);
-    const { threadId, messageId, senderOpenId } = parsed;
-    const botId = this.deps.botConfig?.id;
-    const eventLogId = messageId;
-    const eventStartedAt = Date.now();
-    const recordEvent = async (patch) => {
-      if (!this.deps.recordRuntimeEvent) return;
-      try {
-        await this.deps.recordRuntimeEvent({ id: eventLogId, ...patch });
-      } catch (err) {
-        console.warn("[bridge.handler] recordRuntimeEvent failed (continuing):", err);
-      }
+    const settleMessageId = event.message_id;
+    let settled = false;
+    const settle = (ok) => {
+      if (settled) return;
+      settled = true;
+      if (ok) this.deps.client.markHandled?.(settleMessageId);
+      else this.deps.client.markUnhandled?.(settleMessageId);
     };
-    const triggerType = typeof parsed.raw.root_id === "string" && parsed.raw.root_id ? "thread_reply" : "mention";
-    await recordEvent({
-      botId,
-      botName: this.deps.botConfig?.name,
-      messageId,
-      threadId,
-      chatId: parsed.chatId,
-      senderId: senderOpenId,
-      triggerType,
-      textPreview: parsed.text.slice(0, 120),
-      status: "received",
-      receivedAt: new Date(eventStartedAt).toISOString(),
-      statusPath: ["\u5DF2\u6536\u5230"],
-      reason: "\u5DF2\u8FDB\u5165 bridge\uFF0C\u51C6\u5907\u521B\u5EFA\u5904\u7406\u5361\u7247\u3002"
-    });
-    await this.deps.client.addProcessingReaction?.(messageId);
-    const existing = this.deps.sessionStore.get(threadId, botId);
-    const isNewThread = existing === void 0;
-    const isTopLevel = !(typeof parsed.raw.root_id === "string" && parsed.raw.root_id);
-    const replyInThread = isTopLevel;
-    let card;
     try {
-      card = await this.deps.cardRenderer.start(messageId, { replyInThread, threadId });
-      await recordEvent({
-        status: "running",
-        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        appendPath: "\u5DF2\u521B\u5EFA\u5361\u7247",
-        reason: "\u5DF2\u4EA4\u7ED9\u672C\u5730 Agent \u5904\u7406\u3002"
-      });
-    } catch (err) {
-      console.error("[bridge.handler] Failed to start card for thread", threadId, err);
+      const parsed = parseMessage(event);
+      const { threadId, messageId, senderOpenId } = parsed;
+      const botId = this.deps.botConfig?.id;
+      const eventLogId = messageId;
+      const eventStartedAt = Date.now();
+      const recordEvent = async (patch) => {
+        if (!this.deps.recordRuntimeEvent) return;
+        try {
+          await this.deps.recordRuntimeEvent({ id: eventLogId, ...patch });
+        } catch (err) {
+          console.warn("[bridge.handler] recordRuntimeEvent failed (continuing):", err);
+        }
+      };
+      const triggerType = typeof parsed.raw.root_id === "string" && parsed.raw.root_id ? "thread_reply" : "mention";
       await recordEvent({
-        status: "running",
-        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        appendPath: "\u5361\u7247\u521B\u5EFA\u5931\u8D25\uFF0C\u7EE7\u7EED\u6267\u884C",
-        reason: "\u5361\u7247\u521B\u5EFA\u5931\u8D25\uFF0C\u4F46 bridge \u4F1A\u7EE7\u7EED\u542F\u52A8\u672C\u5730 Agent\u3002"
+        botId,
+        botName: this.deps.botConfig?.name,
+        messageId,
+        threadId,
+        chatId: parsed.chatId,
+        senderId: senderOpenId,
+        triggerType,
+        textPreview: parsed.text.slice(0, 120),
+        status: "received",
+        receivedAt: new Date(eventStartedAt).toISOString(),
+        statusPath: ["\u5DF2\u6536\u5230"],
+        reason: "\u5DF2\u8FDB\u5165 bridge\uFF0C\u51C6\u5907\u521B\u5EFA\u5904\u7406\u5361\u7247\u3002"
       });
-    } finally {
-      await this.deps.client.removeProcessingReaction?.(messageId);
-    }
-    try {
-      const { conventions } = this.deps;
-      const isAgentWorkspace = conventions.runtime === "agent_workspace";
-      if (isAgentWorkspace) {
-        if (!conventions.agentWorkspacePath || !conventions.workspaceSessionsDir || !conventions.workspaceReposPath) {
-          throw new Error("agent_workspace runtime requires workspace path conventions");
-        }
-      }
-      const worktreePath = isAgentWorkspace ? path8.join(conventions.workspaceSessionsDir, threadId) : path8.join(conventions.worktreesDir, threadId);
-      const runCwd = isAgentWorkspace ? conventions.agentWorkspacePath : worktreePath;
-      const hasRepo = !isAgentWorkspace && !!conventions.repoCachePath;
-      const buildWorktree = hasRepo && !conventions.readOnly;
-      const extraRepos = conventions.extraRepoPaths ?? [];
-      if (isAgentWorkspace) {
-        await ensureAgentWorkspace({
-          agentId: botId ?? "v1-default",
-          workspacePath: conventions.agentWorkspacePath,
-          reposPath: conventions.workspaceReposPath,
-          sessionPath: worktreePath,
-          bot: {
-            name: this.deps.botConfig?.name ?? "Larkway Agent",
-            description: this.deps.botConfig?.description ?? "Local agent served through Larkway.",
-            gitlab_token_env: this.deps.botConfig?.git_token_env ?? this.deps.botConfig?.gitlab_token_env
-          },
-          agentMemory: this.deps.agentMemory,
-          repos: [
-            ...conventions.defaultProjectSlug ? [
-              {
-                slug: conventions.defaultProjectSlug,
-                branch: conventions.defaultBranch,
-                url: conventions.primaryRepoUrl,
-                suggestedPath: conventions.repoCachePath ?? conventions.workspaceReposPath
-              }
-            ] : [],
-            ...extraRepos.map((repo) => ({
-              slug: repo.slug,
-              url: repo.url,
-              suggestedPath: repo.cachePath
-            }))
-          ]
+      await this.deps.client.addProcessingReaction?.(messageId);
+      const existing = this.deps.sessionStore.get(threadId, botId);
+      const isNewThread = existing === void 0;
+      const isTopLevel = !(typeof parsed.raw.root_id === "string" && parsed.raw.root_id);
+      const replyInThread = isTopLevel;
+      let card;
+      try {
+        card = await this.deps.cardRenderer.start(messageId, { replyInThread, threadId });
+        await recordEvent({
+          status: "running",
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          appendPath: "\u5DF2\u521B\u5EFA\u5361\u7247",
+          reason: "\u5DF2\u4EA4\u7ED9\u672C\u5730 Agent \u5904\u7406\u3002"
+        });
+      } catch (err) {
+        console.error("[bridge.handler] Failed to start card for thread", threadId, err);
+        await recordEvent({
+          status: "running",
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          appendPath: "\u5361\u7247\u521B\u5EFA\u5931\u8D25\uFF0C\u7EE7\u7EED\u6267\u884C",
+          reason: "\u5361\u7247\u521B\u5EFA\u5931\u8D25\uFF0C\u4F46 bridge \u4F1A\u7EE7\u7EED\u542F\u52A8\u672C\u5730 Agent\u3002"
         });
+      } finally {
+        await this.deps.client.removeProcessingReaction?.(messageId);
       }
-      if (hasRepo) {
-        await ensureRepoClone(
-          conventions.repoCachePath,
-          conventions.primaryRepoUrl,
-          this.deps.gitlabToken,
-          conventions.defaultProjectSlug ?? "primary"
-        );
-        try {
-          await execGit(conventions.repoCachePath, ["fetch", "origin", "--quiet"]);
-        } catch (err) {
-          console.warn("[bridge.handler] primary repo fetch failed (continuing):", err);
+      try {
+        const { conventions } = this.deps;
+        const isAgentWorkspace = conventions.runtime === "agent_workspace";
+        if (isAgentWorkspace) {
+          if (!conventions.agentWorkspacePath || !conventions.workspaceSessionsDir || !conventions.workspaceReposPath) {
+            throw new Error("agent_workspace runtime requires workspace path conventions");
+          }
         }
-      }
-      for (const repo of isAgentWorkspace ? [] : extraRepos) {
-        await ensureRepoClone(
-          repo.cachePath,
-          repo.url,
-          this.deps.gitlabToken,
-          repo.slug
-        );
-        try {
-          await execGit(repo.cachePath, ["fetch", "origin", "--quiet"]);
-        } catch (err) {
-          console.warn(
-            `[bridge.handler] extra repo ${repo.slug} fetch failed (continuing):`,
-            err
-          );
+        const worktreePath = isAgentWorkspace ? path8.join(conventions.workspaceSessionsDir, threadId) : path8.join(conventions.worktreesDir, threadId);
+        const runCwd = isAgentWorkspace ? conventions.agentWorkspacePath : worktreePath;
+        const hasRepo = !isAgentWorkspace && !!conventions.repoCachePath;
+        const buildWorktree = hasRepo && !conventions.readOnly;
+        const extraRepos = conventions.extraRepoPaths ?? [];
+        if (isAgentWorkspace) {
+          await ensureAgentWorkspace({
+            agentId: botId ?? "v1-default",
+            workspacePath: conventions.agentWorkspacePath,
+            reposPath: conventions.workspaceReposPath,
+            sessionPath: worktreePath,
+            bot: {
+              name: this.deps.botConfig?.name ?? "Larkway Agent",
+              description: this.deps.botConfig?.description ?? "Local agent served through Larkway.",
+              gitlab_token_env: this.deps.botConfig?.git_token_env ?? this.deps.botConfig?.gitlab_token_env
+            },
+            agentMemory: this.deps.agentMemory,
+            repos: [
+              ...conventions.defaultProjectSlug ? [
+                {
+                  slug: conventions.defaultProjectSlug,
+                  branch: conventions.defaultBranch,
+                  url: conventions.primaryRepoUrl,
+                  suggestedPath: conventions.repoCachePath ?? conventions.workspaceReposPath
+                }
+              ] : [],
+              ...extraRepos.map((repo) => ({
+                slug: repo.slug,
+                url: repo.url,
+                suggestedPath: repo.cachePath
+              }))
+            ]
+          });
         }
-      }
-      let worktreeExists = await pathExists(worktreePath);
-      if (worktreeExists && buildWorktree) {
-        const healthy = await isWorktreeGitHealthy(worktreePath);
-        if (!healthy) {
-          console.warn(
-            `[bridge.handler] worktree ${worktreePath} exists but git health check failed \u2014 removing stale dir and rebuilding (BL-8: migrated worktree with dead .git pointer)`
+        if (hasRepo) {
+          await ensureRepoClone(
+            conventions.repoCachePath,
+            conventions.primaryRepoUrl,
+            this.deps.gitlabToken,
+            conventions.defaultProjectSlug ?? "primary"
           );
           try {
-            await fs5.rm(worktreePath, { recursive: true, force: true });
-          } catch (rmErr) {
-            console.warn("[bridge.handler] failed to remove stale worktree (will attempt rebuild anyway):", rmErr);
+            await execGit(conventions.repoCachePath, ["fetch", "origin", "--quiet"]);
+          } catch (err) {
+            console.warn("[bridge.handler] primary repo fetch failed (continuing):", err);
           }
-          worktreeExists = false;
         }
-      }
-      if (!worktreeExists) {
-        if (buildWorktree) {
-          const slug = threadId.replace(/^om_/, "").slice(0, 16);
-          const botSegment = this.deps.botConfig?.id ? `${this.deps.botConfig.id}/` : "";
-          const branchName = `larkway/${botSegment}${slug}`;
-          await execGit(conventions.repoCachePath, [
-            "worktree",
-            "add",
-            worktreePath,
-            "-b",
-            branchName,
-            `origin/${conventions.defaultBranch}`
-          ]);
-          console.log(
-            `[bridge.handler] created worktree ${worktreePath} on branch ${branchName}`
+        for (const repo of isAgentWorkspace ? [] : extraRepos) {
+          await ensureRepoClone(
+            repo.cachePath,
+            repo.url,
+            this.deps.gitlabToken,
+            repo.slug
           );
-        } else {
-          await fs5.mkdir(worktreePath, { recursive: true });
-          if (conventions.readOnly && conventions.repoCachePath) {
-            console.log(
-              `[bridge.handler] created scratch dir ${worktreePath} (read_only bot: repo read-only at ${conventions.repoCachePath}, no worktree)`
+          try {
+            await execGit(repo.cachePath, ["fetch", "origin", "--quiet"]);
+          } catch (err) {
+            console.warn(
+              `[bridge.handler] extra repo ${repo.slug} fetch failed (continuing):`,
+              err
             );
-          } else {
+          }
+        }
+        let worktreeExists = await pathExists(worktreePath);
+        if (worktreeExists && buildWorktree) {
+          const healthy = await isWorktreeGitHealthy(worktreePath);
+          if (!healthy) {
+            console.warn(
+              `[bridge.handler] worktree ${worktreePath} exists but git health check failed \u2014 removing stale dir and rebuilding (BL-8: migrated worktree with dead .git pointer)`
+            );
+            try {
+              await fs5.rm(worktreePath, { recursive: true, force: true });
+            } catch (rmErr) {
+              console.warn("[bridge.handler] failed to remove stale worktree (will attempt rebuild anyway):", rmErr);
+            }
+            worktreeExists = false;
+          }
+        }
+        if (!worktreeExists) {
+          if (buildWorktree) {
+            const slug = threadId.replace(/^om_/, "").slice(0, 16);
+            const botSegment = this.deps.botConfig?.id ? `${this.deps.botConfig.id}/` : "";
+            const branchName = `larkway/${botSegment}${slug}`;
+            await execGit(conventions.repoCachePath, [
+              "worktree",
+              "add",
+              worktreePath,
+              "-b",
+              branchName,
+              `origin/${conventions.defaultBranch}`
+            ]);
             console.log(
-              `[bridge.handler] created scratch dir ${worktreePath} (bot has no repos)`
+              `[bridge.handler] created worktree ${worktreePath} on branch ${branchName}`
             );
+          } else {
+            await fs5.mkdir(worktreePath, { recursive: true });
+            if (conventions.readOnly && conventions.repoCachePath) {
+              console.log(
+                `[bridge.handler] created scratch dir ${worktreePath} (read_only bot: repo read-only at ${conventions.repoCachePath}, no worktree)`
+              );
+            } else {
+              console.log(
+                `[bridge.handler] created scratch dir ${worktreePath} (bot has no repos)`
+              );
+            }
           }
         }
-      }
-      if (isAgentWorkspace) {
-        await ensureSessionArtifacts({
-          sessionPath: worktreePath,
-          parsed,
-          isNewThread: existing === void 0,
-          larkCliProfile: this.deps.larkCliProfile
-        });
-      }
-      try {
-        await writeWorktreeSettings(worktreePath, {
-          allowExtra: this.deps.permissionsAllowExtra
-        });
-      } catch (err) {
-        console.warn("[bridge.handler] writeWorktreeSettings failed (continuing):", err);
-      }
-      try {
-        await ensureStateFile(worktreePath);
-      } catch (err) {
-        console.warn("[bridge.handler] ensureStateFile failed (continuing):", err);
-      }
-      if (card) {
+        if (isAgentWorkspace) {
+          await ensureSessionArtifacts({
+            sessionPath: worktreePath,
+            parsed,
+            isNewThread: existing === void 0,
+            larkCliProfile: this.deps.larkCliProfile
+          });
+        }
         try {
-          await writeCardFile(worktreePath, {
-            messageId: card.messageId,
-            chatId: parsed.chatId,
-            threadId,
-            botId: this.deps.botConfig?.id ?? "",
-            replyInThread,
-            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          await writeWorktreeSettings(worktreePath, {
+            allowExtra: this.deps.permissionsAllowExtra
           });
         } catch (err) {
-          console.warn("[bridge.handler] writeCardFile failed (continuing):", err);
+          console.warn("[bridge.handler] writeWorktreeSettings failed (continuing):", err);
         }
-      }
-      if (buildWorktree) {
         try {
-          await ensureNodeModules(worktreePath);
+          await ensureStateFile(worktreePath);
         } catch (err) {
-          console.warn("[bridge.handler] ensureNodeModules failed (continuing):", err);
-        }
-      }
-      const preRunUpdatedAt = (await readStateFile(worktreePath))?.updated_at;
-      let currentExisting = existing;
-      let attempt = 0;
-      while (true) {
-        attempt++;
-        const currentIsNewThread = currentExisting === void 0;
-        const prompt = renderPrompt({
-          parsed,
-          isNewThread: currentIsNewThread,
-          conventions: {
-            worktreePath,
-            runtime: conventions.runtime,
-            agentWorkspacePath: conventions.agentWorkspacePath,
-            workspaceSessionPath: isAgentWorkspace ? worktreePath : void 0,
-            workspaceReposPath: conventions.workspaceReposPath,
-            stateFilePath: stateFilePathOf(worktreePath),
-            repoCachePath: conventions.repoCachePath,
-            primaryRepoUrl: conventions.primaryRepoUrl,
-            defaultBranch: conventions.defaultBranch,
-            defaultProjectSlug: conventions.defaultProjectSlug,
-            extraRepoPaths: conventions.extraRepoPaths,
-            devHostname: conventions.devHostname,
-            portRangeStart: conventions.portRangeStart,
-            portRangeEnd: conventions.portRangeEnd,
-            readOnly: conventions.readOnly,
-            gitlabTokenEnvName: conventions.gitlabTokenEnvName
-          },
-          peers: this.deps.peers,
-          turn_taking_limit: this.deps.botConfig?.turn_taking_limit,
-          botName: this.deps.botConfig?.name,
-          backend: this.deps.botConfig?.backend,
-          agentMemory: this.deps.agentMemory,
-          larkCliProfile: this.deps.larkCliProfile,
-          runtimeWarnings: this.runtimeWarnings()
-        });
-        const backend = this.deps.botConfig?.backend ?? "claude";
-        const permissionMode = this.deps.permissionMode ?? (isAgentWorkspace ? "acceptEdits" : "bypassPermissions");
-        const timeoutMs = this.deps.subprocessTimeoutMs ?? 60 * 60 * 1e3;
-        const handle = createRunner(backend).run({
-          prompt,
-          resumeSessionId: currentExisting?.sessionId,
-          permissionMode,
-          timeoutMs,
-          cwd: runCwd,
-          // V2: inject per-bot git identity; absent in V1 → runner.ts uses "larkway-bot" fallback
-          botGitIdentity: this.deps.botConfig?.git_identity,
-          gitlabToken: this.deps.gitlabToken
-        });
-        let sessionId;
-        let lastText = "";
-        try {
-          for await (const ev of handle.events) {
-            if (card) card.handle(ev);
-            if (ev.type === "system_init") {
-              sessionId = ev.sessionId;
-            }
-            if (ev.type === "text_delta") {
-              lastText = ev.text;
-            }
-          }
-          const result = await handle.done;
-          const rawReportedState = await readStateFile(worktreePath);
-          const reportedState = rawReportedState?.updated_at != null && rawReportedState.updated_at !== preRunUpdatedAt ? rawReportedState : null;
-          const now = Date.now();
-          if (sessionId !== void 0 && currentExisting === void 0) {
-            await this.deps.sessionStore.put({
-              threadId,
-              sessionId,
-              botId,
-              createdTs: now,
-              lastActiveTs: now,
-              senderOpenId
-            });
-          } else if (sessionId !== void 0 && currentExisting !== void 0) {
-            await this.deps.sessionStore.put({
+          console.warn("[bridge.handler] ensureStateFile failed (continuing):", err);
+        }
+        if (card) {
+          try {
+            await writeCardFile(worktreePath, {
+              messageId: card.messageId,
+              chatId: parsed.chatId,
               threadId,
-              sessionId,
-              botId,
-              createdTs: currentExisting.createdTs,
-              lastActiveTs: now,
-              senderOpenId
-            });
-          } else if (currentExisting !== void 0 && sessionId === void 0) {
-            await this.deps.sessionStore.put({
-              ...currentExisting,
-              lastActiveTs: now
+              botId: this.deps.botConfig?.id ?? "",
+              replyInThread,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
             });
+          } catch (err) {
+            console.warn("[bridge.handler] writeCardFile failed (continuing):", err);
           }
-          if (card) {
-            const reportedStatus = reportedState?.status;
-            const reportedError = reportedState?.error;
-            let success;
-            let failureReason;
-            if (reportedStatus === "failed") {
-              success = false;
-              failureReason = reportedError ?? "bot \u62A5\u544A failed (\u65E0 error \u5B57\u6BB5)";
-            } else if (reportedStatus === "ready") {
-              success = true;
-            } else if (result.exitCode === 0) {
-              success = true;
-            } else {
-              success = false;
-              failureReason = `claude exited ${result.exitCode} \u4E14 bot \u672A\u66F4\u65B0 state.json status \u2014 \u53EF\u80FD\u5D29\u6E83`;
-            }
-            const cardBody = reportedState?.last_message ?? (lastText.trim() ? lastText : "\u26A0\uFE0F \u672C\u8F6E\u6CA1\u6709\u62FF\u5230 agent \u7684\u65B0\u56DE\u590D(\u53EF\u80FD\u88AB\u4E2D\u65AD\u6216\u672A\u66F4\u65B0\u72B6\u6001),\u518D @ \u6211\u4E00\u6B21\u91CD\u8BD5\u3002");
-            const noReportThisTurn = reportedState === null;
-            const neutralTitle = noReportThisTurn && success && !failureReason ? "\u{1F4AC} \u5DF2\u56DE\u590D" : void 0;
-            await card.finalize({
-              finalText: cardBody,
-              success,
-              failureReason,
-              titleOverride: reportedState?.card_title ?? neutralTitle,
-              colorOverride: reportedState?.card_color ?? (neutralTitle ? "neutral" : void 0),
-              // V2 dynamic-choice buttons — agent-declared, rendered verbatim.
-              // reportedState is null when state.json wasn't freshly written
-              // (stale-guard), so stale leftover choices never reappear.
-              choices: reportedState?.choices,
-              choicePrompt: reportedState?.choice_prompt
-            });
-            await deleteCardFile(worktreePath);
+        }
+        if (buildWorktree) {
+          try {
+            await ensureNodeModules(worktreePath);
+          } catch (err) {
+            console.warn("[bridge.handler] ensureNodeModules failed (continuing):", err);
           }
-          this.deps.client.acknowledgeMessage(messageId);
-          await recordEvent({
-            status: "completed",
-            finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            durationMs: Date.now() - eventStartedAt,
-            appendPath: "\u5DF2\u5B8C\u6210",
-            reason: "Agent \u5DF2\u7ED3\u675F\uFF0C\u6D88\u606F\u5DF2\u786E\u8BA4\u3002"
+        }
+        const preRunUpdatedAt = (await readStateFile(worktreePath))?.updated_at;
+        let currentExisting = existing;
+        let attempt = 0;
+        while (true) {
+          attempt++;
+          const currentIsNewThread = currentExisting === void 0;
+          const prompt = renderPrompt({
+            parsed,
+            isNewThread: currentIsNewThread,
+            conventions: {
+              worktreePath,
+              runtime: conventions.runtime,
+              agentWorkspacePath: conventions.agentWorkspacePath,
+              workspaceSessionPath: isAgentWorkspace ? worktreePath : void 0,
+              workspaceReposPath: conventions.workspaceReposPath,
+              stateFilePath: stateFilePathOf(worktreePath),
+              repoCachePath: conventions.repoCachePath,
+              primaryRepoUrl: conventions.primaryRepoUrl,
+              defaultBranch: conventions.defaultBranch,
+              defaultProjectSlug: conventions.defaultProjectSlug,
+              extraRepoPaths: conventions.extraRepoPaths,
+              devHostname: conventions.devHostname,
+              portRangeStart: conventions.portRangeStart,
+              portRangeEnd: conventions.portRangeEnd,
+              readOnly: conventions.readOnly,
+              gitlabTokenEnvName: conventions.gitlabTokenEnvName
+            },
+            peers: this.deps.peers,
+            turn_taking_limit: this.deps.botConfig?.turn_taking_limit,
+            botName: this.deps.botConfig?.name,
+            backend: this.deps.botConfig?.backend,
+            agentMemory: this.deps.agentMemory,
+            larkCliProfile: this.deps.larkCliProfile,
+            runtimeWarnings: this.runtimeWarnings()
           });
-          break;
-        } catch (spawnErr) {
-          const errMsg = String(spawnErr.message ?? spawnErr);
-          if (attempt === 1 && currentExisting != null && errMsg.includes("No conversation found")) {
-            console.warn(
-              `[bridge.handler] stale session ${currentExisting.sessionId} for thread ${threadId} \u2014 removing and retrying without --resume`
-            );
-            await this.deps.sessionStore.delete(threadId, botId);
-            currentExisting = void 0;
-            continue;
+          const backend = this.deps.botConfig?.backend ?? "claude";
+          const permissionMode = this.deps.permissionMode ?? (isAgentWorkspace ? "acceptEdits" : "bypassPermissions");
+          const timeoutMs = this.deps.subprocessTimeoutMs ?? 60 * 60 * 1e3;
+          const handle = createRunner(backend).run({
+            prompt,
+            resumeSessionId: currentExisting?.sessionId,
+            permissionMode,
+            timeoutMs,
+            cwd: runCwd,
+            // V2: inject per-bot git identity; absent in V1 → runner.ts uses "larkway-bot" fallback
+            botGitIdentity: this.deps.botConfig?.git_identity,
+            gitlabToken: this.deps.gitlabToken
+          });
+          let sessionId;
+          let lastText = "";
+          try {
+            for await (const ev of handle.events) {
+              if (card) card.handle(ev);
+              if (ev.type === "system_init") {
+                sessionId = ev.sessionId;
+              }
+              if (ev.type === "text_delta") {
+                lastText = ev.text;
+              }
+            }
+            const result = await handle.done;
+            const rawReportedState = await readStateFile(worktreePath);
+            const reportedState = rawReportedState?.updated_at != null && rawReportedState.updated_at !== preRunUpdatedAt ? rawReportedState : null;
+            const now = Date.now();
+            if (sessionId !== void 0 && currentExisting === void 0) {
+              await this.deps.sessionStore.put({
+                threadId,
+                sessionId,
+                botId,
+                createdTs: now,
+                lastActiveTs: now,
+                senderOpenId
+              });
+            } else if (sessionId !== void 0 && currentExisting !== void 0) {
+              await this.deps.sessionStore.put({
+                threadId,
+                sessionId,
+                botId,
+                createdTs: currentExisting.createdTs,
+                lastActiveTs: now,
+                senderOpenId
+              });
+            } else if (currentExisting !== void 0 && sessionId === void 0) {
+              await this.deps.sessionStore.put({
+                ...currentExisting,
+                lastActiveTs: now
+              });
+            }
+            if (card) {
+              const reportedStatus = reportedState?.status;
+              const reportedError = reportedState?.error;
+              let success;
+              let failureReason;
+              if (reportedStatus === "failed") {
+                success = false;
+                failureReason = reportedError ?? "bot \u62A5\u544A failed (\u65E0 error \u5B57\u6BB5)";
+              } else if (reportedStatus === "ready") {
+                success = true;
+              } else if (result.exitCode === 0) {
+                success = true;
+              } else {
+                success = false;
+                failureReason = `claude exited ${result.exitCode} \u4E14 bot \u672A\u66F4\u65B0 state.json status \u2014 \u53EF\u80FD\u5D29\u6E83`;
+              }
+              const cardBody = reportedState?.last_message ?? (lastText.trim() ? lastText : "\u26A0\uFE0F \u672C\u8F6E\u6CA1\u6709\u62FF\u5230 agent \u7684\u65B0\u56DE\u590D(\u53EF\u80FD\u88AB\u4E2D\u65AD\u6216\u672A\u66F4\u65B0\u72B6\u6001),\u518D @ \u6211\u4E00\u6B21\u91CD\u8BD5\u3002");
+              const noReportThisTurn = reportedState === null;
+              const neutralTitle = noReportThisTurn && success && !failureReason ? "\u{1F4AC} \u5DF2\u56DE\u590D" : void 0;
+              await card.finalize({
+                finalText: cardBody,
+                success,
+                failureReason,
+                titleOverride: reportedState?.card_title ?? neutralTitle,
+                colorOverride: reportedState?.card_color ?? (neutralTitle ? "neutral" : void 0),
+                // V2 dynamic-choice buttons — agent-declared, rendered verbatim.
+                // reportedState is null when state.json wasn't freshly written
+                // (stale-guard), so stale leftover choices never reappear.
+                choices: reportedState?.choices,
+                choicePrompt: reportedState?.choice_prompt
+              });
+              await deleteCardFile(worktreePath);
+            }
+            settle(true);
+            await recordEvent({
+              status: "completed",
+              finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              durationMs: Date.now() - eventStartedAt,
+              appendPath: "\u5DF2\u5B8C\u6210",
+              reason: "Agent \u5DF2\u7ED3\u675F\uFF0C\u6D88\u606F\u5DF2\u786E\u8BA4\u3002"
+            });
+            break;
+          } catch (spawnErr) {
+            const errMsg = String(spawnErr.message ?? spawnErr);
+            if (attempt === 1 && currentExisting != null && errMsg.includes("No conversation found")) {
+              console.warn(
+                `[bridge.handler] stale session ${currentExisting.sessionId} for thread ${threadId} \u2014 removing and retrying without --resume`
+              );
+              await this.deps.sessionStore.delete(threadId, botId);
+              currentExisting = void 0;
+              continue;
+            }
+            throw spawnErr;
           }
-          throw spawnErr;
         }
-      }
-    } catch (err) {
-      console.error("[bridge.handler] handleOne failed for thread", threadId, err);
-      await this.deps.client.removeProcessingReaction?.(messageId);
-      await recordEvent({
-        status: "failed",
-        finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        durationMs: Date.now() - eventStartedAt,
-        appendPath: "\u5F02\u5E38",
-        reason: String(err)
-      });
-      this.deps.client.acknowledgeMessage(messageId);
-      if (card) {
-        try {
-          await card.finalize({
-            success: false,
-            failureReason: String(err)
-            // No choices on the hard-crash path: reportedState isn't in scope
-            // here, and a crashed turn offering pick-an-option buttons is wrong.
-          });
-        } catch (finalizeErr) {
-          console.error("[bridge.handler] finalize(failure) also failed:", finalizeErr);
+      } catch (err) {
+        console.error("[bridge.handler] handleOne failed for thread", threadId, err);
+        await this.deps.client.removeProcessingReaction?.(messageId);
+        await recordEvent({
+          status: "failed",
+          finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: Date.now() - eventStartedAt,
+          appendPath: "\u5F02\u5E38",
+          reason: String(err)
+        });
+        settle(false);
+        if (card) {
+          try {
+            await card.finalize({
+              success: false,
+              failureReason: String(err)
+              // No choices on the hard-crash path: reportedState isn't in scope
+              // here, and a crashed turn offering pick-an-option buttons is wrong.
+            });
+          } catch (finalizeErr) {
+            console.error("[bridge.handler] finalize(failure) also failed:", finalizeErr);
+          }
+          const wtPath = this.deps.conventions.runtime === "agent_workspace" && this.deps.conventions.workspaceSessionsDir ? path8.join(this.deps.conventions.workspaceSessionsDir, threadId) : path8.join(this.deps.conventions.worktreesDir, threadId);
+          await deleteCardFile(wtPath);
         }
-        const wtPath = this.deps.conventions.runtime === "agent_workspace" && this.deps.conventions.workspaceSessionsDir ? path8.join(this.deps.conventions.workspaceSessionsDir, threadId) : path8.join(this.deps.conventions.worktreesDir, threadId);
-        await deleteCardFile(wtPath);
       }
+    } finally {
+      settle(false);
     }
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larkway",
-  "version": "0.3.13",
+  "version": "0.3.14",
   "description": "Thin bridge: Feishu thread to local Claude Code CLI",
   "license": "MIT",
   "author": "Chuck Wu (chuckwu0)",