@primusclaw/personal-agent 0.4.0 → 0.5.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}`
   }
 });
 
@@ -5746,6 +5757,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 +5780,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",
@@ -6949,6 +6963,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 +7043,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 +7242,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 +7276,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 +8048,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 +8090,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 +8477,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 +8633,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));
@@ -8782,9 +8846,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 +9761,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;
@@ -13273,162 +13345,674 @@ 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)
-    });
-    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, 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
     });
   }
-  /** 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);
-    }
+  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);
+  }
+  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"
+  });
+  await settleCard(ctx, chat, pending.cardId, [...answers.answers], pickLang2(reply.text, questions[0]?.question));
+  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(request) {
+    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(),
+      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) });
+    }
+  }
+  /**
+   * 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.
+   */
+  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 });
+    }
+  }
+  /**
+   * 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);
+    }
   }
   /**
    * Beside a question about the person's own GitHub while Claw has no token of theirs: the connect card first; once they
@@ -13493,6 +14077,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,
@@ -13630,439 +14215,200 @@ var GroupRouter = class {
   async withKey(message, chat, key, words3) {
     const command = 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);
-    else {
-      const files = await this.text.attachments(message, chat);
-      if (!words3.sent && !words3.quote && files.length === 0) return;
-      await this.starter.start({
-        chat,
-        credential: key,
-        text: words3.text,
-        messageId: message.id,
-        clientPlatform: message.clientPlatform,
-        quote: this.withHistory(message, words3.quote),
-        sent: words3.sent,
-        files
-      });
-    }
-  }
-  /** The chat's recent messages, as untrusted background, before what the person quoted (either may be ""). */
-  withHistory(message, quote) {
-    const history = this.ctx.deps.groupHistory.background(message.conversation.id);
-    return history && quote ? `${history}
-
-${quote}` : history || quote;
-  }
-  /** Which account, in a group: never the sender's email. */
-  async whoami(chat, key) {
-    const said2 = groupText.in(chat.lang());
-    const who = await this.ctx.owners.whoLine(key, false);
-    if (chat.zh()) {
-      const name = who === void 0 ? "" : (await this.ctx.owners.whoami(key))?.[0] ?? "";
-      await chat.say(name ? said2.whoami({ name: chat.sender.name, who: name }) : said2.whoamiUnknown);
-      return;
-    }
-    await chat.say(who === void 0 ? said2.whoamiUnknown : said2.whoami({ name: chat.sender.name, who }));
-  }
-  /**
-   * "停 825", from a person the assistant understands: their reviews of those pull requests are stopped in Claw at once
-   * (not said to the assistant, where it could wait while the merge happens). Placed by the assembly among the group's
-   * interceptors (after feedback, before review requests).
-   */
-  reviewStopInterceptor() {
-    return {
-      name: "review_stop",
-      intercept: async (route) => {
-        const { assistant, reviewStop: reviewStop2 } = this.ctx.deps;
-        if (reviewStop2 === void 0 || !assistant.understands(route.sender.id)) return false;
-        const pulls = reviewStop2(route.text);
-        if (pulls.length === 0) return false;
-        await this.stopReviews(this.ctx.chatOf(route.message, route.scope), pulls, route.text);
-        return true;
-      }
-    };
-  }
-  async stopReviews(chat, pulls, text8) {
-    const zh = hasCjk2(text8);
-    const said2 = groupText.in(zh ? "zh" : "en");
-    const key = await this.ctx.credentials.credential(chat, false);
-    let items;
-    try {
-      items = key === void 0 ? void 0 : await this.ctx.deps.claw.workItems.list(key, "in_progress");
-    } catch {
-      items = void 0;
-    }
-    if (key === void 0 || items === void 0) {
-      await chat.say(said2.stopUnreachable);
-      return;
-    }
-    const lines = [];
-    for (const [slug2, number] of pulls) {
-      const found = items.filter(
-        (i) => i.kind === "review" && i.pull !== null && i.pull.number === number && (slug2 === "" || slug2 === pyLower(`${i.pull.owner}/${i.pull.repo}`))
-      );
-      const [only2] = found;
-      if (only2 === void 0) lines.push(said2.stopNone({ number }));
-      else if (found.length > 1) lines.push(said2.stopMany({ number }));
-      else lines.push(await this.stopReview(key, only2, zh));
-    }
-    await chat.say(lines.join("\n"));
-  }
-  async stopReview(key, item, zh) {
-    const pull2 = item.pull ?? { owner: "", repo: "", number: 0 };
-    const short = `${pull2.owner}/${pull2.repo}#${String(pull2.number)}`;
-    let error;
-    try {
-      const decision = await this.ctx.deps.claw.workItems.stop(key, item.itemId);
-      error = decision.ok ? "" : decision.error;
-      if (decision.ok) this.ctx.itemStopped(item.itemId);
-    } catch (failure) {
-      if (failure instanceof ClawUnreachable)
-        return zh ? `${short}\uFF1A\u6CA1\u8FDE\u4E0A PrimusClaw\uFF0C\u8BF7\u518D\u8BF4\u4E00\u6B21\u3002` : `${short}: PrimusClaw did not answer; please say it again.`;
-      if (!(failure instanceof ClawError)) throw failure;
-      error = failure.status === 409 && isErrorWord(failure.code) ? failure.code : `error ${String(failure.status)}`;
-    }
-    const said2 = (Object.hasOwn(STOP_SAID, error) ? STOP_SAID[error] : void 0) ?? [
-      `\u6CA1\u80FD\u505C\u4E0B\uFF08${error}\uFF09\u3002`,
-      `it could not be stopped (${error}).`
-    ];
-    return zh ? `${short}\uFF1A${said2[0]}` : `${short}: ${said2[1]}`;
-  }
-};
-
-// packages/core/src/routing/link-commands.ts
-var LinkCommands = class {
-  constructor(ctx, resume2) {
-    this.ctx = ctx;
-    this.resume = resume2;
-  }
-  ctx;
-  resume;
-  async link(chat, code3, messageId) {
-    const { store } = this.ctx.deps;
-    const outcome = store.links.redeemPending(chat.sender.id, chat.sender.name, code3 ?? "", messageId || void 0);
-    const said2 = linkText.in("en");
-    if (outcome === "ok") await this.linked(chat);
-    else if (outcome === "limited") {
-      const minutes = Math.max(1, Math.ceil(store.links.linkWindowSeconds / 60));
-      await chat.say(said2.tooManyWrong({ minutes }));
-    } else if (outcome === "global_limit") await chat.say(said2.linkingPaused);
-    else await chat.say(said2.badCode);
-  }
-  async linked(chat) {
-    const { store, subscriptions } = this.ctx.deps;
-    const userId = chat.sender.id;
-    const key = store.links.getKey(userId) ?? "";
-    const clawUserId = key ? await this.ctx.owners.userIdOf(key) : void 0;
-    if (clawUserId !== void 0) store.links.setClawUserId(userId, clawUserId);
-    if (subscriptions !== void 0) await subscriptions.ensure(userId);
-    const pending = store.onboarding.takePendingRequest(userId);
-    const zh = chat.zh();
-    const said2 = linkText.in(zh ? "zh" : "en");
-    let who;
-    if (zh) {
-      const owner = key ? await this.ctx.owners.whoami(key) : void 0;
-      who = owner === void 0 ? "" : `\u5230 SaFE \u7528\u6237 ${owner[0]}` + (owner[1] ? `\uFF08${owner[1]}\uFF09` : "");
-    } else {
-      who = await this.ctx.owners.whoLine(key) ?? "";
-    }
-    await chat.say(said2.linkedAs({ who }) + (pending === null ? said2.getStarted : said2.runningFromGroup));
-    if (pending !== null) await this.resume(chat, pending, true);
-  }
-  async unlink(chat) {
-    const { store, remote, assistant, subscriptions, keyRevoker } = this.ctx.deps;
-    const userId = chat.sender.id;
-    remote.forgetPerson(userId);
-    assistant.forget(userId);
-    const stored2 = store.links.getKey(userId);
-    if (stored2 === null) {
-      store.sessions.clearSession(userId);
-      await chat.say(unlinkText.in(chat.lang()).bindingOnly);
-      return;
-    }
-    if (subscriptions !== void 0) await subscriptions.remove(userId, stored2);
-    const revoked = await keyRevoker.revoke(stored2);
-    store.links.unlink(userId);
-    const stillBound = await this.stillBound(userId);
-    const said2 = unlinkText.in(chat.lang());
-    const tail = (revoked ? said2.deleted : said2.notDeleted) + (stillBound ? said2.stillBound : "");
-    await chat.say(said2.unlinked({ tail }));
-  }
-  /** A chat that runs on the exchange stays connected through the person's binding, which only they can remove. */
-  async stillBound(userId) {
-    if (!this.ctx.credentials.onExchange) return false;
-    this.ctx.deps.exchange.invalidate(userId);
-    return (await this.ctx.deps.exchange.tokenFor(userId)).ok;
-  }
-  /**
-   * The person pressed the button that says they confirmed: the binding is looked for now. The worker cannot make it,
-   * only the person can; not there yet, the card comes back with the link that is still open (or a new one).
-   */
-  async confirmBinding(action, chat) {
-    const { exchange, store, logger } = this.ctx.deps;
-    const said2 = linkText.in("en");
-    exchange.invalidate(chat.sender.id);
-    const token = await exchange.tokenFor(chat.sender.id);
-    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));
+    else if (command === "stop") await this.sessions.stop(chat, key, chat.scope);
+    else if (command === "whoami") await this.whoami(chat, key);
+    else {
+      const files = await this.text.attachments(message, chat);
+      if (!words3.sent && !words3.quote && files.length === 0) return;
+      await this.starter.start({
+        chat,
+        credential: key,
+        text: words3.text,
+        messageId: message.id,
+        clientPlatform: message.clientPlatform,
+        quote: this.withHistory(message, words3.quote),
+        sent: words3.sent,
+        files,
+        typed: true
+      });
     }
