@qwen-code/channel-dws 0.22.3 → 0.23.0

package/dist/dws-channel.js

@@ -12,6 +12,7 @@ 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;
 /**
  * How many times one inbound message may fail its turn before it is dropped.
  *
@@ -28,7 +29,7 @@ const EVENT_RESTART_DELAY_MS = 2_000;
 const EVENT_RESTART_MAX_DELAY_MS = 5 * 60_000;
 const NO_REPLY_SENTINEL = '[NO_REPLY]';
 const NO_REPLY_SENTINEL_PATTERN = /^\[NO_REPLY\][.!]?$/i;
-const ACK_REACTION_NAME = '暗中观察';
+export const DEFAULT_START_REACTION = '🤔';
 const MAX_INBOUND_REACTION_TARGETS = 1_000;
 const NOTIFICATION_HISTORY_OVERLAP_MS = 5_000;
 const NOTIFICATION_POLL_INTERVAL_MS = 5_000;
@@ -314,12 +315,23 @@ export class DwsChannel extends PollingChannelBase {
     userInstructions;
     client;
     imStates;
+    startReactionName;
+    endReactionName;
     watchTodos;
     inboundReactionTargets = new Map();
-    activeReactionKeys = new Set();
+    activeReactions = new Map();
     sessionReactionKeys = new Map();
+    reactionOperations = new Map();
+    endReactionKeys = new Set();
     notifiedSenderPairingNotifications = new Set();
     processingMessages = new Map();
+    queuedDirectMessages = new Map();
+    // Replay-started direct 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();
+    pendingMessageCapacityWaiters = new Set();
     pollAbortController = new AbortController();
     lifecycleGeneration = 0;
     connectionStartedAt = 0;
@@ -328,6 +340,9 @@ export class DwsChannel extends PollingChannelBase {
     notificationWatermarkPulledBack = false;
     constructor(name, config, bridge, options, client) {
         const profile = configuredString(config.profile, 'profile');
+        const startReactionName = configuredString(config.startReaction, 'startReaction') ??
+            DEFAULT_START_REACTION;
+        const endReactionName = configuredString(config.endReaction, 'endReaction');
         const watchTodos = configuredBoolean(config.watchTodos, 'watchTodos');
         if (profile?.includes(',')) {
             throw new Error('DWS channel profile must select exactly one login profile.');
@@ -366,6 +381,8 @@ export class DwsChannel extends PollingChannelBase {
             source,
             restartAttempts: 0,
         }));
+        this.startReactionName = startReactionName;
+        this.endReactionName = endReactionName;
         this.watchTodos = watchTodos;
     }
     createInitialCursor() {
@@ -552,17 +569,19 @@ export class DwsChannel extends PollingChannelBase {
         this.pollAbortController.abort();
         this.lastTodoPollAt = 0;
         this.todoTargets.clear();
-        for (const reactions of this.sessionReactionKeys.values()) {
-            for (const [key, { conversationId, messageId }] of reactions) {
-                if (!this.activeReactionKeys.delete(key))
-                    continue;
-                void this.client
-                    .removeImReaction(conversationId, messageId, ACK_REACTION_NAME)
-                    .catch((error) => this.logReactionFailure('disconnect reaction removal', error));
-            }
+        for (const key of [...this.activeReactions.keys()]) {
+            this.cleanupReaction(key, 'disconnect reaction removal');
         }
-        this.activeReactionKeys.clear();
         this.sessionReactionKeys.clear();
+        this.queuedDirectMessages.clear();
+        this.replayDirectDispatches.clear();
+        for (const resolve of this.directMessageStartResolvers.values())
+            resolve();
+        this.directMessageStartResolvers.clear();
+        this.directConversationTails.clear();
+        for (const resolve of this.pendingMessageCapacityWaiters)
+            resolve();
+        this.pendingMessageCapacityWaiters.clear();
         this.stopPollLoop();
         for (const state of this.imStates) {
             if (state.retryTimer)
@@ -668,7 +687,7 @@ export class DwsChannel extends PollingChannelBase {
         }
         await this.client.sendImMessage(target, text, idempotencyKey);
     }
-    async sendThreadMessage(chatId, threadId, text) {
+    async sendThreadMessage(chatId, threadId, text, sourceLabel) {
         if (!this.connected) {
             throw new Error(`[Channel:${this.name}] DWS channel is disconnected.`);
         }
@@ -678,21 +697,23 @@ export class DwsChannel extends PollingChannelBase {
             if (threadId !== taskId) {
                 throw new Error(`[Channel:${this.name}] DWS todo delivery requires its taskId thread.`);
             }
-            await this.client.addTodoComment(taskId, text);
+            await this.client.addTodoComment(taskId, this.formatMarkdownAttributedText(text, sourceLabel));
             return;
         }
         if (!this.documentSet.has(chatId)) {
-            await this.sendMessage(chatId, text);
+            await this.sendMessage(chatId, this.formatAttributedText(text, sourceLabel));
             return;
         }
         if (!threadId) {
             throw new Error(`[Channel:${this.name}] DWS document delivery requires a commentKey.`);
         }
-        await this.client.replyToComment(chatId, threadId, text);
+        await this.client.replyToComment(chatId, threadId, this.formatMarkdownAttributedText(text, sourceLabel));
     }
-    async sendResponseMessage(chatId, text, sessionId) {
+    async sendResponseMessage(chatId, text, sessionId, sourceLabel) {
         if (isNoReply(text))
             return;
+        const label = sourceLabel ?? this.getResponseSourceLabel(sessionId);
+        const markdown = this.formatMarkdownAttributedText(text, label);
         const threadId = this.getResponseThreadId(sessionId);
         const taskId = this.todoTargets.get(chatId) ??
             (threadId && todoChatId(threadId) === chatId ? threadId : undefined);
@@ -701,7 +722,7 @@ export class DwsChannel extends PollingChannelBase {
                 throw new Error(`[Channel:${this.name}] DWS channel is disconnected.`);
             }
             try {
-                await this.client.addTodoComment(taskId, text);
+                await this.client.addTodoComment(taskId, markdown);
             }
             catch (error) {
                 if (!(error instanceof DwsCommandError) ||
@@ -720,7 +741,7 @@ export class DwsChannel extends PollingChannelBase {
                 throw new Error(`[Channel:${this.name}] DWS document delivery requires a commentKey.`);
             }
             try {
-                await this.client.replyToComment(chatId, threadId, text);
+                await this.client.replyToComment(chatId, threadId, markdown);
             }
             catch (error) {
                 if (!(error instanceof DwsCommandError) ||
@@ -734,15 +755,20 @@ export class DwsChannel extends PollingChannelBase {
         const messageId = this.getResponseMessageId(sessionId);
         const senderId = this.getResponseSenderId(sessionId);
         if (!messageId || !senderId) {
-            await this.sendMessage(chatId, text);
+            await this.sendMessage(chatId, this.formatAttributedText(text, label));
             return;
         }
         const idempotencyKey = stableUuid(`${this.name}\0${chatId}\0${messageId}\0${text}`);
         if (this.findImTarget(chatId)?.kind === 'direct') {
-            await this.sendImText(chatId, text, idempotencyKey);
+            await this.sendImText(chatId, this.formatAttributedText(text, label), idempotencyKey);
             return;
         }
-        await this.client.replyToImMessage(chatId, messageId, senderId, text, idempotencyKey);
+        await this.client.replyToImMessage(chatId, messageId, senderId, this.formatAttributedText(text, label), idempotencyKey);
+    }
+    async pushProactive(target, text, sourceLabel) {
+        if (isNoReply(text))
+            return;
+        await super.pushProactive(target, text, sourceLabel);
     }
     async pollOnce() {
         const signal = this.pollAbortController.signal;
@@ -767,7 +793,7 @@ export class DwsChannel extends PollingChannelBase {
             for (const message of mentions.messages) {
                 if (signal.aborted || !this.connected)
                     return;
-                await this.handleImMessage({ kind: 'at' }, message, true);
+                await this.receiveImMessage({ kind: 'at' }, message, true);
             }
             if (mentions.nextCursor) {
                 this.cursor.mentionCheckpoint = {
@@ -807,22 +833,14 @@ export class DwsChannel extends PollingChannelBase {
                 // shared retry budget twice per poll.
                 if (this.hasPendingMessage(key))
                     continue;
-                try {
-                    await this.handleImMessage({ kind: 'direct' }, message, true);
-                }
-                catch (error) {
-                    // A failed plain direct message was just parked for replay, so the
-                    // page can keep moving. An unparked failure — a document
-                    // notification's turn — must still abort the window: the pinned
-                    // watermark is what re-fetches it until its budget is spent.
-                    if (!this.hasPendingMessage(key))
-                        throw error;
-                    process.stderr.write(`[Channel:${this.name}] direct-message dispatch failed mid-window; the message is parked for retry: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}\n`);
-                }
+                await this.receiveDirectMessage(message, true).admitted;
             }
+            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 `handleImMessage` pulled the watermark back
+                // fetch was in flight, and `admitReceivedDirectMessage` 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:
                 // `checkpoint.endTime` is always past the replay's `eventTime`, and
@@ -986,7 +1004,9 @@ export class DwsChannel extends PollingChannelBase {
         const subscription = await this.client.subscribeToIm(state.source, (message) => {
             state.lastError = undefined;
             state.restartAttempts = 0;
-            return this.handleImMessage(state.source, message);
+            return state.source.kind === 'direct'
+                ? this.receiveDirectMessage(message)
+                : this.receiveImMessage(state.source, message);
         }, (error) => {
             if (error instanceof DwsEventProcessError)
                 state.lastError = error;
@@ -1085,22 +1105,48 @@ export class DwsChannel extends PollingChannelBase {
     logImError(source, error) {
         process.stderr.write(`[Channel:${this.name}] DWS ${sanitizeLogText(sourceLabel(source), 120)} stream error: ${sanitizeLogText(error.message, 300)}\n`);
     }
-    async handleImMessage(source, message, fromHistory = false) {
+    async receiveImMessage(source, message, fromHistory = false) {
         if (!this.connected)
             return;
-        if (this.isSelfMessage(message)) {
+        if (this.markSelfMessageProcessed(message))
+            return;
+        if (this.isStaleLiveMessage(message, fromHistory) &&
+            message.eventTime !== undefined) {
             this.markProcessedMessage(messageKey(message));
             this.saveCursor();
             return;
         }
-        if (!fromHistory &&
-            message.eventTime !== undefined &&
-            message.eventTime < this.connectionStartedAt - 5_000) {
-            if (source.kind !== 'direct') {
-                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));
+    }
+    receiveDirectMessage(message, fromHistory = false, reportFailure = fromHistory) {
+        const admission = this.admitReceivedDirectMessage(message, fromHistory, reportFailure);
+        const completed = admission.then(({ completion }) => completion);
+        void completed.catch(() => undefined);
+        return {
+            admitted: admission.then(() => undefined),
+            completed,
+        };
+    }
+    async admitReceivedDirectMessage(message, fromHistory, reportFailure) {
+        if (!this.connected)
+            return { completion: Promise.resolve() };
+        const key = messageKey(message);
+        if (this.markSelfMessageProcessed(message)) {
+            return { completion: Promise.resolve() };
+        }
+        if (this.isStaleLiveMessage(message, fromHistory) &&
+            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
@@ -1122,20 +1168,90 @@ export class DwsChannel extends PollingChannelBase {
             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();
-            return;
+            return { completion: Promise.resolve() };
         }
-        if (source.kind === 'group-all' &&
-            (this.config.groups[message.conversationId]?.requireMention ??
-                this.config.groups['*']?.requireMention ??
-                true)) {
-            return;
+        return this.admitDirectMessage({ kind: 'direct' }, message, key, reportFailure);
+    }
+    markSelfMessageProcessed(message) {
+        if (!this.isSelfMessage(message))
+            return false;
+        this.markProcessedMessage(messageKey(message));
+        this.saveCursor();
+        return true;
+    }
+    isStaleLiveMessage(message, fromHistory) {
+        return (!fromHistory &&
+            message.eventTime !== undefined &&
+            message.eventTime < this.connectionStartedAt - 5_000);
+    }
+    async admitDirectMessage(source, message, key, reportFailure) {
+        if (this.cursor.processedMessages.includes(key)) {
+            this.removePersistedPendingMessage(key);
+            return { completion: Promise.resolve() };
         }
-        if ((source.kind === 'group' || source.kind === 'group-all') &&
-            this.config.groupPolicy === 'pairing' &&
-            !this.groupGate.isGroupApproved(message.conversationId)) {
-            return;
+        if (!this.hasPendingMessage(key)) {
+            if (!(await this.rememberPendingMessage(source, message))) {
+                return { completion: Promise.resolve() };
+            }
         }
-        const key = messageKey(message);
+        return {
+            completion: this.scheduleDirectMessage(source, message, key, reportFailure),
+        };
+    }
+    scheduleDirectMessage(source, message, key, reportFailure) {
+        const queued = this.queuedDirectMessages.get(key);
+        if (queued)
+            return queued;
+        if (this.cursor.processedMessages.includes(key)) {
+            this.removePersistedPendingMessage(key);
+            return Promise.resolve();
+        }
+        const generation = this.lifecycleGeneration;
+        const dispatch = async () => {
+            try {
+                if (!this.connected || generation !== this.lifecycleGeneration)
+                    return;
+                await this.dispatchImMessage(source, message, key);
+            }
+            finally {
+                if (this.queuedDirectMessages.get(key) === task) {
+                    this.queuedDirectMessages.delete(key);
+                }
+            }
+        };
+        let resolveStarted;
+        const started = new Promise((resolve) => {
+            resolveStarted = resolve;
+        });
+        const previous = this.directConversationTails.get(message.conversationId);
+        // 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'
+            ? 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);
+        void task
+            .finally(() => {
+            this.releaseDirectMessageStart(message.conversationId, message.messageId);
+            if (this.directConversationTails.get(message.conversationId) === tail) {
+                this.directConversationTails.delete(message.conversationId);
+            }
+        })
+            .catch(() => undefined);
+        if (reportFailure) {
+            void task.catch((error) => {
+                this.logImError(source, error instanceof Error ? error : new Error(String(error)));
+            });
+        }
+        return task;
+    }
+    async dispatchImMessage(source, message, key) {
         let waitedOnInFlight = false;
         let inFlightError;
         while (true) {
@@ -1158,6 +1274,10 @@ export class DwsChannel extends PollingChannelBase {
         this.processingMessages.set(key, task);
         try {
             await task;
+            if (this.cursor.processedMessages.includes(key) &&
+                this.hasPendingMessage(key)) {
+                this.removePersistedPendingMessage(key);
+            }
         }
         finally {
             if (this.processingMessages.get(key) === task) {
@@ -1214,7 +1334,7 @@ export class DwsChannel extends PollingChannelBase {
                 // 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.
-                this.rememberPendingMessage(source, message);
+                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
@@ -1278,24 +1398,67 @@ export class DwsChannel extends PollingChannelBase {
             return;
         this.cursor.inboundFailures = failures.filter((failure) => failure.key !== key);
     }
-    rememberPendingMessage(source, message) {
+    async rememberPendingMessage(source, message) {
         const key = messageKey(message);
         if (this.hasPendingMessage(key))
-            return;
+            return true;
+        if (!this.connected)
+            return false;
+        if ((this.cursor.pendingMessages?.length ?? 0) >= MAX_PROCESSED_ITEMS) {
+            throw new Error('DWS pending-message capacity is exhausted; retry later.');
+        }
+        if (this.hasPendingMessage(key))
+            return true;
         const pending = this.cursor.pendingMessages ?? [];
-        while (pending.length >= MAX_PROCESSED_ITEMS) {
-            const dropped = pending.shift();
-            if (!dropped)
-                break;
-            this.clearInboundFailure(messageKey(dropped.message));
-            process.stderr.write(`[Channel:${this.name}] dropping the oldest pending DWS message ` +
-                `because the retry queue reached ${MAX_PROCESSED_ITEMS}.\n`);
+        pending.push({ source, message });
+        this.cursor.pendingMessages = pending;
+        try {
+            this.saveCursor();
+        }
+        catch (error) {
+            this.removePendingMessage(key);
+            throw error;
+        }
+        return true;
+    }
+    async rememberFailedMessage(source, message) {
+        const key = messageKey(message);
+        if (this.hasPendingMessage(key))
+            return;
+        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;
+        const pending = this.cursor.pendingMessages ?? [];
         pending.push({ source, message });
         this.cursor.pendingMessages = pending;
+        try {
+            this.saveCursor();
+        }
+        catch {
+            return;
+        }
+    }
+    removePersistedPendingMessage(key) {
+        if (this.removePendingMessage(key))
+            this.saveCursor();
     }
     removePendingMessage(key) {
-        this.cursor.pendingMessages = (this.cursor.pendingMessages ?? []).filter((pending) => messageKey(pending.message) !== key);
+        const pending = this.cursor.pendingMessages ?? [];
+        const remaining = pending.filter((item) => messageKey(item.message) !== key);
+        this.cursor.pendingMessages = remaining;
+        if (remaining.length === pending.length)
+            return false;
+        for (const resolve of this.pendingMessageCapacityWaiters)
+            resolve();
+        this.pendingMessageCapacityWaiters.clear();
+        return true;
     }
     async processDocumentNotification(message, key, notification) {
         const notificationKey = documentNotificationKey(notification);
@@ -1313,17 +1476,19 @@ export class DwsChannel extends PollingChannelBase {
             // only re-drives a parked entry whose own `senderId` passes the gate
             // (the denied one never will), and this key is skipped by every later
             // history poll, so the allowed user's request went unanswered forever.
-            // Mark only when the comment is genuinely done, or when this caller is
-            // no more entitled to it than the sender already parked.
+            // Mark only when the comment is genuinely done, or when this sender's
+            // own request is already parked. Other senders must take the slot next.
             if (this.cursor.processedMessages.includes(notificationKey) ||
-                (this.hasPendingDocumentNotification(notificationKey) &&
+                (this.hasPendingDocumentNotification(notificationKey, message.senderId) &&
                     !this.gate.isAllowed(message.senderId))) {
                 this.markProcessedMessage(key);
+                this.saveCursor();
+                return;
             }
-            else {
-                this.rememberPendingDocumentNotification(message, notification);
+            if (this.processingMessages.get(notificationKey) === inFlight) {
+                this.processingMessages.delete(notificationKey);
             }
-            this.saveCursor();
+            await this.processDocumentNotification(message, key, notification);
             return;
         }
         const task = (async () => {
@@ -1412,8 +1577,25 @@ export class DwsChannel extends PollingChannelBase {
             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);
+                    }
+                })
+                    .catch(() => undefined);
+                continue;
+            }
             try {
-                await this.handleImMessage(pending.source, pending.message, true);
+                await this.receiveImMessage(pending.source, pending.message, true);
                 this.removePendingMessage(key);
                 this.saveCursor();
             }
@@ -1462,8 +1644,9 @@ export class DwsChannel extends PollingChannelBase {
     hasPendingMessage(key) {
         return (this.cursor.pendingMessages ?? []).some((pending) => messageKey(pending.message) === key);
     }
-    hasPendingDocumentNotification(notificationKey) {
-        return (this.cursor.pendingDocumentNotifications ?? []).some((pending) => documentNotificationKey(pending) === notificationKey);
+    hasPendingDocumentNotification(notificationKey, senderId) {
+        return (this.cursor.pendingDocumentNotifications ?? []).some((pending) => documentNotificationKey(pending) === notificationKey &&
+            (senderId === undefined || pending.senderId === senderId));
     }
     rememberPendingDocumentNotification(message, notification) {
         const key = documentNotificationKey(notification);
@@ -1517,6 +1700,14 @@ export class DwsChannel extends PollingChannelBase {
     reactionKey(conversationId, messageId) {
         return `${conversationId}\0${messageId}`;
     }
+    releaseDirectMessageStart(conversationId, messageId) {
+        const key = `${conversationId}\0${messageId}`;
+        const resolve = this.directMessageStartResolvers.get(key);
+        if (!resolve)
+            return;
+        this.directMessageStartResolvers.delete(key);
+        resolve();
+    }
     rememberInboundReactionTarget(chatId, messageId, conversationId = chatId) {
         const key = this.reactionKey(chatId, messageId);
         this.inboundReactionTargets.delete(key);
@@ -1538,6 +1729,52 @@ export class DwsChannel extends PollingChannelBase {
         if (reactions.size === 0)
             this.sessionReactionKeys.delete(sessionId);
     }
+    releaseActiveReaction(key) {
+        const reaction = this.activeReactions.get(key);
+        if (!reaction)
+            return undefined;
+        this.activeReactions.delete(key);
+        this.untrackSessionReaction(reaction.sessionId, key);
+        return reaction;
+    }
+    enqueueReactionOperation(key, operation) {
+        const previous = this.reactionOperations.get(key) ?? Promise.resolve();
+        const next = previous
+            .catch(() => undefined)
+            .then(() => operation(() => this.reactionOperations.get(key) === next))
+            .catch((error) => this.logReactionFailure('reaction transition', error))
+            .finally(() => {
+            if (this.reactionOperations.get(key) === next) {
+                this.reactionOperations.delete(key);
+            }
+        });
+        this.reactionOperations.set(key, next);
+    }
+    rememberEndReaction(key) {
+        this.endReactionKeys.delete(key);
+        this.endReactionKeys.add(key);
+        if (this.endReactionKeys.size > MAX_INBOUND_REACTION_TARGETS) {
+            const oldest = this.endReactionKeys.values().next().value;
+            if (oldest !== undefined)
+                this.endReactionKeys.delete(oldest);
+        }
+    }
+    async removeStartedReaction(reaction, action) {
+        if (!reaction.added)
+            return;
+        try {
+            await this.client.removeImReaction(reaction.target.conversationId, reaction.target.messageId, this.startReactionName);
+        }
+        catch (error) {
+            this.logReactionFailure(action, error);
+        }
+    }
+    cleanupReaction(key, action) {
+        const reaction = this.releaseActiveReaction(key);
+        if (!reaction)
+            return;
+        this.enqueueReactionOperation(key, () => this.removeStartedReaction(reaction, action));
+    }
     startReaction(conversationId, messageId, sessionId) {
         if (!messageId)
             return;
@@ -1545,63 +1782,105 @@ export class DwsChannel extends PollingChannelBase {
         if (!target)
             return;
         const key = this.reactionKey(target.conversationId, target.messageId);
-        if (this.activeReactionKeys.has(key))
+        if (this.activeReactions.has(key))
             return;
-        this.activeReactionKeys.add(key);
         let reactions = this.sessionReactionKeys.get(sessionId);
         if (!reactions) {
-            reactions = new Map();
+            reactions = new Set();
             this.sessionReactionKeys.set(sessionId, reactions);
         }
-        reactions.set(key, target);
-        void this.client
-            .addImReaction(target.conversationId, target.messageId, ACK_REACTION_NAME)
-            .then(() => {
-            if (!this.activeReactionKeys.has(key)) {
-                void this.client
-                    .removeImReaction(target.conversationId, target.messageId, ACK_REACTION_NAME)
-                    .catch((error) => this.logReactionFailure('late reaction removal', error));
+        reactions.add(key);
+        const reaction = {
+            target,
+            sessionId,
+            added: false,
+        };
+        this.activeReactions.set(key, reaction);
+        this.enqueueReactionOperation(key, async () => {
+            if (this.activeReactions.get(key) !== reaction)
+                return;
+            if (this.endReactionName && this.endReactionKeys.has(key)) {
+                try {
+                    await this.client.removeImReaction(target.conversationId, target.messageId, this.endReactionName);
+                    this.endReactionKeys.delete(key);
+                    if (this.endReactionName === this.startReactionName) {
+                        reaction.added = false;
+                    }
+                }
+                catch (error) {
+                    this.logReactionFailure('previous end reaction removal', error);
+                }
+            }
+            if (this.activeReactions.get(key) !== reaction)
+                return;
+            if (reaction.added)
+                return;
+            try {
+                await this.client.addImReaction(target.conversationId, target.messageId, this.startReactionName);
+                reaction.added = true;
+            }
+            catch (error) {
+                this.logReactionFailure('start reaction add', error);
             }
-        })
-            .catch((error) => {
-            this.activeReactionKeys.delete(key);
-            this.untrackSessionReaction(sessionId, key);
-            this.logReactionFailure('reaction add', error);
         });
     }
-    stopReaction(conversationId, messageId, sessionId) {
+    finishReaction(conversationId, messageId, sessionId) {
         if (!messageId)
             return;
         const target = this.inboundReactionTargets.get(this.reactionKey(conversationId, messageId));
         if (!target)
             return;
         const key = this.reactionKey(target.conversationId, target.messageId);
-        this.untrackSessionReaction(sessionId, key);
-        if (!this.activeReactionKeys.delete(key))
+        const active = this.activeReactions.get(key);
+        if (!active || active.sessionId !== sessionId)
             return;
-        void this.client
-            .removeImReaction(target.conversationId, target.messageId, ACK_REACTION_NAME)
-            .catch((error) => this.logReactionFailure('reaction removal', error));
+        const reaction = this.releaseActiveReaction(key);
+        if (!reaction)
+            return;
+        const generation = this.lifecycleGeneration;
+        this.enqueueReactionOperation(key, async (isLatest) => {
+            const replacement = this.activeReactions.get(key);
+            if (replacement) {
+                if (reaction.added)
+                    replacement.added = true;
+                return;
+            }
+            await this.removeStartedReaction(reaction, 'start reaction removal');
+            if (!isLatest() ||
+                this.activeReactions.has(key) ||
+                !this.endReactionName ||
+                this.endReactionKeys.has(key) ||
+                !this.connected ||
+                generation !== this.lifecycleGeneration) {
+                return;
+            }
+            try {
+                await this.client.addImReaction(reaction.target.conversationId, reaction.target.messageId, this.endReactionName);
+                this.rememberEndReaction(key);
+            }
+            catch (error) {
+                this.logReactionFailure('end reaction add', error);
+            }
+        });
     }
     onTaskLifecycle(event) {
         if (event.type === 'started') {
+            if (event.messageId) {
+                this.releaseDirectMessageStart(event.chatId, event.messageId);
+            }
             this.startReaction(event.chatId, event.messageId, event.sessionId);
             return;
         }
         if (isTerminalTaskLifecycleType(event.type)) {
-            this.stopReaction(event.chatId, event.messageId, event.sessionId);
+            this.finishReaction(event.chatId, event.messageId, event.sessionId);
         }
     }
     onSessionDied(sessionId) {
         const reactions = this.sessionReactionKeys.get(sessionId);
         if (reactions) {
             this.sessionReactionKeys.delete(sessionId);
-            for (const [key, { messageId, conversationId }] of reactions) {
-                if (!this.activeReactionKeys.delete(key))
-                    continue;
-                void this.client
-                    .removeImReaction(conversationId, messageId, ACK_REACTION_NAME)
-                    .catch((error) => this.logReactionFailure('session-death reaction removal', error));
+            for (const key of reactions) {
+                this.cleanupReaction(key, 'session-death reaction removal');
             }
         }
         super.onSessionDied(sessionId);