@ycodium-ai/plugin-im 0.2.3214 → 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,8 +126365,19 @@ var foldConclusionEvent = (state, name, data) => {
   const pending = conclusionDebtsOf(state);
   if (name === "conclusion-delivered") {
     const { [key]: _delivered, ...rest } = pending;
-    return { ...state, conclusions: rest };
+    const turnUserMessageId = data["turnUserMessageId"];
+    const turnKey2 = typeof turnUserMessageId === "string" && turnUserMessageId !== "" ? keyOf(threadId, turnUserMessageId) : key;
+    const { [turnKey2]: _turnDelivered, ...remaining } = rest;
+    return {
+      ...state,
+      conclusions: remaining,
+      deliveredConclusions: keepNewest(
+        { ...state.deliveredConclusions, [key]: true, [turnKey2]: true },
+        CONCLUSION_DEBT_LIMIT
+      )
+    };
   }
+  if (state.deliveredConclusions?.[key] === true) return state;
   const chatKey = data["chatKey"];
   const recordedAt = data["recordedAt"];
   if (typeof chatKey !== "string" || chatKey === "" || typeof recordedAt !== "string" || !Number.isFinite(Date.parse(recordedAt))) {
@@ -126354,19 +126394,41 @@ var foldConclusionEvent = (state, name, data) => {
 var makeConclusionLedger = (core) => {
   const inFlight = /* @__PURE__ */ new Set();
   const registering = /* @__PURE__ */ new Map();
-  const delivered = makeBoundedMap(CONCLUSION_DEBT_LIMIT);
+  const unpersisted = /* @__PURE__ */ new Set();
+  const delivered = (key) => core.state.deliveredConclusions?.[key] === true;
   let disposed = false;
   core.host.onDispose(() => {
     disposed = true;
   });
-  const settle = (debt) => {
-    delivered.set(keyOf(debt.threadId, debt.userMessageId), true);
+  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();
@@ -126378,44 +126440,59 @@ var makeConclusionLedger = (core) => {
         gate.resolve();
       };
     },
-    owe: (debt) => {
+    /** 重放才传 recover；只对本次成功补出的欠账调度恢复，已有欠账交给原来的收尾路径。 */
+    owe: async (debt, recover) => {
+      const key = keyOf(debt.threadId, debt.userMessageId);
+      if (delivered(key)) {
+        core.host.log.info("chat skipped a conclusion debt already delivered", { ...debt });
+        return;
+      }
       const pending = conclusionDebtsOf(core.state);
-      if (Object.keys(pending).length >= CONCLUSION_DEBT_LIMIT && pending[keyOf(debt.threadId, debt.userMessageId)] === void 0) {
+      const added = pending[key] === void 0 || unpersisted.has(key);
+      if (Object.keys(pending).length >= CONCLUSION_DEBT_LIMIT && pending[key] === void 0) {
         core.host.log.warn("chat dropped its oldest conclusion debt at capacity", {
           oldest: Object.values(pending)[0],
           limit: CONCLUSION_DEBT_LIMIT
         });
       }
-      core.commit("conclusion-owed", { ...debt });
+      if (added) unpersisted.add(key);
+      await core.commitDurably("conclusion-owed", { ...debt });
+      unpersisted.delete(key);
+      if (added) await recover?.(debt);
     },
     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.get(key) === true || 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 || inFlight.has(key) || conclusionDebtsOf(core.state)[key] === void 0)
+      if (disposed || delivered(key) || inFlight.has(key) || conclusionDebtsOf(core.state)[key] === void 0)
         return false;
       inFlight.add(key);
       try {
-        const sent = await send(() => conclusionDebtsOf(core.state)[key] !== void 0);
-        if (sent) settle(debt);
+        const sent = await send(
+          () => !delivered(key) && conclusionDebtsOf(core.state)[key] !== void 0
+        );
+        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 && !inFlight.has(key) && conclusionDebtsOf(core.state)[key] !== void 0) {
-        settle(debt);
+      if (!disposed && !delivered(key) && !inFlight.has(key) && conclusionDebtsOf(core.state)[key] !== void 0) {
+        settle(selection);
       }
     }
   };
@@ -127430,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();
@@ -133584,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 ?? [];
@@ -133639,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);
@@ -133765,6 +133868,7 @@ var makeInboundStore = (input) => {
   return {
     load,
     claim,
+    claimReceipt,
     get: (rowId, key) => {
       const row = rowOf(rowId);
       assertReadable(row);
@@ -133802,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,
@@ -133942,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,
@@ -134339,16 +134447,18 @@ var makeImCore = (input) => {
     }
   );
   let persisting = Promise.resolve();
-  const commit = (name, data) => {
+  const commitDurably = (name, data) => {
     state = foldImEvent(state, name, data);
-    persisting = persisting.then(
+    const saved = persisting.then(
       () => host.events.append({ name, aggregate: { kind: "plugin", id: input.pluginId }, data })
-    ).then(
-      () => void 0,
-      (error) => {
-        host.log.warn("chat could not save its state", { name, error: describeError(error) });
-      }
-    );
+    ).then(() => void 0);
+    persisting = saved.catch((error) => {
+      host.log.warn("chat could not save its state", { name, error: describeError(error) });
+    });
+    return saved;
+  };
+  const commit = (name, data) => {
+    void commitDurably(name, data);
   };
   const bindChat = (chatKey, threadId) => {
     commit("chat-updated", { chatKey, threadId });
@@ -134414,6 +134524,7 @@ var makeImCore = (input) => {
     },
     ready,
     commit,
+    commitDurably,
     bindChat,
     outbound,
     deliver,
@@ -134885,6 +134996,7 @@ import { projectOrNull } from "@ycodium-ai/plugin-api";
 
 // src/inboxProcessing.ts
 var processingFor = (store, rowId, entry, retry) => ({
+  replayed: entry.replayed === true,
   get entry() {
     return store.get(rowId, entry.key);
   },
@@ -135046,7 +135158,7 @@ var makeInboxReplay = (core, currentBot, state, enqueueForChat, resumeMessage, c
       await resumeMessage(
         bot,
         latest.message === entry.message ? message : restoreInbound(core.adapterFor(bot.platform), latest.message),
-        latest,
+        { ...latest, replayed: true },
         chatId
       );
     });
@@ -135085,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;
@@ -135312,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(
@@ -135779,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();
@@ -135810,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;
@@ -144047,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,
@@ -144057,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 {};
@@ -144646,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",
@@ -144757,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;
           }
         }
       });
@@ -146619,18 +146779,18 @@ 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
 var MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
-var recoverConclusions = async (core, ledger, delivery, failures) => {
+var makeConclusionRecovery = (core, ledger, delivery, failures) => {
   let disposed = false;
   core.host.onDispose(() => {
     disposed = true;
@@ -146641,55 +146801,103 @@ var recoverConclusions = async (core, ledger, delivery, failures) => {
       error: describeError(error)
     });
   };
-  await core.ready;
-  for (const debt of Object.values(conclusionDebtsOf(core.state))) {
+  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);
-        continue;
-      }
-      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);
-        continue;
-      }
-      if (latest.state === "running" || execution.session?.activeTurnId != null) continue;
-      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);
-        continue;
+        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) continue;
-      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 recoverThread(threadId, debts);
+    }
+  };
+  return { recoverConclusion, recoverConclusions };
 };
 
 // src/notificationTargets.ts