-    return this.launch(request, key, turn);
   }
-  track(task) {
-    this.running.add(task);
-    void task.finally(() => this.running.delete(task));
-    return { done: task };
+  /** The chat's recent messages, as untrusted background, before what the person quoted (either may be ""). */
+  withHistory(message, quote) {
+    const history = this.ctx.deps.groupHistory.background(message.conversation.id);
+    return history && quote ? `${history}
+
+${quote}` : history || quote;
   }
-  /** 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;
+  /** Which account, in a group: never the sender's email. */
+  async whoami(chat, key) {
+    const said2 = groupText.in(chat.lang());
+    const who = await this.ctx.owners.whoLine(key, false);
+    if (chat.zh()) {
+      const name = who === void 0 ? "" : (await this.ctx.owners.whoami(key))?.[0] ?? "";
+      await chat.say(name ? said2.whoami({ name: chat.sender.name, who: name }) : said2.whoamiUnknown);
+      return;
     }
-    return this.track(this.guarded(request, run, key, turn));
+    await chat.say(who === void 0 ? said2.whoamiUnknown : said2.whoami({ name: chat.sender.name, who }));
   }
   /**
-   * 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).
+   * "停 825", from a person the assistant understands: their reviews of those pull requests are stopped in Claw at once
+   * (not said to the assistant, where it could wait while the merge happens). Placed by the assembly among the group's
+   * interceptors (after feedback, before review requests).
    */
-  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;
+  reviewStopInterceptor() {
+    return {
+      name: "review_stop",
+      intercept: async (route) => {
+        const { assistant, reviewStop: reviewStop2 } = this.ctx.deps;
+        if (reviewStop2 === void 0 || !assistant.understands(route.sender.id)) return false;
+        const pulls = reviewStop2(route.text);
+        if (pulls.length === 0) return false;
+        await this.stopReviews(this.ctx.chatOf(route.message, route.scope), pulls, route.text);
+        return true;
+      }
+    };
+  }
+  async stopReviews(chat, pulls, text8) {
+    const zh = hasCjk2(text8);
+    const said2 = groupText.in(zh ? "zh" : "en");
+    const key = await this.ctx.credentials.credential(chat, false);
+    let items;
     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;
+      items = key === void 0 ? void 0 : await this.ctx.deps.claw.workItems.list(key, "in_progress");
+    } catch {
+      items = void 0;
     }
-    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 (key === void 0 || items === void 0) {
+      await chat.say(said2.stopUnreachable);
+      return;
     }
-    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;
+    const lines = [];
+    for (const [slug2, number] of pulls) {
+      const found = items.filter(
+        (i) => i.kind === "review" && i.pull !== null && i.pull.number === number && (slug2 === "" || slug2 === pyLower(`${i.pull.owner}/${i.pull.repo}`))
+      );
+      const [only2] = found;
+      if (only2 === void 0) lines.push(said2.stopNone({ number }));
+      else if (found.length > 1) lines.push(said2.stopMany({ number }));
+      else lines.push(await this.stopReview(key, only2, zh));
     }
-    return "waiting";
+    await chat.say(lines.join("\n"));
   }
