@ycodium-ai/plugin-im 0.2.2596 → 0.2.2634

package/dist/index.js

@@ -126163,7 +126163,8 @@ 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/chatCommand.ts
@@ -126205,6 +126206,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 +126226,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 +126258,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 +126283,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 +126317,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 +126363,74 @@ 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;
+    options.push({
+      token,
+      value: optionValue,
+      label: entry["label"],
+      description: typeof entry["description"] === "string" ? entry["description"] : ""
+    });
+  }
+  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 +126514,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"]);
@@ -132009,6 +132236,47 @@ 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);
@@ -132244,7 +132512,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,
@@ -132346,6 +132614,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),
@@ -132470,6 +132754,44 @@ var en_default = {
     alreadyHandled: "Already handled",
     replyHint: "Reply with the number."
   },
+  question: {
+    title: "\u2753 Question",
+    planTitle: "\u{1F4DD} Plan review",
+    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 +132800,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 +132824,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 +132919,7 @@ var en_default = {
     },
     cmd: {
       new: "New session",
+      continue: "Resume sending",
       stop: "Stop this turn",
       sessions: "Sessions",
       team: "Send to a team",
@@ -132720,6 +133047,44 @@ 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",
+    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 +133093,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 +133117,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 +133212,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 +133403,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 +133771,568 @@ var makePanelController = (deps) => {
   };
 };
 
+// src/flowHost.ts
+var NOT_MINE = { handled: false };
+var handledWith = (notice) => ({ handled: true, notice });
+
+// src/questionCards.ts
+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) => clip2(
+  item.options.filter((option) => option.description.trim() !== "").map((option) => `\xB7 ${option.label}: ${option.description.trim()}`).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),
+  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 ${option.label}` : option.label,
+          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 = option.description.trim();
+    return `${String(position + 1)}. ${option.label}${description === "" ? "" : ` \u2014 ${description}`}`;
+  }),
+  "",
+  item.multiSelect ? t("question.replyMany") : t("question.replyOne"),
+  ...item.allowFreeform ? [t("question.freeformHint")] : []
+].join("\n");
+var parseNumberedReply = (item, text2) => {
+  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) => option.label).join(", ")
+    };
+  }
+  const only = options[0];
+  return only === void 0 ? null : { answer: only.value, label: only.label };
+};
+
+// 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
+          })),
+          ...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, option.label);
+        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) => option.label).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);
+      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/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, failure) => {
+    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, failure);
+    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;
@@ -133579,6 +134519,14 @@ var makeTelegramApi = (input) => {
   };
 };
 
+// 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 +134557,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 +134566,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") {
@@ -133786,7 +134734,7 @@ 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;
               }
@@ -133906,6 +134854,20 @@ ${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)
+        );
+      }
+    },
     fetchResource: async (binding, input) => {
       const api = await apiFor(binding);
       return api.fetchFile(input.resource.key);
@@ -135097,13 +136059,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: describeError(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: describeError(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);
@@ -135409,6 +136474,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: describeError(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: describeError(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) {
@@ -135520,12 +136616,13 @@ ${final.text}`;
         projectByThread.set(createdThreadId, binding.projectId);
       }
       const attachments = await collectAttachment(binding, threadId, message);
+      const userMessageId = crypto.randomUUID();
       await ctx.commands.dispatch({
         type: "thread.turn.start",
         commandId: crypto.randomUUID(),
         threadId,
         message: {
-          messageId: crypto.randomUUID(),
+          messageId: userMessageId,
           role: "user",
           text: text2,
           attachments
@@ -135540,6 +136637,12 @@ ${final.text}`;
         chatId: binding.chatId,
         threadId
       });
+      await queueFlow.noteQueued(
+        chatKey,
+        threadId,
+        userMessageId,
+        text2.trim() || attachments[0]?.name || message.resource?.name || ""
+      );
       return threadId;
     };
     const receiving = readBindings().filter((binding) => binding.projectId !== "");
@@ -135622,7 +136725,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);
@@ -135650,6 +136753,10 @@ ${final.text}`;
         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 && 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) {