@@ -146713,7 +146921,13 @@ var makeNotifications = (core, deps) => {
   const { takeWorking } = deps;
   const { turnCards } = deps.replyCards;
   const { failures, conclusions, delivery } = deps;
-  void recoverConclusions(core, conclusions, delivery, failures);
+  const { recoverConclusion, recoverConclusions } = makeConclusionRecovery(
+    core,
+    conclusions,
+    delivery,
+    failures
+  );
+  void recoverConclusions();
   const projectByThread = /* @__PURE__ */ new Map();
   const projectOfThread = async (threadId) => {
     const known = projectByThread.get(threadId);
@@ -146761,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 });
           });
@@ -146803,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))
     );
@@ -146816,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) {
@@ -146831,7 +147045,7 @@ var makeNotifications = (core, deps) => {
   const rememberThreadProject = (threadId, projectId) => {
     projectByThread.set(threadId, projectId);
   };
-  return { rememberThreadProject };
+  return { rememberThreadProject, recoverConclusion };
 };
 
 // src/panelCommands.ts
@@ -147806,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);
@@ -147817,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;
@@ -147826,7 +148040,7 @@ var makeReplyCards = (core, failures, anchors, conclusions, delivery) => {
         core,
         conclusions,
         binding,
-        debt,
+        selection,
         (owed) => delivery.sendText(binding, threadId, text4, false, turnId, owed)
       );
     },
