@qwen-code/qwen-code 0.23.2-preview.0 → 0.23.3-nightly.20260910.c46cb85cf2

package/chunks/{dist-STAGIFNB.js → dist-3BJVSJ7D.js}

@@ -14,8 +14,8 @@ import {
   sanitizePromptText,
   sanitizeSenderName,
   truncateUtf16Units
-} from "./chunk-XVTCSVBK.js";
-import "./chunk-IW6RQPQB.js";
+} from "./chunk-C4NLHK7X.js";
+import "./chunk-IJOS26LH.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
@@ -38,7 +38,7 @@ init_esbuild_shims();
 // packages/channels/dingtalk/dist/DingtalkAdapter.js
 init_esbuild_shims();
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { basename as basename3, join } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 import { Buffer as Buffer2 } from "node:buffer";
@@ -6279,11 +6279,6 @@ function projectFileText(text) {
   return projector.result(safe);
 }
 __name(projectFileText, "projectFileText");
-function withFileUnavailableNotice(text) {
-  const safe = text.trimEnd();
-  return `${safe}${safe ? "\n" : ""}${FILE_UNAVAILABLE_NOTICE}`;
-}
-__name(withFileUnavailableNotice, "withFileUnavailableNotice");
 function safeFileName(filePath) {
   return basename2(filePath).replace(/[\p{Cc}\p{Cf}[\]]+/gu, "_").slice(0, 200) || "file";
 }
