@ycodium-ai/plugin-im 0.2.3244 → 0.2.3250

package/dist/index.js

@@ -126162,16 +126162,152 @@ import { definePlugin } from "@ycodium-ai/plugin-api";
 // src/errors.ts
 var describeError = (error) => error instanceof Error ? error.message : String(error);
 
+// src/inboundOutcome.ts
+var runInbound = async (core, binding, messageId, execute, lifecycle) => {
+  let outcome;
+  let failure2;
+  let accepted = false;
+  let completed = false;
+  const completeFailure = async () => {
+    try {
+      await lifecycle?.complete();
+      completed = true;
+    } catch (error) {
+      core.host.log.warn("chat could not complete a failed inbound message", {
+        messageId,
+        error: describeError(error)
+      });
+    }
+  };
+  const reportFailure = async () => {
+    try {
+      if (!await core.deliver(
+        binding,
+        core.t(completed ? "reply.inboundFailed" : "reply.inboundDeferred")
+      ))
+        core.host.log.warn("chat could not deliver an inbound failure notice", { messageId });
+    } catch (error) {
+      core.host.log.warn("chat could not deliver an inbound failure notice", {
+        messageId,
+        error: describeError(error)
+      });
+    }
+  };
+  try {
+    outcome = await execute(() => {
+      accepted = true;
+      lifecycle?.clearDeferred();
+    });
+  } catch (error) {
+    failure2 = { error };
+    if (!accepted) await completeFailure();
+  } finally {
+    if (!accepted) {
+      if (outcome?.status === "deferred") lifecycle?.rememberDeferred();
+      else lifecycle?.clearDeferred();
+    }
+    if (!accepted && (outcome === void 0 || outcome.status === "settled") || outcome?.status === "started" && outcome.claimsPlaceholder === false) {
+      try {
+        await core.adapterFor(binding.platform)?.inboundSettled?.(binding, messageId);
+      } catch (error) {
+        core.host.log.warn("chat could not settle inbound message", {
+          messageId,
+          error: describeError(error)
+        });
+      }
+    }
+  }
+  if (failure2 !== void 0) {
+    if (!accepted) await reportFailure();
+    throw failure2.error;
+  }
+  if (outcome?.status === "deferred") outcome.resume?.();
+  if (outcome?.status === "settled") {
+    try {
+      await outcome.respond?.();
+    } catch (error) {
+      core.host.log.warn("chat could not deliver an inbound response", {
+        messageId,
+        error: describeError(error)
+      });
+      throw error;
+    }
+  }
+};
+
 // src/acknowledgements.ts
