@qwen-code/qwen-code 0.23.0 → 0.23.1-preview.1

package/chunks/{dist-QAF5DO3Y.js → dist-SIHF5MU2.js}

@@ -4,8 +4,9 @@ import {
   PollingChannelBase,
   isTerminalTaskLifecycleType,
   sanitizeLogText,
+  stripMessagePrefix,
   truncateCodePoints
-} from "./chunk-U4DJ5XB3.js";
+} from "./chunk-VDXYYVCD.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import {
@@ -770,8 +771,6 @@ var DwsClient = class {
       const result = onMessage(message);
       if (!result || !("admitted" in result))
         return result;
-      if (source.kind !== "direct")
-        return result.completed;
       const reportError = /* @__PURE__ */ __name((error) => {
         try {
           onError(error instanceof Error ? error : new Error(String(error)));
@@ -1076,7 +1075,7 @@ var MAX_DOCUMENT_CONTEXT_CHARS = 12e3;
 var MAX_TODO_CONTEXT_CHARS = 12e3;
 var MAX_COMMENT_CHARS = 4e3;
 var MAX_PROCESSED_ITEMS = 5e3;
-var MAX_DIRECT_REPLAY_DISPATCHES = 16;
+var MAX_REPLAY_CONVERSATIONS = 16;
 var MAX_INBOUND_ATTEMPTS = 5;
 var MAX_IM_TARGETS = 1e3;
 var MAX_TODO_STATES = 1e3;
@@ -1205,12 +1204,12 @@ function isPendingMessage(value) {
     return false;
   }
   const pending = value;
-  const sourceValid = pending.source?.kind === "direct" || pending.source?.kind === "group-all" || pending.source?.kind === "group" && typeof pending.source.conversationId === "string" && Boolean(pending.source.conversationId);
+  const sourceValid = pending.source?.kind === "at" || pending.source?.kind === "direct" || pending.source?.kind === "group-all" || pending.source?.kind === "group" && typeof pending.source.conversationId === "string" && Boolean(pending.source.conversationId);
   const message = pending.message;
   if (!sourceValid || typeof message !== "object" || message === null) {
     return false;
   }
-  return (message.type === "user_im_message_receive_o2o" || message.type === "user_im_message_receive_o2o_all" || message.type === "user_im_message_receive_group" || message.type === "user_im_message_receive_group_all") && [
+  return (message.type === "user_im_message_receive_at" || message.type === "user_im_message_receive_o2o" || message.type === "user_im_message_receive_o2o_all" || message.type === "user_im_message_receive_group" || message.type === "user_im_message_receive_group_all") && [
     message.type,
     message.eventId,
     message.messageId,
@@ -1285,6 +1284,14 @@ function sourceLabel(source) {
   return "group messages";
 }
 __name(sourceLabel, "sourceLabel");
+function sameImSource(left, right) {
+  if (left.kind !== right.kind)
+    return false;
+  if (left.kind !== "group")
+    return true;
+  return right.kind === "group" && left.conversationId === right.conversationId;
+}
+__name(sameImSource, "sameImSource");
 function retryLimit(error) {
   if (!(error instanceof DwsEventProcessError))
     return 1;
@@ -1338,6 +1345,7 @@ var DwsChannel = class extends PollingChannelBase {
   userInstructions;
   client;
   imStates;
+  dwsMessagePrefix;
   startReactionName;
   endReactionName;
   watchTodos;
@@ -1348,13 +1356,17 @@ var DwsChannel = class extends PollingChannelBase {
   endReactionKeys = /* @__PURE__ */ new Set();
   notifiedSenderPairingNotifications = /* @__PURE__ */ new Set();
   processingMessages = /* @__PURE__ */ new Map();
-  queuedDirectMessages = /* @__PURE__ */ new Map();
-  // Replay-started direct dispatches only. The cap must not be consumed by
+  queuedMessages = /* @__PURE__ */ new Map();
+  // Replay-started dispatches only. The cap must not be consumed by
   // live or followup traffic, whose queue entries outlive their turn.
-  replayDirectDispatches = /* @__PURE__ */ new Map();
-  directConversationTails = /* @__PURE__ */ new Map();
-  directMessageStartResolvers = /* @__PURE__ */ new Map();
+  replayDispatches = /* @__PURE__ */ new Map();
+  attemptedPendingMessages = /* @__PURE__ */ new Set();
+  conversationTails = /* @__PURE__ */ new Map();
+  messageStartResolvers = /* @__PURE__ */ new Map();
+  processingMessageGenerations = /* @__PURE__ */ new Map();
   pendingMessageCapacityWaiters = /* @__PURE__ */ new Set();
+  drainingImSubscriptions = /* @__PURE__ */ new Set();
+  pendingImStartups = /* @__PURE__ */ new Set();
   pollAbortController = new AbortController();
   lifecycleGeneration = 0;
   connectionStartedAt = 0;
@@ -1363,6 +1375,7 @@ var DwsChannel = class extends PollingChannelBase {
   notificationWatermarkPulledBack = false;
   constructor(name, config, bridge, options, client) {
     const profile = configuredString(config.profile, "profile");
+    const messagePrefix = configuredString(config.messagePrefix, "messagePrefix");
     const startReactionName = configuredString(config.startReaction, "startReaction") ?? DEFAULT_START_REACTION;
     const endReactionName = configuredString(config.endReaction, "endReaction");
     const watchTodos = configuredBoolean(config.watchTodos, "watchTodos");
@@ -1394,6 +1407,7 @@ var DwsChannel = class extends PollingChannelBase {
     }));
     this.startReactionName = startReactionName;
     this.endReactionName = endReactionName;
+    this.dwsMessagePrefix = messagePrefix;
     this.watchTodos = watchTodos;
   }
   createInitialCursor() {
@@ -1431,7 +1445,7 @@ var DwsChannel = class extends PollingChannelBase {
       notificationCheckpoint: cursor.notificationCheckpoint,
       mentionCheckpoint: cursor.mentionCheckpoint,
       pendingDocumentNotifications: (cursor.pendingDocumentNotifications ?? []).slice(-MAX_PROCESSED_ITEMS),
-      pendingMessages: (cursor.pendingMessages ?? []).slice(-MAX_PROCESSED_ITEMS),
+      pendingMessages: (cursor.pendingMessages ?? []).slice(),
       processedMessages: cursor.processedMessages.slice(-MAX_PROCESSED_ITEMS),
       imTargets: cursor.imTargets.slice(-MAX_IM_TARGETS),
       todosInitialized: cursor.todosInitialized ?? false,
@@ -1444,9 +1458,13 @@ var DwsChannel = class extends PollingChannelBase {
     if (this.connected)
       return;
     const generation = ++this.lifecycleGeneration;
-    this.connectionStartedAt = Date.now();
     this.pollAbortController.abort();
     this.pollAbortController = new AbortController();
+    await this.waitForDisconnect();
+    if (generation !== this.lifecycleGeneration) {
+      throw new Error("DWS channel connection was cancelled.");
+    }
+    this.connectionStartedAt = Date.now();
     await this.client.assertCompatible?.(this.pollAbortController.signal);
     if (generation !== this.lifecycleGeneration) {
       throw new Error("DWS channel connection was cancelled.");
@@ -1504,7 +1522,10 @@ var DwsChannel = class extends PollingChannelBase {
     }
     this.connected = true;
     try {
-      await Promise.all(this.imStates.map((state) => this.startImSourceWithRetry(state, generation)));
+      const startups = this.imStates.map((state) => this.startImSourceWithRetry(state, generation));
+      for (const startup of startups)
+        this.trackImStartup(startup);
+      await Promise.all(startups);
       if (generation !== this.lifecycleGeneration || !this.connected) {
         throw new Error("DWS channel connection was cancelled.");
       }
@@ -1537,12 +1558,13 @@ var DwsChannel = class extends PollingChannelBase {
       this.cleanupReaction(key, "disconnect reaction removal");
     }
     this.sessionReactionKeys.clear();
-    this.queuedDirectMessages.clear();
-    this.replayDirectDispatches.clear();
-    for (const resolve of this.directMessageStartResolvers.values())
+    this.queuedMessages.clear();
+    this.replayDispatches.clear();
+    this.attemptedPendingMessages.clear();
+    for (const { resolve } of this.messageStartResolvers.values())
       resolve();
-    this.directMessageStartResolvers.clear();
-    this.directConversationTails.clear();
+    this.messageStartResolvers.clear();
+    this.conversationTails.clear();
     for (const resolve of this.pendingMessageCapacityWaiters)
       resolve();
     this.pendingMessageCapacityWaiters.clear();
@@ -1551,11 +1573,34 @@ var DwsChannel = class extends PollingChannelBase {
       if (state.retryTimer)
         clearTimeout(state.retryTimer);
       state.retryTimer = void 0;
-      state.subscription?.stop();
+      const subscription = state.subscription;
+      if (subscription) {
+        void this.drainImSubscription(subscription);
+      }
       state.subscription = void 0;
       state.restartAttempts = 0;
     }
   }
+  async waitForDisconnect() {
+    while (this.pendingImStartups.size > 0 || this.drainingImSubscriptions.size > 0) {
+      await Promise.all([
+        ...this.pendingImStartups,
+        ...this.drainingImSubscriptions
+      ]);
+    }
+  }
+  trackImStartup(startup) {
+    const settled = startup.then(() => void 0, () => void 0);
+    this.pendingImStartups.add(settled);
+    void settled.then(() => this.pendingImStartups.delete(settled));
+  }
+  drainImSubscription(subscription) {
+    const drain = subscription.closed.then(() => void 0, () => void 0);
+    this.drainingImSubscriptions.add(drain);
+    void drain.then(() => this.drainingImSubscriptions.delete(drain));
+    subscription.stop();
+    return drain;
+  }
   supportsProactiveSend() {
     return true;
   }
@@ -1724,6 +1769,7 @@ Ask the bot operator to approve you with:
     const signal = this.pollAbortController.signal;
     if (!this.connected || signal.aborted)
       return;
+    this.attemptedPendingMessages.clear();
     const endTime = Date.now();
     await this.replayPendingMessages(signal);
     if (signal.aborted || !this.connected)
@@ -1742,8 +1788,16 @@ Ask the bot operator to approve you with:
       for (const message of mentions.messages) {
         if (signal.aborted || !this.connected)
           return;
-        await this.receiveImMessage({ kind: "at" }, message, true);
+        const key = messageKey(message);
+        if (this.cursor.processedMessages.includes(key))
+          continue;
+        if (this.hasPendingMessage(key))
+          continue;
+        this.enqueuePendingConversation(message.conversationId);
+        await this.admitHistoryMessage({ kind: "at" }, message);
       }
+      if (signal.aborted || !this.connected)
+        return;
       if (mentions.nextCursor) {
         this.cursor.mentionCheckpoint = {
           ...mentionCheckpoint,
@@ -1777,7 +1831,8 @@ Ask the bot operator to approve you with:
         }
         if (this.hasPendingMessage(key))
           continue;
-        await this.receiveDirectMessage(message, true).admitted;
+        this.enqueuePendingConversation(message.conversationId);
+        await this.admitHistoryMessage({ kind: "direct" }, message);
       }
       if (signal.aborted || !this.connected)
         return;
@@ -1883,6 +1938,7 @@ Ask the bot operator to approve you with:
       text: `Process this DingTalk todo:
 ${truncateCodePoints(title, MAX_COMMENT_CHARS)}`,
       displayText: title,
+      bypassMessagePrefix: true,
       isGroup: true,
       isMentioned: true,
       isReplyToBot: false,
@@ -1924,17 +1980,21 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
     this.saveCursor();
   }
   async startImSource(state, generation) {
+    const connectionStartedAt = this.connectionStartedAt;
     const subscription = await this.client.subscribeToIm(state.source, (message) => {
       state.lastError = void 0;
       state.restartAttempts = 0;
-      return state.source.kind === "direct" ? this.receiveDirectMessage(message) : this.receiveImMessage(state.source, message);
+      return this.receiveImMessage(state.source, message, false, false, {
+        generation,
+        connectionStartedAt
+      });
     }, (error) => {
       if (error instanceof DwsEventProcessError)
         state.lastError = error;
       this.logImError(state.source, error);
     });
     if (!this.connected || generation !== this.lifecycleGeneration) {
-      subscription.stop();
+      await this.drainImSubscription(subscription);
       return;
     }
     state.lastError = void 0;
@@ -2005,11 +2065,12 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
       if (!this.connected)
         return;
       state.lastError = void 0;
-      void this.startImSource(state, this.lifecycleGeneration).catch((error2) => {
+      const startup = this.startImSource(state, this.lifecycleGeneration).catch((error2) => {
         const resolvedError2 = error2 instanceof Error ? error2 : new Error(String(error2));
         this.logImError(state.source, resolvedError2);
         this.scheduleImRestart(state, resolvedError2 instanceof DwsEventProcessError ? resolvedError2 : void 0);
       });
+      this.trackImStartup(startup);
     }, delay);
     state.retryTimer.unref?.();
   }
@@ -2017,26 +2078,11 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
     process2.stderr.write(`[Channel:${this.name}] DWS ${sanitizeLogText(sourceLabel(source), 120)} stream error: ${sanitizeLogText(error.message, 300)}
 `);
   }
-  async receiveImMessage(source, message, fromHistory = false) {
-    if (!this.connected)
-      return;
-    if (this.markSelfMessageProcessed(message))
-      return;
-    if (this.isStaleLiveMessage(message, fromHistory) && message.eventTime !== void 0) {
-      this.markProcessedMessage(messageKey(message));
-      this.saveCursor();
-      return;
-    }
-    if (source.kind === "group-all" && (this.config.groups[message.conversationId]?.requireMention ?? this.config.groups["*"]?.requireMention ?? true)) {
-      return;
-    }
-    if ((source.kind === "group" || source.kind === "group-all") && this.config.groupPolicy === "pairing" && !this.groupGate.isGroupApproved(message.conversationId)) {
-      return;
-    }
-    await this.dispatchImMessage(source, message, messageKey(message));
+  requiresMention(conversationId) {
+    return this.config.groups[conversationId]?.requireMention ?? this.config.groups["*"]?.requireMention ?? true;
   }
-  receiveDirectMessage(message, fromHistory = false, reportFailure = fromHistory) {
-    const admission = this.admitReceivedDirectMessage(message, fromHistory, reportFailure);
+  receiveImMessage(source, message, fromHistory = false, reportFailure = fromHistory, admissionContext) {
+    const admission = this.admitReceivedMessage(source, message, fromHistory, reportFailure, admissionContext);
     const completed = admission.then(({ completion }) => completion);
     void completed.catch(() => void 0);
     return {
@@ -2044,50 +2090,124 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
       completed
     };
   }
-  async admitReceivedDirectMessage(message, fromHistory, reportFailure) {
-    if (!this.connected)
-      return { completion: Promise.resolve() };
+  async admitReceivedMessage(source, message, fromHistory, reportFailure, admissionContext) {
+    const isAmbientSource = source.kind === "group" || source.kind === "group-all";
+    const isCurrentLifecycle = this.connected && (admissionContext === void 0 || admissionContext.generation === this.lifecycleGeneration);
+    if (!isCurrentLifecycle && (!admissionContext || !isAmbientSource)) {
+      return { completion: Promise.resolve(), remembered: true };
+    }
     const key = messageKey(message);
     if (this.markSelfMessageProcessed(message)) {
-      return { completion: Promise.resolve() };
+      return { completion: Promise.resolve(), remembered: true };
     }
-    if (this.isStaleLiveMessage(message, fromHistory) && message.eventTime !== void 0) {
-      this.cursor.notificationWatermark = Math.min(this.cursor.notificationWatermark ?? this.connectionStartedAt, message.eventTime);
-      this.notificationWatermarkPulledBack = true;
-      this.cursor.notificationCheckpoint = void 0;
-      process2.stderr.write(`[Channel:${this.name}] parked a stale direct message for history polling and pulled the watermark back to ${message.eventTime}: ${sanitizeLogText(message.messageId, 120)}
-`);
+    if (this.isStaleLiveMessage(message, fromHistory, admissionContext?.connectionStartedAt) && message.eventTime !== void 0) {
+      if (source.kind === "direct") {
+        this.parkStaleDirectMessage(message);
+        return { completion: Promise.resolve(), remembered: true };
+      }
+      this.markProcessedMessage(key);
       this.saveCursor();
-      return { completion: Promise.resolve() };
+      return { completion: Promise.resolve(), remembered: true };
+    }
+    if (this.shouldFilterImMessage(source, message)) {
+      if (source.kind === "group" || source.kind === "group-all") {
+        const text = stripMessagePrefix(message.content.trim(), this.dwsMessagePrefix);
+        if (!this.dwsMessagePrefix || text) {
+          const envelope = this.createImEnvelope(source, message, text);
+          if (this.groupGate.check(envelope, { createPairingRequest: false }).reason === "mention_required" && !this.queuedMessages.has(key) && !this.cursor.processedMessages.includes(key) && !this.hasPendingMessage(key)) {
+            this.recordPendingGroupHistory(envelope);
+          }
+        }
+      }
+      this.removePersistedPendingMessageForSource(key, source);
+      return { completion: Promise.resolve(), remembered: true };
+    }
+    if (!isCurrentLifecycle) {
+      if (this.cursor.processedMessages.includes(key)) {
+        this.removePersistedPendingMessage(key);
+        return { completion: Promise.resolve(), remembered: true };
+      }
+      this.rememberDrainingPendingMessage(source, message);
+      return { completion: Promise.resolve(), remembered: true };
     }
-    return this.admitDirectMessage({ kind: "direct" }, message, key, reportFailure);
+    return this.admitMessage(source, message, key, reportFailure);
+  }
+  async admitHistoryMessage(source, message) {
+    const { completion, remembered } = await this.admitReceivedMessage(source, message, true, true);
+    if (remembered) {
+      void completion.catch(() => void 0);
+      return;
+    }
+    await completion;
+  }
+  shouldFilterImMessage(source, message) {
+    const groupConfig = this.config.groups[message.conversationId] ?? this.config.groups["*"];
+    if ((source.kind === "group" || source.kind === "group-all") && (groupConfig?.requireMention ?? true)) {
+      return true;
+    }
+    return (source.kind === "group" || source.kind === "group-all") && this.config.groupPolicy === "pairing" && !this.groupGate.isGroupApproved(message.conversationId);
+  }
+  parkStaleDirectMessage(message) {
+    this.cursor.notificationWatermark = Math.min(this.cursor.notificationWatermark ?? this.connectionStartedAt, message.eventTime);
+    this.notificationWatermarkPulledBack = true;
+    this.cursor.notificationCheckpoint = void 0;
+    process2.stderr.write(`[Channel:${this.name}] parked a stale direct message for history polling and pulled the watermark back to ${message.eventTime}: ${sanitizeLogText(message.messageId, 120)}
+`);
+    this.saveCursor();
   }
   markSelfMessageProcessed(message) {
     if (!this.isSelfMessage(message))
       return false;
-    this.markProcessedMessage(messageKey(message));
+    const key = messageKey(message);
+    this.markProcessedMessage(key);
+    this.removePendingMessage(key);
     this.saveCursor();
     return true;
   }
-  isStaleLiveMessage(message, fromHistory) {
-    return !fromHistory && message.eventTime !== void 0 && message.eventTime < this.connectionStartedAt - 5e3;
+  isStaleLiveMessage(message, fromHistory, connectionStartedAt = this.connectionStartedAt) {
+    return !fromHistory && message.eventTime !== void 0 && message.eventTime < connectionStartedAt - 5e3;
   }
-  async admitDirectMessage(source, message, key, reportFailure) {
+  async admitMessage(source, message, key, reportFailure) {
     if (this.cursor.processedMessages.includes(key)) {
       this.removePersistedPendingMessage(key);
-      return { completion: Promise.resolve() };
+      return { completion: Promise.resolve(), remembered: true };
+    }
+    if (!reportFailure) {
+      this.enqueuePendingConversation(message.conversationId);
     }
+    let remembered = true;
     if (!this.hasPendingMessage(key)) {
-      if (!await this.rememberPendingMessage(source, message)) {
-        return { completion: Promise.resolve() };
+      const dispatchUnparkedAtCapacity = (source.kind === "at" || source.kind === "direct") && this.connected && (this.cursor.pendingMessages?.length ?? 0) >= MAX_PROCESSED_ITEMS;
+      remembered = dispatchUnparkedAtCapacity ? false : source.kind === "group" || source.kind === "group-all" ? await this.rememberPendingMessageWhenAvailable(source, message) : await this.rememberPendingMessage(source, message);
+      if (!remembered) {
+        if (!dispatchUnparkedAtCapacity) {
+          return { completion: Promise.resolve(), remembered };
+        }
       }
     }
     return {
-      completion: this.scheduleDirectMessage(source, message, key, reportFailure)
+      completion: this.scheduleMessage(source, message, key, reportFailure),
+      remembered
     };
   }
-  scheduleDirectMessage(source, message, key, reportFailure) {
-    const queued = this.queuedDirectMessages.get(key);
+  enqueuePendingConversation(conversationId) {
+    for (const pending of [...this.cursor.pendingMessages ?? []]) {
+      if (pending.message.conversationId !== conversationId)
+        continue;
+      const key = messageKey(pending.message);
+      if (this.attemptedPendingMessages.has(key))
+        continue;
+      if (this.queuedMessages.has(key))
+        continue;
+      const dispatch = this.receiveImMessage(pending.source, pending.message, true, true);
+      void dispatch.admitted.catch((error) => {
+        process2.stderr.write(`[Channel:${this.name}] pending DWS message remains degraded: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
+`);
+      });
+    }
+  }
+  scheduleMessage(source, message, key, reportFailure) {
+    const queued = this.queuedMessages.get(key);
     if (queued)
       return queued;
     if (this.cursor.processedMessages.includes(key)) {
@@ -2099,10 +2219,10 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
       try {
         if (!this.connected || generation !== this.lifecycleGeneration)
           return;
-        await this.dispatchImMessage(source, message, key);
+        await this.dispatchImMessage(source, message, key, generation);
       } finally {
-        if (this.queuedDirectMessages.get(key) === task) {
-          this.queuedDirectMessages.delete(key);
+        if (this.queuedMessages.get(key) === task) {
+          this.queuedMessages.delete(key);
         }
       }
     }, "dispatch");
@@ -2110,17 +2230,19 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
     const started = new Promise((resolve) => {
       resolveStarted = resolve;
     });
-    const previous = this.directConversationTails.get(message.conversationId);
-    const predecessor = reportFailure || this.config.dispatchMode === "followup" ? previous?.completed : previous?.started;
+    const previous = this.conversationTails.get(message.conversationId);
+    const groupConfig = source.kind === "direct" ? void 0 : this.config.groups[message.conversationId] ?? this.config.groups["*"];
+    const predecessor = reportFailure || (groupConfig?.dispatchMode ?? this.config.dispatchMode) === "followup" ? previous?.completed : previous?.started;
     const task = predecessor ? predecessor.catch(() => void 0).then(dispatch) : Promise.resolve().then(dispatch);
     const tail = { started, completed: task };
-    this.queuedDirectMessages.set(key, task);
-    this.directMessageStartResolvers.set(key, resolveStarted);
-    this.directConversationTails.set(message.conversationId, tail);
+    this.queuedMessages.set(key, task);
+    const startResolver = { generation, resolve: resolveStarted };
+    this.messageStartResolvers.set(key, startResolver);
+    this.conversationTails.set(message.conversationId, tail);
     void task.finally(() => {
-      this.releaseDirectMessageStart(message.conversationId, message.messageId);
-      if (this.directConversationTails.get(message.conversationId) === tail) {
-        this.directConversationTails.delete(message.conversationId);
+      this.releaseMessageStart(message.conversationId, message.messageId, startResolver);
+      if (this.conversationTails.get(message.conversationId) === tail) {
+        this.conversationTails.delete(message.conversationId);
       }
     }).catch(() => void 0);
     if (reportFailure) {
@@ -2130,20 +2252,28 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
     }
     return task;
   }
-  async dispatchImMessage(source, message, key) {
+  async dispatchImMessage(source, message, key, generation) {
     let waitedOnInFlight = false;
+    let waitedOnCurrentGeneration = false;
     let inFlightError;
     while (true) {
       const existing = this.processingMessages.get(key);
       if (!existing)
         break;
       waitedOnInFlight = true;
+      if (this.processingMessageGenerations.get(key) === generation) {
+        waitedOnCurrentGeneration = true;
+      }
       inFlightError = await existing.then(() => void 0, (error) => error);
     }
+    if (!this.connected || generation !== this.lifecycleGeneration)
+      return;
     if (this.cursor.processedMessages.includes(key))
       return;
-    if (waitedOnInFlight && this.hasPendingMessage(key))
+    if (waitedOnInFlight && waitedOnCurrentGeneration && this.hasPendingMessage(key)) {
       throw inFlightError;
+    }
+    this.processingMessageGenerations.set(key, generation);
     const task = this.processImMessage(source, message, key);
     this.processingMessages.set(key, task);
     try {
@@ -2154,49 +2284,37 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
     } finally {
       if (this.processingMessages.get(key) === task) {
         this.processingMessages.delete(key);
+        this.processingMessageGenerations.delete(key);
       }
     }
   }
   async processImMessage(source, message, key) {
+    const rawText = source.kind === "at" && this.requiresMention(message.conversationId) ? message.content.replace(/^\s*@[^\s\p{Cf}]+\s+(?=\/[a-zA-Z0-9_:-]+(?:\s|$))(?![\s\S]*(?<![A-Za-z0-9_])@)/u, "").trim() : message.content.trim();
+    const providerDocumentNotification = source.kind === "direct" ? parseDocumentMentionNotification(rawText) : void 0;
+    const text = providerDocumentNotification ? rawText : stripMessagePrefix(rawText, this.dwsMessagePrefix);
+    if (this.dwsMessagePrefix && !text) {
+      this.markProcessedMessage(key);
+      this.saveCursor();
+      return;
+    }
     const target = source.kind === "direct" ? { kind: "direct", openDingTalkId: message.senderId } : { kind: "group", conversationId: message.conversationId };
     this.rememberImTarget(message.conversationId, target);
-    const text = message.content.trim();
     if (!text) {
       this.markProcessedMessage(key);
       this.saveCursor();
       return;
     }
-    const documentNotification = source.kind === "direct" ? parseDocumentMentionNotification(text) : void 0;
+    const documentNotification = providerDocumentNotification ?? (source.kind === "direct" ? parseDocumentMentionNotification(text) : void 0);
     if (documentNotification) {
       await this.processDocumentNotification(message, key, documentNotification);
       return;
     }
-    const isGroup = source.kind !== "direct";
-    const envelope = {
-      channelName: this.name,
-      senderId: message.senderId,
-      senderName: message.senderName,
-      chatId: message.conversationId,
-      chatName: message.conversationId,
-      messageId: message.messageId,
-      text,
-      ...message.referencedText ? { referencedText: message.referencedText } : {},
-      isGroup,
-      isMentioned: source.kind === "at",
-      isReplyToBot: false,
-      metadata: [
-        `DWS event type: ${message.type}`,
-        `DingTalk conversation: ${message.conversationId}`,
-        `DWS event ID: ${message.eventId}`
-      ].join("\n")
-    };
+    const envelope = this.createImEnvelope(source, message, text);
     this.rememberInboundReactionTarget(message.conversationId, message.messageId);
     try {
       await this.handleInbound(envelope);
     } catch (error) {
-      if (source.kind !== "at") {
-        await this.rememberFailedMessage(source, message);
-      }
+      this.attemptedPendingMessages.add(key);
       if (this.recordInboundFailure(key, error, () => {
         this.markProcessedMessage(key);
         this.removePendingMessage(key);
@@ -2210,6 +2328,27 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
     this.markProcessedMessage(key);
     this.saveCursor();
   }
+  createImEnvelope(source, message, text = message.content.trim()) {
+    return {
+      channelName: this.name,
+      senderId: message.senderId,
+      senderName: message.senderName,
+      chatId: message.conversationId,
+      chatName: message.conversationId,
+      messageId: message.messageId,
+      text,
+      bypassMessagePrefix: true,
+      ...message.referencedText ? { referencedText: message.referencedText } : {},
+      isGroup: source.kind !== "direct",
+      isMentioned: source.kind === "at",
+      isReplyToBot: false,
+      metadata: [
+        `DWS event type: ${message.type}`,
+        `DingTalk conversation: ${message.conversationId}`,
+        `DWS event ID: ${message.eventId}`
+      ].join("\n")
+    };
+  }
   /**
    * Account one failed inbound turn, and drop the message once its budget is
    * spent.
@@ -2268,21 +2407,34 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
     try {
       this.saveCursor();
     } catch (error) {
+      if (source.kind === "group" || source.kind === "group-all") {
+        return true;
+      }
       this.removePendingMessage(key);
       throw error;
     }
     return true;
   }
-  async rememberFailedMessage(source, message) {
+  async rememberPendingMessageWhenAvailable(source, message) {
     const key = messageKey(message);
     if (this.hasPendingMessage(key))
-      return;
+      return true;
     const generation = this.lifecycleGeneration;
     while (this.connected && generation === this.lifecycleGeneration && (this.cursor.pendingMessages?.length ?? 0) >= MAX_PROCESSED_ITEMS) {
       await new Promise((resolve) => {
         this.pendingMessageCapacityWaiters.add(resolve);
       });
     }
+    if (this.hasPendingMessage(key))
+      return true;
+    if (!this.connected || generation !== this.lifecycleGeneration) {
+      this.rememberDrainingPendingMessage(source, message);
+      return true;
+    }
+    return this.rememberPendingMessage(source, message);
+  }
+  rememberDrainingPendingMessage(source, message) {
+    const key = messageKey(message);
     if (this.hasPendingMessage(key))
       return;
     const pending = this.cursor.pendingMessages ?? [];
@@ -2290,14 +2442,20 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
     this.cursor.pendingMessages = pending;
     try {
       this.saveCursor();
-    } catch {
-      return;
+    } catch (error) {
+      process2.stderr.write(`[Channel:${this.name}] could not persist a draining DWS message; keeping it in memory: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
+`);
     }
   }
   removePersistedPendingMessage(key) {
     if (this.removePendingMessage(key))
       this.saveCursor();
   }
+  removePersistedPendingMessageForSource(key, source) {
+    const ownsPendingMessage = (this.cursor.pendingMessages ?? []).some((pending) => messageKey(pending.message) === key && sameImSource(pending.source, source));
+    if (ownsPendingMessage)
+      this.removePersistedPendingMessage(key);
+  }
   removePendingMessage(key) {
     const pending = this.cursor.pendingMessages ?? [];
     const remaining = pending.filter((item) => messageKey(item.message) !== key);
@@ -2356,6 +2514,7 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
         threadId: notification.commentKey,
         messageId: message.messageId,
         text: truncateCodePoints(notification.request, MAX_COMMENT_CHARS),
+        bypassMessagePrefix: true,
         isGroup: true,
         isMentioned: true,
         isReplyToBot: false,
@@ -2398,35 +2557,68 @@ ${context}` : "Document Markdown was unavailable; answer from the comment only."
     }
   }
   async replayPendingMessages(signal) {
+    const activeBySource = /* @__PURE__ */ new Map();
+    const activeConversations = /* @__PURE__ */ new Set();
+    for (const { sourceKind, conversationId } of this.replayDispatches.values()) {
+      if (!activeConversations.has(conversationId)) {
+        activeBySource.set(sourceKind, (activeBySource.get(sourceKind) ?? 0) + 1);
+        activeConversations.add(conversationId);
+      }
+    }
+    const selectedConversations = /* @__PURE__ */ new Set();
+    const blockedConversations = /* @__PURE__ */ new Set();
     for (const pending of [...this.cursor.pendingMessages ?? []]) {
       if (signal.aborted || !this.connected)
         return;
       const key = messageKey(pending.message);
-      if (pending.source.kind === "direct") {
-        if (this.queuedDirectMessages.has(key))
-          continue;
-        if (this.replayDirectDispatches.size >= MAX_DIRECT_REPLAY_DISPATCHES) {
-          continue;
-        }
-        const dispatched = this.scheduleDirectMessage(pending.source, pending.message, key, true);
-        this.replayDirectDispatches.set(key, dispatched);
-        void dispatched.finally(() => {
-          if (this.replayDirectDispatches.get(key) === dispatched) {
-            this.replayDirectDispatches.delete(key);
+      if (this.queuedMessages.has(key))
+        continue;
+      if (this.markSelfMessageProcessed(pending.message))
+        continue;
+      if (this.shouldFilterImMessage(pending.source, pending.message)) {
+        if (pending.source.kind === "group" || pending.source.kind === "group-all") {
+          const text = stripMessagePrefix(pending.message.content.trim(), this.dwsMessagePrefix);
+          if (!this.dwsMessagePrefix || text) {
+            const envelope = this.createImEnvelope(pending.source, pending.message, text);
+            if (this.groupGate.check(envelope, { createPairingRequest: false }).reason === "mention_required") {
+              this.recordPendingGroupHistory(envelope);
+            }
           }
-        }).catch(() => void 0);
+        }
+        this.removePersistedPendingMessageForSource(key, pending.source);
         continue;
       }
-      try {
-        await this.receiveImMessage(pending.source, pending.message, true);
-        this.removePendingMessage(key);
-        this.saveCursor();
-      } catch (error) {
+      if (activeConversations.has(pending.message.conversationId))
+        continue;
+      if (blockedConversations.has(pending.message.conversationId))
+        continue;
+      if (!selectedConversations.has(pending.message.conversationId)) {
+        const activeForSource = activeBySource.get(pending.source.kind) ?? 0;
+        if (activeForSource >= MAX_REPLAY_CONVERSATIONS) {
+          blockedConversations.add(pending.message.conversationId);
+          continue;
+        }
+        activeBySource.set(pending.source.kind, activeForSource + 1);
+        selectedConversations.add(pending.message.conversationId);
+      }
+      const dispatch = this.receiveImMessage(pending.source, pending.message, true, true);
+      const completed = dispatch.completed;
+      const replay = {
+        sourceKind: pending.source.kind,
+        conversationId: pending.message.conversationId
+      };
+      this.replayDispatches.set(key, replay);
+      void dispatch.admitted.catch((error) => {
         if (signal.aborted || !this.connected)
           return;
         process2.stderr.write(`[Channel:${this.name}] pending DWS message remains degraded: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
 `);
-      }
+      });
+      void completed.finally(() => {
+        if (this.replayDispatches.get(key) === replay) {
+          this.replayDispatches.delete(key);
+        }
+      }).catch(() => void 0);
     }
   }
   async replayPendingDocumentNotifications(signal) {
@@ -2510,13 +2702,16 @@ ${context}` : "Document Markdown was unavailable; answer from the comment only."
   reactionKey(conversationId, messageId) {
     return `${conversationId}\0${messageId}`;
   }
-  releaseDirectMessageStart(conversationId, messageId) {
+  releaseMessageStart(conversationId, messageId, expected) {
     const key = `${conversationId}\0${messageId}`;
-    const resolve = this.directMessageStartResolvers.get(key);
-    if (!resolve)
+    const resolver = this.messageStartResolvers.get(key);
+    if (!resolver || expected && resolver !== expected)
       return;
-    this.directMessageStartResolvers.delete(key);
-    resolve();
+    if (!expected && this.processingMessageGenerations.get(key) !== resolver.generation) {
+      return;
+    }
+    this.messageStartResolvers.delete(key);
+    resolver.resolve();
   }
   rememberInboundReactionTarget(chatId, messageId, conversationId = chatId) {
     const key = this.reactionKey(chatId, messageId);
@@ -2664,7 +2859,7 @@ ${context}` : "Document Markdown was unavailable; answer from the comment only."
   onTaskLifecycle(event) {
     if (event.type === "started") {
       if (event.messageId) {
-        this.releaseDirectMessageStart(event.chatId, event.messageId);
+        this.releaseMessageStart(event.chatId, event.messageId);
       }
       this.startReaction(event.chatId, event.messageId, event.sessionId);
       return;