@ycodium-ai/plugin-im 0.2.3216 → 0.2.3220

package/dist/index.js

@@ -126258,67 +126258,96 @@ var keepNewest = (record4, limit) => {
   return entries.length <= limit ? record4 : Object.fromEntries(entries.slice(entries.length - limit));
 };
 
-// src/boundedMap.ts
-var makeBoundedMap = (limit) => {
-  const entries = /* @__PURE__ */ new Map();
-  return {
-    get: (key) => entries.get(key),
-    set: (key, value2) => {
-      entries.delete(key);
-      entries.set(key, value2);
-      if (entries.size > limit) {
-        const oldest = entries.keys().next().value;
-        if (oldest !== void 0) entries.delete(oldest);
-      }
-    },
-    /** 忘掉键满足条件的那些。 */
-    forget: (matches) => {
-      for (const key of [...entries.keys()]) if (matches(key)) entries.delete(key);
+// src/executionTurn.ts
+var indexExecution = (execution) => {
+  const intentsByMessageId = /* @__PURE__ */ new Map();
+  const intentsById = /* @__PURE__ */ new Map();
+  const turnsById = /* @__PURE__ */ new Map();
+  for (const intent of execution.turnIntents) {
+    if (!intentsByMessageId.has(intent.messageId)) intentsByMessageId.set(intent.messageId, intent);
+    if (!intentsById.has(intent.intentId)) intentsById.set(intent.intentId, intent);
+    if (intent.turn?.turnId != null && !turnsById.has(intent.turn.turnId)) {
+      turnsById.set(intent.turn.turnId, intent.turn);
     }
-  };
+  }
+  if (execution.latestTurn != null && !turnsById.has(execution.latestTurn.turnId)) {
+    turnsById.set(execution.latestTurn.turnId, execution.latestTurn);
+  }
+  return { execution, intentsByMessageId, intentsById, turnsById };
 };
+var executionTurnFor = (snapshot, turnId) => snapshot.turnsById.get(turnId);
 
-// src/replyAnchors.ts
-var THREAD_LIMIT = 256;
-var TURNS_PER_THREAD = 16;
-var anchorOfMessage = (adapter, message) => adapter?.quotesReplies === true ? { messageId: message.messageId, inThread: message.replyInThread === true } : void 0;
-var userMessageIdOfTurn = (execution, turnId) => {
-  const intent = execution.turnIntents.find((candidate) => candidate.turn?.turnId === turnId);
-  const latest = execution.latestTurn;
-  return intent?.messageId ?? (latest?.turnId === turnId ? latest.userMessageId : void 0);
+// src/intentStatus.ts
+var isLiveIntentStatus = (status) => status === "queued" || status === "preparing" || status === "dispatching" || status === "running" || status === "reconciling" || status === "blocked";
+
+// src/conclusionTurn.ts
+var conclusionOf = (turn) => turn.state === "completed" || turn.state === "interrupted" || turn.state === "error" ? { kind: "settled", ...turn, state: turn.state } : { kind: "pending" };
+var conclusionTurnFor = (snapshot, userMessageId) => {
+  const { execution } = snapshot;
+  const initial = snapshot.intentsByMessageId.get(userMessageId);
+  if (initial === void 0) {
+    const latest = execution.latestTurn;
+    return latest?.userMessageId === userMessageId ? conclusionOf(latest) : { kind: "gone" };
+  }
+  let intent = initial;
+  const visited = /* @__PURE__ */ new Set();
+  while (intent.status === "cancelled" || intent.status === "abandoned") {
+    if (visited.has(intent.intentId)) return { kind: "gone" };
+    visited.add(intent.intentId);
+    const replacementId = intent.replacementIntentId;
+    const replacement = replacementId == null ? void 0 : snapshot.intentsById.get(replacementId);
+    if (replacement === void 0) return { kind: "gone" };
+    intent = replacement;
+  }
+  const action = intent.action;
+  const turn = intent.turn;
+  if (action?.kind === "steer" && intent.deliveredTurnId === action.turnId) {
+    return {
+      kind: "merged",
+      turnId: action.turnId,
+      turn: executionTurnFor(snapshot, action.turnId)
+    };
+  }
+  if (turn !== null) return conclusionOf(turn);
+  if (action?.kind === "steer") return { kind: "pending" };
+  return { kind: isLiveIntentStatus(intent.status) ? "pending" : "gone" };
 };
-var makeReplyAnchors = (host) => {
-  const byThread = makeBoundedMap(THREAD_LIMIT);
-  const userMessageOfTurn = async (threadId, turnId) => {
-    const execution = await host.projections.getThreadExecution(threadId).catch(() => null);
-    if (execution === null) return void 0;
-    const wanted = turnId ?? execution.session?.activeTurnId ?? execution.latestTurn?.turnId;
-    return wanted == null ? void 0 : userMessageIdOfTurn(execution, wanted);
-  };
+var groupConclusionDebts = (snapshot, threadId, debts) => {
+  const resolved = new Map(
+    debts.filter((debt) => debt.threadId === threadId).map((debt) => [
+      debt.userMessageId,
+      { debt, result: conclusionTurnFor(snapshot, debt.userMessageId) }
+    ])
+  );
+  const byTurn = /* @__PURE__ */ new Map();
+  for (const { debt, result: result2 } of resolved.values()) {
+    if (result2.kind !== "settled" && result2.kind !== "merged") continue;
+    const group = byTurn.get(result2.turnId) ?? [];
+    group.push(debt);
+    byTurn.set(result2.turnId, group);
+  }
+  for (const [turnId, candidates] of byTurn) {
+    const ownerId = turnId === null ? void 0 : executionTurnFor(snapshot, turnId)?.userMessageId;
+    const owner = ownerId === void 0 ? void 0 : resolved.get(ownerId);
+    if (owner !== void 0 && owner.result.kind !== "gone" && !candidates.includes(owner.debt))
+      candidates.push(owner.debt);
+  }
+  return { resolved, byTurn };
+};
+var conclusionDebtForTurn = (snapshot, turnId, candidates, isDelivered) => {
+  const turn = turnId === null ? void 0 : executionTurnFor(snapshot, turnId);
+  const own = candidates.find((debt2) => debt2.userMessageId === turn?.userMessageId);
+  const handled = turn?.userMessageId !== void 0 && isDelivered(turn.userMessageId) || candidates.length === 0 && snapshot.execution.turnIntents.some((intent) => {
+    if (!isDelivered(intent.messageId)) return false;
+    const result2 = conclusionTurnFor(snapshot, intent.messageId);
+    return (result2.kind === "merged" || result2.kind === "settled") && result2.turnId === turnId;
+  });
+  const debt = handled ? void 0 : own ?? candidates[0];
   return {
-    /**
-     * 开轮时记一笔：`userMessageId` 是派给宿主的那条用户消息，`binding` 是收到聊天消息的那个
-     * 聊天（带着它的锚点）。没有锚点（平台不引用）就不记。
-     */
-    note: (threadId, userMessageId, binding) => {
-      if (binding.reply === void 0) return;
-      const turns = byThread.get(threadId) ?? makeBoundedMap(TURNS_PER_THREAD);
-      byThread.set(threadId, turns);
-      turns.set(userMessageId, { chatKey: chatKeyOf(binding), anchor: binding.reply });
-    },
-    /**
-     * 给发往这条会话的聊天挂上 `turnId` 那一轮的锚点（null 的含义见上）；取不到就原样返回。
-     *
-     * 锚点只配给它那条消息所在的聊天：会话可以被另一个聊天接走（`/resume`），而回复接口只按被
-     * 回复的消息寻址，挂错了答复就发回原来的聊天。
-     */
-    anchored: async (binding, threadId, turnId) => {
-      const turns = byThread.get(threadId);
-      if (turns === void 0) return binding;
-      const asked = await userMessageOfTurn(threadId, turnId);
-      const noted = asked === void 0 ? void 0 : turns.get(asked);
-      return noted?.chatKey === chatKeyOf(binding) ? { ...binding, reply: noted.anchor } : binding;
-    }
+    debt,
+    handled,
+    userMessageId: turn?.userMessageId,
+    redundant: candidates.filter((candidate) => candidate !== debt)
   };
 };
 
@@ -126336,11 +126365,14 @@ var foldConclusionEvent = (state, name, data) => {
   const pending = conclusionDebtsOf(state);
   if (name === "conclusion-delivered") {
     const { [key]: _delivered, ...rest } = pending;
+    const turnUserMessageId = data["turnUserMessageId"];
+    const turnKey2 = typeof turnUserMessageId === "string" && turnUserMessageId !== "" ? keyOf(threadId, turnUserMessageId) : key;
+    const { [turnKey2]: _turnDelivered, ...remaining } = rest;
     return {
       ...state,
-      conclusions: rest,
+      conclusions: remaining,
       deliveredConclusions: keepNewest(
-        { ...state.deliveredConclusions, [key]: true },
+        { ...state.deliveredConclusions, [key]: true, [turnKey2]: true },
         CONCLUSION_DEBT_LIMIT
       )
     };
@@ -126368,13 +126400,35 @@ var makeConclusionLedger = (core) => {
   core.host.onDispose(() => {
     disposed = true;
   });
-  const settle = (debt) => {
+  const settle = ({ debt, turnUserMessageId }) => {
     core.commit("conclusion-delivered", {
       threadId: debt.threadId,
-      userMessageId: debt.userMessageId
+      userMessageId: debt.userMessageId,
+      ...turnUserMessageId !== void 0 && turnUserMessageId !== debt.userMessageId ? { turnUserMessageId } : {}
     });
   };
+  const forExecutionTurn = (snapshot, threadId, turnId, grouped) => {
+    if (disposed) return { selection: void 0, handled: true };
+    const pending = conclusionDebtsOf(core.state);
+    const candidates = (grouped ?? groupConclusionDebts(snapshot, threadId, Object.values(pending))).byTurn.get(turnId);
+    const currentCandidates = candidates?.filter(
+      (debt) => pending[keyOf(threadId, debt.userMessageId)] !== void 0
+    );
+    if (currentCandidates?.length === 0) return { selection: void 0, handled: true };
+    const selected = conclusionDebtForTurn(
+      snapshot,
+      turnId,
+      currentCandidates ?? [],
+      (messageId) => delivered(keyOf(threadId, messageId))
+    );
+    for (const debt of selected.redundant) settle({ debt, turnUserMessageId: void 0 });
+    return {
+      selection: selected.debt === void 0 ? void 0 : { debt: selected.debt, turnUserMessageId: selected.userMessageId },
+      handled: selected.handled || selected.debt !== void 0 && inFlight.has(keyOf(threadId, selected.debt.userMessageId))
+    };
+  };
   return {
+    forExecutionTurn,
     starting: (threadId) => {
       const gate = Promise.withResolvers();
       const pending = registering.get(threadId) ?? /* @__PURE__ */ new Set();
@@ -126409,15 +126463,17 @@ var makeConclusionLedger = (core) => {
     forTurn: async (threadId, turnId = null) => {
       await Promise.all(registering.get(threadId) ?? []);
       const execution = await core.host.projections.getThreadExecution(threadId);
-      const userMessageId = execution === null ? void 0 : turnId === null ? execution.latestTurn?.userMessageId : userMessageIdOfTurn(execution, turnId);
-      const key = userMessageId === void 0 ? void 0 : keyOf(threadId, userMessageId);
       return {
-        debt: key === void 0 ? void 0 : conclusionDebtsOf(core.state)[key],
-        handled: key !== void 0 && (delivered(key) || inFlight.has(key)),
-        execution
+        execution,
+        ...execution === null ? { selection: void 0, handled: false } : forExecutionTurn(
+          indexExecution(execution),
+          threadId,
+          turnId ?? execution.latestTurn?.turnId ?? null
+        )
       };
     },
-    deliver: async (debt, send) => {
+    deliver: async (selection, send) => {
+      const { debt } = selection;
       const key = keyOf(debt.threadId, debt.userMessageId);
       if (disposed || delivered(key) || inFlight.has(key) || conclusionDebtsOf(core.state)[key] === void 0)
         return false;
@@ -126426,16 +126482,17 @@ var makeConclusionLedger = (core) => {
         const sent = await send(
           () => !delivered(key) && conclusionDebtsOf(core.state)[key] !== void 0
         );
-        if (sent) settle(debt);
+        if (sent) settle(selection);
         return sent;
       } finally {
         inFlight.delete(key);
       }
     },
-    discard: (debt) => {
+    discard: (selection) => {
+      const { debt } = selection;
       const key = keyOf(debt.threadId, debt.userMessageId);
       if (!disposed && !delivered(key) && !inFlight.has(key) && conclusionDebtsOf(core.state)[key] !== void 0) {
-        settle(debt);
+        settle(selection);
       }
     }
   };
@@ -127450,6 +127507,26 @@ var makeChatQueue = (core) => {
 // src/chatSetup.ts
 import { threadOrNull } from "@ycodium-ai/plugin-api";
 
+// src/boundedMap.ts
+var makeBoundedMap = (limit) => {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => entries.get(key),
+    set: (key, value2) => {
+      entries.delete(key);
+      entries.set(key, value2);
+      if (entries.size > limit) {
+        const oldest = entries.keys().next().value;
+        if (oldest !== void 0) entries.delete(oldest);
+      }
+    },
+    /** 忘掉键满足条件的那些。 */
+    forget: (matches) => {
+      for (const key of [...entries.keys()]) if (matches(key)) entries.delete(key);
+    }
+  };
+};
+
 // src/cooldown.ts
 var makeCooldown = (windowMs, now, maxKeys = Number.POSITIVE_INFINITY) => {
   const lastAt = /* @__PURE__ */ new Map();
@@ -133604,18 +133681,14 @@ var makeInboundStore = (input) => {
     write(rowId, row);
     return result2.promise;
   };
-  const claim = (rowId, id, message, receivedAt = 0) => {
+  const claimReceipt = (rowId, id, message, receivedAt = 0) => {
     const row = rowOf(rowId);
-    if (!row.loaded) return load(rowId).then(() => claim(rowId, id, message, receivedAt));
-    try {
-      assertReadable(row);
-    } catch (error) {
-      return Promise.reject(error);
-    }
+    assertReadable(row);
     const pending = row.claims.get(id);
-    if (pending !== void 0) return pending.then(() => false);
+    if (pending !== void 0) return { first: false, persisted: pending };
     const seen = row.data.seenIds.includes(id);
-    if (seen && (row.claimRevisions.get(id) ?? 0) <= row.persisted) return Promise.resolve(false);
+    if (seen && (row.claimRevisions.get(id) ?? 0) <= row.persisted)
+      return { first: false, persisted: Promise.resolve() };
     if (!seen) {
       if (message !== void 0) {
         const inbox = row.data.inbox ?? [];
@@ -133659,7 +133732,17 @@ var makeInboundStore = (input) => {
       row.claims.delete(id);
     };
     void result2.then(forget, forget);
-    return result2.then(() => !seen);
+    return { first: !seen, persisted: result2 };
+  };
+  const claim = (rowId, id, message, receivedAt = 0) => {
+    const row = rowOf(rowId);
+    if (!row.loaded) return load(rowId).then(() => claim(rowId, id, message, receivedAt));
+    try {
+      const receipt = claimReceipt(rowId, id, message, receivedAt);
+      return receipt.persisted.then(() => receipt.first);
+    } catch (error) {
+      return Promise.reject(error);
+    }
   };
   const removeEntry = (rowId, key, failure2) => {
     const row = rowOf(rowId);
@@ -133785,6 +133868,7 @@ var makeInboundStore = (input) => {
   return {
     load,
     claim,
+    claimReceipt,
     get: (rowId, key) => {
       const row = rowOf(rowId);
       assertReadable(row);
@@ -133822,6 +133906,8 @@ var makeInboundStore = (input) => {
       assertReadable(row);
       if (row.data.inbox !== void 0)
         row.data.inbox = row.data.inbox.filter((e) => e.key !== key);
+      row.data.seenIds = row.data.seenIds.filter((id) => id !== key);
+      row.claimRevisions.delete(key);
       row.revision++;
     },
     reset,
@@ -133962,7 +134048,9 @@ var startConnections = (core, inboundHandlersFor, inboundState, recovery) => {
           ...inbound,
           // 停用先封接收，保持发送连接直到已接收工作 drain 完成。
           onMessage: (message) => {
-            if (!closed && !disposed) inbound.onMessage(message);
+            if (closed || disposed)
+              return Promise.reject(new Error("inbound connection is closed"));
+            return inbound.onMessage(message);
           },
           onButton: (...args2) => closed || disposed ? null : inbound.onButton(...args2),
           onPanelClick: (click) => closed || disposed ? null : inbound.onPanelClick?.(click) ?? null,
@@ -135109,6 +135197,45 @@ var makeGreetings = (core, enqueueForChat, now) => {
   };
 };
 
+// src/replyAnchors.ts
+var THREAD_LIMIT = 256;
+var TURNS_PER_THREAD = 16;
+var anchorOfMessage = (adapter, message) => adapter?.quotesReplies === true ? { messageId: message.messageId, inThread: message.replyInThread === true } : void 0;
+var makeReplyAnchors = (host) => {
+  const byThread = makeBoundedMap(THREAD_LIMIT);
+  const userMessageOfTurn = async (threadId, turnId) => {
+    const execution = await host.projections.getThreadExecution(threadId).catch(() => null);
+    if (execution === null) return void 0;
+    const wanted = turnId ?? execution.session?.activeTurnId ?? execution.latestTurn?.turnId;
+    return wanted == null ? void 0 : executionTurnFor(indexExecution(execution), wanted)?.userMessageId;
+  };
+  return {
+    /**
+     * 开轮时记一笔：`userMessageId` 是派给宿主的那条用户消息，`binding` 是收到聊天消息的那个
+     * 聊天（带着它的锚点）。没有锚点（平台不引用）就不记。
+     */
+    note: (threadId, userMessageId, binding) => {
+      if (binding.reply === void 0) return;
+      const turns = byThread.get(threadId) ?? makeBoundedMap(TURNS_PER_THREAD);
+      byThread.set(threadId, turns);
+      turns.set(userMessageId, { chatKey: chatKeyOf(binding), anchor: binding.reply });
+    },
+    /**
+     * 给发往这条会话的聊天挂上 `turnId` 那一轮的锚点（null 的含义见上）；取不到就原样返回。
+     *
+     * 锚点只配给它那条消息所在的聊天：会话可以被另一个聊天接走（`/resume`），而回复接口只按被
+     * 回复的消息寻址，挂错了答复就发回原来的聊天。
+     */
+    anchored: async (binding, threadId, turnId) => {
+      const turns = byThread.get(threadId);
+      if (turns === void 0) return binding;
+      const asked = await userMessageOfTurn(threadId, turnId);
+      const noted = asked === void 0 ? void 0 : turns.get(asked);
+      return noted?.chatKey === chatKeyOf(binding) ? { ...binding, reply: noted.anchor } : binding;
+    }
+  };
+};
+
 // src/inbound.ts
 var ARCHIVED_REPLY_COOLDOWN_MS = 10 * 6e4;
 var UNSUPPORTED_REPLY_COOLDOWN_MS = 6e4;
@@ -135336,40 +135463,44 @@ var makeInbound = (core, deps) => {
     noteChatAlias: (alias, chatId) => noteChatAlias(bot, alias, chatId),
     knowsChatAlias: (alias) => chatAliasOf(core.state, bot.rowId, alias) !== void 0,
     onGreeting: (chatId, senderId) => greet(bot.rowId, chatId, senderId),
-    onMessage: (received) => {
+    onMessage: async (received) => {
       const current = currentBot(bot.rowId);
-      if (!accepting || current === void 0) return;
+      if (!accepting || current === void 0) throw new Error("inbound is not accepting messages");
       const message = settleChat(current, received);
       const work = workForMessage(message);
-      if (inboundState.hasSeen(current.rowId, work.key)) return;
+      const adapter = adapterFor(current.platform);
       let saved;
       try {
-        saved = persistInbound(adapterFor(current.platform), message);
+        saved = persistInbound(adapter, message);
       } catch (error) {
         host.log.warn("chat could not serialize inbound; processing without restart protection", {
           rowId: current.rowId,
           error: describeError(error)
         });
       }
+      const claim = inboundState.claimReceipt(current.rowId, work.key, saved, now());
+      if (!claim.first) return claim.persisted;
+      const receipt = claim.persisted.catch((error) => {
+        inboundState.abandon(current.rowId, work.key);
+        host.log.warn(
+          adapter?.redeliversUnacknowledged ? "chat could not save inbound state; waiting for platform redelivery" : "chat could not save inbound state; processing without restart protection",
+          { rowId: current.rowId, error: describeError(error) }
+        );
+        throw error;
+      });
+      const enqueue = () => {
+        const arrived = bindingOf2(current, message.chatId);
+        if (message.chatKind !== void 0 && chatOf(core.state, chatKeyOf(arrived)).chatKind !== message.chatKind) {
+          commit("chat-updated", { chatKey: chatKeyOf(arrived), chatKind: message.chatKind });
+        }
+        enqueueForChat(chatKeyOf(arrived), () => resumeMessage(current, message, work));
+      };
       track(
-        inboundState.claim(current.rowId, work.key, saved, now()).then(
-          () => {
-          },
-          (error) => {
-            inboundState.abandon(current.rowId, work.key);
-            host.log.warn(
-              "chat could not save inbound state; processing without restart protection",
-              { rowId: current.rowId, error: describeError(error) }
-            );
-          }
-        ).then(() => {
-          const arrived = bindingOf2(current, message.chatId);
-          if (message.chatKind !== void 0 && chatOf(core.state, chatKeyOf(arrived)).chatKind !== message.chatKind) {
-            commit("chat-updated", { chatKey: chatKeyOf(arrived), chatKind: message.chatKind });
-          }
-          enqueueForChat(chatKeyOf(arrived), () => resumeMessage(current, message, work));
+        receipt.then(enqueue, () => {
+          if (!adapter?.redeliversUnacknowledged) enqueue();
         })
       );
+      return receipt;
     }
   });
   const replay = makeInboxReplay(
@@ -135803,14 +135934,6 @@ var queueCardOf = (record4, view, note, t) => {
 var queueViewKey = (view, note) => JSON.stringify([view, note]);
 
 // src/queueFlow.ts
-var LIVE_STATUSES = /* @__PURE__ */ new Set([
-  "queued",
-  "preparing",
-  "dispatching",
-  "running",
-  "reconciling",
-  "blocked"
-]);
 var makeQueueFlow = (host, deps) => {
   const { t } = host;
   const shown = /* @__PURE__ */ new Map();
@@ -135834,7 +135957,7 @@ var makeQueueFlow = (host, deps) => {
     const intent = execution?.intents.find((entry) => entry.messageId === messageId);
     if (execution === null || intent === void 0 || intent.status !== "queued") return;
     const waiting = execution.activeTurnId !== null || execution.queuePaused || execution.intents.some(
-      (other) => other.intentId !== intent.intentId && LIVE_STATUSES.has(other.status) && other.sequence < intent.sequence
+      (other) => other.intentId !== intent.intentId && isLiveIntentStatus(other.status) && other.sequence < intent.sequence
     );
     if (!waiting) return;
     const cards = target2.adapter.choiceCards;
@@ -144071,7 +144194,7 @@ var cardActionOperator = (event) => {
 };
 var startLarkInbound = (input) => {
   const dispatcher = new import_node_sdk.EventDispatcher({}).register({
-    "im.message.receive_v1": (event) => {
+    "im.message.receive_v1": async (event) => {
       const mode = input.groupMention ?? "always";
       const parse = (groupMention) => parseInboundMessage(
         event,
@@ -144081,17 +144204,16 @@ var startLarkInbound = (input) => {
       );
       const parsed = parse(mode);
       if (parsed !== null) {
-        input.onMessage(parsed);
+        await input.onMessage(parsed);
         return {};
       }
       const chat = event.message;
       if (mode === "always" && input.isSoloGroup !== void 0 && chat?.chat_type !== "p2p") {
         const chatId = chat?.chat_id;
         if (typeof chatId === "string") {
-          void input.isSoloGroup(chatId).then((solo) => {
-            const relaxed = solo ? parse("never") : null;
-            if (relaxed !== null) input.onMessage(relaxed);
-          });
+          const solo = await input.isSoloGroup(chatId).catch(() => false);
+          const relaxed = solo ? parse("never") : null;
+          if (relaxed !== null) await input.onMessage(relaxed);
         }
       }
       return {};
@@ -144670,10 +144792,12 @@ var makeLarkAdapter = (deps) => {
   };
   const soloGroupFor = (context2) => async (chatId) => {
     const info = await context2.chatInfo(chatId);
-    return info?.userCount !== void 0 && info.botCount !== void 0 && info.userCount <= 1 && info.botCount <= 1;
+    if (info?.userCount === void 0 || info.botCount === void 0) return false;
+    return info.userCount <= 1 && info.botCount <= 1;
   };
   return {
     platform: "lark",
+    redeliversUnacknowledged: true,
     ...larkInboundPersistence((rowId) => messageContexts.get(rowId)?.context),
     botIdentity: (bot) => larkCredentials(bot).appId,
     icon: "lark",
@@ -144781,15 +144905,27 @@ var makeLarkAdapter = (deps) => {
           const key = JSON.stringify([message.chatId, topic?.threadId]);
           const earlier = pendingDeliveries.get(key);
           if (earlier === void 0 && pending === null && reference2 === null && !(prepared instanceof Promise) && !(source instanceof Promise)) {
-            deliver(prepared, source);
+            return deliver(prepared, source);
           } else {
-            const completed = Promise.all([earlier, pending, reference2, source, prepared]).then(([, , replyTo, names, ready]) => {
+            const completed = Promise.all([
+              earlier?.catch(() => {
+              }),
+              pending,
+              reference2,
+              source,
+              prepared
+            ]).then(([, , replyTo, names, ready]) => {
               if (pendingDeliveries.get(key) === completed) pendingDeliveries.delete(key);
-              if (open) deliver(ready, names, replyTo ?? void 0);
-            }).catch((error) => handlers.onError(describeError(error))).finally(() => {
+              if (!open) throw new Error("lark inbound connection is closed");
+              return deliver(ready, names, replyTo ?? void 0);
+            }).catch((error) => {
+              handlers.onError(describeError(error));
+              throw error;
+            }).finally(() => {
               if (pendingDeliveries.get(key) === completed) pendingDeliveries.delete(key);
             });
             pendingDeliveries.set(key, completed);
+            return completed;
           }
         }
       });
@@ -146643,13 +146779,13 @@ var makeModelPlan = (core, deps) => {
 import { readThreadFailed, threadOrNull as threadOrNull5 } from "@ycodium-ai/plugin-api";
 
 // src/conclusionOutbox.ts
-var enqueueConclusion = (core, ledger, binding, debt, send) => core.outbound(
+var enqueueConclusion = (core, ledger, binding, selection, send) => core.outbound(
   chatKeyOf(binding),
   async () => {
-    if (debt === void 0) await send();
-    else await ledger.deliver(debt, send);
+    if (selection === void 0) await send();
+    else await ledger.deliver(selection, send);
   },
-  { droppable: debt !== void 0 }
+  { droppable: selection !== void 0 }
 );
 
 // src/conclusionRecovery.ts
@@ -146665,60 +146801,100 @@ var makeConclusionRecovery = (core, ledger, delivery, failures) => {
       error: describeError(error)
     });
   };
-  const recoverConclusion = async (debt) => {
+  const recoverThread = async (threadId, debts, requestedMessageId) => {
     await core.ready;
     if (disposed) return;
     try {
-      const execution = await core.host.projections.getThreadExecution(debt.threadId);
+      const execution = await core.host.projections.getThreadExecution(threadId);
       if (disposed) return;
       if (execution === null) {
-        ledger.discard(debt);
-        return;
-      }
-      const latest = execution.latestTurn;
-      if (latest?.userMessageId !== debt.userMessageId) {
-        core.host.log.info("chat discarded a conclusion whose turn is no longer latest", {
-          ...debt
-        });
-        ledger.discard(debt);
-        return;
-      }
-      if (latest.state === "running" || execution.session?.activeTurnId != null) return;
-      if (latest.completedAt !== null && Date.parse(latest.completedAt) < Date.now() - MAX_AGE_MS) {
-        core.host.log.info("chat discarded a conclusion older than seven days", { ...debt });
-        ledger.discard(debt);
+        for (const debt of debts) {
+          if (requestedMessageId === void 0 || debt.userMessageId === requestedMessageId)
+            ledger.discard({ debt, turnUserMessageId: void 0 });
+        }
         return;
       }
-      const binding = core.bindingForChatKey(debt.chatKey);
-      if (binding === void 0) return;
-      enqueueConclusion(core, ledger, binding, debt, async (owed) => {
-        try {
-          if (latest.state === "error") {
-            return delivery.sendText(
-              binding,
-              debt.threadId,
-              failures.forFailure(debt.threadId, execution.session?.lastError),
-              true,
-              latest.turnId,
-              owed
-            );
+      const snapshot = indexExecution(execution);
+      const grouped = groupConclusionDebts(snapshot, threadId, debts);
+      const { resolved, byTurn } = grouped;
+      for (const { debt, result: result2 } of resolved.values()) {
+        if (result2.kind === "gone") {
+          if (requestedMessageId === void 0 || debt.userMessageId === requestedMessageId) {
+            core.host.log.info("chat discarded a conclusion whose message has no turn", {
+              ...debt
+            });
+            ledger.discard({ debt, turnUserMessageId: void 0 });
           }
-          const send = await delivery.prepareConclusion(debt.threadId, latest.turnId);
-          return send(binding, { recovered: true, streaming: false, owed });
-        } catch (error) {
-          couldNotRecover(debt, error);
-          return false;
         }
-      });
+      }
+      const requested = requestedMessageId === void 0 ? void 0 : resolved.get(requestedMessageId)?.result;
+      for (const turnId of byTurn.keys()) {
+        if (requestedMessageId !== void 0 && (requested?.kind !== "settled" && requested?.kind !== "merged" || requested.turnId !== turnId))
+          continue;
+        const { selection, handled } = ledger.forExecutionTurn(snapshot, threadId, turnId, grouped);
+        if (handled || selection === void 0 || requestedMessageId !== void 0 && selection.debt.userMessageId !== requestedMessageId)
+          continue;
+        const result2 = resolved.get(selection.debt.userMessageId).result;
+        if (result2.kind === "pending" || result2.kind === "gone") continue;
+        recoverTurn(selection, result2.kind === "settled" ? result2 : result2.turn, execution);
+      }
     } catch (error) {
-      couldNotRecover(debt, error);
+      for (const debt of debts) couldNotRecover(debt, error);
     }
   };
+  const recoverTurn = (selection, turn, execution) => {
+    const { debt } = selection;
+    if (turn === void 0 || turn.state === "pending" || turn.state === "running" || execution.session?.activeTurnId === turn.turnId)
+      return;
+    if (turn.completedAt !== null && Date.parse(turn.completedAt) < Date.now() - MAX_AGE_MS) {
+      core.host.log.info("chat discarded a conclusion older than seven days", { ...debt });
+      ledger.discard(selection);
+      return;
+    }
+    const binding = core.bindingForChatKey(selection.debt.chatKey);
+    if (binding === void 0) return;
+    enqueueConclusion(core, ledger, binding, selection, async (owed) => {
+      try {
+        if (turn.state === "error") {
+          const detail = execution.latestTurn?.state === "error" && execution.latestTurn.turnId === turn.turnId ? execution.session?.lastError : void 0;
+          return delivery.sendText(
+            binding,
+            debt.threadId,
+            failures.forFailure(debt.threadId, detail),
+            true,
+            turn.turnId,
+            owed
+          );
+        }
+        const send = await delivery.prepareConclusion(debt.threadId, turn.turnId);
+        return send(binding, { recovered: true, streaming: false, owed });
+      } catch (error) {
+        couldNotRecover(debt, error);
+        return false;
+      }
+    });
+  };
+  const recoverConclusion = async (debt) => {
+    await core.ready;
+    await recoverThread(
+      debt.threadId,
+      Object.values(conclusionDebtsOf(core.state)).filter(
+        (candidate) => candidate.threadId === debt.threadId
+      ),
+      debt.userMessageId
+    );
+  };
   const recoverConclusions = async () => {
     await core.ready;
+    const byThread = /* @__PURE__ */ new Map();
     for (const debt of Object.values(conclusionDebtsOf(core.state))) {
+      const group = byThread.get(debt.threadId) ?? [];
+      group.push(debt);
+      byThread.set(debt.threadId, group);
+    }
+    for (const [threadId, debts] of byThread) {
       if (disposed) return;
-      await recoverConclusion(debt);
+      await recoverThread(threadId, debts);
     }
   };
   return { recoverConclusion, recoverConclusions };
@@ -146799,14 +146975,14 @@ var makeNotifications = (core, deps) => {
       await ready;
       const targets = targetsForProject(threadId, await projectOfThread(threadId));
       const owes = Object.values(conclusionDebtsOf(core.state)).some(
-        (debt2) => debt2.threadId === threadId
+        (debt) => debt.threadId === threadId
       );
-      const { debt, handled, execution } = said || owes || targets.length > 0 ? await conclusions.forTurn(threadId) : { debt: void 0, handled: false, execution: null };
-      if (debt !== void 0) {
-        const binding = bindingForChatKey(debt.chatKey);
+      const { selection, handled, execution } = said || owes || targets.length > 0 ? await conclusions.forTurn(threadId) : { selection: void 0, handled: false, execution: null };
+      if (selection !== void 0) {
+        const binding = bindingForChatKey(selection.debt.chatKey);
         if (binding !== void 0 && !streamsTo(binding, threadId) && execution?.session?.activeTurnId == null && execution?.latestTurn?.state !== "running" && execution?.latestTurn?.state !== "error" && payload.session?.status !== "error") {
           const turnId = execution?.latestTurn?.turnId ?? null;
-          enqueueConclusion(core, conclusions, binding, debt, async (owed) => {
+          enqueueConclusion(core, conclusions, binding, selection, async (owed) => {
             const send = await delivery.prepareConclusion(threadId, turnId);
             return send(binding, { recovered: false, streaming: false, owed });
           });
@@ -146841,9 +147017,9 @@ var makeNotifications = (core, deps) => {
     threadsWithSomethingToReport.delete(threadId);
     await ready;
     const targets = targetsForProject(threadId, await projectOfThread(threadId));
-    const { debt, handled, execution } = await conclusions.forTurn(threadId);
-    const debtBinding = debt === void 0 ? void 0 : bindingForChatKey(debt.chatKey);
-    const recipients = debt !== void 0 ? debtBinding === void 0 ? [] : [debtBinding] : targets;
+    const { selection, handled, execution } = await conclusions.forTurn(threadId);
+    const debtBinding = selection === void 0 ? void 0 : bindingForChatKey(selection.debt.chatKey);
+    const recipients = selection !== void 0 ? debtBinding === void 0 ? [] : [debtBinding] : targets;
     const textTargets = handled ? [] : recipients.filter(
       (binding) => !(streamsTo(binding, threadId) && turnCards.covers(threadId))
     );
@@ -146854,7 +147030,7 @@ var makeNotifications = (core, deps) => {
     if (notice !== null) {
       for (const binding of textTargets) {
         const send = (owed) => delivery.sendText(binding, threadId, notice, false, null, owed);
-        enqueueConclusion(core, conclusions, binding, debt, send);
+        enqueueConclusion(core, conclusions, binding, selection, send);
       }
     }
     for (const binding of targets) {
@@ -147844,10 +148020,10 @@ var makeReplyCards = (core, failures, anchors, conclusions, delivery) => {
     onOpened: (card) => commit("turn-card-opened", card),
     onClosed: (cardId) => commit("turn-card-closed", { cardId }),
     finalize: async (threadId, turnId, chatKey, send) => {
-      const { debt, handled } = await conclusions.forTurn(threadId, turnId);
+      const { selection, handled } = await conclusions.forTurn(threadId, turnId);
       if (handled) return true;
-      if (debt === void 0) return send();
-      if (!await conclusions.deliver(debt, send)) return false;
+      if (selection === void 0) return send();
+      if (!await conclusions.deliver(selection, send)) return false;
       const binding = bindingForChatKey(chatKey);
       if (binding === void 0) return true;
       const sendConclusion = await delivery.prepareConclusion(threadId, turnId);
@@ -147855,7 +148031,7 @@ var makeReplyCards = (core, failures, anchors, conclusions, delivery) => {
       return true;
     },
     fallback: async (threadId, turnId, chatKey, view) => {
-      const { debt, handled } = await conclusions.forTurn(threadId, turnId);
+      const { selection, handled } = await conclusions.forTurn(threadId, turnId);
       if (handled) return;
       const binding = bindingForChatKey(chatKey);
       if (binding === void 0) return;
@@ -147864,7 +148040,7 @@ var makeReplyCards = (core, failures, anchors, conclusions, delivery) => {
         core,
         conclusions,
         binding,
-        debt,
+        selection,
         (owed) => delivery.sendText(binding, threadId, text4, false, turnId, owed)
       );
     },
@@ -148996,6 +149172,7 @@ var makeTelegramAdapter = (deps) => {
   });
   return {
     platform: "telegram",
+    redeliversUnacknowledged: true,
     botIdentity: tokenFingerprint,
     icon: "telegram",
     label: "Telegram",
@@ -149107,14 +149284,16 @@ var makeTelegramAdapter = (deps) => {
                 }
               }
               if (!running) break;
-              advanceOffset(update);
               const senderId = message.from === void 0 ? null : String(message.from.id);
               const senderName2 = telegramDisplayName(message.from);
               const chatKind = message.chat.type === "private" ? "private" : "group";
               if (message.voice !== void 0 || text4 === "" && resource === null) {
                 const unsupported = unsupportedTypeOf(message);
-                if (unsupported === null) continue;
-                handlers.onMessage({
+                if (unsupported === null) {
+                  advanceOffset(update);
+                  continue;
+                }
+                await handlers.onMessage({
                   messageId: String(message.message_id),
                   chatId: chatIdOf(message),
                   senderId,
@@ -149123,11 +149302,13 @@ var makeTelegramAdapter = (deps) => {
                   resources: [],
                   unsupportedType: unsupported
                 });
+                if (!running) break;
+                advanceOffset(update);
                 continue;
               }
               const parentChatId = parentChatIdOf(message);
               const replyTo = telegramReplyReference(message, botUsername, botId);
-              handlers.onMessage({
+              await handlers.onMessage({
                 messageId: String(message.message_id),
                 chatId: chatIdOf(message),
                 ...parentChatId === void 0 ? {} : { parentChatId },
@@ -149147,6 +149328,8 @@ var makeTelegramAdapter = (deps) => {
                   }
                 ]
               });
+              if (!running) break;
+              advanceOffset(update);
             }
           } catch (error) {
             if (!running) return;
@@ -149727,12 +149910,10 @@ var makeTurns = (core, deps) => {
       );
       if (!dispatched) return null;
       topicRoot?.confirmConsumed();
-      if (intentAction?.kind !== "steer") {
-        await deps.conclusions.owe(
-          { chatKey, threadId, userMessageId, recordedAt: (/* @__PURE__ */ new Date()).toISOString() },
-          replayed ? deps.recoverConclusion : void 0
-        );
-      }
+      await deps.conclusions.owe(
+        { chatKey, threadId, userMessageId, recordedAt: (/* @__PURE__ */ new Date()).toISOString() },
+        replayed ? deps.recoverConclusion : void 0
+      );
     } finally {
       registered();
     }
@@ -151167,7 +151348,7 @@ ${kept}`;
               if (message.chatType !== "single") return;
               client.rememberRequest(message.chatId, message.requestId);
               client.rememberConversation(message.chatId, message.conversation);
-              handlers.onMessage({
+              void handlers.onMessage({
                 // 不保存短效 req_id：重启后的回话走新连接的 aibot_send_msg 主动发送，
                 // 不冒充原消息的回答，也不复用旧连接的 rememberRequest / 流状态。
                 messageId: message.messageId,
@@ -151184,6 +151365,10 @@ ${kept}`;
                   mimeType: resource.mimeType,
                   kind: resource.kind
                 }))
+              }).catch((error) => {
+                deps.log.warn("wecom could not persist inbound message", {
+                  error: describeError(error)
+                });
               });
             }
           }
@@ -152279,12 +152464,19 @@ var makeWecomAppAdapter = (deps) => {
     }
     const messageId = message.msgid ?? `${chatId}:${message.createTime ?? Date.now()}`;
     const base2 = { messageId, chatId, senderId: chatId };
+    const receive = (inbound) => {
+      void handlers.onMessage(inbound).catch((error) => {
+        deps.log.warn("wecom-app could not persist inbound message", {
+          error: describeError(error)
+        });
+      });
+    };
     if (message.msgtype === "text") {
-      handlers.onMessage({ ...base2, text: message.text?.content?.trim() ?? "", resources: [] });
+      receive({ ...base2, text: message.text?.content?.trim() ?? "", resources: [] });
       return;
     }
     if (message.msgtype === "image" && message.mediaId !== void 0 && message.mediaId !== "") {
-      handlers.onMessage({
+      receive({
         ...base2,
         text: "",
         resources: [
@@ -152293,7 +152485,7 @@ var makeWecomAppAdapter = (deps) => {
       });
       return;
     }
-    handlers.onMessage({
+    receive({
       ...base2,
       text: "",
       resources: [],
@@ -152503,7 +152695,7 @@ var makeWecomAppAdapter = (deps) => {
 // src/index.ts
 var definition = {
   id: "im",
-  apiVersion: 22,
+  apiVersion: 23,
   // 第二个参数只给插件自己的测试夹具：换掉文件 IO 与派发重试的等待。宿主只传 ctx。
   activate: async (ctx, testing = {}) => {
     const { dispatchSleep } = testing;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/plugin-im",
-  "version": "0.2.3216",
+  "version": "0.2.3220",
   "description": "Talk to your agents from Telegram, WeCom, Lark, or WeChat (experimental).",
   "keywords": [
     "im",
@@ -32,7 +32,8 @@
     "markdown-it": "^15.0.2",
     "react": "19.2.6",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.3216"
+    "ycodium-react-test-harness": "0.0.0",
+    "@ycodium-ai/plugin-api": "0.2.3220"
   },
   "ycodium": {
     "plugin": "./dist/index.js",