@ycodium-ai/plugin-im 0.2.2596 → 0.2.2658

package/dist/index.js

@@ -23360,7 +23360,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash } = __require("crypto");
+    var { randomBytes, createHash: createHash2 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -24028,7 +24028,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -24397,7 +24397,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash } = __require("crypto");
+    var { createHash: createHash2 } = __require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -24704,7 +24704,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -25198,9 +25198,9 @@ var require_float = __commonJS({
 var require_utf8 = __commonJS({
   "../../node_modules/.pnpm/@protobufjs+utf8@1.1.2/node_modules/@protobufjs/utf8/index.js"(exports) {
     "use strict";
-    var utf8 = exports;
+    var utf83 = exports;
     var replacementCharCode = 65533;
-    utf8.length = function utf8_length(string) {
+    utf83.length = function utf8_length(string) {
       var len = 0, c = 0;
       for (var i = 0; i < string.length; ++i) {
         c = string.charCodeAt(i);
@@ -25216,7 +25216,7 @@ var require_utf8 = __commonJS({
       }
       return len;
     };
-    utf8.read = function utf8_read(buffer, start, end) {
+    utf83.read = function utf8_read(buffer, start, end) {
       if (end - start < 1)
         return "";
       var parts = null, chunk = [], i = 0, t, t2, c2, c3;
@@ -25252,7 +25252,7 @@ var require_utf8 = __commonJS({
       }
       return String.fromCharCode.apply(String, chunk.slice(0, i));
     };
-    utf8.write = function utf8_write(string, buffer, offset) {
+    utf83.write = function utf8_write(string, buffer, offset) {
       var start = offset, c12, c2;
       for (var i = 0; i < string.length; ++i) {
         c12 = string.charCodeAt(i);
@@ -26595,7 +26595,7 @@ var require_writer = __commonJS({
     var BufferWriter;
     var LongBits = util.LongBits;
     var base64 = util.base64;
-    var utf8 = util.utf8;
+    var utf83 = util.utf8;
     function Op(fn, len, val) {
       this.fn = fn;
       this.len = len;
@@ -26730,8 +26730,8 @@ var require_writer = __commonJS({
       return this.uint32(len)._push(writeBytes, len, value);
     };
     Writer.prototype.string = function write_string(value) {
-      var len = utf8.length(value);
-      return len ? this.uint32(len)._push(utf8.write, len, value) : this._push(writeByte, 1, 0);
+      var len = utf83.length(value);
+      return len ? this.uint32(len)._push(utf83.write, len, value) : this._push(writeByte, 1, 0);
     };
     Writer.prototype.fork = function fork() {
       this.states = new State(this);
@@ -26836,7 +26836,7 @@ var require_reader = __commonJS({
     var util = require_minimal();
     var BufferReader;
     var LongBits = util.LongBits;
-    var utf8 = util.utf8;
+    var utf83 = util.utf8;
     function indexOutOfRange(reader, writeLength) {
       return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
     }
@@ -27001,7 +27001,7 @@ var require_reader = __commonJS({
     };
     Reader.prototype.string = function read_string() {
       var bytes = this.bytes();
-      return utf8.read(bytes, 0, bytes.length);
+      return utf83.read(bytes, 0, bytes.length);
     };
     Reader.prototype.skip = function skip(length) {
       if (typeof length === "number") {
@@ -123921,13 +123921,13 @@ ${block2}
               throw err;
             }
             const delay = base * Math.pow(3, attempt - 1);
-            yield sleep(delay);
+            yield sleep2(delay);
           }
         }
         throw lastErr;
       });
     }
-    function sleep(ms) {
+    function sleep2(ms) {
       return new Promise((r) => setTimeout(r, ms));
     }
     var DEFAULT_CHUNK_LIMIT = 3500;
@@ -126163,9 +126163,155 @@ import {
   readRequestResolved,
   readTurnProgress,
   REQUEST_RESOLVED_TRIGGER_KIND,
-  TURN_PROGRESS_TRIGGER_KIND
+  TURN_PROGRESS_TRIGGER_KIND,
+  USER_INPUT_PENDING_TRIGGER_KIND
 } from "@ycodium-ai/plugin-api";
 
+// src/attachments.ts
+var IMAGE_LIMIT_BYTES = 10 * 1024 * 1024;
+var FILE_LIMIT_BYTES = 25 * 1024 * 1024;
+var MAX_ATTACHMENTS_PER_TURN = 20;
+var INLINE_IMAGE_MIMES = /* @__PURE__ */ new Set([
+  "image/gif",
+  "image/jpeg",
+  "image/png",
+  "image/webp"
+]);
+var isInlineImageMime = (mimeType) => INLINE_IMAGE_MIMES.has(mimeType.toLowerCase());
+var limitForMime = (mimeType) => isInlineImageMime(mimeType) ? IMAGE_LIMIT_BYTES : FILE_LIMIT_BYTES;
+var limitForKind = (kind) => kind === "image" ? IMAGE_LIMIT_BYTES : FILE_LIMIT_BYTES;
+var formatMegabytes = (bytes) => {
+  const megabytes = bytes / (1024 * 1024);
+  return `${Number.isInteger(megabytes) ? String(megabytes) : megabytes.toFixed(1)} MB`;
+};
+var ImResourceTooLargeError = class extends Error {
+  limitBytes;
+  constructor(limitBytes) {
+    super(`the resource is over the ${String(limitBytes)} byte limit`);
+    this.name = "ImResourceTooLargeError";
+    this.limitBytes = limitBytes;
+  }
+};
+var readBodyLimited = async (response, maxBytes) => {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    await response.body?.cancel().catch(() => void 0);
+    throw new ImResourceTooLargeError(maxBytes);
+  }
+  const reader = response.body?.getReader();
+  if (reader === void 0) return new Uint8Array(0);
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel().catch(() => void 0);
+      throw new ImResourceTooLargeError(maxBytes);
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+};
+var startsWith = (bytes, signature, offset = 0) => signature.every((byte, index) => bytes[offset + index] === byte);
+var ascii = (bytes, from, to) => String.fromCharCode(...bytes.subarray(from, to));
+var sniffMime = (bytes) => {
+  if (startsWith(bytes, [137, 80, 78, 71, 13, 10, 26, 10])) return "image/png";
+  if (startsWith(bytes, [255, 216, 255])) return "image/jpeg";
+  const head = ascii(bytes, 0, 6);
+  if (head === "GIF87a" || head === "GIF89a") return "image/gif";
+  if (startsWith(bytes, [37, 80, 68, 70])) return "application/pdf";
+  if (startsWith(bytes, [80, 75, 3, 4]) || startsWith(bytes, [80, 75, 5, 6])) {
+    return "application/zip";
+  }
+  if (ascii(bytes, 0, 4) === "RIFF") {
+    const form = ascii(bytes, 8, 12);
+    if (form === "WEBP") return "image/webp";
+    if (form === "AVI ") return "video/x-msvideo";
+    if (form === "WAVE") return "audio/wav";
+  }
+  if (ascii(bytes, 4, 8) === "ftyp") {
+    const brand = ascii(bytes, 8, 12);
+    if (brand === "qt  ") return "video/quicktime";
+    if (brand === "M4A ") return "audio/mp4";
+    return "video/mp4";
+  }
+  if (startsWith(bytes, [26, 69, 223, 163])) return "video/webm";
+  if (ascii(bytes, 0, 4) === "OggS") return "audio/ogg";
+  if (ascii(bytes, 0, 3) === "ID3") return "audio/mpeg";
+  return void 0;
+};
+var resolveMime = (claimed, bytes) => {
+  const sniffed = sniffMime(bytes);
+  const generic = claimed === "" || claimed === "application/octet-stream";
+  if (sniffed === void 0) {
+    return isInlineImageMime(claimed) ? "application/octet-stream" : claimed || "application/octet-stream";
+  }
+  if (isInlineImageMime(sniffed) || generic || isInlineImageMime(claimed)) return sniffed;
+  return claimed;
+};
+var IMAGE_EXTENSIONS = {
+  "image/png": ["png"],
+  "image/jpeg": ["jpg", "jpeg"],
+  "image/gif": ["gif"],
+  "image/webp": ["webp"]
+};
+var withImageExtension = (name, mimeType) => {
+  const extensions = IMAGE_EXTENSIONS[mimeType.toLowerCase()];
+  if (extensions === void 0) return name;
+  const dot = name.lastIndexOf(".");
+  const current = dot > 0 ? name.slice(dot + 1).toLowerCase() : "";
+  if (extensions.includes(current)) return name;
+  const stem = dot > 0 ? name.slice(0, dot) : name;
+  return `${stem}.${extensions[0] ?? "bin"}`;
+};
+var NAME_MAX_BYTES = 200;
+var utf8 = new TextEncoder();
+var sanitizeAttachmentName = (name, fallback) => {
+  const cleaned = name.replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}/\\<>:"|?*]/gu, "_").replace(/_+/g, "_").trim();
+  if (cleaned === "" || /^\.+$/.test(cleaned) || cleaned === "_") return fallback;
+  if (utf8.encode(cleaned).byteLength <= NAME_MAX_BYTES) return cleaned;
+  const dot = cleaned.lastIndexOf(".");
+  const extension = dot > 0 && cleaned.length - dot <= 17 ? cleaned.slice(dot) : "";
+  const stem = [...extension === "" ? cleaned : cleaned.slice(0, dot)];
+  while (stem.length > 1 && utf8.encode(stem.join("") + extension).byteLength > NAME_MAX_BYTES) {
+    stem.pop();
+  }
+  return stem.join("") + extension;
+};
+var mimeFromName = (name) => {
+  const ext = name.slice(name.lastIndexOf(".") + 1).toLowerCase();
+  const known = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    pdf: "application/pdf",
+    txt: "text/plain",
+    md: "text/markdown",
+    json: "application/json",
+    csv: "text/csv",
+    zip: "application/zip",
+    mp4: "video/mp4",
+    mov: "video/quicktime",
+    webm: "video/webm",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    ogg: "audio/ogg",
+    opus: "audio/ogg",
+    m4a: "audio/mp4"
+  };
+  return known[ext] ?? "application/octet-stream";
+};
+
 // src/chatCommand.ts
 var teamArgument = (text2, chinese) => {
   const match = text2.match(/^\/team(?:\s+([\s\S]*))?$/i);
@@ -126205,6 +126351,8 @@ var isThreadCommand = (text2, chinese) => /^\/thread$/i.test(text2.trim()) || ch
 var ZH_ALIASES = {
   \u505C: "stop",
   \u505C\u6B62: "stop",
+  // 不用单独的「继续」：那是人对 agent 说的话，不该被当成命令吞掉。
+  \u7EE7\u7EED\u53D1\u9001: "continue",
   \u72B6\u6001: "status",
   \u65B0\u5BF9\u8BDD: "new",
   \u5E2E\u52A9: "help",
@@ -126223,6 +126371,7 @@ var resolveTeam = (query, teams) => {
 var parseChatCommand = (input) => {
   const trimmed = input.text.trim();
   if (/^\/stop$/i.test(trimmed)) return { kind: "stop" };
+  if (/^\/continue$/i.test(trimmed)) return { kind: "continue" };
   if (/^\/status$/i.test(trimmed)) return { kind: "status" };
   if (/^\/new$/i.test(trimmed)) return { kind: "new" };
   if (/^\/help$/i.test(trimmed)) return { kind: "help" };
@@ -126254,6 +126403,7 @@ var parseChatCommand = (input) => {
 var helpText = (t, options = {}) => [
   t("help.title"),
   t("help.stop"),
+  t("help.continue"),
   t("help.status"),
   t("help.new"),
   t("help.sessions"),
@@ -126278,9 +126428,20 @@ var IM_STATE_KEY = "chats";
 var IM_STATE_VERSION = 1;
 var OPENED_THREAD_LIMIT = 200;
 var APPROVAL_RECORD_LIMIT = 100;
-var emptyState = () => ({ chats: {}, opened: {}, approvals: {}, turnCards: {} });
+var emptyState = () => ({
+  chats: {},
+  opened: {},
+  approvals: {},
+  turnCards: {},
+  questions: {},
+  queue: {}
+});
+var questionsOf = (state) => state.questions ?? {};
+var queueOf = (state) => state.queue ?? {};
 var openTurnCardsOf = (state) => state.turnCards ?? {};
 var TURN_CARD_RECORD_LIMIT = 50;
+var QUESTION_RECORD_LIMIT = 50;
+var QUEUE_RECORD_LIMIT = 50;
 var DEFAULT_CHAT_RECORD = {
   threadId: null,
   target: { kind: "thread" },
@@ -126301,6 +126462,31 @@ var findApprovalByToken = (state, token) => {
 var openApprovalOf = (state, chatKey) => Object.values(state.approvals).findLast(
   (approval) => approval.chatKey === chatKey && !approval.resolved
 );
+var findQuestionByToken = (state, token) => {
+  for (const record of Object.values(questionsOf(state))) {
+    for (const item of record.items) {
+      const option = item.options.find((candidate) => candidate.token === token);
+      if (option !== void 0) return { record, item, click: { kind: "option", option } };
+      if (item.submitToken === token) return { record, item, click: { kind: "submit" } };
+    }
+  }
+  return void 0;
+};
+var openQuestionOf = (state, chatKey, threadId) => Object.values(questionsOf(state)).findLast(
+  (record) => record.chatKey === chatKey && record.threadId === threadId && !record.resolved
+);
+var isUnanswered = (item) => item.answer === void 0;
+var findQueueByToken = (state, token) => {
+  for (const record of Object.values(queueOf(state))) {
+    if (record.steerToken === token) return { record, op: "steer" };
+    if (record.withdrawToken === token) return { record, op: "withdraw" };
+    if (record.resumeToken === token) return { record, op: "resume" };
+  }
+  return void 0;
+};
+var openQueueOfThread = (state, threadId) => Object.values(queueOf(state)).filter(
+  (record) => record.threadId === threadId && record.settled === void 0
+);
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var nonEmpty = (value) => typeof value === "string" && value !== "" ? value : null;
 var readTarget = (value) => {
@@ -126322,6 +126508,76 @@ var readButtons = (value) => {
   }
   return buttons.length === 0 ? null : buttons;
 };
+var readQuestionOptions = (value) => {
+  if (!Array.isArray(value)) return null;
+  const options = [];
+  for (const entry of value) {
+    if (!isRecord(entry)) return null;
+    const token = nonEmpty(entry["token"]);
+    const optionValue = nonEmpty(entry["value"]);
+    if (token === null || optionValue === null || typeof entry["label"] !== "string") return null;
+    const planAction = entry["planAction"];
+    options.push({
+      token,
+      value: optionValue,
+      label: entry["label"],
+      description: typeof entry["description"] === "string" ? entry["description"] : "",
+      ...planAction === "approve" || planAction === "revise" || planAction === "stop" ? { planAction } : {}
+    });
+  }
+  return options.length === 0 ? null : options;
+};
+var readQuestionItems = (value) => {
+  if (!Array.isArray(value)) return null;
+  const items = [];
+  for (const entry of value) {
+    if (!isRecord(entry)) return null;
+    const id = nonEmpty(entry["id"]);
+    const options = readQuestionOptions(entry["options"]);
+    if (id === null || options === null || typeof entry["question"] !== "string") return null;
+    const submitToken = nonEmpty(entry["submitToken"]);
+    items.push({
+      id,
+      header: typeof entry["header"] === "string" ? entry["header"] : "",
+      question: entry["question"],
+      kind: entry["kind"] === "plan" ? "plan" : "question",
+      multiSelect: entry["multiSelect"] === true,
+      // 老事实没写这个字段时按「允许」处理：与宿主「没明说算 true」一致。
+      allowFreeform: entry["allowFreeform"] !== false,
+      options,
+      ...submitToken === null ? {} : { submitToken },
+      selected: []
+    });
+  }
+  return items.length === 0 ? null : items;
+};
+var readAnswer = (value) => {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
+    return value;
+  }
+  return null;
+};
+var withQuestionItem = (state, requestId, questionId, patch) => {
+  const record = requestId === null ? void 0 : questionsOf(state)[requestId];
+  if (requestId === null || questionId === null || record === void 0) return state;
+  if (!record.items.some((item) => item.id === questionId)) return state;
+  return {
+    ...state,
+    questions: {
+      ...questionsOf(state),
+      [requestId]: {
+        ...record,
+        items: record.items.map((item) => item.id === questionId ? patch(item) : item)
+      }
+    }
+  };
+};
+var withQueueRecord = (state, intentId, patch) => {
+  const record = intentId === null ? void 0 : queueOf(state)[intentId];
+  if (intentId === null || record === void 0) return state;
+  return { ...state, queue: { ...queueOf(state), [intentId]: patch(record) } };
+};
 var keepNewest = (record, limit) => {
   const entries = Object.entries(record);
   return entries.length <= limit ? record : Object.fromEntries(entries.slice(entries.length - limit));
@@ -126405,6 +126661,124 @@ var foldImEvent = (state, name, data) => {
         approvals: { ...state.approvals, [requestId]: { ...existing, cardId } }
       };
     }
+    case "question-offered": {
+      const chatKey = nonEmpty(data["chatKey"]);
+      const threadId = nonEmpty(data["threadId"]);
+      const requestId = nonEmpty(data["requestId"]);
+      const items = readQuestionItems(data["items"]);
+      if (chatKey === null || threadId === null || requestId === null || items === null) {
+        return state;
+      }
+      return {
+        ...state,
+        questions: keepNewest(
+          {
+            ...questionsOf(state),
+            [requestId]: { chatKey, threadId, requestId, items, resolved: false }
+          },
+          QUESTION_RECORD_LIMIT
+        )
+      };
+    }
+    case "question-carded": {
+      const cardId = nonEmpty(data["cardId"]);
+      if (cardId === null) return state;
+      return withQuestionItem(
+        state,
+        nonEmpty(data["requestId"]),
+        nonEmpty(data["questionId"]),
+        (item) => ({ ...item, cardId })
+      );
+    }
+    case "question-selected": {
+      const selected = readAnswer(data["selected"]);
+      if (!Array.isArray(selected)) return state;
+      return withQuestionItem(
+        state,
+        nonEmpty(data["requestId"]),
+        nonEmpty(data["questionId"]),
+        (item) => ({ ...item, selected })
+      );
+    }
+    case "question-answered": {
+      const answer = readAnswer(data["answer"]);
+      if (answer === null) return state;
+      const label = typeof data["label"] === "string" ? data["label"] : "";
+      return withQuestionItem(
+        state,
+        nonEmpty(data["requestId"]),
+        nonEmpty(data["questionId"]),
+        (item) => ({ ...item, answer, answerLabel: label })
+      );
+    }
+    case "question-resolved": {
+      const requestId = nonEmpty(data["requestId"]);
+      const existing = requestId === null ? void 0 : questionsOf(state)[requestId];
+      if (requestId === null || existing === void 0) return state;
+      const ending = data["ending"];
+      return {
+        ...state,
+        questions: {
+          ...questionsOf(state),
+          [requestId]: {
+            ...existing,
+            resolved: true,
+            ending: ending === "elsewhere" || ending === "cancelled" ? ending : "here"
+          }
+        }
+      };
+    }
+    case "queue-offered": {
+      const chatKey = nonEmpty(data["chatKey"]);
+      const threadId = nonEmpty(data["threadId"]);
+      const intentId = nonEmpty(data["intentId"]);
+      const steerToken = nonEmpty(data["steerToken"]);
+      const withdrawToken = nonEmpty(data["withdrawToken"]);
+      const resumeToken = nonEmpty(data["resumeToken"]);
+      if (chatKey === null || threadId === null || intentId === null || steerToken === null || withdrawToken === null || resumeToken === null) {
+        return state;
+      }
+      return {
+        ...state,
+        queue: keepNewest(
+          {
+            ...queueOf(state),
+            [intentId]: {
+              chatKey,
+              threadId,
+              intentId,
+              text: typeof data["text"] === "string" ? data["text"] : "",
+              steerToken,
+              withdrawToken,
+              resumeToken,
+              steering: false
+            }
+          },
+          QUEUE_RECORD_LIMIT
+        )
+      };
+    }
+    case "queue-carded": {
+      const cardId = nonEmpty(data["cardId"]);
+      if (cardId === null) return state;
+      return withQueueRecord(state, nonEmpty(data["intentId"]), (record) => ({
+        ...record,
+        cardId
+      }));
+    }
+    case "queue-steering":
+      return withQueueRecord(state, nonEmpty(data["intentId"]), (record) => ({
+        ...record,
+        steering: data["steering"] === true
+      }));
+    case "queue-settled": {
+      const outcome = data["outcome"];
+      if (outcome !== "steered" && outcome !== "sent" && outcome !== "removed") return state;
+      return withQueueRecord(state, nonEmpty(data["intentId"]), (record) => ({
+        ...record,
+        settled: outcome
+      }));
+    }
     case "turn-card-opened": {
       const cardId = nonEmpty(data["cardId"]);
       const chatKey = nonEmpty(data["chatKey"]);
@@ -126580,6 +126954,39 @@ var uploadImage = async (input) => {
   }
   return body.data.image_key;
 };
+var uploadFile = async (input) => {
+  const form = new FormData();
+  form.set("file_type", "stream");
+  form.set("file_name", input.name);
+  form.set("file", new Blob([new Uint8Array(input.bytes)], { type: input.mimeType }), input.name);
+  const response = await input.http(`${LARK_BASE}/im/v1/files`, {
+    method: "POST",
+    // 不设 content-type：multipart 的 boundary 要让 fetch 自己写。
+    headers: { authorization: `Bearer ${input.token}` },
+    body: form
+  });
+  const body = await readEnvelope("files.create", response);
+  if (typeof body.data?.file_key !== "string") {
+    throw new LarkApiError("files.create", 0, "the response carried no file_key");
+  }
+  return body.data.file_key;
+};
+var sendChatFile = async (input) => {
+  const response = await input.http(`${LARK_BASE}/im/v1/messages?receive_id_type=chat_id`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${input.token}`,
+      "content-type": "application/json; charset=utf-8"
+    },
+    body: JSON.stringify({
+      receive_id: input.chatId,
+      msg_type: "file",
+      content: JSON.stringify({ file_key: input.fileKey })
+    })
+  });
+  const body = await readEnvelope("send.file", response);
+  return body.data?.message_id ?? null;
+};
 var sendChatImage = async (input) => {
   const response = await input.http(`${LARK_BASE}/im/v1/messages?receive_id_type=chat_id`, {
     method: "POST",
@@ -132009,85 +132416,215 @@ var buildPanelCard = (card) => {
     elements
   };
 };
+var CHOICE_TEMPLATE = {
+  ask: "wathet",
+  queue: "wathet",
+  done: "grey"
+};
+var buildChoiceCard = (card) => {
+  const elements = [];
+  const lead = [
+    card.heading === null || card.heading === "" ? "" : `**${stripAngleBrackets(card.heading).replaceAll("*", "")}**`,
+    stripAngleBrackets(card.body)
+  ].filter((part) => part !== "");
+  if (lead.length > 0) elements.push({ tag: "markdown", content: lead.join("\n\n") });
+  for (const row of card.rows) {
+    if (row.length === 0) continue;
+    elements.push({
+      tag: "action",
+      actions: row.map((button) => ({
+        tag: "button",
+        text: { tag: "plain_text", content: button.label },
+        type: button.style,
+        value: { tk: button.token }
+      }))
+    });
+  }
+  if (card.note !== null && card.note !== "") {
+    if (elements.length > 0) elements.push({ tag: "hr" });
+    elements.push({
+      tag: "note",
+      elements: [{ tag: "plain_text", content: card.note }]
+    });
+  }
+  if (elements.length === 0) elements.push({ tag: "markdown", content: " " });
+  return {
+    config: { wide_screen_mode: true },
+    header: {
+      title: { tag: "plain_text", content: card.title },
+      template: CHOICE_TEMPLATE[card.tone]
+    },
+    elements
+  };
+};
 
 // src/larkInbound.ts
 var import_node_sdk = __toESM(require_lib2(), 1);
-var mentionsApp = (event, appId) => (event.message?.mentions ?? []).some(
-  (mention) => mention.id?.app_id === appId || mention.mentioned_type === "bot"
-);
-var mimeFromName = (name) => {
-  const ext = name.slice(name.lastIndexOf(".") + 1).toLowerCase();
-  const known = {
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    gif: "image/gif",
-    webp: "image/webp",
-    pdf: "application/pdf",
-    txt: "text/plain",
-    md: "text/markdown",
-    json: "application/json",
-    csv: "text/csv"
-  };
-  return known[ext] ?? "application/octet-stream";
+
+// src/larkPost.ts
+var styledText = (text2, style) => {
+  let out = text2;
+  if (style?.includes("bold")) out = `**${out}**`;
+  if (style?.includes("italic")) out = `*${out}*`;
+  if (style?.includes("lineThrough")) out = `~~${out}~~`;
+  if (style?.includes("underline")) out = `<u>${out}</u>`;
+  return out;
 };
-var readPost = (content) => {
-  if (content === void 0) return null;
+var nonEmpty2 = (value) => typeof value === "string" && value !== "";
+var resourceOf = (element, index) => {
+  if (element.tag === "img" && nonEmpty2(element.image_key)) {
+    return {
+      fileKey: element.image_key,
+      kind: "image",
+      name: `image-${String(index)}.png`,
+      mimeType: "image/png"
+    };
+  }
+  if ((element.tag === "media" || element.tag === "file") && nonEmpty2(element.file_key)) {
+    const video = element.tag === "media";
+    const name = nonEmpty2(element.file_name) ? element.file_name : video ? `video-${String(index)}.mp4` : `file-${String(index)}`;
+    return {
+      fileKey: element.file_key,
+      kind: "file",
+      name,
+      mimeType: video && !nonEmpty2(element.file_name) ? "video/mp4" : mimeFromName(name)
+    };
+  }
+  return null;
+};
+var placeholderOf = (element, index) => `<${element.tag === "img" ? "image" : element.tag === "media" ? "video" : "file"} ${String(index)}>`;
+var serializeElement = (element, index, botIds) => {
+  switch (element.tag) {
+    case "text":
+      return styledText(element.text ?? "", element.style);
+    case "a": {
+      const label = element.text ?? element.href ?? "";
+      return nonEmpty2(element.href) ? `[${label}](${element.href})` : label;
+    }
+    case "at": {
+      if (element.user_id !== void 0 && botIds.has(element.user_id)) return "";
+      return nonEmpty2(element.user_name) ? `@${element.user_name}` : "";
+    }
+    case "code_block":
+      return `\`\`\`${element.language ?? ""}
+${element.text ?? ""}
+\`\`\``;
+    case "hr":
+      return "---";
+    case "emotion":
+      return element.emoji_type ?? "";
+    case "img":
+    case "media":
+    case "file":
+      return index === null ? "" : placeholderOf(element, index);
+    default:
+      return "";
+  }
+};
+var serializePost = (content, botIds = /* @__PURE__ */ new Set()) => {
   let parsed;
   try {
     parsed = JSON.parse(content);
   } catch {
-    return null;
+    return void 0;
   }
-  const rows = parsed.content ?? [];
-  const lines = [];
-  let imageKey = null;
-  for (const row of rows) {
-    const parts = [];
-    for (const segment of row) {
-      if (segment.tag === "text" && typeof segment.text === "string") parts.push(segment.text);
-      if (segment.tag === "img" && typeof segment.image_key === "string" && imageKey === null) {
-        imageKey = segment.image_key;
-      }
-    }
-    const line = parts.join("").trim();
-    if (line.length > 0) lines.push(line);
+  const elements = (parsed.content ?? []).flat();
+  const resources = [];
+  const indexOf = /* @__PURE__ */ new Map();
+  for (const element of elements) {
+    const resource = resourceOf(element, resources.length + 1);
+    if (resource === null) continue;
+    resources.push(resource);
+    indexOf.set(element, resources.length);
   }
-  return {
-    text: lines.join("\n"),
-    resource: imageKey === null ? null : { fileKey: imageKey, kind: "image", name: "image.png", mimeType: "image/png" }
-  };
+  const md2 = parsed.md;
+  if (typeof md2 === "string" && md2.trim() !== "") {
+    const placeholderByKey = /* @__PURE__ */ new Map();
+    for (const element of elements) {
+      const index = indexOf.get(element);
+      const key = element.tag === "img" ? element.image_key : element.file_key;
+      if (index !== void 0 && nonEmpty2(key)) {
+        placeholderByKey.set(key, placeholderOf(element, index));
+      }
+    }
+    const text3 = md2.replace(
+      /!\[(?:img|video|file)\]\(([^)]+)\)/g,
+      (whole, rawKey) => placeholderByKey.get(rawKey.trim()) ?? whole
+    );
+    return { text: text3, resources };
+  }
+  const paragraphs = (parsed.content ?? []).map(
+    (row) => row.map((element) => serializeElement(element, indexOf.get(element) ?? null, botIds)).join("")
+  );
+  const text2 = paragraphs.map((line) => line.trim()).filter((line) => line !== "").join("\n");
+  if (text2 === "" && resources.length === 0) return void 0;
+  return { text: text2, resources };
 };
-var readResource = (messageType, content) => {
+
+// src/larkInbound.ts
+var mentionsApp = (event, appId) => (event.message?.mentions ?? []).some(
+  (mention) => mention.id?.app_id === appId || mention.mentioned_type === "bot"
+);
+var RESOURCE_MESSAGE_TYPES = /* @__PURE__ */ new Set(["image", "file", "audio", "media"]);
+var UNSUPPORTED_MESSAGE_TYPES = /* @__PURE__ */ new Set([
+  "sticker",
+  "folder",
+  "share_chat",
+  "share_user",
+  "system",
+  "merge",
+  "interactive"
+]);
+var botIdsOf = (mentions, appId) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const mention of mentions) {
+    if (mention.id?.app_id !== appId && mention.mentioned_type !== "bot") continue;
+    ids.add(mention.key);
+    for (const id of [mention.id?.open_id, mention.id?.app_id]) if (id !== void 0) ids.add(id);
+  }
+  return ids;
+};
+var readJson = (content) => {
   if (content === void 0) return null;
-  let parsed;
   try {
-    parsed = JSON.parse(content);
+    const parsed = JSON.parse(content);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
   } catch {
     return null;
   }
+};
+var readResource = (messageType, content) => {
+  const parsed = readJson(content);
+  if (parsed === null) return null;
+  const key = (field) => {
+    const value = parsed[field];
+    return typeof value === "string" && value !== "" ? value : null;
+  };
   if (messageType === "image") {
-    const key = parsed["image_key"];
-    return typeof key !== "string" ? null : { fileKey: key, kind: "image", name: "image.png", mimeType: "image/png" };
+    const imageKey = key("image_key");
+    return imageKey === null ? null : { fileKey: imageKey, kind: "image", name: "image.png", mimeType: "image/png" };
   }
   if (messageType === "file") {
-    const key = parsed["file_key"];
-    if (typeof key !== "string") return null;
-    const rawName = parsed["file_name"];
-    const name = typeof rawName === "string" && rawName.length > 0 ? rawName : "file";
-    return { fileKey: key, kind: "file", name, mimeType: mimeFromName(name) };
+    const fileKey = key("file_key");
+    if (fileKey === null) return null;
+    const name = key("file_name") ?? "file";
+    return { fileKey, kind: "file", name, mimeType: mimeFromName(name) };
+  }
+  if (messageType === "audio") {
+    const fileKey = key("file_key");
+    return fileKey === null ? null : { fileKey, kind: "file", name: "voice.opus", mimeType: "audio/ogg" };
+  }
+  if (messageType === "media") {
+    const fileKey = key("file_key");
+    if (fileKey === null) return null;
+    const name = key("file_name") ?? "video.mp4";
+    return { fileKey, kind: "file", name, mimeType: mimeFromName(name) };
   }
   return null;
 };
 var readText = (content) => {
-  if (content === void 0) return null;
-  try {
-    const parsed = JSON.parse(content);
-    const text2 = parsed.text;
-    return typeof text2 === "string" ? text2 : null;
-  } catch {
-    return null;
-  }
+  const text2 = readJson(content)?.["text"];
+  return typeof text2 === "string" ? text2 : null;
 };
 var parseInboundMessage = (event, appId) => {
   if (event.sender?.sender_type === "app") return null;
@@ -132096,33 +132633,52 @@ var parseInboundMessage = (event, appId) => {
   const { message_id: messageId, chat_id: chatId } = message;
   if (typeof messageId !== "string" || typeof chatId !== "string") return null;
   const chatType = message.chat_type ?? "group";
-  if (chatType !== "p2p" && !mentionsApp(event, appId)) return null;
   const messageType = message.message_type ?? "";
-  const post = messageType === "post" ? readPost(message.content) : null;
-  const resource = post !== null ? post.resource : readResource(messageType, message.content);
-  const raw = post !== null ? post.text : messageType === "text" ? readText(message.content) : null;
-  const text2 = (message.mentions ?? []).reduce((value, mention) => value.replaceAll(mention.key, ""), raw ?? "").trim();
-  if (text2.length === 0 && resource === null) return null;
-  return {
-    messageId,
-    chatId,
-    chatType,
-    senderOpenId: event.sender?.sender_id?.open_id ?? null,
-    text: text2,
-    resource
-  };
+  if (chatType !== "p2p" && !mentionsApp(event, appId) && !RESOURCE_MESSAGE_TYPES.has(messageType)) {
+    return null;
+  }
+  const senderOpenId = event.sender?.sender_id?.open_id ?? null;
+  if (UNSUPPORTED_MESSAGE_TYPES.has(messageType)) {
+    return {
+      messageId,
+      chatId,
+      chatType,
+      senderOpenId,
+      text: "",
+      resources: [],
+      unsupportedType: messageType
+    };
+  }
+  const mentions = message.mentions ?? [];
+  const post = messageType === "post" ? serializePost(message.content ?? "", botIdsOf(mentions, appId)) : void 0;
+  const single = post === void 0 ? readResource(messageType, message.content) : null;
+  const resources = post !== void 0 ? post.resources : single === null ? [] : [single];
+  const raw = post !== void 0 ? post.text : messageType === "text" ? readText(message.content) : null;
+  const text2 = mentions.reduce((value, mention) => value.replaceAll(mention.key, ""), raw ?? "").trim();
+  if (text2.length === 0 && resources.length === 0) return null;
+  return { messageId, chatId, chatType, senderOpenId, text: text2, resources };
 };
 var fetchMessageResource = async (input) => {
-  const url = `https://open.feishu.cn/open-apis/im/v1/messages/${encodeURIComponent(
+  const url = `${LARK_BASE}/im/v1/messages/${encodeURIComponent(
     input.messageId
   )}/resources/${encodeURIComponent(input.resource.fileKey)}?type=${input.resource.kind}`;
   const response = await input.http(url, {
     headers: { authorization: `Bearer ${input.token}` }
   });
   if (!response.ok) {
+    await response.body?.cancel().catch(() => void 0);
     throw new Error(`lark resource fetch failed: HTTP ${String(response.status)}`);
   }
-  return new Uint8Array(await response.arrayBuffer());
+  const bytes = await readBodyLimited(response, input.maxBytes);
+  if ((response.headers.get("content-type") ?? "").includes("application/json")) {
+    const envelope = readJson(new TextDecoder().decode(bytes.subarray(0, 4096)));
+    const code2 = envelope?.["code"];
+    if (typeof code2 === "number" && code2 !== 0) {
+      const detail = envelope?.["msg"];
+      throw new LarkApiError("resource", code2, typeof detail === "string" ? detail : "no message");
+    }
+  }
+  return bytes;
 };
 var cardActionValue = (event) => {
   const roots = [event, event?.event];
@@ -132244,7 +132800,7 @@ var makeLarkAdapter = (deps) => {
         appId,
         appSecret,
         onError: handlers.onError,
-        onCardAction: handlers.onApproval,
+        onCardAction: handlers.onButton,
         onPanelClick: (click, operatorOpenId) => handlers.onPanelClick?.({
           chatId: click.chatId,
           cardId: click.cardId,
@@ -132258,12 +132814,13 @@ var makeLarkAdapter = (deps) => {
             chatId: message.chatId,
             senderId: message.senderOpenId,
             text: message.text,
-            resource: message.resource === null ? null : {
-              key: message.resource.fileKey,
-              name: message.resource.name,
-              mimeType: message.resource.mimeType,
-              kind: message.resource.kind
-            }
+            resources: message.resources.map((resource) => ({
+              key: resource.fileKey,
+              name: resource.name,
+              mimeType: resource.mimeType,
+              kind: resource.kind
+            })),
+            ...message.unsupportedType === void 0 ? {} : { unsupportedType: message.unsupportedType }
           });
         }
       });
@@ -132292,6 +132849,20 @@ var makeLarkAdapter = (deps) => {
       await sendChatImage({ http: deps.http, token, chatId: binding.chatId, imageKey });
       deps.log.info("lark delivered an image", { name: image2.name });
     },
+    sendFile: async (binding, file) => {
+      const token = await tenantToken(binding);
+      const fileKey = await uploadFile({
+        http: deps.http,
+        token,
+        bytes: file.bytes,
+        name: file.name,
+        mimeType: file.mimeType
+      });
+      await sendChatFile({ http: deps.http, token, chatId: binding.chatId, fileKey });
+      deps.log.info("lark delivered a file", { name: file.name });
+    },
+    // 图 10 MB、文件 30 MB（飞书开放平台文档：上传图片接口、上传文件接口；空文件会被拒）。
+    outboundLimits: { imageBytes: 10 * 1024 * 1024, fileBytes: 30 * 1024 * 1024 },
     askApproval: async (binding, request) => sendCard({
       http: deps.http,
       token: await tenantToken(binding),
@@ -132346,6 +132917,22 @@ var makeLarkAdapter = (deps) => {
         });
       }
     },
+    choiceCards: {
+      open: async (binding, card) => sendCard({
+        http: deps.http,
+        token: await tenantToken(binding),
+        chatId: binding.chatId,
+        card: buildChoiceCard(card)
+      }),
+      update: async (binding, cardId, card) => {
+        await patchCard({
+          http: deps.http,
+          token: await tenantToken(binding),
+          messageId: cardId,
+          card: buildChoiceCard(card)
+        });
+      }
+    },
     acknowledge: async (binding, messageId) => addReaction({
       http: deps.http,
       token: await tenantToken(binding),
@@ -132366,6 +132953,7 @@ var makeLarkAdapter = (deps) => {
         http: deps.http,
         token: await tenantToken(binding),
         messageId: input.messageId,
+        maxBytes: input.maxBytes,
         resource: {
           fileKey: resource.key,
           kind: resource.kind,
@@ -132462,7 +133050,20 @@ var en_default = {
     projectArchived: 'Project "{{title}}" is archived. Restore it, then message again.',
     projectMissing: `The project bound to "{{group}}" is no longer on this machine (it may have been deleted), so a thread cannot be started. In Ycodium's chat settings, pick a project for this group again.`,
     threadGone: "The earlier session was deleted or archived, so this group now starts a new one.",
-    teamGone: "The team this group was sending to no longer exists, so messages go to a normal session again."
+    teamGone: "The team this group was sending to no longer exists, so messages go to a normal session again.",
+    attachmentReceived: "Got {{names}} ({{count}} waiting). Tell me what to do with them.",
+    attachmentFailed: "Could not take {{name}}: {{reason}}.",
+    attachmentReason: {
+      tooLarge: "it is over the {{limit}} limit",
+      downloadFailed: "the download failed",
+      storeFailed: "it could not be saved",
+      empty: "it is empty"
+    },
+    attachmentLimit: "At most {{max}} attachments go with one message, so {{name}} was left out. Send a message about the current ones first.",
+    attachmentsNoTeam: "Files cannot be sent to a team yet, so they were left out. Send /thread to go back to a normal session.",
+    unsupportedType: "I can't process {{type}} messages yet.",
+    unsupportedFolder: "Folders can't be downloaded. Zip it and send the archive instead.",
+    sendingFile: "Sending {{name}}:"
   },
   approval: {
     allow: "Allow",
@@ -132470,6 +133071,50 @@ var en_default = {
     alreadyHandled: "Already handled",
     replyHint: "Reply with the number."
   },
+  question: {
+    title: "\u2753 Question",
+    planTitle: "\u{1F4DD} Plan review",
+    planApprove: "Approve plan",
+    planApproveHint: "Let the agent start implementing this plan.",
+    planRevise: "Revise plan",
+    planReviseHint: "Ask the agent to rework the plan before going ahead.",
+    planStop: "Stop here",
+    planStopHint: "Leave plan mode without implementing this plan.",
+    freeformHint: "Or reply with a message to answer in your own words.",
+    replyOne: "Reply with the number.",
+    replyMany: "Reply with the numbers, separated by commas.",
+    submit: "\u2705 Submit",
+    pickFirst: "Pick at least one option first.",
+    answered: "Answer: {{answer}}",
+    elsewhere: "Already answered elsewhere (the web app or another client).",
+    cancelled: "This question was closed without an answer.",
+    alreadyHandled: "Already handled",
+    sendFailed: "Could not hand your answer to the agent. The question may have been answered elsewhere or already closed."
+  },
+  queue: {
+    title: "\u23F3 Queued",
+    waitRunning: "It goes out when the current reply finishes. To add it to the reply in progress now, tap Steer.",
+    waitPaused: "Sending is paused (the last reply was stopped or failed). Tap Resume sending to carry on.",
+    waitIdle: "It goes out shortly.",
+    steer: "\u27A1\uFE0F Steer",
+    withdraw: "\u21A9\uFE0F Withdraw",
+    resume: "\u25B6\uFE0F Resume sending",
+    steeringTitle: "\u23F3 Steering\u2026",
+    steering: "\u{1F4AC} Adding it to the current reply\u2026",
+    sendingTitle: "\u{1F4E4} Sending\u2026",
+    sending: "Sending it now.",
+    steeredTitle: "\u2705 Steered",
+    steered: "Added to the current reply.",
+    sentTitle: "\u{1F4E4} Sent",
+    sent: "It went out as its own turn.",
+    removedTitle: "\u{1F5D1}\uFE0F Withdrawn",
+    removed: "Withdrawn. It will not be sent.",
+    steerFailed: "Could not add it to the current reply (the reply may have just ended or changed). It stays queued and goes out when the reply finishes.",
+    withdrawFailed: "Could not withdraw it: it has already started sending.",
+    resumeFailed: "Could not resume sending. Try again in a moment.",
+    alreadyHandled: "Already handled",
+    plainNotice: "Queued: this message goes out when the current reply finishes."
+  },
   command: {
     teamSelected: 'OK. From now on messages go to "{{title}}".',
     threadSelected: "OK. From now on messages start a normal session.",
@@ -132478,6 +133123,9 @@ var en_default = {
     newSession: "OK. The next message starts a new session.",
     stopNoSession: "Nothing is running in this group.",
     stopNoTurn: "No turn is running right now.",
+    continued: "Resumed. The waiting messages are being sent.",
+    continueNothing: "Nothing to resume: sending is not paused in this group.",
+    continueFailed: "Could not resume sending. Try again in a moment.",
     stopped: "Stopped. The session is still there \u2014 just keep talking."
   },
   status: {
@@ -132499,12 +133147,13 @@ var en_default = {
   },
   help: {
     title: "Commands:",
+    continue: "\xB7 /continue \u2014 resume sending after /stop or a failure paused it; the waiting messages go out",
     stop: "\xB7 /stop \u2014 stop the turn that is running; the session stays",
     status: "\xB7 /status \u2014 what is going on right now",
     new: "\xB7 /new \u2014 forget the current session; the next message starts a new one",
     team: "\xB7 /team name \u2014 send the next messages to a team; /team alone lists the teams",
     thread: "\xB7 /thread \u2014 go back to a normal session",
-    aliases: "Chinese shortcuts (\u505C / \u72B6\u6001 / \u65B0\u5BF9\u8BDD / \u4F1A\u8BDD\u5217\u8868 / \u5207\u6362\u4F1A\u8BDD / \u6362\u6A21\u578B / \u8BA1\u5212\u6A21\u5F0F / \u6362\u56E2\u961F / \u6362\u5BF9\u8BDD) work when the reply language is Chinese.",
+    aliases: "Chinese shortcuts (\u505C / \u7EE7\u7EED\u53D1\u9001 / \u72B6\u6001 / \u65B0\u5BF9\u8BDD / \u4F1A\u8BDD\u5217\u8868 / \u5207\u6362\u4F1A\u8BDD / \u6362\u6A21\u578B / \u8BA1\u5212\u6A21\u5F0F / \u6362\u56E2\u961F / \u6362\u5BF9\u8BDD) work when the reply language is Chinese.",
     sessions: "\xB7 /sessions \u2014 list the sessions this bot opened for this group's project",
     resume: "\xB7 /resume number \u2014 switch to one of them (a number from /sessions, or the start of its id)",
     model: "\xB7 /model \u2014 see the model this group uses; /model number or /model instance/model switches it",
@@ -132593,6 +133242,7 @@ var en_default = {
     },
     cmd: {
       new: "New session",
+      continue: "Resume sending",
       stop: "Stop this turn",
       sessions: "Sessions",
       team: "Send to a team",
@@ -132712,7 +133362,20 @@ var zh_CN_default = {
     projectArchived: "\u9879\u76EE\u300C{{title}}\u300D\u5DF2\u5F52\u6863\uFF0C\u6062\u590D\u540E\u518D\u53D1\u6D88\u606F\u3002",
     projectMissing: "\u300C{{group}}\u300D\u7ED1\u7684\u9879\u76EE\u5DF2\u7ECF\u4E0D\u5728\u8FD9\u53F0\u673A\u5668\u4E0A\u4E86\uFF08\u53EF\u80FD\u88AB\u5220\u4E86\uFF09\uFF0C\u5F00\u4E0D\u4E86\u4F1A\u8BDD\u3002\u5230 Ycodium \u7684\u804A\u5929\u8BBE\u7F6E\u91CC\u7ED9\u8FD9\u4E2A\u7FA4\u91CD\u65B0\u9009\u4E00\u4E2A\u9879\u76EE\u3002",
     threadGone: "\u4E4B\u524D\u90A3\u6761\u4F1A\u8BDD\u5DF2\u88AB\u5220\u9664\u6216\u5F52\u6863\uFF0C\u8FD9\u4E2A\u7FA4\u6539\u4E3A\u5F00\u4E00\u6761\u65B0\u4F1A\u8BDD\u3002",
-    teamGone: "\u8FD9\u4E2A\u7FA4\u539F\u6765\u6D3E\u7ED9\u7684\u961F\u5DF2\u7ECF\u4E0D\u5728\u4E86\uFF0C\u63A5\u4E0B\u6765\u6539\u56DE\u666E\u901A\u4F1A\u8BDD\u3002"
+    teamGone: "\u8FD9\u4E2A\u7FA4\u539F\u6765\u6D3E\u7ED9\u7684\u961F\u5DF2\u7ECF\u4E0D\u5728\u4E86\uFF0C\u63A5\u4E0B\u6765\u6539\u56DE\u666E\u901A\u4F1A\u8BDD\u3002",
+    attachmentReceived: "\u6536\u5230 {{names}}\uFF08\u73B0\u6709 {{count}} \u4E2A\u5F85\u5904\u7406\uFF09\u3002\u8BF4\u4E00\u53E5\u60F3\u8BA9\u6211\u600E\u4E48\u5904\u7406\u3002",
+    attachmentFailed: "\u6CA1\u80FD\u6536\u4E0B {{name}}\uFF1A{{reason}}\u3002",
+    attachmentReason: {
+      tooLarge: "\u8D85\u8FC7\u4E86 {{limit}} \u7684\u4E0A\u9650",
+      downloadFailed: "\u4E0B\u8F7D\u5931\u8D25\u4E86",
+      storeFailed: "\u4FDD\u5B58\u4E0D\u4E86",
+      empty: "\u6587\u4EF6\u662F\u7A7A\u7684"
+    },
+    attachmentLimit: "\u4E00\u6761\u6D88\u606F\u6700\u591A\u5E26 {{max}} \u4E2A\u9644\u4EF6\uFF0C\u6240\u4EE5 {{name}} \u6CA1\u6536\u3002\u5148\u53D1\u4E00\u53E5\u8BDD\u5904\u7406\u624B\u4E0A\u8FD9\u4E9B\u3002",
+    attachmentsNoTeam: "\u6587\u4EF6\u8FD8\u53D1\u4E0D\u5230\u56E2\u961F\uFF0C\u8FD9\u6B21\u6CA1\u5E26\u4E0A\u3002\u53D1 /thread \u56DE\u5230\u666E\u901A\u4F1A\u8BDD\u3002",
+    unsupportedType: "\u6211\u8FD8\u4E0D\u80FD\u5904\u7406 {{type}} \u7C7B\u578B\u7684\u6D88\u606F\u3002",
+    unsupportedFolder: "\u6587\u4EF6\u5939\u6CA1\u6CD5\u4E0B\u8F7D\uFF0C\u8BF7\u6253\u5305\u6210\u538B\u7F29\u6587\u4EF6\u518D\u53D1\u3002",
+    sendingFile: "\u6B63\u5728\u53D1\u9001 {{name}}\uFF1A"
   },
   approval: {
     allow: "\u5141\u8BB8",
@@ -132720,6 +133383,50 @@ var zh_CN_default = {
     alreadyHandled: "\u5DF2\u5904\u7406",
     replyHint: "\u56DE\u590D\u7F16\u53F7\u5373\u53EF\u3002"
   },
+  question: {
+    title: "\u2753 \u63D0\u95EE",
+    planTitle: "\u{1F4DD} \u8BA1\u5212\u786E\u8BA4",
+    planApprove: "\u6279\u51C6\u8BA1\u5212",
+    planApproveHint: "\u8BA9 agent \u6309\u8FD9\u4EFD\u8BA1\u5212\u5F00\u59CB\u5B9E\u65BD\u3002",
+    planRevise: "\u4FEE\u6539\u8BA1\u5212",
+    planReviseHint: "\u8BA9 agent \u5148\u4FEE\u6539\u8BA1\u5212\uFF0C\u518D\u7EE7\u7EED\u5F80\u4E0B\u505A\u3002",
+    planStop: "\u5230\u6B64\u4E3A\u6B62",
+    planStopHint: "\u9000\u51FA\u8BA1\u5212\u6A21\u5F0F\uFF0C\u4E0D\u5B9E\u65BD\u8FD9\u4EFD\u8BA1\u5212\u3002",
+    freeformHint: "\u4E5F\u53EF\u4EE5\u76F4\u63A5\u56DE\u590D\u4E00\u6761\u6D88\u606F\uFF0C\u7528\u81EA\u5DF1\u7684\u8BDD\u4F5C\u7B54\u3002",
+    replyOne: "\u56DE\u590D\u7F16\u53F7\u5373\u53EF\u3002",
+    replyMany: "\u56DE\u590D\u7F16\u53F7\uFF0C\u591A\u4E2A\u7528\u9017\u53F7\u9694\u5F00\u3002",
+    submit: "\u2705 \u63D0\u4EA4",
+    pickFirst: "\u5148\u9009\u4E00\u9879\u518D\u63D0\u4EA4\u3002",
+    answered: "\u56DE\u7B54\uFF1A{{answer}}",
+    elsewhere: "\u5DF2\u5728\u522B\u5904\u56DE\u7B54\uFF08\u7F51\u9875\u6216\u5176\u4ED6\u5BA2\u6237\u7AEF\uFF09\u3002",
+    cancelled: "\u8FD9\u9053\u63D0\u95EE\u5DF2\u7ED3\u675F\uFF0C\u6CA1\u6709\u6536\u5230\u56DE\u7B54\u3002",
+    alreadyHandled: "\u5DF2\u5904\u7406",
+    sendFailed: "\u6CA1\u80FD\u628A\u4F60\u7684\u56DE\u7B54\u4EA4\u7ED9 agent\u3002\u8FD9\u9053\u63D0\u95EE\u53EF\u80FD\u5DF2\u5728\u522B\u5904\u56DE\u7B54\uFF0C\u6216\u5DF2\u7ECF\u7ED3\u675F\u3002"
+  },
+  queue: {
+    title: "\u23F3 \u5DF2\u6392\u961F",
+    waitRunning: "\u5F53\u524D\u8FD9\u4E00\u8F6E\u56DE\u590D\u7ED3\u675F\u540E\u81EA\u52A8\u53D1\u51FA\u3002\u60F3\u73B0\u5728\u5C31\u9001\u8FDB\u6B63\u5728\u8FDB\u884C\u7684\u8FD9\u4E00\u8F6E\uFF0C\u70B9\u300C\u63D2\u8BDD\u300D\u3002",
+    waitPaused: "\u53D1\u9001\u5DF2\u6682\u505C\uFF08\u4E0A\u4E00\u8F6E\u88AB\u505C\u6B62\u6216\u51FA\u9519\u4E86\uFF09\u3002\u70B9\u300C\u6062\u590D\u53D1\u9001\u300D\u7EE7\u7EED\u3002",
+    waitIdle: "\u9A6C\u4E0A\u53D1\u51FA\u3002",
+    steer: "\u27A1\uFE0F \u63D2\u8BDD",
+    withdraw: "\u21A9\uFE0F \u64A4\u56DE",
+    resume: "\u25B6\uFE0F \u6062\u590D\u53D1\u9001",
+    steeringTitle: "\u23F3 \u63D2\u8BDD\u4E2D\u2026",
+    steering: "\u{1F4AC} \u6B63\u5728\u9001\u8FDB\u5F53\u524D\u8FD9\u4E00\u8F6E\u2026",
+    sendingTitle: "\u{1F4E4} \u53D1\u9001\u4E2D\u2026",
+    sending: "\u6B63\u5728\u53D1\u51FA\u3002",
+    steeredTitle: "\u2705 \u5DF2\u63D2\u8BDD",
+    steered: "\u5DF2\u9001\u8FDB\u5F53\u524D\u8FD9\u4E00\u8F6E\u3002",
+    sentTitle: "\u{1F4E4} \u5DF2\u53D1\u9001",
+    sent: "\u5DF2\u4F5C\u4E3A\u5355\u72EC\u7684\u4E00\u8F6E\u53D1\u51FA\u3002",
+    removedTitle: "\u{1F5D1}\uFE0F \u5DF2\u64A4\u56DE",
+    removed: "\u5DF2\u64A4\u56DE\uFF0C\u4E0D\u4F1A\u53D1\u51FA\u3002",
+    steerFailed: "\u6CA1\u80FD\u9001\u8FDB\u5F53\u524D\u8FD9\u4E00\u8F6E\uFF08\u8FD9\u4E00\u8F6E\u53EF\u80FD\u521A\u7ED3\u675F\u6216\u5DF2\u7ECF\u6362\u4E86\uFF09\u3002\u6D88\u606F\u4ECD\u5728\u6392\u961F\uFF0C\u8FD9\u4E00\u8F6E\u7ED3\u675F\u540E\u53D1\u51FA\u3002",
+    withdrawFailed: "\u6CA1\u80FD\u64A4\u56DE\uFF1A\u8FD9\u6761\u6D88\u606F\u5DF2\u7ECF\u5F00\u59CB\u53D1\u9001\u4E86\u3002",
+    resumeFailed: "\u6CA1\u80FD\u6062\u590D\u53D1\u9001\uFF0C\u7A0D\u540E\u518D\u8BD5\u3002",
+    alreadyHandled: "\u5DF2\u5904\u7406",
+    plainNotice: "\u5DF2\u6392\u961F\uFF1A\u5F53\u524D\u8FD9\u4E00\u8F6E\u56DE\u590D\u7ED3\u675F\u540E\u53D1\u51FA\u3002"
+  },
   command: {
     teamSelected: "\u597D\uFF0C\u63A5\u4E0B\u6765\u6D3E\u7ED9\u300C{{title}}\u300D\u3002",
     threadSelected: "\u597D\uFF0C\u63A5\u4E0B\u6765\u5F00\u666E\u901A\u4F1A\u8BDD\u3002",
@@ -132728,6 +133435,9 @@ var zh_CN_default = {
     newSession: "\u597D\uFF0C\u4E0B\u4E00\u53E5\u8BDD\u5F00\u4E00\u6761\u65B0\u4F1A\u8BDD\u3002",
     stopNoSession: "\u8FD9\u4E2A\u7FA4\u73B0\u5728\u6CA1\u6709\u5728\u8DD1\u7684\u6D3B\u513F\u3002",
     stopNoTurn: "\u73B0\u5728\u6CA1\u6709\u5728\u8DD1\u7684\u4E00\u8F6E\u3002",
+    continued: "\u5DF2\u6062\u590D\uFF0C\u6392\u7740\u7684\u6D88\u606F\u5F00\u59CB\u53D1\u9001\u3002",
+    continueNothing: "\u6CA1\u6709\u53EF\u6062\u590D\u7684\uFF1A\u8FD9\u4E2A\u7FA4\u7684\u53D1\u9001\u6CA1\u6709\u88AB\u6682\u505C\u3002",
+    continueFailed: "\u6CA1\u80FD\u6062\u590D\u53D1\u9001\uFF0C\u7A0D\u540E\u518D\u8BD5\u3002",
     stopped: "\u505C\u4E86\u3002\u4F1A\u8BDD\u8FD8\u5728\uFF0C\u63A5\u7740\u8BF4\u5C31\u884C\u3002"
   },
   status: {
@@ -132749,12 +133459,13 @@ var zh_CN_default = {
   },
   help: {
     title: "\u80FD\u7528\u7684\u547D\u4EE4\uFF1A",
+    continue: "\xB7 /continue \u2014\u2014 /stop \u6216\u51FA\u9519\u6682\u505C\u4E86\u53D1\u9001\u4E4B\u540E\uFF0C\u7528\u5B83\u6062\u590D\uFF0C\u6392\u7740\u7684\u6D88\u606F\u7EE7\u7EED\u53D1\u51FA",
     stop: "\xB7 /stop \u2014\u2014 \u505C\u6389\u6B63\u5728\u8DD1\u7684\u8FD9\u4E00\u8F6E\uFF0C\u4F1A\u8BDD\u7559\u7740",
     status: "\xB7 /status \u2014\u2014 \u73B0\u5728\u5728\u5E72\u4EC0\u4E48",
     new: "\xB7 /new \u2014\u2014 \u5FD8\u6389\u5F53\u524D\u4F1A\u8BDD\uFF0C\u4E0B\u4E00\u53E5\u5F00\u65B0\u7684",
     team: "\xB7 /team \u961F\u540D \u2014\u2014 \u628A\u63A5\u4E0B\u6765\u7684\u6D3B\u6D3E\u7ED9\u4E00\u652F\u961F\uFF1B/team \u4E0D\u5E26\u540D\u5B57\u770B\u6709\u54EA\u4E9B\u961F",
     thread: "\xB7 /thread \u2014\u2014 \u5207\u56DE\u666E\u901A\u4F1A\u8BDD",
-    aliases: "\u4E2D\u6587\u4E5F\u884C\uFF1A\u505C / \u72B6\u6001 / \u65B0\u5BF9\u8BDD / \u4F1A\u8BDD\u5217\u8868 / \u5207\u6362\u4F1A\u8BDD / \u6362\u6A21\u578B / \u8BA1\u5212\u6A21\u5F0F / \u6362\u56E2\u961F / \u6362\u5BF9\u8BDD\u3002",
+    aliases: "\u4E2D\u6587\u4E5F\u884C\uFF1A\u505C / \u7EE7\u7EED\u53D1\u9001 / \u72B6\u6001 / \u65B0\u5BF9\u8BDD / \u4F1A\u8BDD\u5217\u8868 / \u5207\u6362\u4F1A\u8BDD / \u6362\u6A21\u578B / \u8BA1\u5212\u6A21\u5F0F / \u6362\u56E2\u961F / \u6362\u5BF9\u8BDD\u3002",
     sessions: "\xB7 /sessions \u2014\u2014 \u5217\u51FA\u672C\u673A\u5668\u4EBA\u4E3A\u8FD9\u4E2A\u7FA4\u7684\u9879\u76EE\u5F00\u8FC7\u7684\u4F1A\u8BDD",
     resume: "\xB7 /resume \u7F16\u53F7 \u2014\u2014 \u5207\u5230\u5176\u4E2D\u4E00\u6761\uFF08/sessions \u91CC\u7684\u7F16\u53F7\uFF0C\u6216\u4F1A\u8BDD id \u7684\u5F00\u5934\uFF09",
     model: "\xB7 /model \u2014\u2014 \u770B\u8FD9\u4E2A\u7FA4\u7528\u7684\u6A21\u578B\uFF1B/model \u7F16\u53F7 \u6216 /model \u5B9E\u4F8B/\u6A21\u578B \u5207\u6362",
@@ -132843,6 +133554,7 @@ var zh_CN_default = {
     },
     cmd: {
       new: "\u65B0\u4F1A\u8BDD",
+      continue: "\u6062\u590D\u53D1\u9001",
       stop: "\u505C\u6B62\u672C\u8F6E",
       sessions: "\u4F1A\u8BDD\u5217\u8868",
       team: "\u6D3E\u7ED9\u56E2\u961F",
@@ -133033,6 +133745,14 @@ var PANEL_COMMANDS = [
     labelKey: "panel.cmd.stop",
     action: { op: "run", arg: "stop" }
   },
+  {
+    id: "continue",
+    category: "session",
+    line: "/continue",
+    kind: "continue",
+    labelKey: "panel.cmd.continue",
+    action: { op: "run", arg: "continue" }
+  },
   {
     id: "sessions",
     category: "session",
@@ -133393,6 +134113,724 @@ var makePanelController = (deps) => {
   };
 };
 
+// src/flowHost.ts
+var NOT_MINE = { handled: false };
+var handledWith = (notice) => ({ handled: true, notice });
+
+// src/questionCards.ts
+var PLAN_ACTION_TEXT = {
+  approve: { label: "question.planApprove", hint: "question.planApproveHint" },
+  revise: { label: "question.planRevise", hint: "question.planReviseHint" },
+  stop: { label: "question.planStop", hint: "question.planStopHint" }
+};
+var planTextOf = (item, option) => item.kind === "plan" && option.planAction !== void 0 ? PLAN_ACTION_TEXT[option.planAction] : void 0;
+var optionLabelOf = (item, option, t) => {
+  const plan = planTextOf(item, option);
+  return plan === void 0 ? option.label : t(plan.label);
+};
+var optionDescriptionOf = (item, option, t) => {
+  const plan = planTextOf(item, option);
+  return (plan === void 0 ? option.description : t(plan.hint)).trim();
+};
+var QUESTION_TEXT_MAX_CHARS = 1500;
+var ANSWER_ECHO_MAX_CHARS = 200;
+var clip2 = (text2, limit) => {
+  const chars = Array.from(text2.trim());
+  return chars.length <= limit ? chars.join("") : `${chars.slice(0, limit).join("")}\u2026`;
+};
+var titleOf = (item, index, total, t) => {
+  const base = item.kind === "plan" ? t("question.planTitle") : t("question.title");
+  return total > 1 ? `${base} ${String(index + 1)}/${String(total)}` : base;
+};
+var bodyOf = (item, t) => clip2(
+  item.options.filter((option) => optionDescriptionOf(item, option, t) !== "").map(
+    (option) => `\xB7 ${optionLabelOf(item, option, t)}: ${optionDescriptionOf(item, option, t)}`
+  ).join("\n"),
+  QUESTION_TEXT_MAX_CHARS
+);
+var headingOf = (item) => clip2(
+  [item.header, item.question].filter((part) => part.trim() !== "").join("\n"),
+  QUESTION_TEXT_MAX_CHARS
+);
+var questionCardOf = (item, index, total, t) => ({
+  tone: "ask",
+  title: titleOf(item, index, total, t),
+  heading: headingOf(item),
+  body: bodyOf(item, t),
+  note: item.allowFreeform ? t("question.freeformHint") : null,
+  rows: [
+    ...item.options.map((option) => {
+      const ticked = item.multiSelect && item.selected.includes(option.value);
+      return [
+        {
+          label: ticked ? `\u2705 ${optionLabelOf(item, option, t)}` : optionLabelOf(item, option, t),
+          token: option.token,
+          style: ticked ? "primary" : "default"
+        }
+      ];
+    }),
+    ...item.multiSelect && item.submitToken !== void 0 ? [[{ label: t("question.submit"), token: item.submitToken, style: "primary" }]] : []
+  ]
+});
+var questionSettledCardOf = (item, index, total, ending, t) => ({
+  tone: "done",
+  title: titleOf(item, index, total, t),
+  heading: headingOf(item),
+  body: "",
+  note: item.answer !== void 0 ? t("question.answered", { answer: item.answerLabel ?? "" }) : ending === "cancelled" ? t("question.cancelled") : t("question.elsewhere"),
+  rows: []
+});
+var questionPlainText = (item, index, total, t) => [
+  titleOf(item, index, total, t),
+  headingOf(item),
+  ...item.options.map((option, position) => {
+    const description = optionDescriptionOf(item, option, t);
+    return `${String(position + 1)}. ${optionLabelOf(item, option, t)}${description === "" ? "" : ` \u2014 ${description}`}`;
+  }),
+  "",
+  item.multiSelect ? t("question.replyMany") : t("question.replyOne"),
+  ...item.allowFreeform ? [t("question.freeformHint")] : []
+].join("\n");
+var parseNumberedReply = (item, text2, t) => {
+  const trimmed = text2.trim();
+  const pattern = item.multiSelect ? /^\d+(?:[\s,，、]+\d+)*$/ : /^\d+$/;
+  if (!pattern.test(trimmed)) return null;
+  const numbers = [...new Set(trimmed.split(/[\s,，、]+/).map(Number))];
+  const picked = numbers.map((number) => item.options[number - 1]);
+  if (picked.some((option) => option === void 0)) return null;
+  const options = item.options.filter((option) => picked.includes(option));
+  if (item.multiSelect) {
+    return {
+      answer: options.map((option) => option.value),
+      label: options.map((option) => optionLabelOf(item, option, t)).join(", ")
+    };
+  }
+  const only = options[0];
+  return only === void 0 ? null : { answer: only.value, label: optionLabelOf(item, only, t) };
+};
+
+// src/questionFlow.ts
+var makeQuestionFlow = (host) => {
+  const { t } = host;
+  const recordOf = (requestId) => questionsOf(host.state())[requestId];
+  const itemOf = (requestId, questionId) => recordOf(requestId)?.items.find((item) => item.id === questionId);
+  const hasButtons = (chatKey) => host.target(chatKey)?.adapter.choiceCards !== void 0;
+  const redraw = async (requestId, questionId) => {
+    const record = recordOf(requestId);
+    const item = itemOf(requestId, questionId);
+    const target = record === void 0 ? void 0 : host.target(record.chatKey);
+    if (record === void 0 || item?.cardId === void 0 || target === void 0) return;
+    if (record.resolved || item.answer !== void 0) return;
+    try {
+      await target.adapter.choiceCards?.update(
+        target.binding,
+        item.cardId,
+        questionCardOf(item, record.items.indexOf(item), record.items.length, t)
+      );
+    } catch (error) {
+      host.warn("chat could not update the question card", error);
+    }
+  };
+  const freeze = async (requestId, questionId) => {
+    const record = recordOf(requestId);
+    const item = itemOf(requestId, questionId);
+    const target = record === void 0 ? void 0 : host.target(record.chatKey);
+    if (record === void 0 || item?.cardId === void 0 || target === void 0) return;
+    try {
+      await target.adapter.choiceCards?.update(
+        target.binding,
+        item.cardId,
+        questionSettledCardOf(
+          item,
+          record.items.indexOf(item),
+          record.items.length,
+          record.ending ?? "here",
+          t
+        )
+      );
+    } catch (error) {
+      host.warn("chat could not update the question card", error);
+    }
+  };
+  const sayNext = async (requestId) => {
+    const record = recordOf(requestId);
+    if (record === void 0 || record.resolved) return;
+    const item = record.items.find(isUnanswered);
+    if (item === void 0) return;
+    await host.say(
+      record.chatKey,
+      questionPlainText(item, record.items.indexOf(item), record.items.length, t)
+    );
+  };
+  const post = async (requestId) => {
+    const first = recordOf(requestId);
+    const target = first === void 0 ? void 0 : host.target(first.chatKey);
+    if (first === void 0 || target === void 0) return;
+    const cards = target.adapter.choiceCards;
+    if (cards === void 0) {
+      await sayNext(requestId);
+      return;
+    }
+    for (const questionId of first.items.map((item) => item.id)) {
+      const record = recordOf(requestId);
+      const item = itemOf(requestId, questionId);
+      if (record === void 0 || record.resolved || item === void 0) return;
+      try {
+        const cardId = await cards.open(
+          target.binding,
+          questionCardOf(item, record.items.indexOf(item), record.items.length, t)
+        );
+        if (cardId === null) continue;
+        host.commit("question-carded", { requestId, questionId, cardId });
+        const after = recordOf(requestId);
+        if (after?.resolved === true || itemOf(requestId, questionId)?.answer !== void 0) {
+          await freeze(requestId, questionId);
+        }
+      } catch (error) {
+        host.warn("chat could not ask the question", error);
+      }
+    }
+  };
+  const offer = (chatKey, threadId, pending) => {
+    const target = host.target(chatKey);
+    if (target === void 0) return;
+    const buttons = target.adapter.choiceCards !== void 0;
+    if (!buttons && target.adapter.answerByText === void 0) {
+      host.warn("chat cannot show questions on this platform");
+      return;
+    }
+    const fresh = pending.filter((request) => recordOf(request.requestId) === void 0);
+    for (const request of buttons ? fresh : fresh.slice(0, 1)) {
+      host.commit("question-offered", {
+        chatKey,
+        threadId,
+        requestId: request.requestId,
+        items: request.questions.map((question) => ({
+          id: question.id,
+          header: question.header,
+          question: question.question,
+          kind: question.kind,
+          multiSelect: question.multiSelect,
+          allowFreeform: question.allowFreeform,
+          options: question.options.map((option) => ({
+            token: host.newToken(),
+            label: option.label,
+            value: option.value,
+            description: option.description,
+            ...option.planAction === void 0 ? {} : { planAction: option.planAction }
+          })),
+          ...question.multiSelect ? { submitToken: host.newToken() } : {}
+        }))
+      });
+      if (recordOf(request.requestId) === void 0) continue;
+      host.outbound(chatKey, () => post(request.requestId));
+    }
+  };
+  const answer = async (requestId, questionId, value, label) => {
+    const before = recordOf(requestId);
+    const item = itemOf(requestId, questionId);
+    if (before === void 0 || before.resolved || item === void 0 || !isUnanswered(item)) {
+      return false;
+    }
+    host.commit("question-answered", { requestId, questionId, answer: value, label });
+    const after = recordOf(requestId);
+    if (after === void 0) return false;
+    const complete = after.items.every((entry) => !isUnanswered(entry));
+    if (complete) host.commit("question-resolved", { requestId, ending: "here" });
+    host.outbound(after.chatKey, () => freeze(requestId, questionId));
+    if (!complete) {
+      if (!hasButtons(after.chatKey)) host.outbound(after.chatKey, () => sayNext(requestId));
+      return true;
+    }
+    try {
+      await host.dispatch({
+        type: "thread.user-input.respond",
+        commandId: host.newId(),
+        threadId: after.threadId,
+        requestId,
+        answers: Object.fromEntries(after.items.map((entry) => [entry.id, entry.answer])),
+        createdAt: host.now()
+      });
+    } catch (error) {
+      host.warn("chat could not hand the answer to the agent", error);
+      await host.say(after.chatKey, t("question.sendFailed"));
+    }
+    return true;
+  };
+  const click = (token, operatorId) => {
+    const found = findQuestionByToken(host.state(), token);
+    if (found === void 0) return NOT_MINE;
+    const { record, item } = found;
+    if (record.resolved || !isUnanswered(item)) return handledWith(t("question.alreadyHandled"));
+    if (!host.allowed(record.chatKey, operatorId)) return handledWith(t("reply.notAllowed"));
+    const requestId = record.requestId;
+    if (found.click.kind === "option") {
+      const option = found.click.option;
+      if (!item.multiSelect) {
+        void answer(requestId, item.id, option.value, optionLabelOf(item, option, t));
+        return handledWith(null);
+      }
+      const selected = item.selected.includes(option.value) ? item.selected.filter((value) => value !== option.value) : [...item.selected, option.value];
+      host.commit("question-selected", { requestId, questionId: item.id, selected });
+      host.outbound(record.chatKey, () => redraw(requestId, item.id));
+      return handledWith(null);
+    }
+    const chosen = item.options.filter((option) => item.selected.includes(option.value));
+    if (chosen.length === 0) return handledWith(t("question.pickFirst"));
+    void answer(
+      requestId,
+      item.id,
+      chosen.map((option) => option.value),
+      chosen.map((option) => optionLabelOf(item, option, t)).join(", ")
+    );
+    return handledWith(null);
+  };
+  const answerByText = async (chatKey, threadId, text2) => {
+    const record = openQuestionOf(host.state(), chatKey, threadId);
+    const trimmed = text2.trim();
+    if (record === void 0 || trimmed === "") return false;
+    const unanswered = record.items.filter(isUnanswered);
+    const first = unanswered[0];
+    if (first === void 0) return false;
+    if (!hasButtons(chatKey)) {
+      const numbered = parseNumberedReply(first, trimmed, t);
+      if (numbered !== null) {
+        return answer(record.requestId, first.id, numbered.answer, numbered.label);
+      }
+    }
+    const freeform = unanswered.find((item) => item.allowFreeform);
+    if (freeform === void 0) return false;
+    return answer(record.requestId, freeform.id, trimmed, clip2(trimmed, ANSWER_ECHO_MAX_CHARS));
+  };
+  const resolved = (requestId, outcome) => {
+    const record = recordOf(requestId);
+    if (record === void 0 || record.resolved) return;
+    const ending = outcome === "answered" ? "elsewhere" : "cancelled";
+    host.commit("question-resolved", { requestId, ending });
+    for (const item of record.items) {
+      if (isUnanswered(item)) host.outbound(record.chatKey, () => freeze(requestId, item.id));
+    }
+  };
+  return { offer, click, answerByText, resolved };
+};
+
+// src/sendFile.ts
+var failure = (code2, text2) => ({
+  text: text2,
+  isError: true,
+  errorCode: code2
+});
+var describeError = (error) => error instanceof Error ? error.message : String(error);
+var reasonOf = (error) => {
+  const reason = error?.reason;
+  return typeof reason === "string" ? reason : void 0;
+};
+var formatSize = (bytes) => bytes < 1024 * 1024 ? `${String(Math.max(1, Math.round(bytes / 1024)))} KB` : formatMegabytes(bytes);
+var baseName = (path) => path.split(/[\\/]/).filter(Boolean).at(-1) ?? "";
+var readFailure = (error, path) => {
+  switch (reasonOf(error)) {
+    case "outside-workspace":
+      return failure(
+        "outside-workspace",
+        `"${path}" is outside this conversation's working folder. Only files inside the project can be sent.`
+      );
+    case "not-a-file":
+      return failure("not-a-file", `"${path}" is not a regular file (a folder cannot be sent).`);
+    case "not-found":
+      return failure("not-found", `"${path}" does not exist. Check the path and try again.`);
+    case "too-large":
+      return failure("too-large", `"${path}" is too large to send.`);
+    case "invocation-ended":
+      return failure(
+        "invocation-ended",
+        "The file could not be read: the tool call had already ended."
+      );
+    default:
+      return failure("unreadable", `"${path}" could not be read: ${describeError(error)}`);
+  }
+};
+var makeSendFileTool = (deps) => ({
+  name: "send_file",
+  description: "Send a file from this project to the chat this conversation is connected to (Lark, Telegram or WeCom), as a native image or file message. Use it when the user asked for a concrete deliverable, or would clearly benefit from one: a chart, a screenshot, a generated report, a CSV, an archive. Do not use it for text you can just say. `path` is relative to your working folder, or an absolute path inside the project; folders, and files outside the project, are refused. Images are sent as pictures when the platform allows it, everything else (documents, audio, video) as a file. Size limits are per platform (about 10 MB for a picture and 20 to 50 MB for a file); a too-large file is refused, so compress or split it. The chat first gets one line of caption, then the file. It only works in a conversation that was started from a chat; elsewhere it fails with not-in-chat and sends nothing.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "The file to send: a path relative to your working folder, or an absolute path inside the project"
+      },
+      description: {
+        type: "string",
+        description: "Optional caption: one short sentence, in the language the user writes in, saying what is being sent. Shown in the chat before the file. Leave it out to use a default line."
+      }
+    },
+    required: ["path"]
+  },
+  handle: async (input, invocation) => {
+    const path = typeof input["path"] === "string" ? input["path"].trim() : "";
+    if (path === "") return failure("unreadable", "`path` is required.");
+    const binding = invocation.threadId === null ? void 0 : deps.boundChat(invocation.threadId);
+    if (binding === void 0) {
+      return failure(
+        "not-in-chat",
+        "This conversation is not connected to a chat, so there is nowhere to send the file. Nothing was sent."
+      );
+    }
+    const adapter = deps.adapterFor(binding);
+    if (adapter?.sendFile === void 0 || adapter.outboundLimits === void 0) {
+      return failure(
+        "unsupported-platform",
+        `${adapter?.label ?? "This chat platform"} cannot receive files from the agent yet. Nothing was sent.`
+      );
+    }
+    const workspace = invocation.workspace;
+    if (workspace === void 0) {
+      return failure(
+        "no-workspace",
+        "Files cannot be read for this call (it did not come from a conversation)."
+      );
+    }
+    const limits = adapter.outboundLimits;
+    let size;
+    try {
+      const info = await workspace.stat(path);
+      if (!info.isFile) {
+        return failure("not-a-file", `"${path}" is not a regular file (a folder cannot be sent).`);
+      }
+      size = info.size;
+    } catch (error) {
+      return readFailure(error, path);
+    }
+    const minBytes = limits.minBytes ?? 1;
+    if (size < minBytes) {
+      return failure(
+        "empty",
+        size === 0 ? `"${path}" is empty, and an empty file cannot be sent.` : `"${path}" is only ${String(size)} bytes, and ${adapter.label} cannot send a file smaller than ${String(minBytes)} bytes.`
+      );
+    }
+    const tooLarge = (bytes2) => failure(
+      "too-large",
+      `"${path}" is ${formatSize(bytes2)}, over the ${formatMegabytes(limits.fileBytes)} limit for ${adapter.label}. Compress or split it and try again.`
+    );
+    if (size > limits.fileBytes) return tooLarge(size);
+    let bytes;
+    try {
+      bytes = (await workspace.readFile(path, { maxBytes: limits.fileBytes })).bytes;
+    } catch (error) {
+      return reasonOf(error) === "too-large" ? tooLarge(size) : readFailure(error, path);
+    }
+    if (bytes.byteLength === 0)
+      return failure("empty", `"${path}" is empty, and an empty file cannot be sent.`);
+    if (bytes.byteLength > limits.fileBytes) return tooLarge(bytes.byteLength);
+    const name = sanitizeAttachmentName(baseName(path), "file");
+    const mimeType = resolveMime(mimeFromName(name), bytes);
+    const asImage = isInlineImageMime(mimeType) && (adapter.imageMimeTypes?.has(mimeType) ?? true) && bytes.byteLength <= limits.imageBytes && adapter.sendImage !== void 0;
+    const caption = typeof input["description"] === "string" && input["description"].trim() !== "" ? input["description"].trim() : deps.translate("reply.sendingFile", { name });
+    try {
+      await adapter.sendText(binding, caption);
+    } catch (error) {
+      deps.log.warn("chat could not send the caption of a file", { error: describeError(error) });
+    }
+    try {
+      const file = { bytes, name, mimeType };
+      if (asImage && adapter.sendImage !== void 0) await adapter.sendImage(binding, file);
+      else await adapter.sendFile(binding, file);
+    } catch (error) {
+      deps.log.warn("chat could not deliver a file", { name, error: describeError(error) });
+      return failure(
+        "upload-failed",
+        `${adapter.label} did not accept "${name}": ${describeError(error)}. The caption line may already be in the chat; nothing else was sent.`
+      );
+    }
+    deps.log.info("chat delivered a file from the agent", {
+      name,
+      sizeBytes: bytes.byteLength,
+      asImage
+    });
+    return {
+      text: `Sent "${name}" (${formatSize(bytes.byteLength)}) to ${adapter.label}.`
+    };
+  }
+});
+
+// src/queueCards.ts
+var QUEUE_PREVIEW_MAX_CHARS = 200;
+var WAITING_STATUSES = /* @__PURE__ */ new Set(["queued", "blocked"]);
+var IN_FLIGHT_STATUSES = /* @__PURE__ */ new Set([
+  "preparing",
+  "dispatching",
+  "reconciling"
+]);
+var WITHDRAWN_STATUSES = /* @__PURE__ */ new Set(["cancelled", "abandoned"]);
+var queueViewOf = (record, facts, released) => {
+  const status = facts.intent?.status;
+  if (status === void 0) return null;
+  if (WITHDRAWN_STATUSES.has(status)) return { kind: "settled", outcome: "removed" };
+  if (IN_FLIGHT_STATUSES.has(status))
+    return record.steering ? { kind: "steering" } : { kind: "sending" };
+  if (!WAITING_STATUSES.has(status)) {
+    return { kind: "settled", outcome: record.steering ? "steered" : "sent" };
+  }
+  if (record.steering && !released) return { kind: "steering" };
+  return { kind: "queued", running: facts.activeTurnId !== null, paused: facts.queuePaused };
+};
+var SETTLED_TITLE = {
+  steered: "queue.steeredTitle",
+  sent: "queue.sentTitle",
+  removed: "queue.removedTitle"
+};
+var SETTLED_NOTE = {
+  steered: "queue.steered",
+  sent: "queue.sent",
+  removed: "queue.removed"
+};
+var queueCardOf = (record, view, note, t) => {
+  const body = clip2(record.text, QUEUE_PREVIEW_MAX_CHARS);
+  if (view.kind === "steering") {
+    return {
+      tone: "queue",
+      title: t("queue.steeringTitle"),
+      heading: null,
+      body,
+      note: t("queue.steering"),
+      rows: []
+    };
+  }
+  if (view.kind === "sending") {
+    return {
+      tone: "queue",
+      title: t("queue.sendingTitle"),
+      heading: null,
+      body,
+      note: t("queue.sending"),
+      rows: []
+    };
+  }
+  if (view.kind === "settled") {
+    return {
+      tone: "done",
+      title: t(SETTLED_TITLE[view.outcome]),
+      heading: null,
+      body,
+      note: t(SETTLED_NOTE[view.outcome]),
+      rows: []
+    };
+  }
+  const steerable = view.running && !view.paused;
+  const state = view.paused ? t("queue.waitPaused") : view.running ? t("queue.waitRunning") : t("queue.waitIdle");
+  return {
+    tone: "queue",
+    title: t("queue.title"),
+    heading: null,
+    body,
+    note: note ?? state,
+    rows: [
+      [
+        ...steerable ? [{ label: t("queue.steer"), token: record.steerToken, style: "primary" }] : [],
+        { label: t("queue.withdraw"), token: record.withdrawToken, style: "default" }
+      ],
+      ...view.paused ? [[{ label: t("queue.resume"), token: record.resumeToken, style: "primary" }]] : []
+    ]
+  };
+};
+var queueViewKey = (view, note) => JSON.stringify([view, note]);
+
+// src/queueFlow.ts
+var LIVE_STATUSES = /* @__PURE__ */ new Set([
+  "queued",
+  "preparing",
+  "dispatching",
+  "running",
+  "reconciling",
+  "blocked"
+]);
+var makeQueueFlow = (host, deps) => {
+  const { t } = host;
+  const shown = /* @__PURE__ */ new Map();
+  const notes = /* @__PURE__ */ new Map();
+  const recordOf = (intentId) => queueOf(host.state())[intentId];
+  const factsOf = (execution, intentId) => ({
+    activeTurnId: execution.activeTurnId,
+    queuePaused: execution.queuePaused,
+    intent: execution.intents.find((intent) => intent.intentId === intentId)
+  });
+  const noteQueued = async (chatKey, threadId, messageId, text2) => {
+    const target = host.target(chatKey);
+    if (target === void 0) return;
+    let execution;
+    try {
+      execution = await deps.readExecution(threadId);
+    } catch (error) {
+      host.warn("chat could not read the turn queue", error);
+      return;
+    }
+    const intent = execution?.intents.find((entry) => entry.messageId === messageId);
+    if (execution === null || intent === void 0 || intent.status !== "queued") return;
+    const waiting = execution.activeTurnId !== null || execution.queuePaused || execution.intents.some(
+      (other) => other.intentId !== intent.intentId && LIVE_STATUSES.has(other.status) && other.sequence < intent.sequence
+    );
+    if (!waiting) return;
+    const cards = target.adapter.choiceCards;
+    if (cards === void 0) {
+      await host.say(chatKey, t("queue.plainNotice"));
+      return;
+    }
+    const intentId = intent.intentId;
+    host.commit("queue-offered", {
+      chatKey,
+      threadId,
+      intentId,
+      text: text2,
+      steerToken: host.newToken(),
+      withdrawToken: host.newToken(),
+      resumeToken: host.newToken()
+    });
+    host.outbound(chatKey, async () => {
+      const record = recordOf(intentId);
+      if (record === void 0) return;
+      try {
+        const latest = await deps.readExecution(threadId) ?? execution;
+        const view = queueViewOf(record, factsOf(latest, intentId), false) ?? {
+          kind: "queued",
+          running: latest.activeTurnId !== null,
+          paused: latest.queuePaused
+        };
+        if (view.kind === "settled") {
+          host.commit("queue-settled", { intentId, outcome: view.outcome });
+          return;
+        }
+        const cardId = await cards.open(target.binding, queueCardOf(record, view, null, t));
+        if (cardId === null) return;
+        host.commit("queue-carded", { intentId, cardId });
+        shown.set(intentId, queueViewKey(view, null));
+      } catch (error) {
+        host.warn("chat could not show the queued message", error);
+      }
+    });
+  };
+  const redraw = async (intentId, released) => {
+    const record = recordOf(intentId);
+    const target = record === void 0 ? void 0 : host.target(record.chatKey);
+    if (record === void 0 || record.settled !== void 0 || target === void 0) return;
+    if (record.cardId === void 0) return;
+    let execution;
+    try {
+      execution = await deps.readExecution(record.threadId);
+    } catch (error) {
+      host.warn("chat could not read the turn queue", error);
+      return;
+    }
+    if (execution === null) return;
+    const view = queueViewOf(record, factsOf(execution, intentId), released);
+    if (view === null) return;
+    if (view.kind === "queued" && record.steering) {
+      host.commit("queue-steering", { intentId, steering: false });
+      notes.set(intentId, t("queue.steerFailed"));
+    }
+    if (view.kind === "settled") notes.delete(intentId);
+    await paint(record, view);
+    if (view.kind === "settled") {
+      host.commit("queue-settled", { intentId, outcome: view.outcome });
+      shown.delete(intentId);
+    }
+  };
+  const paint = async (record, view) => {
+    const target = host.target(record.chatKey);
+    const cards = target?.adapter.choiceCards;
+    if (target === void 0 || cards === void 0 || record.cardId === void 0) return;
+    const note = notes.get(record.intentId) ?? null;
+    const key = queueViewKey(view, note);
+    if (shown.get(record.intentId) === key) return;
+    try {
+      await cards.update(target.binding, record.cardId, queueCardOf(record, view, note, t));
+      shown.set(record.intentId, key);
+    } catch (error) {
+      host.warn("chat could not update the queued message card", error);
+    }
+  };
+  const refresh = (threadId, released = null) => {
+    for (const record of openQueueOfThread(host.state(), threadId)) {
+      host.outbound(record.chatKey, () => redraw(record.intentId, record.intentId === released));
+    }
+  };
+  const run = async (record, work, failure2) => {
+    notes.delete(record.intentId);
+    let ok = false;
+    try {
+      ok = await work();
+    } catch (error) {
+      host.warn("chat could not change the queue", error);
+    }
+    if (!ok) notes.set(record.intentId, failure2);
+    host.outbound(record.chatKey, () => redraw(record.intentId, false));
+  };
+  const steer = async (record) => {
+    const execution = await deps.readExecution(record.threadId);
+    if (execution?.activeTurnId == null) return false;
+    host.commit("queue-steering", { intentId: record.intentId, steering: true });
+    try {
+      await host.dispatch({
+        type: "thread.turn-intent.run",
+        commandId: host.newId(),
+        threadId: record.threadId,
+        intentId: record.intentId,
+        mode: "steer",
+        expectedTurnId: execution.activeTurnId,
+        createdAt: host.now()
+      });
+      return true;
+    } catch (error) {
+      host.commit("queue-steering", { intentId: record.intentId, steering: false });
+      throw error;
+    }
+  };
+  const click = (token, operatorId) => {
+    const found = findQueueByToken(host.state(), token);
+    if (found === void 0) return NOT_MINE;
+    const { record, op } = found;
+    if (record.settled !== void 0) return handledWith(t("queue.alreadyHandled"));
+    if (!host.allowed(record.chatKey, operatorId)) return handledWith(t("reply.notAllowed"));
+    if (op === "steer") {
+      if (record.steering) return handledWith(t("queue.alreadyHandled"));
+      void run(record, () => steer(record), t("queue.steerFailed"));
+    } else if (op === "withdraw") {
+      void run(
+        record,
+        async () => {
+          await host.dispatch({
+            type: "thread.turn-intent.cancel",
+            commandId: host.newId(),
+            threadId: record.threadId,
+            intentId: record.intentId,
+            // 只撤还没开始发送的：已经在路上的由宿主拒绝，而不是被当成「已放弃」。
+            expectedStatus: "queued",
+            expectedDeliveryCertainty: "not-dispatched",
+            createdAt: host.now()
+          });
+          return true;
+        },
+        t("queue.withdrawFailed")
+      );
+    } else {
+      void run(
+        record,
+        async () => {
+          await host.dispatch({
+            type: "thread.turn-queue.resume",
+            commandId: host.newId(),
+            threadId: record.threadId,
+            createdAt: host.now()
+          });
+          return true;
+        },
+        t("queue.resumeFailed")
+      );
+    }
+    return handledWith(null);
+  };
+  return { noteQueued, refresh, click };
+};
+
 // src/telegramApi.ts
 var API_BASE = "https://api.telegram.org";
 var POLL_TIMEOUT_SECONDS = 45;
@@ -133411,28 +134849,19 @@ var TelegramApiError = class extends Error {
 var isNotModified = (error) => error instanceof TelegramApiError && error.code === 400 && error.message.toLowerCase().includes("message is not modified");
 var PHOTO_NAME = "photo.jpg";
 var PHOTO_MIME = "image/jpeg";
-var mimeFromName2 = (name) => {
-  const ext = name.slice(name.lastIndexOf(".") + 1).toLowerCase();
-  const known = {
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    gif: "image/gif",
-    webp: "image/webp",
-    pdf: "application/pdf",
-    txt: "text/plain",
-    md: "text/markdown",
-    json: "application/json",
-    csv: "text/csv"
-  };
-  return known[ext] ?? "application/octet-stream";
-};
-var resourceOf = (message) => {
+var withSize = (size) => size === void 0 ? {} : { sizeBytes: size };
+var resourceOf2 = (message) => {
   const photo = message.photo;
   if (photo !== void 0 && photo.length > 0) {
     const largest = photo[photo.length - 1];
     if (largest !== void 0) {
-      return { fileId: largest.file_id, name: PHOTO_NAME, mimeType: PHOTO_MIME, kind: "image" };
+      return {
+        fileId: largest.file_id,
+        name: PHOTO_NAME,
+        mimeType: PHOTO_MIME,
+        kind: "image",
+        ...withSize(largest.file_size)
+      };
     }
   }
   const document2 = message.document;
@@ -133441,12 +134870,38 @@ var resourceOf = (message) => {
     return {
       fileId: document2.file_id,
       name,
-      mimeType: document2.mime_type ?? mimeFromName2(name),
-      kind: "file"
+      mimeType: document2.mime_type ?? mimeFromName(name),
+      kind: "file",
+      ...withSize(document2.file_size)
+    };
+  }
+  const media = [
+    [message.voice, "voice.ogg", "audio/ogg"],
+    [message.audio, "audio", "application/octet-stream"],
+    [message.video, "video.mp4", "video/mp4"],
+    [message.video_note, "video-note.mp4", "video/mp4"],
+    [message.animation, "animation.mp4", "video/mp4"]
+  ];
+  for (const [entry, fallbackName, fallbackMime] of media) {
+    if (entry === void 0) continue;
+    const name = entry.file_name ?? fallbackName;
+    return {
+      fileId: entry.file_id,
+      name,
+      mimeType: entry.mime_type ?? (entry.file_name === void 0 ? fallbackMime : mimeFromName(name)),
+      kind: "file",
+      ...withSize(entry.file_size)
     };
   }
   return null;
 };
+var unsupportedTypeOf = (message) => {
+  for (const type of ["sticker", "location", "venue", "contact", "poll", "dice"]) {
+    if (message[type] !== void 0) return type;
+  }
+  return null;
+};
+var TELEGRAM_DOWNLOAD_LIMIT_BYTES = 20 * 1024 * 1024;
 var splitForTelegram = (text2, limit = TELEGRAM_TEXT_MAX_CHARS) => splitMessage(text2, limit);
 var nextOffset = (updates, current) => updates.reduce((offset, update) => Math.max(offset, update.update_id + 1), current);
 var commandForBot = (text2, botUsername) => {
@@ -133476,6 +134931,24 @@ var makeTelegramApi = (input) => {
     }
     return envelope.result;
   };
+  const upload = async (method, field, chatId, file) => {
+    const form = new FormData();
+    form.set("chat_id", chatId);
+    form.set(field, new Blob([new Uint8Array(file.bytes)], { type: file.mimeType }), file.name);
+    const response = await input.http(`${API_BASE}/bot${input.token}/${method}`, {
+      method: "POST",
+      body: form
+    });
+    const envelope = await response.json();
+    if (envelope.ok !== true) {
+      throw new TelegramApiError(
+        method,
+        envelope.error_code,
+        envelope.description ?? "no reason",
+        envelope.parameters?.retry_after
+      );
+    }
+  };
   const keyboard = (rows) => ({
     inline_keyboard: rows.map(
       (row) => row.map((button) => ({ text: button.text, callback_data: button.data }))
@@ -133544,41 +135017,38 @@ var makeTelegramApi = (input) => {
       callback_query_id: callbackQueryId,
       ...text2 === void 0 ? {} : { text: text2 }
     }),
-    sendPhoto: async (chatId, photo) => {
-      const form = new FormData();
-      form.set("chat_id", chatId);
-      form.set(
-        "photo",
-        new Blob([new Uint8Array(photo.bytes)], { type: photo.mimeType }),
-        photo.name
-      );
-      const response = await input.http(`${API_BASE}/bot${input.token}/sendPhoto`, {
-        method: "POST",
-        body: form
-      });
-      const envelope = await response.json();
-      if (envelope.ok !== true) {
-        throw new TelegramApiError(
-          "sendPhoto",
-          envelope.error_code,
-          envelope.description ?? "no reason"
-        );
-      }
-    },
+    sendPhoto: (chatId, photo) => upload("sendPhoto", "photo", chatId, photo),
+    /** 以文件形式发（不压缩、不限尺寸比例）：什么类型都行，音频与视频也走这条。 */
+    sendDocument: (chatId, file) => upload("sendDocument", "document", chatId, file),
     /** 取一个文件的字节。要两步：先换路径，再按路径下载。 */
-    fetchFile: async (fileId) => {
-      const file = await call("getFile", { file_id: fileId });
+    fetchFile: async (fileId, maxBytes) => {
+      const file = await call("getFile", {
+        file_id: fileId
+      }).catch((error) => {
+        if (error instanceof TelegramApiError && error.code === 400 && error.message.toLowerCase().includes("too big")) {
+          throw new ImResourceTooLargeError(TELEGRAM_DOWNLOAD_LIMIT_BYTES);
+        }
+        throw error;
+      });
       const path = file.file_path;
       if (path === void 0) throw new TelegramApiError("getFile", void 0, "no file_path");
       const response = await input.http(`${API_BASE}/file/bot${input.token}/${path}`);
       if (!response.ok) {
         throw new TelegramApiError("file", response.status, "download failed");
       }
-      return new Uint8Array(await response.arrayBuffer());
+      return readBodyLimited(response, maxBytes);
     }
   };
 };
 
+// src/telegramChoice.ts
+var renderChoiceCard = (card) => ({
+  text: [card.title, card.heading ?? "", card.body, card.note ?? ""].filter((part) => part !== "").join("\n\n"),
+  rows: card.rows.filter((row) => row.length > 0).map(
+    (row) => row.map((button) => ({ text: button.label, data: button.token }))
+  )
+});
+
 // src/telegramPanel.ts
 var PANEL_DATA_PREFIX = "pn:";
 var renderPanel = (card, version) => {
@@ -133609,7 +135079,7 @@ var parsePanelData = (data) => {
 
 // src/plainTurnText.ts
 var RUNNING_LABEL_MAX_CHARS = 200;
-var clip2 = (text2, max) => {
+var clip3 = (text2, max) => {
   const chars = Array.from(text2);
   return chars.length <= max ? text2 : `${chars.slice(0, max - 1).join("")}\u2026`;
 };
@@ -133618,7 +135088,7 @@ var turnTextParts = (view, t) => {
   if (view.omitted > 0) names.unshift(t("card.step.omitted", { count: view.omitted }));
   const headLines = [view.title === "" ? t("card.untitled") : view.title];
   if (names.length > 0) headLines.push(names.join(" \u2192 "));
-  if (view.running !== null) headLines.push(`\u{1F527} ${clip2(view.running, RUNNING_LABEL_MAX_CHARS)}`);
+  if (view.running !== null) headLines.push(`\u{1F527} ${clip3(view.running, RUNNING_LABEL_MAX_CHARS)}`);
   const body = view.body.trim();
   const footLines = [];
   if (view.status === "working") {
@@ -133695,14 +135165,14 @@ var tokenOf = (binding) => binding.values["telegramToken"] ?? "";
 var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var makeTelegramAdapter = (deps) => {
   const apis = /* @__PURE__ */ new Map();
-  const sleep = deps.sleep ?? defaultSleep;
+  const sleep2 = deps.sleep ?? defaultSleep;
   const t = deps.translate;
   const withFloodWait = async (run) => {
     try {
       return await run();
     } catch (error) {
       if (error instanceof TelegramApiError && error.code === 429 && error.retryAfterSeconds !== void 0 && error.retryAfterSeconds <= FLOOD_WAIT_MAX_SECONDS) {
-        await sleep(error.retryAfterSeconds * 1e3);
+        await sleep2(error.retryAfterSeconds * 1e3);
         return run();
       }
       throw error;
@@ -133786,29 +135256,45 @@ var makeTelegramAdapter = (deps) => {
               const callback = update.callback_query;
               if (callback?.data !== void 0) {
                 const operatorId = callback.from === void 0 ? null : String(callback.from.id);
-                const notice = callback.data.startsWith(PANEL_DATA_PREFIX) ? panelClick(callback, operatorId, handlers) : handlers.onApproval(callback.data, operatorId);
+                const notice = callback.data.startsWith(PANEL_DATA_PREFIX) ? panelClick(callback, operatorId, handlers) : handlers.onButton(callback.data, operatorId);
                 await api.answerCallback(callback.id, notice ?? void 0).catch(() => void 0);
                 continue;
               }
               const message = update.message;
               if (message === void 0) continue;
-              const resource = resourceOf(message);
+              const resource = resourceOf2(message);
               const text2 = commandForBot(
                 (message.text ?? message.caption ?? "").trim(),
                 botUsername
               );
-              if (text2 === null || text2 === "" && resource === null) continue;
+              if (text2 === null) continue;
+              if (text2 === "" && resource === null) {
+                const unsupported = unsupportedTypeOf(message);
+                if (unsupported === null) continue;
+                handlers.onMessage({
+                  messageId: String(message.message_id),
+                  chatId: String(message.chat.id),
+                  senderId: message.from === void 0 ? null : String(message.from.id),
+                  text: "",
+                  resources: [],
+                  unsupportedType: unsupported
+                });
+                continue;
+              }
               handlers.onMessage({
                 messageId: String(message.message_id),
                 chatId: String(message.chat.id),
                 senderId: message.from === void 0 ? null : String(message.from.id),
                 text: text2,
-                resource: resource === null ? null : {
-                  key: resource.fileId,
-                  name: resource.name,
-                  mimeType: resource.mimeType,
-                  kind: resource.kind
-                }
+                resources: resource === null ? [] : [
+                  {
+                    key: resource.fileId,
+                    name: resource.name,
+                    mimeType: resource.mimeType,
+                    kind: resource.kind,
+                    ...resource.sizeBytes === void 0 ? {} : { sizeBytes: resource.sizeBytes }
+                  }
+                ]
               });
             }
           } catch (error) {
@@ -133835,8 +135321,23 @@ var makeTelegramAdapter = (deps) => {
     },
     sendImage: async (binding, image2) => {
       const api = await apiFor(binding);
-      await api.sendPhoto(binding.chatId, image2);
+      try {
+        await api.sendPhoto(binding.chatId, image2);
+      } catch (error) {
+        if (!(error instanceof TelegramApiError && error.code === 400)) throw error;
+        deps.log.info("telegram could not send the picture as a photo, sending it as a file", {
+          name: image2.name,
+          reason: error.message
+        });
+        await api.sendDocument(binding.chatId, image2);
+      }
     },
+    sendFile: async (binding, file) => {
+      const api = await apiFor(binding);
+      await api.sendDocument(binding.chatId, file);
+    },
+    // 单张照片 10 MB、单个文件 50 MB。这两个数来自 Bot API 文档的记忆，本仓库里没有核对过。
+    outboundLimits: { imageBytes: 10 * 1024 * 1024, fileBytes: 50 * 1024 * 1024 },
     askApproval: async (binding, request) => {
       const api = await apiFor(binding);
       return api.sendButtons(binding.chatId, request.body, request.options);
@@ -133906,9 +135407,24 @@ ${line}`
         panelKeyboards.set(key, { version, actions: rendered.actions });
       }
     },
+    choiceCards: {
+      open: async (binding, card) => {
+        const api = await apiFor(binding);
+        const rendered = renderChoiceCard(card);
+        return withFloodWait(() => api.sendOne(binding.chatId, rendered.text, rendered.rows));
+      },
+      update: async (binding, cardId, card) => {
+        const api = await apiFor(binding);
+        const rendered = renderChoiceCard(card);
+        await withFloodWait(
+          () => api.editMessage(binding.chatId, cardId, rendered.text, rendered.rows)
+        );
+      }
+    },
+    downloadLimitBytes: TELEGRAM_DOWNLOAD_LIMIT_BYTES,
     fetchResource: async (binding, input) => {
       const api = await apiFor(binding);
-      return api.fetchFile(input.resource.key);
+      return api.fetchFile(input.resource.key, input.maxBytes);
     }
   };
 };
@@ -134137,34 +135653,177 @@ var makeTurnCards = (deps) => {
   };
 };
 
+// src/wecomUpload.ts
+import * as NodeCrypto from "node:crypto";
+var WECOM_CHUNK_BYTES = 512 * 1024;
+var WECOM_MAX_CHUNKS = 100;
+var WECOM_MIN_UPLOAD_BYTES = 5;
+var FILENAME_MAX_BYTES = 256;
+var CHUNK_RETRY_BACKOFF_MS = [500, 1e3];
+var utf82 = new TextEncoder();
+var concurrencyFor = (chunks) => chunks <= 4 ? chunks : chunks <= 10 ? 3 : 2;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var clampName = (name) => {
+  if (utf82.encode(name).byteLength <= FILENAME_MAX_BYTES) return name;
+  const chars = [...name];
+  while (chars.length > 1 && utf82.encode(chars.join("")).byteLength > FILENAME_MAX_BYTES) {
+    chars.pop();
+  }
+  return chars.join("");
+};
+var uploadWecomMedia = async (input) => {
+  const { bytes } = input;
+  if (bytes.byteLength < WECOM_MIN_UPLOAD_BYTES) {
+    throw new Error(`WeCom needs a file of at least ${String(WECOM_MIN_UPLOAD_BYTES)} bytes`);
+  }
+  const totalChunks = Math.ceil(bytes.byteLength / WECOM_CHUNK_BYTES);
+  if (totalChunks > WECOM_MAX_CHUNKS) {
+    throw new Error(
+      `the file needs ${String(totalChunks)} chunks, WeCom allows ${String(WECOM_MAX_CHUNKS)}`
+    );
+  }
+  const init = await input.request("aibot_upload_media_init", {
+    type: input.type,
+    filename: clampName(input.filename),
+    total_size: bytes.byteLength,
+    total_chunks: totalChunks,
+    md5: NodeCrypto.createHash("md5").update(bytes).digest("hex")
+  });
+  const uploadId = init.upload_id;
+  if (typeof uploadId !== "string" || uploadId === "") {
+    throw new Error("WeCom upload init returned no upload_id");
+  }
+  const sendChunk = async (index) => {
+    const part = bytes.subarray(index * WECOM_CHUNK_BYTES, (index + 1) * WECOM_CHUNK_BYTES);
+    const body = {
+      upload_id: uploadId,
+      chunk_index: index,
+      base64_data: Buffer.from(part).toString("base64")
+    };
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        await input.request("aibot_upload_media_chunk", body);
+        return;
+      } catch (error) {
+        const backoff = CHUNK_RETRY_BACKOFF_MS[attempt];
+        if (backoff === void 0) throw error;
+        await sleep(backoff);
+      }
+    }
+  };
+  let next = 0;
+  let failed = null;
+  const worker = async () => {
+    while (failed === null) {
+      const index = next;
+      next += 1;
+      if (index >= totalChunks) return;
+      try {
+        await sendChunk(index);
+      } catch (error) {
+        failed ??= error;
+        return;
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: concurrencyFor(totalChunks) }, () => worker()));
+  if (failed !== null) throw failed;
+  const finish = await input.request("aibot_upload_media_finish", { upload_id: uploadId });
+  const mediaId = finish.media_id;
+  if (typeof mediaId !== "string" || mediaId === "") {
+    throw new Error("WeCom upload finish returned no media_id");
+  }
+  return mediaId;
+};
+
 // src/wecomApi.ts
 var DEFAULT_WECOM_ENDPOINT = "wss://openws.work.weixin.qq.com/wssvr/";
 var PING_INTERVAL_MS = 3e4;
 var MAX_MISSED_PONGS = 2;
 var SUBSCRIBE_TIMEOUT_MS = 1e4;
 var SEND_ACK_TIMEOUT_MS = 5e3;
+var UPLOAD_ACK_TIMEOUT_MS = 15e3;
 var WECOM_TEXT_MAX_CHARS = 4e3;
 var normalizeWecomEndpoint = (endpoint) => `${endpoint.replace(/\/+$/, "")}/`;
+var mediaResource = (payload, defaults) => typeof payload?.url === "string" && payload.url !== "" ? {
+  url: payload.url,
+  aesKey: typeof payload.aeskey === "string" && payload.aeskey !== "" ? payload.aeskey : void 0,
+  ...defaults
+} : null;
 var parseWecomMessage = (frame, botId) => {
   const body = frame.body;
   if (body === void 0) return null;
   const messageId = body.msgid;
   const chatId = body.chatid ?? body.from?.userid;
   if (typeof messageId !== "string" || typeof chatId !== "string") return null;
-  if (body.msgtype !== "text") return null;
-  const raw = body.text?.content;
-  if (typeof raw !== "string") return null;
   const ownIds = [...new Set([body.aibotid, botId].filter((id) => Boolean(id)))];
+  const stripOwn = (value) => ownIds.reduce((rest, id) => rest.replaceAll(`@${id}`, ""), value);
+  let mentionSource = "";
+  let text2 = "";
+  const resources = [];
+  switch (body.msgtype) {
+    case "text": {
+      const raw = body.text?.content;
+      if (typeof raw !== "string") return null;
+      mentionSource = raw;
+      text2 = stripOwn(raw).trim();
+      break;
+    }
+    case "voice": {
+      const transcript = body.voice?.content;
+      if (typeof transcript !== "string" || transcript.trim() === "") return null;
+      mentionSource = transcript;
+      text2 = stripOwn(transcript).trim();
+      break;
+    }
+    case "image":
+    case "file":
+    case "video": {
+      const resource = body.msgtype === "image" ? mediaResource(body.image, { name: "image.png", mimeType: "image/png", kind: "image" }) : body.msgtype === "file" ? mediaResource(body.file, {
+        name: "file",
+        mimeType: "application/octet-stream",
+        kind: "file"
+      }) : mediaResource(body.video, { name: "video.mp4", mimeType: "video/mp4", kind: "file" });
+      if (resource === null) return null;
+      resources.push(resource);
+      break;
+    }
+    case "mixed": {
+      const parts = [];
+      for (const item of body.mixed?.msg_item ?? []) {
+        if (item.msgtype === "text" && typeof item.text?.content === "string") {
+          mentionSource += item.text.content;
+          const part = stripOwn(item.text.content).trim();
+          if (part !== "") parts.push(part);
+        } else if (item.msgtype === "image") {
+          const resource = mediaResource(item.image, {
+            name: `image-${String(resources.length + 1)}.png`,
+            mimeType: "image/png",
+            kind: "image"
+          });
+          if (resource === null) continue;
+          resources.push(resource);
+          parts.push(`<image ${String(resources.length)}>`);
+        }
+      }
+      if (parts.length === 0) return null;
+      text2 = parts.join("\n");
+      break;
+    }
+    default:
+      return null;
+  }
+  const mentioned = ownIds.some((id) => mentionSource.includes(`@${id}`));
   const chatType = body.chattype ?? "single";
-  const mentioned = ownIds.some((id) => raw.includes(`@${id}`));
-  const text2 = ownIds.reduce((value, id) => value.replaceAll(`@${id}`, ""), raw).trim();
   return {
     messageId,
     chatId,
     senderUserId: body.from?.userid ?? null,
     text: text2,
+    resources,
     requestId: frame.headers?.req_id ?? null,
-    chatType: mentioned ? "single" : chatType
+    chatType: mentioned ? "single" : chatType,
+    conversation: chatType === "group" ? "group" : "single"
   };
 };
 var splitForWecom = (text2, limit = WECOM_TEXT_MAX_CHARS) => splitMessage(text2, limit);
@@ -134173,6 +135832,7 @@ var runWecomClient = (input) => {
   let sequence = 0;
   const nextRequestId = (kind) => `${kind}_${++sequence}`;
   const pendingAcks = /* @__PURE__ */ new Map();
+  const conversations = /* @__PURE__ */ new Map();
   const pendingRequests = /* @__PURE__ */ new Map();
   const openStreams = /* @__PURE__ */ new Map();
   const subscribeId = nextRequestId("aibot_subscribe");
@@ -134181,11 +135841,11 @@ var runWecomClient = (input) => {
   let finished = false;
   const ended = Promise.withResolvers();
   const send = (frame) => input.socket.send(JSON.stringify(frame));
-  const settleAck = (requestId, error) => {
+  const settleAck = (requestId, error, frame) => {
     const pending = pendingAcks.get(requestId);
     if (pending === void 0) return;
     pendingAcks.delete(requestId);
-    if (error === null) pending.resolve();
+    if (error === null) pending.resolve(frame);
     else pending.reject(error);
   };
   const handleFrame = (raw) => {
@@ -134206,7 +135866,7 @@ var runWecomClient = (input) => {
       const error = typeof frame.errcode === "number" && frame.errcode !== 0 ? new Error(`WeCom ack failed: ${String(frame.errcode)} ${frame.errmsg ?? ""}`) : null;
       const stream = openStreams.get(requestId);
       if (stream !== void 0 && error !== null) stream.failed = true;
-      settleAck(requestId, error);
+      settleAck(requestId, error, frame);
       return;
     }
     if (frame.cmd !== "aibot_msg_callback") return;
@@ -134248,7 +135908,7 @@ var runWecomClient = (input) => {
   }, PING_INTERVAL_MS);
   void readLoop();
   const subscribed = new Promise((resolve, reject) => {
-    pendingAcks.set(subscribeId, { resolve, reject });
+    pendingAcks.set(subscribeId, { resolve: () => resolve(), reject });
     setTimeout(() => {
       if (pendingAcks.delete(subscribeId)) reject(new Error("ETIMEDOUT: WeCom subscribe ack"));
     }, SUBSCRIBE_TIMEOUT_MS);
@@ -134285,7 +135945,7 @@ var runWecomClient = (input) => {
       }
       const requestId = nextRequestId("aibot_send_msg");
       const ack = new Promise((resolve, reject) => {
-        pendingAcks.set(requestId, { resolve, reject });
+        pendingAcks.set(requestId, { resolve: () => resolve(), reject });
         setTimeout(() => {
           if (pendingAcks.delete(requestId)) resolve();
         }, SEND_ACK_TIMEOUT_MS);
@@ -134305,6 +135965,50 @@ var runWecomClient = (input) => {
       }
     }
   };
+  const request = async (cmd, body) => {
+    const requestId = nextRequestId(cmd);
+    let timer;
+    const ack = new Promise((resolve, reject) => {
+      pendingAcks.set(requestId, { resolve, reject });
+      timer = setTimeout(() => {
+        if (pendingAcks.delete(requestId)) {
+          reject(
+            new Error(
+              `WeCom did not acknowledge ${cmd} within ${String(UPLOAD_ACK_TIMEOUT_MS / 1e3)} s`
+            )
+          );
+        }
+      }, UPLOAD_ACK_TIMEOUT_MS);
+    });
+    try {
+      const [, frame] = await Promise.all([
+        send({ cmd, headers: { req_id: requestId }, body }),
+        ack
+      ]);
+      return frame?.body ?? {};
+    } catch (error) {
+      pendingAcks.delete(requestId);
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  const sendMedia = async (chatId, kind, media) => {
+    const mediaId = await uploadWecomMedia({
+      request,
+      type: kind,
+      filename: media.name,
+      bytes: media.bytes
+    });
+    const conversation = conversations.get(chatId);
+    await request("aibot_send_msg", {
+      chatid: chatId,
+      // 不知道（重启后还没收到过这个会话的消息）就不填：发文字也是只给 chatid。
+      ...conversation === void 0 ? {} : { chat_type: conversation === "group" ? 2 : 1 },
+      msgtype: kind,
+      [kind]: { media_id: mediaId }
+    });
+  };
   const openStream = (chatId) => {
     const requestId = pendingRequests.get(chatId);
     if (requestId === void 0) return null;
@@ -134336,6 +136040,10 @@ var runWecomClient = (input) => {
   };
   return {
     sendText,
+    sendMedia,
+    rememberConversation: (chatId, conversation) => {
+      conversations.set(chatId, conversation);
+    },
     openStream,
     rememberRequest: (chatId, requestId) => {
       if (requestId !== null) pendingRequests.set(chatId, requestId);
@@ -134350,6 +136058,83 @@ var runWecomClient = (input) => {
   };
 };
 
+// src/wecomMedia.ts
+import * as NodeCrypto2 from "node:crypto";
+var PADDING_BLOCK = 32;
+var KEY_BYTES = 32;
+var IV_BYTES = 16;
+var AES_BLOCK = 16;
+var WecomDecryptError = class extends Error {
+  constructor(reason) {
+    super(`wecom media could not be decrypted: ${reason}`);
+    this.name = "WecomDecryptError";
+  }
+};
+var decryptWecomMedia = (cipher, aesKey) => {
+  const key = Buffer.from(aesKey, "base64");
+  if (key.byteLength !== KEY_BYTES) throw new WecomDecryptError("the key is not 32 bytes");
+  if (cipher.byteLength === 0 || cipher.byteLength % AES_BLOCK !== 0) {
+    throw new WecomDecryptError("the ciphertext is not a whole number of blocks");
+  }
+  const decipher = NodeCrypto2.createDecipheriv("aes-256-cbc", key, key.subarray(0, IV_BYTES));
+  decipher.setAutoPadding(false);
+  const plain = Buffer.concat([decipher.update(cipher), decipher.final()]);
+  const pad = plain[plain.byteLength - 1] ?? 0;
+  if (pad < 1 || pad > PADDING_BLOCK || pad > plain.byteLength) {
+    throw new WecomDecryptError("the padding length is out of range");
+  }
+  for (let index = plain.byteLength - pad; index < plain.byteLength; index += 1) {
+    if (plain[index] !== pad) throw new WecomDecryptError("the padding bytes are not all equal");
+  }
+  return new Uint8Array(plain.subarray(0, plain.byteLength - pad));
+};
+var decodeQuietly = (value) => {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+};
+var filenameFromContentDisposition = (header) => {
+  if (header === null) return void 0;
+  const extended = /filename\*\s*=\s*(?:UTF-8|utf-8)''([^;]+)/i.exec(header);
+  if (extended?.[1] !== void 0) {
+    const name = decodeQuietly(extended[1].trim());
+    if (name !== "") return name;
+  }
+  const quoted = /filename\s*=\s*"([^"]*)"/i.exec(header);
+  const plain = quoted === null ? /filename\s*=\s*([^;]+)/i.exec(header) : null;
+  const raw = quoted?.[1] ?? plain?.[1]?.trim();
+  if (raw === void 0 || raw === "") return void 0;
+  return decodeQuietly(raw);
+};
+var fetchWecomMedia = async (input) => {
+  const response = await input.http(input.url);
+  if (!response.ok) {
+    await response.body?.cancel().catch(() => void 0);
+    throw new Error(`wecom media fetch failed: HTTP ${String(response.status)}`);
+  }
+  const name = filenameFromContentDisposition(response.headers.get("content-disposition"));
+  const encrypted = input.aesKey !== void 0 && input.aesKey !== "";
+  let body;
+  try {
+    body = await readBodyLimited(
+      response,
+      encrypted ? input.maxBytes + PADDING_BLOCK : input.maxBytes
+    );
+  } catch (error) {
+    if (error instanceof ImResourceTooLargeError) throw new ImResourceTooLargeError(input.maxBytes);
+    throw error;
+  }
+  if (!encrypted) {
+    input.onUnencrypted?.();
+    return { bytes: body, name };
+  }
+  const bytes = decryptWecomMedia(body, input.aesKey ?? "");
+  if (bytes.byteLength > input.maxBytes) throw new ImResourceTooLargeError(input.maxBytes);
+  return { bytes, name };
+};
+
 // src/wecomAdapter.ts
 var WECOM_CARD_THROTTLE_MS = 400;
 var LIVE_STREAM_LIMIT = 200;
@@ -134403,6 +136188,12 @@ ${kept}`;
       await entry.client.sendText(entry.chatId, chunk);
     }
   };
+  const sendMedia = async (binding, kind, media) => {
+    const client = clients.get(binding.rowId);
+    if (client === void 0) throw new Error("WeCom is not connected right now");
+    await client.sendMedia(binding.chatId, kind, media);
+    deps.log.info("wecom delivered a file", { name: media.name, as: kind });
+  };
   return {
     platform: "wecom",
     icon: "wecom",
@@ -134436,13 +136227,19 @@ ${kept}`;
             onMessage: (message) => {
               if (message.chatType !== "single") return;
               client.rememberRequest(message.chatId, message.requestId);
+              client.rememberConversation(message.chatId, message.conversation);
               handlers.onMessage({
                 messageId: message.messageId,
                 chatId: message.chatId,
                 senderId: message.senderUserId,
                 text: message.text,
-                // 企微这一版不收附件，先不假装支持。
-                resource: null
+                // 下载地址与密钥打成一个键：核心只管把它原样交回来。
+                resources: message.resources.map((resource) => ({
+                  key: JSON.stringify({ url: resource.url, aesKey: resource.aesKey ?? null }),
+                  name: resource.name,
+                  mimeType: resource.mimeType,
+                  kind: resource.kind
+                }))
               });
             }
           }
@@ -134520,9 +136317,33 @@ ${kept}`;
         if (view.status !== "working") liveStreams.delete(key);
       }
     },
+    sendImage: (binding, image2) => sendMedia(binding, "image", image2),
+    sendFile: (binding, file) => sendMedia(binding, "file", file),
+    // 图 10 MB（只认 png / jpg / jpeg / gif）、文件 20 MB，来自企微官方文档「智能机器人长连接」。
+    outboundLimits: { imageBytes: 10 * 1024 * 1024, fileBytes: 20 * 1024 * 1024, minBytes: 5 },
+    imageMimeTypes: /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/gif"]),
     answerByText: (_binding, text2, options) => {
       const index = optionIndexFrom(text2, options.length);
       return index === null ? null : options[index - 1]?.token ?? null;
+    },
+    fetchResource: async (binding, input) => {
+      const parsed = JSON.parse(input.resource.key);
+      const media = await fetchWecomMedia({
+        http: deps.http,
+        url: parsed.url,
+        aesKey: parsed.aesKey ?? void 0,
+        maxBytes: input.maxBytes,
+        onUnencrypted: () => {
+          deps.log.info("wecom media arrived without a key, used as is", {
+            group: binding.displayName
+          });
+        }
+      });
+      return {
+        bytes: media.bytes,
+        name: media.name,
+        mimeType: media.name === void 0 ? void 0 : mimeFromName(media.name)
+      };
     }
   };
 };
@@ -134536,6 +136357,7 @@ var TITLE_MAX_CHARS = 72;
 var DEFAULT_PLATFORM = "lark";
 var SESSION_SCAN_LIMIT = 50;
 var ARCHIVED_REPLY_COOLDOWN_MS = 10 * 6e4;
+var UNSUPPORTED_REPLY_COOLDOWN_MS = 6e4;
 var INBOUND_RUNTIME_MODES = /* @__PURE__ */ new Set([
   "approval-required",
   "auto-accept-edits",
@@ -134548,7 +136370,7 @@ var readString = (row, key) => {
   const value = row[key];
   return typeof value === "string" ? value.trim() : "";
 };
-var describeError = (error) => error instanceof Error ? error.message : String(error);
+var describeError2 = (error) => error instanceof Error ? error.message : String(error);
 var titleFrom = (text2) => text2.replace(/\s+/g, " ").slice(0, TITLE_MAX_CHARS) || "Chat thread";
 var imPlugin = definePlugin({
   id: "im",
@@ -134582,6 +136404,7 @@ var imPlugin = definePlugin({
       makeWecomAdapter({
         // 企微不需要厂商 SDK：全程 JSON over WebSocket，走插件面那条出网长连接。
         connectSocket: (url) => ctx.socket.connect({ url }),
+        http: ctx.http,
         translate: t,
         log: {
           info: (message, fields) => ctx.log.info(message, fields),
@@ -134753,7 +136576,7 @@ var imPlugin = definePlugin({
         } catch (error) {
           ctx.log.warn("chat could not deliver an image", {
             name: attachment.name,
-            error: describeError(error)
+            error: describeError2(error)
           });
         }
       }
@@ -134764,7 +136587,7 @@ var imPlugin = definePlugin({
       try {
         await adapterFor(binding.platform)?.sendText(binding, text2);
       } catch (error) {
-        ctx.log.warn("chat could not deliver", { error: describeError(error) });
+        ctx.log.warn("chat could not deliver", { error: describeError2(error) });
       }
     };
     const projectByThread = /* @__PURE__ */ new Map();
@@ -134798,7 +136621,7 @@ var imPlugin = definePlugin({
         acknowledgements.set(threadId, pending);
         ctx.log.info("chat acknowledged a message", { threadId, messageId });
       } catch (error) {
-        ctx.log.warn("chat could not acknowledge the message", { error: describeError(error) });
+        ctx.log.warn("chat could not acknowledge the message", { error: describeError2(error) });
       }
     };
     const clearWorking = async (binding, threadId) => {
@@ -134811,7 +136634,7 @@ var imPlugin = definePlugin({
           await adapter.clearAcknowledge(binding, entry.messageId, entry.ackId);
         } catch (error) {
           ctx.log.warn("chat could not clear the acknowledgement", {
-            error: describeError(error)
+            error: describeError2(error)
           });
         }
       }
@@ -134898,7 +136721,7 @@ ${final.text}`;
         state = restored;
       },
       (error) => {
-        ctx.log.warn("chat could not restore its saved state", { error: describeError(error) });
+        ctx.log.warn("chat could not restore its saved state", { error: describeError2(error) });
       }
     );
     let persisting = Promise.resolve();
@@ -134907,7 +136730,7 @@ ${final.text}`;
       persisting = persisting.then(() => ctx.events.append({ name, aggregate: { kind: "plugin", id: ctx.id }, data })).then(
         () => void 0,
         (error) => {
-          ctx.log.warn("chat could not save its state", { name, error: describeError(error) });
+          ctx.log.warn("chat could not save its state", { name, error: describeError2(error) });
         }
       );
     };
@@ -134915,7 +136738,7 @@ ${final.text}`;
       commit("chat-updated", { chatKey, threadId });
     };
     const outbound = makeKeyedQueue((error) => {
-      ctx.log.warn("chat could not deliver a card", { error: describeError(error) });
+      ctx.log.warn("chat could not deliver a card", { error: describeError2(error) });
     });
     const settleApprovalCard = async (approval, settlement) => {
       if (approval.cardId === void 0) return;
@@ -134925,7 +136748,7 @@ ${final.text}`;
       try {
         await settle(binding, approval.cardId, settlement);
       } catch (error) {
-        ctx.log.warn("chat could not update the approval card", { error: describeError(error) });
+        ctx.log.warn("chat could not update the approval card", { error: describeError2(error) });
       }
     };
     const answerApproval = async (approval, decision, label) => {
@@ -134977,12 +136800,12 @@ ${final.text}`;
       },
       endOf: async (threadId) => {
         const stopped = stopRequested.delete(threadId);
-        const failure = failureSummaries.get(threadId);
+        const failure2 = failureSummaries.get(threadId);
         failureSummaries.delete(threadId);
         const thread = await ctx.projections.getThread(threadId).catch(() => null);
         const session = thread?.session;
         if (session?.status === "error") {
-          return { status: "error", errorText: session.lastError ?? failure ?? null };
+          return { status: "error", errorText: session.lastError ?? failure2 ?? null };
         }
         if (stopped || session?.status === "interrupted" || session?.status === "stopped") {
           return { status: "interrupted", errorText: null };
@@ -135002,7 +136825,7 @@ ${final.text}`;
         return () => clearTimeout(timer);
       },
       warn: (message, error) => {
-        ctx.log.warn(`chat ${message}`, { error: describeError(error) });
+        ctx.log.warn(`chat ${message}`, { error: describeError2(error) });
       }
     });
     ctx.events.on(TURN_PROGRESS_TRIGGER_KIND, (event) => {
@@ -135028,7 +136851,7 @@ ${final.text}`;
             );
           } catch (error) {
             ctx.log.warn("chat could not mark a stale card as interrupted", {
-              error: describeError(error)
+              error: describeError2(error)
             });
           }
         }
@@ -135049,7 +136872,7 @@ ${final.text}`;
         const record = state.approvals[offer.requestId];
         if (record?.resolved === true) await settleApprovalCard(record, { kind: "elsewhere" });
       } catch (error) {
-        ctx.log.warn("chat could not ask for the approval", { error: describeError(error) });
+        ctx.log.warn("chat could not ask for the approval", { error: describeError2(error) });
       }
     };
     ctx.events.on("thread.approval-pending", async (event) => {
@@ -135097,13 +136920,116 @@ ${final.text}`;
     });
     ctx.events.on(REQUEST_RESOLVED_TRIGGER_KIND, async (event) => {
       const resolved = readRequestResolved(event);
-      if (resolved === null || resolved.requestKind !== "approval") return;
+      if (resolved === null) return;
       await ready;
+      if (resolved.requestKind === "user-input") {
+        questionFlow.resolved(
+          resolved.requestId,
+          resolved.outcome === "cancelled" ? "cancelled" : "answered"
+        );
+        return;
+      }
       const record = state.approvals[resolved.requestId];
       if (record === void 0 || record.resolved) return;
       commit("approval-resolved", { requestId: resolved.requestId });
       outbound(record.chatKey, () => settleApprovalCard(record, { kind: "elsewhere" }));
     });
+    const bindingOfThread = (threadId) => readBindings().find((candidate) => chatOf(state, chatKeyOf(candidate)).threadId === threadId);
+    const flowHost = {
+      t,
+      state: () => state,
+      commit,
+      // 改卡必须排在回调应答之后：按钮点击的回调要先同步应答，飞书在应答不带改卡时会把卡
+      // 恢复成点击前的样子；所以这两条流的发卡与改卡都推迟一个宏任务再入群队列。
+      outbound: (chatKey, job) => {
+        setTimeout(() => outbound(chatKey, job), 0);
+      },
+      target: (chatKey) => {
+        const binding = bindingOfChat(chatKey);
+        const adapter = binding === void 0 ? void 0 : adapterFor(binding.platform);
+        return binding === void 0 || adapter === void 0 ? void 0 : { binding, adapter };
+      },
+      allowed: (chatKey, operatorId) => {
+        const binding = bindingOfChat(chatKey);
+        if (binding !== void 0 && isAllowedSender(binding, operatorId)) return true;
+        ctx.log.warn("chat ignored a button click from someone not on the allow list", {
+          group: binding?.displayName ?? chatKey,
+          operator: operatorId
+        });
+        return false;
+      },
+      dispatch: (command) => ctx.commands.dispatch(command),
+      say: async (chatKey, text2) => {
+        const binding = bindingOfChat(chatKey);
+        if (binding !== void 0) await deliver(binding, text2);
+      },
+      newToken: () => crypto.randomUUID().slice(0, 8),
+      newId: () => crypto.randomUUID(),
+      now: () => (/* @__PURE__ */ new Date()).toISOString(),
+      warn: (message, error) => {
+        ctx.log.warn(`chat ${message}`, error === void 0 ? {} : { error: describeError2(error) });
+      }
+    };
+    const questionFlow = makeQuestionFlow(flowHost);
+    const queueFlow = makeQueueFlow(flowHost, {
+      readExecution: async (threadId) => {
+        const execution = await ctx.projections.getThreadExecution(threadId);
+        if (execution === null) return null;
+        return {
+          activeTurnId: execution.session?.activeTurnId ?? null,
+          queuePaused: execution.queuePaused,
+          intents: execution.turnIntents.map((intent) => ({
+            intentId: intent.intentId,
+            messageId: intent.messageId,
+            status: intent.status,
+            sequence: intent.sequence
+          }))
+        };
+      }
+    });
+    ctx.events.on(USER_INPUT_PENDING_TRIGGER_KIND, async (event) => {
+      const threadId = event.threadId;
+      if (threadId === null) return;
+      await ready;
+      const binding = bindingOfThread(threadId);
+      if (binding === void 0) return;
+      if (ctx.projections.listPendingUserInputs === void 0) {
+        ctx.log.warn("chat cannot show questions: the host cannot list them");
+        return;
+      }
+      try {
+        questionFlow.offer(
+          chatKeyOf(binding),
+          threadId,
+          await ctx.projections.listPendingUserInputs(threadId)
+        );
+      } catch (error) {
+        ctx.log.warn("chat could not read the pending questions", { error: describeError2(error) });
+      }
+    });
+    ctx.reactor({
+      name: "im.queue-cards",
+      events: [
+        "thread.session-set",
+        "thread.turn-intent-transitioned",
+        "thread.turn-queue-updated",
+        "thread.turn-queue-paused"
+      ],
+      handle: async (event) => {
+        const payload = event.payload;
+        if (typeof payload.threadId !== "string") return;
+        await ready;
+        const released = event.type === "thread.turn-intent-transitioned" && payload.status === "queued" && (payload.fromStatus !== "queued" || typeof payload.blockedReason === "string") && typeof payload.intentId === "string" ? payload.intentId : null;
+        queueFlow.refresh(payload.threadId, released);
+      }
+    });
+    const handleButtonClick = (token, operatorId) => {
+      const question = questionFlow.click(token, operatorId);
+      if (question.handled) return question.notice;
+      const queued = queueFlow.click(token, operatorId);
+      if (queued.handled) return queued.notice;
+      return handleApprovalClick(token, operatorId);
+    };
     const isAllowedSender = (binding, sender) => binding.allowedSenders.size === 0 || sender !== null && binding.allowedSenders.has(sender);
     const handleApprovalClick = (token, operatorId) => {
       const found = findApprovalByToken(state, token);
@@ -135121,12 +137047,13 @@ ${final.text}`;
       }
       void answerApproval(found.approval, found.button.decision, found.button.label).catch(
         (error) => {
-          ctx.log.warn("chat could not answer the approval", { error: describeError(error) });
+          ctx.log.warn("chat could not answer the approval", { error: describeError2(error) });
         }
       );
       return null;
     };
     const archivedReplyCooldown = makeCooldown(ARCHIVED_REPLY_COOLDOWN_MS, () => Date.now());
+    const unsupportedReplyCooldown = makeCooldown(UNSUPPORTED_REPLY_COOLDOWN_MS, () => Date.now());
     const alreadyHandled = (target, messageId) => {
       const key = `${chatKeyOf(target)}:${messageId}`;
       if (seen.has(key)) return true;
@@ -135138,33 +137065,103 @@ ${final.text}`;
       }
       return false;
     };
-    const collectAttachment = async (binding, threadId, message) => {
-      const resource = message.resource;
+    const pendingByChat = /* @__PURE__ */ new Map();
+    const pendingFor = (chatKey, threadId) => {
+      const existing = pendingByChat.get(chatKey);
+      if (existing !== void 0 && existing.threadId === threadId) return existing;
+      const fresh = { threadId, attachments: [], notes: [] };
+      pendingByChat.set(chatKey, fresh);
+      return fresh;
+    };
+    const failureForUser = (failure2) => failure2.kind === "tooLarge" ? t("reply.attachmentReason.tooLarge", { limit: formatMegabytes(failure2.limitBytes) }) : t(`reply.attachmentReason.${failure2.kind}`);
+    const failureForAgent = (failure2) => failure2.kind === "tooLarge" ? `it is over the ${formatMegabytes(failure2.limitBytes)} limit` : failure2.kind === "downloadFailed" ? "the download failed" : failure2.kind === "storeFailed" ? "it could not be saved" : "it is empty";
+    const collectResources = async (binding, threadId, messageId, resources, room) => {
       const adapter = adapterFor(binding.platform);
-      if (resource === null || adapter?.fetchResource === void 0) return [];
-      try {
-        const bytes = await adapter.fetchResource(binding, {
-          messageId: message.messageId,
-          resource
-        });
-        const stored = await ctx.attachments.store({
-          threadId,
-          name: resource.name,
-          mimeType: resource.mimeType,
-          bytes
-        });
-        ctx.log.info("chat stored an inbound attachment", {
-          name: stored.name,
-          sizeBytes: stored.sizeBytes
-        });
-        return [stored];
-      } catch (error) {
-        ctx.log.warn("chat dropped an inbound attachment", {
-          name: resource.name,
-          error: describeError(error)
-        });
-        return [];
+      const attachments = [];
+      const notes = [];
+      const reject = async (name, failure2) => {
+        notes.push(
+          `[the user also sent "${name}", which could not be taken: ${failureForAgent(failure2)}]`
+        );
+        await deliver(
+          binding,
+          t("reply.attachmentFailed", { name, reason: failureForUser(failure2) })
+        );
+      };
+      for (const resource of resources) {
+        const name = sanitizeAttachmentName(resource.name, "file");
+        if (attachments.length >= room) {
+          notes.push(`[the user also sent "${name}", which was left out: too many attachments]`);
+          await deliver(
+            binding,
+            t("reply.attachmentLimit", { max: MAX_ATTACHMENTS_PER_TURN, name })
+          );
+          continue;
+        }
+        const limitBytes = Math.min(
+          limitForKind(resource.kind),
+          adapter?.downloadLimitBytes ?? Number.POSITIVE_INFINITY
+        );
+        if (resource.sizeBytes !== void 0 && resource.sizeBytes > limitBytes) {
+          await reject(name, { kind: "tooLarge", limitBytes });
+          continue;
+        }
+        if (adapter?.fetchResource === void 0) {
+          await reject(name, { kind: "downloadFailed" });
+          continue;
+        }
+        let fetched;
+        try {
+          fetched = await adapter.fetchResource(binding, {
+            messageId,
+            resource,
+            maxBytes: limitBytes
+          });
+        } catch (error) {
+          ctx.log.warn("chat dropped an inbound attachment", {
+            name,
+            error: describeError2(error)
+          });
+          await reject(
+            name,
+            error instanceof ImResourceTooLargeError ? { kind: "tooLarge", limitBytes: error.limitBytes } : { kind: "downloadFailed" }
+          );
+          continue;
+        }
+        const bytes = fetched instanceof Uint8Array ? fetched : fetched.bytes;
+        const knownName = fetched instanceof Uint8Array ? void 0 : fetched.name;
+        const finalName = knownName === void 0 ? name : sanitizeAttachmentName(knownName, name);
+        const claimedMime = (fetched instanceof Uint8Array ? void 0 : fetched.mimeType) ?? resource.mimeType;
+        if (bytes.byteLength === 0) {
+          await reject(finalName, { kind: "empty" });
+          continue;
+        }
+        const mimeType = resolveMime(claimedMime, bytes);
+        if (bytes.byteLength > limitForMime(mimeType)) {
+          await reject(finalName, { kind: "tooLarge", limitBytes: limitForMime(mimeType) });
+          continue;
+        }
+        try {
+          const stored = await ctx.attachments.store({
+            threadId,
+            name: withImageExtension(finalName, mimeType),
+            mimeType,
+            bytes
+          });
+          ctx.log.info("chat stored an inbound attachment", {
+            name: stored.name,
+            sizeBytes: stored.sizeBytes
+          });
+          attachments.push(stored);
+        } catch (error) {
+          ctx.log.warn("chat dropped an inbound attachment", {
+            name: finalName,
+            error: describeError2(error)
+          });
+          await reject(finalName, { kind: "storeFailed" });
+        }
       }
+      return { attachments, notes };
     };
     const targetOf = (binding) => chatOf(state, chatKeyOf(binding)).target;
     const chatByRun = /* @__PURE__ */ new Map();
@@ -135282,7 +137279,7 @@ ${final.text}`;
             modelSelection: selection
           });
         } catch (error) {
-          ctx.log.warn("chat could not switch the thread model", { error: describeError(error) });
+          ctx.log.warn("chat could not switch the thread model", { error: describeError2(error) });
           await deliver(binding, t("model.setFailed"));
           return;
         }
@@ -135362,7 +137359,7 @@ ${final.text}`;
               return true;
             } catch (error) {
               ctx.log.warn("chat could not open the command panel", {
-                error: describeError(error)
+                error: describeError2(error)
               });
             }
           }
@@ -135409,6 +137406,37 @@ ${final.text}`;
           );
           return true;
         }
+        case "continue": {
+          const threadId = chatOf(state, chatKey).threadId ?? void 0;
+          let paused = false;
+          if (threadId !== void 0) {
+            try {
+              paused = (await ctx.projections.getThreadExecution(threadId))?.queuePaused === true;
+            } catch (error) {
+              ctx.log.warn("chat could not read the turn queue", { error: describeError2(error) });
+              await deliver(binding, t("command.continueFailed"));
+              return true;
+            }
+          }
+          if (threadId === void 0 || !paused) {
+            await deliver(binding, t("command.continueNothing"));
+            return true;
+          }
+          try {
+            await ctx.commands.dispatch({
+              type: "thread.turn-queue.resume",
+              commandId: crypto.randomUUID(),
+              threadId,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          } catch (error) {
+            ctx.log.warn("chat could not resume the turn queue", { error: describeError2(error) });
+            await deliver(binding, t("command.continueFailed"));
+            return true;
+          }
+          await deliver(binding, t("command.continued"));
+          return true;
+        }
         case "stop": {
           const threadId = chatOf(state, chatKey).threadId ?? void 0;
           if (threadId === void 0) {
@@ -135465,9 +137493,8 @@ ${final.text}`;
       }
     };
     const interactionModeOf = (chatKey) => chatOf(state, chatKey).plan ? "plan" : "default";
-    const startTurn = async (binding, message) => {
+    const ensureThread = async (binding, titleSeed) => {
       const chatKey = chatKeyOf(binding);
-      const text2 = message.text;
       let threadId = chatOf(state, chatKey).threadId ?? void 0;
       if (threadId !== void 0 && !await threadStillUsable(binding, threadId)) {
         ctx.log.info("chat dropped a saved thread that is no longer usable", {
@@ -135478,70 +137505,136 @@ ${final.text}`;
         threadId = void 0;
         await deliver(binding, t("reply.threadGone"));
       }
-      if (threadId === void 0) {
-        const project = await ctx.projections.getProject(binding.projectId);
-        if (project === null) {
-          ctx.log.warn("chat cannot start a thread: the configured project is gone", {
-            group: binding.displayName,
-            projectId: binding.projectId
-          });
-          return null;
-        }
-        const modelSelection = chatOf(state, chatKey).model ?? project.defaultModelSelection;
-        if (modelSelection === null) {
-          ctx.log.warn("chat cannot start a thread: the project has no default model", {
-            group: binding.displayName,
-            projectId: binding.projectId
-          });
-          await deliver(binding, t("reply.noDefaultModel", { title: project.title }));
-          return null;
-        }
-        const createdThreadId = crypto.randomUUID();
-        threadId = createdThreadId;
-        await ctx.commands.dispatch({
-          type: "thread.create",
-          commandId: crypto.randomUUID(),
-          threadId,
-          projectId: binding.projectId,
-          title: titleFrom(text2 || message.resource?.name || "Chat"),
-          modelSelection,
-          runtimeMode: binding.runtimeMode,
-          interactionMode: interactionModeOf(chatKey),
-          branch: null,
-          worktreePath: null,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      if (threadId !== void 0) return threadId;
+      const project = await ctx.projections.getProject(binding.projectId);
+      if (project === null) {
+        ctx.log.warn("chat cannot start a thread: the configured project is gone", {
+          group: binding.displayName,
+          projectId: binding.projectId
         });
-        commit("thread-opened", {
-          chatKey,
-          threadId: createdThreadId,
-          projectId: binding.projectId,
-          openedAt: (/* @__PURE__ */ new Date()).toISOString()
+        return null;
+      }
+      const modelSelection = chatOf(state, chatKey).model ?? project.defaultModelSelection;
+      if (modelSelection === null) {
+        ctx.log.warn("chat cannot start a thread: the project has no default model", {
+          group: binding.displayName,
+          projectId: binding.projectId
         });
-        projectByThread.set(createdThreadId, binding.projectId);
+        await deliver(binding, t("reply.noDefaultModel", { title: project.title }));
+        return null;
       }
-      const attachments = await collectAttachment(binding, threadId, message);
+      const createdThreadId = crypto.randomUUID();
       await ctx.commands.dispatch({
-        type: "thread.turn.start",
+        type: "thread.create",
         commandId: crypto.randomUUID(),
-        threadId,
-        message: {
-          messageId: crypto.randomUUID(),
-          role: "user",
-          text: text2,
-          attachments
-        },
-        titleSeed: titleFrom(text2 || attachments[0]?.name || "Chat"),
+        threadId: createdThreadId,
+        projectId: binding.projectId,
+        title: titleFrom(titleSeed),
+        modelSelection,
         runtimeMode: binding.runtimeMode,
         interactionMode: interactionModeOf(chatKey),
+        branch: null,
+        worktreePath: null,
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       });
+      commit("thread-opened", {
+        chatKey,
+        threadId: createdThreadId,
+        projectId: binding.projectId,
+        openedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      projectByThread.set(createdThreadId, binding.projectId);
+      return createdThreadId;
+    };
+    const startTurn = async (binding, message) => {
+      const chatKey = chatKeyOf(binding);
+      const text2 = message.text;
+      const threadId = await ensureThread(binding, text2 || message.resources[0]?.name || "Chat");
+      if (threadId === null) return null;
+      const waiting = pendingByChat.get(chatKey);
+      pendingByChat.delete(chatKey);
+      const carried = waiting?.threadId === threadId ? waiting : void 0;
+      const own = await collectResources(
+        binding,
+        threadId,
+        message.messageId,
+        message.resources,
+        MAX_ATTACHMENTS_PER_TURN - (carried?.attachments.length ?? 0)
+      );
+      const attachments = [...carried?.attachments ?? [], ...own.attachments];
+      const notes = [...carried?.notes ?? [], ...own.notes];
+      const userMessageId = crypto.randomUUID();
+      try {
+        await ctx.commands.dispatch({
+          type: "thread.turn.start",
+          commandId: crypto.randomUUID(),
+          threadId,
+          message: {
+            messageId: userMessageId,
+            role: "user",
+            text: notes.length === 0 ? text2 : [text2, ...notes].join("\n"),
+            attachments
+          },
+          titleSeed: titleFrom(text2 || attachments[0]?.name || "Chat"),
+          runtimeMode: binding.runtimeMode,
+          interactionMode: interactionModeOf(chatKey),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch (error) {
+        if (carried !== void 0) pendingByChat.set(chatKey, carried);
+        throw error;
+      }
       ctx.log.info("chat started a turn from a message", {
         group: binding.displayName,
         chatId: binding.chatId,
         threadId
       });
+      await queueFlow.noteQueued(
+        chatKey,
+        threadId,
+        userMessageId,
+        text2.trim() || attachments[0]?.name || message.resources[0]?.name || ""
+      );
       return threadId;
     };
+    const receiveAttachmentsOnly = async (binding, message) => {
+      const threadId = await ensureThread(binding, message.resources[0]?.name || "Chat");
+      if (threadId === null) return;
+      const waiting = pendingFor(chatKeyOf(binding), threadId);
+      const collected = await collectResources(
+        binding,
+        threadId,
+        message.messageId,
+        message.resources,
+        MAX_ATTACHMENTS_PER_TURN - waiting.attachments.length
+      );
+      waiting.attachments.push(...collected.attachments);
+      waiting.notes.push(...collected.notes.slice(0, MAX_ATTACHMENTS_PER_TURN));
+      if (collected.attachments.length === 0) return;
+      await deliver(
+        binding,
+        t("reply.attachmentReceived", {
+          names: collected.attachments.map((attachment) => attachment.name).join(", "),
+          count: waiting.attachments.length
+        })
+      );
+    };
+    ctx.toolkit({
+      name: "im",
+      tools: [
+        makeSendFileTool({
+          boundChat: (threadId) => readBindings().find(
+            (binding) => binding.projectId !== "" && chatOf(state, chatKeyOf(binding)).threadId === threadId
+          ),
+          adapterFor: (binding) => adapterFor(binding.platform),
+          translate: t,
+          log: {
+            info: (message, fields) => ctx.log.info(message, fields),
+            warn: (message, fields) => ctx.log.warn(message, fields)
+          }
+        })
+      ]
+    });
     const receiving = readBindings().filter((binding) => binding.projectId !== "");
     const connections = [];
     const started = /* @__PURE__ */ new Set();
@@ -135549,7 +137642,7 @@ ${final.text}`;
     const chatQueues = /* @__PURE__ */ new Map();
     const enqueueForChat = (chatKey, work) => {
       const run = (chatQueues.get(chatKey) ?? Promise.resolve()).then(work).catch((error) => {
-        ctx.log.warn("chat could not handle the message", { error: describeError(error) });
+        ctx.log.warn("chat could not handle the message", { error: describeError2(error) });
       }).then(() => {
         if (chatQueues.get(chatKey) === run) chatQueues.delete(chatKey);
       });
@@ -135600,7 +137693,7 @@ ${final.text}`;
       },
       now: () => Date.now(),
       warn: (message, error) => {
-        ctx.log.warn(`chat ${message}`, error === void 0 ? {} : { error: describeError(error) });
+        ctx.log.warn(`chat ${message}`, error === void 0 ? {} : { error: describeError2(error) });
       }
     });
     const handlePanelClick = (platform, click) => {
@@ -135622,7 +137715,7 @@ ${final.text}`;
     };
     const inboundHandlersFor = (platform) => ({
       onError: (message) => ctx.log.warn("chat inbound connection failed", { platform, message }),
-      onApproval: handleApprovalClick,
+      onButton: handleButtonClick,
       onPanelClick: (click) => handlePanelClick(platform, click),
       onMessage: (message) => {
         const target = bindingForChat(platform, message.chatId);
@@ -135635,6 +137728,17 @@ ${final.text}`;
           });
           return;
         }
+        if (message.unsupportedType !== void 0) {
+          const unsupported = message.unsupportedType;
+          enqueueForChat(chatKeyOf(target), async () => {
+            if (!unsupportedReplyCooldown.tryAcquire(chatKeyOf(target))) return;
+            await deliver(
+              target,
+              unsupported === "folder" ? t("reply.unsupportedFolder") : t("reply.unsupportedType", { type: unsupported })
+            );
+          });
+          return;
+        }
         const open = openApprovalOf(state, chatKeyOf(target));
         const answerToken = open === void 0 ? null : adapterFor(target.platform)?.answerByText?.(
           target,
@@ -135643,13 +137747,17 @@ ${final.text}`;
         ) ?? null;
         if (answerToken !== null) {
           void answerByToken(answerToken).catch((error) => {
-            ctx.log.warn("chat could not answer the approval", { error: describeError(error) });
+            ctx.log.warn("chat could not answer the approval", { error: describeError2(error) });
           });
           return;
         }
         enqueueForChat(chatKeyOf(target), async () => {
           const teams = await fetchTeams(target);
           if (await handleCommand(target, message.text, teams ?? [])) return;
+          const boundThread = chatOf(state, chatKeyOf(target)).threadId;
+          if (boundThread !== null && message.text !== "" && await questionFlow.answerByText(chatKeyOf(target), boundThread, message.text)) {
+            return;
+          }
           const project = await ctx.projections.getProject(target.projectId);
           if (project === null || project.archivedAt != null) {
             if (project === null) {
@@ -135667,6 +137775,7 @@ ${final.text}`;
             return;
           }
           const routed = targetOf(target);
+          const attachmentsOnly = message.text.trim() === "" && message.resources.length > 0;
           if (routed.kind === "team") {
             if (teams !== null && !teams.some((team) => team.teamId === routed.teamId)) {
               commit("chat-updated", {
@@ -135676,11 +137785,17 @@ ${final.text}`;
               });
               await deliver(target, t("reply.teamGone"));
             } else {
+              if (message.resources.length > 0) await deliver(target, t("reply.attachmentsNoTeam"));
+              if (attachmentsOnly) return;
               await startTeamRun(target, routed.teamId, message.text);
               await markWorking(target, chatKeyOf(target), message.messageId);
               return;
             }
           }
+          if (attachmentsOnly) {
+            await receiveAttachmentsOnly(target, message);
+            return;
+          }
           const threadId = await startTurn(target, message);
           if (threadId !== null) await markWorking(target, threadId, message.messageId);
         });
@@ -135699,7 +137814,7 @@ ${final.text}`;
         ctx.log.warn("chat could not start an inbound connection", {
           group: binding.displayName,
           platform: binding.platform,
-          error: describeError(error)
+          error: describeError2(error)
         });
       });
     }