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

package/dist/dws-channel.js

@@ -5,14 +5,14 @@
  */
 import { createHash, randomUUID } from 'node:crypto';
 import process from 'node:process';
-import { isTerminalTaskLifecycleType, PollingChannelBase, sanitizeLogText, truncateCodePoints, } from '@qwen-code/channel-base';
+import { isTerminalTaskLifecycleType, PollingChannelBase, sanitizeLogText, stripMessagePrefix, truncateCodePoints, } from '@qwen-code/channel-base';
 import { DwsClient, DwsCommandError, } from './dws-client.js';
 import { DwsEventProcessError, } from './dws-event-stream.js';
 const MAX_DOCUMENT_CONTEXT_CHARS = 12_000;
 const MAX_TODO_CONTEXT_CHARS = 12_000;
 const MAX_COMMENT_CHARS = 4_000;
 const MAX_PROCESSED_ITEMS = 5_000;
-const MAX_DIRECT_REPLAY_DISPATCHES = 16;
+const MAX_REPLAY_CONVERSATIONS = 16;
 /**
  * How many times one inbound message may fail its turn before it is dropped.
  *
@@ -164,7 +164,8 @@ function isPendingMessage(value) {
         return false;
     }
     const pending = value;
-    const sourceValid = pending.source?.kind === 'direct' ||
+    const sourceValid = pending.source?.kind === 'at' ||
+        pending.source?.kind === 'direct' ||
         pending.source?.kind === 'group-all' ||
         (pending.source?.kind === 'group' &&
             typeof pending.source.conversationId === 'string' &&
@@ -173,7 +174,8 @@ function isPendingMessage(value) {
     if (!sourceValid || typeof message !== 'object' || message === null) {
         return false;
     }
-    return ((message.type === 'user_im_message_receive_o2o' ||
+    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') &&
@@ -262,6 +264,13 @@ function sourceLabel(source) {
         return 'all group messages';
     return 'group messages';
 }
+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;
+}
 function retryLimit(error) {
     if (!(error instanceof DwsEventProcessError))
         return 1;
@@ -315,6 +324,7 @@ export class DwsChannel extends PollingChannelBase {
     userInstructions;
     client;
     imStates;
+    dwsMessagePrefix;
     startReactionName;
     endReactionName;
     watchTodos;
@@ -325,13 +335,17 @@ export class DwsChannel extends PollingChannelBase {
     endReactionKeys = new Set();
     notifiedSenderPairingNotifications = new Set();
     processingMessages = new Map();
-    queuedDirectMessages = new Map();
-    // Replay-started direct dispatches only. The cap must not be consumed by
+    queuedMessages = new Map();
+    // Replay-started dispatches only. The cap must not be consumed by
     // live or followup traffic, whose queue entries outlive their turn.
-    replayDirectDispatches = new Map();
-    directConversationTails = new Map();
-    directMessageStartResolvers = new Map();
+    replayDispatches = new Map();
+    attemptedPendingMessages = new Set();
+    conversationTails = new Map();
+    messageStartResolvers = new Map();
+    processingMessageGenerations = new Map();
     pendingMessageCapacityWaiters = new Set();
+    drainingImSubscriptions = new Set();
+    pendingImStartups = new Set();
     pollAbortController = new AbortController();
     lifecycleGeneration = 0;
     connectionStartedAt = 0;
@@ -340,6 +354,7 @@ export class DwsChannel 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');
@@ -383,6 +398,7 @@ export class DwsChannel extends PollingChannelBase {
         }));
         this.startReactionName = startReactionName;
         this.endReactionName = endReactionName;
+        this.dwsMessagePrefix = messagePrefix;
         this.watchTodos = watchTodos;
     }
     createInitialCursor() {
@@ -464,7 +480,7 @@ export class DwsChannel 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,
@@ -477,9 +493,13 @@ export class DwsChannel 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.');
@@ -539,7 +559,10 @@ export class DwsChannel 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.');
             }
@@ -573,12 +596,13 @@ export class DwsChannel 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();
@@ -587,11 +611,35 @@ export class DwsChannel extends PollingChannelBase {
             if (state.retryTimer)
                 clearTimeout(state.retryTimer);
             state.retryTimer = undefined;
-            state.subscription?.stop();
+            const subscription = state.subscription;
+            if (subscription) {
+                void this.drainImSubscription(subscription);
+            }
             state.subscription = undefined;
             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(() => undefined, () => undefined);
+        this.pendingImStartups.add(settled);
+        void settled.then(() => this.pendingImStartups.delete(settled));
+    }
+    drainImSubscription(subscription) {
+        const drain = subscription.closed.then(() => undefined, () => undefined);
+        this.drainingImSubscriptions.add(drain);
+        void drain.then(() => this.drainingImSubscriptions.delete(drain));
+        subscription.stop();
+        return drain;
+    }
     supportsProactiveSend() {
         return true;
     }
@@ -774,6 +822,7 @@ export class DwsChannel extends PollingChannelBase {
         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)
@@ -793,8 +842,16 @@ export class DwsChannel extends PollingChannelBase {
             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,
@@ -833,13 +890,14 @@ export class DwsChannel extends PollingChannelBase {
                 // shared retry budget twice per poll.
                 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;
             if (this.notificationWatermarkPulledBack) {
                 // R4-4: a stale direct message replayed while this window's
-                // fetch was in flight, and `admitReceivedDirectMessage` pulled the
+                // fetch was in flight, and `admitReceivedMessage` pulled the
                 // watermark back
                 // to cover it. That replay was left UNMARKED on purpose for history
                 // polling, so finishing this window normally would undo the rescue:
@@ -958,6 +1016,7 @@ export class DwsChannel extends PollingChannelBase {
             messageId: `todo-${fingerprint}`,
             text: `Process this DingTalk todo:\n${truncateCodePoints(title, MAX_COMMENT_CHARS)}`,
             displayText: title,
+            bypassMessagePrefix: true,
             isGroup: true,
             isMentioned: true,
             isReplyToBot: false,
@@ -1001,19 +1060,21 @@ export class DwsChannel extends PollingChannelBase {
         this.saveCursor();
     }
     async startImSource(state, generation) {
+        const connectionStartedAt = this.connectionStartedAt;
         const subscription = await this.client.subscribeToIm(state.source, (message) => {
             state.lastError = undefined;
             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 = undefined;
@@ -1092,45 +1153,27 @@ export class DwsChannel extends PollingChannelBase {
             if (!this.connected)
                 return;
             state.lastError = undefined;
-            void this.startImSource(state, this.lifecycleGeneration).catch((error) => {
+            const startup = this.startImSource(state, this.lifecycleGeneration).catch((error) => {
                 const resolvedError = error instanceof Error ? error : new Error(String(error));
                 this.logImError(state.source, resolvedError);
                 this.scheduleImRestart(state, resolvedError instanceof DwsEventProcessError
                     ? resolvedError
                     : undefined);
             });
+            this.trackImStartup(startup);
         }, delay);
         state.retryTimer.unref?.();
     }
     logImError(source, error) {
         process.stderr.write(`[Channel:${this.name}] DWS ${sanitizeLogText(sourceLabel(source), 120)} stream error: ${sanitizeLogText(error.message, 300)}\n`);
     }
-    async receiveImMessage(source, message, fromHistory = false) {
-        if (!this.connected)
-            return;
-        if (this.markSelfMessageProcessed(message))
-            return;
-        if (this.isStaleLiveMessage(message, fromHistory) &&
-            message.eventTime !== undefined) {
-            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(() => undefined);
         return {
@@ -1138,68 +1181,145 @@ export class DwsChannel extends PollingChannelBase {
             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 === undefined ||
+                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) &&
+        if (this.isStaleLiveMessage(message, fromHistory, admissionContext?.connectionStartedAt) &&
             message.eventTime !== undefined) {
-            // A replayed direct message is left UNMARKED on purpose, for history
-            // polling to pick up. That only works if polling will ever look
-            // that far back: on a fresh cursor `notificationWatermark` starts at
-            // `connectionStartedAt` and the query window opens at `watermark − 5s`
-            // — exactly this branch's drop boundary — so every message this branch
-            // parks was strictly outside every window the watermark would ever
-            // produce, now and forever, since the window only moves forward. Pull
-            // the watermark back to cover what we just declined to handle.
-            this.cursor.notificationWatermark = Math.min(this.cursor.notificationWatermark ?? this.connectionStartedAt, message.eventTime);
-            this.notificationWatermarkPulledBack = true;
-            // R6-1: the flag alone only covers a replay that lands while a poll's
-            // fetch is in flight — `pollOnce` clears it before every fetch, so a
-            // pullback arriving BETWEEN two polls is reset before it is ever read.
-            // A persisted multi-page checkpoint would then resume its own window,
-            // whose `startTime` is already past this replay, and finish by setting
-            // the watermark to `checkpoint.endTime` — pulling it forward again over
-            // a replay no window will ever cover. Drop the checkpoint here too, so
-            // the pullback survives regardless of when it arrived.
-            this.cursor.notificationCheckpoint = undefined;
-            process.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)}\n`);
+            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.admitMessage(source, message, key, reportFailure);
+    }
+    async admitHistoryMessage(source, message) {
+        const { completion, remembered } = await this.admitReceivedMessage(source, message, true, true);
+        if (remembered) {
+            void completion.catch(() => undefined);
+            return;
         }
-        return this.admitDirectMessage({ kind: 'direct' }, message, key, reportFailure);
+        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) {
+        // A replayed direct message is left UNMARKED on purpose, for history
+        // polling to pick up. Pull the watermark back because the normal window
+        // starts after this message and only moves forward.
+        this.cursor.notificationWatermark = Math.min(this.cursor.notificationWatermark ?? this.connectionStartedAt, message.eventTime);
+        this.notificationWatermarkPulledBack = true;
+        // R6-1: also drop a persisted multi-page checkpoint so a replay that
+        // arrives between polls cannot be skipped when that checkpoint resumes.
+        this.cursor.notificationCheckpoint = undefined;
+        process.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)}\n`);
+        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) {
+    isStaleLiveMessage(message, fromHistory, connectionStartedAt = this.connectionStartedAt) {
         return (!fromHistory &&
             message.eventTime !== undefined &&
-            message.eventTime < this.connectionStartedAt - 5_000);
+            message.eventTime < connectionStartedAt - 5_000);
     }
-    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) => {
+                process.stderr.write(`[Channel:${this.name}] pending DWS message remains degraded: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}\n`);
+            });
+        }
+    }
+    scheduleMessage(source, message, key, reportFailure) {
+        const queued = this.queuedMessages.get(key);
         if (queued)
             return queued;
         if (this.cursor.processedMessages.includes(key)) {
@@ -1211,11 +1331,11 @@ export class DwsChannel extends PollingChannelBase {
             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);
                 }
             }
         };
@@ -1223,24 +1343,30 @@ export class DwsChannel extends PollingChannelBase {
         const started = new Promise((resolve) => {
             resolveStarted = resolve;
         });
-        const previous = this.directConversationTails.get(message.conversationId);
+        const previous = this.conversationTails.get(message.conversationId);
+        const groupConfig = source.kind === 'direct'
+            ? undefined
+            : (this.config.groups[message.conversationId] ??
+                this.config.groups['*']);
         // Live turns only need FIFO through ChannelBase registration; replay and
         // followup turns must wait for the prior turn to finish.
-        const predecessor = reportFailure || this.config.dispatchMode === 'followup'
+        const predecessor = reportFailure ||
+            (groupConfig?.dispatchMode ?? this.config.dispatchMode) === 'followup'
             ? previous?.completed
             : previous?.started;
         const task = predecessor
             ? predecessor.catch(() => undefined).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(() => undefined);
@@ -1251,25 +1377,33 @@ export class DwsChannel extends PollingChannelBase {
         }
         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(() => undefined, (error) => error);
         }
+        if (!this.connected || generation !== this.lifecycleGeneration)
+            return;
         if (this.cursor.processedMessages.includes(key))
             return;
-        // The in-flight turn failed and parked the message while this caller
-        // waited; replay already re-drives parked entries every poll, so a new
-        // turn here would spend the retry budget twice in one poll. Rethrow
-        // instead of returning so `replayPendingMessages` keeps the entry — a
-        // normal return there deletes it.
-        if (waitedOnInFlight && this.hasPendingMessage(key))
+        // A duplicate in the same lifecycle must not spend the retry budget twice
+        // in one poll. A replay from a later reconnect generation is different:
+        // it owns the persisted retry and must run before newer conversation work.
+        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 {
@@ -1282,29 +1416,83 @@ export class DwsChannel extends PollingChannelBase {
         finally {
             if (this.processingMessages.get(key) === task) {
                 this.processingMessages.delete(key);
+                this.processingMessageGenerations.delete(key);
             }
         }
     }
     async processImMessage(source, message, key) {
+        // DWS reports only that the bot was mentioned somewhere, not which token is
+        // the bot, so a leading mention goes only when what follows is unambiguously
+        // a slash command and no later mention could be the one that caused the
+        // at-event. That scan shares the document-mention parser's boundary
+        // heuristic: an `@` glued to a word is an address like `bob@example.com`,
+        // one behind punctuation is a rival mention. The command lookahead must stay
+        // ahead of the whole-remainder scan; swapping them re-runs it at every
+        // backtracked space, quadratic on attacker-controlled content.
+        //
+        // Mention-required conversations only: an ambient group delivers one message
+        // on both the at stream and its group stream under a single dedup key, and
+        // only when a mention is required is the at stream the sole deliverer, so
+        // the normalized text cannot depend on which copy won the race.
+        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)
+            : undefined;
+        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)
-            : undefined;
+        const documentNotification = providerDocumentNotification ??
+            (source.kind === 'direct'
+                ? parseDocumentMentionNotification(text)
+                : undefined);
         if (documentNotification) {
             await this.processDocumentNotification(message, key, documentNotification);
             return;
         }
-        const isGroup = source.kind !== 'direct';
-        const envelope = {
+        const envelope = this.createImEnvelope(source, message, text);
+        this.rememberInboundReactionTarget(message.conversationId, message.messageId);
+        try {
+            await this.handleInbound(envelope);
+        }
+        catch (error) {
+            this.attemptedPendingMessages.add(key);
+            // Under budget the throw propagates so redelivery observes the failure
+            // while persisted replay can retry it. Once the budget is spent the
+            // message is marked processed and the error is swallowed, which is the
+            // only thing that lets the watermark move past it.
+            if (this.recordInboundFailure(key, error, () => {
+                this.markProcessedMessage(key);
+                this.removePendingMessage(key);
+            })) {
+                throw error;
+            }
+            return;
+        }
+        this.clearInboundFailure(key);
+        this.removePendingMessage(key);
+        this.markProcessedMessage(key);
+        this.saveCursor();
+    }
+    createImEnvelope(source, message, text = message.content.trim()) {
+        return {
             channelName: this.name,
             senderId: message.senderId,
             senderName: message.senderName,
@@ -1312,10 +1500,11 @@ export class DwsChannel extends PollingChannelBase {
             chatName: message.conversationId,
             messageId: message.messageId,
             text,
+            bypassMessagePrefix: true,
             ...(message.referencedText
                 ? { referencedText: message.referencedText }
                 : {}),
-            isGroup,
+            isGroup: source.kind !== 'direct',
             isMentioned: source.kind === 'at',
             isReplyToBot: false,
             metadata: [
@@ -1324,34 +1513,6 @@ export class DwsChannel extends PollingChannelBase {
                 `DWS event ID: ${message.eventId}`,
             ].join('\n'),
         };
-        this.rememberInboundReactionTarget(message.conversationId, message.messageId);
-        try {
-            await this.handleInbound(envelope);
-        }
-        catch (error) {
-            if (source.kind !== 'at') {
-                // R12-1: park failed direct messages next to ambient group ones.
-                // Direct-message history may be unavailable, and ambient group
-                // messages have no history fallback. `at` messages need no parking:
-                // the pinned mention checkpoint re-fetches them.
-                await this.rememberFailedMessage(source, message);
-            }
-            // Under budget the throw propagates exactly as before, so redelivery
-            // and concurrent-duplicate retry keep their contracts. Once the budget
-            // is spent the message is marked processed and the error is swallowed,
-            // which is the only thing that lets the watermark move past it.
-            if (this.recordInboundFailure(key, error, () => {
-                this.markProcessedMessage(key);
-                this.removePendingMessage(key);
-            })) {
-                throw error;
-            }
-            return;
-        }
-        this.clearInboundFailure(key);
-        this.removePendingMessage(key);
-        this.markProcessedMessage(key);
-        this.saveCursor();
     }
     /**
      * Account one failed inbound turn, and drop the message once its budget is
@@ -1416,15 +1577,18 @@ export class DwsChannel extends PollingChannelBase {
             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 &&
@@ -1433,6 +1597,19 @@ export class DwsChannel extends PollingChannelBase {
                 this.pendingMessageCapacityWaiters.add(resolve);
             });
         }
+        if (this.hasPendingMessage(key))
+            return true;
+        if (!this.connected || generation !== this.lifecycleGeneration) {
+            // Ambient group streams have no history fallback. A disconnect wakes
+            // capacity waiters, so persist their already-read message before the
+            // event process exits even when that temporarily exceeds the soft cap.
+            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 ?? [];
@@ -1441,14 +1618,20 @@ export class DwsChannel extends PollingChannelBase {
         try {
             this.saveCursor();
         }
-        catch {
-            return;
+        catch (error) {
+            process.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)}\n`);
         }
     }
     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);
@@ -1519,6 +1702,7 @@ export class DwsChannel extends PollingChannelBase {
                 threadId: notification.commentKey,
                 messageId: message.messageId,
                 text: truncateCodePoints(notification.request, MAX_COMMENT_CHARS),
+                bypassMessagePrefix: true,
                 isGroup: true,
                 isMentioned: true,
                 isReplyToBot: false,
@@ -1573,37 +1757,71 @@ export class DwsChannel extends PollingChannelBase {
         }
     }
     async replayPendingMessages(signal) {
+        const activeBySource = new Map();
+        const activeConversations = 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 = new Set();
+        const blockedConversations = 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(() => undefined);
+                }
+                this.removePersistedPendingMessageForSource(key, pending.source);
                 continue;
             }
-            try {
-                await this.receiveImMessage(pending.source, pending.message, true);
-                this.removePendingMessage(key);
-                this.saveCursor();
+            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);
             }
-            catch (error) {
+            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;
                 process.stderr.write(`[Channel:${this.name}] pending DWS message remains degraded: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}\n`);
-            }
+            });
+            void completed
+                .finally(() => {
+                if (this.replayDispatches.get(key) === replay) {
+                    this.replayDispatches.delete(key);
+                }
+            })
+                .catch(() => undefined);
         }
     }
     async replayPendingDocumentNotifications(signal) {
@@ -1700,13 +1918,17 @@ export class DwsChannel extends PollingChannelBase {
     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);
@@ -1866,7 +2088,7 @@ export class DwsChannel extends PollingChannelBase {
     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;