@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.2-nightly.20260909.2e212144d3

package/chunks/{dist-P6YWBITG.js → dist-6YDUH3BB.js}

@@ -14,7 +14,7 @@ import {
   sanitizePromptText,
   sanitizeSenderName,
   truncateUtf16Units
-} from "./chunk-65GHQ4FX.js";
+} from "./chunk-WDVV3LRM.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import "./chunk-DMTGGOSA.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)
     }
   };
 }
@@ -6933,6 +6940,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 +7044,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 +7193,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 +7229,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 +7298,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 +7325,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 +7374,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 +7577,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 +7606,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
         }
       });
@@ -7843,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");
 }
@@ -7905,6 +8335,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,11 +8441,36 @@ 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 {
+        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)
       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;
@@ -8017,16 +8478,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);
@@ -8164,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) {
@@ -8388,9 +8850,15 @@ var BACKGROUND_RESPONSE_AGGREGATION_MAX_RETRIES = 3;
 var ACK_REACTION_NAME = "\u{1F440}";
 var ACK_EMOTION_ID = "2659900";
 var ACK_EMOTION_BG_ID = "im_bg_1";
+var STATUS_EMOTION_ID = "34019";
+var STATUS_EMOTION_BG_ID = "im_bg_6";
+var DONE_EMOTION_ID = "54054";
+var DONE_EMOTION_BG_ID = "im_bg_5";
 var EMOTION_API = "https://api.dingtalk.com/v1.0/robot/emotion";
 var EMOTION_MAX_ATTEMPTS = 3;
 var EMOTION_RETRY_BASE_DELAY_MS = 250;
+var EMOTION_FETCH_TIMEOUT_MS = 15e3;
+var EMOTION_FINISH_MAX_ATTEMPTS = 3;
 var GROUP_MSG_API = "https://api.dingtalk.com/v1.0/robot/groupMessages/send";
 var DIRECT_MSG_API = "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend";
 var PROACTIVE_MSG_KEY = "sampleMarkdown";
@@ -8518,6 +8986,26 @@ var FILE_INSTRUCTIONS = [
   "File paths containing ] are not supported.",
   "Do not claim delivery succeeded; DingTalk shows successful files separately and reports failures in the final text."
 ].join("\n");
+function statusEmotionTag(name) {
+  return {
+    name,
+    emotionId: STATUS_EMOTION_ID,
+    backgroundId: STATUS_EMOTION_BG_ID
+  };
+}
+__name(statusEmotionTag, "statusEmotionTag");
+var EYE_TAG = {
+  name: ACK_REACTION_NAME,
+  emotionId: ACK_EMOTION_ID,
+  backgroundId: ACK_EMOTION_BG_ID
+};
+var DONE_TAG = {
+  name: "\u2705 Done",
+  emotionId: DONE_EMOTION_ID,
+  backgroundId: DONE_EMOTION_BG_ID
+};
+var FAILED_TAG = statusEmotionTag("\u274C Failed");
+var STOPPED_TAG = statusEmotionTag("\u23F9\uFE0F Stopped");
 function collectNonBotMentionIds(data) {
   if (!Array.isArray(data.atUsers) || typeof data.chatbotUserId !== "string") {
     return [];
@@ -8585,6 +9073,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   }
   client;
   atSender;
+  displayLanguage;
   connectionManager;
   seenMessages = /* @__PURE__ */ new Map();
   mentionTargets = /* @__PURE__ */ new Map();
@@ -8595,8 +9084,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
@@ -8613,6 +9105,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   interactiveCardClient;
   statusCardController;
   questionCardController;
+  permissionCardController;
   interactionPresenter;
   inboundCardOwners = /* @__PURE__ */ new Map();
   cardRunBySession = /* @__PURE__ */ new Map();
@@ -8621,14 +9114,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();
@@ -8636,6 +9121,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   constructor(name, config, bridge, options) {
     super(name, config, bridge, options);
     this.atSender = config["atSender"] === true;
+    this.displayLanguage = options?.displayLanguage;
     if (!this.config.instructions) {
       this.config.instructions = [
         "## DingTalk Channel",
@@ -8646,7 +9132,7 @@ 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);
@@ -8674,11 +9160,12 @@ 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"),
           ...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)}
 `);
@@ -8697,13 +9184,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,
-          ...config.blockStreaming !== "on" ? {
-            sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId, sourceLabel) => this.sendFallbackReply(chatId, text, sessionId, sourceLabel), "sendFallback")
-          } : {}
+          permissionCards: this.permissionCardController,
+          ...options?.displayLanguage ? { language: options.displayLanguage } : {},
+          sendFallback: /* @__PURE__ */ __name((chatId, text, sessionId, sourceLabel) => this.sendFallbackReply(chatId, text, sessionId, sourceLabel), "sendFallback")
         });
       }
     }
@@ -8787,7 +9286,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
     };
@@ -8999,9 +9502,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]");
@@ -9240,20 +9740,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);
@@ -9351,14 +9860,14 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   getAccessToken() {
     return this.client.getConfig().access_token;
   }
-  async emotionApi(endpoint, msgId, conversationId) {
+  async emotionApi(endpoint, msgId, conversationId, tag) {
     const robotCode = this.config.clientId;
     if (!robotCode || !msgId || !conversationId)
-      return;
+      return false;
     try {
       const token = this.config.clientSecret ? await this.getProactiveToken() : this.getAccessToken();
       if (!token)
-        return;
+        return false;
       for (let attempt = 0; attempt < EMOTION_MAX_ATTEMPTS; attempt++) {
         const resp = await fetch(`${EMOTION_API}/${endpoint}`, {
           method: "POST",
@@ -9371,17 +9880,18 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
             openMsgId: msgId,
             openConversationId: conversationId,
             emotionType: 2,
-            emotionName: ACK_REACTION_NAME,
+            emotionName: tag.name,
             textEmotion: {
-              emotionId: ACK_EMOTION_ID,
-              emotionName: ACK_REACTION_NAME,
-              text: ACK_REACTION_NAME,
-              backgroundId: ACK_EMOTION_BG_ID
+              emotionId: tag.emotionId,
+              emotionName: tag.name,
+              text: tag.name,
+              backgroundId: tag.backgroundId
             }
-          })
+          }),
+          signal: AbortSignal.timeout(EMOTION_FETCH_TIMEOUT_MS)
         });
         if (resp.ok)
-          return;
+          return true;
         const isTransient = resp.status === 429 || resp.status >= 500;
         if (isTransient && attempt < EMOTION_MAX_ATTEMPTS - 1) {
           await resp.body?.cancel();
@@ -9391,25 +9901,31 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         const detail = sanitizeLogText(await resp.text().catch(() => ""), 500);
         process.stderr.write(`[DingTalk:${this.name}] emotion/${endpoint} failed after ${attempt + 1}/${EMOTION_MAX_ATTEMPTS} attempts: ${resp.status} ${detail}
 `);
-        return;
+        return false;
       }
     } catch {
     }
+    return false;
   }
-  async attachReaction(msgId, conversationId) {
-    await this.emotionApi("reply", msgId, conversationId);
+  async attachReaction(msgId, conversationId, tag = EYE_TAG) {
+    return this.emotionApi("reply", msgId, conversationId, tag);
   }
-  async recallReaction(msgId, conversationId) {
-    await this.emotionApi("recall", msgId, conversationId);
+  async recallReaction(msgId, conversationId, tag = EYE_TAG) {
+    return this.emotionApi("recall", msgId, conversationId, tag);
   }
   disconnect() {
     if (this.dedupTimer) {
       clearInterval(this.dedupTimer);
     }
+    const reactionStates = [...this.reactionStates.values()];
+    for (const state of reactionStates) {
+      this.finishReaction(state.chatId, state.messageId, state.sessionId);
+    }
     this.statusCardController?.dispose();
     this.drainBackgroundResponseAggregations();
     this.activeReactionKeys.clear();
     this.sessionReactionKeys.clear();
+    this.reactionStates.clear();
     if (this.connectionManager) {
       this.connectionManager.stop();
     } else {
@@ -9417,6 +9933,10 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
     process.stderr.write(`[DingTalk:${this.name}] Disconnected.
 `);
+    this.disconnectDrain = Promise.allSettled(reactionStates.map((state) => state.tail)).then(() => void 0);
+  }
+  waitForDisconnect() {
+    return this.disconnectDrain ?? Promise.resolve();
   }
   /** Stable API targets are conversation or user IDs, never webhook URLs. */
   isStableTargetId(chatId) {
@@ -9425,6 +9945,111 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   reactionKey(messageId, conversationId) {
     return `${conversationId}:${messageId}`;
   }
+  forgetReactionState(state) {
+    this.activeReactionKeys.delete(state.key);
+    if (this.reactionStates.get(state.key) === state) {
+      this.reactionStates.delete(state.key);
+    }
+    if (!state.sessionId)
+      return;
+    const keys = this.sessionReactionKeys.get(state.sessionId);
+    keys?.delete(state.key);
+    if (keys?.size === 0)
+      this.sessionReactionKeys.delete(state.sessionId);
+  }
+  enqueueReaction(state, operation) {
+    state.tail = state.tail.then(operation).catch((err) => {
+      this.logReactionFailure("lifecycle tag update", err);
+    });
+  }
+  scheduleReactionDrain(state) {
+    if (state.drainScheduled)
+      return;
+    state.drainScheduled = true;
+    this.enqueueReaction(state, async () => {
+      try {
+        await this.drainReactionState(state);
+      } finally {
+        state.drainScheduled = false;
+        if (this.reactionStates.get(state.key) === state && (state.finishing ? !state.finishBlocked : this.activeReactionKeys.has(state.key) && state.desiredStatusTag && state.desiredStatusTag.name !== state.statusTag?.name)) {
+          this.scheduleReactionDrain(state);
+        }
+      }
+    });
+  }
+  async drainReactionState(state) {
+    while (true) {
+      if (state.finishing) {
+        await this.finishReactionState(state);
+        return;
+      }
+      if (this.reactionStates.get(state.key) !== state || !this.activeReactionKeys.has(state.key)) {
+        return;
+      }
+      const desired = state.desiredStatusTag;
+      if (!desired || desired.name === state.statusTag?.name)
+        return;
+      const latched = state.failedTransition;
+      if (state.statusTag) {
+        const from = state.statusTag.name;
+        if (latched && latched.from === from && latched.to === desired.name) {
+          state.desiredStatusTag = state.statusTag;
+          return;
+        }
+        const revision2 = state.revision;
+        if (await this.recallReaction(state.messageId, state.chatId, state.statusTag) === false) {
+          state.failedTransition = { from, to: desired.name };
+          if (state.revision !== revision2)
+            continue;
+          state.desiredStatusTag = state.statusTag;
+          return;
+        }
+        state.failedTransition = void 0;
+        state.statusTag = void 0;
+        continue;
+      }
+      if (latched && latched.from === void 0 && latched.to === desired.name) {
+        state.desiredStatusTag = void 0;
+        return;
+      }
+      const revision = state.revision;
+      if (await this.attachReaction(state.messageId, state.chatId, desired) === false) {
+        state.failedTransition = { from: void 0, to: desired.name };
+        if (state.revision !== revision)
+          continue;
+        state.desiredStatusTag = void 0;
+        return;
+      }
+      state.failedTransition = void 0;
+      state.statusTag = desired;
+    }
+  }
+  async finishReactionState(state) {
+    let statusCleared = true;
+    if (state.statusTag) {
+      statusCleared = await this.recallReaction(state.messageId, state.chatId, state.statusTag) !== false;
+      if (statusCleared)
+        state.statusTag = void 0;
+    }
+    const eyeCleared = !state.eyeAttached || await this.recallReaction(state.messageId, state.chatId, EYE_TAG) !== false;
+    if (eyeCleared)
+      state.eyeAttached = false;
+    let terminalAttached = true;
+    if (state.terminalTag && statusCleared && eyeCleared) {
+      terminalAttached = await this.attachReaction(state.messageId, state.chatId, state.terminalTag) !== false;
+    }
+    if (!statusCleared || !eyeCleared || !terminalAttached) {
+      state.finishAttempts = (state.finishAttempts ?? 0) + 1;
+      if (state.finishAttempts >= EMOTION_FINISH_MAX_ATTEMPTS) {
+        this.logReactionFailure("reaction cleanup", `abandoned after ${state.finishAttempts} attempts`);
+        this.forgetReactionState(state);
+        return;
+      }
+      state.finishBlocked = true;
+      return;
+    }
+    this.forgetReactionState(state);
+  }
   rememberInboundMessageId(msgId) {
     this.inboundMessageIds.delete(msgId);
     this.inboundMessageIds.add(msgId);
@@ -9447,6 +10072,19 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     if (this.activeReactionKeys.has(key))
       return;
     this.activeReactionKeys.add(key);
+    const state = {
+      key,
+      messageId,
+      chatId,
+      ...sessionId ? { sessionId } : {},
+      desiredStatusTag: this.phaseReactionTag("thinking"),
+      finishing: false,
+      drainScheduled: false,
+      eyeAttached: false,
+      revision: 0,
+      tail: Promise.resolve()
+    };
+    this.reactionStates.set(key, state);
     if (sessionId) {
       let keys = this.sessionReactionKeys.get(sessionId);
       if (!keys) {
@@ -9455,39 +10093,71 @@ 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) {
-    this.blockProjectionArmed.delete(sessionId);
-    this.blockFileProjectors.delete(sessionId);
     for (const [runId, state] of this.fileProjectors) {
       if (state.sessionId === sessionId)
         this.fileProjectors.delete(runId);
@@ -9511,16 +10181,32 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     const keys = this.sessionReactionKeys.get(sessionId);
     if (keys) {
       this.sessionReactionKeys.delete(sessionId);
-      for (const [key, { messageId, chatId }] of keys) {
-        if (this.activeReactionKeys.delete(key)) {
-          void this.recallReaction(messageId, chatId).catch((err) => {
-            this.logReactionFailure("session-death reaction recall", err);
-          });
-        }
+      for (const { messageId, chatId } of keys.values()) {
+        this.finishReaction(chatId, messageId, sessionId);
       }
     }
     super.onSessionDied(sessionId);
   }
+  /**
+   * A crashed standalone bridge never settles its in-flight turns, so their
+   * transient tags and ticking status cards would otherwise assert a live
+   * turn forever. Finish the tags without a terminal result and terminalize
+   * the cards as interrupted. Session state stays: crash recovery restores
+   * the sessions on a fresh bridge.
+   */
+  onBridgeDisconnected() {
+    for (const [sessionId, keys] of this.sessionReactionKeys) {
+      this.sessionReactionKeys.delete(sessionId);
+      for (const { messageId, chatId } of keys.values()) {
+        this.finishReaction(chatId, messageId, sessionId);
+      }
+    }
+    for (const [sessionId, runId] of this.cardRunBySession) {
+      this.cardRunBySession.delete(sessionId);
+      this.interactionPresenter?.terminalizeRun(runId, "cancelled");
+      this.cardRuns.delete(runId);
+    }
+  }
   onSessionRetiring(sessionId) {
     this.drainBackgroundResponseAggregations(sessionId);
   }
@@ -9539,10 +10225,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") {
@@ -9587,7 +10281,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);
@@ -9650,35 +10343,9 @@ 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);
@@ -10231,51 +10898,21 @@ ${text}`;
     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.
+   * Body-identical to the base implementation — this override exists only to
+   * widen the signature, which the base seam does not declare. The background
+   * aggregation flush passes `prepared` so the body it already projected isn't
+   * projected a second time (that would re-upload its files), and
+   * `failOnHttpError` so a failed send throws instead of being swallowed,
+   * letting the flush capture the delivery plan for the next retry.
    */
   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);
+    await this.sendResponseMessage(chatId, text, sessionId, 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;
+    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, failOnHttpError);
   }
   async sendFallbackReply(chatId, text, sessionId, sourceLabel) {
     const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
@@ -10329,6 +10966,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).
@@ -10567,7 +11214,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);
@@ -10674,7 +11321,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);
@@ -10761,6 +11408,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
+              }
+            ]
           }
         ]
       }