@xmanrui/dsh-im 4.5.0 → 4.6.0

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';
@@ -108,8 +111,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 +124,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 +153,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 +238,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 +645,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 +975,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 +984,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 +1045,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);
   }

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

@@ -21,6 +21,9 @@ const ILINK_CLIENT_VERSION = (2 << 16) | (4 << 8) | 6;
 const DEFAULT_TIMEOUT_MS = 15_000;
 const DEFAULT_LONG_POLL_TIMEOUT_MS = 35_000;
 const WEIXIN_CDN_UPLOAD_RETRIES = 3;
+const WEIXIN_MESSAGE_ID_TIMESTAMP_SHIFT = 22n;
+const WEIXIN_MESSAGE_ID_MIN_TIMESTAMP_MS = Date.UTC(2020, 0, 1);
+const WEIXIN_MESSAGE_ID_MAX_FUTURE_MS = 24 * 60 * 60 * 1_000;
 const LOGIN_STATUSES = new Set([
   'wait',
   'scaned',
@@ -689,6 +692,7 @@ export function createWeixinApi({ fetchImpl = fetch } = {}) {
       const recipient = nonEmptyString(toUserId);
       const content = nonEmptyString(text);
       if (!recipient || !content) throw new TypeError('toUserId and text are required');
+      const clientId = `dsh-weixin-${randomUUID()}`;
       const response = await requestJson(fetchImpl, {
         method: 'POST',
         baseUrl,
@@ -699,7 +703,7 @@ export function createWeixinApi({ fetchImpl = fetch } = {}) {
           msg: {
             from_user_id: '',
             to_user_id: recipient,
-            client_id: `dsh-weixin-${randomUUID()}`,
+            client_id: clientId,
             message_type: 2,
             message_state: 2,
             item_list: [{ type: 1, text_item: { text: content } }],
@@ -717,7 +721,10 @@ export function createWeixinApi({ fetchImpl = fetch } = {}) {
           { providerCode: sendRejection },
         );
       }
-      return true;
+      return {
+        ...(response && typeof response === 'object' ? response : {}),
+        providerMessageIds: [clientId],
+      };
     },
 
     async sendFile(request) {
@@ -791,6 +798,83 @@ export function extractWeixinText(message) {
   return null;
 }
 
+function weixinReplyAttachment(item) {
+  if (item?.type === 2 || (item?.image_item && typeof item.image_item === 'object')) {
+    return { kind: 'image' };
+  }
+  if (item?.type === 3 || (item?.voice_item && typeof item.voice_item === 'object')) {
+    return { kind: 'audio' };
+  }
+  if (item?.type === 4 || (item?.file_item && typeof item.file_item === 'object')) {
+    const name = nonEmptyString(item?.file_item?.file_name);
+    return { kind: 'file', ...(name ? { name } : {}) };
+  }
+  if (item?.type === 5 || (item?.video_item && typeof item.video_item === 'object')) {
+    return { kind: 'video' };
+  }
+  return null;
+}
+
+function weixinQuotedText(item) {
+  const text = nonEmptyString(item?.text_item?.text);
+  if (text) return text;
+  return nonEmptyString(item?.voice_item?.text);
+}
+
+/** Extract the one-level reply snapshot embedded in an inbound iLink message item. */
+export function extractWeixinReplyReference(message, { resolveContent, loadContent } = {}) {
+  const container = (message?.item_list ?? []).find((item) => (
+    item?.ref_msg && typeof item.ref_msg === 'object'
+  ));
+  if (!container) return null;
+  const ref = container.ref_msg;
+  const quotedItem = ref.message_item && typeof ref.message_item === 'object'
+    ? ref.message_item
+    : null;
+  const quotedText = weixinQuotedText(quotedItem);
+  let content = quotedText ?? nonEmptyString(ref.title);
+  const attachment = weixinReplyAttachment(quotedItem);
+  const messageId = quotedItem?.msg_id === undefined || quotedItem?.msg_id === null
+    ? null
+    : nonEmptyString(String(quotedItem.msg_id));
+  const referenceDetails = {
+    messageId,
+    createTimeMs: quotedItem?.create_time_ms ?? ref.create_time_ms,
+    updateTimeMs: quotedItem?.update_time_ms ?? ref.update_time_ms,
+  };
+  if (!content && !attachment && typeof resolveContent === 'function') {
+    content = nonEmptyString(resolveContent(referenceDetails));
+  }
+  const load = !content && !attachment && typeof loadContent === 'function'
+    ? (options) => loadContent(referenceDetails, options)
+    : null;
+  const knownType = quotedItem && [1, 2, 3, 4, 5, 8].includes(quotedItem.type);
+  return {
+    ...(messageId ? { messageId } : {}),
+    ...(content ? { content } : {}),
+    ...(attachment ? { attachments: [attachment] } : {}),
+    ...(load ? { load } : {}),
+    ...(!content && !attachment && !load
+      ? { unavailableReason: quotedItem && !knownType ? 'unsupported' : 'not-delivered' }
+      : {}),
+  };
+}
+
+/** Decode the millisecond timestamp carried by current 64-bit iLink message IDs. */
+export function weixinMessageTimestampMs(messageId, { now = Date.now() } = {}) {
+  const value = messageId === undefined || messageId === null ? '' : String(messageId).trim();
+  if (!/^\d{16,20}$/u.test(value)) return null;
+  try {
+    const timestampMs = Number(BigInt(value) >> WEIXIN_MESSAGE_ID_TIMESTAMP_SHIFT);
+    if (!Number.isSafeInteger(timestampMs)
+      || timestampMs < WEIXIN_MESSAGE_ID_MIN_TIMESTAMP_MS
+      || timestampMs > now + WEIXIN_MESSAGE_ID_MAX_FUTURE_MS) return null;
+    return timestampMs;
+  } catch {
+    return null;
+  }
+}
+
 export function weixinMessageId(message) {
   if (message?.message_id !== undefined && message.message_id !== null) {
     return String(message.message_id);

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

@@ -2,9 +2,11 @@ import {
   DEFAULT_WEIXIN_MAX_MESSAGE_CHARS,
   extractWeixinFiles,
   extractWeixinImages,
+  extractWeixinReplyReference,
   extractWeixinText,
   splitWeixinText,
   weixinMessageId,
+  weixinMessageTimestampMs,
 } from './weixin-api.mjs';
 import {
   harnessAnswerForQuestion,
@@ -38,7 +40,6 @@ import {
   hasInboundImages,
   imagePromptDiagnostic,
   imagePromptUserMessage,
-  promptContentForMessage,
 } from '../shared/image-prompt.mjs';
 import {
   hasInboundFiles,
@@ -47,10 +48,15 @@ import {
 } from '../shared/inbound-file.mjs';
 import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
 import { deliverOutboundArtifacts } from '../shared/semantic/artifact-delivery.mjs';
+import {
+  hasReplyReference,
+  promptContentForInboundMessage,
+} from '../shared/semantic/reply-reference.mjs';
 import {
   createDeliveryReceipt,
   providerMessageIdsFor,
 } from '../shared/semantic/delivery.mjs';
+import { recoverAssistantTextByTimestamp } from '../shared/session-reply-recovery.mjs';
 import {
   channelDeliveryFailure,
   clearLastMessageFailure,
@@ -67,6 +73,10 @@ const INTERACTION_RESOLVED_TEXT = () => t('这个问题已在其他客户端处
 const DEFAULT_TYPING_KEEPALIVE_MS = 5_000;
 const TYPING_RETRY_DELAY_MS = 60_000;
 const WEIXIN_SEND_DIAGNOSTIC = Symbol('weixin-send-diagnostic');
+const WEIXIN_REPLY_HISTORY_PAGE_SIZE = 100;
+const WEIXIN_REPLY_HISTORY_MAX_PAGES = 3;
+const WEIXIN_REPLY_HISTORY_TIMEOUT_MS = 5_000;
+const WEIXIN_REPLY_HISTORY_MATCH_TOLERANCE_MS = 15_000;
 
 const HELP_TEXT = () => [
   t('微信已连接 DeepSeek Harness。'),
@@ -182,7 +192,20 @@ function weixinSendFailureOptions(error) {
   return undefined;
 }
 
-export function weixinInboundMessage(message, api) {
+export function weixinInboundMessage(message, api, state, { loadReplyContent } = {}) {
+  const toUserId = nonEmptyString(message?.from_user_id);
+  const replyTo = extractWeixinReplyReference(message, {
+    resolveContent: (reference) => state?.recentOutboundTextFor?.({
+      toUserId,
+      ...reference,
+    }),
+    ...(typeof loadReplyContent === 'function' ? {
+      loadContent: (reference, options) => loadReplyContent({
+        toUserId,
+        ...reference,
+      }, options),
+    } : {}),
+  });
   return {
     content: extractWeixinText(message) ?? '',
     images: typeof api?.inboundImages === 'function'
@@ -191,6 +214,7 @@ export function weixinInboundMessage(message, api) {
     files: typeof api?.inboundFiles === 'function'
       ? api.inboundFiles(message)
       : extractWeixinFiles(message),
+    ...(replyTo ? { replyTo } : {}),
   };
 }
 
@@ -375,7 +399,8 @@ export class WeixinHarnessBridge {
         && (this.#queues.has(key) || pending || this.#approvals.hasPending(key))
         ? { handled: true, kind: 'busy', message: batchInputBusyMessage() }
         : this.#batchInputs.handle(key, commandText, {
-            plainText: isNativeWeixinText(message),
+            plainText: isNativeWeixinText(message)
+              && !extractWeixinReplyReference(message),
           });
       if (result.handled) {
         if (result.kind === 'submit') {
@@ -489,7 +514,7 @@ export class WeixinHarnessBridge {
     batchSubmission = null,
   } = {}) {
     const preparedMessage = prefetchInboundFiles(
-      weixinInboundMessage(message, this.#api),
+      this.#inboundMessage(message),
       { signal: this.#signal },
     );
     const previous = this.#queues.get(key) ?? Promise.resolve();
@@ -508,6 +533,54 @@ export class WeixinHarnessBridge {
     return current;
   }
 
+  #inboundMessage(message) {
+    return weixinInboundMessage(message, this.#api, this.#state, {
+      loadReplyContent: (reference, options) => this.#loadReplyContent(reference, options),
+    });
+  }
+
+  async #loadReplyContent(reference, { signal: callerSignal } = {}) {
+    const indexed = this.#state.recentOutboundTextFor?.(reference);
+    if (indexed) return { content: indexed };
+    const quotedAt = [
+      weixinMessageTimestampMs(reference?.messageId),
+      Number(reference?.createTimeMs),
+      Number(reference?.updateTimeMs),
+    ].find(Number.isSafeInteger);
+    if (quotedAt === undefined) return { unavailableReason: 'not-delivered' };
+    const sender = nonEmptyString(reference?.toUserId);
+    const sessionId = sender ? this.#state.sessionFor(conversationKey(sender)) : null;
+    const session = typeof sessionId === 'string' && sessionId
+      ? this.#harness.workspaceSession?.(sessionId)
+      : null;
+    if (typeof session?.readHistory !== 'function') {
+      return { unavailableReason: 'not-delivered' };
+    }
+    const text = await recoverAssistantTextByTimestamp({
+      session,
+      quotedAt,
+      signal: callerSignal,
+      pageSize: WEIXIN_REPLY_HISTORY_PAGE_SIZE,
+      maxPages: WEIXIN_REPLY_HISTORY_MAX_PAGES,
+      timeoutMs: WEIXIN_REPLY_HISTORY_TIMEOUT_MS,
+      toleranceMs: WEIXIN_REPLY_HISTORY_MATCH_TOLERANCE_MS,
+    });
+    if (!text) return { unavailableReason: 'not-delivered' };
+    const messageId = nonEmptyString(reference?.messageId);
+    try {
+      await this.#state.rememberOutboundMessage?.({
+        toUserId: sender,
+        text,
+        sentAt: quotedAt,
+        completedAt: quotedAt,
+        providerMessageIds: messageId ? [messageId] : [],
+      });
+    } catch (error) {
+      this.#logger.warn?.('[dsh-weixin] failed to remember a recovered quote:', error);
+    }
+    return { content: text };
+  }
+
   #finishBatchResult(message, messageId, key, sender, contextToken, runId, result) {
     let task;
     task = Promise.resolve().then(async () => {
@@ -644,11 +717,12 @@ export class WeixinHarnessBridge {
     let batchSettled = batchSubmission === null;
     let promptRecorded = false;
     try {
-      const promptMessage = preparedMessage ?? weixinInboundMessage(message, this.#api);
+      const promptMessage = preparedMessage ?? this.#inboundMessage(message);
       const text = promptMessage.content;
       const hasImages = hasInboundImages(promptMessage);
       const hasFiles = hasInboundFiles(promptMessage);
-      if (!text && !hasImages && !hasFiles) {
+      const hasReply = hasReplyReference(promptMessage);
+      if (!text && !hasImages && !hasFiles && !hasReply) {
         await this.#send(sender, t('目前支持文字、图片、文件，以及微信已转成文字的语音消息。'), contextToken, runId);
         await this.#state.markSeen(messageId);
         return;
@@ -701,8 +775,8 @@ export class WeixinHarnessBridge {
       let artifacts = [];
       await this.#startTyping(sender, contextToken);
       try {
-        let content = hasImages
-          ? await promptContentForMessage(promptMessage, { signal: this.#signal })
+        let content = hasImages || hasReply
+          ? await promptContentForInboundMessage(promptMessage, { signal: this.#signal })
           : undefined;
         const snapshot = this.#acceptedMessageIds.get(messageId);
         let contextEnhanced = false;
@@ -1154,6 +1228,7 @@ export class WeixinHarnessBridge {
     const chunks = splitWeixinText(text, this.#maxMessageChars);
     for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex += 1) {
       const chunk = chunks[chunkIndex];
+      const sentAt = Date.now();
       try {
         const result = await this.#api.sendText({
           baseUrl: this.#baseUrl,
@@ -1164,7 +1239,19 @@ export class WeixinHarnessBridge {
           runId,
           signal: this.#signal,
         });
-        providerMessageIds.push(...providerMessageIdsFor(result));
+        const chunkMessageIds = providerMessageIdsFor(result);
+        providerMessageIds.push(...chunkMessageIds);
+        try {
+          await this.#state.rememberOutboundMessage?.({
+            toUserId,
+            text: chunk,
+            sentAt,
+            completedAt: Date.now(),
+            providerMessageIds: chunkMessageIds,
+          });
+        } catch (error) {
+          this.#logger.warn?.('[dsh-weixin] failed to remember an outbound message:', error);
+        }
       } catch (error) {
         throw weixinSendError(error, {
           baseUrl: this.#baseUrl,

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

@@ -1,5 +1,6 @@
 import { DEFAULT_WEIXIN_MAX_MESSAGE_CHARS, WeixinApiError } from './weixin-api.mjs';
 import { createWeixinBridgeStatus, WeixinHarnessBridge } from './weixin-bridge.mjs';
+import { providerMessageIdsFor } from '../shared/semantic/delivery.mjs';
 import {
   connectionTestTarget,
   connectionTestTargetUnavailable,
@@ -324,9 +325,7 @@ export class WeixinRuntime {
     if (!this.#status.ready || !this.#abortController) {
       throw new Error('Weixin runtime is not connected');
     }
-    await this.#api.sendText({
-      baseUrl: this.#config.baseUrl,
-      token: this.#token,
+    await this.#sendTrackedText({
       toUserId,
       text,
       signal: this.#abortController.signal,
@@ -334,6 +333,29 @@ export class WeixinRuntime {
     return { sent: true };
   }
 
+  async #sendTrackedText({ toUserId, text, signal }) {
+    const sentAt = Date.now();
+    const result = await this.#api.sendText({
+      baseUrl: this.#config.baseUrl,
+      token: this.#token,
+      toUserId,
+      text,
+      signal,
+    });
+    try {
+      await this.#state.rememberOutboundMessage?.({
+        toUserId,
+        text,
+        sentAt,
+        completedAt: Date.now(),
+        providerMessageIds: providerMessageIdsFor(result),
+      });
+    } catch (error) {
+      this.#logger.warn?.('[dsh-weixin] failed to remember an outbound message:', error);
+    }
+    return result;
+  }
+
   async sendProactiveText(target, text, { signal } = {}) {
     const toUserId = typeof target?.route?.toUserId === 'string'
       ? target.route.toUserId.trim() : '';
@@ -348,9 +370,7 @@ export class WeixinRuntime {
       throw error;
     }
     signal?.throwIfAborted();
-    await this.#api.sendText({
-      baseUrl: this.#config.baseUrl,
-      token: this.#token,
+    await this.#sendTrackedText({
       toUserId,
       text,
       signal: signal ?? this.#abortController.signal,