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

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

@@ -14,7 +14,7 @@ import {
   sanitizePromptText,
   sanitizeSenderName,
   truncateUtf16Units
-} from "./chunk-VDXYYVCD.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);
@@ -8382,12 +8541,21 @@ ${boundedLines.join("\n")}`);
 }
 __name(formatChatRecord, "formatChatRecord");
 var DEDUP_TTL_MS = 5 * 60 * 1e3;
+var BACKGROUND_RESPONSE_AGGREGATION_TIMEOUT_MS = 10 * 60 * 1e3;
+var BACKGROUND_RESPONSE_AGGREGATION_RETRY_MS = 30 * 1e3;
+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";
@@ -8515,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 [];
@@ -8552,12 +8740,37 @@ async function withConnectLoggingSuppressed(connect) {
   }
 }
 __name(withConnectLoggingSuppressed, "withConnectLoggingSuppressed");
+var ProactiveTextDeliveryError = class extends Error {
+  static {
+    __name(this, "ProactiveTextDeliveryError");
+  }
+  plan;
+  retryable;
+  constructor(plan, cause) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.plan = plan;
+    if (cause instanceof DingtalkCardRequestError) {
+      this.retryable = cause.retryable;
+    }
+  }
+};
+var ReplyTextDeliveryError = class extends Error {
+  static {
+    __name(this, "ReplyTextDeliveryError");
+  }
+  plan;
+  constructor(plan, cause) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.plan = plan;
+  }
+};
 var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   static {
     __name(this, "DingtalkChannel");
   }
   client;
   atSender;
+  displayLanguage;
   connectionManager;
   seenMessages = /* @__PURE__ */ new Map();
   mentionTargets = /* @__PURE__ */ new Map();
@@ -8568,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
@@ -8582,6 +8798,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
    */
   proactiveToken;
   interactiveCardConfig;
+  aggregateBackgroundAgentResponses;
   interactiveCardClient;
   statusCardController;
   questionCardController;
@@ -8601,9 +8818,14 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   // must be dropped, because recreating state would post the tail of a
   // force-split [FILE: ...] marker verbatim.
   blockProjectionArmed = /* @__PURE__ */ new Set();
+  backgroundResponseAggregations = /* @__PURE__ */ new Map();
+  detachedBackgroundResponseAggregations = /* @__PURE__ */ new Set();
+  pendingBackgroundResponseTerminals = /* @__PURE__ */ new Map();
+  detachedPendingBackgroundResponseTerminals = /* @__PURE__ */ new Set();
   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",
@@ -8618,6 +8840,11 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       this.config.instructions += FILE_INSTRUCTIONS;
     }
     this.interactiveCardConfig = parseDingtalkInteractiveCardConfig(config.interactiveCards);
+    const rawAggregateBackgroundAgentResponses = config.aggregateBackgroundAgentResponses;
+    if (rawAggregateBackgroundAgentResponses !== void 0 && typeof rawAggregateBackgroundAgentResponses !== "boolean") {
+      throw new Error(`Channel "${name}" aggregateBackgroundAgentResponses must be a boolean.`);
+    }
+    this.aggregateBackgroundAgentResponses = rawAggregateBackgroundAgentResponses === true;
     if (!config.clientId || !config.clientSecret) {
       throw new Error(`Channel "${name}" requires clientId and clientSecret for DingTalk.`);
     }
@@ -8642,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)}
 `);
@@ -8664,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")
           } : {}
@@ -9015,16 +9244,27 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
     return replaceImageMarkers(text, markers, replacements);
   }
