@primusclaw/personal-agent 0.4.0 → 0.6.0

package/dist/index.js

@@ -3800,7 +3800,14 @@ var approvalText = defineCatalog({
     questionYours: "Your answer",
     questionOnly: (p) => `Only ${p.who} can answer.`,
     questionAsker: "the person who asked",
-    send: "Send answer"
+    send: "Send answer",
+    /** Under a question card's questions: a client that does not show the card can still answer. */
+    questionReply: "You can also just reply in the chat with your choice.",
+    /** The same in a group chat, where only a message that @mentions the bot reaches it. */
+    questionReplyGroup: "You can also just reply in the chat with your choice, @mentioning me.",
+    /** A question card once a message typed in the chat answered it. */
+    questionReplied: (p) => `Answered: ${p.answer}`,
+    questionRepliedAt: (p) => `Replied in the chat, ${p.at}`
   },
   zh: {
     title: "\u9700\u8981\u4F60\u6279\u51C6",
@@ -3823,7 +3830,11 @@ var approvalText = defineCatalog({
     questionYours: "\u4F60\u7684\u56DE\u7B54",
     questionOnly: (p) => `\u53EA\u6709${p.who}\u53EF\u4EE5\u56DE\u7B54\u3002`,
     questionAsker: "\u53D1\u8D77\u4EBA",
-    send: "\u53D1\u9001\u56DE\u7B54"
+    send: "\u53D1\u9001\u56DE\u7B54",
+    questionReply: "\u4E5F\u53EF\u4EE5\u76F4\u63A5\u5728\u804A\u5929\u91CC\u56DE\u590D\u9009\u9879\u3002",
+    questionReplyGroup: "\u4E5F\u53EF\u4EE5\u5728\u804A\u5929\u91CC @\u6211 \u76F4\u63A5\u56DE\u590D\u9009\u9879\u3002",
+    questionReplied: (p) => `\u5DF2\u56DE\u7B54\uFF1A${p.answer}`,
+    questionRepliedAt: (p) => `\u5728\u804A\u5929\u91CC\u56DE\u590D\uFF0C${p.at}`
   }
 });
 
@@ -4018,7 +4029,18 @@ var assistantCardText = defineCatalog({
     minutesAgo: (p) => `${String(p.n)} min ago`,
     hoursAgo: (p) => `${String(p.n)} h ago`,
     daysAgo: (p) => `${String(p.n)} d ago`,
-    askedTitle: (p) => `Asked of others \xB7 ${String(p.n)}`
+    askedTitle: (p) => `Asked of others \xB7 ${String(p.n)}`,
+    choiceTitle: "Pick one",
+    choiceTitleMany: "Pick any that apply",
+    choiceSend: "Send",
+    choiceTyped: "You can also just reply in the chat.",
+    choiceNone: "Pick an option first, then press Send.",
+    choiceSent: (p) => `You picked: ${p.answer}`,
+    choiceGone: "This choice is no longer open. Reply in the chat instead.",
+    choiceSending: (p) => `Sending: ${p.answer}. If nothing comes back, reply in the chat instead.`,
+    choiceFailed: "That did not go through. Press Send again.",
+    /** How the options picked are joined into the person's message. */
+    choiceJoin: ", "
   },
   zh: {
     ...english2,
@@ -4055,7 +4077,17 @@ var assistantCardText = defineCatalog({
     minutesAgo: (p) => `${String(p.n)} \u5206\u949F\u524D`,
     hoursAgo: (p) => `${String(p.n)} \u5C0F\u65F6\u524D`,
     daysAgo: (p) => `${String(p.n)} \u5929\u524D`,
-    askedTitle: (p) => `\u8BF7\u522B\u4EBA\u505A\u7684\u4EE3\u5BA1 \xB7 ${String(p.n)}`
+    askedTitle: (p) => `\u8BF7\u522B\u4EBA\u505A\u7684\u4EE3\u5BA1 \xB7 ${String(p.n)}`,
+    choiceTitle: "\u8BF7\u9009\u62E9\u4E00\u9879",
+    choiceTitleMany: "\u53EF\u591A\u9009",
+    choiceSend: "\u53D1\u9001",
+    choiceTyped: "\u4E5F\u53EF\u4EE5\u76F4\u63A5\u5728\u804A\u5929\u91CC\u56DE\u590D\u3002",
+    choiceNone: "\u8BF7\u5148\u9009\u4E00\u9879\uFF0C\u518D\u70B9\u53D1\u9001\u3002",
+    choiceSent: (p) => `\u4F60\u9009\u4E86\uFF1A${p.answer}`,
+    choiceGone: "\u8FD9\u4E2A\u9009\u62E9\u5DF2\u7ECF\u5931\u6548\uFF0C\u8BF7\u76F4\u63A5\u5728\u804A\u5929\u91CC\u56DE\u590D\u3002",
+    choiceSending: (p) => `\u6B63\u5728\u53D1\u9001\uFF1A${p.answer}\u3002\u5982\u679C\u4E00\u76F4\u6CA1\u6709\u56DE\u5E94\uFF0C\u8BF7\u76F4\u63A5\u5728\u804A\u5929\u91CC\u56DE\u590D\u3002`,
+    choiceFailed: "\u6CA1\u6709\u53D1\u51FA\u53BB\uFF0C\u8BF7\u518D\u70B9\u4E00\u6B21\u53D1\u9001\u3002",
+    choiceJoin: "\u3001"
   }
 });
 var ASKED_VERDICT = {
@@ -5746,6 +5778,8 @@ var turnText = defineCatalog({
     thinking: "Thinking\u2026",
     /** A turn still running when its stream has to close: the answer follows as a message of its own. */
     stillWorking: "Still working on it; the result will follow as a new message.",
+    /** A turn whose stream is closed because a card now waits for the person's choice. */
+    awaitingChoice: "Waiting for your choice in the card; I will continue once you pick.",
     interrupted: "Interrupted.",
     /** What a turn the person stopped ends with. */
     stopped: "Stopped.",
@@ -5767,6 +5801,7 @@ var turnText = defineCatalog({
     planMore: (p) => `\u2026\u2026\u53E6\u6709 ${String(p.n)} \u9879\uFF08${String(p.done)} \u9879\u5DF2\u5B8C\u6210\uFF0C${String(p.todo)} \u9879\u5F85\u529E\uFF09`,
     thinking: "\u601D\u8003\u4E2D\u2026",
     stillWorking: "\u4ECD\u5728\u5904\u7406\uFF0C\u5B8C\u6210\u540E\u53E6\u53D1\u7ED3\u679C\u3002",
+    awaitingChoice: "\u8BF7\u5728\u5361\u7247\u91CC\u9009\u62E9\uFF0C\u9009\u597D\u540E\u6211\u63A5\u7740\u505A\u3002",
     interrupted: "\u5DF2\u4E2D\u65AD\u3002",
     stopped: "\u5DF2\u505C\u6B62\u3002",
     doneShort: "\u5B8C\u6210\u3002",
@@ -6062,6 +6097,19 @@ function deliveryLine(delivery, url) {
   return turnEnglish.deliveryLine(plain(delivery.name), sizeText(delivery.size), caption, url);
 }
 
+// packages/core/src/language/chosen.ts
+function chosenLang(prefs) {
+  if (!prefs.langSet) return void 0;
+  return prefs.lang === "zh" || prefs.lang === "en" ? prefs.lang : void 0;
+}
+function replyLanguageContext(prefs) {
+  const lang = chosenLang(prefs);
+  return lang === void 0 ? {} : { reply_language: lang };
+}
+function replyLanguageLine(lang) {
+  return `[Reply language: ${lang === "zh" ? "Chinese" : "English"}]`;
+}
+
 // packages/core/src/language/detect.ts
 var CJK2 = /[㐀-䶿一-鿿豈-﫿]/u;
 function hasCjk2(text8) {
@@ -6195,9 +6243,13 @@ ${text8}` : quote || text8;
 function messageOf(ctx) {
   const said2 = withQuote(ctx.request.sent || ctx.request.text, ctx.request.quote ?? "");
   const note = ctx.record.filesNote;
-  return said2 && note ? `${said2}
+  const message = said2 && note ? `${said2}
 
 ${note}` : said2 || note;
+  const chosen = ctx.request.replyLang;
+  return message && chosen !== void 0 ? `${message}
+
+${replyLanguageLine(chosen)}` : message;
 }
 
 // packages/core/src/locales/claw.ts
@@ -6949,6 +7001,8 @@ var StatusMessage = class {
   opening;
   expiry;
   again;
+  /** The stream being closed because a card waits for the person (`awaitingChoice`). */
+  choice;
   preparingTimer;
   lastText = "";
   lastAt = 0;
@@ -7027,20 +7081,61 @@ ${header}` : header;
     const live = this.live;
     if (!live) return;
     await sleepSeconds(this.clock, Math.max(STREAM_CLOSE_SECONDS - live.age(), 0), signal);
-    if (this.closed || !live.closable) return;
+    await this.closeEarly(live, turnText.in(this.lang).stillWorking, "before the chat's limit", signal);
+  }
+  /**
+   * Close the open stream with `line` (after the agent's words in the bubble) while the turn goes on; the answer, whenever it comes, is
+   * a message of its own. Nothing more is sent to the stream once this has begun.
+   */
+  async closeEarly(live, line2, why, signal) {
+    if (this.closed || !live.closable || this.streamOver || this.expiring) return;
     this.expiring = true;
     if (this.stream && this.flusher && !this.flusher.done) await unlessAborted(this.flusher.settled(), signal);
     this.streamOver = true;
-    const line2 = turnText.in(this.lang).stillWorking;
-    const closed = await live.final(plainMessage(live.streamed ? `${live.streamed}
+    const words3 = this.streamable() || live.streamed;
+    const closed = await live.final(plainMessage(words3 ? `${words3}
 
 ${line2}` : line2));
-    if (!closed.ok)
-      this.log.warn("the turn's stream could not be closed before the chat's limit; the answer follows as a message");
+    if (!closed.ok) this.log.warn(`the turn's stream could not be closed ${why}; the answer follows as a message`);
     this.log.info("the turn's stream was closed; the answer follows as a message of its own", {
+      why,
       age: Math.round(live.age())
     });
   }
+  /**
+   * A card now waits for the person (a question of the agent): it is their turn, so the floating status must not go on
+   * saying "Thinking…" until the chat's limit. An open stream is closed at once with AWAITING_CHOICE, and the answer comes
+   * as a message of its own, as after the limit. Without a stream (the progress message) nothing changes: it has no
+   * spinner. Never fails the turn.
+   */
+  awaitingChoice() {
+    const live = this.live;
+    if (this.closed || !live || this.streamOver || this.expiring || this.choice) return;
+    this.choice = detach(async (signal) => {
+      if (this.opening && !this.opening.done) await unlessAborted(this.opening.settled(), signal);
+      if (!this.expiring) this.expiry?.cancel();
+      await this.closeEarly(live, turnText.in(this.lang).awaitingChoice, "while a card waits for the person", signal);
+    });
+  }
+  /**
+   * Claw queued the message behind a turn it is still running: `notice` closes the stream at once, so it does not say
+   * "Thinking…" for the whole wait. The answer comes as a message of its own, as after the limit. When the stream did not open
+   * after all, `notice` is said as a message. False when there is no stream: the caller says it. Never fails the turn.
+   */
+  queued(notice) {
+    const live = this.live;
+    if (this.closed || !live || this.streamOver || this.expiring || this.choice) return false;
+    this.choice = detach(async (signal) => {
+      if (this.opening && !this.opening.done) await unlessAborted(this.opening.settled(), signal);
+      if (this.closed || !live.closable || this.streamOver || this.expiring) {
+        await this.surface.send(plainMessage(notice));
+        return;
+      }
+      this.expiry?.cancel();
+      await this.closeEarly(live, notice, "while the message waits behind another turn", signal);
+    });
+    return true;
+  }
   /** The chat's id of the posted message; undefined when the post failed or its id never came (nothing is edited then). */
   async messageId(signal) {
     if (!this.posted) return void 0;
@@ -7185,8 +7280,7 @@ ${line2}` : line2));
     this.hard = this.hard || hard;
     this.stopPreparingTimer();
     if (this.flusher && !this.flusher.done && (hard || !this.sending)) this.flusher.cancel();
-    if (hard) this.again?.cancel();
-    if (hard) this.expiry?.cancel();
+    if (hard) for (const task of [this.again, this.expiry, this.choice]) task?.cancel();
     if (hard && this.live?.closable && !this.streamOver) {
       this.streamOver = true;
       const live = this.live;
@@ -7220,7 +7314,7 @@ ${line2}` : line2));
   async quiesce() {
     this.close();
     if (this.expiry && !this.expiry.done && !this.expiring) this.expiry.cancel();
-    for (const task of [this.opening, this.flusher, this.expiring ? this.expiry : void 0]) {
+    for (const task of [this.opening, this.flusher, this.expiring ? this.expiry : void 0, this.choice]) {
       if (task) await task.settled();
     }
   }
@@ -7992,15 +8086,17 @@ async function ask2(ctx, sessionId, step) {
   const asked3 = isObject3(step.approval) && truthy(step.approval) ? approvalOf(ctx, sessionId, step.approval) : questionOf2(ctx, sessionId, step.question ?? {});
   const { tool: tool2, toolUseId, request, envelope } = asked3;
   const hooks = ctx.hooks;
-  if (toolUseId && hooks.onApproval?.(sessionId, toolUseId, tool2, waitSeconds(request["timeout_ms"]), envelope) === false)
+  const questions = tool2 === QUESTION_TOOL ? request["questions"] : void 0;
+  if (toolUseId && hooks.onApproval?.(sessionId, toolUseId, tool2, waitSeconds(request["timeout_ms"]), envelope, questions) === false)
     return;
+  let cardId;
   try {
-    await ctx.deps.surface.deliver(envelope);
+    cardId = await ctx.deps.surface.deliver(envelope);
   } catch (err2) {
     if (toolUseId) hooks.onApprovalUnsent?.(sessionId, toolUseId);
     throw err2;
   }
-  if (toolUseId) hooks.onApprovalSent?.(sessionId, toolUseId);
+  if (toolUseId) hooks.onApprovalSent?.(sessionId, toolUseId, cardId);
 }
 async function readOnce(ctx, args, cursor, told) {
   const { sessionId, state, status, signal } = args;
@@ -8032,6 +8128,7 @@ async function take(ctx, args, step) {
   args.status.progress(step);
   if (truthy(step.approval) || truthy(step.question)) {
     await ask2(ctx, args.sessionId, step);
+    if (!truthy(step.approval)) args.status.awaitingChoice();
     return void 0;
   }
   if (!step.finished) return void 0;
@@ -8418,8 +8515,9 @@ var TurnRun = class {
     state.writes = ctx.record.wrote;
     this.state = state;
     noteRunning(ctx, state, this.running);
-    if (messageId === void 0 && !ctx.request.attach) {
-      await ctx.deps.surface.send(plainMessage(turnText.in(langOf(ctx)).queuedNotice));
+    if (queuedByClaw(messageId) && !ctx.request.attach) {
+      const notice = turnText.in(langOf(ctx)).queuedNotice;
+      if (!this.status.queued(notice)) await ctx.deps.surface.send(plainMessage(notice));
     }
     return consume(ctx, { sessionId, state, status: this.status, running: this.running, signal });
   }
@@ -8573,6 +8671,10 @@ var TurnRun = class {
     await offerReport(ctx);
   }
 };
+var QUEUED_MESSAGE_PREFIX = "claw-pending-";
+function queuedByClaw(messageId) {
+  return messageId === void 0 || messageId.startsWith(QUEUED_MESSAGE_PREFIX);
+}
 async function runTurn(ctx, controls) {
   const replyTo = streamReplyTo(ctx);
   if (!replyTo) detach(() => typing(ctx));
@@ -8773,6 +8875,7 @@ var TurnEngine = class {
       quote: run.quote,
       sent: run.sent,
       lang: run.lang,
+      ...run.replyLang === void 0 ? {} : { replyLang: run.replyLang },
       files: run.files,
       ...review ? reviewRequest(review) : {}
     };
@@ -8782,9 +8885,9 @@ var TurnEngine = class {
     const review = run.review?.turn;
     return {
       ...run.provider ? { keyProvider: run.provider } : {},
-      onApproval: (sid, toolUseId, tool2, expiresIn, envelope) => approvals.record(run.userId, sid, toolUseId, tool2, expiresIn, envelope),
-      onApprovalSent: (sid, toolUseId) => {
-        approvals.sent(sid, toolUseId);
+      onApproval: (sid, toolUseId, tool2, expiresIn, envelope, questions) => approvals.record(run.userId, sid, toolUseId, tool2, expiresIn, envelope, questions),
+      onApprovalSent: (sid, toolUseId, cardId) => {
+        approvals.sent(sid, toolUseId, cardId);
       },
       onApprovalUnsent: (sid, toolUseId) => {
         approvals.unsent(sid, toolUseId);
@@ -9697,6 +9800,14 @@ var CredentialUnavailable = class extends Error {
 };
 var IDENTITY_CARD_INTERVAL_SECONDS = 24 * 3600;
 var IDENTITY_CARD_NOTICE = "identity_card";
+function chatCredentialOf(links2, exchange) {
+  return async (sender) => {
+    const key = links2.getKey(sender.id) ?? void 0;
+    if (exchange === void 0 || !exchange.enabled) return key;
+    const token = await exchange.tokenFor(sender.id);
+    return token.ok ? token.value : key;
+  };
+}
 var Credentials = class {
   constructor(deps, views) {
     this.deps = deps;
@@ -10203,7 +10314,7 @@ var CHAT_ENTRIES = [
     category: "chat",
     zh: "\u8981\u4F60\u62CD\u677F\u65F6\u6211\u53D1\u5361\u7247\uFF1A\u70B9\u6309\u94AE\u56DE\u7B54\u3001\u6279\u51C6\u6216\u62D2\u7EDD",
     en: "When I need you, I send a card: tap to answer, approve or deny",
-    covers: ["card:decision", "card:answer", "card:assistant_action"],
+    covers: ["card:decision", "card:answer", "card:assistant_action", "card:assistant_choice"],
     where: "both"
   }),
   capability({
@@ -13134,11 +13245,12 @@ var PersonalRouter = class {
     const { assistant, remote } = this.ctx.deps;
     const userId = chat.sender.id;
     const understood = assistant.understands(userId);
-    const switching = understood && remote.enabled && switchCommand(message.text) !== null;
-    const forAssistant = understood && !exactCommand(message.text, { menuCommand, isKnownCommand }) && !switching;
-    const text8 = understood ? menuCommand(message.text) : this.text.textOf(message);
+    const choice = message.choice === true;
+    const switching = understood && !choice && remote.enabled && switchCommand(message.text) !== null;
+    const forAssistant = understood && (choice || !exactCommand(message.text, { menuCommand, isKnownCommand })) && !switching;
+    const text8 = understood && !choice ? menuCommand(message.text) : this.text.textOf(message);
     learnLang(this.ctx.deps.store, userId, message.text);
-    if (await this.beforeCredential(message, chat, text8, forAssistant)) return;
+    if (!choice && await this.beforeCredential(message, chat, text8, forAssistant)) return;
     const key = await this.ctx.credentials.credential(chat, true);
     if (key === void 0) return;
     if (forAssistant && !this.text.talksToAgent(message)) await this.text.understand(message, chat, key);
@@ -13234,7 +13346,7 @@ var GroupRemote = class {
     const { remote } = this.ctx.deps;
     const bound = this.chatOf(chat);
     const attached = remote.attached(bound.id);
-    const args = this.agentArgs(words3.text, attached);
+    const args = message.choice === true ? null : this.agentArgs(words3.text, attached);
     const provider = this.ctx.credentials.provider(chat.sender.id, key);
     if (args !== null) {
       const parsed = parseAgentCommand(args);
@@ -13255,11 +13367,12 @@ var GroupRemote = class {
     const { remote } = this.ctx.deps;
     const bound = this.chatOf(chat);
     const provider = this.ctx.credentials.provider(chat.sender.id, key);
-    if (naturalCommand(words3.text) === "/stop" || parseCommand(words3.text) === "stop") {
+    const choice = message.choice === true;
+    if (!choice && (naturalCommand(words3.text) === "/stop" || parseCommand(words3.text) === "stop")) {
       await remote.stop(bound, key, chat.conversation);
       return true;
     }
-    if (parseCommand(words3.text) !== null) return false;
+    if (!choice && parseCommand(words3.text) !== null) return false;
     let quote = words3.quote;
     if (remote.windowMode(bound.id) === "card") {
       if (!remote.quotesWindow(bound.id, message)) return false;
@@ -13273,160 +13386,687 @@ var GroupRemote = class {
   }
 };
 
-// packages/core/src/routing/personal-text.ts
-var ELSEWHERE = "Files are not passed on from this chat while it talks to an agent; only your words were sent.";
-var PersonalText = class {
-  constructor(ctx, commands, starter) {
-    this.ctx = ctx;
-    this.commands = commands;
-    this.starter = starter;
-  }
-  ctx;
-  commands;
-  starter;
-  /**
-   * What the person wrote, with a word of the commands menu read as its command and a sentence help teaches read as the
-   * command it means; a sentence for what this chat cannot do right now stays words.
-   */
-  textOf(message, group = false) {
-    const { github, assistant, remote, config } = this.ctx.deps;
-    const userId = group ? void 0 : message.sender.id;
-    const on = (test) => userId !== void 0 && test(userId);
-    const attached = on((id) => remote.attached(id));
-    const off = /* @__PURE__ */ new Set();
-    const rules = [
-      ["github", github !== void 0],
-      ["board", on((id) => assistant.on(id))],
-      ["brief", config.briefEnabled],
-      ["brief now", on((id) => assistant.on(id))],
-      ["agents", remote.enabled],
-      ["agent", remote.enabled],
-      ["agent detach", attached],
-      ["stop it", attached],
-      // ("停掉它" stops the attached agent; with the assistant it is the assistant's to read)
-      ["new", !(attached && on((id) => assistant.on(id)))]
-      // (in an attached chat: a new agent session, the assistant's)
-    ];
-    for (const [word2, enabled] of rules) if (!enabled) off.add(word2);
-    if (remote.enabled && on((id) => assistant.on(id)) && menuCommand(message.text, group) === "/agent sessions" && !/agent/iu.test(message.text))
-      return "/sessions";
-    return naturalCommand(menuCommand(message.text, group), group, off);
-  }
-  async onText(message, chat, key) {
-    const text8 = this.textOf(message);
-    if (parseCommand(text8) === "unlink" && !message.text.startsWith("/")) {
-      await chat.say(routingText.in(chat.lang()).unlinkAsk);
-      return;
-    }
-    if (await this.commands.run(text8, chat, key, message)) return;
-    if (!this.talksToAgent(message))
-      await this.offerGithub(message, chat, key, text8, (m, fresh) => this.sentOn(m, chat, fresh));
-    await this.sentOn(message, chat, key);
-  }
-  /**
-   * Whether this 1:1 message goes to the remote session the chat is attached to: only words the person typed, and not
-   * those that start by naming the bot. A chat whose session card is the window keeps its chat box for the bot: only a
-   * reply that quotes the card goes to the session.
-   */
-  talksToAgent(message) {
-    const { remote } = this.ctx.deps;
-    const userId = message.sender.id;
-    if (!remote.attached(userId) || message.provenance !== "typed" || message.namesBotFirst) return false;
-    if (remote.windowMode(userId) === "card") return remote.quotesWindow(userId, message);
-    return true;
-  }
-  /** The files that go to Claw with a message; the person is told about the ones that do not, and they are counted. */
-  async attachments(message, chat, elsewhere = false) {
-    const { messageText, metrics } = this.ctx.deps;
-    const unreadable = messageText.unreadable(message);
-    if (unreadable !== void 0) {
-      metrics.filesDropped("unreadable", unreadable.count);
-      await chat.say(unreadable.line);
-    }
-    if (message.files.length > 0 && elsewhere) {
-      metrics.filesDropped("remote_agent", message.files.length);
-      await chat.say(ELSEWHERE);
-      return [];
-    }
-    return message.files;
-  }
-  /** What the chat is attached to, for the assistant (only where remote agents are on). */
-  async attached(userId, key) {
-    const { remote } = this.ctx.deps;
-    return remote.enabled ? { attached: await remote.chatContext(userId, key) } : {};
-  }
-  /** A 1:1 message that is no command, as it goes on to the attached agent, the assistant or Claw. */
-  async sentOn(message, chat, key) {
-    const { messageText, assistant } = this.ctx.deps;
-    const userId = chat.sender.id;
-    const text8 = this.textOf(message);
-    const toAgent = this.talksToAgent(message);
-    const quote = toAgent && this.ctx.deps.remote.quotesWindow(userId, message) ? "" : messageText.quoteBlock(message, false);
-    const sent = messageText.withLinks(text8, message);
-    const prompt = messageText.withQuote(sent, quote);
-    const files = await this.attachments(message, chat, toAgent);
-    const control = this.sessionControl(userId, prompt, toAgent, quote, files, text8);
-    if (control && assistant.understands(userId)) {
-      await this.understand(message, chat, key);
-    } else if (prompt && toAgent && !control) {
-      await this.remotePrompt(message, chat, key, prompt);
-    } else if (prompt || files.length > 0) {
-      await this.toAssistantOrTurn(message, chat, key, { text: text8, quote, sent, prompt, files });
-    }
+// packages/core/src/approvals/questions.ts
+import { z as z4 } from "zod";
+
+// packages/core/src/text/plain.ts
+function clip3(text8, limit) {
+  return clipLine(squashSpaces(text8), limit);
+}
+function pyJson(value, options = {}) {
+  return options.compact ? compact(value) : pyJsonDumps(value);
+}
+function compact(value) {
+  if (Array.isArray(value)) return `[${value.map(compact).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value);
+    return `{${entries.map(([k, v]) => `${pyJsonDumps(k)}:${compact(v)}`).join(",")}}`;
   }
-  /**
-   * A message to an attached chat that is about the sessions themselves (switch, open a new one), with the assistant on to
-   * read it: the words alone (a quote or a file goes to the agent with them).
-   */
-  sessionControl(userId, prompt, toAgent, quote, files, text8) {
-    if (!prompt || !toAgent || quote || files.length > 0) return false;
-    return this.ctx.deps.assistant.on(userId) && sessionControl(text8);
+  return pyJsonDumps(value);
+}
+
+// packages/core/src/approvals/questions.ts
+var QUESTION_TOOL2 = "ask_user_question";
+var QUESTIONS_MAX = 5;
+var OPTIONS_MAX = 10;
+var QUESTION_MAX = 500;
+var OPTION_MAX = 120;
+var ANSWER_MAX = 1e3;
+function scalarText(value) {
+  if (value === null || value === void 0 || value === false || value === 0 || value === "") return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  if (value === true) return "True";
+  return "";
+}
+var rawOption = z4.object({ id: z4.unknown(), label: z4.unknown() }).partial();
+var rawQuestion = z4.object({ id: z4.unknown(), question: z4.unknown(), options: z4.unknown(), allow_multiple: z4.unknown() }).partial();
+function optionsOf(raw) {
+  const out = [];
+  for (const item of Array.isArray(raw) ? raw : []) {
+    const option = rawOption.safeParse(item);
+    if (!option.success || typeof item !== "object" || Array.isArray(item)) continue;
+    const id = scalarText(option.data.id);
+    if (!pyStrip(id)) continue;
+    out.push({ id, label: clip3(scalarText(option.data.label) || id, OPTION_MAX) });
   }
-  /** A message the assistant takes when it is on, else a turn of Claw's. */
-  async toAssistantOrTurn(message, chat, key, said2) {
-    const { assistant } = this.ctx.deps;
-    const userId = chat.sender.id;
-    if (assistant.on(userId) && await this.ctx.admission.assistantOverLimit(chat, message.id, key)) return;
-    const routed = await assistant.route({
-      userId,
-      credential: key,
-      prompt: said2.prompt || assistant.filesOnly(chat.lang()),
-      conversation: chat.conversation,
-      files: said2.files,
-      ...await this.attached(userId, key)
+  return out.slice(0, OPTIONS_MAX);
+}
+function cardQuestions(raw) {
+  const out = [];
+  for (const item of Array.isArray(raw) ? raw : []) {
+    const question = rawQuestion.safeParse(item);
+    if (!question.success || typeof item !== "object" || Array.isArray(item)) continue;
+    const id = scalarText(question.data.id);
+    const text8 = scalarText(question.data.question);
+    if (!pyStrip(id) || !pyStrip(text8)) continue;
+    out.push({
+      id,
+      question: clip3(text8, QUESTION_MAX),
+      options: optionsOf(question.data.options),
+      allowMultiple: question.data.allow_multiple === true
     });
-    if (routed) return;
-    this.ctx.admission.dropLastHandoff(userId);
-    await this.starter.start({
-      chat,
-      credential: key,
-      text: said2.text,
-      messageId: message.id,
-      clientPlatform: message.clientPlatform,
-      quote: said2.quote,
-      sent: said2.sent,
-      files: said2.files
+  }
+  return out.slice(0, QUESTIONS_MAX);
+}
+function questionWire(question) {
+  return {
+    id: question.id,
+    question: question.question,
+    options: question.options.map((o) => ({ id: o.id, label: o.label })),
+    allow_multiple: question.allowMultiple
+  };
+}
+function answersOf(data) {
+  const answers = /* @__PURE__ */ new Map();
+  const skipped = [];
+  cardQuestions(data["questions"]).forEach((q, i) => {
+    const labels = new Map(q.options.map((o) => [o.id, o.label]));
+    const chosen = scalarText(own(data, `choice_${String(i)}`)).split(",").flatMap((c) => {
+      const label = labels.get(c);
+      return label === void 0 ? [] : [label];
     });
+    const typed2 = cpHead(pyStrip(scalarText(own(data, `text_${String(i)}`))), ANSWER_MAX);
+    const answer2 = [chosen.join(", "), typed2].filter(Boolean).join(". ");
+    if (answer2) answers.set(q.id, answer2);
+    else skipped.push(q.id);
+  });
+  return { answers, skipped };
+}
+function optionNamed(options, token) {
+  const wanted = token.toLowerCase();
+  const byLabel = options.find((o) => o.label.toLowerCase() === wanted || o.id.toLowerCase() === wanted);
+  if (byLabel !== void 0 || !/^\d{1,2}$/.test(token)) return byLabel;
+  return options[Number(token) - 1];
+}
+function typedAnswers(questions, typed2) {
+  const reply = cpHead(pyStrip(typed2), ANSWER_MAX);
+  const answers = /* @__PURE__ */ new Map();
+  const only2 = questions.length === 1 ? questions[0] : void 0;
+  if (only2 !== void 0) {
+    const tokens2 = only2.allowMultiple ? reply.split(/\s*[,，、;；]\s*/u).filter(Boolean) : [reply];
+    const named2 = tokens2.flatMap((t4) => optionNamed(only2.options, t4) ?? []);
+    const labels = named2.length > 0 && named2.length === tokens2.length ? named2.map((o) => o.label) : [];
+    answers.set(only2.id, labels.length ? labels.join(", ") : reply);
+  } else {
+    for (const q of questions) answers.set(q.id, reply);
   }
-  /** A prompt for the attached agent, within the task limit (the slot is held until the remote turn counts as running). */
-  async remotePrompt(message, chat, key, prompt) {
-    const { remote } = this.ctx.deps;
-    const request = {
-      message,
-      chat: chat.sender,
-      credential: key,
-      prompt,
-      conversation: chat.conversation,
-      provider: this.ctx.credentials.provider(chat.sender.id, key)
-    };
-    if (remote.running(chat.sender.id)) {
-      await remote.prompt(request);
-      return;
-    }
-    if (!await this.ctx.admission.admitRemote(chat, message.id, key)) return;
-    try {
-      await remote.prompt(request);
-    } finally {
+  return { answers, skipped: [] };
+}
+
+// packages/core/src/approvals/click.ts
+function viewMessage2(view7, fallbackText = "") {
+  return { body: { type: "view", view: view7, fallbackText } };
+}
+
+// packages/core/src/proactive/quiet.ts
+var APPROVAL_DEFAULT_SECONDS = 600;
+var PERMISSION_DEFAULT_SECONDS = 600;
+var PERMISSION_MAX_SECONDS = 3600;
+var formatters = /* @__PURE__ */ new Map();
+function formatter(zone) {
+  const known = formatters.get(zone);
+  if (known) return known;
+  try {
+    const made = new Intl.DateTimeFormat("en-US", {
+      timeZone: zone,
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23"
+    });
+    formatters.set(zone, made);
+    return made;
+  } catch {
+    return void 0;
+  }
+}
+function zoneOf3(prefs) {
+  return prefs.timezone && formatter(prefs.timezone) ? prefs.timezone : DEFAULT_TIMEZONE;
+}
+function localMinutes(epochSeconds2, zone) {
+  const parts2 = (formatter(zone) ?? formatter(DEFAULT_TIMEZONE))?.formatToParts(new Date(epochSeconds2 * 1e3)) ?? [];
+  const value = (type) => Number(parts2.find((p) => p.type === type)?.value ?? "0");
+  return value("hour") * 60 + value("minute");
+}
+function minutesOf(clock2) {
+  const [hour = "0", minute = "0"] = clock2.split(":");
+  return Number(hour) * 60 + Number(minute);
+}
+function inQuiet(now, zone, start, end) {
+  const minute = localMinutes(now, zone);
+  const s = minutesOf(start);
+  const e = minutesOf(end);
+  if (s === e) return false;
+  return s < e ? s <= minute && minute < e : minute >= s || minute < e;
+}
+function muted(prefs, now) {
+  if (prefs.pausedUntil !== null && now < prefs.pausedUntil) return "paused";
+  if (prefs.quietEnabled && inQuiet(now, zoneOf3(prefs), prefs.quietStart, prefs.quietEnd)) return "quiet";
+  return void 0;
+}
+function isoSeconds2(raw) {
+  if (typeof raw !== "string") return void 0;
+  const match = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,6})?)?(Z|[+-]\d{2}:?\d{2}(?::?\d{2})?)$/.exec(
+    raw.trim()
+  );
+  if (!match) return void 0;
+  const at = Date.parse(raw.trim().replace(" ", "T"));
+  return Number.isNaN(at) ? void 0 : at / 1e3;
+}
+function approvalExpiry(event, now) {
+  const approval = event["approval"];
+  const raw = typeof approval === "object" && approval !== null ? approval["expires_at"] : void 0;
+  return isoSeconds2(raw) ?? now + APPROVAL_DEFAULT_SECONDS;
+}
+function remoteAskExpiry(ask3, now) {
+  const at = isoSeconds2(ask3["expires_at"]);
+  return at === void 0 ? now + PERMISSION_DEFAULT_SECONDS : Math.min(at, now + PERMISSION_MAX_SECONDS);
+}
+
+// packages/core/src/routing/question-reply.ts
+var TYPED_ANSWER_MARGIN_SECONDS = 15;
+async function answerWaitingQuestion(ctx, reply) {
+  const { store, claw, logger } = ctx.deps;
+  const { chat } = reply;
+  const waiting = waitingQuestion(ctx, reply);
+  if (waiting === void 0) return false;
+  const { pending, questions } = waiting;
+  const { sessionId, toolUseId } = pending;
+  const key = await stillAsked(ctx, reply, pending);
+  if (key === void 0) return false;
+  if (!store.approvals.closeApproval(sessionId, toolUseId, "sending")) return false;
+  const answers = typedAnswers(questions, reply.text);
+  try {
+    await claw.sessions.answer(key, sessionId, toolUseId, Object.fromEntries(answers.answers), answers.skipped);
+  } catch (error) {
+    if (!isClawOrNetwork(error)) throw error;
+    const stale = error instanceof ClawError && [404, 409, 410].includes(error.status);
+    store.approvals.closeApproval(sessionId, toolUseId, stale ? "expired" : "pending", { onlyIfPending: false });
+    logger.warn("a typed answer to a question card was not taken; the message goes on as a new one", {
+      error: statusOrKind(error)
+    });
+    return false;
+  }
+  store.approvals.closeApproval(sessionId, toolUseId, "decided", { onlyIfPending: false });
+  logger.info("a typed message answered the question card waiting in the chat", {
+    chat: chat.scope ? "group" : "1:1",
+    questions: questions.length,
+    card: pending.cardId ? "edited" : "not editable"
+  });
+  const lang = answerLang(store.prefs.getPrefs(chat.sender.id).lang, chat.locale, questions[0]?.question, reply.text);
+  await settleCard(ctx, chat, pending.cardId, [...answers.answers], lang);
+  return true;
+}
+function waitingQuestion(ctx, reply) {
+  const { store } = ctx.deps;
+  const { chat } = reply;
+  if (!pyStrip(reply.text)) return void 0;
+  const sessionId = store.sessions.getSession(chat.sender.id, chat.scope);
+  if (sessionId === null || store.reviewDelegation.isActingSession(sessionId)) return void 0;
+  const pending = store.approvals.pendingQuestion(sessionId, chat.sender.id);
+  if (pending === null || pending.expiresAt - store.now() < TYPED_ANSWER_MARGIN_SECONDS) return void 0;
+  const questions = cardQuestions(pending.questions);
+  return questions.length === 0 ? void 0 : { pending, questions };
+}
+async function stillAsked(ctx, reply, pending) {
+  const { store, claw, logger } = ctx.deps;
+  try {
+    const key = await reply.credential();
+    if ((await claw.sessions.turn(key, pending.sessionId)).running) return key;
+    store.approvals.closeApproval(pending.sessionId, pending.toolUseId, "expired");
+    return void 0;
+  } catch (error) {
+    if (!isClawOrNetwork(error)) throw error;
+    logger.warn("a typed answer to a question card was not sent: the session's turn could not be read", {
+      error: statusOrKind(error)
+    });
+    return void 0;
+  }
+}
+async function settleCard(ctx, chat, cardId, answers, lang) {
+  const { store, logger } = ctx.deps;
+  const zone = zoneOf3(store.prefs.getPrefs(chat.sender.id));
+  const answer2 = [...new Set(answers.map(([, a]) => a))].join(" / ");
+  const words3 = approvalText.in(lang).questionReplied({ answer: answer2 });
+  try {
+    if (cardId) {
+      const view7 = { name: "questionAnswered", model: { answers, when: store.now(), zone, replied: lang } };
+      await chat.conversation.update(cardId, viewMessage2(view7, words3));
+    } else {
+      await chat.say(words3);
+    }
+  } catch (error) {
+    logger.warn("the question card could not be marked answered", { error: errorName(error) });
+  }
+}
+
+// packages/core/src/routing/turn-start.ts
+var MOBILE_PLATFORMS = ["ios", "ipados", "android"];
+function isMobile(clientPlatform) {
+  return MOBILE_PLATFORMS.includes(clientPlatform.toLowerCase());
+}
+function logTurnStarted(logger, clientPlatform, group, route) {
+  logger.info("turn started from Teams client", {
+    platform: clientPlatform || "unknown",
+    chat: group ? "group" : "1:1",
+    route
+  });
+}
+var TurnStarter = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  running = /* @__PURE__ */ new Set();
+  /** The turns that run now (a test waits for them). */
+  settled() {
+    return Promise.all([...this.running]).then(() => void 0);
+  }
+  /** The turn that runs (its end is `done`), or undefined when none was started (the person was told why). */
+  async start(started) {
+    const request = { ...started, ...this.replyLang(started) };
+    const { chat, review } = request;
+    if (await this.answersQuestion(request)) return void 0;
+    const key = review ? reviewTurnKey(chat.sender.id, chat.scope, review.itemId, review.pull) : chatTurnKey(chat.sender.id, chat.scope);
+    const turn = new ActiveTurn(review !== void 0, review?.itemId ?? "");
+    const admitted = review === void 0 && await this.admit(request, key, turn);
+    if (admitted === void 0) return void 0;
+    if (!admitted) {
+      const queued = await this.queueBehind(key, turn, chat);
+      if (queued === "refused") return void 0;
+      if (queued === "waiting") return this.track(this.afterFront(request, key, turn));
+    }
+    return this.launch(request, key, turn);
+  }
+  /** A typed message the waiting question card of the chat's session took as its answer (`question-reply.ts`). */
+  async answersQuestion(request) {
+    if (!request.typed || request.review !== void 0 || (request.files?.length ?? 0) > 0) return false;
+    const provider = this.providerOf(request);
+    return answerWaitingQuestion(this.ctx, {
+      chat: request.chat,
+      text: request.text,
+      credential: provider ?? (() => Promise.resolve(request.credential))
+    });
+  }
+  track(task) {
+    this.running.add(task);
+    void task.finally(() => this.running.delete(task));
+    return { done: task };
+  }
+  /** The turn goes to Claw now; its end is `done`. */
+  async launch(request, key, turn) {
+    turn.launched = true;
+    let run;
+    try {
+      run = await this.runOf(request);
+    } catch (error) {
+      this.ctx.turns.drop(key, turn);
+      throw error;
+    }
+    return this.track(this.guarded(request, run, key, turn));
+  }
+  /**
+   * A queued turn: it goes once every turn in front of it is over, or stopped (Claw took its interrupt: Claw is free for the next
+   * message, whether or not that turn ever reports its end); the caller does not wait for it. Not at all when it was given up
+   * meanwhile (`/stop`, said there).
+   */
+  async afterFront(request, key, turn) {
+    for (; ; ) {
+      if (turn.over) return;
+      const turns = this.ctx.turns.of(key);
+      const at = turns.indexOf(turn);
+      if (at < 0) return;
+      const blocking = turns.slice(0, at).find((front) => !front.stopped.isSet);
+      if (blocking === void 0) break;
+      await Promise.race([blocking.ended.whenSet(), blocking.stopped.whenSet(), turn.ended.whenSet()]);
+    }
+    let started;
+    try {
+      started = await this.launch(request, key, turn);
+    } catch (error) {
+      const ref = this.ctx.deps.random.hexId().slice(0, 8);
+      this.ctx.deps.logger.error("a queued turn could not start", { ref, error: errorName(error) });
+      await this.tell(request, `Something went wrong on my side (ref ${ref}). Please try again.`);
+      return;
+    }
+    await started.done;
+  }
+  /** True when admitted as the chat's first turn; false when the chat has one (queue behind it); undefined: refused. */
+  async admit(request, key, turn) {
+    if (this.ctx.turns.has(key)) return false;
+    const { chat } = request;
+    return this.ctx.admission.lock.run(chat.sender.id, async () => {
+      if (this.ctx.turns.has(key)) return false;
+      if (await this.ctx.admission.overLimit(chat, request.messageId, "claw_turn", "", request.credential))
+        return void 0;
+      this.ctx.turns.claim(key, turn);
+      return true;
+    });
+  }
+  /**
+   * Registers `turn` behind the chat's running one: "front" when the chat has none after all (it runs now), "waiting" when it
+   * is queued (the person is told its place), "refused" (and told why) when it may not wait.
+   */
+  async queueBehind(key, turn, chat) {
+    const queued = this.ctx.turns.enqueue(key, turn);
+    const said2 = routingText.in(chat.lang());
+    if (queued === "still_working" || queued === "queue_full") {
+      await chat.say(queued === "still_working" ? said2.stillWorking : said2.queueFull({ n: QUEUED_TURNS_MAX }));
+      return "refused";
+    }
+    if (queued.front === turn) return "front";
+    const stoppedInFront = this.ctx.turns.of(key).every((front) => front === turn || front.stopped.isSet);
+    if (stoppedInFront) return "waiting";
+    try {
+      await chat.say(said2.queuedBehind({ n: queued.waiting }));
+    } catch (error) {
+      this.ctx.turns.drop(key, turn);
+      throw error;
+    }
+    return "waiting";
+  }
+  async sessionOf(request) {
+    const { chat, review } = request;
+    const { store, config } = this.ctx.deps;
+    if (review !== void 0) return review.itemSessionId;
+    const sessionId = store.sessions.getSession(chat.sender.id, chat.scope);
+    if (sessionId === null) return null;
+    if (Boolean(store.sessions.getSessionPlugin(chat.sender.id, chat.scope)) !== Boolean(config.pluginId)) {
+      await chat.say("Starting a new session so I can use the Primus platform tools.");
+      return null;
+    }
+    if (chat.scope && !store.sessions.getSessionShared(chat.sender.id, chat.scope)) return null;
+    return sessionId;
+  }
+  providerOf(request) {
+    const usesExchange = request.review !== void 0 || this.ctx.credentials.onExchange;
+    if (!this.ctx.deps.exchange.enabled || !usesExchange) return void 0;
+    return () => this.ctx.credentials.fresh(request.chat.sender.id, request.credential);
+  }
+  ownThumbs(request) {
+    return isMobile(request.clientPlatform) && request.review === void 0 && this.ctx.deps.config.ownThumbsMobile;
+  }
+  /** What the run reads of the chat's session: its id, the model it has, the repository a new one is bound to. */
+  async sessionPart(request) {
+    const { chat, review } = request;
+    const { store } = this.ctx.deps;
+    const sessionId = await this.sessionOf(request);
+    const chosen = sessionId === null && !chat.scope ? store.repoHistory.getPendingRepo(chat.sender.id) : null;
+    return {
+      sessionId,
+      sessionModel: sessionId === null || review ? "" : store.sessions.getSessionModel(chat.sender.id, chat.scope),
+      repo: chosen === null ? null : { url: `${REPO_HOST}/${chosen.repo}`, branch: chosen.branch }
+    };
+  }
+  async runOf(request) {
+    const { chat, review } = request;
+    const { store, config, logger } = this.ctx.deps;
+    const session = await this.sessionPart(request);
+    const group = chat.scope !== "";
+    logTurnStarted(logger, request.clientPlatform, group, review ? "review" : "legacy");
+    return {
+      ...session,
+      conversation: chat.conversation,
+      credential: request.credential,
+      provider: this.providerOf(request),
+      text: request.text,
+      messageId: request.messageId,
+      group,
+      userId: chat.sender.id,
+      ownerName: chat.sender.name,
+      model: review ? review.model || config.reviewModel || config.model : config.model,
+      fallbackModel: config.fallbackModel,
+      showChanges: !group && review === void 0,
+      quote: request.quote ?? "",
+      sent: request.sent ?? "",
+      files: request.files ?? [],
+      lang: review?.lang ?? chat.lang(),
+      ...request.replyLang === void 0 ? {} : { replyLang: request.replyLang },
+      ownThumbs: this.ownThumbs(request),
+      notifies: this.ctx.deps.subscriptions !== void 0 && store.notifySubs.getNotifySub(chat.sender.id) !== null,
+      review: review?.fields
+    };
+  }
+  /** The language the sender chose to be answered in, for a chat turn (a review's answer follows its request's language). */
+  replyLang(request) {
+    if (request.review !== void 0) return {};
+    const lang = chosenLang(this.ctx.deps.store.prefs.getPrefs(request.chat.sender.id));
+    return lang === void 0 ? {} : { replyLang: lang };
+  }
+  hooks(request, run, turn, turnId) {
+    const { review, chat } = request;
+    const store = this.ctx.deps.store;
+    return {
+      onSession: (sessionId, sessionModel) => {
+        if (review) review.onSession(sessionId);
+        else this.recordSession(chat, sessionId, run, sessionModel);
+      },
+      onRunning: () => {
+        turn.running.set();
+      },
+      onTurn: (sessionId, what, messageId) => {
+        if (what === "started") store.turns.turnStarted(sessionId, { prompt: run.text, messageId, turnId });
+        else if (what === "delivered") store.turns.turnDelivered(sessionId, { messageId, turnId });
+        else store.turns.turnNotDelivered(sessionId, turnId);
+      },
+      stopRequested: () => turn.stopRequested,
+      toolDenied: () => turn.toolDenied,
+      stopConfirmed: () => turn.stopConfirmed,
+      reportView: () => this.ctx.deps.reportView(chat.sender.id, chat.scope)
+    };
+  }
+  async guarded(request, run, key, turn) {
+    const turnId = this.ctx.deps.random.hexId();
+    try {
+      const outcome = await this.ctx.deps.turns.run(run, this.hooks(request, run, turn, turnId));
+      if (request.review) await request.review.after(outcome);
+    } catch (error) {
+      const ref = this.ctx.deps.random.hexId().slice(0, 8);
+      this.ctx.deps.logger.error("turn failed", { ref, error: errorName(error) });
+      await this.tell(request, `Something went wrong on my side (ref ${ref}). Please try again.`);
+    } finally {
+      this.ctx.turns.drop(key, turn);
+    }
+  }
+  async tell(request, text8) {
+    try {
+      await request.chat.say(text8);
+      const report = this.ctx.deps.reportView(request.chat.sender.id, request.chat.scope);
+      if (report !== void 0) await request.chat.send(report);
+    } catch (error) {
+      this.ctx.deps.logger.warn("a failed turn could not be said", { error: errorName(error) });
+    }
+  }
+  /**
+   * The turn has a session: it is the chat's session, and a 1:1 chat remembers it for /sessions, with what a session
+   * this turn created was started with and the repository it is bound to (which uses up the `/repo` choice).
+   */
+  recordSession(chat, sessionId, run, sessionModel) {
+    const { store, config } = this.ctx.deps;
+    const userId = chat.sender.id;
+    store.sessions.setSession(
+      userId,
+      { sessionId, pluginId: config.pluginId, model: sessionModel, shared: chat.scope !== "" },
+      chat.scope
+    );
+    if (chat.scope) return;
+    const created = run.sessionId !== sessionId;
+    if (created && run.sessionId) store.repoHistory.forgetSession(userId, run.sessionId);
+    const url = run.repo?.url ?? "";
+    const bound = created && run.repo ? url.startsWith(`${REPO_HOST}/`) ? url.slice(REPO_HOST.length + 1) : url : "";
+    store.repoHistory.noteSession(userId, sessionId, {
+      title: created ? cpHead(squashSpaces(run.text), 50) : "",
+      repo: bound,
+      branch: bound && run.repo ? run.repo.branch : ""
+    });
+    if (created && run.repo) store.repoHistory.clearPendingRepo(userId);
+  }
+};
+
+// packages/core/src/routing/personal-text.ts
+var ELSEWHERE = "Files are not passed on from this chat while it talks to an agent; only your words were sent.";
+var PersonalText = class {
+  constructor(ctx, commands, starter) {
+    this.ctx = ctx;
+    this.commands = commands;
+    this.starter = starter;
+  }
+  ctx;
+  commands;
+  starter;
+  /**
+   * What the person wrote, with a word of the commands menu read as its command and a sentence help teaches read as the
+   * command it means; a sentence for what this chat cannot do right now stays words. A choice picked on the assistant's card
+   * is the words picked, never a command.
+   */
+  textOf(message, group = false) {
+    if (message.choice === true) return message.text;
+    const { github, assistant, remote, config } = this.ctx.deps;
+    const userId = group ? void 0 : message.sender.id;
+    const on = (test) => userId !== void 0 && test(userId);
+    const attached = on((id) => remote.attached(id));
+    const off = /* @__PURE__ */ new Set();
+    const rules = [
+      ["github", github !== void 0],
+      ["board", on((id) => assistant.on(id))],
+      ["brief", config.briefEnabled],
+      ["brief now", on((id) => assistant.on(id))],
+      ["agents", remote.enabled],
+      ["agent", remote.enabled],
+      ["agent detach", attached],
+      ["stop it", attached],
+      // ("停掉它" stops the attached agent; with the assistant it is the assistant's to read)
+      ["new", !(attached && on((id) => assistant.on(id)))]
+      // (in an attached chat: a new agent session, the assistant's)
+    ];
+    for (const [word2, enabled] of rules) if (!enabled) off.add(word2);
+    if (remote.enabled && on((id) => assistant.on(id)) && menuCommand(message.text, group) === "/agent sessions" && !/agent/iu.test(message.text))
+      return "/sessions";
+    return naturalCommand(menuCommand(message.text, group), group, off);
+  }
+  async onText(message, chat, key) {
+    const text8 = this.textOf(message);
+    if (message.choice === true) {
+      await this.sentOn(message, chat, key);
+      return;
+    }
+    if (parseCommand(text8) === "unlink" && !message.text.startsWith("/")) {
+      await chat.say(routingText.in(chat.lang()).unlinkAsk);
+      return;
+    }
+    if (await this.commands.run(text8, chat, key, message)) return;
+    if (!this.talksToAgent(message))
+      await this.offerGithub(message, chat, key, text8, (m, fresh) => this.sentOn(m, chat, fresh));
+    await this.sentOn(message, chat, key);
+  }
+  /**
+   * Whether this 1:1 message goes to the remote session the chat is attached to: only words the person typed, and not
+   * those that start by naming the bot. A chat whose session card is the window keeps its chat box for the bot: only a
+   * reply that quotes the card goes to the session.
+   */
+  talksToAgent(message) {
+    const { remote } = this.ctx.deps;
+    const userId = message.sender.id;
+    if (!remote.attached(userId) || message.provenance !== "typed" || message.namesBotFirst) return false;
+    if (remote.windowMode(userId) === "card") return remote.quotesWindow(userId, message);
+    return true;
+  }
+  /** The files that go to Claw with a message; the person is told about the ones that do not, and they are counted. */
+  async attachments(message, chat, elsewhere = false) {
+    const { messageText, metrics } = this.ctx.deps;
+    const unreadable = messageText.unreadable(message);
+    if (unreadable !== void 0) {
+      metrics.filesDropped("unreadable", unreadable.count);
+      await chat.say(unreadable.line);
+    }
+    if (message.files.length > 0 && elsewhere) {
+      metrics.filesDropped("remote_agent", message.files.length);
+      await chat.say(ELSEWHERE);
+      return [];
+    }
+    return message.files;
+  }
+  /** What the chat is attached to, for the assistant (only where remote agents are on). */
+  async attached(userId, key) {
+    const { remote } = this.ctx.deps;
+    return remote.enabled ? { attached: await remote.chatContext(userId, key) } : {};
+  }
+  /** A 1:1 message that is no command, as it goes on to the attached agent, the assistant or Claw. */
+  async sentOn(message, chat, key) {
+    const { messageText, assistant } = this.ctx.deps;
+    const userId = chat.sender.id;
+    const text8 = this.textOf(message);
+    const toAgent = this.talksToAgent(message);
+    const quote = toAgent && this.ctx.deps.remote.quotesWindow(userId, message) ? "" : messageText.quoteBlock(message, false);
+    const sent = messageText.withLinks(text8, message);
+    const prompt = messageText.withQuote(sent, quote);
+    const files = await this.attachments(message, chat, toAgent);
+    const control = message.choice !== true && this.sessionControl(userId, prompt, toAgent, quote, files, text8);
+    if (control && assistant.understands(userId)) {
+      await this.understand(message, chat, key);
+    } else if (prompt && toAgent && !control) {
+      await this.remotePrompt(message, chat, key, prompt);
+    } else if (prompt || files.length > 0) {
+      await this.toAssistantOrTurn(message, chat, key, { text: text8, quote, sent, prompt, files });
+    }
+  }
+  /**
+   * A message to an attached chat that is about the sessions themselves (switch, open a new one), with the assistant on to
+   * read it: the words alone (a quote or a file goes to the agent with them).
+   */
+  sessionControl(userId, prompt, toAgent, quote, files, text8) {
+    if (!prompt || !toAgent || quote || files.length > 0) return false;
+    return this.ctx.deps.assistant.on(userId) && sessionControl(text8);
+  }
+  /** A message the assistant takes when it is on, else a turn of Claw's. */
+  async toAssistantOrTurn(message, chat, key, said2) {
+    const { assistant } = this.ctx.deps;
+    const userId = chat.sender.id;
+    if (assistant.on(userId) && await this.ctx.admission.assistantOverLimit(chat, message.id, key)) return;
+    const routed = await assistant.route({
+      userId,
+      credential: key,
+      prompt: said2.prompt || assistant.filesOnly(chat.lang()),
+      conversation: chat.conversation,
+      files: said2.files,
+      ...await this.attached(userId, key)
+    });
+    if (routed) {
+      logTurnStarted(this.ctx.deps.logger, message.clientPlatform, false, "assistant");
+      return;
+    }
+    this.ctx.admission.dropLastHandoff(userId);
+    await this.starter.start({
+      chat,
+      credential: key,
+      text: said2.text,
+      messageId: message.id,
+      clientPlatform: message.clientPlatform,
+      quote: said2.quote,
+      sent: said2.sent,
+      files: said2.files,
+      typed: true
+    });
+  }
+  /** A prompt for the attached agent, within the task limit (the slot is held until the remote turn counts as running). */
+  async remotePrompt(message, chat, key, prompt) {
+    const { remote } = this.ctx.deps;
+    const request = {
+      message,
+      chat: chat.sender,
+      credential: key,
+      prompt,
+      conversation: chat.conversation,
+      provider: this.ctx.credentials.provider(chat.sender.id, key)
+    };
+    if (remote.running(chat.sender.id)) {
+      await remote.prompt(request);
+      return;
+    }
+    if (!await this.ctx.admission.admitRemote(chat, message.id, key)) return;
+    try {
+      await remote.prompt(request);
+    } finally {
       this.ctx.admission.letGo(chat.sender.id);
     }
   }
@@ -13493,6 +14133,7 @@ var PersonalText = class {
     });
     const held = assistant.reachable(userId);
     if (held && await this.ctx.admission.assistantOverLimit(chat, message.id, key)) return;
+    if (held) logTurnStarted(logger, message.clientPlatform, false, "assistant");
     store.assistantMessages.noteAssistantMessage(
       channelMessageId,
       userId,
@@ -13573,7 +14214,8 @@ var GroupRouter = class {
   async message(message, chat) {
     const words3 = this.words(message);
     learnLang(this.ctx.deps.store, chat.sender.id, message.text);
-    if (await this.groupOwn(message, chat, words3)) return;
+    const choice = message.choice === true;
+    if (!choice && await this.groupOwn(message, chat, words3)) return;
     const route = {
       sender: chat.sender,
       conversation: chat.conversation,
@@ -13582,10 +14224,13 @@ var GroupRouter = class {
       message,
       text: words3.text
     };
-    for (const interceptor of this.ctx.deps.handlers.groupInterceptors) if (await interceptor.intercept(route)) return;
+    if (!choice) {
+      for (const interceptor of this.ctx.deps.handlers.groupInterceptors)
+        if (await interceptor.intercept(route)) return;
+    }
     const key = await this.ctx.credentials.credential(chat, false);
     if (key === void 0) {
-      const keep = parseCommand(words3.text) === null;
+      const keep = choice || parseCommand(words3.text) === null;
       await this.onboarding.member(message, chat, { ...words3, keep, identity: false });
       return;
     }
@@ -13628,7 +14273,7 @@ var GroupRouter = class {
     return !(word2 === "/agent" && remoteOn && (verb === "attach" || verb === "detach"));
   }
   async withKey(message, chat, key, words3) {
-    const command = parseCommand(words3.text);
+    const command = message.choice === true ? null : parseCommand(words3.text);
     if (command === "new") await this.sessions.new(chat, chat.scope);
     else if (command === "stop") await this.sessions.stop(chat, key, chat.scope);
     else if (command === "whoami") await this.whoami(chat, key);
@@ -13643,7 +14288,8 @@ var GroupRouter = class {
         clientPlatform: message.clientPlatform,
         quote: this.withHistory(message, words3.quote),
         sent: words3.sent,
-        files
+        files,
+        typed: true
       });
     }
   }
@@ -13807,262 +14453,22 @@ var LinkCommands = class {
     if (!token.ok && token.error.kind === "not_bound") {
       const notYet = linkText.in(chat.lang());
       const card = await this.ctx.credentials.bindingCard(chat, notYet.notConfirmedYet);
-      await this.ctx.settle(action, chat, card, { fallback: notYet.notConfirmedLine });
-      return;
-    }
-    if (!token.ok) {
-      logger.warn("token exchange failed", { kind: token.error.kind });
-      const text8 = said2.platformUnreachable;
-      const card = this.ctx.views.note(`${text8}${said2.pressConfirmAgain}`, {
-        buttons: [CONFIRM_BUTTON],
-        title: said2.connectTitle({ bot: this.ctx.deps.config.botName })
-      });
-      await this.ctx.settle(action, chat, card, { fallback: text8 });
-      return;
-    }
-    const pending = store.onboarding.takePendingRequest(chat.sender.id);
-    await this.ctx.settle(action, chat, said2.connected + (pending === null ? said2.getStarted : said2.runningFromGroup));
-    if (pending !== null) await this.resume(chat, pending, true);
-  }
-};
-
-// packages/core/src/routing/turn-start.ts
-var MOBILE_PLATFORMS = ["ios", "ipados", "android"];
-function isMobile(clientPlatform) {
-  return MOBILE_PLATFORMS.includes(clientPlatform.toLowerCase());
-}
-var TurnStarter = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  ctx;
-  running = /* @__PURE__ */ new Set();
-  /** The turns that run now (a test waits for them). */
-  settled() {
-    return Promise.all([...this.running]).then(() => void 0);
-  }
-  /** The turn that runs (its end is `done`), or undefined when none was started (the person was told why). */
-  async start(request) {
-    const { chat, review } = request;
-    const key = review ? reviewTurnKey(chat.sender.id, chat.scope, review.itemId, review.pull) : chatTurnKey(chat.sender.id, chat.scope);
-    const turn = new ActiveTurn(review !== void 0, review?.itemId ?? "");
-    const admitted = review === void 0 && await this.admit(request, key, turn);
-    if (admitted === void 0) return void 0;
-    if (!admitted) {
-      const queued = await this.queueBehind(key, turn, chat);
-      if (queued === "refused") return void 0;
-      if (queued === "waiting") return this.track(this.afterFront(request, key, turn));
-    }
-    return this.launch(request, key, turn);
-  }
-  track(task) {
-    this.running.add(task);
-    void task.finally(() => this.running.delete(task));
-    return { done: task };
-  }
-  /** The turn goes to Claw now; its end is `done`. */
-  async launch(request, key, turn) {
-    turn.launched = true;
-    let run;
-    try {
-      run = await this.runOf(request);
-    } catch (error) {
-      this.ctx.turns.drop(key, turn);
-      throw error;
-    }
-    return this.track(this.guarded(request, run, key, turn));
-  }
-  /**
-   * A queued turn: it goes once every turn in front of it is over, or stopped (Claw took its interrupt: Claw is free for the next
-   * message, whether or not that turn ever reports its end); the caller does not wait for it. Not at all when it was given up
-   * meanwhile (`/stop`, said there).
-   */
-  async afterFront(request, key, turn) {
-    for (; ; ) {
-      if (turn.over) return;
-      const turns = this.ctx.turns.of(key);
-      const at = turns.indexOf(turn);
-      if (at < 0) return;
-      const blocking = turns.slice(0, at).find((front) => !front.stopped.isSet);
-      if (blocking === void 0) break;
-      await Promise.race([blocking.ended.whenSet(), blocking.stopped.whenSet(), turn.ended.whenSet()]);
-    }
-    let started;
-    try {
-      started = await this.launch(request, key, turn);
-    } catch (error) {
-      const ref = this.ctx.deps.random.hexId().slice(0, 8);
-      this.ctx.deps.logger.error("a queued turn could not start", { ref, error: errorName(error) });
-      await this.tell(request, `Something went wrong on my side (ref ${ref}). Please try again.`);
-      return;
-    }
-    await started.done;
-  }
-  /** True when admitted as the chat's first turn; false when the chat has one (queue behind it); undefined: refused. */
-  async admit(request, key, turn) {
-    if (this.ctx.turns.has(key)) return false;
-    const { chat } = request;
-    return this.ctx.admission.lock.run(chat.sender.id, async () => {
-      if (this.ctx.turns.has(key)) return false;
-      if (await this.ctx.admission.overLimit(chat, request.messageId, "claw_turn", "", request.credential))
-        return void 0;
-      this.ctx.turns.claim(key, turn);
-      return true;
-    });
-  }
-  /**
-   * Registers `turn` behind the chat's running one: "front" when the chat has none after all (it runs now), "waiting" when it
-   * is queued (the person is told its place), "refused" (and told why) when it may not wait.
-   */
-  async queueBehind(key, turn, chat) {
-    const queued = this.ctx.turns.enqueue(key, turn);
-    const said2 = routingText.in(chat.lang());
-    if (queued === "still_working" || queued === "queue_full") {
-      await chat.say(queued === "still_working" ? said2.stillWorking : said2.queueFull({ n: QUEUED_TURNS_MAX }));
-      return "refused";
-    }
-    if (queued.front === turn) return "front";
-    const stoppedInFront = this.ctx.turns.of(key).every((front) => front === turn || front.stopped.isSet);
-    if (stoppedInFront) return "waiting";
-    try {
-      await chat.say(said2.queuedBehind({ n: queued.waiting }));
-    } catch (error) {
-      this.ctx.turns.drop(key, turn);
-      throw error;
-    }
-    return "waiting";
-  }
-  async sessionOf(request) {
-    const { chat, review } = request;
-    const { store, config } = this.ctx.deps;
-    if (review !== void 0) return review.itemSessionId;
-    const sessionId = store.sessions.getSession(chat.sender.id, chat.scope);
-    if (sessionId === null) return null;
-    if (Boolean(store.sessions.getSessionPlugin(chat.sender.id, chat.scope)) !== Boolean(config.pluginId)) {
-      await chat.say("Starting a new session so I can use the Primus platform tools.");
-      return null;
-    }
-    if (chat.scope && !store.sessions.getSessionShared(chat.sender.id, chat.scope)) return null;
-    return sessionId;
-  }
-  providerOf(request) {
-    const usesExchange = request.review !== void 0 || this.ctx.credentials.onExchange;
-    if (!this.ctx.deps.exchange.enabled || !usesExchange) return void 0;
-    return () => this.ctx.credentials.fresh(request.chat.sender.id, request.credential);
-  }
-  ownThumbs(request) {
-    return isMobile(request.clientPlatform) && request.review === void 0 && this.ctx.deps.config.ownThumbsMobile;
-  }
-  /** What the run reads of the chat's session: its id, the model it has, the repository a new one is bound to. */
-  async sessionPart(request) {
-    const { chat, review } = request;
-    const { store } = this.ctx.deps;
-    const sessionId = await this.sessionOf(request);
-    const chosen = sessionId === null && !chat.scope ? store.repoHistory.getPendingRepo(chat.sender.id) : null;
-    return {
-      sessionId,
-      sessionModel: sessionId === null || review ? "" : store.sessions.getSessionModel(chat.sender.id, chat.scope),
-      repo: chosen === null ? null : { url: `${REPO_HOST}/${chosen.repo}`, branch: chosen.branch }
-    };
-  }
-  async runOf(request) {
-    const { chat, review } = request;
-    const { store, config, logger } = this.ctx.deps;
-    const session = await this.sessionPart(request);
-    const group = chat.scope !== "";
-    logger.info("turn started from Teams client", {
-      platform: request.clientPlatform || "unknown",
-      chat: group ? "group" : "1:1"
-    });
-    return {
-      ...session,
-      conversation: chat.conversation,
-      credential: request.credential,
-      provider: this.providerOf(request),
-      text: request.text,
-      messageId: request.messageId,
-      group,
-      userId: chat.sender.id,
-      ownerName: chat.sender.name,
-      model: review ? review.model || config.reviewModel || config.model : config.model,
-      fallbackModel: config.fallbackModel,
-      showChanges: !group && review === void 0,
-      quote: request.quote ?? "",
-      sent: request.sent ?? "",
-      files: request.files ?? [],
-      lang: review?.lang ?? chat.lang(),
-      ownThumbs: this.ownThumbs(request),
-      notifies: this.ctx.deps.subscriptions !== void 0 && store.notifySubs.getNotifySub(chat.sender.id) !== null,
-      review: review?.fields
-    };
-  }
-  hooks(request, run, turn, turnId) {
-    const { review, chat } = request;
-    const store = this.ctx.deps.store;
-    return {
-      onSession: (sessionId, sessionModel) => {
-        if (review) review.onSession(sessionId);
-        else this.recordSession(chat, sessionId, run, sessionModel);
-      },
-      onRunning: () => {
-        turn.running.set();
-      },
-      onTurn: (sessionId, what, messageId) => {
-        if (what === "started") store.turns.turnStarted(sessionId, { prompt: run.text, messageId, turnId });
-        else if (what === "delivered") store.turns.turnDelivered(sessionId, { messageId, turnId });
-        else store.turns.turnNotDelivered(sessionId, turnId);
-      },
-      stopRequested: () => turn.stopRequested,
-      toolDenied: () => turn.toolDenied,
-      stopConfirmed: () => turn.stopConfirmed,
-      reportView: () => this.ctx.deps.reportView(chat.sender.id, chat.scope)
-    };
-  }
-  async guarded(request, run, key, turn) {
-    const turnId = this.ctx.deps.random.hexId();
-    try {
-      const outcome = await this.ctx.deps.turns.run(run, this.hooks(request, run, turn, turnId));
-      if (request.review) await request.review.after(outcome);
-    } catch (error) {
-      const ref = this.ctx.deps.random.hexId().slice(0, 8);
-      this.ctx.deps.logger.error("turn failed", { ref, error: errorName(error) });
-      await this.tell(request, `Something went wrong on my side (ref ${ref}). Please try again.`);
-    } finally {
-      this.ctx.turns.drop(key, turn);
-    }
-  }
-  async tell(request, text8) {
-    try {
-      await request.chat.say(text8);
-      const report = this.ctx.deps.reportView(request.chat.sender.id, request.chat.scope);
-      if (report !== void 0) await request.chat.send(report);
-    } catch (error) {
-      this.ctx.deps.logger.warn("a failed turn could not be said", { error: errorName(error) });
+      await this.ctx.settle(action, chat, card, { fallback: notYet.notConfirmedLine });
+      return;
     }
-  }
-  /**
-   * The turn has a session: it is the chat's session, and a 1:1 chat remembers it for /sessions, with what a session
-   * this turn created was started with and the repository it is bound to (which uses up the `/repo` choice).
-   */
-  recordSession(chat, sessionId, run, sessionModel) {
-    const { store, config } = this.ctx.deps;
-    const userId = chat.sender.id;
-    store.sessions.setSession(
-      userId,
-      { sessionId, pluginId: config.pluginId, model: sessionModel, shared: chat.scope !== "" },
-      chat.scope
-    );
-    if (chat.scope) return;
-    const created = run.sessionId !== sessionId;
-    if (created && run.sessionId) store.repoHistory.forgetSession(userId, run.sessionId);
-    const url = run.repo?.url ?? "";
-    const bound = created && run.repo ? url.startsWith(`${REPO_HOST}/`) ? url.slice(REPO_HOST.length + 1) : url : "";
-    store.repoHistory.noteSession(userId, sessionId, {
-      title: created ? cpHead(squashSpaces(run.text), 50) : "",
-      repo: bound,
-      branch: bound && run.repo ? run.repo.branch : ""
-    });
-    if (created && run.repo) store.repoHistory.clearPendingRepo(userId);
+    if (!token.ok) {
+      logger.warn("token exchange failed", { kind: token.error.kind });
+      const text8 = said2.platformUnreachable;
+      const card = this.ctx.views.note(`${text8}${said2.pressConfirmAgain}`, {
+        buttons: [CONFIRM_BUTTON],
+        title: said2.connectTitle({ bot: this.ctx.deps.config.botName })
+      });
+      await this.ctx.settle(action, chat, card, { fallback: text8 });
+      return;
+    }
+    const pending = store.onboarding.takePendingRequest(chat.sender.id);
+    await this.ctx.settle(action, chat, said2.connected + (pending === null ? said2.getStarted : said2.runningFromGroup));
+    if (pending !== null) await this.resume(chat, pending, true);
   }
 };
 
@@ -14171,7 +14577,7 @@ var Router = class _Router {
    */
   async withinRate(message, chat) {
     const group = message.conversation.kind === "group";
-    if (group && !message.mentioned || _Router.isStop(message.text, group)) return true;
+    if (group && !message.mentioned || message.choice !== true && _Router.isStop(message.text, group)) return true;
     const { limits, securityEvent, metrics } = this.ctx.deps;
     const verdict = limits.checkMessage(chat.sender.id);
     if (verdict.allowed) return true;
@@ -14228,22 +14634,6 @@ var Router = class _Router {
   }
 };
 
-// packages/core/src/text/plain.ts
-function clip3(text8, limit) {
-  return clipLine(squashSpaces(text8), limit);
-}
-function pyJson(value, options = {}) {
-  return options.compact ? compact(value) : pyJsonDumps(value);
-}
-function compact(value) {
-  if (Array.isArray(value)) return `[${value.map(compact).join(",")}]`;
-  if (value !== null && typeof value === "object") {
-    const entries = Object.entries(value);
-    return `{${entries.map(([k, v]) => `${pyJsonDumps(k)}:${compact(v)}`).join(",")}}`;
-  }
-  return pyJsonDumps(value);
-}
-
 // packages/core/src/approvals/sensitive.ts
 var WORDS = /* @__PURE__ */ new Set([
   "token",
@@ -14510,145 +14900,6 @@ function approvalView(request) {
   };
 }
 
-// packages/core/src/approvals/click.ts
-function viewMessage2(view7, fallbackText = "") {
-  return { body: { type: "view", view: view7, fallbackText } };
-}
-
-// packages/core/src/proactive/quiet.ts
-var APPROVAL_DEFAULT_SECONDS = 600;
-var PERMISSION_DEFAULT_SECONDS = 600;
-var PERMISSION_MAX_SECONDS = 3600;
-var formatters = /* @__PURE__ */ new Map();
-function formatter(zone) {
-  const known = formatters.get(zone);
-  if (known) return known;
-  try {
-    const made = new Intl.DateTimeFormat("en-US", {
-      timeZone: zone,
-      hour: "2-digit",
-      minute: "2-digit",
-      hourCycle: "h23"
-    });
-    formatters.set(zone, made);
-    return made;
-  } catch {
-    return void 0;
-  }
-}
-function zoneOf3(prefs) {
-  return prefs.timezone && formatter(prefs.timezone) ? prefs.timezone : DEFAULT_TIMEZONE;
-}
-function localMinutes(epochSeconds2, zone) {
-  const parts2 = (formatter(zone) ?? formatter(DEFAULT_TIMEZONE))?.formatToParts(new Date(epochSeconds2 * 1e3)) ?? [];
-  const value = (type) => Number(parts2.find((p) => p.type === type)?.value ?? "0");
-  return value("hour") * 60 + value("minute");
-}
-function minutesOf(clock2) {
-  const [hour = "0", minute = "0"] = clock2.split(":");
-  return Number(hour) * 60 + Number(minute);
-}
-function inQuiet(now, zone, start, end) {
-  const minute = localMinutes(now, zone);
-  const s = minutesOf(start);
-  const e = minutesOf(end);
-  if (s === e) return false;
-  return s < e ? s <= minute && minute < e : minute >= s || minute < e;
-}
-function muted(prefs, now) {
-  if (prefs.pausedUntil !== null && now < prefs.pausedUntil) return "paused";
-  if (prefs.quietEnabled && inQuiet(now, zoneOf3(prefs), prefs.quietStart, prefs.quietEnd)) return "quiet";
-  return void 0;
-}
-function isoSeconds2(raw) {
-  if (typeof raw !== "string") return void 0;
-  const match = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,6})?)?(Z|[+-]\d{2}:?\d{2}(?::?\d{2})?)$/.exec(
-    raw.trim()
-  );
-  if (!match) return void 0;
-  const at = Date.parse(raw.trim().replace(" ", "T"));
-  return Number.isNaN(at) ? void 0 : at / 1e3;
-}
-function approvalExpiry(event, now) {
-  const approval = event["approval"];
-  const raw = typeof approval === "object" && approval !== null ? approval["expires_at"] : void 0;
-  return isoSeconds2(raw) ?? now + APPROVAL_DEFAULT_SECONDS;
-}
-function remoteAskExpiry(ask3, now) {
-  const at = isoSeconds2(ask3["expires_at"]);
-  return at === void 0 ? now + PERMISSION_DEFAULT_SECONDS : Math.min(at, now + PERMISSION_MAX_SECONDS);
-}
-
-// packages/core/src/approvals/questions.ts
-import { z as z4 } from "zod";
-var QUESTION_TOOL2 = "ask_user_question";
-var QUESTIONS_MAX = 5;
-var OPTIONS_MAX = 10;
-var QUESTION_MAX = 500;
-var OPTION_MAX = 120;
-var ANSWER_MAX = 1e3;
-function scalarText(value) {
-  if (value === null || value === void 0 || value === false || value === 0 || value === "") return "";
-  if (typeof value === "string") return value;
-  if (typeof value === "number") return String(value);
-  if (value === true) return "True";
-  return "";
-}
-var rawOption = z4.object({ id: z4.unknown(), label: z4.unknown() }).partial();
-var rawQuestion = z4.object({ id: z4.unknown(), question: z4.unknown(), options: z4.unknown(), allow_multiple: z4.unknown() }).partial();
-function optionsOf(raw) {
-  const out = [];
-  for (const item of Array.isArray(raw) ? raw : []) {
-    const option = rawOption.safeParse(item);
-    if (!option.success || typeof item !== "object" || Array.isArray(item)) continue;
-    const id = scalarText(option.data.id);
-    if (!pyStrip(id)) continue;
-    out.push({ id, label: clip3(scalarText(option.data.label) || id, OPTION_MAX) });
-  }
-  return out.slice(0, OPTIONS_MAX);
-}
-function cardQuestions(raw) {
-  const out = [];
-  for (const item of Array.isArray(raw) ? raw : []) {
-    const question = rawQuestion.safeParse(item);
-    if (!question.success || typeof item !== "object" || Array.isArray(item)) continue;
-    const id = scalarText(question.data.id);
-    const text8 = scalarText(question.data.question);
-    if (!pyStrip(id) || !pyStrip(text8)) continue;
-    out.push({
-      id,
-      question: clip3(text8, QUESTION_MAX),
-      options: optionsOf(question.data.options),
-      allowMultiple: question.data.allow_multiple === true
-    });
-  }
-  return out.slice(0, QUESTIONS_MAX);
-}
-function questionWire(question) {
-  return {
-    id: question.id,
-    question: question.question,
-    options: question.options.map((o) => ({ id: o.id, label: o.label })),
-    allow_multiple: question.allowMultiple
-  };
-}
-function answersOf(data) {
-  const answers = /* @__PURE__ */ new Map();
-  const skipped = [];
-  cardQuestions(data["questions"]).forEach((q, i) => {
-    const labels = new Map(q.options.map((o) => [o.id, o.label]));
-    const chosen = scalarText(own(data, `choice_${String(i)}`)).split(",").flatMap((c) => {
-      const label = labels.get(c);
-      return label === void 0 ? [] : [label];
-    });
-    const typed2 = cpHead(pyStrip(scalarText(own(data, `text_${String(i)}`))), ANSWER_MAX);
-    const answer2 = [chosen.join(", "), typed2].filter(Boolean).join(". ");
-    if (answer2) answers.set(q.id, answer2);
-    else skipped.push(q.id);
-  });
-  return { answers, skipped };
-}
-
 // packages/core/src/approvals/decide.ts
 function str(value) {
   return typeof value === "string" ? value : typeof value === "number" ? String(value) : "";
@@ -14951,16 +15202,18 @@ var ApprovalCards = class {
 var TURN_DEADLINE_SECONDS2 = 30 * 60;
 function turnApprovals(store) {
   return {
-    record: (userId, sessionId, toolUseId, tool2, expiresIn, envelope) => store.approvals.saveApproval({
+    record: (userId, sessionId, toolUseId, tool2, expiresIn, envelope, questions) => store.approvals.saveApproval({
       userId,
       sessionId,
       toolUseId,
       tool: tool2,
       expiresAt: store.now() + (expiresIn || TURN_DEADLINE_SECONDS2),
-      envelope
+      envelope,
+      // (a question's, as its card shows them: what a typed answer is matched against)
+      ...questions === void 0 ? {} : { questions: cardQuestions(questions).map((q) => questionWire(q)) }
     }),
-    sent: (sessionId, toolUseId) => {
-      store.approvals.approvalSent(sessionId, toolUseId);
+    sent: (sessionId, toolUseId, cardId) => {
+      store.approvals.approvalSent(sessionId, toolUseId, cardId);
     },
     unsent: (sessionId, toolUseId) => {
       store.approvals.forgetApproval(sessionId, toolUseId);
@@ -14982,7 +15235,15 @@ var approvalTurnCards = {
     return viewMessage2(
       {
         name: "question",
-        model: { questions: cardQuestions(ask3.questions), sessionId, toolUseId, group, ownerName, note: "" }
+        model: {
+          questions: cardQuestions(ask3.questions),
+          sessionId,
+          toolUseId,
+          group,
+          ownerName,
+          note: "",
+          typedReply: true
+        }
       },
       QUESTION_TOOL2
     );
@@ -15338,6 +15599,10 @@ var AssistantChat = class {
   filesOnly(lang) {
     return assistantChatText.in(lang).filesOnly;
   }
+  /** The language the person chose to be answered in, as the message's `channel_context` carries it (none: nothing is sent). */
+  chosenLanguage(userId) {
+    return replyLanguageContext(this.o.store.prefs.getPrefs(userId));
+  }
   langOf(userId, text8) {
     return answerLang(this.o.store.prefs.getPrefs(userId).lang, this.o.clientLocale?.() ?? "", text8);
   }
@@ -15357,10 +15622,11 @@ var AssistantChat = class {
     const handing = { ...request };
     const sent = await this.handTo(handing, async (sessionId, ready) => {
       const folderId = typeof request.context["channel_message_id"] === "string" ? request.context["channel_message_id"] : "";
-      const context2 = request.files.length ? {
+      const context2 = {
         ...request.context,
-        files: await this.handOverFiles(handing, sessionId, folderId || this.o.random.hexId(), request.files)
-      } : request.context;
+        ...request.files.length ? { files: await this.handOverFiles(handing, sessionId, folderId || this.o.random.hexId(), request.files) } : {},
+        ...this.chosenLanguage(request.userId)
+      };
       await ready();
       return this.o.claw.assistant.send(request.credential, sessionId, request.prompt, {
         ...request.modelKey ? { modelKey: request.modelKey } : {},
@@ -15432,7 +15698,7 @@ var AssistantChat = class {
       async (_sessionId, ready) => {
         const files = request.files.length ? { files: await this.handOverFiles(handing, sessionId, this.o.random.hexId(), request.files) } : {};
         const attached = request.attached === void 0 ? {} : { attached: attachedOf(request.attached) };
-        const context2 = { ...files, ...attached };
+        const context2 = { ...files, ...attached, ...this.chosenLanguage(request.userId) };
         await ready();
         return this.o.claw.assistant.send(request.credential, sessionId, request.prompt, {
           ...Object.keys(context2).length ? { context: context2 } : {},
@@ -15933,6 +16199,117 @@ var AssistantActions = class {
   }
 };
 
+// packages/core/src/assistant/choice-clicks.ts
+var CHOICE_VERB = "assistant_choice";
+var CHOICE_INPUT = "choice";
+function pickedOn(card, value) {
+  const places = new Set(
+    pyStr(value).split(",").map((p) => p.trim()).filter((p) => /^\d{1,2}$/.test(p)).map(Number)
+  );
+  return card.options.filter((_, i) => places.has(i));
+}
+function typedMessage(click, text8, id) {
+  const { action } = click;
+  return {
+    type: "message",
+    id,
+    sender: click.sender,
+    conversation: action.conversation,
+    locale: action.locale,
+    clientPlatform: action.clientPlatform,
+    text: text8,
+    mentioned: action.conversation.kind !== "personal",
+    targeted: false,
+    namesBotFirst: false,
+    conversationName: "",
+    mentions: [],
+    links: [],
+    quotes: [],
+    files: [],
+    unreadableFiles: [],
+    provenance: "typed",
+    choice: true
+    // (an option that is a menu word or a help phrase is an answer, never that command)
+  };
+}
+function langOf3(card, click) {
+  if (card?.lang === "zh" || card?.lang === "en") return card.lang;
+  return click.lang();
+}
+var AssistantChoiceClicks = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  verbs = [CHOICE_VERB];
+  /** A 1:1 chat: answered with no Claw key (the message it sends is checked as any typed one is). */
+  async beforeCredential(click) {
+    await this.press(click);
+    return true;
+  }
+  async inGroup(click) {
+    await this.press(click);
+    return true;
+  }
+  async press(click) {
+    const buttons2 = this.deps.store.assistantButtons;
+    const card = buttons2.getChoiceCard(pyStr(click.action.data["card"]));
+    const lang = langOf3(card, click);
+    const t4 = assistantCardText.in(lang);
+    if (card === null || click.conversation.ref.kind === "personal" && card.userId !== click.sender.id) {
+      await finish(click, t4.choiceGone);
+      return;
+    }
+    if (card.state === "done") {
+      await this.sent(click, card, card.chosen, lang, false);
+      return;
+    }
+    if (card.state !== "open") {
+      await click.settle(t4.choiceSending({ answer: card.chosen.join(t4.choiceJoin) }), { announce: false });
+      return;
+    }
+    const chosen = pickedOn(card, click.action.data[CHOICE_INPUT]);
+    if (!chosen.length || !card.multiple && chosen.length > 1) {
+      await this.again(click, card, lang, t4.choiceNone);
+      return;
+    }
+    if (!buttons2.claimChoiceCard(card.cardId, chosen)) {
+      const now = buttons2.getChoiceCard(card.cardId) ?? card;
+      if (now.state === "done") await this.sent(click, now, now.chosen, lang, false);
+      else await click.settle(t4.choiceSending({ answer: now.chosen.join(t4.choiceJoin) }), { announce: false });
+      return;
+    }
+    const text8 = chosen.join(t4.choiceJoin);
+    try {
+      await this.deps.deliver(typedMessage(click, text8, `${CHOICE_VERB}:${card.cardId}`));
+    } catch (error) {
+      buttons2.moveChoiceCard(card.cardId, "open", { onlyFrom: "busy" });
+      this.deps.logger.warn("a choice could not be sent; its card is given back", { error: errorName(error) });
+      await this.again(click, card, lang, t4.choiceFailed);
+      return;
+    }
+    buttons2.moveChoiceCard(card.cardId, "done", { onlyFrom: "busy" });
+    await this.sent(click, card, chosen, lang, true);
+  }
+  /** The card back, open, with `note` under its options. */
+  async again(click, card, lang, note) {
+    const model = { ...this.model(card, lang), note };
+    await click.settle(viewMessage2({ name: "choiceCard", model }), { announce: false });
+  }
+  /** The card replaced by what was picked and sent (said as a line too when `announce`). */
+  async sent(click, card, chosen, lang, announce) {
+    const t4 = assistantCardText.in(lang);
+    const view7 = viewMessage2({ name: "choiceChosen", model: { text: card.text, chosen, lang } });
+    await click.settle(
+      view7,
+      announce ? { fallback: t4.choiceSent({ answer: chosen.join(t4.choiceJoin) }) } : { announce: false }
+    );
+  }
+  model(card, lang) {
+    return { text: card.text, cardId: card.cardId, options: card.options, multiple: card.multiple, note: "", lang };
+  }
+};
+
 // packages/core/src/assistant/auto-reply.ts
 function answersUnasked(watch) {
   return watch["state"] === "active" && watch["reply_allowed"] === true;
@@ -16941,6 +17318,24 @@ function suggestedRepliesOf(event, text8, styleOn, lang) {
   if (replies.length) return replies.slice(0, SUGGESTIONS_MAX);
   return [...ASSISTANT_SUGGESTED_REPLIES[lang ?? pickLang2(text8)]];
 }
+var CHOICE_OPTIONS_MIN = 2;
+var CHOICE_OPTIONS_MAX = 10;
+var CHOICE_OPTION_MAX = 80;
+function choiceOf(event) {
+  const choice = record2(event["choices"]);
+  if (event["type"] !== "assistant.say" || choice === void 0) return void 0;
+  const raw = choice["options"];
+  if (!Array.isArray(raw)) return void 0;
+  const options = [];
+  for (const entry of raw) {
+    if (typeof entry !== "string" || /[\u0000-\u001f\u007f\u2028\u2029]/u.test(entry)) return void 0;
+    const option = pySplit(entry).join(" ");
+    if (!option || cpLength(option) > CHOICE_OPTION_MAX) return void 0;
+    if (!options.includes(option)) options.push(option);
+  }
+  if (options.length < CHOICE_OPTIONS_MIN || options.length > CHOICE_OPTIONS_MAX) return void 0;
+  return { options, multiple: choice["multiple"] === true };
+}
 var REMOTE_KINDS = /* @__PURE__ */ new Set(["done", "needs_you", "error", "resolved"]);
 function resolvedOf(remote) {
   const resolved = record2(remote["resolved"]);
@@ -17077,14 +17472,19 @@ ${text8}`;
     return all.length ? [...said2.slice(0, -1), { ...last, suggestions: toReplies(all.slice(0, SUGGESTIONS_MAX)) }] : said2;
   }
   /**
-   * The card with buttons the event asks for, recorded first: a result that waits, a write Claw holds, or a command put to the
-   * person; undefined for none. `holdsWords`: the card shows the words, which are then not said apart.
+   * The card with buttons the event asks for, recorded first: a result that waits, a write Claw holds, a command or a choice put
+   * to the person; undefined for none. `holdsWords`: the card shows the words, which are then not said apart.
    */
   card(userId, event, item, said2) {
     const inCard = said2.inCard ? said2.text : "";
     if (item?.canAccept)
       return { message: this.workCard(userId, item, said2.text, inCard, said2.lang), holdsWords: said2.inCard };
-    if (item !== null) return void 0;
+    const asked3 = item === null ? this.askCard(userId, event, inCard, said2.lang) : void 0;
+    if (asked3 !== void 0) return { message: asked3, holdsWords: said2.inCard };
+    return this.choiceCard(userId, event, inCard, said2.lang, said2.inCard);
+  }
+  /** A write Claw holds for the person (Allow, Deny) or a command put to them (Run, Cancel), recorded first; undefined for none. */
+  askCard(userId, event, inCard, lang) {
     const held = confirmWriteOf(event);
     if (held !== void 0) {
       const cardId2 = this.deps.store.assistantButtons.addConfirmCard(
@@ -17093,8 +17493,8 @@ ${text8}`;
         held.kind,
         held.allowLabel
       );
-      const model = { text: inCard || held.allowLabel, cardId: cardId2, allowLabel: held.allowLabel, lang: said2.lang };
-      return { message: view3({ name: "confirmWrite", model }), holdsWords: said2.inCard };
+      const model = { text: inCard || held.allowLabel, cardId: cardId2, allowLabel: held.allowLabel, lang };
+      return view3({ name: "confirmWrite", model });
     }
     const confirm = confirmActionOf(event, this.deps.exactCommand);
     if (confirm === void 0) return void 0;
@@ -17105,10 +17505,19 @@ ${text8}`;
       confirm.name,
       confirm.args
     );
-    return {
-      message: view3({ name: "actionCard", model: { text: inCard || command, cardId, command, lang: said2.lang } }),
-      holdsWords: said2.inCard
-    };
+    return view3({ name: "actionCard", model: { text: inCard || command, cardId, command, lang } });
+  }
+  /**
+   * A choice put to the person (`choices`): its options and Send, recorded first (what a press sends is read from the record).
+   * Its Send sends what was picked as the person's own message.
+   */
+  choiceCard(userId, event, inCard, lang, holdsWords) {
+    const choice = choiceOf(event);
+    if (choice === void 0) return void 0;
+    const { options, multiple } = choice;
+    const cardId = this.deps.store.assistantButtons.addChoiceCard(userId, { text: inCard, options, multiple, lang });
+    const model = { text: inCard, cardId, options, multiple, note: "", lang };
+    return { message: view3({ name: "choiceCard", model }, inCard), holdsWords };
   }
   /** What was said, as AI answers with thumbs, each with the citations its own words cite (when the whole text cites at all). */
   said(event, text8, parts2) {
@@ -32555,6 +32964,7 @@ export {
   AssistantActionClicks,
   AssistantActions,
   AssistantChat as AssistantChatService,
+  AssistantChoiceClicks,
   BOARD_CARDS,
   BOARD_LINES,
   BOARD_RETRY_MAX,
@@ -32844,6 +33254,7 @@ export {
   casefold,
   channelActions,
   channelContext,
+  chatCredentialOf,
   chatTurnKey,
   clawText,
   cleanText,
@@ -32947,6 +33358,7 @@ export {
   lastTurns,
   learnLang,
   limitsText,
+  logTurnStarted,
   looksInternal,
   looksLikeFailure,
   looksLikeRepo,
@@ -33147,6 +33559,7 @@ export {
   turnIdOf,
   two,
   typedAnswerText,
+  typedAnswers,
   typedMode,
   unique,
   unreachable,