@ycodium-ai/plugin-im 0.2.2566 → 0.2.2578

package/dist/index.js

@@ -126208,6 +126208,7 @@ var ZH_ALIASES = {
   \u72B6\u6001: "status",
   \u65B0\u5BF9\u8BDD: "new",
   \u5E2E\u52A9: "help",
+  \u9762\u677F: "panel",
   \u4F1A\u8BDD\u5217\u8868: "sessions"
 };
 var resolveTeam = (query, teams) => {
@@ -126225,6 +126226,7 @@ var parseChatCommand = (input) => {
   if (/^\/status$/i.test(trimmed)) return { kind: "status" };
   if (/^\/new$/i.test(trimmed)) return { kind: "new" };
   if (/^\/help$/i.test(trimmed)) return { kind: "help" };
+  if (/^\/panel$/i.test(trimmed)) return { kind: "panel" };
   if (/^\/sessions$/i.test(trimmed)) return { kind: "sessions" };
   const resume = resumeArgument(input.text, input.chinese);
   if (resume !== void 0) {
@@ -126249,7 +126251,7 @@ var parseChatCommand = (input) => {
   }
   return { kind: "message" };
 };
-var helpText = (t) => [
+var helpText = (t, options = {}) => [
   t("help.title"),
   t("help.stop"),
   t("help.status"),
@@ -126260,7 +126262,8 @@ var helpText = (t) => [
   t("help.plan"),
   t("help.team"),
   t("help.thread"),
-  t("help.aliases")
+  t("help.aliases"),
+  ...options.panel === true ? ["", t("help.panel")] : []
 ].join("\n");
 var describeTargets = (target, teams, t) => {
   const current = target.kind === "thread" ? t("targets.currentThread") : t("targets.currentTeam", {
@@ -131972,6 +131975,40 @@ var buildApprovalSettledCard = (settlement, t) => ({
     }
   ]
 });
+var PANEL_TEMPLATE = {
+  menu: "blue",
+  busy: "grey",
+  notice: "orange"
+};
+var panelButton = (button) => ({
+  tag: "button",
+  text: { tag: "plain_text", content: button.label },
+  type: button.danger === true ? "danger" : "default",
+  value: button.action.arg === void 0 ? { pn: button.action.op } : { pn: button.action.op, a: button.action.arg }
+});
+var buildPanelCard = (card) => {
+  const elements = [];
+  if (card.text !== "") elements.push({ tag: "markdown", content: stripAngleBrackets(card.text) });
+  for (const group of card.groups) {
+    if (group.buttons.length === 0) continue;
+    if (group.heading !== null) {
+      elements.push({ tag: "markdown", content: `**${stripAngleBrackets(group.heading)}**` });
+    }
+    elements.push({ tag: "action", actions: group.buttons.map(panelButton) });
+  }
+  if (card.nav.length > 0) {
+    elements.push({ tag: "hr" }, { tag: "action", actions: card.nav.map(panelButton) });
+  }
+  if (elements.length === 0) elements.push({ tag: "markdown", content: " " });
+  return {
+    config: { wide_screen_mode: true },
+    header: {
+      title: { tag: "plain_text", content: card.title },
+      template: PANEL_TEMPLATE[card.tone]
+    },
+    elements
+  };
+};
 
 // src/larkInbound.ts
 var import_node_sdk = __toESM(require_lib2(), 1);
@@ -132087,26 +132124,44 @@ var fetchMessageResource = async (input) => {
   }
   return new Uint8Array(await response.arrayBuffer());
 };
-var cardActionToken = (event) => {
+var cardActionValue = (event) => {
   const roots = [event, event?.event];
   for (const root of roots) {
     const value = root?.action?.value;
     if (value === void 0 || value === null) continue;
-    let record;
-    if (typeof value === "string") {
-      try {
-        record = JSON.parse(value);
-      } catch {
-        record = void 0;
-      }
-    } else {
-      record = value;
+    if (typeof value !== "string") return value;
+    try {
+      return JSON.parse(value);
+    } catch {
+      continue;
     }
-    const token = record?.["tk"];
-    if (typeof token === "string" && token.length > 0) return token;
   }
   return null;
 };
+var cardActionToken = (event) => {
+  const token = cardActionValue(event)?.["tk"];
+  return typeof token === "string" && token.length > 0 ? token : null;
+};
+var cardActionPanel = (event) => {
+  const value = cardActionValue(event);
+  const op = value?.["pn"];
+  if (typeof op !== "string" || op === "") return null;
+  const arg = value?.["a"];
+  const roots = [event, event?.event];
+  const pick = (read) => {
+    for (const root of roots) {
+      if (typeof root !== "object" || root === null) continue;
+      const candidate = read(root);
+      if (typeof candidate === "string" && candidate !== "") return candidate;
+    }
+    return null;
+  };
+  const context = (root) => typeof root["context"] === "object" && root["context"] !== null ? root["context"] : void 0;
+  const cardId = pick((root) => context(root)?.["open_message_id"] ?? root["open_message_id"]);
+  const chatId = pick((root) => context(root)?.["open_chat_id"] ?? root["open_chat_id"]);
+  if (cardId === null || chatId === null) return null;
+  return { op, arg: typeof arg === "string" ? arg : null, cardId, chatId };
+};
 var cardActionOperator = (event) => {
   const roots = [event, event?.event];
   for (const root of roots) {
@@ -132127,6 +132182,11 @@ var startLarkInbound = (input) => {
     // 卡片点击走的也是 event 帧（实测过），所以在同一个 dispatcher 上注册就行，不用开
     // webhook。这条不需要 @：点按钮直接推给应用。
     "card.action.trigger": (event) => {
+      const panel = cardActionPanel(event);
+      if (panel !== null) {
+        const notice2 = input.onPanelClick?.(panel, cardActionOperator(event)) ?? null;
+        return notice2 === null ? {} : { toast: { type: "info", content: notice2 } };
+      }
       const token = cardActionToken(event);
       if (token === null) return {};
       const notice = input.onCardAction(token, cardActionOperator(event));
@@ -132185,6 +132245,13 @@ var makeLarkAdapter = (deps) => {
         appSecret,
         onError: handlers.onError,
         onCardAction: handlers.onApproval,
+        onPanelClick: (click, operatorOpenId) => handlers.onPanelClick?.({
+          chatId: click.chatId,
+          cardId: click.cardId,
+          operatorId: operatorOpenId,
+          op: click.op,
+          arg: click.arg
+        }) ?? null,
         onMessage: (message) => {
           handlers.onMessage({
             messageId: message.messageId,
@@ -132263,6 +132330,22 @@ var makeLarkAdapter = (deps) => {
         });
       }
     },
+    panel: {
+      open: async (binding, card) => sendCard({
+        http: deps.http,
+        token: await tenantToken(binding),
+        chatId: binding.chatId,
+        card: buildPanelCard(card)
+      }),
+      update: async (binding, cardId, card) => {
+        await patchCard({
+          http: deps.http,
+          token: await tenantToken(binding),
+          messageId: cardId,
+          card: buildPanelCard(card)
+        });
+      }
+    },
     acknowledge: async (binding, messageId) => addReaction({
       http: deps.http,
       token: await tenantToken(binding),
@@ -132425,7 +132508,8 @@ var en_default = {
     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",
-    plan: "\xB7 /plan \u2014 toggle plan mode (the agent proposes a plan instead of acting); /plan on, /plan off set it"
+    plan: "\xB7 /plan \u2014 toggle plan mode (the agent proposes a plan instead of acting); /plan on, /plan off set it",
+    panel: "Send /panel to open the command panel with a button for every command."
   },
   sessions: {
     title: "Sessions this bot opened for this group's project ({{count}}):",
@@ -132498,6 +132582,48 @@ var en_default = {
       chosen: "Chosen: {{label}}",
       elsewhere: "Already handled elsewhere (the web app or another client)."
     }
+  },
+  panel: {
+    title: "Command panel",
+    hint: "A button does the same as typing its command. You can still type.",
+    category: {
+      session: "Session",
+      target: "Send to",
+      system: "Settings and status"
+    },
+    cmd: {
+      new: "New session",
+      stop: "Stop this turn",
+      sessions: "Sessions",
+      team: "Send to a team",
+      thread: "Normal session",
+      model: "Model",
+      planOn: "Plan mode: on",
+      planOff: "Plan mode: off",
+      status: "Status",
+      help: "Text help"
+    },
+    back: "Back",
+    prev: "Previous",
+    next: "Next",
+    page: "Page {{page}} of {{total}}",
+    loading: "Loading\u2026",
+    working: "Working on it\u2026",
+    expired: "This panel has expired. Send /panel again.",
+    busy: "The last tap is still being handled. Give it a moment.",
+    loadFailed: "Could not read that just now. Try again in a moment.",
+    sessions: {
+      title: "Pick a session",
+      hint: "Tap one to switch to it."
+    },
+    teams: {
+      title: "Pick a team",
+      hint: "Tap a team and the next messages go to it.",
+      unavailable: "Could not read the team list."
+    },
+    models: {
+      title: "Pick a model"
+    }
   }
 };
 
@@ -132632,7 +132758,8 @@ var zh_CN_default = {
     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",
-    plan: "\xB7 /plan \u2014\u2014 \u5F00\u5173\u8BA1\u5212\u6A21\u5F0F\uFF08agent \u5148\u51FA\u8BA1\u5212\u3001\u4E0D\u52A8\u624B\uFF09\uFF1B/plan on\u3001/plan off \u660E\u786E\u8BBE\u5B9A"
+    plan: "\xB7 /plan \u2014\u2014 \u5F00\u5173\u8BA1\u5212\u6A21\u5F0F\uFF08agent \u5148\u51FA\u8BA1\u5212\u3001\u4E0D\u52A8\u624B\uFF09\uFF1B/plan on\u3001/plan off \u660E\u786E\u8BBE\u5B9A",
+    panel: "\u53D1 /panel \u6253\u5F00\u53EF\u70B9\u7684\u547D\u4EE4\u9762\u677F\u3002"
   },
   sessions: {
     title: "\u672C\u673A\u5668\u4EBA\u4E3A\u8FD9\u4E2A\u7FA4\u7684\u9879\u76EE\u5F00\u8FC7\u7684\u4F1A\u8BDD\uFF08{{count}} \u6761\uFF09\uFF1A",
@@ -132705,6 +132832,48 @@ var zh_CN_default = {
       chosen: "\u5DF2\u9009\uFF1A{{label}}",
       elsewhere: "\u5DF2\u5728\u522B\u5904\u5904\u7406\uFF08\u7F51\u9875\u6216\u5176\u4ED6\u5BA2\u6237\u7AEF\uFF09\u3002"
     }
+  },
+  panel: {
+    title: "\u547D\u4EE4\u9762\u677F",
+    hint: "\u70B9\u6309\u94AE\u7B49\u4E8E\u6253\u51FA\u5BF9\u5E94\u7684\u547D\u4EE4\uFF0C\u4E5F\u53EF\u4EE5\u76F4\u63A5\u6253\u5B57\u3002",
+    category: {
+      session: "\u4F1A\u8BDD",
+      target: "\u6D3E\u7ED9\u8C01",
+      system: "\u8BBE\u7F6E\u4E0E\u72B6\u6001"
+    },
+    cmd: {
+      new: "\u65B0\u4F1A\u8BDD",
+      stop: "\u505C\u6B62\u672C\u8F6E",
+      sessions: "\u4F1A\u8BDD\u5217\u8868",
+      team: "\u6D3E\u7ED9\u56E2\u961F",
+      thread: "\u666E\u901A\u4F1A\u8BDD",
+      model: "\u6A21\u578B",
+      planOn: "\u8BA1\u5212\u6A21\u5F0F\uFF1A\u5F00",
+      planOff: "\u8BA1\u5212\u6A21\u5F0F\uFF1A\u5173",
+      status: "\u72B6\u6001",
+      help: "\u6587\u5B57\u8BF4\u660E"
+    },
+    back: "\u8FD4\u56DE",
+    prev: "\u4E0A\u4E00\u9875",
+    next: "\u4E0B\u4E00\u9875",
+    page: "\u7B2C {{page}} / {{total}} \u9875",
+    loading: "\u52A0\u8F7D\u4E2D\u2026",
+    working: "\u5904\u7406\u4E2D\u2026",
+    expired: "\u9762\u677F\u5DF2\u8FC7\u671F\uFF0C\u518D\u53D1\u4E00\u6B21 /panel\u3002",
+    busy: "\u4E0A\u4E00\u6B65\u8FD8\u5728\u5904\u7406\uFF0C\u7A0D\u7B49\u4E00\u4E0B\u3002",
+    loadFailed: "\u521A\u624D\u6CA1\u8BFB\u51FA\u6765\uFF0C\u7A0D\u540E\u518D\u8BD5\u3002",
+    sessions: {
+      title: "\u9009\u4E00\u6761\u4F1A\u8BDD",
+      hint: "\u70B9\u4E00\u6761\u5207\u8FC7\u53BB\u3002"
+    },
+    teams: {
+      title: "\u9009\u4E00\u652F\u961F",
+      hint: "\u70B9\u4E00\u652F\u961F\uFF0C\u63A5\u4E0B\u6765\u7684\u6D3B\u6D3E\u7ED9\u5B83\u3002",
+      unavailable: "\u8BFB\u4E0D\u5230\u56E2\u961F\u5217\u8868\u3002"
+    },
+    models: {
+      title: "\u9009\u6A21\u578B"
+    }
   }
 };
 
@@ -132845,18 +133014,401 @@ var pickSession = (arg, listed, rows) => {
   return matches.length === 1 ? matches[0]?.threadId ?? null : null;
 };
 
+// src/panelCommands.ts
+var PANEL_CATEGORIES = ["session", "target", "system"];
+var PANEL_COMMANDS = [
+  {
+    id: "new",
+    category: "session",
+    line: "/new",
+    kind: "new",
+    labelKey: "panel.cmd.new",
+    action: { op: "run", arg: "new" }
+  },
+  {
+    id: "stop",
+    category: "session",
+    line: "/stop",
+    kind: "stop",
+    labelKey: "panel.cmd.stop",
+    action: { op: "run", arg: "stop" }
+  },
+  {
+    id: "sessions",
+    category: "session",
+    line: "/sessions",
+    kind: "sessions",
+    labelKey: "panel.cmd.sessions",
+    action: { op: "open", arg: "sessions" }
+  },
+  {
+    id: "team",
+    category: "target",
+    line: "/team",
+    kind: "showTargets",
+    labelKey: "panel.cmd.team",
+    action: { op: "open", arg: "teams" }
+  },
+  {
+    id: "thread",
+    category: "target",
+    line: "/thread",
+    kind: "selectThread",
+    labelKey: "panel.cmd.thread",
+    action: { op: "run", arg: "thread" }
+  },
+  {
+    id: "model",
+    category: "system",
+    line: "/model",
+    kind: "model",
+    labelKey: "panel.cmd.model",
+    action: { op: "open", arg: "models" }
+  },
+  {
+    id: "plan",
+    category: "system",
+    line: "/plan",
+    kind: "plan",
+    // 实际标签随当前状态在「开 / 关」间翻，见控制器；这里放关着时的那个。
+    labelKey: "panel.cmd.planOff",
+    action: { op: "run", arg: "plan" }
+  },
+  {
+    id: "status",
+    category: "system",
+    line: "/status",
+    kind: "status",
+    labelKey: "panel.cmd.status",
+    action: { op: "run", arg: "status" }
+  },
+  {
+    id: "help",
+    category: "system",
+    // 这个按钮发的是文字版命令列表，不是又开一张面板。
+    line: "/help",
+    kind: "help",
+    labelKey: "panel.cmd.help",
+    action: { op: "run", arg: "help" }
+  }
+];
+var PANEL_RUN_LINES = Object.fromEntries(
+  PANEL_COMMANDS.filter((spec) => spec.action.op === "run" && spec.id !== "help").map((spec) => [
+    spec.id,
+    spec.line
+  ])
+);
+
+// src/panelController.ts
+var PANEL_PAGE_SIZE = 8;
+var PANEL_CARD_LIMIT = 200;
+var LABEL_MAX_CHARS = 60;
+var PICK_KINDS = /* @__PURE__ */ new Set(["sessions", "teams", "models"]);
+var clip = (label) => {
+  const chars = Array.from(label);
+  return chars.length <= LABEL_MAX_CHARS ? label : `${chars.slice(0, LABEL_MAX_CHARS - 1).join("")}\u2026`;
+};
+var pageCount = (total) => Math.max(1, Math.ceil(total / PANEL_PAGE_SIZE));
+var makePanelController = (deps) => {
+  const { t } = deps;
+  const cards = /* @__PURE__ */ new Map();
+  const tails = /* @__PURE__ */ new Map();
+  const post = (cardId, job) => {
+    const run = (tails.get(cardId) ?? Promise.resolve()).then(job).catch((error) => deps.warn("panel could not update a card", error)).then(() => {
+      if (tails.get(cardId) === run) tails.delete(cardId);
+    });
+    tails.set(cardId, run);
+    return run;
+  };
+  const remember = (entry) => {
+    cards.delete(entry.cardId);
+    cards.set(entry.cardId, entry);
+    if (cards.size > PANEL_CARD_LIMIT) {
+      const oldest = cards.keys().next().value;
+      if (oldest !== void 0) cards.delete(oldest);
+    }
+  };
+  const button = (label, op, arg, danger) => ({
+    label: clip(label),
+    action: { op, arg },
+    ...danger === true ? { danger } : {}
+  });
+  const busyCard = (title, text2) => ({
+    title,
+    tone: "busy",
+    text: text2,
+    groups: [],
+    nav: []
+  });
+  const viewTitle = (kind) => t(`panel.${kind}.title`);
+  const menuCard = (chatKey) => ({
+    title: t("panel.title"),
+    tone: "menu",
+    text: t("panel.hint"),
+    groups: PANEL_CATEGORIES.map(
+      (category) => ({
+        heading: t(`panel.category.${category}`),
+        buttons: PANEL_COMMANDS.filter((spec) => spec.category === category).map(
+          (spec) => button(
+            // 计划模式的按钮把当前状态写在标签上，点了之后标签跟着翻。
+            spec.id === "plan" ? t(deps.planOn(chatKey) ? "panel.cmd.planOn" : "panel.cmd.planOff") : t(spec.labelKey),
+            spec.action.op,
+            spec.action.arg,
+            spec.id === "stop"
+          )
+        )
+      })
+    ),
+    nav: []
+  });
+  const pickerCard = (input) => {
+    const total = pageCount(input.items.length);
+    const page = Math.min(Math.max(input.page, 0), total - 1);
+    const shown = input.items.slice(page * PANEL_PAGE_SIZE, (page + 1) * PANEL_PAGE_SIZE);
+    const nav = [];
+    if (input.depth > 1) nav.push(button(t("panel.back"), "back"));
+    if (page > 0) nav.push(button(t("panel.prev"), "page", String(page - 1)));
+    if (page < total - 1) nav.push(button(t("panel.next"), "page", String(page + 1)));
+    const pageNote = total > 1 ? t("panel.page", { page: page + 1, total }) : "";
+    return {
+      title: viewTitle(input.kind),
+      tone: "menu",
+      text: [input.text, pageNote].filter((part) => part !== "").join("\n"),
+      groups: shown.map((item) => ({ heading: null, buttons: [item] })),
+      nav
+    };
+  };
+  const render = (entry) => {
+    const view = entry.stack.at(-1) ?? { kind: "menu" };
+    const depth = entry.stack.length;
+    switch (view.kind) {
+      case "menu":
+        return menuCard(entry.chatKey);
+      case "notice":
+        return {
+          title: view.title,
+          tone: "notice",
+          text: view.text,
+          groups: [],
+          nav: depth > 1 ? [button(t("panel.back"), "back")] : []
+        };
+      case "sessions": {
+        const now = deps.now();
+        return pickerCard({
+          kind: "sessions",
+          page: view.page,
+          depth,
+          text: view.rows.length === 0 ? t("sessions.empty") : t("panel.sessions.hint"),
+          items: view.rows.map(
+            (row, index) => button(sessionLine(row, index + 1, now, t), "pick", `sessions:${row.threadId}`)
+          )
+        });
+      }
+      case "teams":
+        return pickerCard({
+          kind: "teams",
+          page: view.page,
+          depth,
+          text: view.teams === null ? t("panel.teams.unavailable") : view.teams.length === 0 ? t("command.noTeams") : t("panel.teams.hint"),
+          items: (view.teams ?? []).map(
+            (team) => button(team.title, "pick", `teams:${team.teamId}`)
+          )
+        });
+      case "models": {
+        const { models } = view;
+        const current = models?.current ?? null;
+        const isCurrent = (choice) => current !== null && choice.instanceId === current.instanceId && choice.model === current.model;
+        return pickerCard({
+          kind: "models",
+          page: view.page,
+          depth,
+          text: models === null || models.choices.length === 0 ? t("model.unavailable") : current === null ? t("model.currentUnknown") : t("model.current", {
+            model: modelLabel(
+              models.choices.find(isCurrent) ?? {
+                instanceName: current.instanceId,
+                modelName: current.model
+              }
+            )
+          }),
+          items: (models?.choices ?? []).map(
+            (choice) => button(
+              `${isCurrent(choice) ? "\u2605 " : ""}${modelLabel(choice)}`,
+              "pick",
+              `models:${choice.instanceId}/${choice.model}`
+            )
+          )
+        });
+      }
+    }
+  };
+  const show = (entry) => post(entry.cardId, async () => {
+    const surface = deps.surface(entry.chatKey);
+    if (surface === null) return;
+    const card = render(entry);
+    try {
+      await surface.update(entry.cardId, card);
+    } catch (error) {
+      deps.warn("panel could not update a card, posting a new one", error);
+      const replacement = await surface.open(card);
+      if (replacement !== null) {
+        cards.delete(entry.cardId);
+        entry.cardId = replacement;
+        remember(entry);
+      }
+    }
+  });
+  const placeholder = (entry, title, text2) => {
+    void post(entry.cardId, async () => {
+      await deps.surface(entry.chatKey)?.update(entry.cardId, busyCard(title, text2));
+    });
+  };
+  const loadView = async (chatKey, kind) => {
+    switch (kind) {
+      case "sessions":
+        return { kind, page: 0, rows: await deps.loadSessions(chatKey) };
+      case "teams":
+        return { kind, page: 0, teams: await deps.loadTeams(chatKey) };
+      case "models":
+        return { kind, page: 0, models: await deps.loadModels(chatKey) };
+    }
+  };
+  const backToMenu = (entry) => {
+    entry.stack = [{ kind: "menu" }];
+    return show(entry);
+  };
+  const guardBusy = (entry, work) => {
+    entry.busy = true;
+    return work().finally(() => {
+      entry.busy = false;
+    });
+  };
+  const operate = (entry, job) => {
+    entry.busy = true;
+    deps.defer(() => {
+      placeholder(entry, t("panel.title"), t("panel.working"));
+      deps.enqueue(
+        entry.chatKey,
+        () => guardBusy(entry, async () => {
+          try {
+            await job();
+          } catch (error) {
+            deps.warn("panel could not run a command", error);
+          }
+          await backToMenu(entry);
+        })
+      );
+    });
+  };
+  const enter = (entry, kind) => {
+    entry.busy = true;
+    deps.defer(() => {
+      placeholder(entry, viewTitle(kind), t("panel.loading"));
+      deps.enqueue(
+        entry.chatKey,
+        () => guardBusy(entry, async () => {
+          try {
+            entry.stack.push(await loadView(entry.chatKey, kind));
+          } catch (error) {
+            deps.warn("panel could not load a view", error);
+            entry.stack.push({
+              kind: "notice",
+              title: viewTitle(kind),
+              text: t("panel.loadFailed")
+            });
+          }
+          await show(entry);
+        })
+      );
+    });
+  };
+  const navigate = (entry, change) => {
+    change();
+    deps.defer(() => void show(entry));
+  };
+  return {
+    /** 开一张新面板卡（`/help`）。发不出就抛，调用方退回文字版。 */
+    open: async (chatKey) => {
+      const surface = deps.surface(chatKey);
+      if (surface === null) throw new Error("this chat has no panel");
+      const entry = { cardId: "", chatKey, stack: [{ kind: "menu" }], busy: false };
+      const cardId = await surface.open(menuCard(chatKey));
+      if (cardId === null) throw new Error("the panel card was sent without an id");
+      entry.cardId = cardId;
+      remember(entry);
+    },
+    /**
+     * 处理一次点击，同步回给点击者的一句提示（null 就是没话说）。取数据、跑命令、改卡都
+     * 在回调应答之后做。
+     */
+    click: (click) => {
+      const entry = cards.get(click.cardId);
+      if (entry === void 0 || entry.chatKey !== click.chatKey) return t("panel.expired");
+      if (entry.busy) return t("panel.busy");
+      const top = entry.stack.at(-1) ?? { kind: "menu" };
+      const arg = click.arg ?? "";
+      switch (click.op) {
+        case "back":
+          if (entry.stack.length > 1) navigate(entry, () => void entry.stack.pop());
+          return null;
+        case "page": {
+          const page = Number(arg);
+          if ((top.kind === "sessions" || top.kind === "teams" || top.kind === "models") && Number.isInteger(page) && page >= 0) {
+            navigate(entry, () => {
+              entry.stack[entry.stack.length - 1] = { ...top, page };
+            });
+          }
+          return null;
+        }
+        case "open":
+          if (top.kind === "menu" && PICK_KINDS.has(arg)) enter(entry, arg);
+          return null;
+        case "run": {
+          if (top.kind !== "menu") return null;
+          if (arg === "help") {
+            operate(entry, () => deps.sendHelpText(entry.chatKey));
+            return null;
+          }
+          const line = PANEL_RUN_LINES[arg];
+          if (line !== void 0) operate(entry, () => deps.runLine(entry.chatKey, line));
+          return null;
+        }
+        case "pick": {
+          const split = arg.indexOf(":");
+          const key = split < 0 ? "" : arg.slice(split + 1);
+          const line = top.kind === "sessions" && arg.startsWith("sessions:") ? top.rows.find((row) => row.threadId === key) === void 0 ? null : `/resume ${key}` : top.kind === "teams" && arg.startsWith("teams:") ? top.teams?.find((team) => team.teamId === key) === void 0 ? null : `/team ${key}` : top.kind === "models" && arg.startsWith("models:") ? top.models?.choices.find(
+            (choice) => `${choice.instanceId}/${choice.model}` === key
+          ) === void 0 ? null : `/model ${key}` : null;
+          if (line === null) {
+            deps.warn("panel ignored a pick that is not in the current view");
+            return null;
+          }
+          operate(entry, () => deps.runLine(entry.chatKey, line));
+          return null;
+        }
+        default:
+          deps.warn(`panel ignored an unknown action: ${click.op}`);
+          return null;
+      }
+    }
+  };
+};
+
 // src/telegramApi.ts
 var API_BASE = "https://api.telegram.org";
 var POLL_TIMEOUT_SECONDS = 45;
 var TELEGRAM_TEXT_MAX_CHARS = 4e3;
 var TelegramApiError = class extends Error {
   code;
-  constructor(method, code2, description) {
+  /** 限流（429）时平台给的等待秒数；别的错误没有。 */
+  retryAfterSeconds;
+  constructor(method, code2, description, retryAfterSeconds) {
     super(`telegram ${method} failed (${String(code2 ?? "?")}): ${description}`);
     this.name = "TelegramApiError";
     this.code = code2;
+    this.retryAfterSeconds = retryAfterSeconds;
   }
 };
+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) => {
@@ -132915,10 +133467,20 @@ var makeTelegramApi = (input) => {
     });
     const envelope = await response.json();
     if (envelope.ok !== true) {
-      throw new TelegramApiError(method, envelope.error_code, envelope.description ?? "no reason");
+      throw new TelegramApiError(
+        method,
+        envelope.error_code,
+        envelope.description ?? "no reason",
+        envelope.parameters?.retry_after
+      );
     }
     return envelope.result;
   };
+  const keyboard = (rows) => ({
+    inline_keyboard: rows.map(
+      (row) => row.map((button) => ({ text: button.text, callback_data: button.data }))
+    )
+  });
   return {
     /** 机器人自己是谁；群里的命令靠它的 `username` 认出是不是发给自己的。 */
     getMe: () => call("getMe", {}),
@@ -132938,16 +133500,45 @@ var makeTelegramApi = (input) => {
         await call("sendMessage", { chat_id: chatId, text: chunk });
       }
     },
-    /** 带按钮的消息。一行一个按钮，审批选项通常不多。 */
-    sendButtons: (chatId, text2, buttons) => call("sendMessage", {
-      chat_id: chatId,
-      text: text2,
-      reply_markup: {
-        inline_keyboard: buttons.map((button) => [
-          { text: button.label, callback_data: button.token }
-        ])
+    /**
+     * 发一条消息，回它的 id。调用方保证 `text` 不超过单条上限（边写边更新的回复要自己
+     * 在上限处翻篇，这里不替它切）。带 `rows` 就挂一块内联键盘。
+     */
+    sendOne: async (chatId, text2, rows) => {
+      const sent = await call("sendMessage", {
+        chat_id: chatId,
+        text: text2,
+        ...rows === void 0 ? {} : { reply_markup: keyboard(rows) }
+      });
+      return sent?.message_id === void 0 ? null : String(sent.message_id);
+    },
+    /**
+     * 改一条已发出的消息。内容没变（`message is not modified`）当成功。`rows` 不给就是
+     * 去掉按钮：改了文字又要保留按钮的调用方得自己再传一次。
+     */
+    editMessage: async (chatId, messageId, text2, rows = []) => {
+      try {
+        await call("editMessageText", {
+          chat_id: chatId,
+          message_id: Number(messageId),
+          text: text2,
+          reply_markup: keyboard(rows)
+        });
+      } catch (error) {
+        if (!isNotModified(error)) throw error;
       }
-    }),
+    },
+    /** 带按钮的审批消息，一行一个按钮；回消息 id，之后才改得了它（平台没给就是 null）。 */
+    sendButtons: async (chatId, text2, buttons) => {
+      const sent = await call("sendMessage", {
+        chat_id: chatId,
+        text: text2,
+        reply_markup: keyboard(
+          buttons.map((button) => [{ text: button.label, data: button.token }])
+        )
+      });
+      return sent?.message_id === void 0 ? null : String(sent.message_id);
+    },
     /** 答完点击，不然客户端上那个按钮一直转圈。带 `text` 时点击者会看到一句提示。 */
     answerCallback: (callbackQueryId, text2) => call("answerCallbackQuery", {
       callback_query_id: callbackQueryId,
@@ -132988,16 +133579,168 @@ var makeTelegramApi = (input) => {
   };
 };
 
+// src/telegramPanel.ts
+var PANEL_DATA_PREFIX = "pn:";
+var renderPanel = (card, version) => {
+  const actions = [];
+  const rowOf = (buttons) => buttons.map((button) => {
+    actions.push(button.action);
+    return {
+      text: button.label,
+      data: `${PANEL_DATA_PREFIX}${String(version)}:${String(actions.length - 1)}`
+    };
+  });
+  const rows = [];
+  for (const group of card.groups) {
+    if (group.buttons.length > 0) rows.push(rowOf(group.buttons));
+  }
+  if (card.nav.length > 0) rows.push(rowOf(card.nav));
+  return {
+    text: [card.title, card.text].filter((part) => part !== "").join("\n\n"),
+    rows,
+    actions
+  };
+};
+var parsePanelData = (data) => {
+  const match = /^pn:(\d+):(\d+)$/.exec(data);
+  if (match === null) return null;
+  return { version: Number(match[1]), index: Number(match[2]) };
+};
+
+// src/plainTurnText.ts
+var RUNNING_LABEL_MAX_CHARS = 200;
+var clip2 = (text2, max) => {
+  const chars = Array.from(text2);
+  return chars.length <= max ? text2 : `${chars.slice(0, max - 1).join("")}\u2026`;
+};
+var turnTextParts = (view, t) => {
+  const names = view.steps.map((kind) => t(`card.step.${kind}`));
+  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)}`);
+  const body = view.body.trim();
+  const footLines = [];
+  if (view.status === "working") {
+    if (body === "" && names.length === 0) footLines.push(t("card.status.working"));
+  } else {
+    footLines.push(t(`card.status.${view.status}`));
+    if (view.errorText !== null && view.errorText !== "") footLines.push(view.errorText);
+  }
+  return { head: headLines.join("\n"), body, foot: footLines.join("\n") };
+};
+var joinParts = (...parts) => parts.filter((part) => part !== "").join("\n\n");
+
+// src/telegramTurn.ts
+var makeTurnWriter = (deps) => {
+  let first = deps.resume ?? null;
+  let live = deps.resume ?? null;
+  let liveText = null;
+  let frozen = 0;
+  let consumed = 0;
+  const put = async (text2) => {
+    const bounded = text2.length <= deps.limit ? text2 : text2.slice(0, deps.limit);
+    if (live === null) {
+      const id = await deps.messages.send(bounded);
+      if (id === null) throw new Error("telegram sent a message without an id");
+      live = id;
+      first ??= id;
+    } else if (bounded === liveText) {
+      return;
+    } else {
+      await deps.messages.edit(live, bounded);
+    }
+    liveText = bounded;
+  };
+  return {
+    firstId: () => first,
+    write: async (view) => {
+      const { head, body, foot } = turnTextParts(view, deps.t);
+      consumed = Math.min(consumed, body.length);
+      for (; ; ) {
+        const rest = body.slice(consumed);
+        const prefix = frozen === 0 ? head.slice(0, Math.floor(deps.limit / 2)) : "";
+        const whole = joinParts(prefix, rest, foot);
+        if (whole.length <= deps.limit) {
+          if (whole !== "") await put(whole);
+          return;
+        }
+        const room = deps.limit - prefix.length - 2;
+        const chunk = splitMessage(rest, room)[0] ?? "";
+        if (chunk === "") {
+          await put(whole);
+          return;
+        }
+        await put(joinParts(prefix, chunk));
+        frozen += 1;
+        consumed += chunk.length;
+        consumed += body.slice(consumed).length - body.slice(consumed).trimStart().length;
+        live = null;
+        liveText = null;
+      }
+    }
+  };
+};
+
 // src/telegramAdapter.ts
 var COLUMNS2 = [
   { key: "telegramToken", kind: "password", labelKey: "column.telegramToken.label" }
 ];
 var BACKOFF_START_MS = 1e3;
 var BACKOFF_MAX_MS = 6e4;
+var TELEGRAM_CARD_THROTTLE_MS = 1200;
+var FLOOD_WAIT_MAX_SECONDS = 30;
+var REMEMBERED_CARD_LIMIT = 200;
 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 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);
+        return run();
+      }
+      throw error;
+    }
+  };
+  const remembering = () => {
+    const entries = /* @__PURE__ */ new Map();
+    return {
+      get: (key) => entries.get(key),
+      set: (key, value) => {
+        entries.delete(key);
+        entries.set(key, value);
+        if (entries.size > REMEMBERED_CARD_LIMIT) {
+          const oldest = entries.keys().next().value;
+          if (oldest !== void 0) entries.delete(oldest);
+        }
+      },
+      delete: (key) => entries.delete(key)
+    };
+  };
+  const turnWriters = remembering();
+  const panelKeyboards = remembering();
+  const panelClick = (callback, operatorId, handlers) => {
+    const messageId = callback.message?.message_id;
+    const chatId = callback.message?.chat.id;
+    if (messageId === void 0 || chatId === void 0) return t("panel.expired");
+    const keyboard = panelKeyboards.get(`${String(chatId)}:${String(messageId)}`);
+    const parsed = parsePanelData(callback.data ?? "");
+    const action = keyboard === void 0 || parsed === null || parsed.version !== keyboard.version ? void 0 : keyboard.actions[parsed.index];
+    if (action === void 0) return t("panel.expired");
+    return handlers.onPanelClick?.({
+      chatId: String(chatId),
+      cardId: String(messageId),
+      operatorId,
+      op: action.op,
+      arg: action.arg ?? null
+    }) ?? null;
+  };
   const apiFor = async (binding) => {
     const existing = apis.get(binding.rowId);
     if (existing !== void 0) return existing;
@@ -133006,6 +133749,15 @@ var makeTelegramAdapter = (deps) => {
     apis.set(binding.rowId, api);
     return api;
   };
+  const makeWriter = (api, chatId, resume) => makeTurnWriter({
+    t,
+    limit: TELEGRAM_TEXT_MAX_CHARS,
+    ...resume === void 0 ? {} : { resume },
+    messages: {
+      send: (text2) => withFloodWait(() => api.sendOne(chatId, text2)),
+      edit: (messageId, text2) => withFloodWait(() => api.editMessage(chatId, messageId, text2))
+    }
+  });
   return {
     platform: "telegram",
     icon: "telegram",
@@ -133033,10 +133785,8 @@ var makeTelegramAdapter = (deps) => {
             for (const update of updates) {
               const callback = update.callback_query;
               if (callback?.data !== void 0) {
-                const notice = handlers.onApproval(
-                  callback.data,
-                  callback.from === void 0 ? null : String(callback.from.id)
-                );
+                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);
                 await api.answerCallback(callback.id, notice ?? void 0).catch(() => void 0);
                 continue;
               }
@@ -133089,8 +133839,72 @@ var makeTelegramAdapter = (deps) => {
     },
     askApproval: async (binding, request) => {
       const api = await apiFor(binding);
-      await api.sendButtons(binding.chatId, request.body, request.options);
-      return null;
+      return api.sendButtons(binding.chatId, request.body, request.options);
+    },
+    settleApproval: async (binding, cardId, settlement) => {
+      const api = await apiFor(binding);
+      const line = settlement.kind === "chosen" ? t("card.approval.chosen", { label: settlement.label }) : t("card.approval.elsewhere");
+      await withFloodWait(
+        () => api.editMessage(
+          binding.chatId,
+          cardId,
+          `${t("card.approval.doneTitle")}
+${line}`
+        )
+      );
+    },
+    turnCards: {
+      throttleMs: TELEGRAM_CARD_THROTTLE_MS,
+      open: async (binding, view) => {
+        const api = await apiFor(binding);
+        const writer = makeWriter(api, binding.chatId);
+        try {
+          await writer.write(view);
+        } catch (error) {
+          if (writer.firstId() === null) throw error;
+          deps.log.warn("telegram could not finish the first card write", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+        const cardId = writer.firstId();
+        if (cardId !== null && view.status === "working") {
+          turnWriters.set(`${binding.chatId}:${cardId}`, writer);
+        }
+        return cardId;
+      },
+      update: async (binding, cardId, view) => {
+        const key = `${binding.chatId}:${cardId}`;
+        const writer = turnWriters.get(key) ?? makeWriter(await apiFor(binding), binding.chatId, cardId);
+        await writer.write(view);
+        if (view.status !== "working") turnWriters.delete(key);
+        else turnWriters.set(key, writer);
+      }
+    },
+    panel: {
+      open: async (binding, card) => {
+        const api = await apiFor(binding);
+        const rendered = renderPanel(card, 1);
+        const cardId = await withFloodWait(
+          () => api.sendOne(binding.chatId, rendered.text, rendered.rows)
+        );
+        if (cardId !== null) {
+          panelKeyboards.set(`${binding.chatId}:${cardId}`, {
+            version: 1,
+            actions: rendered.actions
+          });
+        }
+        return cardId;
+      },
+      update: async (binding, cardId, card) => {
+        const api = await apiFor(binding);
+        const key = `${binding.chatId}:${cardId}`;
+        const version = (panelKeyboards.get(key)?.version ?? 0) + 1;
+        const rendered = renderPanel(card, version);
+        await withFloodWait(
+          () => api.editMessage(binding.chatId, cardId, rendered.text, rendered.rows)
+        );
+        panelKeyboards.set(key, { version, actions: rendered.actions });
+      }
     },
     fetchResource: async (binding, input) => {
       const api = await apiFor(binding);
@@ -133360,6 +134174,7 @@ var runWecomClient = (input) => {
   const nextRequestId = (kind) => `${kind}_${++sequence}`;
   const pendingAcks = /* @__PURE__ */ new Map();
   const pendingRequests = /* @__PURE__ */ new Map();
+  const openStreams = /* @__PURE__ */ new Map();
   const subscribeId = nextRequestId("aibot_subscribe");
   let missedPong = 0;
   let closed = false;
@@ -133389,6 +134204,8 @@ var runWecomClient = (input) => {
         return;
       }
       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);
       return;
     }
@@ -133400,6 +134217,7 @@ var runWecomClient = (input) => {
     if (finished) return;
     finished = true;
     clearInterval(heartbeat);
+    openStreams.clear();
     void input.socket.close().catch(() => void 0);
     for (const requestId of pendingAcks.keys()) {
       settleAck(requestId, new Error("WeCom connection closed"));
@@ -133487,8 +134305,38 @@ var runWecomClient = (input) => {
       }
     }
   };
+  const openStream = (chatId) => {
+    const requestId = pendingRequests.get(chatId);
+    if (requestId === void 0) return null;
+    pendingRequests.delete(chatId);
+    const id = nextRequestId("stream");
+    const state = { failed: false, finished: false };
+    openStreams.set(requestId, state);
+    return {
+      id,
+      send: async (content, finish2) => {
+        if (state.failed) return false;
+        if (state.finished) return true;
+        if (finish2) state.finished = true;
+        try {
+          await send({
+            cmd: "aibot_respond_msg",
+            headers: { req_id: requestId },
+            body: { msgtype: "stream", stream: { id, finish: finish2, content } }
+          });
+        } catch (error) {
+          state.failed = true;
+          openStreams.delete(requestId);
+          throw error;
+        }
+        if (finish2) openStreams.delete(requestId);
+        return true;
+      }
+    };
+  };
   return {
     sendText,
+    openStream,
     rememberRequest: (chatId, requestId) => {
       if (requestId !== null) pendingRequests.set(chatId, requestId);
     },
@@ -133503,6 +134351,8 @@ var runWecomClient = (input) => {
 };
 
 // src/wecomAdapter.ts
+var WECOM_CARD_THROTTLE_MS = 400;
+var LIVE_STREAM_LIMIT = 200;
 var BACKOFF_START_MS2 = 1e3;
 var BACKOFF_MAX_MS2 = 6e4;
 var COLUMNS3 = [
@@ -133523,6 +134373,36 @@ var optionIndexFrom = (text2, count) => {
 };
 var makeWecomAdapter = (deps) => {
   const clients = /* @__PURE__ */ new Map();
+  const t = deps.translate;
+  const liveStreams = /* @__PURE__ */ new Map();
+  const rememberStream = (key, entry) => {
+    liveStreams.set(key, entry);
+    if (liveStreams.size > LIVE_STREAM_LIMIT) {
+      const oldest = liveStreams.keys().next().value;
+      if (oldest !== void 0) liveStreams.delete(oldest);
+    }
+  };
+  const emit = async (entry, view) => {
+    const { head, body, foot } = turnTextParts(view, t);
+    if (view.status === "working") {
+      let shown = body;
+      const whole = joinParts(head, body, foot);
+      if (whole.length > WECOM_TEXT_MAX_CHARS) {
+        const marker = t("card.truncated", { count: 9999999 });
+        const room = WECOM_TEXT_MAX_CHARS - head.length - foot.length - marker.length - 6;
+        const kept = room > 0 ? body.slice(Math.max(0, body.length - room)) : "";
+        shown = `${t("card.truncated", { count: body.length - kept.length })}
+${kept}`;
+      }
+      await entry.stream.send(joinParts(head, shown, foot), false);
+      return;
+    }
+    const chunks = splitForWecom(joinParts(head, body, foot));
+    const delivered = await entry.stream.send(chunks[0] ?? "", true);
+    for (const chunk of delivered ? chunks.slice(1) : chunks) {
+      await entry.client.sendText(entry.chatId, chunk);
+    }
+  };
   return {
     platform: "wecom",
     icon: "wecom",
@@ -133621,6 +134501,25 @@ var makeWecomAdapter = (deps) => {
       await (clients.get(binding.rowId)?.sendText(binding.chatId, lines.join("\n")) ?? Promise.resolve());
       return null;
     },
+    turnCards: {
+      throttleMs: WECOM_CARD_THROTTLE_MS,
+      open: async (binding, view) => {
+        const client = clients.get(binding.rowId);
+        const stream = client?.openStream(binding.chatId) ?? null;
+        if (client === void 0 || stream === null) return null;
+        const entry = { stream, client, chatId: binding.chatId };
+        await emit(entry, view);
+        if (view.status === "working") rememberStream(`${binding.rowId}:${stream.id}`, entry);
+        return stream.id;
+      },
+      update: async (binding, cardId, view) => {
+        const key = `${binding.rowId}:${cardId}`;
+        const entry = liveStreams.get(key);
+        if (entry === void 0) return;
+        await emit(entry, view);
+        if (view.status !== "working") liveStreams.delete(key);
+      }
+    },
     answerByText: (_binding, text2, options) => {
       const index = optionIndexFrom(text2, options.length);
       return index === null ? null : options[index - 1]?.token ?? null;
@@ -133674,6 +134573,7 @@ var imPlugin = definePlugin({
         // Telegram 在不少网络里要绕代理，而绕不绕、绕哪个是按行配的 —— 这是插件面上
         // `ctx.proxies` 的第一个真实消费者。
         fetchVia: (proxy) => ctx.proxies.fetch(proxy),
+        translate: t,
         log: {
           info: (message, fields) => ctx.log.info(message, fields),
           warn: (message, fields) => ctx.log.warn(message, fields)
@@ -133682,6 +134582,7 @@ var imPlugin = definePlugin({
       makeWecomAdapter({
         // 企微不需要厂商 SDK：全程 JSON over WebSocket，走插件面那条出网长连接。
         connectSocket: (url) => ctx.socket.connect({ url }),
+        translate: t,
         log: {
           info: (message, fields) => ctx.log.info(message, fields),
           warn: (message, fields) => ctx.log.warn(message, fields)
@@ -134405,9 +135306,10 @@ ${final.text}`;
       commit("chat-updated", { chatKey, plan: next });
       await deliver(binding, t(next ? "plan.on" : "plan.off"));
     };
-    const handleCommand = async (binding, message, teams) => {
+    const hasPanel = (binding) => adapterFor(binding.platform)?.panel !== void 0;
+    const handleCommand = async (binding, text2, teams) => {
       const command = parseChatCommand({
-        text: message.text,
+        text: text2,
         teams,
         // 中文别名只在回话语言是中文时认，免得英文用户打一个「停」就被当成命令。
         chinese: t.language === "zh-CN"
@@ -134451,7 +135353,20 @@ ${final.text}`;
           await deliver(binding, t("command.noTeams"));
           return true;
         case "help":
-          await deliver(binding, helpText(t));
+          await deliver(binding, helpText(t, { panel: hasPanel(binding) }));
+          return true;
+        case "panel":
+          if (hasPanel(binding)) {
+            try {
+              await panel.open(chatKey);
+              return true;
+            } catch (error) {
+              ctx.log.warn("chat could not open the command panel", {
+                error: describeError(error)
+              });
+            }
+          }
+          await deliver(binding, helpText(t, { panel: false }));
           return true;
         case "sessions":
           await showSessions(binding);
@@ -134640,9 +135555,75 @@ ${final.text}`;
       });
       chatQueues.set(chatKey, run);
     };
+    const panel = makePanelController({
+      t,
+      surface: (chatKey) => {
+        const binding = bindingOfChat(chatKey);
+        const surface = binding === void 0 ? void 0 : adapterFor(binding.platform)?.panel;
+        if (binding === void 0 || surface === void 0) return null;
+        return {
+          open: (card) => surface.open(binding, card),
+          update: (cardId, card) => surface.update(binding, cardId, card)
+        };
+      },
+      planOn: (chatKey) => chatOf(state, chatKey).plan,
+      loadSessions: async (chatKey) => {
+        const binding = bindingOfChat(chatKey);
+        if (binding === void 0) return [];
+        const rows = await sessionRowsFor(binding);
+        listedByChat.set(chatKey, listedThreadIds(rows));
+        return rows;
+      },
+      loadTeams: async (chatKey) => {
+        const binding = bindingOfChat(chatKey);
+        return binding === void 0 ? null : fetchTeams(binding);
+      },
+      loadModels: async (chatKey) => {
+        const binding = bindingOfChat(chatKey);
+        const instances = await ctx.providers.listInstances().catch(() => null);
+        if (binding === void 0 || instances === null) return null;
+        return { current: await currentModelOf(binding), choices: modelChoices(instances) };
+      },
+      runLine: async (chatKey, line) => {
+        const binding = bindingOfChat(chatKey);
+        if (binding === void 0) return;
+        await handleCommand(binding, line, await fetchTeams(binding) ?? []);
+      },
+      sendHelpText: async (chatKey) => {
+        const binding = bindingOfChat(chatKey);
+        if (binding !== void 0) await deliver(binding, helpText(t));
+      },
+      enqueue: enqueueForChat,
+      // 改卡必须排在回调应答之后：飞书在应答不带改卡时会把卡恢复成点击前的样子。
+      defer: (run) => {
+        setTimeout(run, 0);
+      },
+      now: () => Date.now(),
+      warn: (message, error) => {
+        ctx.log.warn(`chat ${message}`, error === void 0 ? {} : { error: describeError(error) });
+      }
+    });
+    const handlePanelClick = (platform, click) => {
+      const target = bindingForChat(platform, click.chatId);
+      if (target === void 0 || target.projectId === "") return null;
+      if (!isAllowedSender(target, click.operatorId)) {
+        ctx.log.warn("chat ignored a panel click from someone not on the allow list", {
+          group: target.displayName,
+          operator: click.operatorId
+        });
+        return t("reply.notAllowed");
+      }
+      return panel.click({
+        chatKey: chatKeyOf(target),
+        cardId: click.cardId,
+        op: click.op,
+        arg: click.arg
+      });
+    };
     const inboundHandlersFor = (platform) => ({
       onError: (message) => ctx.log.warn("chat inbound connection failed", { platform, message }),
       onApproval: handleApprovalClick,
+      onPanelClick: (click) => handlePanelClick(platform, click),
       onMessage: (message) => {
         const target = bindingForChat(platform, message.chatId);
         if (target === void 0 || target.projectId === "") return;
@@ -134668,7 +135649,7 @@ ${final.text}`;
         }
         enqueueForChat(chatKeyOf(target), async () => {
           const teams = await fetchTeams(target);
-          if (await handleCommand(target, message, teams ?? [])) return;
+          if (await handleCommand(target, message.text, teams ?? [])) return;
           const project = await ctx.projections.getProject(target.projectId);
           if (project === null || project.archivedAt != null) {
             if (project === null) {