@@ -148211,7 +148425,7 @@ var teamGoalRequestId = (binding, messageId) => {
   return NodeCrypto5.createHash("sha256").update(identity2).digest("hex");
 };
 var makeTeamGoals = (core) => {
-  const { host, t, deliver, commit } = core;
+  const { host, t, deliver, commitDurably } = core;
   const hasRosterFor = async (binding) => {
     try {
       const roster = await host.plugins.invoke({
@@ -148255,13 +148469,16 @@ var makeTeamGoals = (core) => {
         throw new Error("team startGoal returned an invalid result");
       }
       topicRoot?.confirmConsumed();
-      commit("team-goal-started", { chatKey: chatKeyOf(binding), threadId: result2.leadThreadId });
       goal = { leadThreadId: result2.leadThreadId, leadName: result2.leadName };
     } catch (error) {
       host.log.warn("chat could not start the team goal", { error: describeError(error) });
       await deliver(binding, t("team.startFailed"));
       return null;
     }
+    await commitDurably("team-goal-started", {
+      chatKey: chatKeyOf(binding),
+      threadId: goal.leadThreadId
+    });
     await accepted?.(goal.leadThreadId);
     await deliver(
       binding,
@@ -148955,6 +149172,7 @@ var makeTelegramAdapter = (deps) => {
   });
   return {
     platform: "telegram",
+    redeliversUnacknowledged: true,
     botIdentity: tokenFingerprint,
     icon: "telegram",
     label: "Telegram",
@@ -149066,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,
@@ -149082,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 },
@@ -149106,6 +149328,8 @@ var makeTelegramAdapter = (deps) => {
                   }
                 ]
               });
+              if (!running) break;
+              advanceOffset(update);
             }
           } catch (error) {
             if (!running) return;
@@ -149581,6 +149805,7 @@ var makeTurns = (core, deps) => {
   const startTurn = async (binding, message, accepted, inbox) => {
     const chatKey = chatKeyOf(binding);
     const text4 = message.text;
+    const replayed = inbox?.replayed === true || (inbox?.entry?.attempts ?? 0) > 0;
     const threadId = inbox?.entry?.threadId ?? await ensureThread(binding, message);
     if (threadId === null) {
       await inbox?.complete();
@@ -149685,14 +149910,10 @@ var makeTurns = (core, deps) => {
       );
       if (!dispatched) return null;
       topicRoot?.confirmConsumed();
-      if (intentAction?.kind !== "steer") {
-        deps.conclusions.owe({
-          chatKey,
-          threadId,
-          userMessageId,
-          recordedAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
+      await deps.conclusions.owe(
+        { chatKey, threadId, userMessageId, recordedAt: (/* @__PURE__ */ new Date()).toISOString() },
+        replayed ? deps.recoverConclusion : void 0
+      );
     } finally {
       registered();
     }
@@ -151127,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,
@@ -151144,6 +151365,10 @@ ${kept}`;
                   mimeType: resource.mimeType,
                   kind: resource.kind
                 }))
+              }).catch((error) => {
+                deps.log.warn("wecom could not persist inbound message", {
+                  error: describeError(error)
+                });
               });
             }
           }
@@ -152239,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: [
@@ -152253,7 +152485,7 @@ var makeWecomAppAdapter = (deps) => {
       });
       return;
     }
-    handlers.onMessage({
+    receive({
       ...base2,
       text: "",
       resources: [],
@@ -152463,7 +152695,7 @@ var makeWecomAppAdapter = (deps) => {
 // src/index.ts
 var definition = {
   id: "im",
-  apiVersion: 21,
+  apiVersion: 23,
   // 第二个参数只给插件自己的测试夹具：换掉文件 IO 与派发重试的等待。宿主只传 ctx。
   activate: async (ctx, testing = {}) => {
     const { dispatchSleep } = testing;
@@ -152592,6 +152824,7 @@ var definition = {
     const turns = makeTurns(core, {
       conclusions,
       attachments: inboundAttachments,
+      recoverConclusion: notifications.recoverConclusion,
       queueFlow: interactions.queueFlow,
       rememberThreadProject: notifications.rememberThreadProject,
       noteInboundUserMessage: webSync.noteInboundUserMessage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/plugin-im",
-  "version": "0.2.3214",
+  "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.3214"
+    "ycodium-react-test-harness": "0.0.0",
+    "@ycodium-ai/plugin-api": "0.2.3220"
   },
   "ycodium": {
     "plugin": "./dist/index.js",