@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.1

package/chunks/{dist-P6YWBITG.js → dist-STAGIFNB.js}

@@ -14,7 +14,7 @@ import {
   sanitizePromptText,
   sanitizeSenderName,
   truncateUtf16Units
-} from "./chunk-65GHQ4FX.js";
+} from "./chunk-XVTCSVBK.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";
@@ -6933,6 +6933,95 @@ __name(parseDingtalkCardActorId, "parseDingtalkCardActorId");
 // packages/channels/dingtalk/dist/status-card-controller.js
 init_esbuild_shims();
 import { randomUUID as randomUUID2 } from "node:crypto";
+
+// packages/channels/dingtalk/dist/presentation-phase.js
+init_esbuild_shims();
+var DINGTALK_PRESENTATION_PHASE_LABELS = {
+  thinking: "\u{1F914} Thinking",
+  reading: "\u{1F4D6} Reading",
+  searching: "\u{1F50E} Searching",
+  running: "\u{1F5A5}\uFE0F Running",
+  editing: "\u{1F6E0}\uFE0F Editing",
+  deleting: "\u{1F5D1}\uFE0F Deleting",
+  moving: "\u{1F4E6} Moving",
+  fetching: "\u{1F310} Fetching",
+  switching: "\u{1F504} Switching mode",
+  working: "\u{1F6E0}\uFE0F Working",
+  failed: "\u26A0\uFE0F Tool failed",
+  replying: "\u270D\uFE0F Replying"
+};
+var DINGTALK_ZH_PRESENTATION_PHASE_LABELS = {
+  thinking: "\u{1F914} \u601D\u8003\u4E2D",
+  reading: "\u{1F4D6} \u8BFB\u53D6\u4E2D",
+  searching: "\u{1F50E} \u641C\u7D22\u4E2D",
+  running: "\u{1F5A5}\uFE0F \u6267\u884C\u4E2D",
+  editing: "\u{1F6E0}\uFE0F \u7F16\u8F91\u4E2D",
+  deleting: "\u{1F5D1}\uFE0F \u5220\u9664\u4E2D",
+  moving: "\u{1F4E6} \u79FB\u52A8\u4E2D",
+  fetching: "\u{1F310} \u83B7\u53D6\u4E2D",
+  switching: "\u{1F504} \u5207\u6362\u6A21\u5F0F\u4E2D",
+  working: "\u{1F6E0}\uFE0F \u5904\u7406\u4E2D",
+  failed: "\u26A0\uFE0F \u5DE5\u5177\u5931\u8D25",
+  replying: "\u270D\uFE0F \u56DE\u590D\u4E2D"
+};
+function isChinesePresentationLanguage(language) {
+  const normalized = language?.trim().toLowerCase().replaceAll("_", "-");
+  return normalized === "zh" || normalized === "zh-cn";
+}
+__name(isChinesePresentationLanguage, "isChinesePresentationLanguage");
+function presentationPhaseLabel(phase, language) {
+  return (isChinesePresentationLanguage(language) ? DINGTALK_ZH_PRESENTATION_PHASE_LABELS : DINGTALK_PRESENTATION_PHASE_LABELS)[phase];
+}
+__name(presentationPhaseLabel, "presentationPhaseLabel");
+function toolPresentationPhase(kind) {
+  switch (kind.trim().toLowerCase()) {
+    case "read":
+      return "reading";
+    case "edit":
+      return "editing";
+    case "delete":
+      return "deleting";
+    case "move":
+      return "moving";
+    case "search":
+      return "searching";
+    case "execute":
+      return "running";
+    case "think":
+      return "thinking";
+    case "fetch":
+      return "fetching";
+    case "switch_mode":
+      return "switching";
+    case "other":
+      return "working";
+    default:
+      if (/read/iu.test(kind))
+        return "reading";
+      if (/search|browser|web/iu.test(kind))
+        return "searching";
+      if (/shell|exec|command|run/iu.test(kind))
+        return "running";
+      if (/edit|write|patch/iu.test(kind))
+        return "editing";
+      return "working";
+  }
+}
+__name(toolPresentationPhase, "toolPresentationPhase");
+function lifecyclePresentationPhase(event) {
+  if (event.type === "text_chunk")
+    return "replying";
+  if (event.type !== "tool_call")
+    return void 0;
+  if (/fail|error/iu.test(event.toolCall.status))
+    return "failed";
+  if (/complete|success/iu.test(event.toolCall.status))
+    return "thinking";
+  return toolPresentationPhase(event.toolCall.kind);
+}
+__name(lifecyclePresentationPhase, "lifecyclePresentationPhase");
+
+// packages/channels/dingtalk/dist/status-card-controller.js
 var FLUSH_INTERVAL_MS = 500;
 var STATUS_REFRESH_INTERVAL_MS = 1e3;
 var CONTENT_SYNC_INTERVAL_SECONDS = 5;
