eve-lark 0.4.5 → 0.5.0

package/dist/index.js

@@ -107,22 +107,24 @@ var LarkClient = class {
   }
   async sendText(args) {
     const content = JSON.stringify({ text: args.content });
+    if (args.rootId) {
+      return this.#replyMessage(args.rootId, "text", content);
+    }
     return this.#sendMessage({
       receive_id: args.chatId,
       msg_type: "text",
-      content,
-      root_id: args.rootId,
-      parent_id: args.parentId
+      content
     });
   }
   async sendCard(args) {
     const content = JSON.stringify(args.card);
+    if (args.rootId) {
+      return this.#replyMessage(args.rootId, "interactive", content);
+    }
     return this.#sendMessage({
       receive_id: args.chatId,
       msg_type: "interactive",
-      content,
-      root_id: args.rootId,
-      parent_id: args.parentId
+      content
     });
   }
   async sendPost(args) {
@@ -131,14 +133,31 @@ var LarkClient = class {
         content: [[{ tag: "md", text: args.content }]]
       }
     };
+    const content = JSON.stringify(post);
+    if (args.rootId) {
+      return this.#replyMessage(args.rootId, "post", content);
+    }
     return this.#sendMessage({
       receive_id: args.chatId,
       msg_type: "post",
-      content: JSON.stringify(post),
-      root_id: args.rootId,
-      parent_id: args.parentId
+      content
     });
   }
