@xmanrui/dsh-im 4.5.0 → 4.7.0

package/src/channels/shared/workspace-command.mjs

@@ -18,6 +18,7 @@ const SESSION_BIND_USAGE = '用法：/session Session ID 或当前工作区序
 const SESSION_LIST_USAGE = [
   '用法：',
   '/sessionlist  列出当前工作区会话',
+  '/sessionlist --limit N  列出当前工作区前 N 个会话（N 为正整数）',
   '/sessionlist 工作区序号  按 /workspacelist 序号列出会话',
   '/sessionlist 工作区绝对路径  列出指定工作区会话',
 ].join('\n');
@@ -45,6 +46,20 @@ function validSessionId(value) {
     && !UNSAFE_DISPLAY_TEXT.test(value);
 }
 
+export function parseSessionListArgument(value) {
+  const argument = typeof value === 'string' ? value.trim() : '';
+  if (!argument) return { selector: '', limit: null };
+  if (!argument.toLowerCase().startsWith('--limit')) {
+    return { selector: argument, limit: null };
+  }
+  const match = /^--limit[ \t]+(\d+)$/iu.exec(argument);
+  const limit = match ? Number(match[1]) : null;
+  if (!Number.isSafeInteger(limit) || limit < 1) {
+    return { error: t(SESSION_LIST_USAGE) };
+  }
+  return { selector: '', limit };
+}
+
 async function existingWorkspacePaths(values) {
   const checked = await Promise.all(values.map(async (value) => {
     const workspace = normalizedWorkspacePath(value);
@@ -235,12 +250,13 @@ async function currentSessionListWorkspace(harness) {
 }
 
 async function runSessionListCommand(match, harness) {
+  const request = parseSessionListArgument(match[1]);
+  if (request.error) return commandResult(request.error);
   if (typeof harness?.listWorkspaceSessions !== 'function') {
     return commandResult(t('当前机器人暂不支持列出工作区会话。'));
   }
-  const selector = match[1]?.trim() ?? '';
   try {
-    const resolved = await resolveSessionListWorkspace(selector, harness);
+    const resolved = await resolveSessionListWorkspace(request.selector, harness);
     if (resolved.error) return commandResult(resolved.error);
     const listed = await harness.listWorkspaceSessions(resolved.workspace);
     if (!listed || !Array.isArray(listed.sessions)) {
@@ -249,7 +265,10 @@ async function runSessionListCommand(match, harness) {
     harness.assertWorkspaceScope?.();
     const workspace = normalizedWorkspacePath(listed.workspace) ?? resolved.workspace;
     const currentWorkspace = await currentSessionListWorkspace(harness);
-    const message = sessionListMessage(workspace, listed.sessions, {
+    const sessions = request.limit === null
+      ? listed.sessions
+      : listed.sessions.slice(0, request.limit);
+    const message = sessionListMessage(workspace, sessions, {
       currentWorkspace: workspace === currentWorkspace,
     });
     return commandResult(message, splitWorkspaceCommandMessage(message));

package/src/channels/slack/manifest.mjs

@@ -17,9 +17,12 @@ oauth_config:
     bot:
       - app_mentions:read
       - chat:write
+      - channels:history
       - files:read
       - files:write
+      - groups:history
       - im:history
+      - mpim:history
       - reactions:write
 settings:
   event_subscriptions:

package/src/channels/slack/slack-api.mjs

@@ -246,6 +246,24 @@ export class SlackApi {
     return value.file;
   }
 
+  async getMessage({ channelId, messageTs, signal } = {}) {
+    const timestamp = requiredString(messageTs, 'message timestamp');
+    const value = await this.#request('conversations.history', {
+      tokenKind: 'bot',
+      signal,
+      body: {
+        channel: slackId(channelId, 'channel id'),
+        oldest: timestamp,
+        latest: timestamp,
+        inclusive: true,
+        limit: 1,
+      },
+    });
+    return Array.isArray(value?.messages)
+      ? value.messages.find((message) => String(message?.ts ?? '') === timestamp) ?? null
+      : null;
+  }
+
   postMessage({ channelId, text, threadTs, signal }) {
     return this.#request('chat.postMessage', {
       tokenKind: 'bot',

package/src/channels/slack/slack-runtime.mjs

@@ -49,6 +49,58 @@ function slackFileUrl(file) {
     ? file.url_private_download : file?.url_private;
 }
 
+function slackReplyAttachment(file) {
+  if (!file || typeof file !== 'object') return null;
+  const mediaType = typeof file.mimetype === 'string' ? file.mimetype.toLowerCase() : '';
+  const kind = mediaType.startsWith('image/') ? 'image'
+    : mediaType.startsWith('audio/') ? 'audio'
+      : mediaType.startsWith('video/') ? 'video' : 'file';
+  const name = typeof file.name === 'string' && file.name
+    ? file.name : typeof file.title === 'string' && file.title ? file.title : undefined;
+  return { kind, ...(name ? { name } : {}) };
+}
+
+function slackReplySnapshot(message, messageTs) {
+  if (!message || String(message.ts ?? '') !== messageTs) return null;
+  const authorId = typeof message.user === 'string' && message.user
+    ? message.user : typeof message.bot_id === 'string' && message.bot_id
+      ? message.bot_id : undefined;
+  const authorName = typeof message.username === 'string' && message.username
+    ? message.username : undefined;
+  return {
+    messageId: messageTs,
+    ...(authorId ? { authorId } : {}),
+    ...(authorName ? { authorName } : {}),
+    content: decodeSlackText(message.text ?? ''),
+    attachments: Array.isArray(message.files)
+      ? message.files.map(slackReplyAttachment).filter(Boolean)
+      : [],
+  };
+}
+
+function slackThreadReplyReference(event, loadReply) {
+  const messageTs = typeof event?.thread_ts === 'string' ? event.thread_ts : '';
+  if (!messageTs || messageTs === String(event?.ts ?? '')) return undefined;
+  return {
+    messageId: messageTs,
+    load: async ({ signal } = {}) => {
+      try {
+        const message = await loadReply({
+          channelId: String(event.channel),
+          messageTs,
+          signal,
+        });
+        return slackReplySnapshot(message, messageTs);
+      } catch (error) {
+        if (error?.code === 'slack-missing-scope') {
+          return { messageId: messageTs, unavailableReason: 'permission-denied' };
+        }
+        throw error;
+      }
+    },
+  };
+}
+
 function slackImageSource(file, loadFile) {
   const mediaType = typeof file?.mimetype === 'string' ? file.mimetype.toLowerCase() : '';
   const url = slackFileUrl(file);
@@ -104,6 +156,7 @@ export function normalizeSlackEvent(payload, botUserId, {
   loadFile = async () => { throw new Error('Slack file downloader is unavailable'); },
   loadFileStream = loadFile,
   loadFileInfo = async () => { throw new Error('Slack file metadata loader is unavailable'); },
+  loadReply = async () => { throw new Error('Slack reply loader is unavailable'); },
 } = {}) {
   const event = payload?.event;
   if (!event || !payload?.event_id || !event.channel || !event.user || !event.ts) return null;
@@ -112,6 +165,7 @@ export function normalizeSlackEvent(payload, botUserId, {
   if (!direct && !mentioned) return null;
   if ((event.subtype && event.subtype !== 'file_share') || event.bot_id || event.app_id) return null;
   const threadTs = String(event.thread_ts ?? event.ts);
+  const replyTo = slackThreadReplyReference(event, loadReply);
   return {
     messageId: String(payload.event_id),
     senderId: String(event.user),
@@ -126,6 +180,7 @@ export function normalizeSlackEvent(payload, botUserId, {
     files: Array.isArray(event.files)
       ? event.files.map((file) => slackFileSource(file, loadFileStream, loadFileInfo)).filter(Boolean)
       : [],
+    ...(replyTo ? { replyTo } : {}),
     addressed: direct || mentioned,
     reactionTarget: {
       channelId: String(event.channel),
@@ -555,6 +610,7 @@ export class SlackRuntime {
           loadFile: (url, options) => this.#api.downloadFile({ url, ...options }),
           loadFileStream: (url, options) => this.#api.downloadFileStream({ url, ...options }),
           loadFileInfo: (fileId, options) => this.#api.fileInfo({ fileId, ...options }),
+          loadReply: (options) => this.#api.getMessage(options),
         });
         const bridge = this.#bridge;
         if (message && bridge) {

package/src/channels/telegram/telegram-runtime.mjs

@@ -4,6 +4,7 @@ import { createEditableMessageStream, splitMessageText } from '../shared/editabl
 import { createTextDeliveryBlock } from '../shared/semantic/delivery.mjs';
 import { t } from '../shared/i18n.mjs';
 import { captureContextEnhancement } from '../shared/context-enhancement.mjs';
+import { recoverAssistantTextByTimestamp } from '../shared/session-reply-recovery.mjs';
 import { COMMANDS_MENU_BUTTON, TelegramApi } from './telegram-api.mjs';
 import { createTelegramHttpTransport } from './telegram-http.mjs';
 import { createTelegramBridgeStatus, TelegramHarnessBridge } from './telegram-bridge.mjs';
@@ -138,11 +139,94 @@ function telegramFileSource(message, loadFile) {
   };
 }
 
+function telegramReplyAttachment(kind, file, fallbackName) {
+  if (!file || typeof file !== 'object') return null;
+  const name = typeof file.file_name === 'string' && file.file_name
+    ? file.file_name : typeof fallbackName === 'string' && fallbackName
+      ? fallbackName : undefined;
+  return { kind, ...(name ? { name } : {}) };
+}
+
+function telegramReplyAttachments(message) {
+  const attachments = [];
+  if (Array.isArray(message?.photo) && message.photo.length > 0) {
+    const largest = message.photo.reduce((best, candidate) => (
+      photoScore(candidate) > photoScore(best) ? candidate : best
+    ));
+    attachments.push(telegramReplyAttachment(
+      'image',
+      largest,
+      `${largest.file_unique_id ?? largest.file_id ?? 'telegram-photo'}.jpg`,
+    ));
+  } else if (message?.document) {
+    attachments.push(telegramReplyAttachment(
+      imageTypeForDocument(message.document) ? 'image' : 'file',
+      message.document,
+    ));
+  }
+  for (const [field, kind] of [
+    ['audio', 'audio'],
+    ['voice', 'audio'],
+    ['video', 'video'],
+    ['video_note', 'video'],
+    ['animation', 'video'],
+  ]) {
+    if (message?.[field]) attachments.push(telegramReplyAttachment(kind, message[field]));
+  }
+  if (message?.sticker) {
+    attachments.push(telegramReplyAttachment(
+      message.sticker.is_video === true ? 'video' : 'image',
+      message.sticker,
+      message.sticker.file_unique_id ?? message.sticker.file_id,
+    ));
+  }
+  return attachments.filter(Boolean);
+}
+
+function telegramReplyReference(message, { quote, loadReplyContent } = {}) {
+  if ((!message || typeof message !== 'object')
+    && (!quote || typeof quote !== 'object')) return undefined;
+  const authorId = message?.from?.id === undefined ? undefined : String(message.from.id);
+  const authorName = [message?.from?.first_name, message?.from?.last_name]
+    .filter((value) => typeof value === 'string' && value.trim())
+    .map((value) => value.trim()).join(' ') || (
+      typeof message?.from?.username === 'string' && message.from.username
+        ? message.from.username : undefined
+    );
+  const content = typeof message?.text === 'string'
+    ? message.text : typeof message?.caption === 'string'
+      ? message.caption : typeof quote?.text === 'string' ? quote.text : '';
+  const attachments = telegramReplyAttachments(message);
+  const messageId = Number.isSafeInteger(message?.message_id)
+    ? String(message.message_id) : undefined;
+  const createdAt = Number.isSafeInteger(message?.date) && message.date >= 0
+    ? message.date * 1_000 : undefined;
+  const load = !content.trim() && attachments.length === 0
+    && typeof loadReplyContent === 'function'
+    ? ({ signal } = {}) => loadReplyContent({
+        ...(messageId ? { messageId } : {}),
+        ...(createdAt === undefined ? {} : { createdAt }),
+      }, { signal })
+    : null;
+  return {
+    ...(messageId ? { messageId } : {}),
+    ...(authorId ? { authorId } : {}),
+    ...(authorName ? { authorName } : {}),
+    ...(content.trim() ? { content } : {}),
+    ...(attachments.length > 0 ? { attachments } : {}),
+    ...(load ? { load } : {}),
+    ...(!content.trim() && attachments.length === 0 && !load
+      ? { unavailableReason: 'not-delivered' }
+      : {}),
+  };
+}
+
 export function normalizeTelegramUpdate(update, {
   botId,
   username,
   loadFile = async () => { throw new Error('Telegram file downloader is unavailable'); },
   loadFileStream = loadFile,
+  loadReplyContent,
 }) {
   const message = update?.message;
   const chatId = message?.chat?.id;
@@ -159,6 +243,21 @@ export function normalizeTelegramUpdate(update, {
     ? message.message_thread_id : undefined;
   const image = telegramImageSource(message, loadFile);
   const file = telegramFileSource(message, loadFileStream);
+  const conversationId = messageThreadId === undefined
+    ? String(chatId) : `${chatId}:${messageThreadId}`;
+  const key = `${direct ? 'direct' : 'group'}:${conversationId}`;
+  const replyTo = telegramReplyReference(
+    message.reply_to_message ?? message.external_reply,
+    {
+      quote: message.quote,
+      ...(typeof loadReplyContent === 'function' ? {
+        loadReplyContent: (reference, options) => loadReplyContent({
+          conversationKey: key,
+          ...reference,
+        }, options),
+      } : {}),
+    },
+  );
   return {
     messageId: String(update.update_id),
     senderId: String(senderId),
@@ -170,12 +269,12 @@ export function normalizeTelegramUpdate(update, {
     }),
     senderIsBot: message.from?.is_bot === true,
     kind: direct ? 'direct' : 'group',
-    conversationId: messageThreadId === undefined
-      ? String(chatId) : `${chatId}:${messageThreadId}`,
+    conversationId,
     content: withoutBotMention(message.text ?? message.caption ?? '', username),
     plainText: typeof message.text === 'string',
     images: image ? [image] : [],
     files: file ? [file] : [],
+    ...(replyTo ? { replyTo } : {}),
     addressed,
     reactionTarget: { chatId, messageId },
     replyTarget: {
@@ -839,6 +938,21 @@ export class TelegramRuntime {
     }
   }
 
+  async #loadReplyContent(reference, { signal } = {}) {
+    const key = typeof reference?.conversationKey === 'string'
+      ? reference.conversationKey.trim() : '';
+    const quotedAt = Number(reference?.createdAt);
+    if (!key || !Number.isFinite(quotedAt)) {
+      return { unavailableReason: 'not-delivered' };
+    }
+    const sessionId = this.#state.sessionFor(key);
+    const session = typeof sessionId === 'string' && sessionId
+      ? this.#harness.workspaceSession?.(sessionId)
+      : null;
+    const text = await recoverAssistantTextByTimestamp({ session, quotedAt, signal });
+    return text ? { content: text } : { unavailableReason: 'not-delivered' };
+  }
+
   async #poll(initialCursor, signal) {
     let cursor = initialCursor;
     while (!signal.aborted) {
@@ -863,6 +977,7 @@ export class TelegramRuntime {
           username: this.#config.username,
           loadFile: (fileId, options) => this.#api.downloadFile({ fileId, ...options }),
           loadFileStream: (fileId, options) => this.#api.downloadFileStream({ fileId, ...options }),
+          loadReplyContent: (reference, options) => this.#loadReplyContent(reference, options),
         });
         if (message) {
           void this.#bridge.accept(message, { contextSnapshot }).catch((error) => {

package/src/channels/wecom/wecom-bridge.mjs

@@ -33,7 +33,6 @@ import {
   ImagePromptError,
   imagePromptDiagnostic,
   imagePromptUserMessage,
-  promptContentForMessage,
 } from '../shared/image-prompt.mjs';
 import {
   hasInboundFiles,
@@ -42,6 +41,10 @@ import {
 import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
 import { trackOutboundArtifactProviderPromise } from '../shared/semantic/artifact.mjs';
 import { deliverOutboundArtifacts } from '../shared/semantic/artifact-delivery.mjs';
+import {
+  hasReplyReference,
+  promptContentForInboundMessage,
+} from '../shared/semantic/reply-reference.mjs';
 import {
   createDeliveryReceipt,
 } from '../shared/semantic/delivery.mjs';
@@ -71,6 +74,7 @@ function helpText() {
     t('/workspace 工作区序号或绝对路径  切换工作区'),
     t('/workspacelist  列出工作区绝对路径'),
     t('/sessionlist 或 /sessions [工作区序号或绝对路径]  列出会话 ID 和标题'),
+    t('/sessionlist --limit N  仅列出当前工作区前 N 个会话'),
     t('/session Session ID 或当前工作区序号  将当前聊天绑定到指定会话'),
     t('/models  按序号列出所有可用模型'),
     t('/reasoninglist 或 /reasonings  按序号列出当前模型可用推理等级'),
@@ -108,8 +112,7 @@ function conversationKey(frame) {
   return body.chattype === 'group' ? `group:${body.chatid}` : `direct:${body.from?.userid}`;
 }
 
-function messageText(frame) {
-  const body = bodyOf(frame);
+function messageContentText(body) {
   let text = '';
   if (body.msgtype === 'text') {
     text = typeof body.text?.content === 'string' ? body.text.content.trim() : '';
@@ -122,6 +125,12 @@ function messageText(frame) {
       .join('\n')
       .trim();
   }
+  return text;
+}
+
+function messageText(frame) {
+  const body = bodyOf(frame);
+  const text = messageContentText(body);
   // Group callbacks retain the leading @bot mention that caused delivery.
   // It is routing metadata rather than part of the user's prompt or answer.
   return body.chattype === 'group'
@@ -145,6 +154,36 @@ function fileContents(frame) {
     : [];
 }
 
+function quoteAttachments(quote) {
+  if (quote?.msgtype === 'image') return [{ kind: 'image' }];
+  if (quote?.msgtype === 'voice') return [{ kind: 'audio' }];
+  if (quote?.msgtype === 'file') {
+    const name = nonEmptyString(
+      quote.file?.filename ?? quote.file?.file_name ?? quote.file?.name,
+    );
+    return [{ kind: 'file', ...(name ? { name } : {}) }];
+  }
+  if (quote?.msgtype !== 'mixed' || !Array.isArray(quote.mixed?.msg_item)) return [];
+  return quote.mixed.msg_item
+    .filter((item) => item?.msgtype === 'image')
+    .map(() => ({ kind: 'image' }));
+}
+
+function replyReferenceForBody(body) {
+  const quote = body?.quote;
+  if (!quote || typeof quote !== 'object') return null;
+  const content = messageContentText(quote);
+  const attachments = quoteAttachments(quote);
+  const supported = ['text', 'image', 'mixed', 'voice', 'file'].includes(quote.msgtype);
+  return {
+    ...(content ? { content } : {}),
+    ...(attachments.length > 0 ? { attachments } : {}),
+    ...(!content && attachments.length === 0
+      ? { unavailableReason: supported ? 'not-delivered' : 'unsupported' }
+      : {}),
+  };
+}
+
 function imageSource(client, image) {
   const url = nonEmptyString(image?.url);
   if (!url) return null;
@@ -200,10 +239,13 @@ function fileSource(client, file) {
 }
 
 export function wecomInboundMessage(frame, client) {
+  const body = bodyOf(frame);
+  const replyTo = replyReferenceForBody(body);
   return {
     content: messageText(frame),
     images: imageContents(frame).map((image) => imageSource(client, image)).filter(Boolean),
     files: fileContents(frame).map((file) => fileSource(client, file)).filter(Boolean),
+    ...(replyTo ? { replyTo } : {}),
   };
 }
 
@@ -604,7 +646,7 @@ export class WecomHarnessBridge {
         && (this.#queues.has(key) || pending || this.#approvals.hasPending(key))
         ? { handled: true, kind: 'busy', message: batchInputBusyMessage() }
         : this.#batchInputs.handle(key, commandText, {
-            plainText: isNativeWecomText(frame),
+            plainText: isNativeWecomText(frame) && !hasReplyReference(commandMessage),
           });
       if (result.handled) {
         if (result.kind === 'submit') {
@@ -934,6 +976,7 @@ export class WecomHarnessBridge {
     const text = message.content;
     const hasImages = hasInboundImages(message);
     const hasFiles = hasInboundFiles(message);
+    const hasReply = hasReplyReference(message);
     const key = conversationKey(frame);
     let streamId = null;
     let streamStarted = false;
@@ -942,7 +985,7 @@ export class WecomHarnessBridge {
     let batchSettled = batchSubmission === null;
     let promptRecorded = false;
     try {
-      if (!text && !hasImages && !hasFiles) {
+      if (!text && !hasImages && !hasFiles && !hasReply) {
         await this.#sendImmediate(frame, chatId, t('目前支持文字、图片、文件和语音转写消息。'));
         await this.#state.markSeen(messageId);
         return;
@@ -1003,8 +1046,8 @@ export class WecomHarnessBridge {
         this.#logger.warn?.('[dsh-im:wecom] unable to start a stream; using an active reply:', error);
       }
 
-      let content = hasImages
-        ? await promptContentForMessage(message, { signal: this.#signal })
+      let content = hasImages || hasReply
+        ? await promptContentForInboundMessage(message, { signal: this.#signal })
         : undefined;
       const snapshot = this.#acceptedMessageIds.get(messageId);
       let contextEnhanced = false;

package/src/channels/weixin/state-store.mjs

@@ -1,13 +1,67 @@
 import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 
+import { weixinMessageTimestampMs } from './weixin-api.mjs';
+
 const EMPTY_STATE = Object.freeze({
   version: 1,
   sessions: {},
   seenMessageIds: [],
   getUpdatesBuf: '',
+  recentOutboundMessages: [],
 });
 
+export const WEIXIN_RECENT_OUTBOUND_LIMIT = 200;
+export const WEIXIN_RECENT_OUTBOUND_TTL_MS = 30 * 24 * 60 * 60 * 1_000;
+export const WEIXIN_RECENT_OUTBOUND_TEXT_LIMIT = 8_000;
+export const WEIXIN_RECENT_OUTBOUND_MATCH_TOLERANCE_MS = 15_000;
+
+function nonEmptyString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function timestamp(value) {
+  const number = typeof value === 'string' && value.trim() ? Number(value) : value;
+  return Number.isFinite(number) && number >= 0 ? Math.trunc(number) : null;
+}
+
+function providerMessageIds(value) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value
+    .map((id) => (id === undefined || id === null ? null : nonEmptyString(String(id))))
+    .filter(Boolean))];
+}
+
+function truncateText(value) {
+  const text = nonEmptyString(value);
+  return text ? [...text].slice(0, WEIXIN_RECENT_OUTBOUND_TEXT_LIMIT).join('') : null;
+}
+
+function normalizeRecentOutboundMessage(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const toUserId = nonEmptyString(value.toUserId);
+  const text = truncateText(value.text);
+  const sentAt = timestamp(value.sentAt);
+  const completedAt = timestamp(value.completedAt) ?? sentAt;
+  if (!toUserId || !text || sentAt === null || completedAt === null) return null;
+  return {
+    toUserId,
+    text,
+    sentAt,
+    completedAt: Math.max(sentAt, completedAt),
+    providerMessageIds: providerMessageIds(value.providerMessageIds),
+  };
+}
+
+function recentOutboundMessages(value, now = Date.now()) {
+  if (!Array.isArray(value)) return [];
+  const cutoff = now - WEIXIN_RECENT_OUTBOUND_TTL_MS;
+  return value
+    .map(normalizeRecentOutboundMessage)
+    .filter((entry) => entry && entry.completedAt >= cutoff)
+    .slice(-WEIXIN_RECENT_OUTBOUND_LIMIT);
+}
+
 function normalizeState(value) {
   if (!value || typeof value !== 'object') return structuredClone(EMPTY_STATE);
   const sessions = {};
@@ -25,6 +79,7 @@ function normalizeState(value) {
       ? value.seenMessageIds.filter((id) => typeof id === 'string').slice(-1_000)
       : [],
     getUpdatesBuf: typeof value.getUpdatesBuf === 'string' ? value.getUpdatesBuf : '',
+    recentOutboundMessages: recentOutboundMessages(value.recentOutboundMessages),
   };
 }
 
@@ -90,6 +145,61 @@ export class WeixinStateStore {
     await this.#persist();
   }
 
+  async rememberOutboundMessage({
+    toUserId,
+    text,
+    sentAt = Date.now(),
+    completedAt = Date.now(),
+    providerMessageIds: messageIds = [],
+  } = {}) {
+    const entry = normalizeRecentOutboundMessage({
+      toUserId,
+      text,
+      sentAt,
+      completedAt,
+      providerMessageIds: messageIds,
+    });
+    if (!entry) throw new TypeError('Invalid Weixin outbound message');
+    this.#state.recentOutboundMessages = recentOutboundMessages([
+      ...this.#state.recentOutboundMessages,
+      entry,
+    ]);
+    await this.#persist();
+  }
+
+  recentOutboundTextFor({
+    toUserId,
+    messageId,
+    createTimeMs,
+    updateTimeMs,
+    now = Date.now(),
+  } = {}) {
+    const recipient = nonEmptyString(toUserId);
+    if (!recipient) return null;
+    const active = recentOutboundMessages(this.#state.recentOutboundMessages, now)
+      .filter((entry) => entry.toUserId === recipient);
+    const quotedMessageId = messageId === undefined || messageId === null
+      ? null
+      : nonEmptyString(String(messageId));
+    if (quotedMessageId) {
+      const exact = active.filter((entry) => entry.providerMessageIds.includes(quotedMessageId));
+      if (exact.length === 1) return exact[0].text;
+      if (exact.length > 1) return null;
+    }
+    const quotedTimes = [
+      timestamp(createTimeMs),
+      timestamp(updateTimeMs),
+      weixinMessageTimestampMs(quotedMessageId, { now }),
+    ]
+      .filter((value) => value !== null);
+    if (quotedTimes.length === 0) return null;
+    const candidates = active.filter((entry) => quotedTimes.some((quotedAt) => (
+      quotedAt >= entry.sentAt - WEIXIN_RECENT_OUTBOUND_MATCH_TOLERANCE_MS
+        && quotedAt <= entry.completedAt + WEIXIN_RECENT_OUTBOUND_MATCH_TOLERANCE_MS
+    )));
+    return candidates.length === 1 ? candidates[0].text : null;
+  }
+
   snapshot() {
     return structuredClone(this.#state);
   }