@cabane/companion 0.6.202 → 0.6.203

package/dist/cli.js

@@ -1395,6 +1395,18 @@ var init_boot_id = __esm({
 function activeRunOutboxKey(conversationId, agentId) {
   return `activerun:${conversationId}:${agentId}`;
 }
+function isAlreadyPublished(err) {
+  return err instanceof ApiError && err.status === 409 && apiErrorCode(err) === "already_published";
+}
+function trailOf(body) {
+  const b = body;
+  return {
+    turnId: b.turnId,
+    text: b.body,
+    ...b.seq !== void 0 ? { seq: b.seq } : {},
+    ...b.executionSourceId !== void 0 ? { executionSourceId: b.executionSourceId } : {}
+  };
+}
 function isRetryable(err) {
   if (err instanceof ApiError) return err.status >= 500;
   if (isAbortError(err)) return false;
@@ -1522,7 +1534,7 @@ var init_api = __esm({
       //     text use (turnId, seq) within each kind for nonzero seq; tool activity
       //     uses (turnId, toolUseId). Legacy zero/missing seq bypasses row deduplication.
       //     Server fences and the outbox's discard/eviction bounds still apply.
-      async durableCommit(kind, path, body, turnId, seq, signal) {
+      async durableCommit(kind, path, body, turnId, seq, signal, trailPath) {
         try {
           await this.request("POST", path, body, {
             retry: true,
@@ -1533,7 +1545,16 @@ var init_api = __esm({
           if (!outbox) throw err;
           if (signal?.aborted || isAbortError(err)) throw err;
           if (!isRetryable(err)) throw err;
-          outbox.persist({ enqueuedAt: Date.now(), turnId, seq, method: "POST", path, body, kind });
+          outbox.persist({
+            enqueuedAt: Date.now(),
+            turnId,
+            seq,
+            method: "POST",
+            path,
+            body,
+            kind,
+            ...trailPath ? { trailPath } : {}
+          });
           this.opts.log?.debug(
             { kind, turnId, seq, err: err instanceof Error ? err.message : String(err) },
             "companion: commit queued to outbox after transient failure (will drain when the API returns)"
@@ -1558,6 +1579,29 @@ var init_api = __esm({
               progressed = true;
             } catch (err) {
               if (err instanceof ApiError && err.status >= 400 && err.status < 500) {
+                if (entry.kind === "message" && entry.trailPath && isAlreadyPublished(err)) {
+                  try {
+                    await this.request("POST", entry.trailPath, trailOf(entry.body), {
+                      retry: true
+                    });
+                  } catch (trailErr) {
+                    if (!(trailErr instanceof ApiError && trailErr.status >= 400 && trailErr.status < 500)) {
+                      break;
+                    }
+                    this.opts.log?.warn(
+                      {
+                        kind: entry.kind,
+                        turnId: entry.turnId,
+                        seq: entry.seq,
+                        ...apiErrorLogFields(trailErr)
+                      },
+                      `Cabane rejected a postscript; it could not be filed. ${mayNeedUpdate()}`
+                    );
+                  }
+                  outbox.remove(entry.turnId, entry.seq);
+                  progressed = true;
+                  continue;
+                }
                 if (entry.kind === "active-run" && isTurnEndedRefusal(err)) {
                   this.opts.log?.debug(
                     { kind: entry.kind, turnId: entry.turnId, ...apiErrorLogFields(err) },
@@ -1633,6 +1677,19 @@ var init_api = __esm({
           (e) => e.turnId === turnId && e.kind === "message" && e.body?.kind !== "runtime_notice"
         );
       }
+      // The `seq` of this turn's SELECTED ANSWER still waiting in the outbox — the
+      // `declared` commit the server's `answerArmed` cannot see — or null when none
+      // is queued. A resumed run that re-armed over it would let a newer text
+      // consume the arm first; with the selection queued, the resumed run starts
+      // declared, its texts are trail, and the drain delivers the selection.
+      outboxDeclaredSeqForTurn(turnId) {
+        const outbox = this.opts.outbox;
+        if (!outbox) return null;
+        const queued = outbox.list().find(
+          (e) => e.turnId === turnId && e.kind === "message" && e.body?.declared === true
+        );
+        return queued ? queued.seq : null;
+      }
       // ADOPT a turn context's issuance as the execution source of its work, once,
       // before preparation emits or queues anything, so every row can name a source
       // the server durably recorded and will never reap. Adoption is idempotent, so
@@ -1806,15 +1863,36 @@ var init_api = __esm({
       // seq also orders speech against the turn's tool/thinking/text trail.
       // Transport/5xx failures get bounded retries and optional outbox delivery;
       // terminal 4xx and cancellation stop delivery rather than proving no commit.
-      postTurnMessage(workspaceId, conversationId, body, signal) {
-        return this.durableCommit(
-          "message",
-          `/api/workspaces/${workspaceId}/conversations/${conversationId}/messages`,
-          body,
-          body.turnId,
-          body.seq ?? 0,
-          signal
-        );
+      //
+      // A turn's answer can be out before a later speech commit arrives — the
+      // declaration published it, or another host's selection drained first — and
+      // the server refuses the commit `409 already_published`. The text is a
+      // postscript then: with `trail` (the committing agent, which names the text
+      // route), it is filed as trail at the same seq, live here and from the outbox
+      // on a drain. Without `trail` (a runtime notice) the refusal is terminal.
+      async postTurnMessage(workspaceId, conversationId, body, signal, trail) {
+        const trailPath = trail ? `/api/workspaces/${workspaceId}/conversations/${conversationId}/participants/agents/${trail.agentId}/text` : void 0;
+        try {
+          await this.durableCommit(
+            "message",
+            `/api/workspaces/${workspaceId}/conversations/${conversationId}/messages`,
+            body,
+            body.turnId,
+            body.seq ?? 0,
+            signal,
+            trailPath
+          );
+        } catch (err) {
+          if (!trailPath || !isAlreadyPublished(err)) throw err;
+          await this.durableCommit(
+            "text",
+            trailPath,
+            trailOf(body),
+            body.turnId,
+            body.seq ?? 0,
+            signal
+          );
+        }
       }
       // Report a tool transition (start/done/error). The server checks span
       // ownership, upserts by (turnId, toolUseId), and publishes agent_activity SSE.
@@ -2017,6 +2095,8 @@ var init_turn_diagnostics = __esm({
     turnSessionModes = ["fresh", "resumed", "degraded"];
     turnRuntimeResultKinds = ["success", "error", "no_terminal"];
     turnFinalSources = [
+      // The agent declared its answer with the `answer` turn act (CT1973).
+      "declared",
       "runtime_text",
       "progress_promotion",
       "host_fallback",
@@ -2495,39 +2575,145 @@ var init_transcript_sink = __esm({
   }
 });
 
+// packages/agent-runtime/src/turn-control/descriptions.ts
+var MAX_ASK_QUESTION_BYTES, MAX_ASK_HEADLINE_BYTES, MAX_ASK_ITEMS, MAX_ASK_OPTION_BYTES, ASK_OPTION_NOT_A_STRING, MIN_ASK_OPTIONS, MAX_ASK_OPTIONS, ASK_TARGET_PATTERN, ASK_TARGET_INVALID, MAX_WAKE_NOTE_BYTES, MAX_WITHDRAW_REASON_BYTES, MAX_SKIP_REASON_BYTES, TURN_CONTROL_MCP_SERVER, TURN_CONTROL_TOOLS, TURN_CONTROL_TOOL_DESCRIPTIONS, TURN_CONTROL_FIELD_DESCRIPTIONS;
+var init_descriptions = __esm({
+  "packages/agent-runtime/src/turn-control/descriptions.ts"() {
+    "use strict";
+    MAX_ASK_QUESTION_BYTES = 400;
+    MAX_ASK_HEADLINE_BYTES = 120;
+    MAX_ASK_ITEMS = 20;
+    MAX_ASK_OPTION_BYTES = 200;
+    ASK_OPTION_NOT_A_STRING = "An ask option is a plain string label.";
+    MIN_ASK_OPTIONS = 2;
+    MAX_ASK_OPTIONS = 4;
+    ASK_TARGET_PATTERN = /^(?:[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}|@?[A-Za-z0-9-]{2,32})$/;
+    ASK_TARGET_INVALID = "An ask target is a user id or an @handle.";
+    MAX_WAKE_NOTE_BYTES = 2e3;
+    MAX_WITHDRAW_REASON_BYTES = 400;
+    MAX_SKIP_REASON_BYTES = 500;
+    TURN_CONTROL_MCP_SERVER = "cabane_companion";
+    TURN_CONTROL_TOOLS = [
+      "answer",
+      "ask",
+      "cancel_wake",
+      "skip_turn",
+      "wake_me",
+      "withdraw_ask"
+    ];
+    TURN_CONTROL_TOOL_DESCRIPTIONS = {
+      answer: `Call this just before you write your answer: the text you write next is what the conversation keeps as your message. Call it once.`,
+      ask: `Ask a person a structured question you need answered to continue, then end your turn; don't wait for the reply. \`targetUserId\` is a person on your roster, by their \`@handle\`; to bring in an agent, name them with \`@handle\` in your reply.
+- Form: one question (\`headline\`, optional \`question\` body, \`options\`) or \`questions\`, 1\u2013${MAX_ASK_ITEMS} \`{ headline, body?, options? }\`; never both. Decisions that arise together go in ONE call, in the order you want them answered. A second \`ask\` is a separate item, never an edit; raise one only for a genuinely new question.
+- \`headline\`: one sentence ending in \`?\`. Body (\`question\` or each item's \`body\`): a sentence or two of framing, not a report; inline Markdown only, no lists or headings. \`options\`: ${MIN_ASK_OPTIONS}\u2013${MAX_ASK_OPTIONS} one-click answers (always for a yes/no go-ahead), each a distinct course of action you can carry out without asking back.
+- Voice, in headline, body and options: "I" for yourself, never your own name; name everyone else who decides or acts, as on your roster. Never "you", "your", "we", "us", "our" or their contractions, nor "he", "she" or "they" for a named actor. Each option reads correctly alone. A quotation stays accurate: say who said it.
+- It must stand alone, since it can arrive first: the reply carries the findings, the ask the question; don't repeat the reply in it.
+- Recorded when you call this; delivered when your turn ends, or after 3 minutes if it is still running. Ask as soon as you know. The answer reaches you on a later turn.
+- The person sends one response; unanswered questions end as Unanswered. A person can dismiss an ask; you aren't told and nothing wakes you. Check an ask's status before raising it again.
+- To replace a stale ask (yours or anyone's here), pass \`replaces: { askId, reason }\`: both land in one write and the person sees the reason. To withdraw without a replacement, use \`withdraw_ask\`.`,
+      cancel_wake: `Stand down the wake you have armed in this conversation, now, when you call it. No arguments. Use it when what the wake was to check has already happened or the work it watched is over; an unneeded wake fires into a turn with nothing to do. Your turn context prints the armed wake ("Wake armed: \u2026"); one no longer printed has fired or been dismissed. Nothing armed is a clean no-op. Calls act in order: \`cancel_wake\` then \`wake_me\` leaves the new wake armed. It reaches only your own wake here, never a peer's and never a recurring schedule (\`schedules.*\`).`,
+      skip_turn: `End your current turn WITHOUT posting a reply. Call this when you've been woken to read a message that genuinely doesn't need a response from you \u2014 a thanks/aside, a question already answered, chatter outside your lane, or something another participant clearly owns. Your turn ends silently: no message bubble is posted. The \`reason\` is a short free-text note for telemetry (e.g. "already answered by cabane", "thanks, nothing to add"). Prefer this over posting a low-value "ok!"/"got it" reply. Don't also write a reply when you skip \u2014 skipping IS the whole turn.`,
+      wake_me: `Wake yourself later: end this turn now and be re-dispatched at a time you pick, with a note to yourself. Use it to wait for a condition you can name (a PR merging, a session limit resetting, an answer landing): arm, end the turn, and you're woken to CHECK and either act or re-arm. Most wakes are short, seconds to a couple of hours. Reach past a few hours only when a person asked for that timing or the wait is pinned to a real external event (a report that runs Mondays); if no one asked and you can't name both what clears the wait and why it takes that long, don't arm it: finish now, or raise an \`ask\`. Pass EXACTLY ONE of \`afterSeconds\` (\`300\` for five minutes) or \`at\` (an ISO-8601 timestamp WITH a zone, e.g. \`2026-07-16T09:00:00-07:00\`, which YOU compute; nothing parses natural-language time). \`note\` becomes the body of the message that re-dispatches you: write the condition to re-check. The wake arms NOW, when you call this; a later \`wake_me\` in the same turn replaces it, \`cancel_wake\` stands it down, and one that comes due mid-turn is delivered after your reply. This is the ONLY way to schedule your own continuation; never a host cron or scheduler. Floor 60s, horizon 14 days, enforced here so you can recompute. Widen the interval as a loop ages (5m \u2192 15m \u2192 1h\u2026); after many re-arms with no other activity you'll be steered to an \`ask\` instead.`,
+      withdraw_ask: `Withdraw an open ask \u2014 yours or anyone's in this conversation \u2014 because the question is moot, was wrong, or has been overtaken. \`reason\` is required and is shown to the person and, if it wasn't your ask, to the agent who asked it. If there is a current question to put in its place, don't call this \u2014 call \`ask\` with \`replaces\` so the two land as one and the person never sees neither or both. Never withdraw to hurry an answer; to act on a deadline, arm a \`wake_me\` and decide then.`
+    };
+    TURN_CONTROL_FIELD_DESCRIPTIONS = {
+      answer: {},
+      ask: {
+        targetUserId: "The person to ask: their `@handle` from your turn context's roster (preferred), or their user id.",
+        question: `SINGLE-question form: a short body \u2014 one or two sentences of framing the headline can't hold. NOT a report (up to ${MAX_ASK_QUESTION_BYTES} characters, inline markdown only). Provide EITHER this or \`questions\`, not both. Put the crisp one-sentence question in \`headline\`.`,
+        headline: `SINGLE-question form: the question itself as ONE clear, capitalized sentence ending in \`?\` ("Should Ledger deploy once Mia approves?"), up to ${MAX_ASK_HEADLINE_BYTES} characters. What the person reads first in For you and on the chip \u2014 one scannable question, no elaboration (that goes in \`question\`). Strongly encouraged.`,
+        options: `SINGLE-question form: optional ${MIN_ASK_OPTIONS}\u2013${MAX_ASK_OPTIONS} suggested one-click answers, up to ${MAX_ASK_OPTION_BYTES} characters each. Each option must make sense on its own.`,
+        questions: `MULTI-question form: 1\u2013${MAX_ASK_ITEMS} questions to ask at once, when a plan ends with several bounded decisions. Provide EITHER this or \`question\`/\`headline\`/\`options\`, not both.`,
+        "questions.headline": `The one-sentence question ("Should Ledger deploy once Mia approves?") \u2014 required for each item, up to ${MAX_ASK_HEADLINE_BYTES} characters.`,
+        "questions.body": `Optional short framing beneath the headline, up to ${MAX_ASK_QUESTION_BYTES} characters, inline markdown only. NOT a report.`,
+        "questions.options": `Optional ${MIN_ASK_OPTIONS}\u2013${MAX_ASK_OPTIONS} one-click answers for this question, up to ${MAX_ASK_OPTION_BYTES} characters each. Each option must make sense on its own.`,
+        replaces: "Withdraw a stale ask in this conversation as part of raising this one. Both land in a single write, so the person goes from the old question to the new one and never sees neither or both.",
+        "replaces.askId": "The id of the open ask to withdraw.",
+        "replaces.reason": `Why the old question is no longer the question \u2014 shown to the person on their Done row. Up to ${MAX_WITHDRAW_REASON_BYTES} characters.`
+      },
+      cancel_wake: {},
+      skip_turn: {
+        reason: `Short reason you are declining \u2014 used for telemetry/debugging, never posted. Up to ${MAX_SKIP_REASON_BYTES} characters.`
+      },
+      wake_me: {
+        afterSeconds: "Relative delay in seconds from NOW \u2014 this call (e.g. 300 = five minutes). Provide EITHER this or `at`, not both. Floor 60s, horizon 14 days \u2014 enforced server-side.",
+        at: "Absolute ISO-8601 timestamp WITH a zone (`Z` or `\xB1HH:MM`), e.g. `2026-07-16T09:00:00-07:00`. YOU compute it from a natural-language phrase using the current datetime in your turn context. Provide EITHER this or `afterSeconds`, not both.",
+        note: `A note to your future self \u2014 becomes the body of the wake message that re-dispatches you, up to ${MAX_WAKE_NOTE_BYTES} characters. Write the condition to re-check in a sentence or two ("check whether the PR merged"), not a plan. You never need to name yourself: the wake reaches you on its own.`
+      },
+      withdraw_ask: {
+        askId: "The open ask to withdraw. Ask ids ride the conversation's message rows (`ask: { id, status, items }`), and your turn context lists the ones you have open.",
+        reason: `Why this question is no longer the question ("merged via GitHub #1551"). Required, and shown to the person on their Done row \u2014 a bare "withdrawn" tells them nothing. Up to ${MAX_WITHDRAW_REASON_BYTES} characters.`
+      }
+    };
+  }
+});
+
 // packages/agent-runtime/src/pump.ts
-var THINKING_TEXT_MAX_CHARS, TurnPump;
+function isTurnControlAnswer(evt) {
+  if (evt.mcpServer !== TURN_CONTROL_MCP_SERVER) return false;
+  const name = evt.toolName;
+  return name === ANSWER_TOOL || name === `${TURN_CONTROL_MCP_SERVER}.${ANSWER_TOOL}` || name === `${TURN_CONTROL_MCP_SERVER}_${ANSWER_TOOL}`;
+}
+var ANSWER_TOOL, THINKING_TEXT_MAX_CHARS, TurnPump;
 var init_pump = __esm({
   "packages/agent-runtime/src/pump.ts"() {
     "use strict";
     init_empty_result();
     init_transcript();
+    init_descriptions();
+    ANSWER_TOOL = "answer";
     THINKING_TEXT_MAX_CHARS = 3900;
     TurnPump = class {
       constructor(opts) {
         this.opts = opts;
         this.hasSpoken = opts.spoke ?? false;
+        this.armed = opts.armed ?? false;
+        if (opts.declaredSeq !== void 0) {
+          this.hasSpoken = true;
+          this.armed = false;
+          this.declared = true;
+          this.emittedFinal = true;
+          this.finalSeq = opts.declaredSeq;
+          this.emittedFinalSource = "declared";
+        }
         this.sink = {
           onAssistantText: async (evt) => {
             if (opts.signal.aborted) return;
             const body = normalizeCommitText(evt.text);
             if (!body) return;
             const seq = opts.nextSeq();
-            if (!evt.final && this.hasSpoken) {
+            if (this.armed) {
+              await opts.commit.commitMessage({ body, kind: "message", seq, declared: true });
+              this.armed = false;
+              this.declared = true;
+              this.hasSpoken = true;
+              this.emittedFinal = true;
+              this.finalSeq = seq;
+              this.lastTextSeq = seq;
+              this.finalReplyBody = body;
+              this.emittedFinalSource = "declared";
+              return;
+            }
+            if (this.declared || !evt.final && this.hasSpoken) {
               await opts.commit.reportText({ text: body, seq });
+              this.lastTextSeq = seq;
               return;
             }
             await opts.commit.commitMessage({ body, kind: "message", seq });
             this.hasSpoken = true;
+            this.lastTextSeq = seq;
             if (evt.final) {
               this.emittedFinal = true;
-              this.lastSeq = seq;
+              this.finalSeq = seq;
               this.finalReplyBody = body;
               this.emittedFinalSource = "runtime_text";
             }
           },
           onToolActivity: async (evt) => {
             if (opts.signal.aborted) return;
+            if (evt.phase === "done" && !this.declared && isTurnControlAnswer(evt)) {
+              this.armed = true;
+            }
             let call = this.toolCallByProviderId.get(evt.toolUseId);
             if (evt.phase === "start" || call === void 0) {
               call = { persistedId: crypto.randomUUID(), seq: opts.nextSeq() };
@@ -2568,9 +2754,16 @@ var init_pump = __esm({
       // A message has landed under this span — its first words. Every later
       // non-terminal text is the trail. Seeded from the host on a resume.
       hasSpoken;
-      // The last words landed, and their `seq` — what the settle declares.
+      // An accepted `answer` act this turn has not yet written the text for.
+      armed;
+      // The answer committed with `declared: true`; every text after it is trail.
+      declared = false;
+      // The answer landed — declared, or the adapter's terminal text — and its `seq`.
       emittedFinal = false;
-      lastSeq = null;
+      finalSeq = null;
+      // The `seq` of the turn's last text through either door. Undeclared, this is
+      // what the settle names: the server makes that text the body at the end.
+      lastTextSeq = null;
       // The turn's final reply text, captured for the dashboard feed / logging.
       finalReplyBody = null;
       emittedFinalSource = "none";
@@ -2592,14 +2785,20 @@ var init_pump = __esm({
       get spoke() {
         return this.hasSpoken;
       }
-      // Whether the turn has committed its last words.
+      // Whether the turn has committed its answer: declared, or the adapter's
+      // terminal text.
       get finalEmitted() {
         return this.emittedFinal;
       }
-      // The `seq` of the last words, for the settle to declare — or null when the
-      // span ended without any. Nothing is put in their place.
+      // What the settle names, by `seq`: the declared answer, or — undeclared —
+      // the turn's last text through either door, which the server makes the body
+      // at the end. Null when the turn wrote no text at all.
       get lastMessageSeq() {
-        return this.lastSeq;
+        return this.declared ? this.finalSeq : this.lastTextSeq;
+      }
+      // Whether an accepted `answer` act is still waiting for its text.
+      get answerArmed() {
+        return this.armed;
       }
       // The turn's final reply text, or null if none landed (failure / cancel /
       // empty). Used for the dashboard feed's reply preview.
@@ -2613,75 +2812,6 @@ var init_pump = __esm({
   }
 });
 
-// packages/agent-runtime/src/turn-control/descriptions.ts
-var MAX_ASK_QUESTION_BYTES, MAX_ASK_HEADLINE_BYTES, MAX_ASK_ITEMS, MAX_ASK_OPTION_BYTES, ASK_OPTION_NOT_A_STRING, MIN_ASK_OPTIONS, MAX_ASK_OPTIONS, ASK_TARGET_PATTERN, ASK_TARGET_INVALID, MAX_WAKE_NOTE_BYTES, MAX_WITHDRAW_REASON_BYTES, MAX_SKIP_REASON_BYTES, TURN_CONTROL_TOOLS, TURN_CONTROL_TOOL_DESCRIPTIONS, TURN_CONTROL_FIELD_DESCRIPTIONS;
-var init_descriptions = __esm({
-  "packages/agent-runtime/src/turn-control/descriptions.ts"() {
-    "use strict";
-    MAX_ASK_QUESTION_BYTES = 400;
-    MAX_ASK_HEADLINE_BYTES = 120;
-    MAX_ASK_ITEMS = 20;
-    MAX_ASK_OPTION_BYTES = 200;
-    ASK_OPTION_NOT_A_STRING = "An ask option is a plain string label.";
-    MIN_ASK_OPTIONS = 2;
-    MAX_ASK_OPTIONS = 4;
-    ASK_TARGET_PATTERN = /^(?:[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}|@?[A-Za-z0-9-]{2,32})$/;
-    ASK_TARGET_INVALID = "An ask target is a user id or an @handle.";
-    MAX_WAKE_NOTE_BYTES = 2e3;
-    MAX_WITHDRAW_REASON_BYTES = 400;
-    MAX_SKIP_REASON_BYTES = 500;
-    TURN_CONTROL_TOOLS = [
-      "ask",
-      "cancel_wake",
-      "skip_turn",
-      "wake_me",
-      "withdraw_ask"
-    ];
-    TURN_CONTROL_TOOL_DESCRIPTIONS = {
-      ask: `Ask a person a structured question you need answered to continue, then end your turn; don't wait for the reply. \`targetUserId\` is a person on your roster, by their \`@handle\`; to bring in an agent, name them with \`@handle\` in your reply.
-- Form: one question (\`headline\`, optional \`question\` body, \`options\`) or \`questions\`, 1\u2013${MAX_ASK_ITEMS} \`{ headline, body?, options? }\`; never both. Decisions that arise together go in ONE call, in the order you want them answered. A second \`ask\` is a separate item, never an edit; raise one only for a genuinely new question.
-- \`headline\`: one sentence ending in \`?\`. Body (\`question\` or each item's \`body\`): a sentence or two of framing, not a report; inline Markdown only, no lists or headings. \`options\`: ${MIN_ASK_OPTIONS}\u2013${MAX_ASK_OPTIONS} one-click answers (always for a yes/no go-ahead), each a distinct course of action you can carry out without asking back.
-- Voice, in headline, body and options: "I" for yourself, never your own name; name everyone else who decides or acts, as on your roster. Never "you", "your", "we", "us", "our" or their contractions, nor "he", "she" or "they" for a named actor. Each option reads correctly alone. A quotation stays accurate: say who said it.
-- It must stand alone, since it can arrive first: the reply carries the findings, the ask the question; don't repeat the reply in it.
-- Recorded when you call this; delivered when your turn ends, or after 3 minutes if it is still running. Ask as soon as you know. The answer reaches you on a later turn.
-- The person sends one response; unanswered questions end as Unanswered. A person can dismiss an ask; you aren't told and nothing wakes you. Check an ask's status before raising it again.
-- To replace a stale ask (yours or anyone's here), pass \`replaces: { askId, reason }\`: both land in one write and the person sees the reason. To withdraw without a replacement, use \`withdraw_ask\`.`,
-      cancel_wake: `Stand down the wake you have armed in this conversation, now, when you call it. No arguments. Use it when what the wake was to check has already happened or the work it watched is over; an unneeded wake fires into a turn with nothing to do. Your turn context prints the armed wake ("Wake armed: \u2026"); one no longer printed has fired or been dismissed. Nothing armed is a clean no-op. Calls act in order: \`cancel_wake\` then \`wake_me\` leaves the new wake armed. It reaches only your own wake here, never a peer's and never a recurring schedule (\`schedules.*\`).`,
-      skip_turn: `End your current turn WITHOUT posting a reply. Call this when you've been woken to read a message that genuinely doesn't need a response from you \u2014 a thanks/aside, a question already answered, chatter outside your lane, or something another participant clearly owns. Your turn ends silently: no message bubble is posted. The \`reason\` is a short free-text note for telemetry (e.g. "already answered by cabane", "thanks, nothing to add"). Prefer this over posting a low-value "ok!"/"got it" reply. Don't also write a reply when you skip \u2014 skipping IS the whole turn.`,
-      wake_me: `Wake yourself later: end this turn now and be re-dispatched at a time you pick, with a note to yourself. Use it to wait for a condition you can name (a PR merging, a session limit resetting, an answer landing): arm, end the turn, and you're woken to CHECK and either act or re-arm. Most wakes are short, seconds to a couple of hours. Reach past a few hours only when a person asked for that timing or the wait is pinned to a real external event (a report that runs Mondays); if no one asked and you can't name both what clears the wait and why it takes that long, don't arm it: finish now, or raise an \`ask\`. Pass EXACTLY ONE of \`afterSeconds\` (\`300\` for five minutes) or \`at\` (an ISO-8601 timestamp WITH a zone, e.g. \`2026-07-16T09:00:00-07:00\`, which YOU compute; nothing parses natural-language time). \`note\` becomes the body of the message that re-dispatches you: write the condition to re-check. The wake arms NOW, when you call this; a later \`wake_me\` in the same turn replaces it, \`cancel_wake\` stands it down, and one that comes due mid-turn is delivered after your reply. This is the ONLY way to schedule your own continuation; never a host cron or scheduler. Floor 60s, horizon 14 days, enforced here so you can recompute. Widen the interval as a loop ages (5m \u2192 15m \u2192 1h\u2026); after many re-arms with no other activity you'll be steered to an \`ask\` instead.`,
-      withdraw_ask: `Withdraw an open ask \u2014 yours or anyone's in this conversation \u2014 because the question is moot, was wrong, or has been overtaken. \`reason\` is required and is shown to the person and, if it wasn't your ask, to the agent who asked it. If there is a current question to put in its place, don't call this \u2014 call \`ask\` with \`replaces\` so the two land as one and the person never sees neither or both. Never withdraw to hurry an answer; to act on a deadline, arm a \`wake_me\` and decide then.`
-    };
-    TURN_CONTROL_FIELD_DESCRIPTIONS = {
-      ask: {
-        targetUserId: "The person to ask: their `@handle` from your turn context's roster (preferred), or their user id.",
-        question: `SINGLE-question form: a short body \u2014 one or two sentences of framing the headline can't hold. NOT a report (up to ${MAX_ASK_QUESTION_BYTES} characters, inline markdown only). Provide EITHER this or \`questions\`, not both. Put the crisp one-sentence question in \`headline\`.`,
-        headline: `SINGLE-question form: the question itself as ONE clear, capitalized sentence ending in \`?\` ("Should Ledger deploy once Mia approves?"), up to ${MAX_ASK_HEADLINE_BYTES} characters. What the person reads first in For you and on the chip \u2014 one scannable question, no elaboration (that goes in \`question\`). Strongly encouraged.`,
-        options: `SINGLE-question form: optional ${MIN_ASK_OPTIONS}\u2013${MAX_ASK_OPTIONS} suggested one-click answers, up to ${MAX_ASK_OPTION_BYTES} characters each. Each option must make sense on its own.`,
-        questions: `MULTI-question form: 1\u2013${MAX_ASK_ITEMS} questions to ask at once, when a plan ends with several bounded decisions. Provide EITHER this or \`question\`/\`headline\`/\`options\`, not both.`,
-        "questions.headline": `The one-sentence question ("Should Ledger deploy once Mia approves?") \u2014 required for each item, up to ${MAX_ASK_HEADLINE_BYTES} characters.`,
-        "questions.body": `Optional short framing beneath the headline, up to ${MAX_ASK_QUESTION_BYTES} characters, inline markdown only. NOT a report.`,
-        "questions.options": `Optional ${MIN_ASK_OPTIONS}\u2013${MAX_ASK_OPTIONS} one-click answers for this question, up to ${MAX_ASK_OPTION_BYTES} characters each. Each option must make sense on its own.`,
-        replaces: "Withdraw a stale ask in this conversation as part of raising this one. Both land in a single write, so the person goes from the old question to the new one and never sees neither or both.",
-        "replaces.askId": "The id of the open ask to withdraw.",
-        "replaces.reason": `Why the old question is no longer the question \u2014 shown to the person on their Done row. Up to ${MAX_WITHDRAW_REASON_BYTES} characters.`
-      },
-      cancel_wake: {},
-      skip_turn: {
-        reason: `Short reason you are declining \u2014 used for telemetry/debugging, never posted. Up to ${MAX_SKIP_REASON_BYTES} characters.`
-      },
-      wake_me: {
-        afterSeconds: "Relative delay in seconds from NOW \u2014 this call (e.g. 300 = five minutes). Provide EITHER this or `at`, not both. Floor 60s, horizon 14 days \u2014 enforced server-side.",
-        at: "Absolute ISO-8601 timestamp WITH a zone (`Z` or `\xB1HH:MM`), e.g. `2026-07-16T09:00:00-07:00`. YOU compute it from a natural-language phrase using the current datetime in your turn context. Provide EITHER this or `afterSeconds`, not both.",
-        note: `A note to your future self \u2014 becomes the body of the wake message that re-dispatches you, up to ${MAX_WAKE_NOTE_BYTES} characters. Write the condition to re-check in a sentence or two ("check whether the PR merged"), not a plan. You never need to name yourself: the wake reaches you on its own.`
-      },
-      withdraw_ask: {
-        askId: "The open ask to withdraw. Ask ids ride the conversation's message rows (`ask: { id, status, items }`), and your turn context lists the ones you have open.",
-        reason: `Why this question is no longer the question ("merged via GitHub #1551"). Required, and shown to the person on their Done row \u2014 a bare "withdrawn" tells them nothing. Up to ${MAX_WITHDRAW_REASON_BYTES} characters.`
-      }
-    };
-  }
-});
-
 // packages/agent-runtime/src/turn-control/prompt-guidance.ts
 function turnControlPromptGuidance(prefix) {
   const controls = TURN_CONTROL_TOOLS.map((name) => `\`${prefix}${name}\` (${MEANINGS[name]})`);
@@ -2693,6 +2823,7 @@ var init_prompt_guidance = __esm({
     "use strict";
     init_descriptions();
     MEANINGS = {
+      answer: "declare the text you write next as your answer",
       ask: "put a structured question to a person",
       cancel_wake: "cancel your own armed wake in this conversation",
       skip_turn: "end without posting a reply",
@@ -4231,6 +4362,15 @@ var init_events = __esm({
 });
 
 // packages/agent-runtime/src/opencode/loop.ts
+function opencodeMcpServerOf(tool2, servers) {
+  let best = null;
+  for (const server of servers ?? []) {
+    if (tool2.length > server.length + 1 && tool2.startsWith(`${server}_`)) {
+      if (best === null || server.length > best.length) best = server;
+    }
+  }
+  return best;
+}
 async function* decodeOpencodeStream(events, ctx2) {
   let held = null;
   const pending = /* @__PURE__ */ new Map();
@@ -4257,12 +4397,14 @@ async function* decodeOpencodeStream(events, ctx2) {
         if (sealed) yield sealed;
         const key = part.callID ?? part.id;
         const input = part.state.input;
+        const server = opencodeMcpServerOf(part.tool, ctx2.mcpServers);
+        const origin = server ? { mcpServer: server } : {};
         if (!startedTools.has(key)) {
           const name = prettyToolName(part.tool);
           const summary = summarizeToolInput(input);
           pending.set(key, { name, summary, input });
           startedTools.add(key);
-          yield { type: "tool", id: key, name, phase: "start", summary, input };
+          yield { type: "tool", id: key, name, phase: "start", summary, input, ...origin };
         }
         const entry = pending.get(key);
         if (entry && hasToolInput(input)) {
@@ -4282,7 +4424,8 @@ async function* decodeOpencodeStream(events, ctx2) {
             phase,
             summary: started?.summary ?? "",
             input: started?.input ?? input,
-            result
+            result,
+            ...origin
           };
         }
       } else {
@@ -4480,15 +4623,15 @@ function buildMcp(req) {
 function isStringRecord(v) {
   return !!v && typeof v === "object" && Object.values(v).every((x) => typeof x === "string");
 }
-var CABANE_MCP_SERVER2, TURN_CONTROL_MCP_SERVER, ACTIVE_CONVERSATION_HEADER2;
+var CABANE_MCP_SERVER2, ACTIVE_CONVERSATION_HEADER2;
 var init_run_spec = __esm({
   "packages/agent-runtime/src/opencode/run-spec.ts"() {
     "use strict";
+    init_descriptions();
     init_mcp_secret_env();
     init_policy2();
     init_model2();
     CABANE_MCP_SERVER2 = "cabane";
-    TURN_CONTROL_MCP_SERVER = "cabane_companion";
     ACTIVE_CONVERSATION_HEADER2 = "x-cabane-active-conversation";
   }
 });
@@ -4799,7 +4942,10 @@ function createOpencodeAdapter(deps = {}) {
       }
       yield* decodeOpencodeStream(result.events, {
         signal,
-        sessionId: result.sessionId
+        sessionId: result.sessionId,
+        // The keys the turn's servers were installed under: what the decoder
+        // splits a raw `<server>_<tool>` id on.
+        mcpServers: Object.keys(spec.mcp)
       });
     }
   };
@@ -4961,7 +5107,15 @@ var init_conformance3 = __esm({
         expected: [
           sessionEvent2(NEW_SESSION_ID),
           // start: fires off the first (empty) snapshot — empty input + summary, by design.
-          { type: "tool", id: "call_1", name: "cabane_list", phase: "start", summary: "", input: {} },
+          {
+            type: "tool",
+            id: "call_1",
+            name: "cabane_list",
+            phase: "start",
+            summary: "",
+            input: {},
+            mcpServer: "cabane"
+          },
           // done: carries the full args captured from the later snapshot, and the
           // summary recomputed from them — NOT the first-seen `{}`.
           {
@@ -4971,11 +5125,63 @@ var init_conformance3 = __esm({
             phase: "done",
             summary: "/product/tasks",
             input: { path: "/product/tasks" },
-            result: "CT301.md"
+            result: "CT301.md",
+            mcpServer: "cabane"
           },
           { type: "result", ok: true }
         ]
       },
+      {
+        // The turn-control server's `answer` (CT1973). opencode names an MCP tool `<server>_<tool>`,
+        // so the installed keys split the raw id: `cabane_companion_answer` is the turn-control
+        // server's, never the workspace server's `companion_answer`. The pump binds on that.
+        name: "turn-control answer is read as the turn-control server\u2019s, not cabane\u2019s",
+        request: makeRequest2({
+          cabane: {
+            mcpUrl: "https://cabane.test/api/mcp",
+            turnControlUrl: "https://cabane.test/api/turn-control",
+            bearer: "tok",
+            activeConversationId: "conv"
+          }
+        }),
+        nativeStream: [
+          textPart("p1", "On it."),
+          toolPart("t1", "cabane_companion_answer", { status: "running", input: {} }, "call_1"),
+          toolPart(
+            "t1",
+            "cabane_companion_answer",
+            { status: "completed", input: {}, output: '{"ok":true,"kind":"answer"}' },
+            "call_1"
+          ),
+          textPart("p2", "The answer."),
+          idle()
+        ],
+        expected: [
+          sessionEvent2(NEW_SESSION_ID),
+          { type: "text", body: "On it.", terminal: false },
+          {
+            type: "tool",
+            id: "call_1",
+            name: "cabane_companion_answer",
+            phase: "start",
+            summary: "",
+            input: {},
+            mcpServer: "cabane_companion"
+          },
+          {
+            type: "tool",
+            id: "call_1",
+            name: "cabane_companion_answer",
+            phase: "done",
+            summary: "",
+            input: {},
+            result: '{"ok":true,"kind":"answer"}',
+            mcpServer: "cabane_companion"
+          },
+          { type: "text", body: "The answer.", terminal: true },
+          { type: "result", ok: true }
+        ]
+      },
       {
         // Highest risk: cancel mid-stream. The abort lands after the tool result; the adapter stops before
         // the closing reply — no final text, no `result` event (the server writes the stopped marker).
@@ -5339,6 +5545,7 @@ function readToolItem(item, eventType) {
       name: server && server !== "cabane" ? `${server}.${tool2}` : tool2,
       input: item.arguments,
       status: toStatus(item.status),
+      ...server ? { server } : {},
       ...item.status === "completed" ? { result } : item.status === "failed" ? { result: hasMcpReceipt(result) ? result : readMcpError(item.error) } : {}
     };
   }
@@ -5577,11 +5784,20 @@ async function* decodeCodexStream(events, ctx2) {
       if (!tool2) continue;
       yield* flushInterim();
       const name = prettyToolName(tool2.name);
+      const origin = tool2.server ? { mcpServer: tool2.server } : {};
       if (!startedTools.has(tool2.id)) {
         const summary = summarizeToolInput(tool2.input);
         pending.set(tool2.id, { name, summary, input: tool2.input });
         startedTools.add(tool2.id);
-        yield { type: "tool", id: tool2.id, name, phase: "start", summary, input: tool2.input };
+        yield {
+          type: "tool",
+          id: tool2.id,
+          name,
+          phase: "start",
+          summary,
+          input: tool2.input,
+          ...origin
+        };
       }
       const entry = pending.get(tool2.id);
       if (entry && hasToolInput2(tool2.input)) {
@@ -5599,7 +5815,8 @@ async function* decodeCodexStream(events, ctx2) {
           phase: tool2.status === "completed" ? "done" : "error",
           summary: started?.summary ?? "",
           input: started?.input ?? tool2.input,
-          result: tool2.result
+          result: tool2.result,
+          ...origin
         };
       }
       continue;
@@ -5830,7 +6047,7 @@ function buildConfig(req) {
     default_tools_approval_mode: "approve"
   };
   if (req.cabane.turnControlUrl) {
-    mcp_servers[TURN_CONTROL_MCP_SERVER2] = {
+    mcp_servers[TURN_CONTROL_MCP_SERVER] = {
       url: req.cabane.turnControlUrl,
       http_headers: {
         Authorization: `Bearer ${req.cabane.bearer}`,
@@ -5855,16 +6072,16 @@ function buildConfig(req) {
 function isStringRecord2(v) {
   return !!v && typeof v === "object" && Object.values(v).every((x) => typeof x === "string");
 }
-var CABANE_MCP_SERVER3, TURN_CONTROL_MCP_SERVER2, ACTIVE_CONVERSATION_HEADER3, ENV_ENVELOPE_KEYS, CORE_REPLACES, CONVERSATION_REPLACES;
+var CABANE_MCP_SERVER3, ACTIVE_CONVERSATION_HEADER3, ENV_ENVELOPE_KEYS, CORE_REPLACES, CONVERSATION_REPLACES;
 var init_run_spec2 = __esm({
   "packages/agent-runtime/src/codex/run-spec.ts"() {
     "use strict";
+    init_descriptions();
     init_standing();
     init_policy3();
     init_model3();
     init_session3();
     CABANE_MCP_SERVER3 = "cabane";
-    TURN_CONTROL_MCP_SERVER2 = "cabane_companion";
     ACTIVE_CONVERSATION_HEADER3 = "x-cabane-active-conversation";
     ENV_ENVELOPE_KEYS = [
       "CABANE_CONVERSATION_ID",
@@ -6336,6 +6553,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "t1",
             name: "read",
+            mcpServer: "cabane",
             phase: "start",
             summary: "sleep.md",
             input: { path: "sleep.md" }
@@ -6344,6 +6562,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "t1",
             name: "read",
+            mcpServer: "cabane",
             phase: "done",
             summary: "sleep.md",
             input: { path: "sleep.md" },
@@ -6389,6 +6608,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "query-success",
             name: "query",
+            mcpServer: "cabane",
             phase: "start",
             summary: "",
             input: { op: "files.read", args: { path: "/ABOUT.md" } }
@@ -6397,6 +6617,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "query-success",
             name: "query",
+            mcpServer: "cabane",
             phase: "done",
             summary: "",
             input: { op: "files.read", args: { path: "/ABOUT.md" } },
@@ -6443,6 +6664,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "query-failed",
             name: "query",
+            mcpServer: "cabane",
             phase: "start",
             summary: "",
             input: { op: "files.read", args: { path: "/ABOUT.md" } }
@@ -6451,6 +6673,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "query-failed",
             name: "query",
+            mcpServer: "cabane",
             phase: "error",
             summary: "",
             input: { op: "files.read", args: { path: "/ABOUT.md" } },
@@ -6460,6 +6683,54 @@ var init_conformance4 = __esm({
           { type: "result", ok: true }
         ]
       },
+      {
+        // The turn-control server's `answer` (CT1973): the tool event carries the server Codex names
+        // beside the tool, which is what the pump binds the declaration to. A non-cabane server keeps
+        // its prefix on the card as before.
+        name: "turn-control answer carries its server",
+        request: makeRequest3(),
+        nativeStream: [
+          threadStarted(NEW_THREAD_ID),
+          agentMessage("m1", "On it."),
+          toolFrame("item.completed", {
+            id: "answer-1",
+            type: "mcp_tool_call",
+            server: "cabane_companion",
+            tool: "answer",
+            arguments: {},
+            status: "completed",
+            result: { content: [{ type: "text", text: '{"ok":true,"kind":"answer"}' }] }
+          }),
+          agentMessage("m2", "The answer."),
+          turnCompleted()
+        ],
+        expected: [
+          startedSession(NEW_THREAD_ID),
+          { type: "text", body: "On it.", terminal: false },
+          {
+            type: "tool",
+            id: "answer-1",
+            name: "cabane_companion.answer",
+            mcpServer: "cabane_companion",
+            phase: "start",
+            summary: "",
+            input: {}
+          },
+          {
+            type: "tool",
+            id: "answer-1",
+            name: "cabane_companion.answer",
+            mcpServer: "cabane_companion",
+            phase: "done",
+            summary: "",
+            input: {},
+            result: [{ type: "text", text: '{"ok":true,"kind":"answer"}' }]
+          },
+          { type: "text", body: "The answer.", terminal: true },
+          closingSession(NEW_THREAD_ID),
+          { type: "result", ok: true }
+        ]
+      },
       {
         // A transport/tool failure with no MCP result payload still uses the real adapter error message,
         // never `undefined`.
@@ -6485,6 +6756,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "mcp-failed",
             name: "other.lookup",
+            mcpServer: "other",
             phase: "start",
             summary: "receipt",
             input: { q: "receipt" }
@@ -6493,6 +6765,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "mcp-failed",
             name: "other.lookup",
+            mcpServer: "other",
             phase: "error",
             summary: "receipt",
             input: { q: "receipt" },
@@ -6529,6 +6802,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "mcp-image",
             name: "other.render",
+            mcpServer: "other",
             phase: "start",
             summary: "",
             input: {}
@@ -6537,6 +6811,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "mcp-image",
             name: "other.render",
+            mcpServer: "other",
             phase: "done",
             summary: "",
             input: {},
@@ -6584,11 +6859,20 @@ var init_conformance4 = __esm({
         ],
         expected: [
           startedSession(NEW_THREAD_ID),
-          { type: "tool", id: "t1", name: "list", phase: "start", summary: "", input: {} },
           {
             type: "tool",
             id: "t1",
             name: "list",
+            mcpServer: "cabane",
+            phase: "start",
+            summary: "",
+            input: {}
+          },
+          {
+            type: "tool",
+            id: "t1",
+            name: "list",
+            mcpServer: "cabane",
             phase: "done",
             summary: "/product/tasks",
             input: { path: "/product/tasks" },
@@ -8428,6 +8712,13 @@ function createTurnControlMcpServer(acts, skipState) {
         }),
         { annotations: ACT_TOOL, alwaysLoad: true }
       ),
+      tool(
+        ANSWER_TOOL2,
+        TURN_CONTROL_TOOL_DESCRIPTIONS.answer,
+        {},
+        async () => performAct(acts, { kind: "answer", callId: randomUUID2() }),
+        { annotations: ACT_TOOL, alwaysLoad: true }
+      ),
       // The inverse. No arguments — it can only ever stand down the
       // caller's own wake in the conversation it's holding a turn in.
       tool(
@@ -8440,7 +8731,7 @@ function createTurnControlMcpServer(acts, skipState) {
     ]
   });
 }
-var COMPANION_LOCAL_MCP_SERVER, COMPANION_LOCAL_TOOL_GLOB, SKIP_TURN_TOOL, ASK_TOOL, ASK_TOOL_NAME, WITHDRAW_ASK_TOOL, WITHDRAW_ASK_TOOL_NAME, WAKE_ME_TOOL, WAKE_ME_TOOL_NAME, CANCEL_WAKE_TOOL, CANCEL_WAKE_TOOL_NAME, TURN_ACT_TIMEOUT_MS;
+var COMPANION_LOCAL_MCP_SERVER, COMPANION_LOCAL_TOOL_GLOB, SKIP_TURN_TOOL, ASK_TOOL, ASK_TOOL_NAME, WITHDRAW_ASK_TOOL, WITHDRAW_ASK_TOOL_NAME, ANSWER_TOOL2, WAKE_ME_TOOL, WAKE_ME_TOOL_NAME, CANCEL_WAKE_TOOL, CANCEL_WAKE_TOOL_NAME, TURN_ACT_TIMEOUT_MS;
 var init_turn_control_tools = __esm({
   "src/turn-control-tools.ts"() {
     "use strict";
@@ -8448,13 +8739,14 @@ var init_turn_control_tools = __esm({
     init_descriptions();
     init_errors();
     init_api_error_shape();
-    COMPANION_LOCAL_MCP_SERVER = "cabane_companion";
+    COMPANION_LOCAL_MCP_SERVER = TURN_CONTROL_MCP_SERVER;
     COMPANION_LOCAL_TOOL_GLOB = `mcp__${COMPANION_LOCAL_MCP_SERVER}__*`;
     SKIP_TURN_TOOL = "skip_turn";
     ASK_TOOL = "ask";
     ASK_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${ASK_TOOL}`;
     WITHDRAW_ASK_TOOL = "withdraw_ask";
     WITHDRAW_ASK_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${WITHDRAW_ASK_TOOL}`;
+    ANSWER_TOOL2 = "answer";
     WAKE_ME_TOOL = "wake_me";
     WAKE_ME_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${WAKE_ME_TOOL}`;
     CANCEL_WAKE_TOOL = "cancel_wake";
@@ -9111,7 +9403,7 @@ var init_turn_committer = __esm({
           deps.onCommitFailed?.(err);
         };
         const commit = {
-          commitMessage: async ({ body, kind, seq }) => {
+          commitMessage: async ({ body, kind, seq, declared }) => {
             await deps.api.postTurnMessage(
               deps.workspaceId,
               deps.conversationId,
@@ -9121,9 +9413,11 @@ var init_turn_committer = __esm({
                 turnId: deps.turnId,
                 seq,
                 parentMessageId: deps.parentMessageId,
-                ...source
+                ...source,
+                ...declared ? { declared } : {}
               },
-              deps.signal
+              deps.signal,
+              { agentId: deps.agentId }
             );
           },
           reportTool: async ({
@@ -9182,7 +9476,9 @@ var init_turn_committer = __esm({
           commit,
           signal: deps.signal,
           nextSeq: deps.nextSeq,
-          ...deps.spoke !== void 0 ? { spoke: deps.spoke } : {}
+          ...deps.spoke !== void 0 ? { spoke: deps.spoke } : {},
+          ...deps.armed !== void 0 ? { armed: deps.armed } : {},
+          ...deps.declaredSeq !== void 0 ? { declaredSeq: deps.declaredSeq } : {}
         });
         this.emit = sinkEmitter(this.pump.sink, this.onError);
       }
@@ -9204,14 +9500,15 @@ var init_turn_committer = __esm({
         }
       }
       // A message has landed under this span — its first words at least. A span
-      // that spoke settles; one that never did is a pass. Nothing is promoted at
-      // the end of a turn: the held-text flush is the adapter's (it emits the
-      // closing reply as a terminal `text` event before `result`), and a span
-      // that ended on working text ends without last words.
+      // that spoke settles; one that never did is a pass. The held-text flush is
+      // the adapter's (it emits the closing reply as a terminal `text` event before
+      // `result`); a span that ended on working text names that text as its last,
+      // and the server makes it the body at the end.
       get spoke() {
         return this.pump.spoke;
       }
-      // The `seq` of the last words, for the settle to declare; null when none.
+      // What the settle names by `seq`: the declared answer, or the turn's last
+      // text through either door; null when the turn wrote none.
       get lastMessageSeq() {
         return this.pump.lastMessageSeq;
       }
@@ -9442,6 +9739,12 @@ var init_turn_execution = __esm({
       // Whether the span this resumed run continues already has first words —
       // from the server (`turnSpoke`) or from speech still queued in the outbox.
       resumedSpoke = false;
+      // Whether the resumed run starts with the `answer` act armed: the server
+      // holds an accepted act (`answerArmed`) and this device's outbox holds no
+      // `declared` commit for the turn — a queued selection stands, and the run
+      // starts declared at its seq instead.
+      resumedArmed = false;
+      resumedDeclaredSeq;
       turnContext;
       resolvedMcpServers;
       // The harness's secret environment for this turn. Only ever handed to the
@@ -9627,6 +9930,7 @@ var init_turn_execution = __esm({
         const { payload, turnId, turnLog } = this;
         const outboxFloor = this.resumed ? readOutboxFloor((id) => this.opts.api.outboxMaxSeqForTurn(id), turnId, turnLog) : 0;
         const outboxSpoke = this.resumed && this.opts.api.outboxHasSpeechForTurn(turnId);
+        const outboxDeclaredSeq = this.resumed ? this.opts.api.outboxDeclaredSeqForTurn(turnId) : null;
         let turnContext;
         try {
           turnContext = await this.opts.api.getTurnContext(
@@ -9681,6 +9985,16 @@ var init_turn_execution = __esm({
           this.seqCounter = Math.max(this.seqCounter, this.resumedFromSeq);
           this.resumedSpoke = turnContext.turnSpoke === true || outboxSpoke;
           if (this.resumedSpoke) turnLog.debug({ turnId }, "dispatcher: resumed span already spoke");
+          this.resumedArmed = turnContext.answerArmed === true && outboxDeclaredSeq === null;
+          this.resumedDeclaredSeq = outboxDeclaredSeq ?? void 0;
+          if (this.resumedArmed)
+            turnLog.debug({ turnId }, "dispatcher: resumed turn re-armed its answer");
+          if (outboxDeclaredSeq !== null) {
+            turnLog.debug(
+              { turnId, seq: outboxDeclaredSeq },
+              "dispatcher: resumed turn keeps the answer queued in its outbox"
+            );
+          }
         }
       }
       // Register this context's issuance as the execution source of the work about to
@@ -10188,6 +10502,8 @@ var init_turn_execution = __esm({
           log: turnLog,
           nextSeq: this.nextSeq,
           spoke: this.resumedSpoke,
+          armed: this.resumedArmed,
+          ...this.resumedDeclaredSeq !== void 0 ? { declaredSeq: this.resumedDeclaredSeq } : {},
           // Admitted by now, so this is the source the model's work runs on.
           ...this.executionSourceId !== void 0 ? { executionSourceId: this.executionSourceId } : {},
           // A commit that didn't land may mean the lease is gone; see