@@ -6853,16 +6848,24 @@ function parseDingtalkInteractiveCardConfig(value) {
   const root = asRecord(value) ?? {};
   const status = asRecord(root["statusCard"]);
   const question = asRecord(root["questionCard"]);
+  const permission = asRecord(root["permissionCard"]);
   if (root["statusCard"] !== void 0 && !status) {
     throw new Error("DingTalk interactiveCards.statusCard must be an object.");
   }
   if (root["questionCard"] !== void 0 && !question) {
     throw new Error("DingTalk interactiveCards.questionCard must be an object.");
   }
-  const timeoutMs = question?.["timeoutMs"] === void 0 ? DEFAULT_QUESTION_TIMEOUT_MS : question["timeoutMs"];
-  if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= DINGTALK_INTERACTIVE_CARD_TIMEOUT_EXCLUSIVE_MINIMUM) {
+  if (root["permissionCard"] !== void 0 && !permission) {
+    throw new Error("DingTalk interactiveCards.permissionCard must be an object.");
+  }
+  const questionTimeoutMs = question?.["timeoutMs"] === void 0 ? DEFAULT_QUESTION_TIMEOUT_MS : question["timeoutMs"];
+  if (typeof questionTimeoutMs !== "number" || !Number.isFinite(questionTimeoutMs) || questionTimeoutMs <= DINGTALK_INTERACTIVE_CARD_TIMEOUT_EXCLUSIVE_MINIMUM) {
     throw new Error("DingTalk interactiveCards.questionCard.timeoutMs must be a finite positive number.");
   }
+  const permissionTimeoutMs = permission?.["timeoutMs"] === void 0 ? DEFAULT_QUESTION_TIMEOUT_MS : permission["timeoutMs"];
+  if (typeof permissionTimeoutMs !== "number" || !Number.isFinite(permissionTimeoutMs) || permissionTimeoutMs <= DINGTALK_INTERACTIVE_CARD_TIMEOUT_EXCLUSIVE_MINIMUM) {
+    throw new Error("DingTalk interactiveCards.permissionCard.timeoutMs must be a finite positive number.");
+  }
   return {
     enabled: optionalBoolean(root["enabled"], "enabled", configured),
     statusCard: {
@@ -6870,7 +6873,11 @@ function parseDingtalkInteractiveCardConfig(value) {
     },
     questionCard: {
       enabled: optionalBoolean(question?.["enabled"], "questionCard.enabled", true),
-      timeoutMs: Math.min(timeoutMs, DINGTALK_INTERACTIVE_CARD_TIMEOUT_MAXIMUM_MS)
+      timeoutMs: Math.min(questionTimeoutMs, DINGTALK_INTERACTIVE_CARD_TIMEOUT_MAXIMUM_MS)
+    },
+    permissionCard: {
+      enabled: optionalBoolean(permission?.["enabled"], "permissionCard.enabled", true),
+      timeoutMs: Math.min(permissionTimeoutMs, DINGTALK_INTERACTIVE_CARD_TIMEOUT_MAXIMUM_MS)
     }
   };
 }
@@ -7981,9 +7988,294 @@ ${text}`;
   }
 };
 
-// packages/channels/dingtalk/dist/interaction-presenter.js
+// packages/channels/dingtalk/dist/permission-card-controller.js
 init_esbuild_shims();
 import { randomUUID as randomUUID4 } from "node:crypto";
+var DECISION_FIELD = "permission_decision";
+var PERMISSION_CARD_COPY = {
+  en: {
+    title: "Permission required",
+    submit: "Submit",
+    choose: "Choose how to continue",
+    approved: { description: "Permission approved.", button: "Approved" },
+    denied: { description: "Permission denied.", button: "Denied" },
+    expired: {
+      description: "This permission request is no longer available.",
+      button: "Expired"
+    },
+    cancelled: {
+      description: "Permission request cancelled.",
+      button: "Cancelled"
+    }
+  },
+  zh: {
+    title: "\u9700\u8981\u6388\u6743",
+    submit: "\u63D0\u4EA4",
+    choose: "\u8BF7\u9009\u62E9\u540E\u7EED\u64CD\u4F5C",
+    approved: { description: "\u5DF2\u6388\u6743\u3002", button: "\u5DF2\u6388\u6743" },
+    denied: { description: "\u5DF2\u62D2\u7EDD\u6388\u6743\u3002", button: "\u5DF2\u62D2\u7EDD" },
+    expired: { description: "\u6B64\u6388\u6743\u8BF7\u6C42\u5DF2\u5931\u6548\u3002", button: "\u5DF2\u5931\u6548" },
+    cancelled: { description: "\u6388\u6743\u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002", button: "\u5DF2\u53D6\u6D88" }
+  }
+};
+var PermissionCardController = class {
+  static {
+    __name(this, "PermissionCardController");
+  }
+  options;
+  byRequest = /* @__PURE__ */ new Map();
+  byOutTrack = /* @__PURE__ */ new Map();
+  pendingByRun = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+  }
+  async present(context, target) {
+    const previous = this.byRequest.get(context.requestId);
+    if (previous) {
+      this.reserveTerminalProjection(previous);
+      await this.finalize(previous, "expired");
+    }
+    const record = {
+      context,
+      target,
+      outTrackId: `qwen-permission-${randomUUID4()}`,
+      state: "reserved",
+      delivered: false,
+      forbiddenActors: /* @__PURE__ */ new Set()
+    };
+    this.byRequest.set(context.requestId, record);
+    this.byOutTrack.set(record.outTrackId, record);
+    const unsubscribe = context.onSettled((reason) => {
+      if (record.state === "claimed")
+        return;
+      if (record.state === "pending")
+        this.reserveTerminalProjection(record);
+      void this.finalize(record, reason === "resolved_outside_presenter" ? "expired" : "cancelled");
+    });
+    record.unsubscribe = unsubscribe;
+    if (record.state === "terminal")
+      unsubscribe();
+    try {
+      await this.options.client.createAndDeliver({
+        templateId: QUESTION_CARD_TEMPLATE_ID,
+        outTrackId: record.outTrackId,
+        target,
+        cardParamMap: this.cardData(context)
+      });
+      record.delivered = true;
+    } catch (error) {
+      this.options.onError?.("permission card creation", error);
+      if (record.state === "terminal")
+        return { kind: "presented" };
+      this.discard(record);
+      return { kind: "unsupported" };
+    }
+    if (record.state !== "reserved") {
+      await this.projectTerminal(record);
+      return { kind: "presented" };
+    }
+    record.state = "pending";
+    const pending = this.pendingByRun.get(context.runId) ?? /* @__PURE__ */ new Set();
+    pending.add(context.requestId);
+    this.pendingByRun.set(context.runId, pending);
+    record.timer = setTimeout(() => {
+      void this.expire(record);
+    }, this.options.timeoutMs);
+    record.timer.unref?.();
+    return { kind: "presented" };
+  }
+  claim(callback) {
+    const record = this.byOutTrack.get(callback.outTrackId);
+    if (!record || record.state !== "pending") {
+      return { kind: "ignored", actorId: callback.actorId };
+    }
+    if (record.context.owner.id !== callback.actorId) {
+      if (record.forbiddenActors.has(callback.actorId)) {
+        return { kind: "ignored" };
+      }
+      record.forbiddenActors.add(callback.actorId);
+      return {
+        kind: "forbidden",
+        actorId: callback.actorId,
+        target: record.target
+      };
+    }
+    if (callback.hasBusinessPayload === false || !callback.isCancel && callback.actionId !== "cancel" && callback.actionId !== "submit" && callback.actionId !== record.context.requestId) {
+      return { kind: "ignored", actorId: callback.actorId };
+    }
+    if (callback.isCancel || callback.actionId === "cancel") {
+      this.reserveTerminalProjection(record);
+      record.state = "claimed";
+      return {
+        kind: "accepted",
+        execute: /* @__PURE__ */ __name(() => this.respond(record, "deny", "cancelled"), "execute")
+      };
+    }
+    const decision = this.parseDecision(record, callback.formData);
+    if (!decision)
+      return { kind: "ignored", actorId: callback.actorId };
+    this.reserveTerminalProjection(record);
+    record.state = "claimed";
+    return {
+      kind: "accepted",
+      execute: /* @__PURE__ */ __name(() => this.respond(record, decision), "execute")
+    };
+  }
+  cancelRun(runId) {
+    const requestIds = [...this.pendingByRun.get(runId) ?? []];
+    for (const requestId of requestIds) {
+      const record = this.byRequest.get(requestId);
+      if (record) {
+        this.reserveTerminalProjection(record);
+        void this.finalize(record, "cancelled");
+      }
+    }
+  }
+  async respond(record, decision, terminalState) {
+    try {
+      const accepted = await record.context.respond(decision);
+      await this.finalize(record, accepted ? terminalState ?? (decision === "deny" ? "denied" : "approved") : "expired");
+    } catch (error) {
+      this.options.onError?.("permission response", error);
+      await this.finalize(record, "expired");
+    }
+  }
+  async expire(record) {
+    if (record.state !== "pending")
+      return;
+    this.reserveTerminalProjection(record);
+    record.state = "claimed";
+    const response = record.context.respond("deny").catch((error) => {
+      this.options.onError?.("expired permission cancellation", error);
+    });
+    await this.finalize(record, "expired");
+    await response;
+  }
+  async finalize(record, terminalState) {
+    if (record.state === "terminal")
+      return;
+    record.state = "terminal";
+    record.terminalState = terminalState;
+    this.removeRecord(record);
+    if (!record.delivered)
+      return;
+    const finishTerminalProjection = record.finishTerminalProjection;
+    record.finishTerminalProjection = void 0;
+    if (finishTerminalProjection) {
+      await finishTerminalProjection(() => this.projectTerminal(record));
+    } else {
+      await this.projectTerminal(record);
+    }
+  }
+  discard(record) {
+    if (record.state === "terminal")
+      return;
+    record.state = "terminal";
+    this.removeRecord(record);
+  }
+  removeRecord(record) {
+    if (record.timer)
+      clearTimeout(record.timer);
+    record.timer = void 0;
+    record.unsubscribe?.();
+    record.unsubscribe = void 0;
+    this.byRequest.delete(record.context.requestId);
+    this.byOutTrack.delete(record.outTrackId);
+    const pending = this.pendingByRun.get(record.context.runId);
+    pending?.delete(record.context.requestId);
+    if (pending?.size === 0)
+      this.pendingByRun.delete(record.context.runId);
+  }
+  reserveTerminalProjection(record) {
+    record.finishTerminalProjection ??= this.options.reserveRunProjection?.(record.context.runId);
+  }
+  async projectTerminal(record) {
+    if (!record.terminalState)
+      return;
+    const copy = PERMISSION_CARD_COPY[this.options.locale ?? "en"];
+    const cardParamMap = {
+      approved: {
+        card_status: "approved",
+        question_desc: copy.approved.description,
+        form_btn_text: copy.approved.button
+      },
+      denied: {
+        card_status: "denied",
+        question_desc: copy.denied.description,
+        form_btn_text: copy.denied.button
+      },
+      expired: {
+        card_status: "expired",
+        question_desc: copy.expired.description,
+        form_btn_text: copy.expired.button
+      },
+      cancelled: {
+        card_status: "cancelled",
+        question_desc: copy.cancelled.description,
+        form_btn_text: copy.cancelled.button
+      }
+    };
+    try {
+      await this.options.client.updateInstance({
+        outTrackId: record.outTrackId,
+        cardParamMap: cardParamMap[record.terminalState]
+      });
+    } catch (error) {
+      this.options.onError?.("permission card finalization", error);
+    }
+  }
+  parseDecision(record, formData) {
+    if (Object.keys(formData).length !== 1 || !Object.prototype.hasOwnProperty.call(formData, DECISION_FIELD)) {
+      return void 0;
+    }
+    const values = this.readValues(formData[DECISION_FIELD]);
+    if (values.length !== 1)
+      return void 0;
+    const decision = values[0];
+    return record.context.decisions.some((candidate) => candidate.kind === decision) ? decision : void 0;
+  }
+  readValues(value) {
+    if (typeof value === "string")
+      return value.trim() ? [value.trim()] : [];
+    if (Array.isArray(value)) {
+      return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+    }
+    if (value !== null && typeof value === "object") {
+      return this.readValues(value["value"]);
+    }
+    return [];
+  }
+  cardData(context) {
+    const copy = PERMISSION_CARD_COPY[this.options.locale ?? "en"];
+    return {
+      question_id: context.requestId,
+      question_title: copy.title,
+      question_desc: context.title,
+      card_status: "pending",
+      form_btn_text: copy.submit,
+      selected_text: "",
+      selected_values: "[]",
+      form: {
+        fields: [
+          {
+            name: DECISION_FIELD,
+            label: copy.choose,
+            type: "CHECKBOX_GROUP",
+            required: true,
+            options: context.decisions.map((decision) => ({
+              value: decision.kind,
+              text: decision.label
+            }))
+          }
+        ]
+      }
+    };
+  }
+};
+
+// packages/channels/dingtalk/dist/interaction-presenter.js
+init_esbuild_shims();
+import { randomUUID as randomUUID5 } from "node:crypto";
 function escapeSenderMarkdownText(text) {
   return text.replace(/([\\`*_[\]{}()#+.!|>~-])/gu, "\\$1");
 }