@@ -6948,6 +7037,23 @@ function boundContent(content) {
   return `${TRUNCATION_MARKER}${content.slice(content.length - (CONTENT_LIMIT - TRUNCATION_MARKER.length))}`;
 }
 __name(boundContent, "boundContent");
+function activeContent(phase, content, language, sourcePrefix) {
+  const label = presentationPhaseLabel(phase, language);
+  const sanitized = sanitizeStreamingImageMarkers(content);
+  const renderedSourcePrefix = sourcePrefix && (sanitized === sourcePrefix || sanitized.startsWith(`${sourcePrefix}
+
+`)) ? sourcePrefix : void 0;
+  const body = renderedSourcePrefix ? sanitized.slice(renderedSourcePrefix.length + (sanitized.length === renderedSourcePrefix.length ? 0 : 2)) : sanitized;
+  const prefix = [label, renderedSourcePrefix].filter(Boolean).join("\n\n");
+  if (!body)
+    return prefix;
+  const separator = "\n\n";
+  const available = CONTENT_LIMIT - prefix.length - separator.length;
+  if (body.length <= available)
+    return `${prefix}${separator}${body}`;
+  return `${prefix}${separator}${TRUNCATION_MARKER}${body.slice(body.length - (available - TRUNCATION_MARKER.length))}`;
+}
+__name(activeContent, "activeContent");
 var StatusCardController = class {
   static {
     __name(this, "StatusCardController");
@@ -7080,6 +7186,8 @@ var StatusCardController = class {
       target,
       outTrackId,
       content: boundContent(initialContent),
+      ...segment.sourceLabel ? { sourcePrefix: escapeDingTalkMarkdown(segment.sourceLabel) } : {},
+      phase: "thinking",
       startedAt: Date.now(),
       lastStatusSecond: 0,
       lastContentSyncSecond: 0,
@@ -7114,6 +7222,20 @@ var StatusCardController = class {
   complete(segmentId, text, retainedContent) {
     return this.finalize(segmentId, boundContent(text), "Completed", false, retainedContent);
   }
+  updateRunPhase(runId, phase) {
+    if (this.disposed)
+      return;
+    for (const segmentId of this.segmentIdsByRun.get(runId) ?? []) {
+      const record = this.recordsBySegment.get(segmentId);
+      if (!record || record.terminal || record.streamFailed || record.phase === phase) {
+        continue;
+      }
+      record.phase = phase;
+      record.contentVersion++;
+      record.hasPendingWrite = true;
+      this.scheduleFlush(record);
+    }
+  }
   fail(segmentId, error) {
     void this.finalize(segmentId, boundContent(error), "Failed", true);
   }
@@ -7169,9 +7291,9 @@ var StatusCardController = class {
           outTrackId: record.outTrackId,
           target,
           cardParamMap: {
-            content: sanitizeStreamingImageMarkers(record.content),
+            content: activeContent(record.phase, record.content, this.options.language, record.sourcePrefix),
             flowStatus: 2,
-            statusLine: this.statusLine(record, "Running").text,
+            statusLine: this.statusLine(record).text,
             hasAction: "true",
             stop_action: "true"
           }
@@ -7196,7 +7318,7 @@ var StatusCardController = class {
       await this.options.client.openOrUpdateStream({
         outTrackId: record.outTrackId,
         key: "content",
-        content: sanitizeStreamingImageMarkers(record.content),
+        content: activeContent(record.phase, record.content, this.options.language, record.sourcePrefix),
         finalize: false
       });
     } catch (error) {
@@ -7245,7 +7367,7 @@ var StatusCardController = class {
       await this.options.client.openOrUpdateStream({
         outTrackId: record.outTrackId,
         key: "content",
-        content: sanitizeStreamingImageMarkers(record.content),
+        content: activeContent(record.phase, record.content, this.options.language, record.sourcePrefix),
         finalize: false
       });
       contentWritten = true;
@@ -7448,14 +7570,28 @@ var StatusCardController = class {
     const second = Math.max(0, Math.floor((Date.now() - record.startedAt) / 1e3));
     const model = this.options.model?.trim();
     return {
-      text: [state, model, `${second}s`].filter(Boolean).join(" \xB7 "),
+      text: [
+        state ? this.statusStateLabel(state) : void 0,
+        model,
+        `${second}s`
+      ].filter(Boolean).join(" \xB7 "),
       second
     };
   }
+  statusStateLabel(state) {
+    if (!isChinesePresentationLanguage(this.options.language))
+      return state;
+    return {
+      Completed: "\u5DF2\u5B8C\u6210",
+      Failed: "\u5DF2\u5931\u8D25",
+      Stopped: "\u5DF2\u7EC8\u6B62",
+      Cancelled: "\u5DF2\u53D6\u6D88"
+    }[state] ?? state;
+  }
   async updateRunningStatus(record) {
     if (this.disposed || record.terminal || record.streamFailed)
       return;
-    const status = this.statusLine(record, "Running");
+    const status = this.statusLine(record);
     if (status.second === record.lastStatusSecond)
       return;
     const syncContent = status.second - record.lastContentSyncSecond >= CONTENT_SYNC_INTERVAL_SECONDS;
@@ -7463,7 +7599,9 @@ var StatusCardController = class {
       await this.options.client.updateInstance({
         outTrackId: record.outTrackId,
         cardParamMap: {
-          ...syncContent ? { content: sanitizeStreamingImageMarkers(record.content) } : {},
+          ...syncContent ? {
+            content: activeContent(record.phase, record.content, this.options.language, record.sourcePrefix)
+          } : {},
           statusLine: status.text
         }
       });
@@ -7905,6 +8043,12 @@ var DingtalkInteractionPresenter = class {
       statusCards?.replace(statusContext, target, this.withSourcePrefix(run, ""));
     });
   }
+  updateStatusCardPhase(runId, phase) {
+    const run = this.runs.get(runId);
+    if (!run || run.terminal)
+      return;
+    void this.enqueue(run, () => this.options.statusCards?.updateRunPhase(runId, phase));
+  }
   appendOutput(segment, chunk) {
     const run = this.runs.get(segment.runId);
     if (!run || run.terminal || run.ownerId !== segment.owner.id || run.target.chatId !== segment.target.chatId || run.target.isGroup !== segment.target.isGroup || !chunk || this.terminalSegmentIds.has(segment.segmentId)) {
@@ -8005,6 +8149,20 @@ var DingtalkInteractionPresenter = class {
       return Promise.resolve({ kind: "unsupported" });
     return questionCards.present(context, this.cardTarget(context.target));
   }
+  terminalCopy() {
+    if (this.options.language !== void 0 && !isChinesePresentationLanguage(this.options.language)) {
+      return {
+        failed: "Processing failed, please try again later.",
+        stopped: "Task stopped",
+        cancelled: "Task cancelled"
+      };
+    }
+    return {
+      failed: "\u672C\u6B21\u5904\u7406\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002",
+      stopped: "\u4EFB\u52A1\u5DF2\u505C\u6B62",
+      cancelled: "\u4EFB\u52A1\u5DF2\u53D6\u6D88"
+    };
+  }
   terminalizeRun(runId, terminal, detail = "") {
     const run = this.runs.get(runId);
     if (!run || run.terminal)
@@ -8017,16 +8175,17 @@ var DingtalkInteractionPresenter = class {
       this.segments.delete(activeSegmentId);
       this.addTerminalSegment(activeSegmentId);
     }
+    const copy = this.terminalCopy();
     const finalization = this.enqueue(run, async () => {
       if (terminal === "failed") {
         const statusContext = this.ensureStatusContext(run);
         this.options.statusCards?.ensure(statusContext, this.cardTarget(statusContext.target));
-        this.options.statusCards?.fail(statusContext.segmentId, this.withSenderPrefix(run, "\u672C\u6B21\u5904\u7406\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002"));
+        this.options.statusCards?.fail(statusContext.segmentId, this.withSenderPrefix(run, copy.failed));
         await this.redeliverCardDeliveredContent(run);
       } else if (terminal === "cancelled") {
         const statusContext = run.statusContext;
         if (statusContext) {
-          this.options.statusCards?.replace(statusContext, this.cardTarget(statusContext.target), this.withSenderPrefix(run, detail === "cancel_command" ? "\u4EFB\u52A1\u5DF2\u505C\u6B62" : "\u4EFB\u52A1\u5DF2\u53D6\u6D88"));
+          this.options.statusCards?.replace(statusContext, this.cardTarget(statusContext.target), this.withSenderPrefix(run, detail === "cancel_command" ? copy.stopped : copy.cancelled));
         }
         this.options.statusCards?.cancelRun(runId, detail === "cancel_command" ? "cancel_command" : "dropped");
         await this.redeliverCardDeliveredContent(run);
@@ -8388,9 +8547,15 @@ var BACKGROUND_RESPONSE_AGGREGATION_MAX_RETRIES = 3;
 var ACK_REACTION_NAME = "\u{1F440}";
 var ACK_EMOTION_ID = "2659900";
 var ACK_EMOTION_BG_ID = "im_bg_1";
+var STATUS_EMOTION_ID = "34019";
+var STATUS_EMOTION_BG_ID = "im_bg_6";
+var DONE_EMOTION_ID = "54054";
+var DONE_EMOTION_BG_ID = "im_bg_5";
 var EMOTION_API = "https://api.dingtalk.com/v1.0/robot/emotion";
 var EMOTION_MAX_ATTEMPTS = 3;
 var EMOTION_RETRY_BASE_DELAY_MS = 250;
+var EMOTION_FETCH_TIMEOUT_MS = 15e3;
+var EMOTION_FINISH_MAX_ATTEMPTS = 3;
 var GROUP_MSG_API = "https://api.dingtalk.com/v1.0/robot/groupMessages/send";
 var DIRECT_MSG_API = "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend";
 var PROACTIVE_MSG_KEY = "sampleMarkdown";
@@ -8518,6 +8683,26 @@ var FILE_INSTRUCTIONS = [
   "File paths containing ] are not supported.",
   "Do not claim delivery succeeded; DingTalk shows successful files separately and reports failures in the final text."
 ].join("\n");
+function statusEmotionTag(name) {
+  return {
+    name,
+    emotionId: STATUS_EMOTION_ID,
+    backgroundId: STATUS_EMOTION_BG_ID
+  };
+}
+__name(statusEmotionTag, "statusEmotionTag");
+var EYE_TAG = {
+  name: ACK_REACTION_NAME,
+  emotionId: ACK_EMOTION_ID,
+  backgroundId: ACK_EMOTION_BG_ID
+};
+var DONE_TAG = {
+  name: "\u2705 Done",
+  emotionId: DONE_EMOTION_ID,
+  backgroundId: DONE_EMOTION_BG_ID
+};
+var FAILED_TAG = statusEmotionTag("\u274C Failed");
+var STOPPED_TAG = statusEmotionTag("\u23F9\uFE0F Stopped");
 function collectNonBotMentionIds(data) {
   if (!Array.isArray(data.atUsers) || typeof data.chatbotUserId !== "string") {
     return [];
@@ -8585,6 +8770,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   }
   client;
   atSender;
+  displayLanguage;
   connectionManager;
   seenMessages = /* @__PURE__ */ new Map();
   mentionTargets = /* @__PURE__ */ new Map();
@@ -8595,8 +8781,11 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   /** Map conversationId → latest sessionWebhook URL for sending replies. */
   webhooks = /* @__PURE__ */ new Map();
   activeReactionKeys = /* @__PURE__ */ new Set();
+  reactionStates = /* @__PURE__ */ new Map();
   /** sessionId → reaction keys, so a dead session's reactions can be recalled. */
   sessionReactionKeys = /* @__PURE__ */ new Map();
+  /** Settles when the reaction cleanup queued by disconnect() has run. */
+  disconnectDrain;
   /**
    * Real inbound message ids (insertion-ordered, size-capped). Unlike the
    * TTL-swept seenMessages dedup map, entries survive long queue waits, so a
@@ -8636,6 +8825,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   constructor(name, config, bridge, options) {
     super(name, config, bridge, options);
     this.atSender = config["atSender"] === true;
+    this.displayLanguage = options?.displayLanguage;
     if (!this.config.instructions) {
       this.config.instructions = [
         "## DingTalk Channel",
@@ -8679,6 +8869,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
           client: this.interactiveCardClient,
           cancelRun: /* @__PURE__ */ __name((sessionId, runId) => this.requestPromptRunCancellation(sessionId, runId), "cancelRun"),
           ...config.model ? { model: config.model } : {},
+          ...options?.displayLanguage ? { language: options.displayLanguage } : {},
           onError: /* @__PURE__ */ __name((operation, error) => {
             process.stderr.write(`[DingTalk:${this.name}] ${operation} failed: ${sanitizeLogText(String(error), 300)}
 `);
@@ -8701,6 +8892,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         this.interactionPresenter = new DingtalkInteractionPresenter({
           statusCards: this.statusCardController,
           questionCards: this.questionCardController,
+          ...options?.displayLanguage ? { language: options.displayLanguage } : {},
           ...config.blockStreaming !== "on" ? {
             sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId, sourceLabel) => this.sendFallbackReply(chatId, text, sessionId, sourceLabel), "sendFallback")
           } : {}
@@ -9351,14 +9543,14 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   getAccessToken() {
     return this.client.getConfig().access_token;
   }
-  async emotionApi(endpoint, msgId, conversationId) {
+  async emotionApi(endpoint, msgId, conversationId, tag) {
     const robotCode = this.config.clientId;
     if (!robotCode || !msgId || !conversationId)
-      return;
+      return false;
     try {
       const token = this.config.clientSecret ? await this.getProactiveToken() : this.getAccessToken();
       if (!token)
-        return;
+        return false;
       for (let attempt = 0; attempt < EMOTION_MAX_ATTEMPTS; attempt++) {
         const resp = await fetch(`${EMOTION_API}/${endpoint}`, {
           method: "POST",
@@ -9371,17 +9563,18 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
             openMsgId: msgId,
             openConversationId: conversationId,
             emotionType: 2,
-            emotionName: ACK_REACTION_NAME,
+            emotionName: tag.name,
             textEmotion: {
-              emotionId: ACK_EMOTION_ID,
-              emotionName: ACK_REACTION_NAME,
-              text: ACK_REACTION_NAME,
-              backgroundId: ACK_EMOTION_BG_ID
+              emotionId: tag.emotionId,
+              emotionName: tag.name,
+              text: tag.name,
+              backgroundId: tag.backgroundId
             }
-          })
+          }),
+          signal: AbortSignal.timeout(EMOTION_FETCH_TIMEOUT_MS)
         });
         if (resp.ok)
-          return;
+          return true;
         const isTransient = resp.status === 429 || resp.status >= 500;
         if (isTransient && attempt < EMOTION_MAX_ATTEMPTS - 1) {
           await resp.body?.cancel();
@@ -9391,25 +9584,31 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         const detail = sanitizeLogText(await resp.text().catch(() => ""), 500);
         process.stderr.write(`[DingTalk:${this.name}] emotion/${endpoint} failed after ${attempt + 1}/${EMOTION_MAX_ATTEMPTS} attempts: ${resp.status} ${detail}
 `);
-        return;
+        return false;
       }
     } catch {
     }
+    return false;
   }
-  async attachReaction(msgId, conversationId) {
-    await this.emotionApi("reply", msgId, conversationId);
+  async attachReaction(msgId, conversationId, tag = EYE_TAG) {
+    return this.emotionApi("reply", msgId, conversationId, tag);
   }
-  async recallReaction(msgId, conversationId) {
-    await this.emotionApi("recall", msgId, conversationId);
+  async recallReaction(msgId, conversationId, tag = EYE_TAG) {
+    return this.emotionApi("recall", msgId, conversationId, tag);
   }
   disconnect() {
     if (this.dedupTimer) {
       clearInterval(this.dedupTimer);
     }
+    const reactionStates = [...this.reactionStates.values()];
+    for (const state of reactionStates) {
+      this.finishReaction(state.chatId, state.messageId, state.sessionId);
+    }
     this.statusCardController?.dispose();
     this.drainBackgroundResponseAggregations();
     this.activeReactionKeys.clear();
     this.sessionReactionKeys.clear();
+    this.reactionStates.clear();
     if (this.connectionManager) {
       this.connectionManager.stop();
     } else {
@@ -9417,6 +9616,10 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
     process.stderr.write(`[DingTalk:${this.name}] Disconnected.
 `);
+    this.disconnectDrain = Promise.allSettled(reactionStates.map((state) => state.tail)).then(() => void 0);
+  }
+  waitForDisconnect() {
+    return this.disconnectDrain ?? Promise.resolve();
   }
   /** Stable API targets are conversation or user IDs, never webhook URLs. */
   isStableTargetId(chatId) {
@@ -9425,6 +9628,111 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   reactionKey(messageId, conversationId) {
     return `${conversationId}:${messageId}`;
   }
+  forgetReactionState(state) {
+    this.activeReactionKeys.delete(state.key);
+    if (this.reactionStates.get(state.key) === state) {
+      this.reactionStates.delete(state.key);
+    }
+    if (!state.sessionId)
+      return;
+    const keys = this.sessionReactionKeys.get(state.sessionId);
+    keys?.delete(state.key);
+    if (keys?.size === 0)
+      this.sessionReactionKeys.delete(state.sessionId);
+  }
+  enqueueReaction(state, operation) {
+    state.tail = state.tail.then(operation).catch((err) => {
+      this.logReactionFailure("lifecycle tag update", err);
+    });
+  }
+  scheduleReactionDrain(state) {
+    if (state.drainScheduled)
+      return;
+    state.drainScheduled = true;
+    this.enqueueReaction(state, async () => {
+      try {
+        await this.drainReactionState(state);
+      } finally {
+        state.drainScheduled = false;
+        if (this.reactionStates.get(state.key) === state && (state.finishing ? !state.finishBlocked : this.activeReactionKeys.has(state.key) && state.desiredStatusTag && state.desiredStatusTag.name !== state.statusTag?.name)) {
+          this.scheduleReactionDrain(state);
+        }
+      }
+    });
+  }
+  async drainReactionState(state) {
+    while (true) {
+      if (state.finishing) {
+        await this.finishReactionState(state);
+        return;
+      }
+      if (this.reactionStates.get(state.key) !== state || !this.activeReactionKeys.has(state.key)) {
+        return;
+      }
+      const desired = state.desiredStatusTag;
+      if (!desired || desired.name === state.statusTag?.name)
+        return;
+      const latched = state.failedTransition;
+      if (state.statusTag) {
+        const from = state.statusTag.name;
+        if (latched && latched.from === from && latched.to === desired.name) {
+          state.desiredStatusTag = state.statusTag;
+          return;
+        }
+        const revision2 = state.revision;
+        if (await this.recallReaction(state.messageId, state.chatId, state.statusTag) === false) {
+          state.failedTransition = { from, to: desired.name };
+          if (state.revision !== revision2)
+            continue;
+          state.desiredStatusTag = state.statusTag;
+          return;
+        }
+        state.failedTransition = void 0;
+        state.statusTag = void 0;
+        continue;
+      }
+      if (latched && latched.from === void 0 && latched.to === desired.name) {
+        state.desiredStatusTag = void 0;
+        return;
+      }
+      const revision = state.revision;
+      if (await this.attachReaction(state.messageId, state.chatId, desired) === false) {
+        state.failedTransition = { from: void 0, to: desired.name };
+        if (state.revision !== revision)
+          continue;
+        state.desiredStatusTag = void 0;
+        return;
+      }
+      state.failedTransition = void 0;
+      state.statusTag = desired;
+    }
+  }
+  async finishReactionState(state) {
+    let statusCleared = true;
+    if (state.statusTag) {
+      statusCleared = await this.recallReaction(state.messageId, state.chatId, state.statusTag) !== false;
+      if (statusCleared)
+        state.statusTag = void 0;
+    }
+    const eyeCleared = !state.eyeAttached || await this.recallReaction(state.messageId, state.chatId, EYE_TAG) !== false;
+    if (eyeCleared)
+      state.eyeAttached = false;
+    let terminalAttached = true;
+    if (state.terminalTag && statusCleared && eyeCleared) {
+      terminalAttached = await this.attachReaction(state.messageId, state.chatId, state.terminalTag) !== false;
+    }
+    if (!statusCleared || !eyeCleared || !terminalAttached) {
+      state.finishAttempts = (state.finishAttempts ?? 0) + 1;
+      if (state.finishAttempts >= EMOTION_FINISH_MAX_ATTEMPTS) {
+        this.logReactionFailure("reaction cleanup", `abandoned after ${state.finishAttempts} attempts`);
+        this.forgetReactionState(state);
+        return;
+      }
+      state.finishBlocked = true;
+      return;
+    }
+    this.forgetReactionState(state);
+  }
   rememberInboundMessageId(msgId) {
     this.inboundMessageIds.delete(msgId);
     this.inboundMessageIds.add(msgId);
@@ -9447,6 +9755,19 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     if (this.activeReactionKeys.has(key))
       return;
     this.activeReactionKeys.add(key);
+    const state = {
+      key,
+      messageId,
+      chatId,
+      ...sessionId ? { sessionId } : {},
+      desiredStatusTag: this.phaseReactionTag("thinking"),
+      finishing: false,
+      drainScheduled: false,
+      eyeAttached: false,
+      revision: 0,
+      tail: Promise.resolve()
+    };
+    this.reactionStates.set(key, state);
     if (sessionId) {
       let keys = this.sessionReactionKeys.get(sessionId);
       if (!keys) {
@@ -9455,34 +9776,68 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       }
       keys.set(key, { messageId, chatId });
     }
-    this.attachReaction(messageId, chatId).then(() => {
-      if (!this.activeReactionKeys.has(key)) {
-        void this.recallReaction(messageId, chatId).catch((err) => {
-          this.logReactionFailure("late reaction recall", err);
-        });
+    this.enqueueReaction(state, async () => {
+      try {
+        if (await this.attachReaction(messageId, chatId, EYE_TAG) === false) {
+          this.forgetReactionState(state);
+          return;
+        }
+        state.eyeAttached = true;
+        this.scheduleReactionDrain(state);
+      } catch (err) {
+        this.forgetReactionState(state);
+        this.logReactionFailure("reaction attach", err);
       }
-    }).catch((err) => {
-      this.activeReactionKeys.delete(key);
-      this.logReactionFailure("reaction attach", err);
     });
   }
-  stopReaction(chatId, messageId, sessionId) {
+  replaceStatusReaction(chatId, messageId, tag) {
+    if (!messageId)
+      return;
+    const state = this.reactionStates.get(this.reactionKey(messageId, chatId));
+    if (!state || !this.activeReactionKeys.has(state.key))
+      return;
+    state.desiredStatusTag = tag;
+    state.revision++;
+    this.scheduleReactionDrain(state);
+  }
+  phaseReactionTag(phase) {
+    return statusEmotionTag(presentationPhaseLabel(phase, this.displayLanguage));
+  }
+  terminalReactionTag(type) {
+    if (!isChinesePresentationLanguage(this.displayLanguage)) {
+      return type === "completed" ? DONE_TAG : type === "failed" ? FAILED_TAG : STOPPED_TAG;
+    }
+    if (type === "completed") {
+      return { ...DONE_TAG, name: "\u2705 \u5DF2\u5B8C\u6210" };
+    }
+    return statusEmotionTag(type === "failed" ? "\u274C \u5931\u8D25" : "\u23F9\uFE0F \u5DF2\u505C\u6B62");
+  }
+  finishReaction(chatId, messageId, sessionId, terminalTag) {
     if (!messageId || !this.isStableTargetId(chatId))
       return;
     const key = this.reactionKey(messageId, chatId);
-    if (sessionId) {
-      const keys = this.sessionReactionKeys.get(sessionId);
-      if (keys) {
-        keys.delete(key);
-        if (keys.size === 0)
-          this.sessionReactionKeys.delete(sessionId);
-      }
+    const state = this.reactionStates.get(key);
+    if (!state)
+      return;
+    if (state.finishing) {
+      if (!state.finishBlocked)
+        return;
+      state.finishBlocked = false;
+      if (terminalTag)
+        state.terminalTag = terminalTag;
+      this.scheduleReactionDrain(state);
+      return;
     }
     if (!this.activeReactionKeys.delete(key))
       return;
-    this.recallReaction(messageId, chatId).catch((err) => {
-      this.logReactionFailure("reaction recall", err);
-    });
+    state.finishing = true;
+    state.desiredStatusTag = void 0;
+    state.terminalTag = terminalTag;
+    state.revision++;
+    this.scheduleReactionDrain(state);
+  }
+  stopReaction(chatId, messageId, sessionId) {
+    this.finishReaction(chatId, messageId, sessionId);
   }
   /** Recall reactions left behind when a session dies without terminal lifecycle events. */
   onSessionDied(sessionId) {
@@ -9511,16 +9866,32 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     const keys = this.sessionReactionKeys.get(sessionId);
     if (keys) {
       this.sessionReactionKeys.delete(sessionId);
-      for (const [key, { messageId, chatId }] of keys) {
-        if (this.activeReactionKeys.delete(key)) {
-          void this.recallReaction(messageId, chatId).catch((err) => {
-            this.logReactionFailure("session-death reaction recall", err);
-          });
-        }
+      for (const { messageId, chatId } of keys.values()) {
+        this.finishReaction(chatId, messageId, sessionId);
       }
     }
     super.onSessionDied(sessionId);
   }
+  /**
+   * A crashed standalone bridge never settles its in-flight turns, so their
+   * transient tags and ticking status cards would otherwise assert a live
+   * turn forever. Finish the tags without a terminal result and terminalize
+   * the cards as interrupted. Session state stays: crash recovery restores
+   * the sessions on a fresh bridge.
+   */
+  onBridgeDisconnected() {
+    for (const [sessionId, keys] of this.sessionReactionKeys) {
+      this.sessionReactionKeys.delete(sessionId);
+      for (const { messageId, chatId } of keys.values()) {
+        this.finishReaction(chatId, messageId, sessionId);
+      }
+    }
+    for (const [sessionId, runId] of this.cardRunBySession) {
+      this.cardRunBySession.delete(sessionId);
+      this.interactionPresenter?.terminalizeRun(runId, "cancelled");
+      this.cardRuns.delete(runId);
+    }
+  }
   onSessionRetiring(sessionId) {
     this.drainBackgroundResponseAggregations(sessionId);
   }
@@ -9539,10 +9910,18 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       }
       return;
     }
+    const presentationPhase = lifecyclePresentationPhase(event);
+    if (event.runId && presentationPhase) {
+      this.interactionPresenter?.updateStatusCardPhase(event.runId, presentationPhase);
+    }
+    if (presentationPhase) {
+      this.replaceStatusReaction(event.chatId, event.messageId, this.phaseReactionTag(presentationPhase));
+      return;
+    }
     if (isTerminalTaskLifecycleType(event.type)) {
       if (event.messageId)
         this.mentionTargets.delete(event.messageId);
-      this.stopReaction(event.chatId, event.messageId, event.sessionId);
+      this.finishReaction(event.chatId, event.messageId, event.sessionId, this.terminalReactionTag(event.type));
       if (event.runId) {
         this.deleteFileProjectorsForRun(event.runId);
         if (event.type === "failed") {