+  /** Quote-reply to a specific message via Feishu's reply API.
+   *  POST /open-apis/im/v1/messages/{message_id}/reply — this is the only
+   *  way to quote-reply to a normal (non-thread) message; sendMessage's
+   *  root_id field only works inside threads. */
+  async #replyMessage(replyToMessageId, msgType, content) {
+    const path = `/open-apis/im/v1/messages/${encodeURIComponent(replyToMessageId)}/reply`;
+    const json = await this.#request("POST", path, { msg_type: msgType, content });
+    const messageId = json.data?.message_id;
+    if (!messageId) {
+      throw new LarkApiError("eve-lark: reply missing message_id in response", {
+        body: json
+      });
+    }
+    return { messageId };
+  }
   async #sendMessage(body) {
     const payload = Object.fromEntries(
       Object.entries(body).filter(([, v]) => v !== void 0)
@@ -885,6 +904,16 @@ var StreamingCardController = class {
   getMessageId() {
     return this.messageId;
   }
+  /** Aim the next card we create at this user message (quote-reply). Used
+   *  when messages interleave so the user can tell which reply answers which
+   *  message. Must be called before the first sendCard (i.e. in the webhook
+   *  handler right after helpers.send, before any streaming delta).
+   *
+   *  Sets rootId (not parentId) because Feishu's sendMessage API uses root_id
+   *  for quote-reply; parent_id is ignored. */
+  setReplyTarget(messageId) {
+    this.deps.rootId = messageId;
+  }
   /** Active HITL request being rendered inline on this card, or null. */
   getAskRequest() {
     return this.askRequest;
@@ -946,10 +975,11 @@ var StreamingCardController = class {
    * patch the first card — the user would only see the latest reply
    * overwritten onto one card instead of N independent cards.
    */
-  resetForNewMessage() {
+  resetForNewMessage(replyTargetMessageId) {
     this.resetForNewTurn();
     this.messageId = void 0;
     this.state = "idle";
+    if (replyTargetMessageId) this.deps.rootId = replyTargetMessageId;
   }
   async finalize(fullText) {
     if (this.state === "completed" || this.state === "aborted") return;
@@ -1032,9 +1062,10 @@ var StreamingCardController = class {
   scheduleCreate() {
     if (this.createTimer) return;
     this.state = "creating";
+    const rootIdSnapshot = this.deps.rootId;
     this.createTimer = setTimeout(() => {
       this.createTimer = null;
-      void this.doCreate();
+      void this.doCreate(rootIdSnapshot);
     }, this.deps.createThresholdMs);
   }
   cancelCreateTimer() {
@@ -1043,13 +1074,13 @@ var StreamingCardController = class {
       this.createTimer = null;
     }
   }
-  async doCreate() {
+  async doCreate(rootIdSnapshot) {
     if (this.state !== "creating") return;
     try {
       const res = await this.client.sendCard({
         chatId: this.deps.chatId,
         card: this.deps.useCardKitV2 ? buildCardKitStreamingCard({ buffer: this.buffer, status: this.status, streamingMode: true, toolCalls: this.toolCalls, askRequest: this.askRequest }) : buildStreamingCard({ buffer: this.buffer, status: this.status, toolCalls: this.toolCalls, askRequest: this.askRequest }),
-        rootId: this.deps.rootId,
+        rootId: rootIdSnapshot ?? this.deps.rootId,
         parentId: this.deps.parentId
       });
       this.messageId = res.messageId;
@@ -1104,12 +1135,11 @@ var StreamingCardController = class {
 var DEFAULTS = {
   baseUrl: "https://open.feishu.cn",
   webhookPath: "/lark/webhook",
-  // "post" renders at native chat-message size with full markdown support
-  // (bold, links, code, color tags). Cards render noticeably smaller because
-  // Feishu treats them as "structured content". The tradeoff: post can't be
-  // live-patched during streaming — users who want streaming should set
-  // replyMode: "streaming" explicitly.
-  replyMode: "post",
+  // "streaming-v2" uses Feishu CardKit v2 (schema 2.0 + streaming_mode) for
+  // live-patched interactive cards — the best live UX this channel can offer
+  // today. Users who prefer native chat-message size (with markdown) at the
+  // cost of no streaming should opt into replyMode: "post".
+  replyMode: "streaming-v2",
   streamPatchIntervalMs: 1e3,
   streamCreateThresholdMs: 400,
   dedupTtlMs: 30 * 60 * 1e3,
@@ -1712,13 +1742,18 @@ function createLarkChannel(optionsInput) {
     console.log("[eve-lark] skipping WSClient start in eve-start launcher process; the spawned server will start it");
   }
   const controllers = /* @__PURE__ */ new Map();
+  const turnSources = /* @__PURE__ */ new Map();
+  const turnTouchedAt = /* @__PURE__ */ new Map();
   const sessionMeta = /* @__PURE__ */ new Map();
   const pendingInputsByRequestId = /* @__PURE__ */ new Map();
   const pendingInputsByChatToken = /* @__PURE__ */ new Map();
   const authCards = /* @__PURE__ */ new Map();
-  const expectFreshCard = /* @__PURE__ */ new Set();
-  function getController(sessionId, meta) {
-    let ctrl = controllers.get(sessionId);
+  const ackReactions = /* @__PURE__ */ new Map();
+  const currentInboundMsgIds = /* @__PURE__ */ new Map();
+  const lastChatMessage = /* @__PURE__ */ new Map();
+  const cleanedTurns = /* @__PURE__ */ new Set();
+  function getController(turnId, meta) {
+    let ctrl = controllers.get(turnId);
     if (!ctrl) {
       ctrl = new StreamingCardController(client, {
         chatId: meta.chatId,
@@ -1728,39 +1763,48 @@ function createLarkChannel(optionsInput) {
         createThresholdMs: options.streamCreateThresholdMs,
         useCardKitV2: options.replyMode === "streaming-v2"
       });
-      controllers.set(sessionId, ctrl);
-    }
-    if (sessionMeta.has(sessionId)) {
-      sessionMeta.get(sessionId).touchedAt = Date.now();
-    } else {
-      sessionMeta.set(sessionId, {
-        chatId: meta.chatId,
-        rootId: meta.rootId,
-        parentId: meta.parentId,
-        messageId: meta.messageId,
-        touchedAt: Date.now()
-      });
+      controllers.set(turnId, ctrl);
     }
+    turnTouchedAt.set(turnId, Date.now());
     return ctrl;
   }
   __name(getController, "getController");
-  async function cleanupAckReaction(sessionId) {
-    const meta = sessionMeta.get(sessionId);
-    if (!meta?.ackReactionId || !meta.messageId) return;
+  function dropTurn(turnId) {
+    controllers.delete(turnId);
+    turnSources.delete(turnId);
+    turnTouchedAt.delete(turnId);
+  }
+  __name(dropTurn, "dropTurn");
+  async function cleanupAckReaction(messageId) {
+    const ack = ackReactions.get(messageId);
+    if (!ack) return;
     try {
-      await client.removeReaction({
-        messageId: meta.messageId,
-        reactionId: meta.ackReactionId
-      });
+      await client.removeReaction({ messageId, reactionId: ack.reactionId });
     } catch (e) {
       console.warn(
         "[eve-lark] ack reaction cleanup failed:",
         e instanceof Error ? e.message : e
       );
     }
+    ackReactions.delete(messageId);
   }
   __name(cleanupAckReaction, "cleanupAckReaction");
-  async function deliverReply(sessionId, info, text) {
+  async function cleanupAckForSession(sessionId) {
+    const queue = currentInboundMsgIds.get(sessionId);
+    if (!queue || queue.length === 0) return;
+    const msgId = queue.shift();
+    if (!msgId) return;
+    if (queue.length === 0) currentInboundMsgIds.delete(sessionId);
+    await cleanupAckReaction(msgId);
+  }
+  __name(cleanupAckForSession, "cleanupAckForSession");
+  async function cleanupAckForTurn(turnId) {
+    const sourceMsgId = turnSources.get(turnId);
+    if (!sourceMsgId) return;
+    await cleanupAckReaction(sourceMsgId);
+  }
+  __name(cleanupAckForTurn, "cleanupAckForTurn");
+  async function deliverReply(turnId, info, text) {
     if (options.replyMode === "post") {
       try {
         await client.sendPost({
@@ -1769,11 +1813,11 @@ function createLarkChannel(optionsInput) {
           rootId: info.rootId,
           parentId: info.parentId
         });
-        console.log(`[eve-lark] delivered via sendPost (sessionId=${sessionId})`);
+        console.log(`[eve-lark] delivered via sendPost (turnId=${turnId ?? "?"})`);
         return;
       } catch (postErr) {
         console.warn(
-          `[eve-lark] sendPost failed; falling back to plain text (sessionId=${sessionId}):`,
+          `[eve-lark] sendPost failed; falling back to plain text (turnId=${turnId ?? "?"}):`,
           postErr instanceof Error ? postErr.message : postErr
         );
       }
@@ -1784,40 +1828,43 @@ function createLarkChannel(optionsInput) {
           rootId: info.rootId,
           parentId: info.parentId
         });
-        console.log(`[eve-lark] delivered via sendText fallback (sessionId=${sessionId})`);
+        console.log(`[eve-lark] delivered via sendText fallback (turnId=${turnId ?? "?"})`);
       } catch (textErr) {
         console.error(
-          `[eve-lark] sendText fallback ALSO failed; the user will not see this reply (sessionId=${sessionId}):`,
+          `[eve-lark] sendText fallback ALSO failed; the user will not see this reply (turnId=${turnId ?? "?"}):`,
           textErr instanceof Error ? textErr.message : textErr
         );
       }
       return;
     }
     if (options.replyMode === "streaming" || options.replyMode === "streaming-v2") {
-      const ctrl = controllers.get(sessionId) ?? getController(sessionId, info);
-      try {
-        await ctrl.finalize(text);
-        console.log(`[eve-lark] delivered via streaming finalize (sessionId=${sessionId})`);
-        return;
-      } catch (e) {
-        console.warn(
-          `[eve-lark] streaming finalize failed; falling back to fresh card (sessionId=${sessionId}):`,
-          e instanceof Error ? e.message : e
-        );
+      const ctrl = turnId ? controllers.get(turnId) : void 0;
+      if (ctrl) {
+        try {
+          await ctrl.finalize(text);
+          console.log(`[eve-lark] delivered via streaming finalize (turnId=${turnId})`);
+          return;
+        } catch (e) {
+          console.warn(
+            `[eve-lark] streaming finalize failed; falling back to fresh card (turnId=${turnId}):`,
+            e instanceof Error ? e.message : e
+          );
+        }
       }
     }
     try {
-      await client.sendCard({
+      const res = await client.sendCard({
         chatId: info.chatId,
         card: buildTextCard(text),
         rootId: info.rootId,
         parentId: info.parentId
       });
-      console.log(`[eve-lark] delivered via sendCard (sessionId=${sessionId})`);
+      console.log(`[eve-lark] delivered via sendCard (turnId=${turnId ?? "?"})`);
+      void res;
       return;
     } catch (cardErr) {
       console.warn(
-        `[eve-lark] sendCard failed; falling back to plain text (sessionId=${sessionId}):`,
+        `[eve-lark] sendCard failed; falling back to plain text (turnId=${turnId ?? "?"}):`,
         cardErr instanceof Error ? cardErr.message : cardErr
       );
     }
@@ -1828,10 +1875,10 @@ function createLarkChannel(optionsInput) {
         rootId: info.rootId,
         parentId: info.parentId
       });
-      console.log(`[eve-lark] delivered via sendText fallback (sessionId=${sessionId})`);
+      console.log(`[eve-lark] delivered via sendText fallback (turnId=${turnId ?? "?"})`);
     } catch (textErr) {
       console.error(
-        `[eve-lark] sendText fallback ALSO failed; the user will not see this reply (sessionId=${sessionId}):`,
+        `[eve-lark] sendText fallback ALSO failed; the user will not see this reply (turnId=${turnId ?? "?"}):`,
         textErr instanceof Error ? textErr.message : textErr
       );
     }
@@ -1843,9 +1890,13 @@ function createLarkChannel(optionsInput) {
     if (now - lastSweepAt < SWEEP_INTERVAL_MS) return;
     lastSweepAt = now;
     const cutoff = now - STALE_SESSION_MS;
+    for (const [turnId, touchedAt] of turnTouchedAt) {
+      if (touchedAt < cutoff) {
+        dropTurn(turnId);
+      }
+    }
     for (const [id, meta] of sessionMeta) {
       if (meta.touchedAt < cutoff) {
-        controllers.delete(id);
         sessionMeta.delete(id);
       }
     }
@@ -2070,21 +2121,22 @@ function createLarkChannel(optionsInput) {
     console.log(
       `[eve-lark] helpers.send returned sessionId=${session.id} for chatId=${parsed.chatId}`
     );
-    expectFreshCard.add(session.id);
+    const queue = currentInboundMsgIds.get(session.id);
+    if (queue) queue.push(parsed.messageId);
+    else currentInboundMsgIds.set(session.id, [parsed.messageId]);
+    lastChatMessage.set(session.id, parsed.messageId);
     sessionMeta.set(session.id, {
       chatId: parsed.chatId,
       rootId: parsed.rootId ?? void 0,
       parentId: parsed.parentId ?? void 0,
-      messageId: parsed.messageId,
       touchedAt: Date.now()
     });
     const emoji = pickAckEmoji(options.ackReaction);
     if (emoji) {
-      const sessionId = session.id;
+      const inboundMsgId = parsed.messageId;
       helpers.waitUntil(
-        client.addReaction({ messageId: parsed.messageId, emojiType: emoji }).then(({ reactionId }) => {
-          const m = sessionMeta.get(sessionId);
-          if (m) m.ackReactionId = reactionId;
+        client.addReaction({ messageId: inboundMsgId, emojiType: emoji }).then(({ reactionId }) => {
+          ackReactions.set(inboundMsgId, { reactionId, createdAt: Date.now() });
         }).catch((e) => {
           console.warn(
             "[eve-lark] ack reaction failed:",
@@ -2114,7 +2166,7 @@ function createLarkChannel(optionsInput) {
     helpers.waitUntil(
       (async () => {
         if (pending.cardMessageId && selectedOpt) {
-          const ctrlForBuffer = controllers.get(pending.sessionId);
+          const ctrlForBuffer = controllers.get(pending.turnId);
           const priorBuffer = ctrlForBuffer?.getBuffer() ?? void 0;
           try {
             await client.patchCard({
@@ -2180,9 +2232,16 @@ function createLarkChannel(optionsInput) {
       const sessionId = ctx.session.id;
       const info = sessionInfoFromCtx(ctx);
       if (!info) return;
+      const turnId = data?.turnId;
+      if (!turnId) return;
       const d = data;
       if (typeof d.messageDelta !== "string") return;
-      const ctrl = getController(sessionId, info);
+      const ctrl = getController(turnId, info);
+      const source = turnSources.get(turnId);
+      if (source) {
+        console.log(`[eve-lark] quote-reply turnId=${turnId} sessionId=${sessionId} \u2192 REPLY ${source}`);
+        ctrl.setReplyTarget(source);
+      }
       ctrl.appendDelta(d.messageDelta);
     },
     // Model is about to call tools. Record each call on the streaming
@@ -2194,13 +2253,14 @@ function createLarkChannel(optionsInput) {
     // surface to update.
     async "actions.requested"(data, _channel, ctx) {
       if (options.replyMode !== "streaming" && options.replyMode !== "streaming-v2") return;
-      const sessionId = ctx.session.id;
       const info = sessionInfoFromCtx(ctx);
       if (!info) return;
+      const turnId = data?.turnId;
+      if (!turnId) return;
       const d = data;
       const names = (d.actions ?? []).map((a) => a.toolName).filter((n) => typeof n === "string");
       if (names.length === 0) return;
-      const ctrl = getController(sessionId, info);
+      const ctrl = getController(turnId, info);
       for (const name of names) {
         ctrl.addToolCall(name);
       }
@@ -2209,10 +2269,11 @@ function createLarkChannel(optionsInput) {
     // the user keeps the tool history at the top of the card through end
     // of turn. Best-effort: if we can't find the controller (e.g. post
     // mode, or session already cleaned up), no-op.
-    async "action.result"(data, _channel, ctx) {
+    async "action.result"(data, _channel, _ctx) {
       if (options.replyMode !== "streaming" && options.replyMode !== "streaming-v2") return;
-      const sessionId = ctx.session.id;
-      const ctrl = controllers.get(sessionId);
+      const turnId = data?.turnId;
+      if (!turnId) return;
+      const ctrl = controllers.get(turnId);
       if (!ctrl) return;
       const d = data;
       const name = d.result?.toolName;
@@ -2229,14 +2290,19 @@ function createLarkChannel(optionsInput) {
         console.warn(`[eve-lark] input.requested: no session info (sessionId=${sessionId})`);
         return;
       }
+      const turnId = data?.turnId;
+      if (!turnId) {
+        console.warn(`[eve-lark] input.requested: no turnId (sessionId=${sessionId})`);
+        return;
+      }
       const d = data;
       const requests = d.requests ?? [];
       if (requests.length === 0) return;
       console.log(
-        `[eve-lark] input.requested sessionId=${sessionId} chatId=${info.chatId} count=${requests.length}`
+        `[eve-lark] input.requested sessionId=${sessionId} turnId=${turnId} chatId=${info.chatId} count=${requests.length}`
       );
       for (const req of requests) {
-        const existingCtrl = controllers.get(sessionId);
+        const existingCtrl = controllers.get(turnId);
         const canPatchExisting = existingCtrl && existingCtrl.getMessageId() && (options.replyMode === "streaming" || options.replyMode === "streaming-v2");
         let cardMessageId;
         if (canPatchExisting && existingCtrl) {
@@ -2263,6 +2329,7 @@ function createLarkChannel(optionsInput) {
         const pending = {
           requestId: req.requestId,
           sessionId,
+          turnId,
           chatId: info.chatId,
           rootId: info.rootId,
           parentId: info.parentId,
@@ -2280,6 +2347,13 @@ function createLarkChannel(optionsInput) {
       }
     },
     // Terminal — deliver the final reply, then clean up the ack reaction.
+    // The per-turn controller is NOT destroyed here: in HITL flows eve fires
+    // input.requested AFTER message.completed (still in the same turn), and
+    // that handler needs the controller to patch the streaming card with the
+    // ask UI inline. The controller is torn down by turn.completed (the true
+    // end of turn). Duplicate message.completed events on the same turn are
+    // deduped by the controller's finalize() state guard (state→completed on
+    // first call, no-op thereafter).
     async "message.completed"(data, _channel, ctx) {
       const sessionId = ctx.session.id;
       const info = sessionInfoFromCtx(ctx);
@@ -2289,14 +2363,28 @@ function createLarkChannel(optionsInput) {
       }
       const d = data;
       const rawText = typeof d.message === "string" ? d.message : "";
+      const mcTurnId = data?.turnId;
       console.log(
-        `[eve-lark] message.completed sessionId=${sessionId} chatId=${info.chatId} msgLen=${rawText.length}`
+        `[eve-lark] message.completed sessionId=${sessionId} chatId=${info.chatId} msgLen=${rawText.length}` + (mcTurnId ? ` turnId=${mcTurnId}` : "")
       );
       const text = rawText.length > 0 ? rawText : EMPTY_REPLY_TEXT;
+      const isStreaming = options.replyMode === "streaming" || options.replyMode === "streaming-v2";
+      if (isStreaming && mcTurnId && !controllers.has(mcTurnId)) {
+        if (!cleanedTurns.has(mcTurnId)) {
+          cleanedTurns.add(mcTurnId);
+          await cleanupAckForTurn(mcTurnId);
+        }
+        return;
+      }
       try {
-        await deliverReply(sessionId, info, text);
+        await deliverReply(mcTurnId, info, text);
       } finally {
-        await cleanupAckReaction(sessionId);
+        if (mcTurnId && !cleanedTurns.has(mcTurnId)) {
+          cleanedTurns.add(mcTurnId);
+          await cleanupAckForTurn(mcTurnId);
+        } else if (!mcTurnId) {
+          await cleanupAckForSession(sessionId);
+        }
       }
     },
     async "turn.failed"(data, _channel, ctx) {
@@ -2310,33 +2398,39 @@ function createLarkChannel(optionsInput) {
         console.warn(`[eve-lark] turn.failed: no session info (sessionId=${sessionId})`);
         return;
       }
+      const failedTurnId = data?.turnId;
       const userText = formatFailureMessage(data, "turn failed", { sentence: "turn" });
       const errorId = extractErrorId(data?.details);
       console.warn(
-        `[eve-lark] turn.failed sessionId=${sessionId} chatId=${info.chatId} err="${userText.slice(0, 200)}"` + (errorId ? ` errorId=${errorId}` : "")
+        `[eve-lark] turn.failed sessionId=${sessionId} chatId=${info.chatId} err="${userText.slice(0, 200)}"` + (failedTurnId ? ` turnId=${failedTurnId}` : "") + (errorId ? ` errorId=${errorId}` : "")
       );
-      const ctrl = controllers.get(sessionId);
+      const ctrl = failedTurnId ? controllers.get(failedTurnId) : void 0;
       if (ctrl) {
         try {
           await ctrl.abort(userText);
-          console.log(`[eve-lark] error shown via streaming abort (sessionId=${sessionId})`);
+          console.log(`[eve-lark] error shown via streaming abort (turnId=${failedTurnId})`);
         } catch (e) {
           console.warn(
-            `[eve-lark] turn.failed: streaming abort failed, will deliver fresh error (sessionId=${sessionId}):`,
+            `[eve-lark] turn.failed: streaming abort failed, will deliver fresh error (turnId=${failedTurnId}):`,
             e instanceof Error ? e.message : e
           );
           try {
-            await deliverReply(sessionId, info, userText);
+            await deliverReply(failedTurnId, info, userText);
           } catch {
           }
         }
       } else {
         try {
-          await deliverReply(sessionId, info, userText);
+          await deliverReply(failedTurnId, info, userText);
         } catch {
         }
       }
-      await cleanupAckReaction(sessionId);
+      if (!failedTurnId || !cleanedTurns.has(failedTurnId)) {
+        if (failedTurnId) cleanedTurns.add(failedTurnId);
+        if (failedTurnId) await cleanupAckForTurn(failedTurnId);
+        else await cleanupAckForSession(sessionId);
+      }
+      if (failedTurnId) dropTurn(failedTurnId);
     },
     async "session.failed"(data) {
       const userText = formatFailureMessage(data, "session failed", { sentence: "session" });
@@ -2345,36 +2439,44 @@ function createLarkChannel(optionsInput) {
         `[eve-lark] session.failed: ${userText}` + (errorId ? ` (errorId=${errorId})` : "")
       );
     },
-    // A new turn is starting within an existing session. Two cases:
-    //
-    //   1. NEW inbound message (the webhook handler set `expectFreshCard`):
-    //      force a fresh card so each user message gets its own reply card.
-    //   2. Continuation (HITL answer via button click / freeform, or tool
-    //      resume): keep the same card so the whole flow stays on one card.
+    // A new turn is starting. Per-turn controllers mean we no longer reset
+    // existing controllers here — each turn gets a fresh one (created lazily
+    // in message.appended / actions.requested). The only side effect left is
+    // mapping turnId → inbound source message: shift the head of the
+    // session's FIFO (populated by the webhook handler) so message.appended
+    // can aim this turn's card at the right user message and terminal events
+    // can clean up the right ack reaction.
     async "turn.started"(_data, _channel, ctx) {
       const sessionId = ctx?.session?.id;
       if (!sessionId) return;
-      const ctrl = controllers.get(sessionId);
-      if (ctrl) {
-        if (expectFreshCard.has(sessionId)) {
-          ctrl.resetForNewMessage();
-          expectFreshCard.delete(sessionId);
-        } else {
-          ctrl.resetForNewTurn();
-        }
+      const tsTurnId = _data?.turnId;
+      console.log(`[eve-lark] turn.started sessionId=${sessionId}` + (tsTurnId ? ` turnId=${tsTurnId}` : ""));
+      if (!tsTurnId) return;
+      const queue = currentInboundMsgIds.get(sessionId);
+      if (queue && queue.length > 0) {
+        const source = queue.shift();
+        if (queue.length === 0) currentInboundMsgIds.delete(sessionId);
+        turnSources.set(tsTurnId, source);
       }
     },
     // Turn ended cleanly. eve fires this after the final message.completed
     // (or instead of it when the assistant step ended in tool-calls with no
-    // visible text). Just clean up the ack reaction — the controller stays
-    // for the next turn (cleaned by stale-sweep if the session goes quiet).
-    async "turn.completed"(data, _channel, ctx) {
-      const sessionId = ctx?.session?.id;
-      if (!sessionId) return;
+    // visible text). Clean up the ack reaction and destroy the per-turn
+    // controller (idempotent — message.completed/turn.failed may have done
+    // it already).
+    async "turn.completed"(data, _channel, _ctx) {
+      const turnId = data?.turnId;
+      if (!turnId) return;
+      if (cleanedTurns.has(turnId)) {
+        dropTurn(turnId);
+        return;
+      }
+      cleanedTurns.add(turnId);
       try {
-        await cleanupAckReaction(sessionId);
+        await cleanupAckForTurn(turnId);
       } catch {
       }
+      dropTurn(turnId);
     },
     // The agent needs the user to sign in to an external service (e.g.
     // GitHub, Slack, Linear). Render a card with a "Sign in with <X>"