@@ -8149,6 +8441,16 @@ var DingtalkInteractionPresenter = class {
       return Promise.resolve({ kind: "unsupported" });
     return questionCards.present(context, this.cardTarget(context.target));
   }
+  presentPermission(context) {
+    const run = this.runs.get(context.runId);
+    if (!run || run.terminal || run.ownerId !== context.owner.id || run.target.chatId !== context.target.chatId || run.target.isGroup !== context.target.isGroup) {
+      return Promise.resolve({ kind: "unsupported" });
+    }
+    const permissionCards = this.options.permissionCards;
+    if (!permissionCards)
+      return Promise.resolve({ kind: "unsupported" });
+    return permissionCards.present(context, this.cardTarget(context.target));
+  }
   terminalCopy() {
     if (this.options.language !== void 0 && !isChinesePresentationLanguage(this.options.language)) {
       return {
@@ -8168,6 +8470,7 @@ var DingtalkInteractionPresenter = class {
     if (!run || run.terminal)
       return;
     this.options.questionCards?.cancelRun(runId, terminal === "cancelled" && (detail === "cancel_command" || detail === "clear") ? "cancelled" : "expired");
+    this.options.permissionCards?.cancelRun(runId);
     run.terminal = true;
     const activeSegmentId = run.activeSegmentId;
     run.activeSegmentId = void 0;
@@ -8323,7 +8626,7 @@ ${this.boundContent(content, Math.max(0, CONTENT_LIMIT - sourceLabel.length - 2)
   ensureStatusContext(run, segment) {
     if (run.statusContext)
       return run.statusContext;
-    run.statusContext = segment ? { ...segment } : { ...run.baseContext, segmentId: `${run.runId}:${randomUUID4()}` };
+    run.statusContext = segment ? { ...segment } : { ...run.baseContext, segmentId: `${run.runId}:${randomUUID5()}` };
     return run.statusContext;
   }
   cardTarget(target) {
@@ -8541,9 +8844,6 @@ ${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";
@@ -8740,30 +9040,6 @@ 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");
@@ -8798,10 +9074,10 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
    */
   proactiveToken;
   interactiveCardConfig;
-  aggregateBackgroundAgentResponses;
   interactiveCardClient;
   statusCardController;
   questionCardController;
+  permissionCardController;
   interactionPresenter;
   inboundCardOwners = /* @__PURE__ */ new Map();
   cardRunBySession = /* @__PURE__ */ new Map();
@@ -8810,18 +9086,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   // boundary, input requested) mints a fresh segment UUID but the projection
   // state must survive it, or a marker split across the reset leaks.
   fileProjectors = /* @__PURE__ */ new Map();
-  blockFileProjectors = /* @__PURE__ */ new Map();
-  // Sessions armed for block projection by onPromptStart and disarmed when
-  // the turn settles (or the session dies). A block send that finds NO
-  // projector state is only legitimate as a turn's FIRST block, which always
-  // lands while armed: late sends from an evicted (/clear) or dead session
-  // 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;
@@ -8836,15 +9100,10 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     } else if (!this.config.instructions.includes("[IMAGE:")) {
       this.config.instructions += IMAGE_INSTRUCTIONS;
     }
-    if (config.blockStreaming !== "on" && !this.config.instructions.includes("[FILE:")) {
+    if (!this.config.instructions.includes("[FILE:")) {
       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.`);
     }
@@ -8864,7 +9123,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
           }
         }, "invalidateAccessToken")
       });
-      if (this.interactiveCardConfig.statusCard.enabled && config.blockStreaming !== "on") {
+      if (this.interactiveCardConfig.statusCard.enabled) {
         this.statusCardController = new StatusCardController({
           client: this.interactiveCardClient,
           cancelRun: /* @__PURE__ */ __name((sessionId, runId) => this.requestPromptRunCancellation(sessionId, runId), "cancelRun"),
@@ -8888,14 +9147,25 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
           }, "onError")
         });
       }
-      if (this.statusCardController || this.questionCardController) {
+      if (this.interactiveCardConfig.permissionCard.enabled) {
+        this.permissionCardController = new PermissionCardController({
+          client: this.interactiveCardClient,
+          timeoutMs: this.interactiveCardConfig.permissionCard.timeoutMs,
+          locale: this.locale,
+          reserveRunProjection: /* @__PURE__ */ __name((runId) => this.interactionPresenter?.reserveProjection(runId), "reserveRunProjection"),
+          onError: /* @__PURE__ */ __name((operation, error) => {
+            process.stderr.write(`[DingTalk:${this.name}] ${operation} failed: ${sanitizeLogText(String(error), 300)}
+`);
+          }, "onError")
+        });
+      }
+      if (this.statusCardController || this.questionCardController || this.permissionCardController) {
         this.interactionPresenter = new DingtalkInteractionPresenter({
           statusCards: this.statusCardController,
           questionCards: this.questionCardController,
+          permissionCards: this.permissionCardController,
           ...options?.displayLanguage ? { language: options.displayLanguage } : {},
-          ...config.blockStreaming !== "on" ? {
-            sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId, sourceLabel) => this.sendFallbackReply(chatId, text, sessionId, sourceLabel), "sendFallback")
-          } : {}
+          sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId, sourceLabel) => this.sendFallbackReply(chatId, text, sessionId, sourceLabel), "sendFallback")
         });
       }
     }
@@ -8979,7 +9249,11 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     if (callback.actionId === "btn_stop") {
       return this.statusCardController?.claimStop(callback.outTrackId, callback.actorId) ?? { kind: "ignored", actorId: callback.actorId };
     }
-    return this.questionCardController?.claim(callback) ?? {
+    const permissionResult = this.permissionCardController?.claim(callback);
+    if (permissionResult && permissionResult.kind !== "ignored") {
+      return permissionResult;
+    }
+    return this.questionCardController?.claim(callback) ?? permissionResult ?? {
       kind: "ignored",
       actorId: callback.actorId
     };
@@ -9191,9 +9465,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       process.stderr.write(`[DingTalk:${this.name}] file markers projected (final=${projection.markerCount}, streamed=${streamedMarkers})
 `);
     }
-    if (this.config.blockStreaming === "on" && (projection.markerCount > 0 || streamedMarkers > 0)) {
-      return this.prepareOutgoingText(withFileUnavailableNotice(projection.text));
-    }
     const notices = [];
     if (projection.invalidMarkers > 0) {
       notices.push("[File delivery failed: invalid marker]");
@@ -9244,25 +9515,18 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
     return replaceImageMarkers(text, markers, replacements);
   }
-  async sendReply(chatId, text, atUserId, sourceLabel, prepared = false, failOnHttpError = false) {
+  async sendReply(chatId, text, atUserId, sourceLabel, prepared = 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);
-    }
+    await this.deliverReplyText(chatId, plan);
   }
   createReplyTextDelivery(outgoingText, atUserId, sourceLabel) {
     const mentionPrefix = atUserId ? `@${atUserId}
@@ -9283,12 +9547,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       ...atUserId ? { atUserId } : {}
     };
   }
-  async deliverReplyText(chatId, plan, failOnHttpError = false) {
+  async deliverReplyText(chatId, plan) {
     const webhook = this.webhooks.get(chatId);
     if (!webhook) {
-      if (failOnHttpError) {
-        throw new Error("DingTalk session webhook unavailable");
-      }
       return;
     }
     while (plan.nextChunk < plan.chunks.length) {
@@ -9328,19 +9589,6 @@ 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++;
     }
@@ -9375,11 +9623,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     const plan = await this.createProactiveTextDelivery(target, text, sourceLabel);
     if (!plan)
       return;
-    try {
-      await this.deliverProactiveText(target, plan);
-    } catch (error) {
-      throw new ProactiveTextDeliveryError(plan, error);
-    }
+    await this.deliverProactiveText(target, plan);
   }
   async createProactiveTextDelivery(target, text, sourceLabel) {
     const outgoingText = await this.prepareFileOutput(text, (file, mediaId) => this.sendProactiveFile(target, file, mediaId));
@@ -9432,20 +9676,29 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     return data.access_token;
   }
   sendCardInteractionFeedback(actorId, target) {
+    const copy = this.locale === "zh" ? {
+      title: "\u5361\u7247\u64CD\u4F5C",
+      group: "\u4EC5\u4EFB\u52A1\u53D1\u8D77\u4EBA\u53EF\u4EE5\u64CD\u4F5C\u8FD9\u5F20\u5361\u7247\uFF0C\u672C\u6B21\u64CD\u4F5C\u672A\u751F\u6548\u3002",
+      direct: "\u4F60\u65E0\u6743\u64CD\u4F5C\u8FD9\u5F20\u5361\u7247\uFF0C\u4EC5\u4EFB\u52A1\u53D1\u8D77\u4EBA\u53EF\u4EE5\u63D0\u4EA4\u6216\u505C\u6B62\u3002"
+    } : {
+      title: "Card interaction",
+      group: "Only the task initiator can operate this card. This action had no effect.",
+      direct: "You cannot operate this card. Only the task initiator can submit or stop it."
+    };
     if (target?.isGroup) {
       return this.sendProactiveChunk({
         channelName: this.name,
         senderId: actorId,
         chatId: target.chatId,
         isGroup: true
-      }, "\u5361\u7247\u64CD\u4F5C", "\u4EC5\u4EFB\u52A1\u53D1\u8D77\u4EBA\u53EF\u4EE5\u64CD\u4F5C\u8FD9\u5F20\u5361\u7247\uFF0C\u672C\u6B21\u64CD\u4F5C\u672A\u751F\u6548\u3002", "card interaction feedback");
+      }, copy.title, copy.group, "card interaction feedback");
     }
     return this.sendProactiveChunk({
       channelName: this.name,
       senderId: actorId,
       chatId: actorId,
       isGroup: false
-    }, "\u5361\u7247\u64CD\u4F5C", "\u4F60\u65E0\u6743\u64CD\u4F5C\u8FD9\u5F20\u5361\u7247\uFF0C\u4EC5\u4EFB\u52A1\u53D1\u8D77\u4EBA\u53EF\u4EE5\u63D0\u4EA4\u6216\u505C\u6B62\u3002", "card interaction feedback");
+    }, copy.title, copy.direct, "card interaction feedback");
   }
   async sendProactiveChunk(target, title, text, chunkLabel) {
     return this.sendProactivePayload(target, PROACTIVE_MSG_KEY, { title, text }, chunkLabel);
@@ -9605,7 +9858,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       this.finishReaction(state.chatId, state.messageId, state.sessionId);
     }
     this.statusCardController?.dispose();
-    this.drainBackgroundResponseAggregations();
     this.activeReactionKeys.clear();
     this.sessionReactionKeys.clear();
     this.reactionStates.clear();
@@ -9841,8 +10093,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   }
   /** Recall reactions left behind when a session dies without terminal lifecycle events. */
   onSessionDied(sessionId) {
-    this.blockProjectionArmed.delete(sessionId);
-    this.blockFileProjectors.delete(sessionId);
     for (const [runId, state] of this.fileProjectors) {
       if (state.sessionId === sessionId)
         this.fileProjectors.delete(runId);
@@ -9856,7 +10106,6 @@ 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);
@@ -9892,9 +10141,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       this.cardRuns.delete(runId);
     }
   }
-  onSessionRetiring(sessionId) {
-    this.drainBackgroundResponseAggregations(sessionId);
-  }
   onTaskLifecycle(event) {
     if (event.type === "started") {
       this.startReaction(event.chatId, event.messageId, event.sessionId);
@@ -9966,7 +10212,6 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
   }
   onPromptStart(chatId, sessionId, messageId) {
-    this.blockProjectionArmed.add(sessionId);
     if (messageId) {
       this.bufferedMentionTargets.delete(messageId);
       this.untrackBufferedMentionTarget(sessionId, messageId);
@@ -10029,576 +10274,15 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       this.bufferedMentionTargetsBySession.delete(sessionId);
   }
   onPromptEnd(chatId, sessionId, messageId) {
-    this.settleBlockFileProjector(chatId, sessionId);
     this.sessionMentionTargets.delete(sessionId);
     this.stopReaction(chatId, messageId, sessionId);
   }
-  /**
-   * Turn end is the only point where the block projector's held state can be
-   * settled: ChannelBase drains the turn's queued block sends before calling
-   * onPromptEnd, so everything already appended belongs to this turn. Flush
-   * the held candidate bytes (a trailing `[FILE:` prefix the stream never
-   * completed) before deleting the entry — a later delete-without-settle
-   * would silently drop them from the delivered answer. Also disarm the
-   * session: /clear eviction and session death settle WITHOUT draining the
-   * turn's send chain, and any block that lands afterwards must be dropped
-   * rather than recreating projector state.
-   */
-  settleBlockFileProjector(chatId, sessionId) {
-    this.blockProjectionArmed.delete(sessionId);
-    const state = this.blockFileProjectors.get(sessionId);
-    if (!state)
-      return;
-    this.blockFileProjectors.delete(sessionId);
-    const tail = state.projector.complete();
-    if (!tail.trim())
-      return;
-    void this.sendReply(chatId, tail, void 0, this.getResponseSourceLabel(sessionId)).catch((err) => {
-      process.stderr.write(`[DingTalk:${this.name}] projector tail delivery failed for session ${sessionId}: ${err instanceof Error ? err.message : String(err)}
-`);
-    });
-  }
-  /** 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") {
+    if (!target || target.channelName !== this.name || context !== void 0 && context.kind !== "agent" || !text.trim()) {
       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")}`;
+    return super.dispatchBackgroundResponse(sessionId, this.formatBackgroundAgentResponse(text, context?.label), context);
   }
   formatBackgroundAgentResponse(text, label) {
     return `## \u{1F916} Agent \xB7 ${this.formatBackgroundAgentLabel(label)}
@@ -10609,52 +10293,11 @@ ${text}`;
     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, prepared = false, failOnHttpError = false) {
-    if (this.config.blockStreaming !== "on") {
-      return this.sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared, failOnHttpError);
-    }
-    await this.sendReply(chatId, text, void 0, sourceLabel, prepared, failOnHttpError);
-  }
-  async sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared = false, failOnHttpError = false) {
-    let outgoingText = text;
-    let consumesMention = true;
-    if (this.config.blockStreaming === "on") {
-      const projected = this.projectBlockStreamChunk(text, sessionId);
-      if (!projected.text.trim())
-        return;
-      outgoingText = projected.text;
-      consumesMention = projected.hasContent;
-    }
-    const atUserId = consumesMention && this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
+  async sendResponseMessage(chatId, text, sessionId, sourceLabel, prepared = false) {
+    const atUserId = 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, failOnHttpError);
-  }
-  projectBlockStreamChunk(text, sessionId) {
-    let state = this.blockFileProjectors.get(sessionId);
-    if (!state) {
-      if (!this.blockProjectionArmed.has(sessionId)) {
-        return { text: "", hasContent: false };
-      }
-      state = { projector: new OutboundFileProjector(), reportedMarkers: 0 };
-      this.blockFileProjectors.set(sessionId, state);
-    }
-    const safe = state.projector.append(text);
-    const hasContent = safe.trim().length > 0;
-    const result = state.projector.result(safe);
-    let outgoingText = safe;
-    if (result.markerCount > state.reportedMarkers) {
-      outgoingText = withFileUnavailableNotice(safe);
-      state.reportedMarkers = result.markerCount;
-      process.stderr.write(`[DingTalk:${this.name}] file markers redacted in block stream (session ${sessionId}, markers=${result.markerCount})
-`);
-    }
-    return { text: outgoingText, hasContent };
+    await this.sendReply(chatId, text, atUserId, sourceLabel ?? this.getResponseSourceLabel(sessionId), prepared);
   }
   async sendFallbackReply(chatId, text, sessionId, sourceLabel) {
     const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
@@ -10708,6 +10351,16 @@ ${text}`;
     }
     return this.interactionPresenter.presentInput(context);
   }
+  async presentPermissionRequest(context) {
+    const run = this.cardRuns.get(context.runId);
+    if (!run || run.ownerId !== context.owner.id) {
+      return { kind: "unsupported" };
+    }
+    if (!this.permissionCardController || !this.interactionPresenter) {
+      return { kind: "unsupported" };
+    }
+    return this.interactionPresenter.presentPermission(context);
+  }
   /**
    * Extract quoted/referenced message context from a reply.
    * DingTalk provides this via text.repliedMsg (newer) or quoteMessage (legacy).
@@ -10946,7 +10599,7 @@ ${text}`;
       let filePath;
       let safeName;
       try {
-        dir = join(tmpdir3(), "channel-files", randomUUID5());
+        dir = join(tmpdir3(), "channel-files", randomUUID6());
         mkdirSync(dir, { recursive: true });
         safeName = basename3(typeof fileName === "string" ? fileName : "") || `dingtalk_${mediaType}_${Date.now()}.${GENERATED_MEDIA_EXT[media.mimeType] ?? "bin"}`;
         filePath = join(dir, safeName);
@@ -11053,7 +10706,7 @@ ${text}`;
         }
       }) : this.handleInbound(envelope);
       processMessage.catch((err) => {
-        const reference = randomUUID5().slice(0, 8);
+        const reference = randomUUID6().slice(0, 8);
         let errorSummary = "Unknown error";
         try {
           errorSummary = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
@@ -11095,12 +10748,6 @@ 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",
@@ -11140,6 +10787,24 @@ var plugin = {
                 exclusiveMinimum: DINGTALK_INTERACTIVE_CARD_TIMEOUT_EXCLUSIVE_MINIMUM
               }
             ]
+          },
+          {
+            key: "permissionCard",
+            label: "Permission Card",
+            kind: "object",
+            properties: [
+              {
+                key: "enabled",
+                label: "Enabled",
+                kind: "boolean"
+              },
+              {
+                key: "timeoutMs",
+                label: "Timeout (ms)",
+                kind: "number",
+                exclusiveMinimum: DINGTALK_INTERACTIVE_CARD_TIMEOUT_EXCLUSIVE_MINIMUM
+              }
+            ]
           }
         ]
       }