-  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;
+  async stopReview(key, item, zh) {
+    const pull2 = item.pull ?? { owner: "", repo: "", number: 0 };
+    const short = `${pull2.owner}/${pull2.repo}#${String(pull2.number)}`;
+    let error;
+    try {
+      const decision = await this.ctx.deps.claw.workItems.stop(key, item.itemId);
+      error = decision.ok ? "" : decision.error;
+      if (decision.ok) this.ctx.itemStopped(item.itemId);
+    } catch (failure) {
+      if (failure instanceof ClawUnreachable)
+        return zh ? `${short}\uFF1A\u6CA1\u8FDE\u4E0A PrimusClaw\uFF0C\u8BF7\u518D\u8BF4\u4E00\u6B21\u3002` : `${short}: PrimusClaw did not answer; please say it again.`;
+      if (!(failure instanceof ClawError)) throw failure;
+      error = failure.status === 409 && isErrorWord(failure.code) ? failure.code : `error ${String(failure.status)}`;
     }
-    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);
+    const said2 = (Object.hasOwn(STOP_SAID, error) ? STOP_SAID[error] : void 0) ?? [
+      `\u6CA1\u80FD\u505C\u4E0B\uFF08${error}\uFF09\u3002`,
+      `it could not be stopped (${error}).`
+    ];
+    return zh ? `${short}\uFF1A${said2[0]}` : `${short}: ${said2[1]}`;
   }
