@qwen-code/qwen-code 0.22.3-nightly.20260831.3a0c4c6108 → 0.23.0

package/chunks/{dist-SDKHGH5O.js → dist-PDGNRVPY.js}

@@ -3,14 +3,14 @@
 import {
   require_axios,
   require_ws
-} from "./chunk-AVNATYLY.js";
-import "./chunk-XIQ5HQ2F.js";
+} from "./chunk-JJKNYRFY.js";
+import "./chunk-OBTWL6ZW.js";
 import "./chunk-K6KS3LTN.js";
-import "./chunk-7E7UCJHS.js";
+import "./chunk-OSHQMOBS.js";
 import {
   ChannelBase,
   sanitizeLogText
-} from "./chunk-IXEZHTDR.js";
+} from "./chunk-U4DJ5XB3.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";

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

@@ -5,7 +5,7 @@ import {
   isTerminalTaskLifecycleType,
   sanitizeLogText,
   truncateCodePoints
-} from "./chunk-IXEZHTDR.js";
+} from "./chunk-U4DJ5XB3.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import {
@@ -765,7 +765,27 @@ var DwsClient = class {
     if (source.kind === "group") {
       args.push("--group", source.conversationId);
     }
-    return this.eventStarter(this.executable, args, async (line) => onMessage(parseDwsImEvent(line)), onError);
+    return this.eventStarter(this.executable, args, (line) => {
+      const message = parseDwsImEvent(line);
+      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)));
+        } catch {
+          return;
+        }
+      }, "reportError");
+      const admissionSucceeded = result.admitted.then(() => true, () => false);
+      void result.completed.catch(async (error) => {
+        if (await admissionSucceeded)
+          reportError(error);
+      });
+      return result.admitted;
+    }, onError);
   }
   async sendImMessage(target, content, idempotencyKey) {
     const targetArgs = target.kind === "group" ? ["--group", target.conversationId] : ["--open-dingtalk-id", target.openDingTalkId];
@@ -1056,6 +1076,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_INBOUND_ATTEMPTS = 5;
 var MAX_IM_TARGETS = 1e3;
 var MAX_TODO_STATES = 1e3;
@@ -1065,7 +1086,7 @@ var EVENT_RESTART_DELAY_MS = 2e3;
 var EVENT_RESTART_MAX_DELAY_MS = 5 * 6e4;
 var NO_REPLY_SENTINEL = "[NO_REPLY]";
 var NO_REPLY_SENTINEL_PATTERN = /^\[NO_REPLY\][.!]?$/i;
-var ACK_REACTION_NAME = "\u6697\u4E2D\u89C2\u5BDF";
+var DEFAULT_START_REACTION = "\u{1F914}";
 var MAX_INBOUND_REACTION_TARGETS = 1e3;
 var NOTIFICATION_HISTORY_OVERLAP_MS = 5e3;
 var NOTIFICATION_POLL_INTERVAL_MS = 5e3;
@@ -1317,12 +1338,23 @@ var DwsChannel = class extends PollingChannelBase {
   userInstructions;
   client;
   imStates;
+  startReactionName;
+  endReactionName;
   watchTodos;
   inboundReactionTargets = /* @__PURE__ */ new Map();
-  activeReactionKeys = /* @__PURE__ */ new Set();
+  activeReactions = /* @__PURE__ */ new Map();
   sessionReactionKeys = /* @__PURE__ */ new Map();
+  reactionOperations = /* @__PURE__ */ new Map();
+  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
+  // live or followup traffic, whose queue entries outlive their turn.
+  replayDirectDispatches = /* @__PURE__ */ new Map();
+  directConversationTails = /* @__PURE__ */ new Map();
+  directMessageStartResolvers = /* @__PURE__ */ new Map();
+  pendingMessageCapacityWaiters = /* @__PURE__ */ new Set();
   pollAbortController = new AbortController();
   lifecycleGeneration = 0;
   connectionStartedAt = 0;
@@ -1331,6 +1363,8 @@ var DwsChannel = class 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.");
@@ -1358,6 +1392,8 @@ var DwsChannel = class extends PollingChannelBase {
       source,
       restartAttempts: 0
     }));
+    this.startReactionName = startReactionName;
+    this.endReactionName = endReactionName;
     this.watchTodos = watchTodos;
   }
   createInitialCursor() {
@@ -1497,15 +1533,19 @@ var DwsChannel = class 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)
@@ -1702,7 +1742,7 @@ Ask the bot operator to approve you with:
       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 = {
@@ -1737,15 +1777,10 @@ Ask the bot operator to approve you with:
         }
         if (this.hasPendingMessage(key))
           continue;
-        try {
-          await this.handleImMessage({ kind: "direct" }, message, true);
-        } catch (error) {
-          if (!this.hasPendingMessage(key))
-            throw error;
-          process2.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)}
-`);
-        }
+        await this.receiveDirectMessage(message, true).admitted;
       }
+      if (signal.aborted || !this.connected)
+        return;
       if (this.notificationWatermarkPulledBack) {
         this.cursor.notificationCheckpoint = void 0;
       } else if (page.nextCursor) {
@@ -1892,7 +1927,7 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
     const subscription = await this.client.subscribeToIm(state.source, (message) => {
       state.lastError = void 0;
       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;
@@ -1982,35 +2017,120 @@ ${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 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 !== void 0) {
       this.markProcessedMessage(messageKey(message));
       this.saveCursor();
       return;
     }
-    if (!fromHistory && message.eventTime !== void 0 && message.eventTime < this.connectionStartedAt - 5e3) {
-      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(() => void 0);
+    return {
+      admitted: admission.then(() => void 0),
+      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 !== 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)}
 `);
       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 !== void 0 && message.eventTime < this.connectionStartedAt - 5e3;
