@qwen-code/qwen-code 0.21.7 → 0.21.8

package/chunks/{dist-DPPHJAVL.js → dist-EEEQGCZA.js}

@@ -14,8 +14,9 @@ import {
   ChannelBase,
   ChannelProactiveDeliveryError,
   isChannelProactiveDeliveryError,
-  isTerminalTaskLifecycleType
-} from "./chunk-DIEFUBV6.js";
+  isTerminalTaskLifecycleType,
+  sanitizeSenderName
+} from "./chunk-DIWZNWZT.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-H6XPXXMH.js";
 import {
@@ -88996,8 +88997,443 @@ async function downloadMedia(messageId, fileKey, resourceType, accessToken) {
 }
 __name(downloadMedia, "downloadMedia");
 
+// packages/channels/feishu/dist/question-card-controller.js
+init_esbuild_shims();
+
+// packages/channels/feishu/dist/question-card.js
+init_esbuild_shims();
+var terminalLabels = {
+  processing: "\u6B63\u5728\u5904\u7406...",
+  submitted: "\u5DF2\u63D0\u4EA4",
+  cancelled: "\u5DF2\u53D6\u6D88",
+  expired: "\u5DF2\u8FC7\u671F"
+};
+function buildQuestionCard(context) {
+  const elements = [];
+  for (const question of context.questions) {
+    const descriptions = question.options.map((option) => `> **${option.label}**: ${option.description}`).join("\n");
+    elements.push({
+      tag: "markdown",
+      text_size: "notation",
+      content: `**${question.header}**
+> ${question.question}
+
+${descriptions}`
+    });
+    elements.push({
+      tag: question.multiSelect ? "multi_select_static" : "select_static",
+      name: question.answerKey,
+      options: question.options.map((option) => ({
+        text: { tag: "plain_text", content: option.label },
+        value: option.label
+      }))
+    });
+  }
+  elements.push({
+    tag: "button",
+    text: { tag: "plain_text", content: "\u63D0\u4EA4" },
+    type: "primary",
+    name: `qwen_ask_submit_${context.requestId}`,
+    form_action_type: "submit",
+    value: {
+      action: "qwen_ask_submit",
+      operation_id: context.requestId
+    }
+  }, {
+    tag: "button",
+    text: { tag: "plain_text", content: "\u53D6\u6D88" },
+    name: `qwen_ask_cancel_${context.requestId}`,
+    value: {
+      action: "qwen_ask_cancel",
+      operation_id: context.requestId
+    }
+  });
+  return {
+    schema: "2.0",
+    body: { elements: [{ tag: "form", name: "qwen_ask_form", elements }] }
+  };
+}
+__name(buildQuestionCard, "buildQuestionCard");
+function buildQuestionTerminalCard(questions, state, answers) {
+  const details = questions.map((question) => {
+    const answer = answers?.[question.answerKey];
+    return answer ? `**${question.header}**
+${answer}` : `**${question.header}**
+${question.question}`;
+  }).join("\n\n");
+  return {
+    schema: "2.0",
+    body: {
+      elements: [
+        {
+          tag: "markdown",
+          content: `**${terminalLabels[state]}**
+
+${details}`
+        }
+      ]
+    }
+  };
+}
+__name(buildQuestionTerminalCard, "buildQuestionTerminalCard");
+function record(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+__name(record, "record");
+function nonEmptyString(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+__name(nonEmptyString, "nonEmptyString");
+function parseQuestionAction(data) {
+  const payload = record(data);
+  const action = record(payload?.["action"]);
+  const rawValue = action?.["value"];
+  const value = record(rawValue);
+  let requestId = nonEmptyString(value?.["operation_id"]);
+  let actionId = nonEmptyString(value?.["action"]);
+  const name = action?.["name"];
+  if (rawValue === void 0 && typeof name === "string" && name.startsWith("qwen_ask_submit_")) {
+    requestId = nonEmptyString(name.slice("qwen_ask_submit_".length));
+    actionId = requestId ? "qwen_ask_submit" : void 0;
+  }
+  if (rawValue === void 0 && typeof name === "string" && name.startsWith("qwen_ask_cancel_")) {
+    requestId = nonEmptyString(name.slice("qwen_ask_cancel_".length));
+    actionId = requestId ? "qwen_ask_cancel" : void 0;
+  }
+  if (!requestId || !actionId || typeof name !== "string") {
+    return { kind: "unhandled" };
+  }
+  const operator = record(payload?.["operator"]);
+  const operatorId = nonEmptyString(operator?.["open_id"]);
+  const operatorResult = operatorId ? { operatorId } : void 0;
+  const context = record(payload?.["context"]);
+  const chatId = nonEmptyString(context?.["open_chat_id"]) ?? nonEmptyString(payload?.["open_chat_id"]);
+  const messageId = nonEmptyString(context?.["open_message_id"]) ?? nonEmptyString(payload?.["open_message_id"]);
+  const correlation = {
+    ...chatId ? { chatId } : {},
+    ...messageId ? { messageId } : {}
+  };
+  if (actionId === "qwen_ask_submit" && name === `qwen_ask_submit_${requestId}`) {
+    const formValue = record(action?.["form_value"]);
+    return {
+      kind: "submit",
+      requestId,
+      ...operatorResult,
+      ...correlation,
+      ...formValue ? { formValue } : {}
+    };
+  }
+  if (actionId === "qwen_ask_cancel" && name === `qwen_ask_cancel_${requestId}`) {
+    return { kind: "cancel", requestId, ...operatorResult, ...correlation };
+  }
+  return { kind: "unhandled" };
+}
+__name(parseQuestionAction, "parseQuestionAction");
+function parseQuestionAnswers(questions, formValue) {
+  if (!formValue)
+    return void 0;
+  const answerKeys = new Set(questions.map((question) => question.answerKey));
+  const submittedKeys = Object.keys(formValue);
+  if (submittedKeys.length !== questions.length || submittedKeys.some((key) => !answerKeys.has(key))) {
+    return void 0;
+  }
+  const answers = {};
+  for (const question of questions) {
+    const rawAnswer = formValue[question.answerKey];
+    let values;
+    if (question.multiSelect) {
+      if (Array.isArray(rawAnswer)) {
+        values = rawAnswer;
+      } else if (typeof rawAnswer === "string") {
+        try {
+          const parsed = JSON.parse(rawAnswer);
+          if (!Array.isArray(parsed))
+            return void 0;
+          values = parsed;
+        } catch {
+          return void 0;
+        }
+      } else {
+        return void 0;
+      }
+    } else if (typeof rawAnswer === "string" && rawAnswer) {
+      values = [rawAnswer];
+    } else {
+      return void 0;
+    }
+    if (values.length === 0 || !question.multiSelect && values.length !== 1 || question.multiSelect && new Set(values).size !== values.length || values.some((value) => typeof value !== "string" || !question.options.some((option) => option.label === value))) {
+      return void 0;
+    }
+    answers[question.answerKey] = values.join(", ");
+  }
+  return answers;
+}
+__name(parseQuestionAnswers, "parseQuestionAnswers");
+
+// packages/channels/feishu/dist/question-card-controller.js
+var FeishuQuestionCardController = class {
+  static {
+    __name(this, "FeishuQuestionCardController");
+  }
+  options;
+  byRequest = /* @__PURE__ */ new Map();
+  activeByScope = /* @__PURE__ */ new Map();
+  disposed = false;
+  constructor(options) {
+    this.options = options;
+  }
+  async present(context) {
+    if (this.disposed)
+      return { kind: "unsupported" };
+    const scopeKey = this.scopeKey(context);
+    const active = this.activeByScope.get(scopeKey);
+    if (active && active.state !== "terminal")
+      return { kind: "unsupported" };
+    const record2 = {
+      context,
+      requestId: context.requestId,
+      runId: context.runId,
+      ownerId: context.owner.id,
+      chatId: context.target.chatId,
+      scopeKey,
+      state: "reserved"
+    };
+    this.byRequest.set(context.requestId, record2);
+    this.activeByScope.set(scopeKey, record2);
+    const unsubscribe = context.onSettled((reason) => {
+      if (record2.state !== "claimed" || !record2.responding) {
+        void this.finalize(record2, reason === "resolved_outside_presenter" ? "expired" : "cancelled");
+      }
+    });
+    record2.unsubscribe = unsubscribe;
+    if (record2.state === "terminal") {
+      unsubscribe();
+      record2.unsubscribe = void 0;
+      return { kind: "presented" };
+    }
+    try {
+      const messageId = await this.options.sendCard(record2.chatId, buildQuestionCard(context));
+      if (!messageId)
+        throw new Error("Feishu card delivery returned no message id");
+      if (record2.state !== "reserved" || this.byRequest.get(record2.requestId) !== record2 || this.activeByScope.get(record2.scopeKey) !== record2) {
+        await this.projectTerminal(record2, messageId);
+        return { kind: "presented" };
+      }
+      record2.messageId = messageId;
+    } catch (error) {
+      if (this.isTerminated(record2))
+        return { kind: "presented" };
+      this.options.onError?.("question card delivery", error);
+      await this.finalize(record2, "cancelled");
+      try {
+        await this.options.sendFallback(record2.chatId, this.fallbackText(record2.context));
+      } catch (fallbackError) {
+        this.options.onError?.("question fallback delivery", fallbackError);
+      }
+      try {
+        await context.respond({ outcome: { outcome: "cancelled" } });
+      } catch (respondError) {
+        this.options.onError?.("question delivery cancellation", respondError);
+      }
+      return { kind: "handled" };
+    }
+    record2.state = "pending";
+    record2.timer = setTimeout(() => {
+      void this.expire(record2);
+    }, this.options.timeoutMs);
+    record2.timer.unref?.();
+    return { kind: "presented" };
+  }
+  claim(data) {
+    const action = parseQuestionAction(data);
+    if (action.kind === "unhandled")
+      return { kind: "unhandled" };
+    const record2 = this.byRequest.get(action.requestId);
+    if (!record2 || record2.state !== "pending")
+      return this.expiredResponse();
+    if (!action.operatorId || !action.chatId || !action.messageId || action.operatorId !== record2.ownerId || action.chatId !== record2.chatId || action.messageId !== record2.messageId) {
+      return this.expiredResponse();
+    }
+    if (action.kind === "submit") {
+      const answers = parseQuestionAnswers(record2.context.questions, action.formValue);
+      if (!answers) {
+        return {
+          kind: "handled",
+          response: {
+            toast: { type: "warning", content: "\u8BF7\u5B8C\u6574\u9009\u62E9\u6709\u6548\u7B54\u6848\u3002" }
+          }
+        };
+      }
+      this.markClaimed(record2);
+      return {
+        kind: "handled",
+        response: {
+          toast: { type: "success", content: "\u7B54\u6848\u5DF2\u63D0\u4EA4\uFF0C\u6B63\u5728\u5904\u7406\u3002" },
+          card: {
+            type: "raw",
+            data: buildQuestionTerminalCard(record2.context.questions, "processing", answers)
+          }
+        },
+        execute: /* @__PURE__ */ __name(() => this.respond(record2, "submitted", answers), "execute")
+      };
+    }
+    this.markClaimed(record2);
+    record2.terminalDeliveredByClaim = true;
+    return {
+      kind: "handled",
+      response: {
+        toast: { type: "info", content: "\u5DF2\u53D6\u6D88\u3002" },
+        card: {
+          type: "raw",
+          data: buildQuestionTerminalCard(record2.context.questions, "cancelled")
+        }
+      },
+      execute: /* @__PURE__ */ __name(() => this.respond(record2, "cancelled"), "execute")
+    };
+  }
+  cancelRun(runId, terminalState = "cancelled") {
+    for (const record2 of [...this.byRequest.values()]) {
+      if (record2.runId === runId)
+        void this.finalize(record2, terminalState);
+    }
+  }
+  dispose() {
+    this.disposed = true;
+    for (const record2 of [...this.byRequest.values()]) {
+      record2.ignoreResponseProjection = true;
+      void this.finalize(record2, "expired");
+    }
+  }
+  async expire(record2) {
+    if (record2.state !== "pending")
+      return;
+    await this.finalize(record2, "expired");
+    try {
+      await record2.context.respond({ outcome: { outcome: "cancelled" } });
+    } catch (error) {
+      this.options.onError?.("expired question cancellation", error);
+    }
+  }
+  async respond(record2, terminalState, answers) {
+    if (record2.state !== "claimed")
+      return;
+    record2.responding = true;
+    try {
+      const accepted = await record2.context.respond(terminalState === "submitted" ? {
+        outcome: {
+          outcome: "selected",
+          optionId: record2.context.submitOptionId
+        },
+        answers
+      } : { outcome: { outcome: "cancelled" } });
+      record2.responding = false;
+      if (!accepted) {
+        this.options.onError?.("question response", new Error("Question response was no longer accepted"));
+      } else if (terminalState === "submitted") {
+        record2.terminalAnswers = answers;
+      }
+      await this.completeResponse(record2, accepted ? terminalState : "expired");
+    } catch (error) {
+      record2.responding = false;
+      this.options.onError?.("question response", error);
+      await this.completeResponse(record2, "expired");
+    }
+  }
+  isTerminated(record2) {
+    return record2.state === "terminal";
+  }
+  async finalize(record2, terminalState) {
+    if (record2.state === "terminal")
+      return;
+    record2.state = "terminal";
+    record2.terminalState = terminalState;
+    if (record2.timer)
+      clearTimeout(record2.timer);
+    record2.timer = void 0;
+    record2.unsubscribe?.();
+    record2.unsubscribe = void 0;
+    this.byRequest.delete(record2.requestId);
+    if (this.activeByScope.get(record2.scopeKey) === record2) {
+      this.activeByScope.delete(record2.scopeKey);
+    }
+    await this.projectTerminal(record2);
+  }
+  async completeResponse(record2, terminalState) {
+    if (record2.state !== "terminal") {
+      await this.finalize(record2, terminalState);
+      return;
+    }
+    if (record2.ignoreResponseProjection)
+      return;
+    if (terminalState === "expired" && record2.terminalState)
+      return;
+    record2.terminalState = terminalState;
+    await this.projectTerminal(record2);
+  }
+  projectTerminal(record2, messageId = record2.messageId) {
+    if (!messageId || !record2.terminalState)
+      return Promise.resolve();
+    if (record2.terminalDeliveredByClaim)
+      return Promise.resolve();
+    const terminalState = record2.terminalState;
+    const answers = record2.terminalAnswers;
+    const card = buildQuestionTerminalCard(record2.context.questions, terminalState, answers);
+    const projection = (record2.projection ?? Promise.resolve()).then(async () => {
+      let patched = false;
+      try {
+        patched = await this.options.patchCard(messageId, card);
+        if (!patched) {
+          this.options.onError?.("question card finalization", new Error("Feishu card patch was not accepted"));
+        }
+      } catch (error) {
+        this.options.onError?.("question card finalization", error);
+      }
+      if (!patched) {
+        const details = record2.context.questions.map((question) => {
+          const answer = answers?.[question.answerKey];
+          return `${question.header}: ${answer ?? question.question}`;
+        }).join("\n");
+        try {
+          await this.options.sendFallback(record2.chatId, `${terminalLabels[terminalState]}
+${details}`);
+        } catch (fallbackError) {
+          this.options.onError?.("question terminal fallback delivery", fallbackError);
+        }
+      }
+    });
+    record2.projection = projection;
+    return projection;
+  }
+  expiredResponse() {
+    return {
+      kind: "handled",
+      response: {
+        toast: { type: "warning", content: "\u8BE5\u95EE\u9898\u5DF2\u8FC7\u671F\u6216\u5DF2\u5904\u7406\u3002" }
+      }
+    };
+  }
+  markClaimed(record2) {
+    record2.state = "claimed";
+    if (record2.timer)
+      clearTimeout(record2.timer);
+    record2.timer = void 0;
+  }
+  scopeKey(context) {
+    return `${context.sessionId}\0${context.owner.id}`;
+  }
+  fallbackText(context) {
+    const questions = context.questions.map((question) => `- ${question.question}: ${question.options.map((option) => option.label).join(", ")}`).join("\n");
+    return `\u4E92\u52A8\u95EE\u9898\u5361\u7247\u6295\u9012\u5931\u8D25\uFF0C\u8BE5\u8BF7\u6C42\u5DF2\u53D6\u6D88\uFF0C\u8BF7\u91CD\u8BD5\u3002
+${questions}`;
+  }
+};
+
 // packages/channels/feishu/dist/FeishuAdapter.js
 var DEDUP_TTL_MS = 5 * 60 * 1e3;
+var OBSERVED_LABEL_CACHE_LIMIT = 500;
 var CARD_UPDATE_INTERVAL_MS = 1500;
 var FEISHU_RUNNING_STATUS_LABEL = "\u8FD0\u884C\u4E2D...";
 var FEISHU_STOPPED_STATUS_LABEL = "\u5DF2\u505C\u6B62\u751F\u6210";
@@ -89023,6 +89459,17 @@ var FEISHU_STATUS_LABELS = `(?:${FEISHU_STATUS_STRINGS.map(escapeRegExp).join("|
 var FEISHU_STATUS_BLOCK_RE = new RegExp(`(?:^|\\n)---\\n\\*${FEISHU_STATUS_LABELS}\\*(?=\\n|$)`, "g");
 var BASE_URL2 = "https://open.feishu.cn/open-apis";
 var FEISHU_ID_RE2 = /^[a-zA-Z0-9_.:-]+$/;
+var FeishuCardDeliveryError = class extends Error {
+  static {
+    __name(this, "FeishuCardDeliveryError");
+  }
+  detail;
+  constructor(message, detail) {
+    super(message);
+    this.detail = detail;
+    this.name = "FeishuCardDeliveryError";
+  }
+};
 var FeishuChannel = class extends ChannelBase {
   static {
     __name(this, "FeishuChannel");
@@ -89047,6 +89494,16 @@ var FeishuChannel = class extends ChannelBase {
   botOpenId;
   tokenCache;
   tokenRefreshPromise;
+  questionCardController;
+  // Core (non-silent) callers waiting on the shared token refresh, so a
+  // silent-initiated refresh still logs token errors for them.
+  tokenRefreshHasCoreWaiters = false;
+  observedUserNames = /* @__PURE__ */ new Map();
+  observedChatNames = /* @__PURE__ */ new Map();
+  observedUserLookups = /* @__PURE__ */ new Map();
+  observedChatLookups = /* @__PURE__ */ new Map();
+  observedContactWrites = /* @__PURE__ */ new Map();
+  hydratedObservedNames = false;
   collapsible;
   collapsibleThreshold;
   constructor(name, config, bridge, options) {
@@ -89057,6 +89514,16 @@ var FeishuChannel = class extends ChannelBase {
     const feishuCfg = config;
     this.collapsible = feishuCfg["collapsible"] || false;
     this.collapsibleThreshold = feishuCfg["collapsibleThreshold"] || 500;
+    this.questionCardController = new FeishuQuestionCardController({
+      timeoutMs: 27e4,
+      sendCard: /* @__PURE__ */ __name((chatId, card) => this.sendInteractiveCard(chatId, card), "sendCard"),
+      patchCard: /* @__PURE__ */ __name((messageId, card) => this.patchInteractiveCard(messageId, card), "patchCard"),
+      sendFallback: /* @__PURE__ */ __name((chatId, text) => this.sendMessageInternal(chatId, text, true), "sendFallback"),
+      onError: /* @__PURE__ */ __name((operation, error) => {
+        process.stderr.write(`[Feishu:${this.name}] ${operation} error: ${error instanceof Error ? error.message : error}
+`);
+      }, "onError")
+    });
   }
   supportsProactiveSend() {
     return true;
@@ -89072,6 +89539,19 @@ var FeishuChannel = class extends ChannelBase {
       "card.action.trigger": /* @__PURE__ */ __name((data) => {
         const payload = data;
         this.logDebugPayload("Feishu", payload);
+        const question = this.questionCardController.claim(payload);
+        if (question.kind === "handled") {
+          const execute = question.execute;
+          if (execute) {
+            setImmediate(() => {
+              execute().catch((error) => {
+                process.stderr.write(`[Feishu:${this.name}] question action execution error: ${error instanceof Error ? error.message : error}
+`);
+              });
+            });
+          }
+          return question.response;
+        }
         const stopped = this.onCardAction(payload);
         if (stopped) {
           return { toast: { type: "info", content: "\u5DF2\u505C\u6B62" } };
@@ -89385,10 +89865,12 @@ var FeishuChannel = class extends ChannelBase {
     text = text.replace(/^好的，<at[^>]*><\/at>\s*\n*/, "");
     return text.trim() || void 0;
   }
-  async getTenantAccessToken() {
+  async getTenantAccessToken(options) {
     if (this.tokenCache && Date.now() < this.tokenCache.expiresAt) {
       return this.tokenCache.token;
     }
+    if (!options?.silent)
+      this.tokenRefreshHasCoreWaiters = true;
     if (this.tokenRefreshPromise)
       return this.tokenRefreshPromise;
     this.tokenRefreshPromise = this.refreshToken();
@@ -89396,6 +89878,7 @@ var FeishuChannel = class extends ChannelBase {
       return await this.tokenRefreshPromise;
     } finally {
       this.tokenRefreshPromise = void 0;
+      this.tokenRefreshHasCoreWaiters = false;
     }
   }
   async refreshToken() {
@@ -89410,8 +89893,10 @@ var FeishuChannel = class extends ChannelBase {
         signal: AbortSignal.timeout(15e3)
       });
       if (!resp.ok) {
-        process.stderr.write(`[Feishu:${this.name}] getTenantAccessToken failed: HTTP ${resp.status}
+        if (this.tokenRefreshHasCoreWaiters) {
+          process.stderr.write(`[Feishu:${this.name}] getTenantAccessToken failed: HTTP ${resp.status}
 `);
+        }
         if (resp.status === 401)
           this.tokenCache = void 0;
         return void 0;
@@ -89424,11 +89909,172 @@ var FeishuChannel = class extends ChannelBase {
       };
       return this.tokenCache.token;
     } catch (err) {
-      process.stderr.write(`[Feishu:${this.name}] getTenantAccessToken error: ${err}
+      if (this.tokenRefreshHasCoreWaiters) {
+        process.stderr.write(`[Feishu:${this.name}] getTenantAccessToken error: ${err}
 `);
+      }
       return void 0;
     }
   }
+  hydrateObservedNames() {
+    if (this.hydratedObservedNames)
+      return;
+    this.hydratedObservedNames = true;
+    const graph = this.persistedObservedContacts();
+    if (!graph)
+      return;
+    const newestUser = /* @__PURE__ */ new Map();
+    const newestChat = /* @__PURE__ */ new Map();
+    const consider = /* @__PURE__ */ __name((best, id, label, at) => {
+      if (label === id)
+        return;
+      const current = best.get(id);
+      if (!current || at >= current.at)
+        best.set(id, { label, at });
+    }, "consider");
+    for (const user of graph.users) {
+      consider(newestUser, user.id, user.label, user.lastObservedAt);
+    }
+    for (const group of graph.groups) {
+      consider(newestChat, group.id, group.label, group.lastObservedAt);
+      for (const member of group.users) {
+        consider(newestUser, member.id, member.label, member.lastObservedAt);
+      }
+    }
+    for (const [id, entry] of newestUser) {
+      this.observedUserNames.set(id, entry.label);
+    }
+    for (const [id, entry] of newestChat) {
+      this.observedChatNames.set(id, entry.label);
+    }
+    this.capObservedCache(this.observedUserNames);
+    this.capObservedCache(this.observedChatNames);
+  }
+  /** Evicts the oldest-inserted entries once a runtime cache exceeds the cap. */
+  capObservedCache(cache) {
+    let evicted = false;
+    while (cache.size > OBSERVED_LABEL_CACHE_LIMIT) {
+      const oldest = cache.keys().next();
+      if (oldest.done)
+        break;
+      cache.delete(oldest.value);
+      evicted = true;
+    }
+    return evicted;
+  }
+  observedUserName(userId) {
+    const userIdType = userId.startsWith("ou_") ? "open_id" : userId.startsWith("on_") ? "union_id" : "user_id";
+    return this.observedNameLookup({
+      lookups: this.observedUserLookups,
+      names: this.observedUserNames,
+      id: userId,
+      request: /* @__PURE__ */ __name((token) => fetch(`${BASE_URL2}/contact/v3/users/basic_batch?user_id_type=${userIdType}`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ user_ids: [userId] }),
+        signal: AbortSignal.timeout(15e3)
+      }), "request"),
+      extractName: /* @__PURE__ */ __name((body) => {
+        const data = body;
+        return data.code === 0 ? data.data?.users?.[0]?.name : void 0;
+      }, "extractName")
+    });
+  }
+  observedChatName(chatId) {
+    return this.observedNameLookup({
+      lookups: this.observedChatLookups,
+      names: this.observedChatNames,
+      id: chatId,
+      request: /* @__PURE__ */ __name((token) => fetch(`${BASE_URL2}/im/v1/chats/${encodeURIComponent(chatId)}`, {
+        headers: { Authorization: `Bearer ${token}` },
+        signal: AbortSignal.timeout(15e3)
+      }), "request"),
+      extractName: /* @__PURE__ */ __name((body) => {
+        const data = body;
+        return data.code === 0 ? data.data?.name : void 0;
+      }, "extractName")
+    });
+  }
+  observedNameLookup(options) {
+    const cached = options.names.get(options.id);
+    if (cached)
+      return Promise.resolve(cached);
+    const existing = options.lookups.get(options.id);
+    if (existing)
+      return existing;
+    const lookup = (async () => {
+      try {
+        const token = await this.getTenantAccessToken({ silent: true });
+        if (!token) {
+          options.lookups.delete(options.id);
+          return void 0;
+        }
+        const response = await options.request(token);
+        if (!response.ok) {
+          if (response.status === 401) {
+            this.tokenCache = void 0;
+            options.lookups.delete(options.id);
+          }
+          return void 0;
+        }
+        const name = options.extractName(await response.json())?.trim();
+        if (!name)
+          return void 0;
+        const label = sanitizeSenderName(name);
+        if (label === "unknown")
+          return void 0;
+        options.names.set(options.id, label);
+        if (this.capObservedCache(options.names)) {
+          this.hydratedObservedNames = false;
+        }
+        return label;
+      } catch {
+        return void 0;
+      }
+    })();
+    options.lookups.set(options.id, lookup);
+    this.capObservedCache(options.lookups);
+    return lookup;
+  }
+  onObservedContact(envelope) {
+    this.observedContactWrites.set(this.observedContactKey(envelope), {
+      senderName: envelope.senderName,
+      chatName: envelope.chatName
+    });
+    this.capObservedCache(this.observedContactWrites);
+    void this.enrichObservedContact(envelope).catch(() => {
+    });
+  }
+  observedContactKey(envelope) {
+    return envelope.isGroup ? `${envelope.senderId}\0${envelope.chatId}\0${envelope.threadId ?? ""}` : envelope.senderId;
+  }
+  async enrichObservedContact(envelope) {
+    const [senderName, chatName] = await Promise.all([
+      this.observedUserName(envelope.senderId),
+      envelope.isGroup ? this.observedChatName(envelope.chatId) : Promise.resolve(void 0)
+    ]);
+    if (!senderName && !chatName)
+      return;
+    const key = this.observedContactKey(envelope);
+    const nextLabels = {
+      senderName: senderName ?? envelope.senderName,
+      chatName: chatName ?? envelope.chatName
+    };
+    const persistedLabels = this.observedContactWrites.get(key);
+    if (persistedLabels && persistedLabels.senderName === nextLabels.senderName && persistedLabels.chatName === nextLabels.chatName) {
+      return;
+    }
+    this.observedContactWrites.set(key, nextLabels);
+    this.capObservedCache(this.observedContactWrites);
+    await this.recordObservedContact({
+      ...envelope,
+      ...senderName ? { senderName } : {},
+      ...chatName ? { chatName } : {}
+    });
+  }
   async sendMessage(chatId, text) {
     await this.sendMessageInternal(chatId, text, false);
   }
@@ -89502,65 +90148,40 @@ var FeishuChannel = class extends ChannelBase {
     }
   }
   // ----- Interactive Card Streaming -----
-  async createStreamingCard(chatId, text, title, inboundMsgId) {
+  async sendInteractiveCard(chatId, card) {
     const token = await this.getTenantAccessToken();
     if (!token)
-      return { messageId: "", success: false };
-    const cardTitle = title || inboundMsgId && this.msgToQuestion.get(inboundMsgId) || "Qwen";
-    const card = buildCardContent(text, {
-      title: cardTitle,
-      showStopButton: true,
-      isStreaming: true,
-      statusLabel: this.statusLabelFor(),
-      collapsible: this.collapsible,
-      collapsibleThreshold: this.collapsibleThreshold
+      throw new FeishuCardDeliveryError("Feishu card delivery failed: no access token");
+    const resp = await fetch(`${BASE_URL2}/im/v1/messages?receive_id_type=chat_id`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        receive_id: chatId,
+        msg_type: "interactive",
+        content: JSON.stringify(card)
+      }),
+      signal: AbortSignal.timeout(15e3)
     });
-    const body = {
-      receive_id: chatId,
-      msg_type: "interactive",
-      content: JSON.stringify(card)
-    };
-    try {
-      const resp = await fetch(`${BASE_URL2}/im/v1/messages?receive_id_type=chat_id`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${token}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(15e3)
-      });
-      if (!resp.ok) {
-        if (resp.status === 401)
-          this.tokenCache = void 0;
-        const detail = await resp.text().catch(() => "");
-        process.stderr.write(`[Feishu:${this.name}] createStreamingCard failed: HTTP ${resp.status} ${detail}
-`);
-        return { messageId: "", success: false };
-      }
-      const data = await resp.json();
-      const messageId = data.data?.message_id || "";
-      return { messageId, success: !!messageId };
-    } catch (err) {
-      process.stderr.write(`[Feishu:${this.name}] createStreamingCard error: ${err}
-`);
-      return { messageId: "", success: false };
+    if (!resp.ok) {
+      if (resp.status === 401)
+        this.tokenCache = void 0;
+      const detail = await resp.text().catch(() => "");
+      const errorDetail = `HTTP ${resp.status} ${detail}`;
+      throw new FeishuCardDeliveryError(`Feishu card delivery failed: ${errorDetail}`, errorDetail);
+    }
+    const data = await resp.json();
+    const messageId = data.data?.message_id;
+    if (!messageId) {
+      throw new FeishuCardDeliveryError("Feishu card delivery returned no message id");
     }
+    return messageId;
   }
-  async updateCard(messageId, text, finished = false, inboundMsgId, statusLabel) {
+  async patchInteractiveCard(messageId, card) {
     const token = await this.getTenantAccessToken();
-    if (!token)
-      return false;
-    const cardTitle = inboundMsgId ? this.msgToQuestion.get(inboundMsgId) || "Qwen" : "Qwen";
-    const card = buildCardContent(text, {
-      title: cardTitle,
-      showStopButton: !finished,
-      isStreaming: !finished,
-      statusLabel: statusLabel ?? (!finished ? this.statusLabelFor() : void 0),
-      collapsible: this.collapsible,
-      collapsibleThreshold: this.collapsibleThreshold
-    });
-    if (!FEISHU_ID_RE2.test(messageId))
+    if (!token || !FEISHU_ID_RE2.test(messageId))
       return false;
     try {
       const resp = await fetch(`${BASE_URL2}/im/v1/messages/${messageId}`, {
@@ -89590,6 +90211,52 @@ var FeishuChannel = class extends ChannelBase {
       return false;
     }
   }
+  async createStreamingCard(chatId, text, title, inboundMsgId) {
+    const cardTitle = title || inboundMsgId && this.msgToQuestion.get(inboundMsgId) || "Qwen";
+    const card = buildCardContent(text, {
+      title: cardTitle,
+      showStopButton: true,
+      isStreaming: true,
+      statusLabel: this.statusLabelFor(),
+      collapsible: this.collapsible,
+      collapsibleThreshold: this.collapsibleThreshold
+    });
+    try {
+      const messageId = await this.sendInteractiveCard(chatId, card);
+      return { messageId, success: true };
+    } catch (err) {
+      if (err instanceof FeishuCardDeliveryError) {
+        process.stderr.write(`[Feishu:${this.name}] createStreamingCard failed: ${err.detail ?? err.message}
+`);
+        return { messageId: "", success: false };
+      }
+      process.stderr.write(`[Feishu:${this.name}] createStreamingCard error: ${err}
+`);
+      return { messageId: "", success: false };
+    }
+  }
+  async updateCard(messageId, text, finished = false, inboundMsgId, statusLabel) {
+    const cardTitle = inboundMsgId ? this.msgToQuestion.get(inboundMsgId) || "Qwen" : "Qwen";
+    const card = buildCardContent(text, {
+      title: cardTitle,
+      showStopButton: !finished,
+      isStreaming: !finished,
+      statusLabel: statusLabel ?? (!finished ? this.statusLabelFor() : void 0),
+      collapsible: this.collapsible,
+      collapsibleThreshold: this.collapsibleThreshold
+    });
+    return this.patchInteractiveCard(messageId, card);
+  }
+  async presentUserInputRequest(context) {
+    if (!context.precedingSegmentId) {
+      const inboundMsgId = this.sessionToInboundMsg.get(context.sessionId);
+      const cardState = inboundMsgId ? this.cardSessions.get(inboundMsgId) : void 0;
+      if (inboundMsgId && cardState) {
+        await this.endOutputCardBeforeInputRequest(context.target.chatId, inboundMsgId, cardState);
+      }
+    }
+    return this.questionCardController.present(context);
+  }
   /** Delete a card message from Feishu to prevent orphaned "思考中..." cards. */
   async deleteCard(messageId) {
     const token = await this.getTenantAccessToken();
@@ -89641,6 +90308,7 @@ var FeishuChannel = class extends ChannelBase {
     }
     if (cardState.stopped)
       return;
+    cardState.boundaryText = void 0;
     const MAX_ACCUMULATE = 25e3;
     cardState.accumulatedText += chunk;
     if (cardState.accumulatedText.length > MAX_ACCUMULATE) {
@@ -89650,12 +90318,14 @@ var FeishuChannel = class extends ChannelBase {
       return;
     if (!cardState.created && !cardState.cardCreationFailed) {
       cardState.creating = true;
+      cardState.lastUpdateAt = Date.now();
       const cs = cardState;
       cardState.creationTimer = setTimeout(async () => {
         try {
           if (cs.stopped || this.stoppedMessages.has(inboundMsgId)) {
             cs.creating = false;
-            this.cleanupCard(inboundMsgId);
+            if (!cs.abandoned)
+              this.cleanupCard(inboundMsgId);
             return;
           }
           const atPrefix = this.msgToSenderName.get(inboundMsgId);
@@ -89702,36 +90372,50 @@ ${cs.accumulatedText}` : cs.accumulatedText;
       const cs = cardState;
       const elapsed = Date.now() - cardState.lastUpdateAt;
       const delay = Math.max(0, CARD_UPDATE_INTERVAL_MS - elapsed);
-      cardState.pendingUpdateTimer = setTimeout(async () => {
+      cardState.pendingUpdateTimer = setTimeout(() => {
         cs.pendingUpdateTimer = void 0;
         if (cs.stopped || cs.finalizing)
           return;
         cs.lastUpdateAt = Date.now();
-        try {
-          const MAX_CARD_CHARS = 2e4;
-          const atPrefix = this.msgToSenderName.get(inboundMsgId);
-          let displayContent = atPrefix ? `${atPrefix}
-
-${cs.accumulatedText}` : cs.accumulatedText;
-          if (displayContent.length > MAX_CARD_CHARS) {
-            const marker = "\n\n_(\u5185\u5BB9\u8FC7\u957F\uFF0C\u5DF2\u622A\u65AD\u65E9\u671F\u5185\u5BB9)_";
-            displayContent = displayContent.slice(-(MAX_CARD_CHARS - marker.length)) + marker;
-            if (this.countFences(displayContent) % 2 === 1) {
-              displayContent = "```\n" + displayContent;
-            }
-          }
-          const ok = await this.updateCard(cs.messageId, displayContent, false, inboundMsgId);
-          if (!ok) {
-            const stripped = this.stripTables(displayContent, "(\u8868\u683C)");
-            await this.updateCard(cs.messageId, stripped, false, inboundMsgId);
-          }
-        } catch (err) {
+        if (cs.pendingUpdatePromise) {
+          cs.updateQueued = true;
+          return;
+        }
+        cs.pendingUpdatePromise = this.runThrottledCardUpdate(inboundMsgId, cs).catch((err) => {
           process.stderr.write(`[Feishu:${this.name}] card update error: ${err}
 `);
-        }
+        }).then(() => {
+          cs.pendingUpdatePromise = void 0;
+        });
       }, delay);
     }
   }
+  /** Runs one throttled streaming PATCH, then re-runs once when timer fires
+   *  coalesced behind it (`updateQueued`) so the latest buffer still goes out.
+   *  `pendingUpdatePromise` covers the whole chain so finalization can drain
+   *  every in-flight update before sending the final patch. */
+  async runThrottledCardUpdate(inboundMsgId, cs) {
+    if (cs.stopped || cs.finalizing)
+      return;
+    try {
+      const atPrefix = this.msgToSenderName.get(inboundMsgId);
+      const displayContent = this.truncateCardText(atPrefix ? `${atPrefix}
+
+${cs.accumulatedText}` : cs.accumulatedText);
+      const ok = await this.updateCard(cs.messageId, displayContent, false, inboundMsgId);
+      if (!ok && !cs.stopped && !cs.finalizing) {
+        const stripped = this.stripTables(displayContent, "(\u8868\u683C)");
+        await this.updateCard(cs.messageId, stripped, false, inboundMsgId);
+      }
+    } catch (err) {
+      process.stderr.write(`[Feishu:${this.name}] card update error: ${err}
+`);
+    }
+    if (cs.updateQueued) {
+      cs.updateQueued = false;
+      await this.runThrottledCardUpdate(inboundMsgId, cs);
+    }
+  }
   onResponseBoundary(_chatId, sessionId) {
     if (this.config.blockStreaming === "on")
       return;
@@ -89745,8 +90429,90 @@ ${cs.accumulatedText}` : cs.accumulatedText;
       clearTimeout(cardState.pendingUpdateTimer);
       cardState.pendingUpdateTimer = void 0;
     }
+    cardState.updateQueued = false;
+    if (cardState.accumulatedText) {
+      cardState.boundaryText = cardState.accumulatedText;
+    }
     cardState.accumulatedText = "";
   }
+  async onOutputSegmentEnd(chatId, sessionId, _segment, reason) {
+    if (reason === "response_boundary") {
+      this.onResponseBoundary(chatId, sessionId);
+      return;
+    }
+    if (reason !== "input_requested" || this.config.blockStreaming === "on") {
+      return;
+    }
+    const inboundMsgId = this.sessionToInboundMsg.get(sessionId);
+    if (!inboundMsgId)
+      return;
+    const cardState = this.cardSessions.get(inboundMsgId);
+    if (!cardState)
+      return;
+    await this.endOutputCardBeforeInputRequest(chatId, inboundMsgId, cardState);
+  }
+  async endOutputCardBeforeInputRequest(chatId, inboundMsgId, cardState) {
+    if (cardState.cancelling || cardState.stopped || cardState.finalizing || this.stoppedMessages.has(inboundMsgId)) {
+      return;
+    }
+    const atPrefix = this.msgToSenderName.get(inboundMsgId);
+    const text = cardState.accumulatedText || cardState.boundaryText || "";
+    const displayText = atPrefix ? text ? `${atPrefix}
+
+${text}` : atPrefix : text;
+    const completedSuffix = `
+
+---
+*${this.statusLabelFor("completed")}*`;
+    const prefixPart = atPrefix && text ? `${atPrefix}
+
+` : "";
+    const finalText = text ? prefixPart + this.truncateCardText(text, prefixPart.length + completedSuffix.length) : displayText;
+    try {
+      if (cardState.created && cardState.messageId && !cardState.stopped) {
+        cardState.finalizing = true;
+        if (cardState.pendingUpdateTimer) {
+          clearTimeout(cardState.pendingUpdateTimer);
+          cardState.pendingUpdateTimer = void 0;
+        }
+        if (cardState.pendingUpdatePromise) {
+          await cardState.pendingUpdatePromise;
+        }
+        let updated = false;
+        try {
+          if (await this.finalizeStoppedCardUpdate(inboundMsgId, cardState, chatId)) {
+            return;
+          }
+          updated = await this.updateCard(cardState.messageId, finalText, true, inboundMsgId, this.statusLabelFor("completed"));
+          if (!updated) {
+            const noTableText = this.stripTables(finalText, "(\u8868\u683C\u5185\u5BB9\u8BF7\u67E5\u770B\u539F\u6587)");
+            updated = await this.updateCard(cardState.messageId, noTableText, true, inboundMsgId, this.statusLabelFor("completed"));
+          }
+          if (await this.finalizeStoppedCardUpdate(inboundMsgId, cardState, chatId)) {
+            return;
+          }
+        } catch (error) {
+          process.stderr.write(`[Feishu:${this.name}] input-request card finalization error: ${error instanceof Error ? error.message : error}
+`);
+        }
+        if (!updated) {
+          await this.deleteCard(cardState.messageId);
+          if (displayText)
+            await this.sendMessage(chatId, displayText);
+        }
+      } else {
+        if (cardState.creating) {
+          cardState.stopped = true;
+          cardState.abandoned = true;
+        }
+        if (text) {
+          await this.sendMessage(chatId, displayText);
+        }
+      }
+    } finally {
+      this.releaseOutputCard(inboundMsgId);
+    }
+  }
   isKnownInboundMessageId(messageId) {
     return this.msgToQuestion.has(messageId) || this.msgToSenderName.has(messageId) || this.msgToSenderId.has(messageId) || this.cardSessions.has(messageId) || this.stoppedMessages.has(messageId);
   }
@@ -89791,6 +90557,9 @@ ${contentPart}` : contentPart;
     if (!isTerminalTaskLifecycleType(event.type)) {
       return;
     }
+    if (event.runId) {
+      this.questionCardController.cancelRun(event.runId, event.type === "cancelled" && (event.reason === "cancel_command" || event.reason === "clear") ? "cancelled" : "expired");
+    }
     const inboundMsgId = this.knownInboundMessageId(event.sessionId, event.messageId);
     if (!inboundMsgId)
       return;
@@ -89820,34 +90589,22 @@ ${contentPart}` : contentPart;
       return;
     }
     const atSender = this.msgToSenderName.get(inboundMsgId);
-    let displayText = atSender ? `${atSender}
-
-${fullText}` : fullText;
     const completedLabel = this.statusLabelFor("completed");
     const completedSuffix = `
 
 ---
 *${completedLabel}*`;
-    const MAX_FINAL_CARD_CHARS = 2e4;
-    if (displayText.length + completedSuffix.length > MAX_FINAL_CARD_CHARS) {
-      const prefix = atSender ? `${atSender}
+    const atPrefix = atSender ? `${atSender}
 
 ` : "";
-      const suffix = "\n\n_(\u5185\u5BB9\u8FC7\u957F\uFF0C\u5DF2\u622A\u65AD\u65E9\u671F\u5185\u5BB9)_";
-      const fenceReserve = 4;
-      const maxBody = MAX_FINAL_CARD_CHARS - prefix.length - suffix.length - completedSuffix.length - fenceReserve;
-      displayText = prefix + fullText.slice(-maxBody) + suffix;
-      if (this.countFences(displayText) % 2 === 1) {
-        displayText = "```\n" + displayText;
-      }
-    }
+    const displayText = atPrefix + this.truncateCardText(fullText, atPrefix.length + completedSuffix.length);
     if (cardState)
       cardState.finalizing = true;
     if (cardState?.pendingUpdateTimer) {
       clearTimeout(cardState.pendingUpdateTimer);
     }
-    if (cardState?.creationTimer) {
-      clearTimeout(cardState.creationTimer);
+    if (cardState?.pendingUpdatePromise) {
+      await cardState.pendingUpdatePromise;
     }
     if (cardState?.creating) {
       await new Promise((resolve) => {
@@ -89922,60 +90679,20 @@ ${fullText}` : fullText);
 
 ${fullText}` : fullText);
   }
-  onPromptStart(chatId, sessionId, messageId) {
+  onPromptStart(_chatId, sessionId, messageId) {
     const inboundMsgId = messageId && this.isKnownInboundMessageId(messageId) ? messageId : void 0;
     if (inboundMsgId) {
       this.sessionToInboundMsg.set(sessionId, inboundMsgId);
       this.addReaction(inboundMsgId, "OnIt").catch(() => {
       });
-      if (this.config.blockStreaming === "on")
-        return;
-      if (!this.cardSessions.has(inboundMsgId)) {
-        const atSender = this.msgToSenderName.get(inboundMsgId) || "";
-        const placeholderText = atSender ? `${atSender}\uFF0C\u601D\u8003\u4E2D...` : "\u601D\u8003\u4E2D...";
-        const cardState = {
+      if (this.config.blockStreaming !== "on" && !this.cardSessions.has(inboundMsgId)) {
+        this.cardSessions.set(inboundMsgId, {
           messageId: "",
           created: false,
-          creating: true,
+          creating: false,
           stopped: false,
           accumulatedText: "",
           lastUpdateAt: Date.now()
-        };
-        this.cardSessions.set(inboundMsgId, cardState);
-        this.createStreamingCard(chatId, placeholderText, void 0, inboundMsgId).then((result) => {
-          if (cardState.stopped || this.stoppedMessages.has(inboundMsgId)) {
-            if (cardState.abandoned) {
-              if (result.success) {
-                this.deleteCard(result.messageId).catch((err) => {
-                  process.stderr.write(`[Feishu:${this.name}] ORPHANED CARD: failed to delete abandoned card msg=${result.messageId}: ${err instanceof Error ? err.message : err}
-`);
-                });
-              }
-              cardState.creating = false;
-              return;
-            }
-            if (result.success) {
-              const prefix = cardState.atPrefix || this.msgToSenderName.get(inboundMsgId) || "";
-              this.updateCard(result.messageId, prefix, true, inboundMsgId, this.stopLabelFor(cardState.terminalStatus, cardState.userStopped ?? false)).catch(() => {
-              });
-            }
-            cardState.creating = false;
-            this.cleanupCard(inboundMsgId);
-            return;
-          }
-          if (result.success) {
-            cardState.messageId = result.messageId;
-            cardState.created = true;
-            cardState.lastUpdateAt = Date.now();
-          } else {
-            cardState.cardCreationFailed = true;
-          }
-          cardState.creating = false;
-        }).catch((err) => {
-          process.stderr.write(`[Feishu:${this.name}] Processing card error: ${err}
-`);
-          cardState.creating = false;
-          this.cleanupCard(inboundMsgId);
         });
       }
     }
@@ -89991,6 +90708,14 @@ ${fullText}` : fullText);
           cs.stopped = true;
         } else if (cs.created) {
           cs.stopped = true;
+          cs.finalizing = true;
+          if (cs.pendingUpdateTimer) {
+            clearTimeout(cs.pendingUpdateTimer);
+            cs.pendingUpdateTimer = void 0;
+          }
+          if (cs.pendingUpdatePromise) {
+            await cs.pendingUpdatePromise;
+          }
           const atPrefix = this.msgToSenderName.get(inboundMsgId) || "";
           const terminalStatus = cs.terminalStatus ?? (cs.cancelling ? "cancelled" : "failed");
           const terminalLabel = this.stopLabelFor(terminalStatus, cs.userStopped ?? false);
@@ -90008,7 +90733,7 @@ ${cs.accumulatedText}` : cs.accumulatedText : atPrefix || "";
 ${cs.accumulatedText}` : cs.accumulatedText;
             this.sendMessage(_chatId, fallbackText).catch(() => {
             });
-          } else {
+          } else if (cs.terminalStatus !== "completed") {
             const atPrefix = this.msgToSenderName.get(inboundMsgId) || "";
             const fallbackLabel = cs.terminalStatus ? this.statusLabelFor(cs.terminalStatus) : "\u51FA\u9519\u4E86\uFF0C\u8BF7\u91CD\u8BD5";
             const errorText = atPrefix ? `${atPrefix}
@@ -90148,6 +90873,13 @@ ${cs.accumulatedText}` : cs.accumulatedText;
         }
         if (cardState.finalizing)
           return;
+        if (cardState.pendingUpdateTimer) {
+          clearTimeout(cardState.pendingUpdateTimer);
+          cardState.pendingUpdateTimer = void 0;
+        }
+        if (cardState.pendingUpdatePromise) {
+          await cardState.pendingUpdatePromise;
+        }
         if (cardState.created && cardState.messageId) {
           const prefix = cardState.atPrefix || this.msgToSenderName.get(inboundId) || "";
           const stopLabel = cancelSucceeded ? this.stopLabelFor(cardState.terminalStatus, wasUserStop) : FEISHU_STOP_FAILED_STATUS_LABEL;
@@ -90178,6 +90910,7 @@ ${contentPart}` : prefix : contentPart;
     }
   }
   disconnect() {
+    this.questionCardController.dispose();
     if (this.dedupTimer) {
       clearInterval(this.dedupTimer);
       this.dedupTimer = void 0;
@@ -90252,6 +90985,21 @@ ${contentPart}` : prefix : contentPart;
     }
     return result.join("\n");
   }
+  /** Truncate card content to the Feishu card size limit, keeping the tail.
+   *  `reservedChars` covers content rendered alongside the text (greeting
+   *  prefix, status block) that must fit the same limit. */
+  truncateCardText(text, reservedChars = 0) {
+    const MAX_CARD_CHARS = 2e4;
+    if (text.length + reservedChars <= MAX_CARD_CHARS)
+      return text;
+    const marker = "\n\n_(\u5185\u5BB9\u8FC7\u957F\uFF0C\u5DF2\u622A\u65AD\u65E9\u671F\u5185\u5BB9)_";
+    const fenceReserve = 4;
+    let truncated = text.slice(-(MAX_CARD_CHARS - marker.length - fenceReserve - reservedChars)) + marker;
+    if (this.countFences(truncated) % 2 === 1) {
+      truncated = "```\n" + truncated;
+    }
+    return truncated;
+  }
   cleanupCard(inboundMsgId) {
     const cardState = this.cardSessions.get(inboundMsgId);
     if (cardState?.pendingUpdateTimer) {
@@ -90272,6 +91020,30 @@ ${contentPart}` : prefix : contentPart;
       }
     }
   }
+  releaseOutputCard(inboundMsgId) {
+    const cardState = this.cardSessions.get(inboundMsgId);
+    if (!cardState)
+      return;
+    if (cardState.pendingUpdateTimer) {
+      clearTimeout(cardState.pendingUpdateTimer);
+    }
+    if (cardState.creationTimer) {
+      clearTimeout(cardState.creationTimer);
+    }
+    this.cardSessions.set(inboundMsgId, {
+      messageId: "",
+      created: false,
+      creating: false,
+      // Carry a settled user stop (not the abandoned-creation marker) so a
+      // late-settled stop cannot flip onPromptEnd into a contradictory
+      // terminal message.
+      stopped: cardState.stopped && !cardState.abandoned,
+      accumulatedText: "",
+      lastUpdateAt: Date.now(),
+      userStopped: cardState.userStopped,
+      terminalStatus: cardState.terminalStatus
+    });
+  }
   // ----- Message handling -----
   onMessage(data) {
     try {
@@ -90286,6 +91058,9 @@ ${contentPart}` : prefix : contentPart;
       const isGroup = msg.chat_type === "group";
       const chatId = msg.chat_id;
       const senderId = sender.sender_id?.open_id || sender.sender_id?.user_id || sender.sender_id?.union_id || "";
+      this.hydrateObservedNames();
+      const senderName = this.observedUserNames.get(senderId) || senderId;
+      const chatName = isGroup ? this.observedChatNames.get(chatId) : void 0;
       const content = this.extractContent(msg.message_type, msg.content);
       let isMentioned = false;
       let cleanText = content.text;
@@ -90315,8 +91090,9 @@ ${contentPart}` : prefix : contentPart;
       const envelope = {
         channelName: this.name,
         senderId,
-        senderName: senderId,
+        senderName,
         chatId,
+        ...chatName ? { chatName } : {},
         text: cleanText,
         messageId: msgId,
         threadId: msg.root_id || void 0,