-  ownThumbs(request) {
-    return isMobile(request.clientPlatform) && request.review === void 0 && this.ctx.deps.config.ownThumbsMobile;
+};
+
+// packages/core/src/routing/link-commands.ts
+var LinkCommands = class {
+  constructor(ctx, resume2) {
+    this.ctx = ctx;
+    this.resume = resume2;
   }
-  /** 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;
+  ctx;
+  resume;
+  async link(chat, code3, messageId) {
     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);
+    const outcome = store.links.redeemPending(chat.sender.id, chat.sender.name, code3 ?? "", messageId || void 0);
+    const said2 = linkText.in("en");
+    if (outcome === "ok") await this.linked(chat);
+    else if (outcome === "limited") {
+      const minutes = Math.max(1, Math.ceil(store.links.linkWindowSeconds / 60));
+      await chat.say(said2.tooManyWrong({ minutes }));
+    } else if (outcome === "global_limit") await chat.say(said2.linkingPaused);
+    else await chat.say(said2.badCode);
+  }
+  async linked(chat) {
+    const { store, subscriptions } = this.ctx.deps;
+    const userId = chat.sender.id;
+    const key = store.links.getKey(userId) ?? "";
+    const clawUserId = key ? await this.ctx.owners.userIdOf(key) : void 0;
+    if (clawUserId !== void 0) store.links.setClawUserId(userId, clawUserId);
+    if (subscriptions !== void 0) await subscriptions.ensure(userId);
+    const pending = store.onboarding.takePendingRequest(userId);
+    const zh = chat.zh();
+    const said2 = linkText.in(zh ? "zh" : "en");
+    let who;
+    if (zh) {
+      const owner = key ? await this.ctx.owners.whoami(key) : void 0;
+      who = owner === void 0 ? "" : `\u5230 SaFE \u7528\u6237 ${owner[0]}` + (owner[1] ? `\uFF08${owner[1]}\uFF09` : "");
+    } else {
+      who = await this.ctx.owners.whoLine(key) ?? "";
     }
+    await chat.say(said2.linkedAs({ who }) + (pending === null ? said2.getStarted : said2.runningFromGroup));
+    if (pending !== null) await this.resume(chat, pending, true);
   }
-  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) });
+  async unlink(chat) {
+    const { store, remote, assistant, subscriptions, keyRevoker } = this.ctx.deps;
+    const userId = chat.sender.id;
+    remote.forgetPerson(userId);
+    assistant.forget(userId);
+    const stored2 = store.links.getKey(userId);
+    if (stored2 === null) {
+      store.sessions.clearSession(userId);
+      await chat.say(unlinkText.in(chat.lang()).bindingOnly);
+      return;
     }
+    if (subscriptions !== void 0) await subscriptions.remove(userId, stored2);
+    const revoked = await keyRevoker.revoke(stored2);
+    store.links.unlink(userId);
+    const stillBound = await this.stillBound(userId);
+    const said2 = unlinkText.in(chat.lang());
+    const tail = (revoked ? said2.deleted : said2.notDeleted) + (stillBound ? said2.stillBound : "");
+    await chat.say(said2.unlinked({ tail }));
+  }
+  /** A chat that runs on the exchange stays connected through the person's binding, which only they can remove. */
+  async stillBound(userId) {
+    if (!this.ctx.credentials.onExchange) return false;
+    this.ctx.deps.exchange.invalidate(userId);
+    return (await this.ctx.deps.exchange.tokenFor(userId)).ok;
   }
   /**
-   * 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).
+   * The person pressed the button that says they confirmed: the binding is looked for now. The worker cannot make it,
+   * only the person can; not there yet, the card comes back with the link that is still open (or a new one).
    */
-  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);
+  async confirmBinding(action, chat) {
+    const { exchange, store, logger } = this.ctx.deps;
+    const said2 = linkText.in("en");
+    exchange.invalidate(chat.sender.id);
+    const token = await exchange.tokenFor(chat.sender.id);
+    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);
   }
 };
 
@@ -14228,22 +14574,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 +14840,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 +15142,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 +15175,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
     );
@@ -32844,6 +33045,7 @@ export {
   casefold,
   channelActions,
   channelContext,
+  chatCredentialOf,
   chatTurnKey,
   clawText,
   cleanText,
@@ -32947,6 +33149,7 @@ export {
   lastTurns,
   learnLang,
   limitsText,
+  logTurnStarted,
   looksInternal,
   looksLikeFailure,
   looksLikeRepo,
@@ -33147,6 +33350,7 @@ export {
   turnIdOf,
   two,
   typedAnswerText,
+  typedAnswers,
   typedMode,
   unique,
   unreachable,