-var makeAcknowledgements = (core) => {
+var TYPING_KEEPALIVE_MS = 4e3;
+var makeAcknowledgements = (core, intervals) => {
   const { host, adapterFor } = core;
   const acknowledgements = /* @__PURE__ */ new Map();
+  const deferred = /* @__PURE__ */ new Map();
+  const typingKeepalive = /* @__PURE__ */ new Map();
+  const messageKey = (identity2) => JSON.stringify([identity2.platform, identity2.rowId, identity2.chatId, identity2.messageId]);
+  const noteTypingFailure = (error) => {
+    host.log.info("chat could not show typing", { error: describeError(error) });
+  };
+  const clearDeferred = (identity2) => {
+    deferred.delete(messageKey(identity2));
+  };
+  const stopTyping = (threadId) => {
+    const lane = typingKeepalive.get(threadId);
+    if (lane === void 0) return;
+    typingKeepalive.delete(threadId);
+    lane.cancel();
+  };
+  const stopTypingFor = (threadId) => {
+    stopTyping(threadId);
+  };
+  const showTyping = (binding, threadId, sendTyping) => {
+    const existing = typingKeepalive.get(threadId);
+    if (existing !== void 0) {
+      existing.retarget(binding, sendTyping);
+      existing.send();
+      return;
+    }
+    let pending = false;
+    let stopped = false;
+    let currentBinding = binding;
+    let currentSend = sendTyping;
+    const send = () => {
+      if (stopped || pending) return;
+      pending = true;
+      let sending;
+      try {
+        sending = currentSend(currentBinding);
+      } catch (error) {
+        pending = false;
+        noteTypingFailure(error);
+        return;
+      }
+      void sending.catch(noteTypingFailure).finally(() => {
+        pending = false;
+      });
+    };
+    const dispose = intervals({
+      name: `typing-keepalive:${threadId}`,
+      everyMs: TYPING_KEEPALIVE_MS,
+      handle: () => {
+        send();
+      }
+    });
+    typingKeepalive.set(threadId, {
+      send,
+      cancel: () => {
+        stopped = true;
+        dispose();
+      },
+      retarget: (nextBinding, nextSend) => {
+        currentBinding = nextBinding;
+        currentSend = nextSend;
+      }
+    });
+    send();
+  };
   const markWorking = async (binding, threadId, messageId) => {
     const adapter = adapterFor(binding.platform);
     if (adapter?.sendTyping !== void 0) {
-      void adapter.sendTyping(binding).catch((error) => {
-        host.log.info("chat could not show typing", { error: describeError(error) });
-      });
+      showTyping(binding, threadId, adapter.sendTyping.bind(adapter));
     }
     if (adapter?.acknowledge === void 0) return;
     try {
@@ -126186,6 +126322,7 @@ var makeAcknowledgements = (core) => {
     }
   };
   const takeWorking = (binding, threadId, outcome) => {
+    stopTyping(threadId);
     const adapter = adapterFor(binding.platform);
     const clear = adapter?.clearAcknowledge?.bind(adapter);
     const pending = acknowledgements.get(threadId);
@@ -126204,7 +126341,26 @@ var makeAcknowledgements = (core) => {
     };
   };
   const clearWorking = (binding, threadId, outcome) => takeWorking(binding, threadId, outcome)();
-  return { markWorking, takeWorking, clearWorking };
+  const rememberDeferred = (identity2, binding) => {
+    const key2 = messageKey(identity2);
+    if (!deferred.has(key2)) deferred.set(key2, { binding, identity: identity2 });
+  };
+  const stopDeferred = async (rowId) => {
+    for (const [key2, { binding, identity: identity2 }] of [...deferred]) {
+      if (rowId !== void 0 && identity2.rowId !== rowId) continue;
+      if (!deferred.delete(key2)) continue;
+      await runInbound(core, binding, identity2.messageId, async () => ({ status: "settled" }));
+    }
+  };
+  return {
+    markWorking,
+    takeWorking,
+    clearWorking,
+    clearDeferred,
+    rememberDeferred,
+    stopDeferred,
+    stopTypingFor
+  };
 };
 
 // src/botConfig.ts
@@ -128085,7 +128241,8 @@ var makeChatSetup = (core, deps) => {
     await deliver(binding, t("repo.done", { title: target2.title }));
     const pending = pendingMessages.get(chatKey);
     pendingMessages.forget((key2) => key2 === chatKey);
-    if (pending !== void 0) await deps.resumeMessage(binding, pending);
+    if (pending !== void 0)
+      deps.enqueueForChat(chatKey, () => deps.resumeMessage(binding, pending), true);
   };
   const handleRepo = async (binding, arg) => {
     if (arg === "") {
@@ -128139,7 +128296,7 @@ var makeChatSetup = (core, deps) => {
     const only = rows.length === 1 ? rows[0] : void 0;
     return only === void 0 ? { kind: "list" } : { kind: "auto", projectId: only.projectId };
   };
-  const executeProjectDecision = async (binding, message, decision) => {
+  const executeProjectDecision = async (binding, message, decision, deferReply) => {
     if (decision.kind === "loadFailed" || decision.kind === "notFound") {
       await deliver(
         binding,
@@ -128148,8 +128305,18 @@ var makeChatSetup = (core, deps) => {
       return false;
     }
     const chatKey = chatKeyOf(binding);
-    const rows = await loadProjectRows(binding);
-    if (rows === null) return false;
+    const send = async (text3) => {
+      const reply = async () => {
+        await deliver(binding, text3);
+      };
+      if (deferReply === void 0) await reply();
+      else deferReply(reply);
+    };
+    const rows = await readProjectRows(chatKey);
+    if (rows === null) {
+      await send(t("panel.loadFailed"));
+      return false;
+    }
     if (decision.kind === "pick") {
       await selectProject(binding, decision.projectId, rows);
       return false;
@@ -128157,12 +128324,12 @@ var makeChatSetup = (core, deps) => {
     if (decision.kind === "auto") {
       const target2 = rows.find((row) => row.projectId === decision.projectId);
       if (target2 === void 0) {
-        await deliver(binding, t("repo.gone"));
+        await send(t("repo.gone"));
         return false;
       }
       commit("chat-updated", { chatKey, projectId: target2.projectId });
       pendingMessages.forget((key2) => key2 === chatKey);
-      await deliver(binding, t("repo.autoSelected", { title: target2.title }));
+      await send(t("repo.autoSelected", { title: target2.title }));
       return true;
     }
     pendingMessages.set(chatKey, message);
@@ -133373,6 +133540,7 @@ var Uint8Array2 = /* @__PURE__ */ instanceOf(globalThis.Uint8Array, {
 });
 
 // src/chatCommand.ts
+var HISTORY_COUNTS = { defaultCount: 3, maxCount: 5 };
 var SimpleChatCommand = Struct({
   kind: Literals([
     "stop",
@@ -133390,6 +133558,7 @@ var ParsedChatCommand = Union2([
   SimpleChatCommand,
   Struct({ kind: Literal2("sessions"), arg: optionalKey2(String4) }),
   Struct({ kind: Literals(["resume", "model", "repo"]), arg: String4 }),
+  Struct({ kind: Literal2("history"), count: NullOr(Number5) }),
   Struct({
     kind: Literal2("preset"),
     arg: String4,
@@ -133441,6 +133610,16 @@ var parseChatCommand = (input) => {
   if (sessions !== void 0) {
     return sessions === "" ? { kind: "sessions" } : { kind: "sessions", arg: sessions };
   }
+  const history = commandArgument(
+    trimmed,
+    input.chinese,
+    /^\/history(?:\s+([\s\S]*))?$/i,
+    /^会话历史(?:\s+([\s\S]*))?$/
+  );
+  if (history !== void 0) {
+    const count = history === "" ? HISTORY_COUNTS.defaultCount : /^\d+$/.test(history) ? Math.min(Number(history), HISTORY_COUNTS.maxCount) : 0;
+    return { kind: "history", count: count > 0 ? count : null };
+  }
   const resume = resumeArgument(input.text, input.chinese);
   if (resume !== void 0) {
     return resume === "" ? { kind: "sessions" } : { kind: "resume", arg: resume };
@@ -133480,6 +133659,7 @@ var helpText = (t, options = {}) => [
   t("help.new"),
   t("help.sessions"),
   t("help.resume"),
+  t("help.history", HISTORY_COUNTS),
   t("help.syncNote"),
   t("help.model"),
   t("help.preset"),
@@ -133492,6 +133672,175 @@ var helpText = (t, options = {}) => [
   ...options.panel === true ? ["", t("help.panel")] : []
 ].join("\n");
 
+// src/deadline.ts
+var withDeadline = async (timeoutMs, load) => {
+  const signal = AbortSignal.timeout(timeoutMs);
+  let onAbort = () => {
+  };
+  const aborted = new Promise((_, reject) => {
+    onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([load(signal), aborted]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+};
+
+// src/threadMessages.ts
+import {
+  isThreadNotFound,
+  threadMessagesNewestFirst
+} from "@ycodium-ai/plugin-api";
+var PAGE_SIZE = 20;
+async function* newestFirst(threads, threadId) {
+  try {
+    yield* threadMessagesNewestFirst(threads, threadId, { pageSize: PAGE_SIZE });
+  } catch (error) {
+    if (!isThreadNotFound(error)) throw error;
+  }
+}
+async function attachmentsOf(threads, threadId, message) {
+  const collected = [...message.attachments ?? []];
+  const total = message.attachmentsTotal ?? collected.length;
+  while (collected.length < total) {
+    let page;
+    try {
+      page = await threads.messages.list({
+        threadId,
+        messageId: message.id,
+        attachmentOffset: collected.length,
+        textLimit: 2
+      });
+    } catch (error) {
+      if (isThreadNotFound(error)) break;
+      throw error;
+    }
+    const more = page.items[0]?.attachments ?? [];
+    if (more.length === 0) break;
+    collected.push(...more);
+  }
+  return collected;
+}
+async function latestMessage(threads, threadId, accept) {
+  for await (const message of newestFirst(threads, threadId)) {
+    if (accept(message)) return message;
+  }
+  return void 0;
+}
+async function recentMessages(threads, threadId, count, accept) {
+  const collected = [];
+  for await (const message of newestFirst(threads, threadId)) {
+    if (!accept(message)) continue;
+    collected.push(message);
+    if (collected.length >= count) break;
+  }
+  return collected.toReversed();
+}
+async function messagesAfterLastUser(threads, threadId) {
+  const after = [];
+  for await (const message of newestFirst(threads, threadId)) {
+    if (message.role === "user") break;
+    after.push(message);
+  }
+  return after.toReversed();
+}
+
+// src/historyCommand.ts
+var READ_TIMEOUT_MS = 1e4;
+var MAX_PAGES = 3;
+var TEXT_LIMIT = 1e3;
+var makeHistoryCommand = (core) => {
+  const { host, t, deliver } = core;
+  return async (binding, command, chatKind) => {
+    if (chatKind !== "private") {
+      await deliver(binding, t("history.directOnly"));
+      return;
+    }
+    const count = command.count;
+    if (count === null) {
+      await deliver(binding, t("history.usage", HISTORY_COUNTS));
+      return;
+    }
+    const chatKey = chatKeyOf(binding);
+    const threadId = chatOf(core.state, chatKey).threadId;
+    if (threadId === null) {
+      await deliver(binding, t("history.noSession"));
+      return;
+    }
+    const switched = () => {
+      if (chatOf(core.state, chatKey).threadId === threadId) return false;
+      host.log.info("chat cancelled a history read after the session changed", { threadId });
+      return true;
+    };
+    const adapter = core.adapterFor(binding.platform);
+    if (adapter?.sendTyping !== void 0) {
+      void adapter.sendTyping(binding).catch(() => {
+        host.log.info("chat could not show history typing", { threadId });
+      });
+    }
+    let text3;
+    try {
+      text3 = await withDeadline(READ_TIMEOUT_MS, async (signal) => {
+        const threads = {
+          messages: {
+            list: async (input) => {
+              signal.throwIfAborted();
+              const page = await host.threads.messages.list({
+                ...input,
+                textLimit: input.textLimit ?? TEXT_LIMIT
+              });
+              signal.throwIfAborted();
+              return page;
+            }
+          }
+        };
+        let pages = 0;
+        let reachedEnd = false;
+        const bounded = {
+          messages: {
+            list: async (input) => {
+              const page = await threads.messages.list(input);
+              pages += 1;
+              reachedEnd = page.nextCursor === null;
+              return { ...page, nextCursor: pages >= MAX_PAGES ? null : page.nextCursor };
+            }
+          }
+        };
+        const messages = await recentMessages(
+          bounded,
+          threadId,
+          count,
+          (message) => message.role === "user" || message.role === "assistant" && !message.streaming
+        );
+        if (messages.length === 0) return t(reachedEnd ? "history.empty" : "history.noneRecent");
+        const entries = [];
+        for (const message of messages) {
+          const attachments = await attachmentsOf(threads, threadId, message);
+          const body = [
+            message.text.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu, "").trim(),
+            ...message.textWindow?.nextOffset != null ? [t("history.truncated")] : [],
+            ...attachments.map(
+              (attachment) => t(attachment.type === "image" ? "history.image" : "history.file")
+            )
+          ].filter(Boolean).join("\n") || t("history.noText");
+          const role = t(message.role === "user" ? "history.user" : "history.assistant");
+          entries.push(`${entries.length + 1}. ${role}
+${body}`);
+        }
+        return [t("history.title", { count: messages.length }), ...entries].join("\n\n");
+      });
+    } catch {
+      if (switched()) return;
+      host.log.warn("chat could not read history", { threadId });
+      text3 = t("history.failed");
+    }
+    if (switched()) return;
+    await deliver(binding, text3);
+  };
+};
+
 // src/commands.ts
 var NEEDS_PROJECT_COMMANDS = /* @__PURE__ */ new Set(["sessions", "resume", "selectTeam", "selectThread"]);
 var makeCommands = (core, deps) => {
@@ -133501,8 +133850,9 @@ var makeCommands = (core, deps) => {
   const { showSessions, resumeSession } = deps.sessions;
   const { handleModel, handlePlan } = deps.modelPlan;
   const { openPanel } = deps;
+  const handleHistory = makeHistoryCommand(core);
   const targetOf = (binding) => chatOf(core.state, chatKeyOf(binding)).target;
-  const executeCommand = async (binding, command, senderId = null) => {
+  const executeCommand = async (binding, command, senderId = null, chatKind = void 0) => {
     const chatKey = chatKeyOf(binding);
     host.log.info("chat handled a command", {
       bot: binding.displayName,
@@ -133553,6 +133903,9 @@ var makeCommands = (core, deps) => {
       case "sessions":
         await showSessions(binding, command.arg);
         return;
+      case "history":
+        await handleHistory(binding, command, chatKind);
+        return;
       case "resume":
         await resumeSession(binding, command.arg);
         return;
@@ -135185,56 +135538,6 @@ var deliveryFailure = (core, binding, threadId, turnId) => async (error) => {
   }
 };
 
-// src/threadMessages.ts
-import {
-  isThreadNotFound,
-  threadMessagesNewestFirst
-} from "@ycodium-ai/plugin-api";
-var PAGE_SIZE = 20;
-async function* newestFirst(threads, threadId) {
-  try {
-    yield* threadMessagesNewestFirst(threads, threadId, { pageSize: PAGE_SIZE });
-  } catch (error) {
-    if (!isThreadNotFound(error)) throw error;
-  }
-}
-async function attachmentsOf(threads, threadId, message) {
-  const collected = [...message.attachments ?? []];
-  const total = message.attachmentsTotal ?? collected.length;
-  while (collected.length < total) {
-    let page;
-    try {
-      page = await threads.messages.list({
-        threadId,
-        messageId: message.id,
-        attachmentOffset: collected.length,
-        textLimit: 2
-      });
-    } catch (error) {
-      if (isThreadNotFound(error)) break;
-      throw error;
-    }
-    const more = page.items[0]?.attachments ?? [];
-    if (more.length === 0) break;
-    collected.push(...more);
-  }
-  return collected;
-}
-async function latestMessage(threads, threadId, accept) {
-  for await (const message of newestFirst(threads, threadId)) {
-    if (accept(message)) return message;
-  }
-  return void 0;
-}
-async function messagesAfterLastUser(threads, threadId) {
-  const after = [];
-  for await (const message of newestFirst(threads, threadId)) {
-    if (message.role === "user") break;
-    after.push(message);
-  }
-  return after.toReversed();
-}
-
 // src/conclusionDelivery.ts
 var ALWAYS_OWED = () => true;
 var makeConclusionDelivery = (core, anchors) => {
@@ -135604,16 +135907,6 @@ var workForMessage = (message) => ({
 });
 
 // src/inboundRoutes.ts
-var settleInbound = async (core, binding, messageId) => {
-  try {
-    await core.adapterFor(binding.platform)?.inboundSettled?.(binding, messageId);
-  } catch (error) {
-    core.host.log.warn("chat could not settle inbound message", {
-      messageId,
-      error: describeError(error)
-    });
-  }
-};
 var executeInboundRoute = async (core, actions, input) => {
   const { current, message, route, work } = input;
   const target2 = input.target;
@@ -135623,82 +135916,113 @@ var executeInboundRoute = async (core, actions, input) => {
   switch (route.kind) {
     case "command":
       await complete();
-      await actions.commands.executeCommand(target2, route.command, message.senderId);
-      await settleInbound(core, target2, message.messageId);
-      return;
-    case "project":
-      if (route.decision.kind !== "auto") await complete();
-      if (await actions.chatSetup.executeProjectDecision(target2, message, route.decision)) {
-        await actions.continueMessage({
+      await actions.commands.executeCommand(
+        target2,
+        route.command,
+        message.senderId,
+        message.chatKind
+      );
+      return { status: "settled" };
+    case "project": {
+      if (route.decision.kind !== "auto") {
+        await complete();
+        await actions.chatSetup.executeProjectDecision(target2, message, route.decision);
+        return { status: "settled" };
+      }
+      const replies = [];
+      const respond = async () => {
+        for (const reply of replies) await reply();
+      };
+      if (await actions.chatSetup.executeProjectDecision(
+        target2,
+        message,
+        route.decision,
+        (reply) => replies.push(reply)
+      )) {
+        const outcome = await actions.continueMessage({
           ...core.bindingOf(current, message.chatId),
           reply: target2.reply
         });
-      } else {
-        if (route.decision.kind === "auto") await complete();
-        await settleInbound(core, target2, message.messageId);
+        if (outcome.status === "settled")
+          return {
+            status: "settled",
+            respond: async () => {
+              await respond();
+              await outcome.respond?.();
+            }
+          };
+        await respond();
+        return outcome;
       }
-      return;
+      await complete();
+      return { status: "settled", respond };
+    }
     case "question":
       await complete();
       await actions.interactions.questionFlow.answerText(route.answer);
-      await settleInbound(core, target2, message.messageId);
-      return;
+      return { status: "settled" };
     case "approval":
       await complete();
       await actions.approvals.answerByToken(route.token);
-      await settleInbound(core, target2, message.messageId);
-      return;
+      return { status: "settled" };
     case "unavailable":
       await complete();
-      await settleInbound(core, target2, message.messageId);
-      return;
-    case "attachments":
-      await actions.turns.receiveAttachmentsOnly(target2, message, complete);
+      return { status: "settled" };
+    case "attachments": {
+      const outcome = await actions.turns.receiveAttachmentsOnly(target2, message, complete);
       await complete();
-      await settleInbound(core, target2, message.messageId);
-      return;
+      return outcome;
+    }
     case "team": {
       const routed = { ...target2, chatId: route.chatId, projectId: route.projectId };
-      if (message.resources.length > 0)
-        await core.deliver(routed, core.t("reply.attachmentsNoTeam"));
-      const leadThreadId = await actions.teams.startTeamGoal(
+      const outcome = await actions.teams.startTeamGoal(
         routed,
         message,
-        actions.acceptedWork(routed, message, work)
+        actions.acceptedWork(routed, message, work, input.onAccepted)
       );
-      if (leadThreadId === null) {
+      if (outcome.status === "settled") {
         await complete();
-        await settleInbound(core, target2, message.messageId);
+        return {
+          status: "settled",
+          respond: async () => {
+            if (message.resources.length > 0)
+              await core.deliver(routed, core.t("reply.attachmentsNoTeam"));
+            await outcome.respond?.();
+          }
+        };
       }
-      return;
+      if (message.resources.length > 0)
+        await core.deliver(routed, core.t("reply.attachmentsNoTeam"));
+      return outcome;
     }
     case "turn":
-      await actions.openTurn(
+      return actions.openTurn(
         { ...target2, chatId: route.chatId, projectId: route.projectId },
         message,
-        work
+        work,
+        input.onAccepted
       );
-      return;
     case "handoff": {
-      const executeHandoff = async () => {
+      const executeHandoff = async (onAccepted) => {
         actions.inheritFromParent(current, route.chatId, message.chatId);
         const child = {
           ...core.bindingOf(current, route.chatId),
           projectId: route.projectId,
           reply: target2.reply
         };
-        await actions.openTurn(child, message, work);
+        return actions.openTurn(child, message, work, onAccepted);
       };
       if (input.queueChatId === route.chatId) {
-        await executeHandoff();
-        return;
+        return executeHandoff(input.onAccepted);
       }
-      actions.enqueueForChat(
-        chatKeyOf({ rowId: current.rowId, chatId: route.chatId }),
-        executeHandoff,
-        true
-      );
-      return;
+      return {
+        status: "deferred",
+        resume: () => actions.enqueueForChat(
+          chatKeyOf({ rowId: current.rowId, chatId: route.chatId }),
+          () => actions.run(executeHandoff),
+          true
+        )
+      };
     }
   }
 };
@@ -135875,16 +136199,14 @@ var makeInbound = (core, deps) => {
     }));
     return true;
   };
-  const turnAwayStranger = (target2, sender) => {
+  const turnAwayStranger = async (target2, sender) => {
     host.log.warn("chat ignored a message from someone not on the allow list", {
       bot: target2.displayName,
       sender
     });
     if (sender === null) return;
     if (!notAllowedReplyCooldown.tryAcquire(`${target2.rowId}:${sender}`)) return;
-    enqueueForChat(chatKeyOf(target2), async () => {
-      await deliver(target2, t("reply.notAllowedYet", { id: sender }));
-    });
+    await deliver(target2, t("reply.notAllowedYet", { id: sender }));
   };
   const currentBot = (rowId) => bots().find((candidate) => candidate.rowId === rowId);
   const inheritFromParent = (bot, chatId, parentChatId) => {
@@ -135911,24 +136233,24 @@ var makeInbound = (core, deps) => {
     if (known === void 0) noteChatAlias(bot, message.chatAlias, message.chatId);
     return known === void 0 || known === message.chatId ? message : { ...message, chatId: known };
   };
-  const acceptedWork = (speaker, message, work) => async (threadId, register) => {
-    await markWorking(speaker, threadId, message.messageId);
-    await register?.();
-    if (work !== void 0) await inboundState.complete(speaker.rowId, work.key);
-  };
-  const openTurn = async (speaker, message, work) => {
-    await startTurn(
-      speaker,
-      message,
-      acceptedWork(speaker, message, work),
-      work === void 0 ? void 0 : processingFor(inboundState, speaker.rowId, work, () => {
-        replay.enqueue(speaker.rowId, work.key, Promise.resolve(true));
-      })
-    );
-  };
+  const acceptedWork = (speaker, message, work, onAccepted) => Object.assign(
+    async (threadId, register) => {
+      await markWorking(speaker, threadId, message.messageId);
+      await register?.();
+      if (work !== void 0) await inboundState.complete(speaker.rowId, work.key);
+    },
+    { onAccepted }
+  );
+  const openTurn = (speaker, message, work, onAccepted) => startTurn(
+    speaker,
+    message,
+    acceptedWork(speaker, message, work, onAccepted),
+    work === void 0 ? void 0 : processingFor(inboundState, speaker.rowId, work, () => {
+      replay.enqueue(speaker.rowId, work.key, Promise.resolve(true));
+    })
+  );
   const resumeMessage = async (current, message, work, queueChatId = message.chatId) => {
-    inheritFromParent(current, message.chatId, message.parentChatId);
-    const target2 = {
+    let target2 = {
       ...bindingOf2(current, message.chatId),
       reply: anchorOfMessage(adapterFor(current.platform), message)
     };
@@ -135939,14 +136261,24 @@ var makeInbound = (core, deps) => {
     const complete = async () => {
       if (work !== void 0) await inboundState.complete(current.rowId, work.key);
     };
+    const identity2 = {
+      platform: current.platform,
+      rowId: current.rowId,
+      chatId: message.chatId,
+      messageId: message.messageId
+    };
+    const run2 = (execute2) => runInbound(core, target2, message.messageId, execute2, {
+      rememberDeferred: () => deps.acknowledgements.rememberDeferred(identity2, target2),
+      clearDeferred: () => deps.acknowledgements.clearDeferred(identity2),
+      complete
+    });
     const continueMessage = async (target3) => {
       const boundThread = chatOf(core.state, chatKey).threadId;
       const answer = boundThread === null ? void 0 : questionFlow.textAnswer(chatKey, boundThread, message.text);
       if (answer !== void 0) {
         const route2 = { kind: "question", answer };
         await saveRoute(route2);
-        await execute(route2, target3);
-        return;
+        return execute(route2, target3);
       }
       const project = await projectOrNull(host.projects, target3.projectId);
       if (project === null || project.archivedAt != null) {
@@ -135958,14 +136290,16 @@ var makeInbound = (core, deps) => {
             projectId: target3.projectId
           });
         }
-        if (archivedReplyCooldown.tryAcquire(chatKey)) {
-          await deliver(
-            target3,
-            project === null ? t("reply.projectMissing") : t("reply.projectArchived", { title: project.title })
-          );
-        }
-        await settleInbound(core, target3, message.messageId);
-        return;
+        return {
+          status: "settled",
+          respond: async () => {
+            if (archivedReplyCooldown.tryAcquire(chatKey))
+              await deliver(
+                target3,
+                project === null ? t("reply.projectMissing") : t("reply.projectArchived", { title: project.title })
+              );
+          }
+        };
       }
       const routed = targetOf(target3);
       const attachmentsOnly = message.text.trim() === "" && message.resources.length > 0;
@@ -135973,20 +136307,21 @@ var makeInbound = (core, deps) => {
         if (attachmentsOnly) {
           await saveRoute({ kind: "unavailable" });
           await complete();
-          await deliver(target3, t("reply.attachmentsNoTeam"));
-          await settleInbound(core, target3, message.messageId);
-          return;
+          return {
+            status: "settled",
+            respond: async () => {
+              await deliver(target3, t("reply.attachmentsNoTeam"));
+            }
+          };
         }
         const route2 = { kind: "team", chatId: target3.chatId, projectId: target3.projectId };
         await saveRoute(route2);
-        await execute(route2, target3);
-        return;
+        return execute(route2, target3);
       }
       if (attachmentsOnly) {
         const route2 = { kind: "attachments" };
         await saveRoute(route2);
-        await execute(route2, target3);
-        return;
+        return execute(route2, target3);
       }
       const branchChatId = hasWaitingAttachments(chatKey) ? void 0 : message.branchChatId;
       const route = {
@@ -135995,62 +136330,65 @@ var makeInbound = (core, deps) => {
         projectId: target3.projectId
       };
       await saveRoute(route);
-      await execute(route, target3);
+      return execute(route, target3);
     };
     const execute = (route, routedTarget = target2) => executeInboundRoute(
       core,
-      { ...deps, openTurn, acceptedWork, inheritFromParent, continueMessage },
-      { current, message, target: routedTarget, route, work, queueChatId }
+      { ...deps, openTurn, acceptedWork, inheritFromParent, continueMessage, run: run2 },
+      { current, message, target: routedTarget, route, work, queueChatId, onAccepted }
     );
-    if (work?.route !== void 0) {
-      await execute(work.route);
-      return;
-    }
-    if (!isAllowedSender(target2, message.senderId, message.chatKind)) {
-      await saveRoute({ kind: "unavailable" });
-      await complete();
-      turnAwayStranger(target2, message.senderId);
-      await settleInbound(core, target2, message.messageId);
-      return;
-    }
-    if (message.unsupportedType !== void 0) {
-      await saveRoute({ kind: "unavailable" });
-      await complete();
-      if (unsupportedReplyCooldown.tryAcquire(chatKey))
-        await deliver(
-          target2,
-          message.unsupportedType === "folder" ? t("reply.unsupportedFolder") : message.unsupportedType === "voice" ? t("reply.unsupportedVoice") : t("reply.unsupportedType", { type: message.unsupportedType })
-        );
-      await settleInbound(core, target2, message.messageId);
-      return;
-    }
-    const approval = openApprovalOf(core.state, chatKey);
-    const token = approval === void 0 ? null : adapterFor(target2.platform)?.answerByText?.(target2, message.text, approval.options) ?? null;
-    if (token !== null) {
-      const route = { kind: "approval", token };
-      await saveRoute(route);
-      await execute(route);
-      return;
-    }
-    const command = parseChatCommand({
-      text: message.text,
-      chinese: t.language === "zh-CN",
-      hasImages: message.resources.length > 0
-    });
-    if (command.kind !== "message") {
-      const route = { kind: "command", command };
-      await saveRoute(route);
-      await execute(route);
-      return;
-    }
-    if (target2.projectId === "") {
-      const decision = await decideProjectMessage(target2, message);
-      const route = { kind: "project", decision };
-      await saveRoute(route);
-      await execute(route);
-      return;
-    }
-    await continueMessage(target2);
+    let onAccepted;
+    const executeMessage = async (accepted) => {
+      onAccepted = accepted;
+      inheritFromParent(current, message.chatId, message.parentChatId);
+      target2 = { ...bindingOf2(current, message.chatId), reply: target2.reply };
+      if (work?.route !== void 0) return execute(work.route);
+      if (!isAllowedSender(target2, message.senderId, message.chatKind)) {
+        await saveRoute({ kind: "unavailable" });
+        await complete();
+        return { status: "settled", respond: () => turnAwayStranger(target2, message.senderId) };
+      }
+      const unsupportedType = message.unsupportedType;
+      if (unsupportedType !== void 0) {
+        await saveRoute({ kind: "unavailable" });
+        await complete();
+        return {
+          status: "settled",
+          respond: async () => {
+            if (unsupportedReplyCooldown.tryAcquire(chatKey))
+              await deliver(
+                target2,
+                unsupportedType === "folder" ? t("reply.unsupportedFolder") : unsupportedType === "voice" ? t("reply.unsupportedVoice") : t("reply.unsupportedType", { type: unsupportedType })
+              );
+          }
+        };
+      }
+      const approval = openApprovalOf(core.state, chatKey);
+      const token = approval === void 0 ? null : adapterFor(target2.platform)?.answerByText?.(target2, message.text, approval.options) ?? null;
+      if (token !== null) {
+        const route = { kind: "approval", token };
+        await saveRoute(route);
+        return execute(route);
+      }
+      const command = parseChatCommand({
+        text: message.text,
+        chinese: t.language === "zh-CN",
+        hasImages: message.resources.length > 0
+      });
+      if (command.kind !== "message") {
+        const route = { kind: "command", command };
+        await saveRoute(route);
+        return execute(route);
+      }
+      if (target2.projectId === "") {
+        const decision = await decideProjectMessage(target2, message);
+        const route = { kind: "project", decision };
+        await saveRoute(route);
+        return execute(route);
+      }
+      return continueMessage(target2);
+    };
+    await run2(executeMessage);
   };
   const inboundHandlersFor = (bot) => ({
     onError: (message) => host.log.warn("chat inbound connection failed", {
@@ -136137,7 +136475,10 @@ var makeInbound = (core, deps) => {
     inboundHandlersFor,
     resumeMessage,
     enqueueReplay,
-    cancelReplay: replay.cancelReplay,
+    cancelReplay: (rowId) => {
+      replay.cancelReplay(rowId);
+      track(deps.acknowledgements.stopDeferred(rowId));
+    },
     stop: async () => {
       accepting = false;
       replay.stop();
@@ -137410,7 +137751,7 @@ var ConsoleError = class extends Error {
     this.retryAfterMs = extra.retryAfterMs;
   }
 };
-var withDeadline = async (deps, ms, run2) => {
+var withDeadline2 = async (deps, ms, run2) => {
   const controller = new AbortController();
   const timer = new AbortController();
   let timedOut = false;
@@ -137437,7 +137778,7 @@ var withDeadline = async (deps, ms, run2) => {
     deps.signal.removeEventListener("abort", onParentAbort);
   }
 };
-var guarded = withDeadline;
+var guarded = withDeadline2;
 var sleepOrAbort = async (deps, ms) => {
   try {
     await deps.clock.sleep(ms, deps.signal);
@@ -137469,7 +137810,7 @@ var retryAfterMs = (response) => {
 };
 var openConsole = async (deps, jar) => {
   const pageUrl = `${CONSOLE_ORIGIN}${CONSOLE_APP_PATH}`;
-  const loadPage = () => withDeadline(deps, TIMEOUT_MS.page, async (signal) => {
+  const loadPage = () => withDeadline2(deps, TIMEOUT_MS.page, async (signal) => {
     const { response, finalUrl } = await jar.fetch(deps.fetch, pageUrl, {
       method: "GET",
       headers: { accept: "text/html,application/xhtml+xml" },
@@ -137498,7 +137839,7 @@ var openConsole = async (deps, jar) => {
     calls += 1;
     const started = deps.clock.now();
     try {
-      const result2 = await withDeadline(deps, timeoutOf(kind), async (signal) => {
+      const result2 = await withDeadline2(deps, timeoutOf(kind), async (signal) => {
         const { response } = await jar.fetch(deps.fetch, `${origin}${path}`, {
           method: "POST",
           headers: {
@@ -145068,22 +145409,6 @@ var larkInboundPersistence = (contextFor) => ({
   }
 });
 
-// src/deadline.ts
-var withDeadline2 = async (timeoutMs, load) => {
-  const signal = AbortSignal.timeout(timeoutMs);
-  let onAbort = () => {
-  };
-  const aborted = new Promise((_, reject) => {
-    onAbort = () => reject(signal.reason);
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-  try {
-    return await Promise.race([load(signal), aborted]);
-  } finally {
-    signal.removeEventListener("abort", onAbort);
-  }
-};
-
 // src/boundedSeen.ts
 var makeBoundedSeen = (limit) => {
   const seen = /* @__PURE__ */ new Set();
@@ -145229,7 +145554,7 @@ var errorReason = (error) => {
 };
 var loadReplyReference = async (load) => {
   try {
-    return await withDeadline2(LOAD_TIMEOUT_MS, load) ?? { unavailableReason: "not-found" };
+    return await withDeadline(LOAD_TIMEOUT_MS, load) ?? { unavailableReason: "not-found" };
   } catch (error) {
     return { unavailableReason: errorReason(error) };
   }
@@ -145248,7 +145573,7 @@ var makeLookup = (rowId, load) => {
     if (known !== void 0 && Date.now() - known.at < CACHE_MS) return known.value;
     const pending = inflight.get(key2);
     if (pending !== void 0) return pending;
-    const reading = withDeadline2(LOOKUP_TIMEOUT_MS, (signal) => load(id, signal)).catch(() => null).then((value2) => {
+    const reading = withDeadline(LOOKUP_TIMEOUT_MS, (signal) => load(id, signal)).catch(() => null).then((value2) => {
       cache.set(key2, { value: value2, at: Date.now() });
       return value2;
     }).finally(() => inflight.delete(key2));
@@ -145428,7 +145753,7 @@ ${indent}  `)}`;
 };
 var loadMergeForward = async (message, deps) => {
   try {
-    const items = await withDeadline2(1e4, async (signal) => {
+    const items = await withDeadline(1e4, async (signal) => {
       const token = await deps.tenantToken();
       signal.throwIfAborted();
       return fetchMergeForwardMessages({
@@ -145848,6 +146173,8 @@ var en_default = {
     sendingFile: "Sending {{name}}:",
     notAllowedYet: `You are not on the allow list yet. Your user id is {{id}}. Add it under Settings \u2192 Plugins \u2192 Chat, in this bot's "Allowed people" box.`,
     received: "Got it, working on it.",
+    inboundFailed: "This message couldn't be handled. Please send it again later.",
+    inboundDeferred: "No need to send this again \u2014 it will be handled automatically the next time the machine starts.",
     welcome: "Connected. Send text or images to get started, or send /help to see the available commands."
   },
   approval: {
@@ -145932,9 +146259,10 @@ var en_default = {
     new: "\xB7 /new \u2014 forget the current session; the next message starts a new one",
     team: "\xB7 /team \u2014 give this project's team a goal with each message; use /repo to pick the project first",
     thread: "\xB7 /thread \u2014 go back to a normal session",
-    aliases: "Chinese shortcuts (\u505C / \u7EE7\u7EED\u53D1\u9001 / \u72B6\u6001 / \u65B0\u5BF9\u8BDD / \u4F1A\u8BDD\u5217\u8868 / \u5207\u6362\u4F1A\u8BDD / \u6362\u6A21\u578B / \u8BA1\u5212\u6A21\u5F0F / \u6362\u9879\u76EE / \u5EFA\u7FA4 / \u6362\u56E2\u961F / \u6362\u5BF9\u8BDD) work when the reply language is Chinese.",
+    aliases: "Chinese shortcuts (\u505C / \u7EE7\u7EED\u53D1\u9001 / \u72B6\u6001 / \u65B0\u5BF9\u8BDD / \u4F1A\u8BDD\u5217\u8868 / \u5207\u6362\u4F1A\u8BDD / \u4F1A\u8BDD\u5386\u53F2 / \u6362\u6A21\u578B / \u8BA1\u5212\u6A21\u5F0F / \u6362\u9879\u76EE / \u5EFA\u7FA4 / \u6362\u56E2\u961F / \u6362\u5BF9\u8BDD) work when the reply language is Chinese.",
     sessions: "\xB7 /sessions \u2014 list this project's sessions; add a project number from /repo to list the ones this bot opened in another project",
     resume: "\xB7 /resume number-or-id-prefix \u2014 switch sessions; one from another project switches the project too",
+    history: "\xB7 /history [count] \u2014 preview recent messages in the current session, in private chats only (default {{defaultCount}}, maximum {{maxCount}})",
     model: "\xB7 /model \u2014 see the model this chat uses; /model number or /model instance/model switches it",
     preset: "\xB7 /preset \u2014 see the preset this chat uses for new sessions; /preset number or /preset name-or-id switches it; /preset none clears the chat choice",
     plan: "\xB7 /plan \u2014 toggle plan mode (the agent proposes a plan instead of acting); /plan on, /plan off set it",
@@ -145943,6 +146271,21 @@ var en_default = {
     group: "\xB7 /group name \u2014 Lark only: the bot creates a group and adds you (bots on other platforms cannot)",
     syncNote: "\xB7 After a private chat attaches a session, web user text and final assistant text sync here (groups never sync)."
   },
+  history: {
+    usage: "Usage: /history [count] \u2014 1 to {{maxCount}} (larger numbers count as {{maxCount}}), default {{defaultCount}}.",
+    directOnly: "In a group this would show the session to everyone. Send /history in a private chat with the bot.",
+    noSession: "This chat has no current session. Send a message to start one, or use /sessions to find a session and /resume to switch to it.",
+    empty: "No messages to show in this session yet.",
+    noneRecent: "Nothing to show among this session's most recent messages (older ones were not checked).",
+    failed: "Could not read the recent messages. Try again in a moment.",
+    title: "Recent messages in this session ({{count}}):",
+    user: "User",
+    assistant: "Assistant",
+    image: "[Image]",
+    file: "[File]",
+    noText: "[No previewable text]",
+    truncated: "[Remaining text omitted]"
+  },
   sessions: {
     title: "This project's sessions ({{count}}):",
     empty: "This bot has not opened any session in this project yet. Send a message to start one.",
@@ -146755,6 +147098,8 @@ var zh_CN_default = {
     sendingFile: "\u6B63\u5728\u53D1\u9001 {{name}}\uFF1A",
     notAllowedYet: "\u4F60\u8FD8\u4E0D\u5728\u5141\u8BB8\u540D\u5355\u91CC\uFF0C\u4F60\u7684\u7528\u6237 id \u662F {{id}}\uFF0C\u8BF7\u628A\u5B83\u586B\u8FDB \u8BBE\u7F6E \u2192 \u63D2\u4EF6 \u2192 \u804A\u5929 \u2192 \u8FD9\u4E2A\u673A\u5668\u4EBA\u7684\u300C\u5141\u8BB8\u7684\u4EBA\u300D\u3002",
     received: "\u6536\u5230\uFF0C\u5728\u5904\u7406\u3002",
+    inboundFailed: "\u8FD9\u6761\u6D88\u606F\u5904\u7406\u65F6\u51FA\u4E86\u9519\uFF0C\u8BF7\u7A0D\u540E\u91CD\u53D1\u3002",
+    inboundDeferred: "\u4E0D\u7528\u91CD\u53D1\uFF1A\u673A\u5668\u4E0B\u6B21\u542F\u52A8\u65F6\u4F1A\u81EA\u52A8\u5904\u7406\u8FD9\u6761\u6D88\u606F\u3002",
     welcome: "\u5DF2\u8FDE\u4E0A\u3002\u76F4\u63A5\u53D1\u6587\u5B57\u6216\u56FE\u7247\u5C31\u80FD\u5F00\u59CB\uFF0C\u53D1 /help \u770B\u80FD\u7528\u7684\u547D\u4EE4\u3002"
   },
   approval: {
@@ -146839,9 +147184,10 @@ var zh_CN_default = {
     new: "\xB7 /new \u2014\u2014 \u5FD8\u6389\u5F53\u524D\u4F1A\u8BDD\uFF0C\u4E0B\u4E00\u53E5\u5F00\u65B0\u7684",
     team: "\xB7 /team \u2014\u2014 \u6BCF\u6761\u6D88\u606F\u90FD\u7ED9\u8FD9\u4E2A\u9879\u76EE\u7684\u56E2\u961F\u5F00\u4E00\u4E2A\u76EE\u6807\uFF1B\u5148\u7528 /repo \u9009\u9879\u76EE",
     thread: "\xB7 /thread \u2014\u2014 \u5207\u56DE\u666E\u901A\u4F1A\u8BDD",
-    aliases: "\u4E2D\u6587\u4E5F\u884C\uFF1A\u505C / \u7EE7\u7EED\u53D1\u9001 / \u72B6\u6001 / \u65B0\u5BF9\u8BDD / \u4F1A\u8BDD\u5217\u8868 / \u5207\u6362\u4F1A\u8BDD / \u6362\u6A21\u578B / \u8BA1\u5212\u6A21\u5F0F / \u6362\u9879\u76EE / \u5EFA\u7FA4 / \u6362\u56E2\u961F / \u6362\u5BF9\u8BDD\u3002",
+    aliases: "\u4E2D\u6587\u4E5F\u884C\uFF1A\u505C / \u7EE7\u7EED\u53D1\u9001 / \u72B6\u6001 / \u65B0\u5BF9\u8BDD / \u4F1A\u8BDD\u5217\u8868 / \u5207\u6362\u4F1A\u8BDD / \u4F1A\u8BDD\u5386\u53F2 / \u6362\u6A21\u578B / \u8BA1\u5212\u6A21\u5F0F / \u6362\u9879\u76EE / \u5EFA\u7FA4 / \u6362\u56E2\u961F / \u6362\u5BF9\u8BDD\u3002",
     sessions: "\xB7 /sessions \u2014\u2014 \u5217\u51FA\u672C\u9879\u76EE\u7684\u4F1A\u8BDD\uFF1B\u52A0 /repo \u91CC\u7684\u9879\u76EE\u7F16\u53F7\uFF0C\u5217\u51FA\u672C\u673A\u5668\u4EBA\u5728\u522B\u7684\u9879\u76EE\u5F00\u8FC7\u7684",
     resume: "\xB7 /resume \u7F16\u53F7\u6216 id \u5F00\u5934 \u2014\u2014 \u5207\u4F1A\u8BDD\uFF1B\u522B\u7684\u9879\u76EE\u7684\u4F1A\u8BDD\u4F1A\u8FDE\u540C\u9879\u76EE\u4E00\u8D77\u5207",
+    history: "\xB7 /history [\u6570\u91CF] \u2014\u2014 \u4EC5\u79C1\u804A\uFF1A\u67E5\u770B\u5F53\u524D\u4F1A\u8BDD\u6700\u8FD1\u7684\u6D88\u606F\uFF08\u9ED8\u8BA4 {{defaultCount}} \u6761\uFF0C\u6700\u591A {{maxCount}} \u6761\uFF09",
     model: "\xB7 /model \u2014\u2014 \u770B\u8FD9\u4E2A\u804A\u5929\u7528\u7684\u6A21\u578B\uFF1B/model \u7F16\u53F7 \u6216 /model \u5B9E\u4F8B/\u6A21\u578B \u5207\u6362",
     preset: "\xB7 /preset \u2014\u2014 \u770B\u8FD9\u4E2A\u804A\u5929\u65B0\u4F1A\u8BDD\u7528\u7684\u9884\u8BBE\uFF1B/preset \u7F16\u53F7 \u6216 /preset \u540D\u5B57\u6216 id \u5207\u6362\uFF1B/preset none \u6E05\u6389\u804A\u5929\u9009\u62E9",
     plan: "\xB7 /plan \u2014\u2014 \u5F00\u5173\u8BA1\u5212\u6A21\u5F0F\uFF08agent \u5148\u51FA\u8BA1\u5212\u3001\u4E0D\u52A8\u624B\uFF09\uFF1B/plan on\u3001/plan off \u660E\u786E\u8BBE\u5B9A",
@@ -146850,6 +147196,21 @@ var zh_CN_default = {
     group: "\xB7 /group \u7FA4\u540D \u2014\u2014 \u4EC5\u98DE\u4E66\uFF1A\u673A\u5668\u4EBA\u5EFA\u4E00\u4E2A\u7FA4\u5E76\u628A\u4F60\u62C9\u8FDB\u53BB\uFF08\u522B\u7684\u5E73\u53F0\u7684\u673A\u5668\u4EBA\u5EFA\u4E0D\u4E86\u7FA4\uFF09",
     syncNote: "\xB7 \u79C1\u804A\u9644\u7740\u4F1A\u8BDD\u540E\uFF0C\u7F51\u9875\u4E0A\u7684\u7528\u6237\u6587\u5B57\u4E0E\u7EC8\u6001\u52A9\u624B\u6587\u5B57\u4F1A\u540C\u6B65\u5230\u6B64\uFF08\u7FA4\u804A\u4E0D\u540C\u6B65\uFF09\u3002"
   },
+  history: {
+    usage: "\u7528\u6CD5\uFF1A/history [\u6570\u91CF] \u2014\u2014 1\u2013{{maxCount}} \u6761\uFF08\u8D85\u51FA\u6309 {{maxCount}} \u6761\u7B97\uFF09\uFF0C\u9ED8\u8BA4 {{defaultCount}} \u6761\u3002",
+    directOnly: "\u5728\u7FA4\u91CC\u4F1A\u628A\u4F1A\u8BDD\u5185\u5BB9\u53D1\u7ED9\u6240\u6709\u4EBA\u3002\u5728\u4E0E\u673A\u5668\u4EBA\u7684\u79C1\u804A\u91CC\u53D1 /history\u3002",
+    noSession: "\u8FD9\u4E2A\u804A\u5929\u8FD8\u6CA1\u6709\u5F53\u524D\u4F1A\u8BDD\u3002\u53D1\u4E00\u53E5\u8BDD\u5F00\u4E00\u4E2A\uFF0C\u6216\u5148\u7528 /sessions \u627E\u5230\u4F1A\u8BDD\uFF0C\u518D\u7528 /resume \u5207\u8FC7\u53BB\u3002",
+    empty: "\u5F53\u524D\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u80FD\u67E5\u770B\u7684\u6D88\u606F\u3002",
+    noneRecent: "\u5F53\u524D\u4F1A\u8BDD\u6700\u8FD1\u7684\u6D88\u606F\u91CC\u6CA1\u6709\u80FD\u67E5\u770B\u7684\uFF08\u66F4\u65E9\u7684\u6CA1\u6709\u5F80\u524D\u7FFB\uFF09\u3002",
+    failed: "\u6CA1\u80FD\u8BFB\u53D6\u6700\u8FD1\u7684\u6D88\u606F\uFF0C\u7A0D\u540E\u518D\u8BD5\u3002",
+    title: "\u5F53\u524D\u4F1A\u8BDD\u6700\u8FD1\u7684\u6D88\u606F\uFF08{{count}} \u6761\uFF09\uFF1A",
+    user: "\u7528\u6237",
+    assistant: "\u52A9\u624B",
+    image: "[\u56FE\u7247]",
+    file: "[\u6587\u4EF6]",
+    noText: "[\u6CA1\u6709\u53EF\u9884\u89C8\u7684\u6587\u5B57]",
+    truncated: "[\u5176\u4F59\u6587\u5B57\u5DF2\u7701\u7565]"
+  },
   sessions: {
     title: "\u672C\u9879\u76EE\u7684\u4F1A\u8BDD\uFF08{{count}} \u6761\uFF09\uFF1A",
     empty: "\u672C\u673A\u5668\u4EBA\u8FD8\u6CA1\u5728\u672C\u9879\u76EE\u5F00\u8FC7\u4F1A\u8BDD\uFF0C\u53D1\u4E00\u53E5\u8BDD\u5C31\u4F1A\u5F00\u4E00\u6761\u3002",
@@ -147604,7 +147965,7 @@ var CREATE_INTERVAL_MS = 1100;
 var syncLarkSlashCommands = async (input) => {
   const request = async (method, id, body) => {
     input.signal.throwIfAborted();
-    return withDeadline2(REQUEST_TIMEOUT_MS, async (timeout2) => {
+    return withDeadline(REQUEST_TIMEOUT_MS, async (timeout2) => {
       const signal = AbortSignal.any([input.signal, timeout2]);
       const response = await input.http(
         id === void 0 ? ENDPOINT : `${ENDPOINT}/${encodeURIComponent(id)}`,
@@ -147681,7 +148042,7 @@ var makeLarkSlashCommands = (deps) => {
     const run2 = app.settled.then(async () => {
       if (signal.aborted) return;
       try {
-        const token = await withDeadline2(
+        const token = await withDeadline(
           REQUEST_TIMEOUT_MS,
           (timeout2) => deps.tenantToken(bot, AbortSignal.any([signal, timeout2]))
         );
@@ -148159,14 +148520,14 @@ var makeLarkAdapter = (deps) => {
     }),
     clearAcknowledge: async (binding, messageId, ackId, outcome) => {
       const token = await tenantToken(binding);
-      await withDeadline2(
+      await withDeadline(
         LARK_REACTION_TIMEOUT_MS,
         (signal) => removeReaction({ http: deps.http, token, messageId, reactionId: ackId, signal })
       );
       const emojiType = outcome === "done" ? LARK_DONE_REACTION : outcome === "failed" ? LARK_FAILED_REACTION : null;
       if (emojiType === null) return;
       try {
-        await withDeadline2(
+        await withDeadline(
           LARK_REACTION_TIMEOUT_MS,
           (signal) => addReaction({ http: deps.http, token, messageId, emojiType, signal })
         );
@@ -148436,7 +148797,7 @@ var outcomeOfSession = (status) => {
 var THREAD_PROJECT_CACHE_LIMIT = 256;
 var makeNotifications = (core, deps) => {
   const { host, adapterFor, bindingForChatKey, ready } = core;
-  const { takeWorking } = deps;
+  const { takeWorking, stopTypingFor } = deps;
   const { turnCards } = deps.replyCards;
   const { failures, conclusions, delivery } = deps;
   const { recoverConclusion, recoverConclusions } = makeConclusionRecovery(
@@ -148489,6 +148850,7 @@ var makeNotifications = (core, deps) => {
       const threadId = payload.threadId;
       if (typeof threadId !== "string") return;
       if (payload.session?.activeTurnId != null) return;
+      stopTypingFor(threadId);
       const outcome = outcomeOfSession(payload.session?.status);
       const said = threadsWithSomethingToReport.delete(threadId);
       await ready;
@@ -148533,6 +148895,7 @@ var makeNotifications = (core, deps) => {
   host.events.on("thread.failed", async (event) => {
     const threadId = event.threadId;
     if (threadId === null) return;
+    stopTypingFor(threadId);
     threadsWithSomethingToReport.delete(threadId);
     await ready;
     const targets = targetsForProject(threadId, await projectOfThread(threadId));
@@ -150072,6 +150435,7 @@ var makeTeamGoals = (core) => {
   };
   const startTeamGoal = async (binding, message, accepted) => {
     let goal;
+    let confirmConsumed;
     try {
       const requestId = teamGoalRequestId(binding, message.messageId);
       const topicRoot = await message.topicRootForSession?.(requestId);
@@ -150086,24 +150450,30 @@ var makeTeamGoals = (core) => {
         }
       });
       if (isRecord3(result2) && result2._tag === "TeamGoalRejection") {
-        await deliver(
-          binding,
-          t(
-            result2.code === "no-roster" ? "team.noRoster" : result2.code === "invalid-goal" ? "team.invalidGoal" : "team.startFailed"
-          )
-        );
-        return null;
+        const key2 = result2.code === "no-roster" ? "team.noRoster" : result2.code === "invalid-goal" ? "team.invalidGoal" : "team.startFailed";
+        return {
+          status: "settled",
+          respond: async () => {
+            await deliver(binding, t(key2));
+          }
+        };
       }
       if (!isRecord3(result2) || typeof result2.leadThreadId !== "string" || result2.leadThreadId === "" || result2.leadName !== null && typeof result2.leadName !== "string") {
         throw new Error("team startGoal returned an invalid result");
       }
-      topicRoot?.confirmConsumed();
       goal = { leadThreadId: result2.leadThreadId, leadName: result2.leadName };
+      confirmConsumed = () => topicRoot?.confirmConsumed();
     } catch (error) {
       host.log.warn("chat could not start the team goal", { error: describeError(error) });
-      await deliver(binding, t("team.startFailed"));
-      return null;
+      return {
+        status: "settled",
+        respond: async () => {
+          await deliver(binding, t("team.startFailed"));
+        }
+      };
     }
+    accepted?.onAccepted?.();
+    confirmConsumed();
     await commitDurably("team-goal-started", {
       chatKey: chatKeyOf(binding),
       threadId: goal.leadThreadId
@@ -150117,7 +150487,7 @@ var makeTeamGoals = (core) => {
       bot: binding.displayName,
       threadId: goal.leadThreadId
     });
-    return goal.leadThreadId;
+    return { status: "started", claimsPlaceholder: false };
   };
   return { hasRosterFor, startTeamGoal };
 };
@@ -151350,12 +151720,11 @@ var dispatchTurnWithReceipt = async (host, input, options) => {
 var DELAYS = [3e4, 12e4, 6e5];
 var MAX_DISPATCH_ATTEMPTS = DELAYS.length + 1;
 var makeTurnRetry = (core, deps) => async (binding, input, inbox, restoreCarried, messageText2, firstAttachmentName) => {
-  if (deps.signal.aborted) return false;
+  if (deps.signal.aborted) return { status: "deferred" };
   const previous = inbox?.entry?.attempts ?? 0;
   const attempt = Math.min(previous + 1, MAX_DISPATCH_ATTEMPTS);
   const nextAttemptAt = inbox?.entry?.nextAttemptAt;
   const incremented = previous < MAX_DISPATCH_ATTEMPTS;
-  if (incremented) await inbox?.saveRetry(attempt, nextAttemptAt);
   const reference2 = dispatchFailureReference(input.requestId);
   const notify = async (text3) => {
     try {
@@ -151368,6 +151737,18 @@ var makeTurnRetry = (core, deps) => async (binding, input, inbox, restoreCarried
       });
     }
   };
+  if (incremented) {
+    try {
+      await inbox?.saveRetry(attempt, nextAttemptAt);
+    } catch (error) {
+      core.host.log.warn("chat could not save a dispatch attempt; leaving it for replay", {
+        threadId: input.threadId,
+        requestId: input.requestId,
+        error: describeError(error)
+      });
+      return { status: "settled", respond: () => notify(core.t("reply.inboundDeferred")) };
+    }
+  }
   try {
     if (incremented) {
       await dispatchTurnWithReceipt(core.host, input, {
@@ -151376,14 +151757,14 @@ var makeTurnRetry = (core, deps) => async (binding, input, inbox, restoreCarried
       });
     } else {
       const status = await confirmTurnReceipt(core.host, input);
-      if (deps.signal.aborted) return false;
+      if (deps.signal.aborted) return { status: "deferred" };
       if (status === "absent") throw new Error("attempt budget exhausted; receipt absent");
     }
-    return true;
+    return { status: "accepted" };
   } catch (error) {
     if (deps.signal.aborted) {
       if (incremented) await inbox?.saveRetry(previous, nextAttemptAt);
-      return false;
+      return { status: "deferred" };
     }
     const delay2 = DELAYS[attempt - 1];
     if (!(error instanceof TurnDispatchRejected) && delay2 !== void 0 && inbox?.entry !== void 0) {
@@ -151397,7 +151778,7 @@ var makeTurnRetry = (core, deps) => async (binding, input, inbox, restoreCarried
         error: describeError(error)
       });
       if (attempt === 1) await notify(deps.failures.forDispatchRetry(input.requestId));
-      return false;
+      return { status: "deferred" };
     }
     const redactor = botRedactor(
       core.adapterFor(binding.platform)?.columns ?? [],
@@ -151416,10 +151797,12 @@ var makeTurnRetry = (core, deps) => async (binding, input, inbox, restoreCarried
     const textExcerpt = messageText2.trim();
     const attachmentName = firstAttachmentName?.trim() ?? "";
     const identifyingNotice = textExcerpt !== "" ? deps.failures.forDispatchFailureQuoted(input.requestId, textExcerpt) : attachmentName !== "" ? deps.failures.forDispatchFailureAttachment(input.requestId, attachmentName) : void 0;
-    await notify(
-      binding.reply === void 0 && attempt > 1 && identifyingNotice !== void 0 ? identifyingNotice : failureNotice
-    );
-    return false;
+    return {
+      status: "settled",
+      respond: () => notify(
+        binding.reply === void 0 && attempt > 1 && identifyingNotice !== void 0 ? identifyingNotice : failureNotice
+      )
+    };
   }
 };
 
@@ -151473,6 +151856,7 @@ var makeTurns = (core, deps) => {
   const ensureThread = async (binding, message) => {
     const chatKey = chatKeyOf(binding);
     let threadId = chatOf(core.state, chatKey).threadId ?? void 0;
+    let dropped = false;
     if (threadId !== void 0 && !await threadStillUsable(binding, threadId)) {
       host.log.info("chat dropped a saved thread that is no longer usable", {
         bot: binding.displayName,
@@ -151480,7 +151864,7 @@ var makeTurns = (core, deps) => {
       });
       bindChat(chatKey, null);
       threadId = void 0;
-      await deliver(binding, t("reply.threadGone"));
+      dropped = true;
     }
     if (threadId !== void 0) return threadId;
     const project = await projectOrNull2(host.projects, binding.projectId);
@@ -151489,7 +151873,13 @@ var makeTurns = (core, deps) => {
         bot: binding.displayName,
         projectId: binding.projectId
       });
-      return null;
+      return {
+        status: "settled",
+        respond: async () => {
+          if (dropped) await deliver(binding, t("reply.threadGone"));
+          await deliver(binding, t("reply.projectMissing"));
+        }
+      };
     }
     const modelSelection = await resolveDefaultModel(
       binding,
@@ -151502,8 +151892,13 @@ var makeTurns = (core, deps) => {
         bot: binding.displayName,
         projectId: binding.projectId
       });
-      await deliver(binding, t("reply.noDefaultModel", { title: project.title }));
-      return null;
+      return {
+        status: "settled",
+        respond: async () => {
+          if (dropped) await deliver(binding, t("reply.threadGone"));
+          await deliver(binding, t("reply.noDefaultModel", { title: project.title }));
+        }
+      };
     }
     const createdThreadId = identity2("thread", binding, message);
     const presetId = await resolveDefaultPreset(chatOf(core.state, chatKey).preset, binding, host);
@@ -151526,17 +151921,19 @@ var makeTurns = (core, deps) => {
       openedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     rememberThreadProject(createdThreadId, binding.projectId);
+    if (dropped) await deliver(binding, t("reply.threadGone"));
     return createdThreadId;
   };
   const startTurn = async (binding, message, accepted, inbox) => {
     const chatKey = chatKeyOf(binding);
     const text3 = message.text;
     const replayed = inbox?.replayed === true || (inbox?.entry?.attempts ?? 0) > 0;
-    const threadId = inbox?.entry?.threadId ?? await ensureThread(binding, message);
-    if (threadId === null) {
+    const prepared = inbox?.entry?.threadId ?? await ensureThread(binding, message);
+    if (typeof prepared !== "string") {
       await inbox?.complete();
-      return null;
+      return prepared;
     }
+    const threadId = prepared;
     await inbox?.saveThread(threadId);
     const topicRoot = await message.topicRootForSession?.(threadId);
     const requestId = identity2("turn", binding, message);
@@ -151570,11 +151967,33 @@ var makeTurns = (core, deps) => {
           stored: [...saved.stored, ...own.attachments],
           notes: [...saved.notes, ...own.notes]
         };
-        await inbox?.saveAttachments(saved);
       } catch (error) {
         restoreCarried();
         throw error;
       }
+      try {
+        await inbox?.saveAttachments(saved);
+      } catch (error) {
+        restoreCarried();
+        host.log.warn("chat could not save inbound attachments; leaving them for replay", {
+          threadId,
+          error: describeError(error)
+        });
+        return {
+          status: "settled",
+          respond: async () => {
+            try {
+              if (!await deliver(binding, t("reply.inboundDeferred")))
+                host.log.warn("chat could not deliver an inbound deferral notice", { threadId });
+            } catch (deliveryError) {
+              host.log.warn("chat could not deliver an inbound deferral notice", {
+                threadId,
+                error: describeError(deliveryError)
+              });
+            }
+          }
+        };
+      }
     }
     const attachments = saved.stored;
     const notes = saved.notes;
@@ -151634,7 +152053,8 @@ var makeTurns = (core, deps) => {
         message.text,
         message.resources[0]?.name
       );
-      if (!dispatched) return null;
+      if (dispatched.status !== "accepted") return dispatched;
+      accepted.onAccepted?.();
       topicRoot?.confirmConsumed();
       await deps.conclusions.owe(
         { chatKey, threadId, userMessageId, recordedAt: (/* @__PURE__ */ new Date()).toISOString() },
@@ -151658,11 +152078,12 @@ var makeTurns = (core, deps) => {
         binding.reply
       );
     });
-    return threadId;
+    return { status: "started" };
   };
   const receiveAttachmentsOnly = async (binding, message, enteredWaiting) => {
-    const threadId = await ensureThread(binding, message);
-    if (threadId === null) return;
+    const prepared = await ensureThread(binding, message);
+    if (typeof prepared !== "string") return prepared;
+    const threadId = prepared;
     const waiting = pendingFor(chatKeyOf(binding), threadId);
     const collected = await collectResources(
       binding,
@@ -151674,7 +152095,7 @@ var makeTurns = (core, deps) => {
     waiting.attachments.push(...collected.attachments);
     waiting.notes.push(...collected.notes.slice(0, MAX_ATTACHMENTS_PER_TURN));
     await enteredWaiting?.();
-    if (collected.attachments.length === 0) return;
+    if (collected.attachments.length === 0) return { status: "settled" };
     await deliver(
       binding,
       t("reply.attachmentReceived", {
@@ -151682,6 +152103,7 @@ var makeTurns = (core, deps) => {
         count: waiting.attachments.length
       })
     );
+    return { status: "settled" };
   };
   const hasWaitingAttachments = (chatKey) => (waitingFor(chatKey, chatOf(core.state, chatKey).threadId)?.attachments.length ?? 0) > 0;
   return {
@@ -155175,7 +155597,7 @@ var makeWecomAppAdapter = (deps) => {
 // src/index.ts
 var definition = {
   id: "im",
-  apiVersion: 27,
+  apiVersion: 28,
   // 第二个参数只给插件自己的测试夹具：换掉文件 IO 与派发重试的等待。宿主只传 ctx。
   activate: async (ctx, testing = {}) => {
     const { dispatchSleep } = testing;
@@ -155276,7 +155698,7 @@ var definition = {
       t,
       adapters
     });
-    const acknowledgements = makeAcknowledgements(core);
+    const acknowledgements = makeAcknowledgements(core, ctx.interval);
     const failures = makeFailureNotices(core);
     const replyAnchors = makeReplyAnchors(core.host);
     const conclusions = makeConclusionLedger(core);
@@ -155291,6 +155713,7 @@ var definition = {
     const teams = makeTeamGoals(core);
     const notifications = makeNotifications(core, {
       takeWorking: acknowledgements.takeWorking,
+      stopTypingFor: acknowledgements.stopTypingFor,
       replyCards,
       failures,
       conclusions,
@@ -155330,6 +155753,7 @@ var definition = {
     });
     const chatSetup = makeChatSetup(core, {
       rows: projectRows,
+      enqueueForChat: chatQueue.enqueueForChat,
       resumeMessage: (bot, message) => inbound.resumeMessage(bot, message),
       openPicker: (chatKey, rows, reply) => panelWiring.panel.openProjects(chatKey, rows, reply)
     });
@@ -155380,6 +155804,7 @@ var definition = {
         await inbound.stop();
         turns.stop();
         await chatQueue.closeAndDrain();
+        await acknowledgements.stopDeferred();
       }
     });
     registerSettingsRowActions(