+  }
+  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 = /* @__PURE__ */ __name(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);
+        }
+      }
+    }, "dispatch");
+    let resolveStarted;
+    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 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);
+    void task.finally(() => {
+      this.releaseDirectMessageStart(message.conversationId, message.messageId);
+      if (this.directConversationTails.get(message.conversationId) === tail) {
+        this.directConversationTails.delete(message.conversationId);
+      }
+    }).catch(() => void 0);
+    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) {
@@ -2028,6 +2148,9 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
     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) {
         this.processingMessages.delete(key);
@@ -2072,7 +2195,7 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
       await this.handleInbound(envelope);
     } catch (error) {
       if (source.kind !== "at") {
-        this.rememberPendingMessage(source, message);
+        await this.rememberFailedMessage(source, message);
       }
       if (this.recordInboundFailure(key, error, () => {
         this.markProcessedMessage(key);
@@ -2128,24 +2251,63 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
       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));
-      process2.stderr.write(`[Channel:${this.name}] dropping the oldest pending DWS message because the retry queue reached ${MAX_PROCESSED_ITEMS}.
-`);
+    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);
@@ -2157,12 +2319,15 @@ ${truncateCodePoints(JSON.stringify(detail.data), MAX_TODO_CONTEXT_CHARS)}`
     const inFlight = this.processingMessages.get(notificationKey);
     if (inFlight) {
       await inFlight;
-      if (this.cursor.processedMessages.includes(notificationKey) || this.hasPendingDocumentNotification(notificationKey) && !this.gate.isAllowed(message.senderId)) {
+      if (this.cursor.processedMessages.includes(notificationKey) || this.hasPendingDocumentNotification(notificationKey, message.senderId) && !this.gate.isAllowed(message.senderId)) {
         this.markProcessedMessage(key);
-      } else {
-        this.rememberPendingDocumentNotification(message, notification);
+        this.saveCursor();
+        return;
       }
-      this.saveCursor();
+      if (this.processingMessages.get(notificationKey) === inFlight) {
+        this.processingMessages.delete(notificationKey);
+      }
+      await this.processDocumentNotification(message, key, notification);
       return;
     }
     const task = (async () => {
@@ -2237,8 +2402,23 @@ ${context}` : "Document Markdown was unavailable; answer from the comment only."
       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(() => void 0);
+        continue;
+      }
       try {
-        await this.handleImMessage(pending.source, pending.message, true);
+        await this.receiveImMessage(pending.source, pending.message, true);
         this.removePendingMessage(key);
         this.saveCursor();
       } catch (error) {
@@ -2287,8 +2467,8 @@ ${context}` : "Document Markdown was unavailable; answer from the comment only."
   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 === void 0 || pending.senderId === senderId));
   }
   rememberPendingDocumentNotification(message, notification) {
     const key = documentNotificationKey(notification);
@@ -2330,6 +2510,14 @@ ${context}` : "Document Markdown was unavailable; answer from the comment only."
   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);
@@ -2352,6 +2540,47 @@ ${context}` : "Document Markdown was unavailable; answer from the comment only."
     if (reactions.size === 0)
       this.sessionReactionKeys.delete(sessionId);
   }
+  releaseActiveReaction(key) {
+    const reaction = this.activeReactions.get(key);
+    if (!reaction)
+      return void 0;
+    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(() => void 0).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 !== void 0)
+        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;
@@ -2359,54 +2588,97 @@ ${context}` : "Document Markdown was unavailable; answer from the comment only."
     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 = /* @__PURE__ */ new Map();
+      reactions = /* @__PURE__ */ 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;
+    const reaction = this.releaseActiveReaction(key);
+    if (!reaction)
       return;
-    void this.client.removeImReaction(target.conversationId, target.messageId, ACK_REACTION_NAME).catch((error) => this.logReactionFailure("reaction removal", error));
+    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);
@@ -2503,6 +2775,19 @@ var plugin = {
         label: "Watch Native Todos",
         kind: "boolean",
         description: "Poll pending todos assigned to this DWS account and run newly assigned or changed tasks"
+      },
+      {
+        key: "startReaction",
+        label: "Start Reaction",
+        kind: "string",
+        default: DEFAULT_START_REACTION,
+        description: `DingTalk reaction emoji or name added while a task is running. Leave empty to use ${DEFAULT_START_REACTION}`
+      },
+      {
+        key: "endReaction",
+        label: "End Reaction",
+        kind: "string",
+        description: "DingTalk reaction emoji or name added after a task ends. Leave empty to disable it"
       }
     ],
     validateConfig: /* @__PURE__ */ __name((config) => {
@@ -2515,6 +2800,11 @@ var plugin = {
       if (config["watchTodos"] !== void 0 && typeof config["watchTodos"] !== "boolean") {
         return "DWS watchTodos must be a boolean.";
       }
+      for (const field of ["startReaction", "endReaction"]) {
+        if (config[field] !== void 0 && typeof config[field] !== "string") {
+          return `DWS ${field} must be a string.`;
+        }
+      }
       return void 0;
     }, "validateConfig")
   },

package/chunks/{dist-WIVVPE7M.js → dist-ZCJLKQSP.js}

@@ -8,7 +8,7 @@ import {
   sanitizeLogText,
   sanitizePromptText,
   truncateCodePoints
-} from "./chunk-IXEZHTDR.js";
+} from "./chunk-U4DJ5XB3.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import {