-  async sendReply(chatId, text, atUserId, sourceLabel, prepared = false) {
+  async sendReply(chatId, text, atUserId, sourceLabel, prepared = false, failOnHttpError = false) {
     const webhook = this.webhooks.get(chatId);
     if (!webhook) {
       process.stderr.write(`[DingTalk:${this.name}] No webhook for chatId ${chatId}, cannot send.
 `);
+      if (failOnHttpError) {
+        throw new Error("DingTalk session webhook unavailable");
+      }
       return;
     }
     const outgoingText = prepared ? text : await this.prepareReplyOutput(chatId, text);
     if (!outgoingText.trim())
       return;
+    const plan = this.createReplyTextDelivery(outgoingText, atUserId, sourceLabel);
+    try {
+      await this.deliverReplyText(chatId, plan, failOnHttpError);
+    } catch (error) {
+      throw new ReplyTextDeliveryError(plan, error);
+    }
+  }
+  createReplyTextDelivery(outgoingText, atUserId, sourceLabel) {
     const mentionPrefix = atUserId ? `@${atUserId}
 
 ` : "";
@@ -9036,17 +9276,32 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       throw new Error("DingTalk source label exceeds the message limit.");
     }
     const chunks = normalizeDingTalkMarkdown(outgoingText, contentLimit).map((chunk, index) => `${index === 0 ? mentionPrefix : ""}${sourcePrefix}${chunk}`);
-    const title = extractTitle(outgoingText);
-    for (let i = 0; i < chunks.length; i++) {
-      const chunk = chunks[i];
-      const isMention = i === 0 && atUserId !== void 0;
+    return {
+      title: extractTitle(outgoingText),
+      chunks,
+      nextChunk: 0,
+      ...atUserId ? { atUserId } : {}
+    };
+  }
+  async deliverReplyText(chatId, plan, failOnHttpError = false) {
+    const webhook = this.webhooks.get(chatId);
+    if (!webhook) {
+      if (failOnHttpError) {
+        throw new Error("DingTalk session webhook unavailable");
+      }
+      return;
+    }
+    while (plan.nextChunk < plan.chunks.length) {
+      const index = plan.nextChunk;
+      const chunk = plan.chunks[index];
+      const isMention = index === 0 && plan.atUserId !== void 0;
       const body = {
         msgtype: "markdown",
         markdown: {
-          title: i === 0 ? title : `${title} (cont.)`,
+          title: index === 0 ? plan.title : `${plan.title} (cont.)`,
           text: chunk
         },
-        ...isMention ? { at: { atUserIds: [atUserId] } } : {}
+        ...isMention ? { at: { atUserIds: [plan.atUserId] } } : {}
       };
       let resp;
       try {
@@ -9073,7 +9328,21 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         const detail = await resp.text().catch(() => "");
         process.stderr.write(`[DingTalk:${this.name}] sendMessage failed: HTTP ${resp.status} ${detail}
 `);
+        if (failOnHttpError) {
+          throw new Error(`DingTalk reply send failed: HTTP ${resp.status} ${detail}`);
+        }
+      } else if (failOnHttpError) {
+        const payload = await resp.clone().json().catch(() => void 0);
+        const response = payload && typeof payload === "object" ? payload : void 0;
+        const value = response?.["errcode"] ?? response?.["code"];
+        if (value !== void 0 && String(value) !== "0") {
+          const detail = sanitizeLogText(String(response?.["errmsg"] ?? response?.["message"] ?? value), 300);
+          process.stderr.write(`[DingTalk:${this.name}] sendMessage failed: ${detail}
+`);
+          throw new Error(`DingTalk reply send failed: ${detail}`);
+        }
       }
+      plan.nextChunk++;
     }
   }
   async sendMessage(chatId, text) {
@@ -9103,9 +9372,19 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   async pushProactive(target, text, sourceLabel) {
     if (!text.trim())
       return;
+    const plan = await this.createProactiveTextDelivery(target, text, sourceLabel);
+    if (!plan)
+      return;
+    try {
+      await this.deliverProactiveText(target, plan);
+    } catch (error) {
+      throw new ProactiveTextDeliveryError(plan, error);
+    }
+  }
+  async createProactiveTextDelivery(target, text, sourceLabel) {
     const outgoingText = await this.prepareFileOutput(text, (file, mediaId) => this.sendProactiveFile(target, file, mediaId));
     if (!outgoingText.trim())
-      return;
+      return void 0;
     const sourcePrefix = sourceLabel ? `${escapeDingTalkMarkdown(sourceLabel)}
 
 ` : "";
@@ -9114,9 +9393,13 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       throw new Error("DingTalk source label exceeds the message limit.");
     }
     const chunks = normalizeDingTalkMarkdown(outgoingText, contentLimit).map((chunk) => `${sourcePrefix}${chunk}`);
-    const title = extractTitle(outgoingText);
-    for (let i = 0; i < chunks.length; i++) {
-      await this.sendProactiveChunk(target, i === 0 ? title : `${title} (cont.)`, chunks[i], `chunk ${i + 1}/${chunks.length}`);
+    return { title: extractTitle(outgoingText), chunks, nextChunk: 0 };
+  }
+  async deliverProactiveText(target, plan) {
+    while (plan.nextChunk < plan.chunks.length) {
+      const index = plan.nextChunk;
+      await this.sendProactiveChunk(target, index === 0 ? plan.title : `${plan.title} (cont.)`, plan.chunks[index], `chunk ${index + 1}/${plan.chunks.length}`);
+      plan.nextChunk++;
     }
   }
   async getProactiveToken() {
@@ -9260,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",
@@ -9280,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();
@@ -9300,24 +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 {
@@ -9325,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) {
@@ -9333,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);
@@ -9355,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) {
@@ -9363,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) {
@@ -9409,6 +9856,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       }
     }
     this.sessionMentionTargets.delete(sessionId);
+    this.drainBackgroundResponseAggregations(sessionId);
     const cardRunId = this.cardRunBySession.get(sessionId);
     if (cardRunId) {
       this.cardRunBySession.delete(sessionId);
@@ -9418,16 +9866,35 @@ 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);
+  }
   onTaskLifecycle(event) {
     if (event.type === "started") {
       this.startReaction(event.chatId, event.messageId, event.sessionId);
@@ -9443,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") {
@@ -9583,18 +10058,569 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
 `);
     });
   }
+  /** Deliver every Agent segment immediately unless aggregation is enabled. */
+  async dispatchBackgroundResponse(sessionId, text, context) {
+    const target = this.router.getTarget(sessionId);
+    if (!target || target.channelName !== this.name || context !== void 0 && context.kind !== "agent") {
+      return super.dispatchBackgroundResponse(sessionId, text, context);
+    }
+    const canAggregate = this.aggregateBackgroundAgentResponses && context?.kind === "agent" && typeof context.turnComplete === "boolean";
+    if (!canAggregate) {
+      if (text.trim().length === 0) {
+        return super.dispatchBackgroundResponse(sessionId, text, context);
+      }
+      return super.dispatchBackgroundResponse(sessionId, this.formatBackgroundAgentResponse(text, context?.label), context);
+    }
+    const key = JSON.stringify([sessionId, context.taskId, context.turnId]);
+    let current = this.backgroundResponseAggregations.get(key);
+    let parked = this.pendingBackgroundResponseTerminals.get(key);
+    if (current?.turnComplete === true) {
+      this.detachedBackgroundResponseAggregations.add(current);
+      this.backgroundResponseAggregations.delete(key);
+      current = void 0;
+    }
+    if (!current && (parked?.turnEnded === true || parked?.turnComplete === true && (parked.retryTimer || parked.retryInFlight || parked.resolvers > 0))) {
+      if (!parked.turnEnded) {
+        this.detachedPendingBackgroundResponseTerminals.add(parked);
+      }
+      parked = { sessionId, target, resolvers: 0, held: [] };
+      this.pendingBackgroundResponseTerminals.set(key, parked);
+    }
+    if (!current && text.trim().length === 0) {
+      if (!parked || parked.resolvers === 0 && !parked.retryTimer && !parked.retryInFlight && !parked.resolutionDropped && !parked.turnComplete) {
+        if (parked)
+          this.pendingBackgroundResponseTerminals.delete(key);
+        return super.dispatchBackgroundResponse(sessionId, text, context);
+      }
+      if (context.turnComplete) {
+        parked.turnComplete = true;
+        parked.status = context.status;
+        parked.label = context.label ?? parked.label;
+        parked.completionPartial = context.partial === true;
+        if (parked.resolvers === 0 && !parked.retryTimer && !parked.retryInFlight && (parked.retryAttempts ?? 0) >= BACKGROUND_RESPONSE_AGGREGATION_MAX_RETRIES) {
+          parked.turnEnded = true;
+          this.pendingBackgroundResponseTerminals.delete(key);
+        }
+      }
+      return;
+    }
+    if (!current) {
+      parked ??= { sessionId, target, resolvers: 0, held: [] };
+      this.pendingBackgroundResponseTerminals.set(key, parked);
+      this.holdPendingBackgroundResponse(parked, text, context);
+      parked.resolvers++;
+      try {
+        let delivery;
+        try {
+          delivery = await this.resolveBackgroundResponseDelivery(sessionId);
+        } catch (error) {
+          if (parked.resolvers === 1 && !this.backgroundResponseAggregations.has(key)) {
+            this.scheduleBackgroundResponseResolutionRetry(key, sessionId, parked);
+          } else {
+            const existing = this.backgroundResponseAggregations.get(key);
+            if (existing) {
+              if (parked.held.length > 0) {
+                this.applyHeldBackgroundResponses(existing, parked);
+              }
+              this.applyPendingBackgroundResponseTerminal(existing, parked);
+              if (parked.resolvers === 1) {
+                if (existing.turnComplete) {
+                  await this.completeBackgroundResponseAggregation(key, existing);
+                } else {
+                  this.scheduleBackgroundResponseAggregationFlush(key, existing);
+                }
+              }
+            }
+          }
+          throw error;
+        }
+        if (!delivery || this.router.getTarget(sessionId) !== delivery.target) {
+          if (parked.resolvers === 1 && !this.backgroundResponseAggregations.has(key)) {
+            this.scheduleBackgroundResponseResolutionRetry(key, sessionId, parked);
+          } else {
+            const existing = this.backgroundResponseAggregations.get(key);
+            if (existing) {
+              if (parked.held.length > 0) {
+                this.applyHeldBackgroundResponses(existing, parked);
+              }
+              this.applyPendingBackgroundResponseTerminal(existing, parked);
+              if (parked.resolvers === 1) {
+                if (existing.turnComplete) {
+                  await this.completeBackgroundResponseAggregation(key, existing);
+                } else {
+                  this.scheduleBackgroundResponseAggregationFlush(key, existing);
+                }
+              }
+            }
+          }
+          return;
+        }
+        if (parked.retiring || this.pendingBackgroundResponseTerminals.get(key) !== parked) {
+          await this.flushDetachedBackgroundResponse(key, sessionId, parked, delivery);
+          return;
+        }
+        if (parked.retryTimer) {
+          clearTimeout(parked.retryTimer);
+          parked.retryTimer = void 0;
+        }
+        current = this.backgroundResponseAggregations.get(key) ?? this.createBackgroundResponseAggregation(key, sessionId, parked.held[0]?.context ?? context, delivery.target, delivery.sourceLabel);
+        this.applyHeldBackgroundResponses(current, parked);
+        this.applyPendingBackgroundResponseTerminal(current, parked);
+        if (parked.resolutionDropped) {
+          current.resolutionDropped = true;
+          parked.resolutionDropped = void 0;
+        }
+      } finally {
+        parked.resolvers--;
+        if (this.pendingBackgroundResponseTerminals.get(key) === parked && parked.resolvers === 0 && !parked.retryTimer && parked.held.length === 0 && (!parked.resolutionDropped || parked.turnEnded)) {
+          this.pendingBackgroundResponseTerminals.delete(key);
+        }
+      }
+      if (!current)
+        return;
+      if (current.turnComplete && parked.resolvers > 0)
+        return;
+      if (!current.turnComplete) {
+        this.scheduleBackgroundResponseAggregationFlush(key, current);
+      } else {
+        await this.completeBackgroundResponseAggregation(key, current);
+      }
+      return;
+    }
+    current.status = context.status;
+    current.label = context.label ?? current.label;
+    if (text.trim().length > 0)
+      current.parts.push(text);
+    if (context.turnComplete && parked && parked.resolvers > 0) {
+      parked.turnComplete = true;
+      parked.status = context.status;
+      parked.label = context.label ?? parked.label;
+      parked.completionPartial = context.partial === true;
+    } else if (context.turnComplete) {
+      current.turnComplete = true;
+      current.completionPartial = context.partial === true;
+    } else if (parked?.turnComplete && parked.resolvers === 0) {
+      current.turnComplete = true;
+      current.status = parked.status ?? current.status;
+      current.label = parked.label ?? current.label;
+      current.completionPartial = parked.completionPartial === true;
+    }
+    current.resolutionDropped ||= parked?.resolutionDropped;
+    if (!current.turnComplete) {
+      this.scheduleBackgroundResponseAggregationFlush(key, current);
+      return;
+    }
+    await this.completeBackgroundResponseAggregation(key, current);
+  }
+  async flushBackgroundResponseAggregation(key, aggregation) {
+    if (this.backgroundResponseAggregations.get(key) !== aggregation && !this.detachedBackgroundResponseAggregations.has(aggregation) || aggregation.flushing) {
+      return;
+    }
+    this.refreshBackgroundResponseDelivery(aggregation);
+    if (aggregation.retryTimer)
+      clearTimeout(aggregation.retryTimer);
+    aggregation.retryTimer = void 0;
+    let delivery = aggregation.delivery;
+    if (!delivery) {
+      if (aggregation.parts.length === 0) {
+        if (!this.owesTerminalBackgroundResponseCard(aggregation)) {
+          if (aggregation.retiring || aggregation.turnComplete) {
+            this.removeBackgroundResponseAggregation(key, aggregation);
+          } else {
+            this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+          }
+          return;
+        }
+      }
+      if (aggregation.timeoutTimer)
+        clearTimeout(aggregation.timeoutTimer);
+      aggregation.timeoutTimer = void 0;
+      const parts = aggregation.parts.splice(0);
+      delivery = {
+        status: aggregation.status,
+        label: aggregation.label,
+        parts,
+        partial: this.isPartialBackgroundResponseDelivery(aggregation, parts.length),
+        attempts: 0,
+        composedTurnComplete: aggregation.turnComplete === true
+      };
+      aggregation.delivery = delivery;
+    }
+    const body = this.formatBackgroundResponseAggregation(delivery);
+    aggregation.flushing = true;
+    let error;
+    try {
+      if (delivery.proactivePlan) {
+        await this.deliverProactiveText(aggregation.target, delivery.proactivePlan);
+      } else if (delivery.replyPlan) {
+        await this.deliverReplyText(aggregation.target.chatId, delivery.replyPlan, true);
+      } else if (this.supportsProactiveSend() && this.supportsProactiveTarget(aggregation.target)) {
+        await this.deliverBackgroundResponseToTarget(aggregation.sessionId, body, {
+          target: aggregation.target,
+          sourceLabel: aggregation.sourceLabel
+        });
+      } else {
+        delivery.preparedReplyBody ??= await this.prepareReplyOutput(aggregation.target.chatId, body);
+        await this.deliverBackgroundReply(aggregation.target.chatId, delivery.preparedReplyBody, aggregation.sessionId, aggregation.sourceLabel, true, true);
+      }
+    } catch (caught) {
+      error = caught;
+      if (caught instanceof ProactiveTextDeliveryError) {
+        delivery.proactivePlan = caught.plan;
+      } else if (caught instanceof ReplyTextDeliveryError) {
+        delivery.replyPlan = caught.plan;
+      }
+    } finally {
+      aggregation.flushing = false;
+    }
+    if (error === void 0) {
+      aggregation.delivery = void 0;
+      aggregation.delivered = true;
+      if (delivery.composedTurnComplete === true && aggregation.turnComplete && delivery.partial !== true && !aggregation.retiring) {
+        aggregation.completionDelivered = true;
+      }
+      if (aggregation.retiring || aggregation.turnComplete) {
+        await this.flushBackgroundResponseAggregation(key, aggregation);
+      } else {
+        this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+      }
+      return;
+    }
+    delivery.attempts++;
+    process.stderr.write(`[DingTalk:${this.name}] background response delivery failed (attempt ${delivery.attempts}): ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
+`);
+    if (delivery.attempts >= BACKGROUND_RESPONSE_AGGREGATION_MAX_RETRIES || // A permanently rejected send (an invalid appkey, a missing app) cannot
+    // succeed later; retrying it only spends the chat's send quota.
+    error instanceof ProactiveTextDeliveryError && error.retryable === false) {
+      aggregation.delivery = void 0;
+      aggregation.dropped = true;
+      if (aggregation.parts.length === 0) {
+        if (aggregation.retiring || aggregation.turnComplete) {
+          this.removeBackgroundResponseAggregation(key, aggregation);
+        } else {
+          this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+        }
+      } else if (aggregation.retiring || aggregation.turnComplete) {
+        await this.flushBackgroundResponseAggregation(key, aggregation);
+      } else {
+        this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+      }
+      return;
+    }
+    aggregation.retryTimer = setTimeout(() => {
+      aggregation.retryTimer = void 0;
+      void this.flushBackgroundResponseAggregation(key, aggregation);
+    }, BACKGROUND_RESPONSE_AGGREGATION_RETRY_MS);
+    aggregation.retryTimer.unref?.();
+  }
+  /**
+   * A card carries `（部分）` whenever it is not the turn's whole output: the
+   * turn is still open, earlier text already went out (or was given up on),
+   * or the turn itself ended early.
+   */
+  isPartialBackgroundResponseDelivery(aggregation, partCount) {
+    return partCount > 0 && (aggregation.delivered === true || aggregation.dropped === true || aggregation.resolutionDropped === true || aggregation.retiring === true || aggregation.completionPartial === true || aggregation.turnComplete !== true);
+  }
+  /**
+   * A turn that outran the bounded wait had its text delivered under the
+   * `（部分）` label. When it then completes normally with nothing buffered,
+   * a header-only card is the only way the chat ever learns it finished.
+   */
+  owesTerminalBackgroundResponseCard(aggregation) {
+    return aggregation.turnComplete === true && aggregation.delivered === true && aggregation.completionDelivered !== true && aggregation.retiring !== true && aggregation.completionPartial !== true && aggregation.dropped !== true && aggregation.resolutionDropped !== true;
+  }
+  refreshBackgroundResponseDelivery(aggregation) {
+    const delivery = aggregation.delivery;
+    if (!delivery || aggregation.flushing)
+      return;
+    const plan = delivery.proactivePlan ?? delivery.replyPlan;
+    if (plan && plan.nextChunk > 0)
+      return;
+    const body = this.formatBackgroundResponseAggregation(delivery);
+    const header = body.split("\n", 1)[0];
+    const replaceHeader = /* @__PURE__ */ __name((text) => text.replace(/## (?:✅|❌|⏹️) Agent · [^\n]+/, () => header), "replaceHeader");
+    if (plan) {
+      plan.title = extractTitle(body);
+      plan.chunks[0] = replaceHeader(plan.chunks[0]);
+    }
+    if (delivery.preparedReplyBody) {
+      delivery.preparedReplyBody = replaceHeader(delivery.preparedReplyBody);
+    }
+    delivery.composedTurnComplete = aggregation.turnComplete === true;
+  }
+  removeBackgroundResponseAggregation(key, aggregation) {
+    if (this.backgroundResponseAggregations.get(key) === aggregation) {
+      this.backgroundResponseAggregations.delete(key);
+    }
+    this.detachedBackgroundResponseAggregations.delete(aggregation);
+  }
+  drainBackgroundResponseAggregations(sessionId) {
+    for (const [key, pending] of this.pendingBackgroundResponseTerminals) {
+      if (sessionId !== void 0 && pending.sessionId !== sessionId)
+        continue;
+      if (pending.retryTimer)
+        clearTimeout(pending.retryTimer);
+      pending.retryTimer = void 0;
+      pending.retiring = true;
+      pending.turnComplete = true;
+      pending.completionPartial = true;
+      this.pendingBackgroundResponseTerminals.delete(key);
+      this.detachedPendingBackgroundResponseTerminals.add(pending);
+    }
+    for (const pending of this.detachedPendingBackgroundResponseTerminals) {
+      if (sessionId !== void 0 && pending.sessionId !== sessionId)
+        continue;
+      if (pending.retryTimer)
+        clearTimeout(pending.retryTimer);
+      pending.retryTimer = void 0;
+      pending.retiring = true;
+      pending.turnComplete = true;
+      pending.completionPartial = true;
+      if (pending.held.length > 0 && this.router.getTarget(pending.sessionId) === pending.target) {
+        void this.flushDetachedBackgroundResponse("", pending.sessionId, pending, { target: pending.target }).catch((error) => {
+          process.stderr.write(`[DingTalk:${this.name}] background response delivery failed during drain: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
+`);
+        });
+      } else if (pending.held.length > 0) {
+        process.stderr.write(`[DingTalk:${this.name}] background response target unavailable during drain; ${pending.held.length} buffered segment(s) discarded
+`);
+        pending.held.length = 0;
+        this.detachedPendingBackgroundResponseTerminals.delete(pending);
+      } else if (pending.held.length === 0) {
+        this.detachedPendingBackgroundResponseTerminals.delete(pending);
+      }
+    }
+    const aggregations = /* @__PURE__ */ new Set([
+      ...this.backgroundResponseAggregations.values(),
+      ...this.detachedBackgroundResponseAggregations
+    ]);
+    for (const aggregation of aggregations) {
+      if (sessionId !== void 0 && aggregation.sessionId !== sessionId) {
+        continue;
+      }
+      if (aggregation.timeoutTimer)
+        clearTimeout(aggregation.timeoutTimer);
+      if (aggregation.retryTimer)
+        clearTimeout(aggregation.retryTimer);
+      aggregation.timeoutTimer = void 0;
+      aggregation.retryTimer = void 0;
+      aggregation.retiring = true;
+      aggregation.turnComplete = true;
+      aggregation.completionPartial = true;
+      if (!aggregation.flushing) {
+        void this.flushBackgroundResponseAggregation(aggregation.key, aggregation);
+      }
+    }
+  }
+  createBackgroundResponseAggregation(key, sessionId, context, target, sourceLabel) {
+    const aggregation = {
+      key,
+      sessionId,
+      target,
+      sourceLabel,
+      status: context.status,
+      label: context.label,
+      parts: []
+    };
+    this.backgroundResponseAggregations.set(key, aggregation);
+    return aggregation;
+  }
+  scheduleBackgroundResponseResolutionRetry(key, sessionId, pending) {
+    if (pending.retiring)
+      return;
+    if (pending.retryTimer)
+      return;
+    pending.retryAttempts = (pending.retryAttempts ?? 0) + 1;
+    if (pending.retryAttempts >= BACKGROUND_RESPONSE_AGGREGATION_MAX_RETRIES) {
+      pending.resolutionDropped = true;
+      pending.turnEnded = pending.turnComplete === true;
+      pending.held.length = 0;
+      pending.turnComplete = void 0;
+      pending.status = void 0;
+      pending.label = void 0;
+      pending.completionPartial = void 0;
+      if (pending.turnEnded) {
+        this.detachedPendingBackgroundResponseTerminals.delete(pending);
+      }
+      return;
+    }
+    pending.retryTimer = setTimeout(() => {
+      pending.retryTimer = void 0;
+      pending.retryInFlight = true;
+      void this.retryBackgroundResponseResolution(key, sessionId, pending).catch((error) => {
+        process.stderr.write(`[DingTalk:${this.name}] background response target resolution failed: ${sanitizeLogText(error instanceof Error ? error.message : String(error), 300)}
+`);
+      }).finally(() => {
+        pending.retryInFlight = false;
+        if (pending.retiring || !pending.retryTimer && !pending.resolutionDropped) {
+          this.detachedPendingBackgroundResponseTerminals.delete(pending);
+        }
+        if (this.pendingBackgroundResponseTerminals.get(key) === pending && pending.resolvers === 0 && !pending.retryTimer && pending.held.length === 0 && (!pending.resolutionDropped || pending.turnEnded)) {
+          this.pendingBackgroundResponseTerminals.delete(key);
+        }
+      });
+    }, BACKGROUND_RESPONSE_AGGREGATION_RETRY_MS);
+    pending.retryTimer.unref?.();
+    const active = this.pendingBackgroundResponseTerminals.get(key);
+    if (!active || active === pending) {
+      this.pendingBackgroundResponseTerminals.set(key, pending);
+    }
+  }
+  async retryBackgroundResponseResolution(key, sessionId, pending) {
+    let delivery;
+    try {
+      delivery = await this.resolveBackgroundResponseDelivery(sessionId);
+    } catch (error) {
+      if (this.pendingBackgroundResponseTerminals.get(key) === pending && !this.backgroundResponseAggregations.has(key) || this.detachedPendingBackgroundResponseTerminals.has(pending)) {
+        this.scheduleBackgroundResponseResolutionRetry(key, sessionId, pending);
+      }
+      throw error;
+    }
+    if (!delivery || this.router.getTarget(sessionId) !== delivery.target) {
+      if (pending.retiring) {
+        if (pending.held.length > 0) {
+          process.stderr.write(`[DingTalk:${this.name}] background response target unavailable during drain; ${pending.held.length} buffered segment(s) discarded
+`);
+        }
+        pending.held.length = 0;
+        this.detachedPendingBackgroundResponseTerminals.delete(pending);
+        return;
+      }
+      if (this.pendingBackgroundResponseTerminals.get(key) === pending && !this.backgroundResponseAggregations.has(key) || this.detachedPendingBackgroundResponseTerminals.has(pending)) {
+        this.scheduleBackgroundResponseResolutionRetry(key, sessionId, pending);
+      }
+      return;
+    }
+    if (pending.retiring || this.pendingBackgroundResponseTerminals.get(key) !== pending || pending.turnComplete) {
+      await this.flushDetachedBackgroundResponse(key, sessionId, pending, delivery);
+      return;
+    }
+    const first = pending.held[0];
+    if (!first)
+      return;
+    const aggregation = this.createBackgroundResponseAggregation(key, sessionId, first.context, delivery.target, delivery.sourceLabel);
+    this.applyHeldBackgroundResponses(aggregation, pending);
+    if (pending.resolutionDropped) {
+      aggregation.resolutionDropped = true;
+      pending.resolutionDropped = void 0;
+    }
+    if (this.pendingBackgroundResponseTerminals.get(key) === pending) {
+      this.pendingBackgroundResponseTerminals.delete(key);
+    }
+    this.scheduleBackgroundResponseAggregationFlush(key, aggregation);
+  }
+  holdPendingBackgroundResponse(pending, text, context) {
+    if (text.trim().length > 0)
+      pending.held.push({ text, context });
+    if (context.turnComplete) {
+      pending.turnComplete = true;
+      pending.status = context.status;
+      pending.label = context.label ?? pending.label;
+      pending.completionPartial = context.partial === true;
+    }
+  }
+  applyHeldBackgroundResponses(aggregation, pending) {
+    for (const { text, context } of pending.held.splice(0)) {
+      aggregation.status = context.status;
+      aggregation.label = context.label ?? aggregation.label;
+      aggregation.parts.push(text);
+      if (context.turnComplete) {
+        aggregation.turnComplete = true;
+        aggregation.completionPartial = context.partial === true;
+      }
+    }
+  }
+  applyPendingBackgroundResponseTerminal(aggregation, pending) {
+    if (!pending.turnComplete)
+      return;
+    aggregation.turnComplete = true;
+    aggregation.status = pending.status ?? aggregation.status;
+    aggregation.label = pending.label ?? aggregation.label;
+    aggregation.completionPartial = pending.completionPartial === true;
+    pending.turnComplete = void 0;
+    pending.status = void 0;
+    pending.label = void 0;
+    pending.completionPartial = void 0;
+  }
+  async completeBackgroundResponseAggregation(key, aggregation) {
+    if (aggregation.delivery) {
+      aggregation.delivery.status = aggregation.status;
+      aggregation.delivery.label = aggregation.label ?? aggregation.delivery.label;
+      aggregation.delivery.partial = this.isPartialBackgroundResponseDelivery(aggregation, aggregation.delivery.parts.length) || aggregation.parts.length > 0;
+    }
+    if (aggregation.timeoutTimer)
+      clearTimeout(aggregation.timeoutTimer);
+    aggregation.timeoutTimer = void 0;
+    await this.flushBackgroundResponseAggregation(key, aggregation);
+  }
+  async flushDetachedBackgroundResponse(key, sessionId, pending, delivery) {
+    const first = pending.held[0];
+    if (!first) {
+      this.detachedPendingBackgroundResponseTerminals.delete(pending);
+      return;
+    }
+    const aggregation = {
+      key,
+      sessionId,
+      target: delivery.target,
+      sourceLabel: delivery.sourceLabel,
+      status: first.context.status,
+      label: first.context.label,
+      parts: [],
+      turnComplete: pending.turnComplete,
+      completionPartial: pending.completionPartial,
+      resolutionDropped: pending.resolutionDropped
+    };
+    this.applyHeldBackgroundResponses(aggregation, pending);
+    aggregation.status = pending.status ?? aggregation.status;
+    aggregation.label = pending.label ?? aggregation.label;
+    if (this.pendingBackgroundResponseTerminals.get(key) === pending) {
+      this.pendingBackgroundResponseTerminals.delete(key);
+    }
+    this.detachedPendingBackgroundResponseTerminals.delete(pending);
+    this.detachedBackgroundResponseAggregations.add(aggregation);
+    await this.flushBackgroundResponseAggregation(key, aggregation);
+  }
+  scheduleBackgroundResponseAggregationFlush(key, aggregation) {
+    if (aggregation.timeoutTimer || aggregation.delivery)
+      return;
+    aggregation.timeoutTimer = setTimeout(() => {
+      aggregation.timeoutTimer = void 0;
+      void this.flushBackgroundResponseAggregation(key, aggregation);
+    }, BACKGROUND_RESPONSE_AGGREGATION_TIMEOUT_MS);
+    aggregation.timeoutTimer.unref?.();
+  }
+  formatBackgroundResponseAggregation(delivery) {
+    const icon = delivery.status === "completed" ? "\u2705" : delivery.status === "failed" ? "\u274C" : "\u23F9\uFE0F";
+    const label = this.formatBackgroundAgentLabel(delivery.label);
+    const header = `## ${icon} Agent \xB7 ${label}${delivery.partial ? "\uFF08\u90E8\u5206\uFF09" : ""}`;
+    if (delivery.parts.length === 0)
+      return header;
+    return `${header}
+
+${delivery.parts.join("\n\n")}`;
+  }
+  formatBackgroundAgentResponse(text, label) {
+    return `## \u{1F916} Agent \xB7 ${this.formatBackgroundAgentLabel(label)}
+
+${text}`;
+  }
+  formatBackgroundAgentLabel(label) {
+    const normalized = label?.replace(new RegExp("\\p{Cc}+", "gu"), " ").replace(/\s+/g, " ").trim();
+    return escapeDingTalkMarkdown(normalized || "\u540E\u53F0\u4EFB\u52A1");
+  }
   /**
    * Out-of-turn one-shot sends (background responses) must not flow through
    * the session's block-streaming projector: a second sender interleaving with
    * mid-projection state can swallow the send or split a held marker.
    */
-  async deliverBackgroundReply(chatId, text, sessionId, sourceLabel) {
+  async deliverBackgroundReply(chatId, text, sessionId, sourceLabel, prepared = false, failOnHttpError = false) {
     if (this.config.blockStreaming !== "on") {
-      return super.deliverBackgroundReply(chatId, text, sessionId, sourceLabel);
+      return this.sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared, failOnHttpError);
     }
-    await this.sendReply(chatId, text, void 0, sourceLabel);
+    await this.sendReply(chatId, text, void 0, sourceLabel, prepared, failOnHttpError);
   }
-  async sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared = false) {
+  async sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared = false, failOnHttpError = false) {
     let outgoingText = text;
     let consumesMention = true;
     if (this.config.blockStreaming === "on") {
@@ -9607,7 +10633,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     const atUserId = consumesMention && this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
     if (atUserId)
       this.sessionMentionTargets.delete(sessionId);
-    await this.sendReply(chatId, outgoingText, atUserId, sourceLabel ?? this.getResponseSourceLabel(sessionId), prepared);
+    await this.sendReply(chatId, outgoingText, atUserId, sourceLabel ?? this.getResponseSourceLabel(sessionId), prepared, failOnHttpError);
   }
   projectBlockStreamChunk(text, sessionId) {
     let state = this.blockFileProjectors.get(sessionId);
@@ -10069,6 +11095,12 @@ var plugin = {
         required: true,
         envResolvable: true
       },
+      {
+        key: "aggregateBackgroundAgentResponses",
+        label: "Aggregate Background Agent Responses",
+        kind: "boolean",
+        description: "Buffer each background Agent turn and send one labeled result instead of labeled segments"
+      },
       {
         key: "interactiveCards",
         label: "Interactive Cards",