@cabane/companion 0.6.202 → 0.6.204

package/dist/cli.js

@@ -321,25 +321,7 @@ var init_prepare_hook = __esm({
       // Wall-clock cap for the hook. Provisioning is slow (minutes), so the
       // default is generous; a hook that hangs past this is killed and the turn
       // fails with a clear timeout message rather than pinning the companion.
-      timeoutMs: z.number().int().positive().optional(),
-      // Re-invoke the hook when a prepared result already exists, in VALIDATE
-      // mode: the cached result is handed back as `prepared` and stdout is
-      // ignored, so the cwd cannot move. Its only power is to exit non-zero and
-      // fail the turn. The hook resolves once per (conversation, agent), so a
-      // later message asking for a different environment is otherwise silently
-      // ignored; this lets a hook refuse it out loud.
-      //
-      // Default OFF: a hook that provisions unconditionally must not start
-      // running on every turn because the companion upgraded.
-      validateCached: z.boolean().optional(),
-      // Independent operator-owned reporter. Receives sanitized failure metadata
-      // on stdin; never re-enters this hook and cannot change the turn outcome.
-      failureReporter: z.object({
-        command: z.string().min(1),
-        args: z.array(z.string()).optional(),
-        env: z.record(z.string(), z.string()).optional(),
-        timeoutMs: z.number().int().positive().max(3e4).optional()
-      }).strict().optional()
+      timeoutMs: z.number().int().positive().optional()
     }).strict();
     DEFAULT_TIMEOUT_MS = 10 * 6e4;
     prepareResultSchema = z.object({
@@ -369,15 +351,7 @@ var init_prepare_hook = __esm({
               CABANE_AGENT_USERNAME: input.agentUsername,
               CABANE_DEFAULT_CWD: input.defaultCwd,
               CABANE_RUNTIME: input.runtime ?? "",
-              // Newline-joined — workspace paths never contain a newline, so a
-              // hook splits on `\n` unambiguously. Empty string when none.
-              CABANE_TRIGGER_ENTRY_PATHS: input.triggerEntryPaths.join("\n"),
-              CABANE_CONVERSATION_TITLE: input.title ?? "",
-              // The dispatching message's text, and — in validate mode only —
-              // the prepared result the hook is being asked to check this dispatch
-              // against. Both empty/absent on an ordinary first run.
-              CABANE_TRIGGER_MESSAGE: input.messageBody ?? "",
-              ...input.prepared ? { CABANE_PREPARED: JSON.stringify(input.prepared) } : {}
+              CABANE_CONVERSATION_TITLE: input.title ?? ""
             }
           });
         } catch (err) {
@@ -415,10 +389,6 @@ var init_prepare_hook = __esm({
               );
               return;
             }
-            if (input.prepared) {
-              resolve2(input.prepared);
-              return;
-            }
             try {
               resolve2(parsePrepareOutput(stdout));
             } catch (err) {
@@ -487,33 +457,36 @@ function workRoot(cfg) {
   if (root.startsWith("~/")) return join4(homedir5(), root.slice(2));
   return root;
 }
-function retiredConfigKeys(raw) {
-  if (!raw || typeof raw !== "object") return [];
-  const obj = raw;
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function splitRetired(raw) {
   const keys = [];
-  if ("runners" in obj) keys.push("runners");
-  const agents = obj.agents;
-  if (agents && typeof agents === "object") {
-    for (const [key, row3] of Object.entries(agents)) {
-      if (row3 && typeof row3 === "object" && "sandbox" in row3) keys.push(`agents.${key}.sandbox`);
+  const without = (obj, names, path) => {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      if (names.includes(k)) keys.push(`${path}${k}`);
+      else out[k] = v;
+    }
+    return out;
+  };
+  const hook = (row3, path) => isObject(row3.prepareHook) ? { ...row3, prepareHook: without(row3.prepareHook, RETIRED_HOOK_KEYS, `${path}prepareHook.`) } : row3;
+  const kept = hook(without(raw, ["runners"], ""), "");
+  if (isObject(kept.agents)) {
+    const agents = {};
+    for (const [key, row3] of Object.entries(kept.agents)) {
+      const path = `agents.${key}.`;
+      agents[key] = isObject(row3) ? hook(without(row3, RETIRED_ROW_KEYS, path), path) : row3;
     }
+    kept.agents = agents;
   }
-  return keys;
+  return { keys, kept };
+}
+function retiredConfigKeys(raw) {
+  return isObject(raw) ? splitRetired(raw).keys : [];
 }
 function withoutRetiredKeys(raw) {
-  if (retiredConfigKeys(raw).length === 0) return raw;
-  const { runners: _runners, ...rest } = raw;
-  if (!rest.agents || typeof rest.agents !== "object") return rest;
-  const agents = {};
-  for (const [key, row3] of Object.entries(rest.agents)) {
-    if (row3 && typeof row3 === "object" && "sandbox" in row3) {
-      const { sandbox: _sandbox, ...kept } = row3;
-      agents[key] = kept;
-    } else {
-      agents[key] = row3;
-    }
-  }
-  return { ...rest, agents };
+  return isObject(raw) ? splitRetired(raw).kept : raw;
 }
 function retiredConfigKeysOnDisk() {
   try {
@@ -708,7 +681,7 @@ function deleteConfig() {
     writeFileSync(path, "", { mode: 384 });
   }
 }
-var HARNESS_RUNTIMES, realHomeCache, localAgentConfigSchema, agentsConfigSchema, companionConfigSchema, legacyOfferSchema;
+var HARNESS_RUNTIMES, realHomeCache, localAgentConfigSchema, agentsConfigSchema, companionConfigSchema, RETIRED_ROW_KEYS, RETIRED_HOOK_KEYS, legacyOfferSchema;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
@@ -753,8 +726,7 @@ var init_config = __esm({
       // The DEVICE-LEVEL prepare hook, for every agent assigned here unless its own
       // `agents` row names one. Per-agent hooks alone make the config a second
       // silent roster: an agent nobody listed gets no hook and no error, and starts
-      // in the operator's `$HOME` (an agent woke in `/home/joshed` this way on
-      // 2026-08-17).
+      // in the operator's `$HOME`.
       prepareHook: prepareHookSchema.optional(),
       // `dashboardPort` and `autoOpen` are IGNORED by the CLI (no port, no browser)
       // but stay in the schema so an existing file still parses; the Electron shell
@@ -791,13 +763,16 @@ var init_config = __esm({
       root: z2.string().min(1).refine(isRootPath, { message: "must be an absolute path, or start with ~/" }).optional(),
       // An argv prefix the operator puts in front of every turn's runner: the companion starts
       // `<prefix…> <its own run-turn command…>` instead of the runner bare. What the prefix does
-      // is the operator's (a box of their own making, ENG225); the companion knows nothing of it
+      // is the operator's (a container or VM per turn, say); the companion knows nothing of it
       // beyond handing the runner over, with the turn's inputs in its environment and the
-      // credential and secrets on its stdin (`runner/launch.ts`, `boxed`).
+      // credential and secrets on its stdin (`runner/launch.ts`, `wrapped`). The README lists
+      // what a wrapper can rely on.
       runner: z2.object({
         command: z2.array(z2.string().min(1)).min(1)
       }).strict().optional()
     });
+    RETIRED_ROW_KEYS = ["sandbox"];
+    RETIRED_HOOK_KEYS = ["validateCached", "failureReporter"];
     legacyOfferSchema = z2.object({
       claudeCode: z2.object({ enabled: z2.boolean().optional() }).passthrough().optional(),
       codex: z2.object({ enabled: z2.boolean().optional() }).passthrough().optional(),
@@ -1395,6 +1370,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 +1509,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 +1520,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 +1554,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 +1652,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 +1838,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 +2070,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 +2550,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 +2729,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 +2760,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 +2787,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 +2798,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 +4337,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 +4372,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 +4399,8 @@ async function* decodeOpencodeStream(events, ctx2) {
             phase,
             summary: started?.summary ?? "",
             input: started?.input ?? input,
-            result
+            result,
+            ...origin
           };
         }
       } else {
@@ -4480,15 +4598,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 +4917,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 +5082,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,8 +5100,60 @@ 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 }
         ]
       },
@@ -5339,6 +5520,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 +5759,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 +5790,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 +6022,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 +6047,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",
@@ -6038,7 +6230,7 @@ function createCodexAdapter(deps = {}) {
         if (signal.aborted) return;
         if (compactions === null) {
           deps.onWarn?.(
-            "codex adapter: the thread's compaction count could not be read \u2014 re-sending the standing instructions (ENG210)",
+            "codex adapter: the thread's compaction count could not be read \u2014 re-sending the standing instructions",
             { threadId: decision.resume }
           );
         } else if (decision.compactions === compactions) {
@@ -6048,7 +6240,7 @@ function createCodexAdapter(deps = {}) {
           };
         } else if (decision.compactions !== null && compactions > decision.compactions) {
           deps.onWarn?.(
-            "codex adapter: the thread compacted since the last turn \u2014 re-sending the standing instructions (ENG210)",
+            "codex adapter: the thread compacted since the last turn \u2014 re-sending the standing instructions",
             {
               threadId: decision.resume,
               compactions,
@@ -6336,6 +6528,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "t1",
             name: "read",
+            mcpServer: "cabane",
             phase: "start",
             summary: "sleep.md",
             input: { path: "sleep.md" }
@@ -6344,6 +6537,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "t1",
             name: "read",
+            mcpServer: "cabane",
             phase: "done",
             summary: "sleep.md",
             input: { path: "sleep.md" },
@@ -6389,6 +6583,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 +6592,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 +6639,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 +6648,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" } },
@@ -6461,17 +6659,65 @@ var init_conformance4 = __esm({
         ]
       },
       {
-        // A transport/tool failure with no MCP result payload still uses the real adapter error message,
-        // never `undefined`.
-        name: "failed MCP call without result keeps error message fallback",
+        // 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: "mcp-failed",
+            id: "answer-1",
             type: "mcp_tool_call",
-            server: "other",
-            tool: "lookup",
+            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`.
+        name: "failed MCP call without result keeps error message fallback",
+        request: makeRequest3(),
+        nativeStream: [
+          threadStarted(NEW_THREAD_ID),
+          toolFrame("item.completed", {
+            id: "mcp-failed",
+            type: "mcp_tool_call",
+            server: "other",
+            tool: "lookup",
             arguments: { q: "receipt" },
             status: "failed",
             result: { content: [], isError: true },
@@ -6485,6 +6731,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "mcp-failed",
             name: "other.lookup",
+            mcpServer: "other",
             phase: "start",
             summary: "receipt",
             input: { q: "receipt" }
@@ -6493,6 +6740,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "mcp-failed",
             name: "other.lookup",
+            mcpServer: "other",
             phase: "error",
             summary: "receipt",
             input: { q: "receipt" },
@@ -6529,6 +6777,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "mcp-image",
             name: "other.render",
+            mcpServer: "other",
             phase: "start",
             summary: "",
             input: {}
@@ -6537,6 +6786,7 @@ var init_conformance4 = __esm({
             type: "tool",
             id: "mcp-image",
             name: "other.render",
+            mcpServer: "other",
             phase: "done",
             summary: "",
             input: {},
@@ -6584,11 +6834,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" },
@@ -7582,11 +7841,10 @@ function required(env, name) {
 function runnerPlace(env) {
   const workRoot2 = env[PLACE_ENV.workRoot];
   const transcriptDir = env[PLACE_ENV.transcriptDir];
-  const box = env[PLACE_ENV.box];
   return {
     ...workRoot2 ? { workRoot: workRoot2 } : {},
     ...transcriptDir ? { transcriptDir } : {},
-    ...box ? { box } : {}
+    ...env[PLACE_ENV.dedicatedRoot] === "1" ? { dedicatedRoot: true } : {}
   };
 }
 function parseRunnerInput(env, stdin) {
@@ -7671,7 +7929,7 @@ var init_protocol = __esm({
     PLACE_ENV = {
       workRoot: "CABANE_WORK_ROOT",
       transcriptDir: "CABANE_TRANSCRIPT_DIR",
-      box: "CABANE_BOX"
+      dedicatedRoot: "CABANE_WORK_ROOT_DEDICATED"
     };
     runtimeHealthSchema = z14.object({
       quotaState: z14.enum(["ok", "limited", "auth_expired", "unknown"]),
@@ -7729,568 +7987,157 @@ var init_protocol = __esm({
   }
 });
 
-// src/runner/launch.ts
-import { createInterface } from "readline";
-function selfRunnerCommand() {
-  const script = process.argv[1];
-  if (!script) throw new Error("runner: cannot tell which script started this companion");
-  return [process.execPath, ...process.execArgv, script, "run-turn"];
+// src/grants.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { join as join14 } from "path";
+import { z as z15 } from "zod";
+function allowedGrantVariable(name) {
+  return name.length <= 100 && VARIABLE_NAME_RE.test(name) && !name.startsWith("CABANE_");
 }
-function wrappedRunnerCommand(prefix, own) {
-  return [...prefix ?? [], ...own];
+function environmentSafe(value) {
+  return !value.includes("\0");
 }
-function runnerExecEnv(base, boxed) {
-  const env = {};
-  for (const [k, v] of Object.entries(base)) {
-    if (v === void 0) continue;
-    if (boxed && BOXED_ENV_DROPPED.includes(k)) continue;
-    env[k] = v;
-  }
-  return env;
+function grantsPath() {
+  return join14(cabaneDir(), "grants.json");
 }
-function healthSnapshot(store) {
+function readGrants(keys, report) {
+  if (keys.length === 0) return {};
+  const file = loadGrantsFile(report);
   const out = {};
-  for (const r of store?.reports() ?? []) {
-    out[r.runtime] = {
-      quotaState: r.quotaState ?? "unknown",
-      limitedUntil: r.limitedUntil ?? null,
-      lastError: r.lastError ?? null
-    };
+  for (const key of keys) {
+    if (!allowedGrantVariable(key) || !Object.hasOwn(file, key)) continue;
+    const entry = {};
+    for (const [variable, value] of Object.entries(file[key])) {
+      if (allowedGrantVariable(variable) && environmentSafe(value)) entry[variable] = value;
+      else report.refusedVariable(key, variable);
+    }
+    out[key] = entry;
   }
   return out;
 }
-function runnerSpec(opts, launch, duties, runnerId) {
-  return {
-    runnerId,
-    ...opts.deviceId ? { deviceId: opts.deviceId } : {},
-    bootId,
-    workspaceId: opts.workspaceId,
-    workspaceSlug: opts.workspaceSlug,
-    agentId: opts.agentId,
-    agentUsername: opts.agentUsername,
-    agentName: String(opts.log.bindings().agentName ?? opts.agentUsername),
-    local: opts.local,
-    runConfig: opts.runConfig,
-    workRoot: opts.workRoot,
-    ...opts.opencodeServerUrl ? { opencodeServerUrl: opts.opencodeServerUrl } : {},
-    // Read now, per turn, the way adapter selection reads them.
-    claudeCodeAvailable: opts.claudeCodeAvailable?.() ?? true,
-    codexAvailable: opts.codexAvailable?.() ?? false,
-    ...opts.idleTimeoutMs !== void 0 ? { idleTimeoutMs: opts.idleTimeoutMs } : {},
-    ...opts.totalTimeoutMs !== void 0 ? { totalTimeoutMs: opts.totalTimeoutMs } : {},
-    ...opts.leaseRenewalMs !== void 0 ? { leaseRenewalMs: opts.leaseRenewalMs } : {},
-    ...opts.preparingRowDelayMs !== void 0 ? { preparingRowDelayMs: opts.preparingRowDelayMs } : {},
-    transcripts: opts.transcriptDir !== void 0,
-    logLevel: opts.log.level,
-    connectorHealth: healthSnapshot(launch.connectorHealth),
-    sessionWriteNoticeClaimed: duties.sessionWriteNoticeClaimed()
-  };
-}
-function relayRunnerLog(line, log2) {
-  if (!line.trim()) return;
-  let record = null;
+function loadGrantsFile(report) {
+  const path = grantsPath();
+  if (!existsSync9(path)) return {};
+  let raw;
   try {
-    const parsed = JSON.parse(line);
-    if (parsed && typeof parsed === "object") record = parsed;
+    raw = readFileSync7(path, "utf8");
+  } catch (err) {
+    const code = err.code ?? "unknown error";
+    report.unreadable(`couldn't read ${path}: ${code}`);
+    return {};
+  }
+  if (raw.trim().length === 0) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
   } catch {
-    record = null;
+    report.unreadable(`${path} is not valid JSON.`);
+    return {};
   }
-  if (!record || typeof record.level !== "number") {
-    log2.debug({ runnerStderr: line }, "runner: output");
-    return;
+  const result = grantsFileSchema.safeParse(parsed);
+  if (!result.success) {
+    report.unreadable(
+      `${path} must map a secret's variable name to an object of "VARIABLE": "value" pairs (e.g. { "HAS_STAGING_DB": { "DATABASE_URL": "postgres://\u2026" } }).`
+    );
+    return {};
   }
-  const {
-    level,
-    msg,
-    time: _time,
-    pid: _pid,
-    hostname: _hostname,
-    agentName: _agentName,
-    ...fields
-  } = record;
-  const method = PINO_LEVELS[level] ?? "info";
-  log2[method](fields, typeof msg === "string" ? msg : "");
+  return result.data;
 }
-function lines(stream, onLine) {
-  const rl = createInterface({ input: stream, crlfDelay: Infinity });
-  rl.on("line", onLine);
-  return new Promise((resolve2) => rl.once("close", resolve2));
+function harnessSecretEnv(parts) {
+  const env = {};
+  const dropped = [];
+  for (const [name, value] of Object.entries({
+    ...parts.deviceDefaults,
+    ...parts.granted,
+    ...parts.issued
+  })) {
+    if (environmentSafe(value)) env[name] = value;
+    else dropped.push(name);
+  }
+  return { env, dropped };
 }
-function giveBackLocks(locks, prefix, remote, launch, log2) {
-  locks.withdraw(prefix);
-  const stop2 = launch.stopRemoteSession ?? ((url, id) => stopRemoteOpencodeSession(url, id));
-  for (const { key, owner } of locks.heldBy(prefix)) {
-    const left = remote.filter((r) => opencodeLockKey(r.serverUrl) === key);
-    if (!left.length) {
-      locks.release(owner);
-      continue;
+function grantEnv(sent, issuedBySecret, issued) {
+  const env = {};
+  for (const [key, entry] of Object.entries(sent ?? {})) {
+    if (!Object.hasOwn(issuedBySecret, key)) continue;
+    for (const [variable, value] of Object.entries(entry)) {
+      if (Object.hasOwn(issued, variable) || Object.hasOwn(env, variable)) continue;
+      env[variable] = value;
     }
-    void (async () => {
-      for (let attempt = 1; ; attempt++) {
-        const stopped = await Promise.all(left.map((r) => stop2(r.serverUrl, r.sessionId))).catch(
-          () => [false]
-        );
-        if (stopped.every(Boolean)) break;
-        if (attempt === 1)
-          log2.warn(
-            { key, sessions: left.map((r) => r.sessionId) },
-            "runner: a dead runner left work on a shared server that could not be confirmed stopped; holding the server until it is"
-          );
-        await new Promise((resolve2) => setTimeout(resolve2, launch.reconcileRetryMs ?? 5e3));
-      }
-      locks.release(owner);
-    })();
   }
+  return env;
 }
-async function mintForRunner(opts, payload, handleOpts, signal, log2) {
-  try {
-    const minted = await opts.api.mintRunnerCredential({
-      conversationId: payload.conversationId,
-      messageId: payload.messageId,
-      ...payload.episode !== void 0 ? { episode: payload.episode } : {},
-      // The one turn the credential will operate: this run's.
-      turnId: handleOpts.turnId
-    });
-    return {
-      ok: true,
-      credential: minted.credential,
-      runnerId: minted.runnerId,
-      deviceGrants: minted.deviceGrants ?? []
-    };
-  } catch (err) {
-    if (signal.aborted) return { ok: false, reason: "cancelled" };
-    const status2 = err instanceof ApiError ? err.status : 0;
-    if (status2 === 404) return { ok: false, reason: "runner_credential_not_found" };
-    if (status2 === 409 && apiErrorCode(err) === "dispatch_not_admitted")
-      return { ok: false, reason: "runner_credential_not_admitted" };
-    log2.warn(apiErrorLogFields(err), "runner: couldn't get a credential for the turn's runner");
-    const reason = `fetch_failed: ${describeError(err)}`;
-    return { ok: false, reason, errorReason: reason };
+var VARIABLE_NAME_RE, grantsFileSchema;
+var init_grants = __esm({
+  "src/grants.ts"() {
+    "use strict";
+    init_config();
+    VARIABLE_NAME_RE = /^[A-Z_][A-Z0-9_]*$/;
+    grantsFileSchema = z15.record(z15.string(), z15.record(z15.string(), z15.string()));
   }
+});
+
+// src/work-dir.ts
+import { statSync as statSync3 } from "fs";
+import { join as join15 } from "path";
+function pairDirectory(root, pair) {
+  return join15(root, pair.workspaceSlug, pair.agentUsername, pair.conversationId);
 }
-async function settleUnstarted(opts, payload, turnId, errorReason, log2) {
+function chooseStandingDirectory(named, pairDir, isDirectory = directoryExists) {
+  const skipped = [];
+  for (const candidate of named) {
+    if (isDirectory(candidate.path)) return { cwd: candidate.path, skipped };
+    skipped.push(candidate);
+  }
+  return { cwd: pairDir, skipped };
+}
+function directoryExists(path) {
   try {
-    await opts.api.setActiveRun(opts.workspaceId, payload.conversationId, payload.agentId, {
-      activeRunStartedAt: null,
-      turnId,
-      outcome: "failed",
-      ...errorReason ? { errorReason: errorReason.slice(0, ERROR_REASON_MAX) } : {},
-      readThrough: payload.messageId
-    });
-  } catch (err) {
-    log2.warn(
-      { ...apiErrorLogFields(err), turnId },
-      "Couldn't update the turn's status in Cabane. Check the conversation before trying again."
-    );
+    return statSync3(path).isDirectory();
+  } catch {
+    return false;
   }
 }
-async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
-  const startedAt = Date.now();
-  const { turnId } = handleOpts;
-  const oomKilled = (id) => (launch.oomKilled ?? turnScopeOomKilled)(id).catch(() => false);
-  const log2 = opts.log.child({
-    workspaceId: opts.workspaceId,
-    conversationId: payload.conversationId,
-    agentId: payload.agentId,
-    messageId: payload.messageId
-  });
-  const controller = new AbortController();
-  duties.registerAbort(turnId, controller);
-  const stopRunner = new AbortController();
-  let ready = false;
-  let child;
-  let stopAnnounced = false;
-  const announceStop = () => {
-    if (stopAnnounced || !child?.stdin.writable) return;
-    stopAnnounced = true;
-    child.stdin.write(encodeLauncherMessage({ cabaneLauncher: "stop" }));
-  };
-  const forwardStop = () => {
-    announceStop();
-    if (ready) stopRunner.abort();
-  };
-  controller.signal.addEventListener("abort", forwardStop, { once: true });
-  const attempt = {
-    workspaceId: opts.workspaceId,
-    conversationId: payload.conversationId,
-    agentId: payload.agentId,
-    turnId
-  };
-  const minted = await mintForRunner(opts, payload, handleOpts, controller.signal, log2);
-  if (!minted.ok) {
-    controller.signal.removeEventListener("abort", forwardStop);
-    duties.releaseAbort(turnId, controller);
-    const durationMs2 = Date.now() - startedAt;
-    await settleUnstarted(opts, payload, turnId, minted.errorReason, log2);
-    duties.notifyEnd({ id: payload.messageId, ok: false, durationMs: durationMs2, reason: minted.reason });
-    return { ok: false, durationMs: durationMs2, reason: minted.reason };
+var init_work_dir = __esm({
+  "src/work-dir.ts"() {
+    "use strict";
   }
+});
+
+// src/turn-control-tools.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { z as z16 } from "zod";
+function createSkipState() {
+  return { skipped: false, reason: null };
+}
+function toolError(text) {
+  return { isError: true, content: [{ type: "text", text }] };
+}
+async function performAct(acts, act) {
   let result;
-  let thrown;
-  let code;
-  let handle;
-  const groups = [];
-  const remote = [];
-  const lockOwner = (id) => `${turnId}#${id}`;
-  const locks = launch.locks;
-  try {
-    handle = await launch.provider.acquire(attempt);
-  } catch (err) {
-    const reason2 = `runner_unavailable: ${describeError(err)}`;
-    log2.warn(
-      { turnId, provider: launch.provider.name, err: describeError(err) },
-      "runner: no place to run the turn"
-    );
-    controller.signal.removeEventListener("abort", forwardStop);
-    duties.releaseAbort(turnId, controller);
-    await settleUnstarted(opts, payload, turnId, reason2, log2);
-    await launch.reportRunnerGone?.({
-      workspaceId: opts.workspaceId,
-      conversationId: payload.conversationId,
-      agentId: payload.agentId,
-      messageId: payload.messageId,
-      runnerId: minted.runnerId,
-      reason: "provider_failed"
-    });
-    const durationMs2 = Date.now() - startedAt;
-    duties.notifyEnd({ id: payload.messageId, ok: false, durationMs: durationMs2, reason: reason2 });
-    return { ok: false, durationMs: durationMs2, reason: reason2 };
-  }
   try {
-    const boxed = launch.boxed === true;
-    const env = runnerExecEnv(launch.env ?? process.env, boxed);
-    const grants = minted.deviceGrants.length > 0 ? launch.grants?.(minted.deviceGrants) ?? {} : {};
-    const input = {
-      baseUrl: opts.baseUrl,
-      credential: minted.credential,
-      ...boxed ? { secrets: launch.secrets?.() ?? {} } : {},
-      ...Object.keys(grants).length > 0 ? { grants } : {},
-      dispatch: payload,
-      turnId,
-      resumed: handleOpts.resumed,
-      spec: runnerSpec(opts, launch, duties, minted.runnerId)
-    };
-    Object.assign(env, runnerEnv(input));
-    const running = launch.provider.exec(handle, launch.command, env, {
-      signal: stopRunner.signal,
-      stdin: runnerStdin(input)
-    });
-    child = running;
-    if (controller.signal.aborted) announceStop();
-    log2.debug(
-      { turnId, runnerPid: running.pid, provider: launch.provider.name },
-      "runner: started"
-    );
-    const stdoutDone = lines(running.stdout, (line) => {
-      const event = decodeRunnerEvent(line);
-      if (!event) {
-        log2.debug({ runnerStdout: line }, "runner: output");
-        return;
-      }
-      switch (event.cabaneRunner) {
-        case "ready":
-          ready = true;
-          if (controller.signal.aborted) stopRunner.abort();
-          return;
-        case "start":
-          duties.notifyStart({
-            id: event.id,
-            conversationId: event.conversationId,
-            message: event.message
-          });
-          return;
-        case "end": {
-          const { cabaneRunner: _kind, ...info } = event;
-          duties.notifyEnd(info);
-          return;
-        }
-        case "session_write_notice":
-          duties.markSessionWriteNotice();
-          return;
-        case "connector_health":
-          launch.connectorHealth?.recordSettle(event.runtime, {
-            ok: event.ok,
-            errorReason: event.errorReason
-          });
-          return;
-        case "result":
-          result = event.result;
-          return;
-        case "error":
-          thrown = event.message;
-          return;
-        case "lock":
-          if (!locks) {
-            log2.warn(
-              { key: event.key },
-              "runner: asked for a device lock this launcher has none of"
-            );
-            return;
-          }
-          locks.request(
-            event.key,
-            lockOwner(event.id),
-            () => running.stdin.write(encodeLauncherMessage({ cabaneLauncher: "granted", id: event.id }))
-          );
-          return;
-        case "unlock":
-          locks?.release(lockOwner(event.id));
-          return;
-        case "process_group":
-          if (!boxed) groups.push(event.pgid);
-          return;
-        case "remote_session":
-          remote.push({ serverUrl: event.serverUrl, sessionId: event.sessionId });
-          return;
-        case "terminated":
-          void oomKilled(turnId).then((oom) => {
-            if (running.stdin.writable) {
-              running.stdin.write(
-                encodeLauncherMessage({
-                  cabaneLauncher: "cause",
-                  cause: oom ? "out_of_memory" : null
-                })
-              );
-            }
-          });
-          return;
-      }
-    });
-    const stderrDone = lines(running.stderr, (line) => relayRunnerLog(line, opts.log));
-    code = await running.exit;
-    await Promise.all([stdoutDone, stderrDone]);
-  } finally {
-    if (locks) giveBackLocks(locks, `${turnId}#`, remote, launch, log2);
-    child?.stdin.end();
-    controller.signal.removeEventListener("abort", forwardStop);
-    duties.releaseAbort(turnId, controller);
-    await launch.provider.release(handle, { destroy: false }).catch(
-      (err) => log2.warn({ err: describeError(err) }, "runner: couldn't give its place back")
-    );
-  }
-  if (result) return result;
-  const durationMs = Date.now() - startedAt;
-  const stopped = controller.signal.aborted && thrown === void 0;
-  const reason = stopped ? "cancelled" : thrown !== void 0 ? `runner_failed: ${thrown}` : await oomKilled(turnId) ? "out_of_memory" : `runner_exited: ${code}`;
-  await child?.reap(groups);
-  const reaped = await (launch.reapTurn ?? reapTurnScopes)(turnId).catch((err) => ({
-    failures: [err instanceof Error ? err.message : String(err)]
-  }));
-  if (reaped.failures.length) {
-    log2.warn(
-      { turnId, failures: reaped.failures },
-      "runner: couldn't stop what the dead runner's turn left running"
+    result = await acts.api.turnAct(
+      acts.workspaceId,
+      acts.turnId,
+      act,
+      AbortSignal.timeout(TURN_ACT_TIMEOUT_MS)
     );
-  }
-  try {
-    await opts.api.setActiveRun(opts.workspaceId, payload.conversationId, payload.agentId, {
-      activeRunStartedAt: null,
-      turnId,
-      ...stopped ? { outcome: "interrupted" } : { outcome: "failed", errorReason: reason.slice(0, ERROR_REASON_MAX) },
-      readThrough: payload.messageId
-    });
   } catch (err) {
-    log2.warn(
-      { ...apiErrorLogFields(err), turnId },
-      "Couldn't update the turn's status in Cabane. Check the conversation before trying again."
-    );
+    if (err instanceof ApiError && err.status >= 500) {
+      return uncertainOutcome(`${err.status}: ${apiErrorMessage(err)}`);
+    }
+    if (err instanceof ApiError) {
+      if (err.status === 409 && apiErrorCode(err) === "no_active_turn") {
+        return toolError(
+          "No active turn: this turn has already settled, so the act was not performed."
+        );
+      }
+      return toolError(`The act was refused (${err.status}): ${apiErrorMessage(err)}`);
+    }
+    return uncertainOutcome(err instanceof Error ? err.message : String(err));
   }
-  await launch.reportRunnerGone?.({
-    workspaceId: opts.workspaceId,
-    conversationId: payload.conversationId,
-    agentId: payload.agentId,
-    messageId: payload.messageId,
-    runnerId: minted.runnerId,
-    reason: "exited"
-  });
-  if (thrown !== void 0) throw new Error(thrown);
-  if (stopped) log2.info({ turnId, code }, "runner: stopped before it could report");
-  else log2.warn({ turnId, code }, "runner: exited without reporting a result");
-  duties.notifyEnd({ id: payload.messageId, ok: false, durationMs, reason });
-  return { ok: false, durationMs, reason };
-}
-var BOXED_ENV_DROPPED, PINO_LEVELS;
-var init_launch = __esm({
-  "src/runner/launch.ts"() {
-    "use strict";
-    init_src();
-    init_opencode_lock();
-    init_api_error_shape();
-    init_errors();
-    init_boot_id();
-    init_turn_containment();
-    init_protocol();
-    BOXED_ENV_DROPPED = [
-      "ANTHROPIC_API_KEY",
-      "CLAUDE_CODE_OAUTH_TOKEN",
-      "CODEX_API_KEY",
-      "GH_TOKEN",
-      "GITHUB_TOKEN",
-      "DBUS_SESSION_BUS_ADDRESS",
-      "XDG_RUNTIME_DIR"
-    ];
-    PINO_LEVELS = {
-      10: "trace",
-      20: "debug",
-      30: "info",
-      40: "warn",
-      50: "error",
-      60: "fatal"
-    };
-  }
-});
-
-// src/grants.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { join as join14 } from "path";
-import { z as z15 } from "zod";
-function allowedGrantVariable(name) {
-  return name.length <= 100 && VARIABLE_NAME_RE.test(name) && !name.startsWith("CABANE_");
-}
-function environmentSafe(value) {
-  return !value.includes("\0");
-}
-function grantsPath() {
-  return join14(cabaneDir(), "grants.json");
-}
-function readGrants(keys, report) {
-  if (keys.length === 0) return {};
-  const file = loadGrantsFile(report);
-  const out = {};
-  for (const key of keys) {
-    if (!allowedGrantVariable(key) || !Object.hasOwn(file, key)) continue;
-    const entry = {};
-    for (const [variable, value] of Object.entries(file[key])) {
-      if (allowedGrantVariable(variable) && environmentSafe(value)) entry[variable] = value;
-      else report.refusedVariable(key, variable);
-    }
-    out[key] = entry;
-  }
-  return out;
-}
-function loadGrantsFile(report) {
-  const path = grantsPath();
-  if (!existsSync9(path)) return {};
-  let raw;
-  try {
-    raw = readFileSync7(path, "utf8");
-  } catch (err) {
-    const code = err.code ?? "unknown error";
-    report.unreadable(`couldn't read ${path}: ${code}`);
-    return {};
-  }
-  if (raw.trim().length === 0) return {};
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    report.unreadable(`${path} is not valid JSON.`);
-    return {};
-  }
-  const result = grantsFileSchema.safeParse(parsed);
-  if (!result.success) {
-    report.unreadable(
-      `${path} must map a secret's variable name to an object of "VARIABLE": "value" pairs (e.g. { "HAS_PROD_ACCESS": { "RENDER_API_KEY": "rnd_\u2026" } }).`
-    );
-    return {};
-  }
-  return result.data;
-}
-function harnessSecretEnv(parts) {
-  const env = {};
-  const dropped = [];
-  for (const [name, value] of Object.entries({
-    ...parts.deviceDefaults,
-    ...parts.granted,
-    ...parts.issued
-  })) {
-    if (environmentSafe(value)) env[name] = value;
-    else dropped.push(name);
-  }
-  return { env, dropped };
-}
-function grantEnv(sent, issuedBySecret, issued) {
-  const env = {};
-  for (const [key, entry] of Object.entries(sent ?? {})) {
-    if (!Object.hasOwn(issuedBySecret, key)) continue;
-    for (const [variable, value] of Object.entries(entry)) {
-      if (Object.hasOwn(issued, variable) || Object.hasOwn(env, variable)) continue;
-      env[variable] = value;
-    }
-  }
-  return env;
-}
-var VARIABLE_NAME_RE, grantsFileSchema;
-var init_grants = __esm({
-  "src/grants.ts"() {
-    "use strict";
-    init_config();
-    VARIABLE_NAME_RE = /^[A-Z_][A-Z0-9_]*$/;
-    grantsFileSchema = z15.record(z15.string(), z15.record(z15.string(), z15.string()));
-  }
-});
-
-// src/work-dir.ts
-import { statSync as statSync3 } from "fs";
-import { join as join15 } from "path";
-function pairDirectory(root, pair) {
-  return join15(root, pair.workspaceSlug, pair.agentUsername, pair.conversationId);
-}
-function chooseStandingDirectory(named, pairDir, isDirectory = directoryExists) {
-  const skipped = [];
-  for (const candidate of named) {
-    if (isDirectory(candidate.path)) return { cwd: candidate.path, skipped };
-    skipped.push(candidate);
-  }
-  return { cwd: pairDir, skipped };
-}
-function directoryExists(path) {
-  try {
-    return statSync3(path).isDirectory();
-  } catch {
-    return false;
-  }
-}
-var init_work_dir = __esm({
-  "src/work-dir.ts"() {
-    "use strict";
-  }
-});
-
-// src/turn-control-tools.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { z as z16 } from "zod";
-function createSkipState() {
-  return { skipped: false, reason: null };
-}
-function toolError(text) {
-  return { isError: true, content: [{ type: "text", text }] };
-}
-async function performAct(acts, act) {
-  let result;
-  try {
-    result = await acts.api.turnAct(
-      acts.workspaceId,
-      acts.turnId,
-      act,
-      AbortSignal.timeout(TURN_ACT_TIMEOUT_MS)
-    );
-  } catch (err) {
-    if (err instanceof ApiError && err.status >= 500) {
-      return uncertainOutcome(`${err.status}: ${apiErrorMessage(err)}`);
-    }
-    if (err instanceof ApiError) {
-      if (err.status === 409 && apiErrorCode(err) === "no_active_turn") {
-        return toolError(
-          "No active turn: this turn has already settled, so the act was not performed."
-        );
-      }
-      return toolError(`The act was refused (${err.status}): ${apiErrorMessage(err)}`);
-    }
-    return uncertainOutcome(err instanceof Error ? err.message : String(err));
-  }
-  if (!result.ok) return toolError(JSON.stringify(result));
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  if (!result.ok) return toolError(JSON.stringify(result));
+  return { content: [{ type: "text", text: JSON.stringify(result) }] };
 }
 function uncertainOutcome(cause) {
   return toolError(
@@ -8428,6 +8275,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 +8294,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 +8302,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";
@@ -8713,73 +8568,6 @@ var init_turn_seq_floor = __esm({
   }
 });
 
-// src/prepare-failure.ts
-import { spawn as spawn4 } from "child_process";
-import { hostname } from "os";
-function prepareFailureCause(error) {
-  const message2 = error instanceof Error ? error.message : String(error);
-  if (/timed out/i.test(message2)) return "prepare hook timed out";
-  if (/MODULE_NOT_FOUND|Cannot find (?:module|package)/.test(message2))
-    return "prepare hook module missing; check the configured command and its installation for this device";
-  if (/not valid JSON|JSON must carry|produced no output/.test(message2))
-    return "prepare hook returned malformed output; expected a cwd path or JSON with a non-empty cwd";
-  if (/ENOENT/.test(message2)) return "prepare hook executable missing (ENOENT)";
-  if (/EACCES/.test(message2)) return "prepare hook executable is not accessible (EACCES)";
-  const exit = message2.match(/exited with code (\d+)/)?.[1];
-  return exit ? `prepare hook exited with code ${exit}` : "prepare hook failed; inspect the device-local hook log";
-}
-async function runPrepareWithReporting(runner, hook, input, context, reportError) {
-  try {
-    return await runner(hook, input);
-  } catch (error) {
-    if (hook.failureReporter) {
-      try {
-        await reportFailure(hook.failureReporter, {
-          workspaceId: input.workspaceId,
-          conversationId: input.conversationId,
-          agentId: input.agentId,
-          agentUsername: input.agentUsername,
-          turnId: context.turnId,
-          deviceId: context.deviceId ?? hostname(),
-          cause: prepareFailureCause(error)
-        });
-      } catch {
-        reportError();
-      }
-    }
-    throw error;
-  }
-}
-function reportFailure(config, body) {
-  return new Promise((resolve2, reject) => {
-    const child = spawn4(config.command, config.args ?? [], {
-      stdio: ["pipe", "ignore", "ignore"],
-      env: { ...process.env, ...config.env }
-    });
-    const timer = setTimeout(() => {
-      child.kill("SIGKILL");
-      reject(new Error("reporter timeout"));
-    }, config.timeoutMs ?? 15e3);
-    child.stdin.on("error", () => {
-    });
-    child.once("error", () => {
-      clearTimeout(timer);
-      reject(new Error("reporter failed to start"));
-    });
-    child.once("close", (code) => {
-      clearTimeout(timer);
-      if (code === 0) resolve2();
-      else reject(new Error("reporter failed"));
-    });
-    child.stdin.end(JSON.stringify(body));
-  });
-}
-var init_prepare_failure = __esm({
-  "src/prepare-failure.ts"() {
-    "use strict";
-  }
-});
-
 // src/prepared.ts
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, rmSync as rmSync5, writeFileSync as writeFileSync5, existsSync as existsSync10 } from "fs";
 import { join as join19 } from "path";
@@ -9111,7 +8899,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 +8909,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 +8972,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 +8996,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;
       }
@@ -9317,7 +9110,7 @@ var init_turn_runtime_integrity = __esm({
 
 // src/turn-execution.ts
 import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
-import { mkdirSync as mkdirSync9 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9 } from "fs";
 function resolveIdleTimeoutMs(override) {
   return override ?? DEFAULT_AGENT_IDLE_TIMEOUT_MS;
 }
@@ -9374,7 +9167,6 @@ var init_turn_execution = __esm({
     init_errors();
     init_turn_seq_floor();
     init_prepare_hook();
-    init_prepare_failure();
     init_prepared();
     init_secrets();
     init_turn_env();
@@ -9383,7 +9175,6 @@ var init_turn_execution = __esm({
     init_turn_containment();
     init_turn_committer();
     init_turn_runtime_integrity();
-    init_dispatcher();
     PREPARING_TOOL_NAME = "preparing";
     HARNESS_UNAVAILABLE_NOTICE = "**This harness isn't available on the companion.** Check the harness on the device, or choose another harness in the agent's settings. Then reply to try again.";
     NO_TURN_TOKEN_REASON = "no_turn_token: the server issued no turn credential for this turn";
@@ -9442,6 +9233,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 +9424,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 +9479,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
@@ -9764,7 +9572,7 @@ var init_turn_execution = __esm({
       async prepareEnvironment() {
         const { payload, workspaceId, turnId, turnLog } = this;
         const prepareHook = this.opts.local.prepareHook;
-        const pairDir = this.opts.boxed ? this.opts.workRoot : pairDirectory(this.opts.workRoot, {
+        const pairDir = this.opts.dedicatedRoot ? this.opts.workRoot : pairDirectory(this.opts.workRoot, {
           workspaceSlug: this.opts.workspaceSlug,
           agentUsername: this.opts.agentUsername,
           conversationId: payload.conversationId
@@ -9792,10 +9600,10 @@ var init_turn_execution = __esm({
         let hookEnv;
         if (prepareHook) {
           let cached2 = readPrepared(workspaceId, payload.conversationId, payload.agentId);
-          if (cached2 && !checkoutState(cached2.cwd).ok) {
+          if (cached2 && !existsSync12(cached2.cwd)) {
             turnLog.debug(
-              { cwd: cached2.cwd, reason: checkoutState(cached2.cwd).reason },
-              "dispatcher: the prepared checkout is no longer usable \u2014 re-running the prepare hook to restore it"
+              { cwd: cached2.cwd },
+              "dispatcher: the prepared directory is gone \u2014 re-running the prepare hook"
             );
             clearPrepared(workspaceId, payload.conversationId, payload.agentId);
             cached2 = null;
@@ -9803,38 +9611,6 @@ var init_turn_execution = __esm({
           if (cached2) {
             effectiveCwd = cached2.cwd;
             hookEnv = cached2.env;
-            if (prepareHook.validateCached) {
-              const runHook = this.opts.prepareHookRunner ?? runPrepareHook;
-              try {
-                await runPrepareWithReporting(
-                  runHook,
-                  prepareHook,
-                  {
-                    workspaceId,
-                    conversationId: payload.conversationId,
-                    agentId: payload.agentId,
-                    agentUsername: this.opts.agentUsername,
-                    defaultCwd: pairDir,
-                    runtime: this.turnContext.runtime,
-                    triggerEntryPaths: this.turnContext.conversation.triggerEntryPaths ?? [],
-                    title: this.turnContext.conversation.title,
-                    messageBody: this.turnContext.message.body,
-                    prepared: cached2
-                  },
-                  { turnId, deviceId: this.opts.deviceId },
-                  () => {
-                    turnLog.error(
-                      "dispatcher: prepare failure reporter failed; original failure preserved"
-                    );
-                  }
-                );
-              } catch (err) {
-                const reason = err instanceof Error ? err.message : String(err);
-                turnLog.debug({ err: reason }, "dispatcher: prepare hook rejected a prepared turn");
-                const failReason = `prepare_failed: ${reason}`;
-                throw this.concluded(failReason, failReason);
-              }
-            }
           } else {
             const delayMs = this.opts.preparingRowDelayMs ?? DEFAULT_PREPARING_ROW_DELAY_MS;
             let preparingStarted = false;
@@ -9866,33 +9642,17 @@ var init_turn_execution = __esm({
             preparingTimer.unref?.();
             const runHook = this.opts.prepareHookRunner ?? runPrepareHook;
             try {
-              const result = await runPrepareWithReporting(
-                runHook,
-                prepareHook,
-                {
-                  workspaceId,
-                  conversationId: payload.conversationId,
-                  agentId: payload.agentId,
-                  agentUsername: this.opts.agentUsername,
-                  // The pair's own directory, already made, for a hook that only
-                  // wants to add to it.
-                  defaultCwd: pairDir,
-                  runtime: this.turnContext.runtime,
-                  // The trigger message's referenced-entry paths, which a prepare hook
-                  // may key its per-task env off. `[]` from an older API.
-                  triggerEntryPaths: this.turnContext.conversation.triggerEntryPaths ?? [],
-                  title: this.turnContext.conversation.title,
-                  // Where an `env:` directive rides, so a dispatch can ask for its
-                  // environment in words.
-                  messageBody: this.turnContext.message.body
-                },
-                { turnId, deviceId: this.opts.deviceId },
-                () => {
-                  turnLog.error(
-                    "dispatcher: prepare failure reporter failed; original failure preserved"
-                  );
-                }
-              );
+              const result = await runHook(prepareHook, {
+                workspaceId,
+                conversationId: payload.conversationId,
+                agentId: payload.agentId,
+                agentUsername: this.opts.agentUsername,
+                // The pair's own directory, already made, for a hook that only
+                // wants to add to it.
+                defaultCwd: pairDir,
+                runtime: this.turnContext.runtime,
+                title: this.turnContext.conversation.title
+              });
               clearTimeout(preparingTimer);
               if (preparingStarted) reportPreparing("done");
               writePrepared(workspaceId, payload.conversationId, payload.agentId, result);
@@ -10188,6 +9948,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
@@ -10537,171 +10299,38 @@ var init_turn_execution = __esm({
   }
 });
 
-// src/dispatcher.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync12, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
+// src/outbox.ts
+import {
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync10,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync11,
+  renameSync as renameSync5,
+  rmSync as rmSync7,
+  writeFileSync as writeFileSync6
+} from "fs";
 import { join as join22 } from "path";
-function checkoutState(cwd) {
-  if (!cwd) return { ok: false, reason: "no working directory was resolved for this turn" };
-  if (!existsSync12(cwd)) return { ok: false, reason: `the working directory is gone (${cwd})` };
-  let entries;
-  try {
-    entries = readdirSync2(cwd);
-  } catch (error) {
-    return { ok: false, reason: `${cwd} is unreadable (${error.message})` };
-  }
-  if (entries.length === 0) {
-    return { ok: false, reason: `${cwd} is empty \u2014 a recreated shell, not a prepared directory` };
-  }
-  const gitPath = join22(cwd, ".git");
-  if (!existsSync12(gitPath)) return { ok: true, reason: "usable" };
-  let stat;
-  try {
-    stat = statSync4(gitPath);
-  } catch (error) {
-    return { ok: false, reason: `${gitPath} is unreadable (${error.message})` };
-  }
-  if (stat.isDirectory() && !existsSync12(join22(gitPath, "HEAD")))
-    return { ok: false, reason: `${gitPath} has no HEAD \u2014 an empty shell, not a checkout` };
-  return { ok: true, reason: "usable" };
-}
-function runKey(conversationId, agentId) {
-  return `${conversationId}|${agentId}`;
-}
-var Dispatcher;
-var init_dispatcher = __esm({
-  "src/dispatcher.ts"() {
+var MAX_ENTRIES, MAX_AGE_MS, Outbox;
+var init_outbox = __esm({
+  "src/outbox.ts"() {
     "use strict";
-    init_launch();
-    init_turn_execution();
-    Dispatcher = class {
-      constructor(opts) {
-        this.opts = opts;
-        this.aborts = opts.aborts ?? /* @__PURE__ */ new Map();
+    init_config();
+    MAX_ENTRIES = 2e3;
+    MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+    Outbox = class {
+      constructor(workspaceId, log2) {
+        this.workspaceId = workspaceId;
+        this.log = log2;
       }
-      opts;
-      // (conversation|agent) → per-turn controllers. A delayed cancel for an old
-      // turn must never reach its successor.
-      aborts;
-      // Pairs already told their session couldn't be saved: the notice is once per
-      // pair, while the rejection repeats every turn.
-      sessionWriteNotified = /* @__PURE__ */ new Set();
-      notifyStart(info) {
-        try {
-          this.opts.observer?.onStart(info);
-        } catch {
-        }
-      }
-      notifyEnd(info) {
-        try {
-          this.opts.observer?.onEnd(info);
-        } catch {
-        }
-      }
-      // The supervisor supplies a stable turnId on both fresh and resumed dispatch.
-      // resumed is separate: only replay seeds sequence/speech recovery from the
-      // prior span. A direct caller omitting turnId gets a fresh id.
-      async handle(payload, opts = {}) {
-        const key = runKey(payload.conversationId, payload.agentId);
-        return runTurnInRunner(
-          this.opts.turn,
-          this.opts.runner,
-          {
-            registerAbort: (turnId, controller) => {
-              let pairAborts = this.aborts.get(key);
-              if (!pairAborts) {
-                pairAborts = /* @__PURE__ */ new Map();
-                this.aborts.set(key, pairAborts);
-              }
-              pairAborts.set(turnId, controller);
-            },
-            releaseAbort: (turnId, controller) => {
-              const pair = this.aborts.get(key);
-              if (pair?.get(turnId) !== controller) return;
-              pair.delete(turnId);
-              if (pair.size === 0) this.aborts.delete(key);
-            },
-            sessionWriteNoticeClaimed: () => this.sessionWriteNotified.has(key),
-            markSessionWriteNotice: () => {
-              this.sessionWriteNotified.add(key);
-            },
-            notifyStart: (info) => this.notifyStart(info),
-            notifyEnd: (info) => this.notifyEnd(info)
-          },
-          payload,
-          { turnId: opts.turnId ?? randomUUID4(), resumed: opts.resumed === true }
-        );
-      }
-      // Cancel the named turn. An older server omits turnId and cancels the pair.
-      cancel(conversationId, agentId, turnId) {
-        const key = runKey(conversationId, agentId);
-        const pair = this.aborts.get(key);
-        if (!pair || pair.size === 0) return false;
-        const controllers = turnId === void 0 ? [...pair.values()] : [pair.get(turnId)];
-        let aborted = false;
-        for (const ac of controllers) {
-          if (!ac) continue;
-          aborted = true;
-          try {
-            ac.abort();
-          } catch {
-          }
-        }
-        return aborted;
-      }
-      // Abort every run in flight in THIS process, whatever its conversation. For
-      // an agent taken off this device: nothing it is still running here is
-      // legitimate, and a cancel frame that arrives after it is dropped from the
-      // roster finds no dispatcher to reach. True if any was aborted.
-      cancelAll() {
-        let aborted = false;
-        for (const pair of this.aborts.values()) {
-          for (const ac of [...pair.values()]) {
-            try {
-              ac.abort();
-              aborted = true;
-            } catch {
-            }
-          }
-        }
-        return aborted;
-      }
-    };
-  }
-});
-
-// src/outbox.ts
-import {
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync10,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync11,
-  renameSync as renameSync5,
-  rmSync as rmSync7,
-  writeFileSync as writeFileSync6
-} from "fs";
-import { join as join23 } from "path";
-var MAX_ENTRIES, MAX_AGE_MS, Outbox;
-var init_outbox = __esm({
-  "src/outbox.ts"() {
-    "use strict";
-    init_config();
-    MAX_ENTRIES = 2e3;
-    MAX_AGE_MS = 24 * 60 * 60 * 1e3;
-    Outbox = class {
-      constructor(workspaceId, log2) {
-        this.workspaceId = workspaceId;
-        this.log = log2;
-      }
-      workspaceId;
-      log;
-      // Resolved lazily (per call) so tests that swap HOME between
-      // cases route writes at the right tmpdir.
-      dir() {
-        return join23(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
+      workspaceId;
+      log;
+      // Resolved lazily (per call) so tests that swap HOME between
+      // cases route writes at the right tmpdir.
+      dir() {
+        return join22(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
       }
       fileFor(turnId, seq) {
-        return join23(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
+        return join22(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
       }
       // Persist a commit for later draining. Atomic (temp file + rename) so a
       // concurrent `list()` never reads a half-written entry, then enforces the
@@ -10736,14 +10365,14 @@ var init_outbox = __esm({
         if (!existsSync14(dir2)) return [];
         let names;
         try {
-          names = readdirSync3(dir2);
+          names = readdirSync2(dir2);
         } catch {
           return [];
         }
         const entries = [];
         for (const name of names) {
           if (!name.endsWith(".json")) continue;
-          const full = join23(dir2, name);
+          const full = join22(dir2, name);
           try {
             const parsed = JSON.parse(readFileSync11(full, "utf8"));
             if (parsed && typeof parsed.turnId === "string" && typeof parsed.seq === "number" && typeof parsed.path === "string") {
@@ -10780,7 +10409,7 @@ var init_outbox = __esm({
       maxSeqForTurn(turnId) {
         const dir2 = this.dir();
         if (!existsSync14(dir2)) return 0;
-        const names = readdirSync3(dir2);
+        const names = readdirSync2(dir2);
         const prefix = `${encodeURIComponent(turnId)}__`;
         let max = 0;
         for (const name of names) {
@@ -10801,7 +10430,7 @@ var init_outbox = __esm({
         const dir2 = this.dir();
         if (!existsSync14(dir2)) return 0;
         try {
-          return readdirSync3(dir2).filter((n) => n.endsWith(".json")).length;
+          return readdirSync2(dir2).filter((n) => n.endsWith(".json")).length;
         } catch {
           return 0;
         }
@@ -10850,7 +10479,7 @@ var init_outbox = __esm({
 
 // src/runner/exec-shim.ts
 import { chmodSync as chmodSync6, mkdirSync as mkdirSync18, mkdtempSync, rmSync as rmSync13, writeFileSync as writeFileSync11 } from "fs";
-import { join as join33 } from "path";
+import { join as join32 } from "path";
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -10860,10 +10489,10 @@ function createShimDir() {
   return {
     write(argv) {
       if (!dir2) {
-        mkdirSync18(join33(cabaneDir(), "runner"), { recursive: true });
-        dir2 = mkdtempSync(join33(cabaneDir(), "runner", "turn-"));
+        mkdirSync18(join32(cabaneDir(), "runner"), { recursive: true });
+        dir2 = mkdtempSync(join32(cabaneDir(), "runner", "turn-"));
       }
-      const path = join33(dir2, `exec-${++count}`);
+      const path = join32(dir2, `exec-${++count}`);
       writeFileSync11(path, `#!/bin/sh
 exec ${argv.map(shellQuote).join(" ")} "$@"
 `);
@@ -11030,13 +10659,13 @@ function runnerTurnOptions(input, log2, emit, extras = {}) {
     local: spec.local,
     // The place the runner stands in names its own root and transcript
     // directory when it has them (`PLACE_ENV`); the launcher's host-computed
-    // values are what a runner on the person's own machine gets. A box is one
-    // conversation × agent's, so the turn stands in its root itself.
+    // values are what a runner on the person's own machine gets. A dedicated
+    // root is one conversation × agent's, so the turn stands in it itself.
     workRoot: input.place?.workRoot ?? spec.workRoot,
-    ...input.place?.box ? { boxed: true } : {},
+    ...input.place?.dedicatedRoot ? { dedicatedRoot: true } : {},
     runConfig: spec.runConfig,
-    // The launcher's copy of the device's secrets, when it sent one: a runner
-    // in a box has no `secrets.json` to read.
+    // The launcher's copy of the device's secrets, when it sent one: a wrapped
+    // runner may have no `secrets.json` to read.
     ...input.secrets ? { secretStore: makeStore(input.secrets) } : {},
     // The grants-file entries the launcher read for this dispatch's turn.
     ...input.grants ? { deviceGrants: input.grants } : {},
@@ -11900,7 +11529,7 @@ async function liveCompanionState() {
 // src/commands/setup.ts
 init_cabane_command();
 init_config();
-import { hostname as hostname3 } from "os";
+import { hostname as hostname2 } from "os";
 
 // src/logger.ts
 init_config();
@@ -12126,8 +11755,8 @@ async function claimSetupCode(baseUrl, input) {
     ..."deviceLabel" in body && typeof body.deviceLabel === "string" ? { deviceLabel: body.deviceLabel } : {}
   };
 }
-function deviceLabelFromHostname(hostname4) {
-  const trimmed = hostname4.trim().replace(/\.local$/i, "");
+function deviceLabelFromHostname(hostname3) {
+  const trimmed = hostname3.trim().replace(/\.local$/i, "");
   return trimmed.length ? trimmed.slice(0, 120) : void 0;
 }
 
@@ -12672,7 +12301,7 @@ var emptyHeartbeatStatus = () => ({
 
 // src/supervisor.ts
 init_cabane_command();
-import { hostname as hostname2 } from "os";
+import { hostname } from "os";
 
 // src/log-copy.ts
 init_failure();
@@ -12898,241 +12527,745 @@ function save(deviceId, map) {
     } catch {
     }
   }
-  const path = devicePath(deviceId);
-  const tmp = `${path}.${process.pid}.tmp`;
-  try {
-    writeFileSync3(tmp, JSON.stringify(map, null, 2) + "\n", { mode: 384 });
+  const path = devicePath(deviceId);
+  const tmp = `${path}.${process.pid}.tmp`;
+  try {
+    writeFileSync3(tmp, JSON.stringify(map, null, 2) + "\n", { mode: 384 });
+    try {
+      chmodSync3(tmp, 384);
+    } catch {
+    }
+    renameSync3(tmp, path);
+  } catch (err) {
+    try {
+      rmSync4(tmp, { force: true });
+    } catch {
+    }
+    throw err;
+  }
+}
+function getCredential(deviceId, agentId) {
+  return load(deviceId)[agentId] ?? null;
+}
+function setCredential(deviceId, agentId, pat) {
+  if (read(devicePath(deviceId))?.[agentId] === pat) return;
+  const map = load(deviceId);
+  map[agentId] = pat;
+  save(deviceId, map);
+}
+function pruneCredentials(deviceId, keepAgentIds) {
+  const keep = new Set(keepAgentIds);
+  if (keep.size === 0) return [];
+  const own = read(devicePath(deviceId));
+  const map = own ?? load(deviceId);
+  const removed = Object.keys(map).filter((id) => !keep.has(id));
+  for (const id of removed) delete map[id];
+  if (removed.length > 0 || own === null) save(deviceId, map);
+  return removed;
+}
+function clearCredentials() {
+  rmSync4(credentialsDir(), { recursive: true, force: true });
+  if (existsSync7(legacyPath())) writeFileSync3(legacyPath(), "", { mode: 384 });
+}
+
+// src/dispatch-dedupe.ts
+init_config();
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync as renameSync4, existsSync as existsSync8 } from "fs";
+import { join as join13 } from "path";
+var MAX_IDS = 256;
+function dir(log2) {
+  return join13(cabaneDir(), log2);
+}
+function pathFor(log2, workspaceId) {
+  return join13(dir(log2), encodeURIComponent(workspaceId));
+}
+function readIds(log2, workspaceId) {
+  const path = pathFor(log2, workspaceId);
+  if (!existsSync8(path)) return [];
+  try {
+    return readFileSync5(path, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+  } catch {
+    return [];
+  }
+}
+function has(log2, workspaceId, eventId) {
+  return readIds(log2, workspaceId).includes(eventId);
+}
+function mark(log2, workspaceId, eventId) {
+  const ids = readIds(log2, workspaceId);
+  if (ids.includes(eventId)) return;
+  ids.push(eventId);
+  const trimmed = ids.length > MAX_IDS ? ids.slice(-MAX_IDS) : ids;
+  mkdirSync6(dir(log2), { recursive: true });
+  writeFileSync4(pathFor(log2, workspaceId), trimmed.join("\n") + "\n", "utf8");
+}
+function hasDispatched(workspaceId, eventId) {
+  return has("dispatched", workspaceId, eventId);
+}
+function markDispatched(workspaceId, eventId) {
+  mark("dispatched", workspaceId, eventId);
+}
+function hasCompleted(workspaceId, eventId) {
+  return has("completed", workspaceId, eventId);
+}
+function markCompleted(workspaceId, eventId) {
+  mark("completed", workspaceId, eventId);
+  forgetTurnId(workspaceId, eventId);
+}
+var MAX_RESUME_ATTEMPTS = 3;
+function resumeDir() {
+  return join13(cabaneDir(), "resume-attempts");
+}
+function resumePathFor(workspaceId) {
+  return join13(resumeDir(), encodeURIComponent(workspaceId));
+}
+function readResumeCounts(workspaceId) {
+  const out = /* @__PURE__ */ new Map();
+  const path = resumePathFor(workspaceId);
+  if (!existsSync8(path)) return out;
+  try {
+    for (const line of readFileSync5(path, "utf8").split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const tab = trimmed.lastIndexOf("	");
+      if (tab <= 0) continue;
+      const id = trimmed.slice(0, tab);
+      const count = Number.parseInt(trimmed.slice(tab + 1), 10);
+      if (id && Number.isFinite(count)) out.set(id, count);
+    }
+  } catch {
+    return out;
+  }
+  return out;
+}
+function bumpResumeAttempt(workspaceId, eventId) {
+  const counts = readResumeCounts(workspaceId);
+  const next = (counts.get(eventId) ?? 0) + 1;
+  counts.set(eventId, next);
+  const entries = [...counts.entries()];
+  const trimmed = entries.length > MAX_IDS ? entries.slice(-MAX_IDS) : entries;
+  mkdirSync6(resumeDir(), { recursive: true });
+  writeFileSync4(
+    resumePathFor(workspaceId),
+    trimmed.map(([id, c]) => `${id}	${c}`).join("\n") + "\n",
+    "utf8"
+  );
+  return next;
+}
+function turnDir() {
+  return join13(cabaneDir(), "turns");
+}
+function turnPathFor(workspaceId) {
+  return join13(turnDir(), encodeURIComponent(workspaceId));
+}
+var TURN_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function readTurnIds(workspaceId) {
+  const out = /* @__PURE__ */ new Map();
+  const path = turnPathFor(workspaceId);
+  if (!existsSync8(path)) return out;
+  try {
+    for (const line of readFileSync5(path, "utf8").split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const tab = trimmed.lastIndexOf("	");
+      if (tab <= 0) continue;
+      const id = trimmed.slice(0, tab);
+      const turnId = trimmed.slice(tab + 1);
+      if (id && TURN_ID_RE.test(turnId)) out.set(id, turnId);
+    }
+  } catch {
+    return out;
+  }
+  return out;
+}
+function turnIdForEvent(workspaceId, eventId) {
+  return readTurnIds(workspaceId).get(eventId) ?? null;
+}
+var TURN_ID_OVERFLOW_WARN = 8192;
+function writeTurnIds(workspaceId, turns) {
+  const entries = [...turns.entries()];
+  mkdirSync6(turnDir(), { recursive: true });
+  const path = turnPathFor(workspaceId);
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync4(tmp, entries.map(([id, t]) => `${id}	${t}`).join("\n") + "\n", "utf8");
+  renameSync4(tmp, path);
+  return entries.length;
+}
+function rememberTurnId(workspaceId, eventId, turnId) {
+  const turns = readTurnIds(workspaceId);
+  if (turns.get(eventId) === turnId) return turns.size;
+  turns.set(eventId, turnId);
+  return writeTurnIds(workspaceId, turns);
+}
+function forgetTurnId(workspaceId, eventId) {
+  const turns = readTurnIds(workspaceId);
+  if (!turns.delete(eventId)) return;
+  writeTurnIds(workspaceId, turns);
+}
+function noResume() {
+  return process.env.CABANE_COMPANION_NO_RESUME === "1";
+}
+
+// src/supervisor.ts
+init_bundled_binaries();
+init_install_kind();
+
+// src/connector-health.ts
+init_src();
+var ConnectorHealthStore = class {
+  byRuntime = /* @__PURE__ */ new Map();
+  // Record a settled turn's outcome for `runtime`. A success heals to `ok`; a
+  // classified failure sets `limited`(+reset) / `auth_expired` with the reason as
+  // `last_error`; anything else (a user Stop, a timeout, an unclassified error)
+  // leaves the last-known status untouched — we only ever move state on real
+  // evidence.
+  recordSettle(runtime, outcome) {
+    if (outcome.ok) {
+      this.byRuntime.set(runtime, { quotaState: "ok", limitedUntil: null, lastError: null });
+      return;
+    }
+    const failure = decodeFailureReason(outcome.errorReason);
+    if (!failure) return;
+    const quota = quotaForFailure(failure);
+    if (!quota) return;
+    this.byRuntime.set(runtime, {
+      quotaState: quota.quotaState,
+      limitedUntil: quota.limitedUntil,
+      lastError: outcome.errorReason ?? null
+    });
+  }
+  // The store's current opinion for one runtime, or undefined when it has
+  // no observation. Read by the dispatcher at idle-timeout fire: an idle reap
+  // while this runtime is definitively `limited` (a present, future `limitedUntil`
+  // recorded by a sibling/earlier turn's classified cap settle) is the account cap
+  // surfacing as silence, not a genuine hang — so the settle reclassifies to
+  // `usage_capped` instead of `timeout_idle`. Returns the stored shape verbatim
+  // (the dispatcher reads `quotaState` + `limitedUntil` and applies its own
+  // future-instant gate); a read never mutates state.
+  lookup(runtime) {
+    return this.byRuntime.get(runtime);
+  }
+  // The per-connector reports to attach to a heartbeat — one entry per runtime the
+  // companion has an observation for. Empty until the first classified failure/heal,
+  // so a companion that has seen nothing sends no `connectors[]` and the server's
+  // manifest synthesis (status-less rows) is unaffected.
+  reports() {
+    return [...this.byRuntime.entries()].map(([runtime, h]) => ({
+      runtime,
+      quotaState: h.quotaState,
+      limitedUntil: h.limitedUntil,
+      lastError: h.lastError
+    }));
+  }
+};
+
+// src/dispatcher.ts
+import { randomUUID as randomUUID4 } from "crypto";
+
+// src/runner/launch.ts
+init_src();
+init_opencode_lock();
+init_api_error_shape();
+init_errors();
+init_boot_id();
+init_turn_containment();
+init_protocol();
+import { createInterface } from "readline";
+function selfRunnerCommand() {
+  const script = process.argv[1];
+  if (!script) throw new Error("runner: cannot tell which script started this companion");
+  return [process.execPath, ...process.execArgv, script, "run-turn"];
+}
+function wrappedRunnerCommand(prefix, own) {
+  return [...prefix ?? [], ...own];
+}
+var WRAPPED_ENV_DROPPED = [
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CODEX_API_KEY",
+  "GH_TOKEN",
+  "GITHUB_TOKEN",
+  "DBUS_SESSION_BUS_ADDRESS",
+  "XDG_RUNTIME_DIR"
+];
+function runnerExecEnv(base, wrapped) {
+  const env = {};
+  for (const [k, v] of Object.entries(base)) {
+    if (v === void 0) continue;
+    if (wrapped && WRAPPED_ENV_DROPPED.includes(k)) continue;
+    env[k] = v;
+  }
+  return env;
+}
+function healthSnapshot(store) {
+  const out = {};
+  for (const r of store?.reports() ?? []) {
+    out[r.runtime] = {
+      quotaState: r.quotaState ?? "unknown",
+      limitedUntil: r.limitedUntil ?? null,
+      lastError: r.lastError ?? null
+    };
+  }
+  return out;
+}
+function runnerSpec(opts, launch, duties, runnerId) {
+  return {
+    runnerId,
+    ...opts.deviceId ? { deviceId: opts.deviceId } : {},
+    bootId,
+    workspaceId: opts.workspaceId,
+    workspaceSlug: opts.workspaceSlug,
+    agentId: opts.agentId,
+    agentUsername: opts.agentUsername,
+    agentName: String(opts.log.bindings().agentName ?? opts.agentUsername),
+    local: opts.local,
+    runConfig: opts.runConfig,
+    workRoot: opts.workRoot,
+    ...opts.opencodeServerUrl ? { opencodeServerUrl: opts.opencodeServerUrl } : {},
+    // Read now, per turn, the way adapter selection reads them.
+    claudeCodeAvailable: opts.claudeCodeAvailable?.() ?? true,
+    codexAvailable: opts.codexAvailable?.() ?? false,
+    ...opts.idleTimeoutMs !== void 0 ? { idleTimeoutMs: opts.idleTimeoutMs } : {},
+    ...opts.totalTimeoutMs !== void 0 ? { totalTimeoutMs: opts.totalTimeoutMs } : {},
+    ...opts.leaseRenewalMs !== void 0 ? { leaseRenewalMs: opts.leaseRenewalMs } : {},
+    ...opts.preparingRowDelayMs !== void 0 ? { preparingRowDelayMs: opts.preparingRowDelayMs } : {},
+    transcripts: opts.transcriptDir !== void 0,
+    logLevel: opts.log.level,
+    connectorHealth: healthSnapshot(launch.connectorHealth),
+    sessionWriteNoticeClaimed: duties.sessionWriteNoticeClaimed()
+  };
+}
+var PINO_LEVELS = {
+  10: "trace",
+  20: "debug",
+  30: "info",
+  40: "warn",
+  50: "error",
+  60: "fatal"
+};
+function relayRunnerLog(line, log2) {
+  if (!line.trim()) return;
+  let record = null;
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed && typeof parsed === "object") record = parsed;
+  } catch {
+    record = null;
+  }
+  if (!record || typeof record.level !== "number") {
+    log2.debug({ runnerStderr: line }, "runner: output");
+    return;
+  }
+  const {
+    level,
+    msg,
+    time: _time,
+    pid: _pid,
+    hostname: _hostname,
+    agentName: _agentName,
+    ...fields
+  } = record;
+  const method = PINO_LEVELS[level] ?? "info";
+  log2[method](fields, typeof msg === "string" ? msg : "");
+}
+function lines(stream, onLine) {
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  rl.on("line", onLine);
+  return new Promise((resolve2) => rl.once("close", resolve2));
+}
+function giveBackLocks(locks, prefix, remote, launch, log2) {
+  locks.withdraw(prefix);
+  const stop2 = launch.stopRemoteSession ?? ((url, id) => stopRemoteOpencodeSession(url, id));
+  for (const { key, owner } of locks.heldBy(prefix)) {
+    const left = remote.filter((r) => opencodeLockKey(r.serverUrl) === key);
+    if (!left.length) {
+      locks.release(owner);
+      continue;
+    }
+    void (async () => {
+      for (let attempt = 1; ; attempt++) {
+        const stopped = await Promise.all(left.map((r) => stop2(r.serverUrl, r.sessionId))).catch(
+          () => [false]
+        );
+        if (stopped.every(Boolean)) break;
+        if (attempt === 1)
+          log2.warn(
+            { key, sessions: left.map((r) => r.sessionId) },
+            "runner: a dead runner left work on a shared server that could not be confirmed stopped; holding the server until it is"
+          );
+        await new Promise((resolve2) => setTimeout(resolve2, launch.reconcileRetryMs ?? 5e3));
+      }
+      locks.release(owner);
+    })();
+  }
+}
+async function mintForRunner(opts, payload, handleOpts, signal, log2) {
+  try {
+    const minted = await opts.api.mintRunnerCredential({
+      conversationId: payload.conversationId,
+      messageId: payload.messageId,
+      ...payload.episode !== void 0 ? { episode: payload.episode } : {},
+      // The one turn the credential will operate: this run's.
+      turnId: handleOpts.turnId
+    });
+    return {
+      ok: true,
+      credential: minted.credential,
+      runnerId: minted.runnerId,
+      deviceGrants: minted.deviceGrants ?? []
+    };
+  } catch (err) {
+    if (signal.aborted) return { ok: false, reason: "cancelled" };
+    const status2 = err instanceof ApiError ? err.status : 0;
+    if (status2 === 404) return { ok: false, reason: "runner_credential_not_found" };
+    if (status2 === 409 && apiErrorCode(err) === "dispatch_not_admitted")
+      return { ok: false, reason: "runner_credential_not_admitted" };
+    log2.warn(apiErrorLogFields(err), "runner: couldn't get a credential for the turn's runner");
+    const reason = `fetch_failed: ${describeError(err)}`;
+    return { ok: false, reason, errorReason: reason };
+  }
+}
+async function settleUnstarted(opts, payload, turnId, errorReason, log2) {
+  try {
+    await opts.api.setActiveRun(opts.workspaceId, payload.conversationId, payload.agentId, {
+      activeRunStartedAt: null,
+      turnId,
+      outcome: "failed",
+      ...errorReason ? { errorReason: errorReason.slice(0, ERROR_REASON_MAX) } : {},
+      readThrough: payload.messageId
+    });
+  } catch (err) {
+    log2.warn(
+      { ...apiErrorLogFields(err), turnId },
+      "Couldn't update the turn's status in Cabane. Check the conversation before trying again."
+    );
+  }
+}
+async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
+  const startedAt = Date.now();
+  const { turnId } = handleOpts;
+  const oomKilled = (id) => (launch.oomKilled ?? turnScopeOomKilled)(id).catch(() => false);
+  const log2 = opts.log.child({
+    workspaceId: opts.workspaceId,
+    conversationId: payload.conversationId,
+    agentId: payload.agentId,
+    messageId: payload.messageId
+  });
+  const controller = new AbortController();
+  duties.registerAbort(turnId, controller);
+  const stopRunner = new AbortController();
+  let ready = false;
+  let child;
+  let stopAnnounced = false;
+  const announceStop = () => {
+    if (stopAnnounced || !child?.stdin.writable) return;
+    stopAnnounced = true;
+    child.stdin.write(encodeLauncherMessage({ cabaneLauncher: "stop" }));
+  };
+  const forwardStop = () => {
+    announceStop();
+    if (ready) stopRunner.abort();
+  };
+  controller.signal.addEventListener("abort", forwardStop, { once: true });
+  const attempt = {
+    workspaceId: opts.workspaceId,
+    conversationId: payload.conversationId,
+    agentId: payload.agentId,
+    turnId
+  };
+  const minted = await mintForRunner(opts, payload, handleOpts, controller.signal, log2);
+  if (!minted.ok) {
+    controller.signal.removeEventListener("abort", forwardStop);
+    duties.releaseAbort(turnId, controller);
+    const durationMs2 = Date.now() - startedAt;
+    await settleUnstarted(opts, payload, turnId, minted.errorReason, log2);
+    duties.notifyEnd({ id: payload.messageId, ok: false, durationMs: durationMs2, reason: minted.reason });
+    return { ok: false, durationMs: durationMs2, reason: minted.reason };
+  }
+  let result;
+  let thrown;
+  let code;
+  let handle;
+  const groups = [];
+  const remote = [];
+  const lockOwner = (id) => `${turnId}#${id}`;
+  const locks = launch.locks;
+  try {
+    handle = await launch.provider.acquire(attempt);
+  } catch (err) {
+    const reason2 = `runner_unavailable: ${describeError(err)}`;
+    log2.warn(
+      { turnId, provider: launch.provider.name, err: describeError(err) },
+      "runner: no place to run the turn"
+    );
+    controller.signal.removeEventListener("abort", forwardStop);
+    duties.releaseAbort(turnId, controller);
+    await settleUnstarted(opts, payload, turnId, reason2, log2);
+    await launch.reportRunnerGone?.({
+      workspaceId: opts.workspaceId,
+      conversationId: payload.conversationId,
+      agentId: payload.agentId,
+      messageId: payload.messageId,
+      runnerId: minted.runnerId,
+      reason: "provider_failed"
+    });
+    const durationMs2 = Date.now() - startedAt;
+    duties.notifyEnd({ id: payload.messageId, ok: false, durationMs: durationMs2, reason: reason2 });
+    return { ok: false, durationMs: durationMs2, reason: reason2 };
+  }
+  try {
+    const wrapped = launch.wrapped === true;
+    const env = runnerExecEnv(launch.env ?? process.env, wrapped);
+    const grants = minted.deviceGrants.length > 0 ? launch.grants?.(minted.deviceGrants) ?? {} : {};
+    const input = {
+      baseUrl: opts.baseUrl,
+      credential: minted.credential,
+      ...wrapped ? { secrets: launch.secrets?.() ?? {} } : {},
+      ...Object.keys(grants).length > 0 ? { grants } : {},
+      dispatch: payload,
+      turnId,
+      resumed: handleOpts.resumed,
+      spec: runnerSpec(opts, launch, duties, minted.runnerId)
+    };
+    Object.assign(env, runnerEnv(input));
+    const running = launch.provider.exec(handle, launch.command, env, {
+      signal: stopRunner.signal,
+      stdin: runnerStdin(input)
+    });
+    child = running;
+    if (controller.signal.aborted) announceStop();
+    log2.debug(
+      { turnId, runnerPid: running.pid, provider: launch.provider.name },
+      "runner: started"
+    );
+    const stdoutDone = lines(running.stdout, (line) => {
+      const event = decodeRunnerEvent(line);
+      if (!event) {
+        log2.debug({ runnerStdout: line }, "runner: output");
+        return;
+      }
+      switch (event.cabaneRunner) {
+        case "ready":
+          ready = true;
+          if (controller.signal.aborted) stopRunner.abort();
+          return;
+        case "start":
+          duties.notifyStart({
+            id: event.id,
+            conversationId: event.conversationId,
+            message: event.message
+          });
+          return;
+        case "end": {
+          const { cabaneRunner: _kind, ...info } = event;
+          duties.notifyEnd(info);
+          return;
+        }
+        case "session_write_notice":
+          duties.markSessionWriteNotice();
+          return;
+        case "connector_health":
+          launch.connectorHealth?.recordSettle(event.runtime, {
+            ok: event.ok,
+            errorReason: event.errorReason
+          });
+          return;
+        case "result":
+          result = event.result;
+          return;
+        case "error":
+          thrown = event.message;
+          return;
+        case "lock":
+          if (!locks) {
+            log2.warn(
+              { key: event.key },
+              "runner: asked for a device lock this launcher has none of"
+            );
+            return;
+          }
+          locks.request(
+            event.key,
+            lockOwner(event.id),
+            () => running.stdin.write(encodeLauncherMessage({ cabaneLauncher: "granted", id: event.id }))
+          );
+          return;
+        case "unlock":
+          locks?.release(lockOwner(event.id));
+          return;
+        case "process_group":
+          if (!wrapped) groups.push(event.pgid);
+          return;
+        case "remote_session":
+          remote.push({ serverUrl: event.serverUrl, sessionId: event.sessionId });
+          return;
+        case "terminated":
+          void oomKilled(turnId).then((oom) => {
+            if (running.stdin.writable) {
+              running.stdin.write(
+                encodeLauncherMessage({
+                  cabaneLauncher: "cause",
+                  cause: oom ? "out_of_memory" : null
+                })
+              );
+            }
+          });
+          return;
+      }
+    });
+    const stderrDone = lines(running.stderr, (line) => relayRunnerLog(line, opts.log));
+    code = await running.exit;
+    await Promise.all([stdoutDone, stderrDone]);
+  } finally {
+    if (locks) giveBackLocks(locks, `${turnId}#`, remote, launch, log2);
+    child?.stdin.end();
+    controller.signal.removeEventListener("abort", forwardStop);
+    duties.releaseAbort(turnId, controller);
+    await launch.provider.release(handle, { destroy: false }).catch(
+      (err) => log2.warn({ err: describeError(err) }, "runner: couldn't give its place back")
+    );
+  }
+  if (result) return result;
+  const durationMs = Date.now() - startedAt;
+  const stopped = controller.signal.aborted && thrown === void 0;
+  const reason = stopped ? "cancelled" : thrown !== void 0 ? `runner_failed: ${thrown}` : await oomKilled(turnId) ? "out_of_memory" : `runner_exited: ${code}`;
+  await child?.reap(groups);
+  const reaped = await (launch.reapTurn ?? reapTurnScopes)(turnId).catch((err) => ({
+    failures: [err instanceof Error ? err.message : String(err)]
+  }));
+  if (reaped.failures.length) {
+    log2.warn(
+      { turnId, failures: reaped.failures },
+      "runner: couldn't stop what the dead runner's turn left running"
+    );
+  }
+  try {
+    await opts.api.setActiveRun(opts.workspaceId, payload.conversationId, payload.agentId, {
+      activeRunStartedAt: null,
+      turnId,
+      ...stopped ? { outcome: "interrupted" } : { outcome: "failed", errorReason: reason.slice(0, ERROR_REASON_MAX) },
+      readThrough: payload.messageId
+    });
+  } catch (err) {
+    log2.warn(
+      { ...apiErrorLogFields(err), turnId },
+      "Couldn't update the turn's status in Cabane. Check the conversation before trying again."
+    );
+  }
+  await launch.reportRunnerGone?.({
+    workspaceId: opts.workspaceId,
+    conversationId: payload.conversationId,
+    agentId: payload.agentId,
+    messageId: payload.messageId,
+    runnerId: minted.runnerId,
+    reason: "exited"
+  });
+  if (thrown !== void 0) throw new Error(thrown);
+  if (stopped) log2.info({ turnId, code }, "runner: stopped before it could report");
+  else log2.warn({ turnId, code }, "runner: exited without reporting a result");
+  duties.notifyEnd({ id: payload.messageId, ok: false, durationMs, reason });
+  return { ok: false, durationMs, reason };
+}
+
+// src/dispatcher.ts
+init_turn_execution();
+function runKey(conversationId, agentId) {
+  return `${conversationId}|${agentId}`;
+}
+var Dispatcher = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.aborts = opts.aborts ?? /* @__PURE__ */ new Map();
+  }
+  opts;
+  // (conversation|agent) → per-turn controllers. A delayed cancel for an old
+  // turn must never reach its successor.
+  aborts;
+  // Pairs already told their session couldn't be saved: the notice is once per
+  // pair, while the rejection repeats every turn.
+  sessionWriteNotified = /* @__PURE__ */ new Set();
+  notifyStart(info) {
     try {
-      chmodSync3(tmp, 384);
+      this.opts.observer?.onStart(info);
     } catch {
     }
-    renameSync3(tmp, path);
-  } catch (err) {
+  }
+  notifyEnd(info) {
     try {
-      rmSync4(tmp, { force: true });
+      this.opts.observer?.onEnd(info);
     } catch {
     }
-    throw err;
-  }
-}
-function getCredential(deviceId, agentId) {
-  return load(deviceId)[agentId] ?? null;
-}
-function setCredential(deviceId, agentId, pat) {
-  if (read(devicePath(deviceId))?.[agentId] === pat) return;
-  const map = load(deviceId);
-  map[agentId] = pat;
-  save(deviceId, map);
-}
-function pruneCredentials(deviceId, keepAgentIds) {
-  const keep = new Set(keepAgentIds);
-  if (keep.size === 0) return [];
-  const own = read(devicePath(deviceId));
-  const map = own ?? load(deviceId);
-  const removed = Object.keys(map).filter((id) => !keep.has(id));
-  for (const id of removed) delete map[id];
-  if (removed.length > 0 || own === null) save(deviceId, map);
-  return removed;
-}
-function clearCredentials() {
-  rmSync4(credentialsDir(), { recursive: true, force: true });
-  if (existsSync7(legacyPath())) writeFileSync3(legacyPath(), "", { mode: 384 });
-}
-
-// src/dispatch-dedupe.ts
-init_config();
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync as renameSync4, existsSync as existsSync8 } from "fs";
-import { join as join13 } from "path";
-var MAX_IDS = 256;
-function dir(log2) {
-  return join13(cabaneDir(), log2);
-}
-function pathFor(log2, workspaceId) {
-  return join13(dir(log2), encodeURIComponent(workspaceId));
-}
-function readIds(log2, workspaceId) {
-  const path = pathFor(log2, workspaceId);
-  if (!existsSync8(path)) return [];
-  try {
-    return readFileSync5(path, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
-  } catch {
-    return [];
   }
-}
-function has(log2, workspaceId, eventId) {
-  return readIds(log2, workspaceId).includes(eventId);
-}
-function mark(log2, workspaceId, eventId) {
-  const ids = readIds(log2, workspaceId);
-  if (ids.includes(eventId)) return;
-  ids.push(eventId);
-  const trimmed = ids.length > MAX_IDS ? ids.slice(-MAX_IDS) : ids;
-  mkdirSync6(dir(log2), { recursive: true });
-  writeFileSync4(pathFor(log2, workspaceId), trimmed.join("\n") + "\n", "utf8");
-}
-function hasDispatched(workspaceId, eventId) {
-  return has("dispatched", workspaceId, eventId);
-}
-function markDispatched(workspaceId, eventId) {
-  mark("dispatched", workspaceId, eventId);
-}
-function hasCompleted(workspaceId, eventId) {
-  return has("completed", workspaceId, eventId);
-}
-function markCompleted(workspaceId, eventId) {
-  mark("completed", workspaceId, eventId);
-  forgetTurnId(workspaceId, eventId);
-}
-var MAX_RESUME_ATTEMPTS = 3;
-function resumeDir() {
-  return join13(cabaneDir(), "resume-attempts");
-}
-function resumePathFor(workspaceId) {
-  return join13(resumeDir(), encodeURIComponent(workspaceId));
-}
-function readResumeCounts(workspaceId) {
-  const out = /* @__PURE__ */ new Map();
-  const path = resumePathFor(workspaceId);
-  if (!existsSync8(path)) return out;
-  try {
-    for (const line of readFileSync5(path, "utf8").split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      const tab = trimmed.lastIndexOf("	");
-      if (tab <= 0) continue;
-      const id = trimmed.slice(0, tab);
-      const count = Number.parseInt(trimmed.slice(tab + 1), 10);
-      if (id && Number.isFinite(count)) out.set(id, count);
-    }
-  } catch {
-    return out;
+  // The supervisor supplies a stable turnId on both fresh and resumed dispatch.
+  // resumed is separate: only replay seeds sequence/speech recovery from the
+  // prior span. A direct caller omitting turnId gets a fresh id.
+  async handle(payload, opts = {}) {
+    const key = runKey(payload.conversationId, payload.agentId);
+    return runTurnInRunner(
+      this.opts.turn,
+      this.opts.runner,
+      {
+        registerAbort: (turnId, controller) => {
+          let pairAborts = this.aborts.get(key);
+          if (!pairAborts) {
+            pairAborts = /* @__PURE__ */ new Map();
+            this.aborts.set(key, pairAborts);
+          }
+          pairAborts.set(turnId, controller);
+        },
+        releaseAbort: (turnId, controller) => {
+          const pair = this.aborts.get(key);
+          if (pair?.get(turnId) !== controller) return;
+          pair.delete(turnId);
+          if (pair.size === 0) this.aborts.delete(key);
+        },
+        sessionWriteNoticeClaimed: () => this.sessionWriteNotified.has(key),
+        markSessionWriteNotice: () => {
+          this.sessionWriteNotified.add(key);
+        },
+        notifyStart: (info) => this.notifyStart(info),
+        notifyEnd: (info) => this.notifyEnd(info)
+      },
+      payload,
+      { turnId: opts.turnId ?? randomUUID4(), resumed: opts.resumed === true }
+    );
   }
-  return out;
-}
-function bumpResumeAttempt(workspaceId, eventId) {
-  const counts = readResumeCounts(workspaceId);
-  const next = (counts.get(eventId) ?? 0) + 1;
-  counts.set(eventId, next);
-  const entries = [...counts.entries()];
-  const trimmed = entries.length > MAX_IDS ? entries.slice(-MAX_IDS) : entries;
-  mkdirSync6(resumeDir(), { recursive: true });
-  writeFileSync4(
-    resumePathFor(workspaceId),
-    trimmed.map(([id, c]) => `${id}	${c}`).join("\n") + "\n",
-    "utf8"
-  );
-  return next;
-}
-function turnDir() {
-  return join13(cabaneDir(), "turns");
-}
-function turnPathFor(workspaceId) {
-  return join13(turnDir(), encodeURIComponent(workspaceId));
-}
-var TURN_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function readTurnIds(workspaceId) {
-  const out = /* @__PURE__ */ new Map();
-  const path = turnPathFor(workspaceId);
-  if (!existsSync8(path)) return out;
-  try {
-    for (const line of readFileSync5(path, "utf8").split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      const tab = trimmed.lastIndexOf("	");
-      if (tab <= 0) continue;
-      const id = trimmed.slice(0, tab);
-      const turnId = trimmed.slice(tab + 1);
-      if (id && TURN_ID_RE.test(turnId)) out.set(id, turnId);
+  // Cancel the named turn. An older server omits turnId and cancels the pair.
+  cancel(conversationId, agentId, turnId) {
+    const key = runKey(conversationId, agentId);
+    const pair = this.aborts.get(key);
+    if (!pair || pair.size === 0) return false;
+    const controllers = turnId === void 0 ? [...pair.values()] : [pair.get(turnId)];
+    let aborted = false;
+    for (const ac of controllers) {
+      if (!ac) continue;
+      aborted = true;
+      try {
+        ac.abort();
+      } catch {
+      }
     }
-  } catch {
-    return out;
-  }
-  return out;
-}
-function turnIdForEvent(workspaceId, eventId) {
-  return readTurnIds(workspaceId).get(eventId) ?? null;
-}
-var TURN_ID_OVERFLOW_WARN = 8192;
-function writeTurnIds(workspaceId, turns) {
-  const entries = [...turns.entries()];
-  mkdirSync6(turnDir(), { recursive: true });
-  const path = turnPathFor(workspaceId);
-  const tmp = `${path}.${process.pid}.tmp`;
-  writeFileSync4(tmp, entries.map(([id, t]) => `${id}	${t}`).join("\n") + "\n", "utf8");
-  renameSync4(tmp, path);
-  return entries.length;
-}
-function rememberTurnId(workspaceId, eventId, turnId) {
-  const turns = readTurnIds(workspaceId);
-  if (turns.get(eventId) === turnId) return turns.size;
-  turns.set(eventId, turnId);
-  return writeTurnIds(workspaceId, turns);
-}
-function forgetTurnId(workspaceId, eventId) {
-  const turns = readTurnIds(workspaceId);
-  if (!turns.delete(eventId)) return;
-  writeTurnIds(workspaceId, turns);
-}
-function noResume() {
-  return process.env.CABANE_COMPANION_NO_RESUME === "1";
-}
-
-// src/supervisor.ts
-init_bundled_binaries();
-init_install_kind();
-
-// src/connector-health.ts
-init_src();
-var ConnectorHealthStore = class {
-  byRuntime = /* @__PURE__ */ new Map();
-  // Record a settled turn's outcome for `runtime`. A success heals to `ok`; a
-  // classified failure sets `limited`(+reset) / `auth_expired` with the reason as
-  // `last_error`; anything else (a user Stop, a timeout, an unclassified error)
-  // leaves the last-known status untouched — we only ever move state on real
-  // evidence.
-  recordSettle(runtime, outcome) {
-    if (outcome.ok) {
-      this.byRuntime.set(runtime, { quotaState: "ok", limitedUntil: null, lastError: null });
-      return;
+    return aborted;
+  }
+  // Abort every run in flight in THIS process, whatever its conversation. For
+  // an agent taken off this device: nothing it is still running here is
+  // legitimate, and a cancel frame that arrives after it is dropped from the
+  // roster finds no dispatcher to reach. True if any was aborted.
+  cancelAll() {
+    let aborted = false;
+    for (const pair of this.aborts.values()) {
+      for (const ac of [...pair.values()]) {
+        try {
+          ac.abort();
+          aborted = true;
+        } catch {
+        }
+      }
     }
-    const failure = decodeFailureReason(outcome.errorReason);
-    if (!failure) return;
-    const quota = quotaForFailure(failure);
-    if (!quota) return;
-    this.byRuntime.set(runtime, {
-      quotaState: quota.quotaState,
-      limitedUntil: quota.limitedUntil,
-      lastError: outcome.errorReason ?? null
-    });
-  }
-  // The store's current opinion for one runtime, or undefined when it has
-  // no observation. Read by the dispatcher at idle-timeout fire: an idle reap
-  // while this runtime is definitively `limited` (a present, future `limitedUntil`
-  // recorded by a sibling/earlier turn's classified cap settle) is the account cap
-  // surfacing as silence, not a genuine hang — so the settle reclassifies to
-  // `usage_capped` instead of `timeout_idle`. Returns the stored shape verbatim
-  // (the dispatcher reads `quotaState` + `limitedUntil` and applies its own
-  // future-instant gate); a read never mutates state.
-  lookup(runtime) {
-    return this.byRuntime.get(runtime);
-  }
-  // The per-connector reports to attach to a heartbeat — one entry per runtime the
-  // companion has an observation for. Empty until the first classified failure/heal,
-  // so a companion that has seen nothing sends no `connectors[]` and the server's
-  // manifest synthesis (status-less rows) is unaffected.
-  reports() {
-    return [...this.byRuntime.entries()].map(([runtime, h]) => ({
-      runtime,
-      quotaState: h.quotaState,
-      limitedUntil: h.limitedUntil,
-      lastError: h.lastError
-    }));
+    return aborted;
   }
 };
 
-// src/supervisor.ts
-init_dispatcher();
-
 // src/host-report.ts
 import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
 import { userInfo as userInfo2 } from "os";
@@ -13171,7 +13304,7 @@ function hostReport() {
 }
 
 // src/providers/local-process.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { constants as constants2 } from "os";
 var DEFAULT_KILL_GRACE_MS = 3e4;
 var DEFAULT_REAP_GRACE_MS = 3e3;
@@ -13182,7 +13315,7 @@ function exitCode(code, signal) {
 }
 function createLocalProcessProvider(opts = {}) {
   const killGraceMs = opts.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
-  const spawnFn = opts.spawnFn ?? spawn5;
+  const spawnFn = opts.spawnFn ?? spawn4;
   const reapGraceMs = opts.reapGraceMs ?? DEFAULT_REAP_GRACE_MS;
   const killFn = opts.killFn ?? ((pid, signal) => process.kill(pid, signal));
   const groupAlive = (pgid) => {
@@ -13316,9 +13449,6 @@ var DeviceLocks = class {
   }
 };
 
-// src/supervisor.ts
-init_launch();
-
 // src/manifest.ts
 var DEVICE_MANIFEST = {
   runtimes: [{ name: "claude-code", version: null }],
@@ -13561,9 +13691,9 @@ var SseSubscriber = class {
 init_transcript_writer();
 
 // src/updater.ts
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { copyFileSync as copyFileSync2, existsSync as existsSync16, mkdirSync as mkdirSync14, renameSync as renameSync9, rmSync as rmSync10 } from "fs";
-import { dirname as dirname11, join as join27 } from "path";
+import { dirname as dirname11, join as join26 } from "path";
 
 // src/boot-rule.ts
 import {
@@ -13575,7 +13705,7 @@ import {
   symlinkSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { dirname as dirname8, join as join24 } from "path";
+import { dirname as dirname8, join as join23 } from "path";
 var UNCONFIRMED_WINDOW_MS = 10 * 6e4;
 var MAX_STAGE_ATTEMPTS = 3;
 function superseded(pending, ...running) {
@@ -13603,38 +13733,38 @@ import {
   lstatSync,
   mkdirSync as mkdirSync12,
   readFileSync as readFileSync13,
-  readdirSync as readdirSync4,
+  readdirSync as readdirSync3,
   realpathSync as realpathSync5,
   renameSync as renameSync7,
   rmSync as rmSync9,
   symlinkSync as symlinkSync2
 } from "fs";
-import { dirname as dirname9, join as join25 } from "path";
+import { dirname as dirname9, join as join24 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 function versionsDir() {
-  return join25(cabaneDir(), "versions");
+  return join24(cabaneDir(), "versions");
 }
 function currentLink() {
-  return join25(cabaneDir(), "current");
+  return join24(cabaneDir(), "current");
 }
 function bootGuardPath() {
-  return join25(cabaneDir(), "boot-guard.mjs");
+  return join24(cabaneDir(), "boot-guard.mjs");
 }
 function pinnedNodeDir() {
-  return join25(cabaneDir(), "node");
+  return join24(cabaneDir(), "node");
 }
 function pinnedNodePath() {
-  return join25(pinnedNodeDir(), "bin", "node");
+  return join24(pinnedNodeDir(), "bin", "node");
 }
 function versionPackageRoot(version) {
-  return join25(versionsDir(), version, "node_modules", "@cabane", "companion");
+  return join24(versionsDir(), version, "node_modules", "@cabane", "companion");
 }
 function ownPackageRoot(moduleUrl = import.meta.url) {
   return dirname9(dirname9(fileURLToPath5(moduleUrl)));
 }
 function packageVersion(root) {
   try {
-    const pkg2 = JSON.parse(readFileSync13(join25(root, "package.json"), "utf8"));
+    const pkg2 = JSON.parse(readFileSync13(join24(root, "package.json"), "utf8"));
     return typeof pkg2.version === "string" ? pkg2.version : null;
   } catch {
     return null;
@@ -13643,7 +13773,7 @@ function packageVersion(root) {
 function currentRoot() {
   try {
     const root = realpathSync5(currentLink());
-    return existsSync15(join25(root, "dist", "cli.js")) ? root : null;
+    return existsSync15(join24(root, "dist", "cli.js")) ? root : null;
   } catch {
     return null;
   }
@@ -13664,9 +13794,9 @@ function pruneVersions(keep) {
   const dir2 = versionsDir();
   if (!existsSync15(dir2)) return [];
   const removed = [];
-  for (const name of readdirSync4(dir2)) {
+  for (const name of readdirSync3(dir2)) {
     if (keep.includes(name)) continue;
-    rmSync9(join25(dir2, name), { recursive: true, force: true });
+    rmSync9(join24(dir2, name), { recursive: true, force: true });
     removed.push(name);
   }
   return removed;
@@ -13686,7 +13816,7 @@ function compareVersions(a, b) {
 // src/update-state.ts
 init_config();
 import { mkdirSync as mkdirSync13, readFileSync as readFileSync14, renameSync as renameSync8, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname10, join as join26 } from "path";
+import { dirname as dirname10, join as join25 } from "path";
 import { z as z18 } from "zod";
 var resultSchema = z18.object({
   kind: z18.enum(["updated", "rolled_back", "failed"]),
@@ -13710,7 +13840,7 @@ var stateSchema = z18.object({
   failed: z18.object({ version: z18.string(), attempts: z18.number().int(), at: z18.string() }).optional()
 });
 function updateStatePath(dir2 = cabaneDir()) {
-  return join26(dir2, "update.json");
+  return join25(dir2, "update.json");
 }
 function readUpdateState(path = updateStatePath()) {
   try {
@@ -13759,7 +13889,7 @@ function rollBack(pending, reason, now = /* @__PURE__ */ new Date()) {
   return updateUpdateState((state) => rolledBackState(state, pending, reason, now));
 }
 function writeBootGuard(root = ownPackageRoot()) {
-  const built = join27(root, "dist", "boot-guard.js");
+  const built = join26(root, "dist", "boot-guard.js");
   if (!existsSync16(built)) return false;
   const target = bootGuardPath();
   mkdirSync14(dirname11(target), { recursive: true });
@@ -13776,7 +13906,7 @@ var runProcess = (command, args, opts = {}) => new Promise((resolve2) => {
   let stderr = "";
   let child;
   try {
-    child = spawn6(command, [...args], {
+    child = spawn5(command, [...args], {
       stdio: ["ignore", "pipe", "pipe"],
       env: opts.env ?? process.env
     });
@@ -13799,17 +13929,17 @@ var runProcess = (command, args, opts = {}) => new Promise((resolve2) => {
 async function stageVersion(version, harnesses, deps = {}) {
   const run = deps.run ?? runProcess;
   const node = deps.execPath ?? process.execPath;
-  const target = join27(versionsDir(), version);
+  const target = join26(versionsDir(), version);
   const placed = versionPackageRoot(version);
   if (existsSync16(placed)) {
     if (!await verifyInstall(placed, version, harnesses, { run, execPath: node }))
       return { ok: true, root: placed };
   }
-  const npm = join27(dirname11(node), "npm");
+  const npm = join26(dirname11(node), "npm");
   if (!existsSync16(npm))
     return { ok: false, reason: `there is no npm beside Node at ${dirname11(node)}` };
   mkdirSync14(versionsDir(), { recursive: true });
-  const staging = join27(versionsDir(), `.${version}.staging-${process.pid}`);
+  const staging = join26(versionsDir(), `.${version}.staging-${process.pid}`);
   rmSync10(staging, { recursive: true, force: true });
   const installed = await run(
     npm,
@@ -13838,7 +13968,7 @@ async function stageVersion(version, harnesses, deps = {}) {
       return { ok: false, reason: `version ${version} isn't published yet`, unpublished: true };
     return { ok: false, reason: `npm couldn't install it: ${lastLine(installed.stderr)}` };
   }
-  const root = join27(staging, "node_modules", "@cabane", "companion");
+  const root = join26(staging, "node_modules", "@cabane", "companion");
   const verdict = await verifyInstall(root, version, harnesses, { run, execPath: node });
   if (verdict) {
     rmSync10(staging, { recursive: true, force: true });
@@ -13850,7 +13980,7 @@ async function stageVersion(version, harnesses, deps = {}) {
 }
 async function verifyInstall(root, version, harnesses, deps) {
   if (packageVersion(root) !== version) return `the installed package isn't version ${version}`;
-  const answered = await deps.run(deps.execPath, [join27(root, "dist", "bin.js"), "--version"], {
+  const answered = await deps.run(deps.execPath, [join26(root, "dist", "bin.js"), "--version"], {
     timeoutMs: 6e4,
     env: { ...process.env, CABANE_LAUNCH_SELF: "1" }
   });
@@ -13858,7 +13988,7 @@ async function verifyInstall(root, version, harnesses, deps) {
     return `it doesn't start: ${lastLine(answered.stderr) || "no version printed"}`;
   }
   if (harnesses.length === 0) return null;
-  const probed = await deps.run(deps.execPath, [join27(root, "dist", "postinstall.js"), "--json"], {
+  const probed = await deps.run(deps.execPath, [join26(root, "dist", "postinstall.js"), "--json"], {
     timeoutMs: 6e4
   });
   let resolutions = {};
@@ -14276,13 +14406,13 @@ var CompanionSupervisor = class {
     if (this.stopped) return;
     this.log.info(
       { protocolVersion: TURN_PROTOCOL_VERSION, version: COMPANION_VERSION },
-      `Companion ${COMPANION_VERSION} starting on ${this.config.deviceLabel ?? hostname2()}`
+      `Companion ${COMPANION_VERSION} starting on ${this.config.deviceLabel ?? hostname()}`
     );
     const retired = retiredConfigKeysOnDisk();
     if (retired.length > 0) {
       this.log.warn(
         { keys: retired },
-        `config.json: ${retired.join(", ")} ${retired.length === 1 ? "is" : "are"} no longer read and can be removed. The companion does no sandboxing, and every turn runs in a child process of its own.`
+        `config.json: ${retired.join(", ")} ${retired.length === 1 ? "is" : "are"} no longer read and can be removed.`
       );
     }
     if (this.config.deviceToken) {
@@ -14322,7 +14452,7 @@ var CompanionSupervisor = class {
       log: this.log,
       lastEventId: null,
       onOpen: () => {
-        this.log.info(`Connected to Cabane as ${this.hub.statusJson().device_label ?? hostname2()}`);
+        this.log.info(`Connected to Cabane as ${this.hub.statusJson().device_label ?? hostname()}`);
         this.deviceConnected = true;
         for (const wr of this.workspaces.values()) {
           this.hub.setConnected(wr.workspaceId, true);
@@ -14868,9 +14998,9 @@ var CompanionSupervisor = class {
           this.runnerCommand ?? selfRunnerCommand()
         ),
         ...this.config.runner?.command ? {
-          boxed: true,
+          wrapped: true,
           secrets: () => loadSecretValuesTolerant(
-            (m) => this.log.warn({ err: m }, "Could not read the secrets file for a boxed turn.")
+            (m) => this.log.warn({ err: m }, "Could not read the secrets file for a wrapped turn.")
           )
         } : {},
         // Read per dispatch, for the secret variables its mint named and no others.
@@ -15549,9 +15679,9 @@ async function waitForBoundedHeartbeat(heartbeat) {
 }
 function defaultReexec() {
   clearRuntimeState();
-  void import("child_process").then(({ spawn: spawn8 }) => {
+  void import("child_process").then(({ spawn: spawn7 }) => {
     try {
-      const child = spawn8(process.execPath, process.argv.slice(1), {
+      const child = spawn7(process.execPath, process.argv.slice(1), {
         stdio: "inherit",
         detached: false
       });
@@ -15623,9 +15753,9 @@ function handleUncaught(log2, err, origin) {
 // src/crash-marker.ts
 init_config();
 import { existsSync as existsSync17, mkdirSync as mkdirSync15, readFileSync as readFileSync15, rmSync as rmSync11, writeFileSync as writeFileSync9 } from "fs";
-import { join as join28 } from "path";
+import { join as join27 } from "path";
 function crashMarkerPath() {
-  return join28(cabaneDir(), "last-error.json");
+  return join27(cabaneDir(), "last-error.json");
 }
 function recordCrash(rec2) {
   try {
@@ -15646,7 +15776,7 @@ function clearCrash() {
 init_config();
 import { spawnSync } from "child_process";
 import { readFileSync as readFileSync16 } from "fs";
-import { join as join29 } from "path";
+import { join as join28 } from "path";
 var COMPANION_ENTRY = /@cabane\/companion\/|cabane-companion|(^|[\s/])cabane\s|\.cabane\/(versions|current|boot-guard)/;
 var START = /\sstart(\s|$)/;
 function companionStarts(psOutput) {
@@ -15663,7 +15793,7 @@ function companionStarts(psOutput) {
 }
 function stateDirOf(env) {
   const home = env.CABANE_COMPANION_HOME || env.HOME;
-  return home ? join29(home, ".cabane") : null;
+  return home ? join28(home, ".cabane") : null;
 }
 function envFromPsE(output, command) {
   const line = output.replace(/\n$/, "");
@@ -15938,7 +16068,7 @@ import {
   writeFileSync as writeFileSync10
 } from "fs";
 import { homedir as homedir9, userInfo as userInfo3 } from "os";
-import { dirname as dirname12, join as join30, sep as sep3 } from "path";
+import { dirname as dirname12, join as join29, sep as sep3 } from "path";
 function servicePlatform(platform = process.platform) {
   if (platform === "linux") return "systemd";
   if (platform === "darwin") return "launchd";
@@ -15956,15 +16086,15 @@ function serviceNode(execPath = process.execPath) {
   return existsSync18(pinnedNodePath()) ? pinnedNodePath() : execPath;
 }
 function servicePaths(platform, env = process.env, home = homedir9(), node = serviceNode()) {
-  const unitFile = platform === "systemd" ? join30(
-    env.XDG_CONFIG_HOME || join30(home, ".config"),
+  const unitFile = platform === "systemd" ? join29(
+    env.XDG_CONFIG_HOME || join29(home, ".config"),
     "systemd",
     "user",
     `${serviceName(env)}.service`
-  ) : join30(home, "Library", "LaunchAgents", `${launchdLabel(env)}.plist`);
+  ) : join29(home, "Library", "LaunchAgents", `${launchdLabel(env)}.plist`);
   return {
     unitFile,
-    envFile: join30(cabaneDir(), "service.env"),
+    envFile: join29(cabaneDir(), "service.env"),
     node,
     entry: bootGuardPath()
   };
@@ -16031,7 +16161,7 @@ function renderLaunchdPlist(paths, env = process.env, servicePath) {
     "  <key>ThrottleInterval</key><integer>5</integer>",
     // The companion writes its own log; the console copy would only grow a second one.
     "  <key>StandardOutPath</key><string>/dev/null</string>",
-    `  <key>StandardErrorPath</key><string>${xml(join30(cabaneDir(), "service-error.log"))}</string>`,
+    `  <key>StandardErrorPath</key><string>${xml(join29(cabaneDir(), "service-error.log"))}</string>`,
     "</dict>",
     "</plist>",
     ""
@@ -16171,15 +16301,15 @@ async function seedManagedInstall(deps) {
   }
   const target = versionPackageRoot(version);
   if (!existsSync18(target)) {
-    const staging = join30(versionsDir(), `.${version}.seed-${process.pid}`);
+    const staging = join29(versionsDir(), `.${version}.seed-${process.pid}`);
     rmSync12(staging, { recursive: true, force: true });
     try {
-      cpSync(own, join30(staging, "node_modules", "@cabane", "companion"), {
+      cpSync(own, join29(staging, "node_modules", "@cabane", "companion"), {
         recursive: true,
         verbatimSymlinks: true
       });
-      rmSync12(join30(versionsDir(), version), { recursive: true, force: true });
-      renameSync10(staging, join30(versionsDir(), version));
+      rmSync12(join29(versionsDir(), version), { recursive: true, force: true });
+      renameSync10(staging, join29(versionsDir(), version));
     } catch (err) {
       rmSync12(staging, { recursive: true, force: true });
       return {
@@ -16190,7 +16320,7 @@ async function seedManagedInstall(deps) {
   }
   const unrunnable = await verifyInstall(target, version, [], deps);
   if (unrunnable) {
-    rmSync12(join30(versionsDir(), version), { recursive: true, force: true });
+    rmSync12(join29(versionsDir(), version), { recursive: true, force: true });
     return { ok: false, reason: `The copy of Cabane for the service can't run: ${unrunnable}.` };
   }
   pointCurrentAt(target);
@@ -16272,9 +16402,9 @@ function userName() {
     return process.env.USER ?? "";
   }
 }
-function rewriteScriptWrappers(dir2 = join30(cabaneDir(), "bin")) {
+function rewriteScriptWrappers(dir2 = join29(cabaneDir(), "bin")) {
   for (const name of ["cabane", "cabane-companion"]) {
-    const path = join30(dir2, name);
+    const path = join29(dir2, name);
     let text;
     try {
       text = readFileSync17(path, "utf8");
@@ -16324,7 +16454,7 @@ async function controlService(action, deps) {
 init_cabane_command();
 init_cli_entry();
 init_config();
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { closeSync as closeSync3, mkdirSync as mkdirSync17, openSync as openSync4 } from "fs";
 init_config();
 async function startDaemon(opts = {}, deps = {}) {
@@ -16406,7 +16536,7 @@ function defaultSpawnDetached(args) {
   mkdirSync17(cabaneDir(), { recursive: true });
   const logFd = openSync4(companionLogPath(), "a");
   try {
-    const child = spawn7(process.execPath, [cliPath, ...args], {
+    const child = spawn6(process.execPath, [cliPath, ...args], {
       detached: true,
       stdio: ["ignore", logFd, logFd],
       env: { ...process.env, CABANE_COMPANION_DAEMON: "1" }
@@ -16832,7 +16962,7 @@ async function setupScript(opts, deps) {
     }
     device = await (deps.claim ?? claimSetupCode)(baseUrl, {
       userCode: opts.code,
-      label: deviceLabelFromHostname(hostname3()) ?? "Computer",
+      label: deviceLabelFromHostname(hostname2()) ?? "Computer",
       ...paired && cfg?.deviceToken ? { deviceToken: cfg.deviceToken } : {}
     });
     writePairedConfig(device);
@@ -17031,9 +17161,9 @@ async function logs(opts = {}) {
 init_cabane_command();
 init_install_kind();
 init_cabane_command();
-import { readdirSync as readdirSync5, realpathSync as realpathSync6, existsSync as existsSync19 } from "fs";
+import { readdirSync as readdirSync4, realpathSync as realpathSync6, existsSync as existsSync19 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname13, join as join31 } from "path";
+import { dirname as dirname13, join as join30 } from "path";
 init_config();
 init_secrets();
 init_term();
@@ -17319,7 +17449,7 @@ function versionLine() {
   const install = companionInstall();
   const own = installedCommandPath({ install });
   if (install === "script") {
-    return `Cabane ${COMPANION_VERSION} \xB7 installed by the install script (${tildePath(join31(homedir10(), ".cabane"))})`;
+    return `Cabane ${COMPANION_VERSION} \xB7 installed by the install script (${tildePath(join30(homedir10(), ".cabane"))})`;
   }
   if (own)
     return `Cabane ${COMPANION_VERSION} \xB7 installed with npm (${tildePath(dirname13(dirname13(own)))})`;
@@ -17345,7 +17475,7 @@ function otherInstall(install, own) {
     }
   };
   if (install === "npm") {
-    const script = join31(
+    const script = join30(
       homedir10(),
       ".cabane",
       "node",
@@ -17354,11 +17484,11 @@ function otherInstall(install, own) {
       "@cabane",
       "companion"
     );
-    return existsSync19(script) ? join31(homedir10(), ".cabane") : null;
+    return existsSync19(script) ? join30(homedir10(), ".cabane") : null;
   }
   const found = firstOnPath("cabane-companion", process.env.PATH);
   if (!found) return null;
-  const ownAlias = own ? real(join31(dirname13(own), "cabane-companion")) : null;
+  const ownAlias = own ? real(join30(dirname13(own), "cabane-companion")) : null;
   return real(found) === ownAlias ? null : dirname13(found);
 }
 function runningMode(running, service2) {
@@ -17396,7 +17526,7 @@ function transcriptsLine() {
   let count = 0;
   let newest;
   try {
-    const files = readdirSync5(dir2).filter((f) => f.endsWith(".jsonl")).sort();
+    const files = readdirSync4(dir2).filter((f) => f.endsWith(".jsonl")).sort();
     count = files.length;
     newest = files[files.length - 1];
   } catch {
@@ -17564,8 +17694,8 @@ init_cabane_command();
 init_errors();
 init_src();
 init_transcript_writer();
-import { existsSync as existsSync20, readFileSync as readFileSync18, readdirSync as readdirSync6 } from "fs";
-import { basename as basename4, isAbsolute as isAbsolute2, join as join32 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync18, readdirSync as readdirSync5 } from "fs";
+import { basename as basename4, isAbsolute as isAbsolute2, join as join31 } from "path";
 async function transcript(opts = {}) {
   const dir2 = transcriptsDir();
   if (opts.follow) {
@@ -17582,7 +17712,7 @@ async function transcript(opts = {}) {
       process.stdout.write(emptyMessage(dir2));
       return;
     }
-    process.stdout.write(renderFile(join32(dir2, newest)) + "\n");
+    process.stdout.write(renderFile(join31(dir2, newest)) + "\n");
     return;
   }
   printList(dir2);
@@ -17665,7 +17795,7 @@ function isComplete(content) {
 async function followTranscripts(dir2) {
   const follower = new TranscriptFollower({
     listFiles: () => listFiles(dir2),
-    read: (f) => readFileSync18(join32(dir2, f), "utf8"),
+    read: (f) => readFileSync18(join31(dir2, f), "utf8"),
     write: (s) => process.stdout.write(s),
     // CSI: cursor up `n` lines, then erase from cursor to end of screen.
     clearLines: (n) => process.stdout.write(`\x1B[${n}A\x1B[0J`),
@@ -17691,7 +17821,7 @@ async function followTranscripts(dir2) {
 function listTranscriptFiles(dir2) {
   let entries;
   try {
-    entries = readdirSync6(dir2, { withFileTypes: true });
+    entries = readdirSync5(dir2, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -17701,7 +17831,7 @@ function listTranscriptFiles(dir2) {
     if (!entry.isDirectory() || entry.name === "anomalies") continue;
     let inner;
     try {
-      inner = readdirSync6(join32(dir2, entry.name));
+      inner = readdirSync5(join31(dir2, entry.name));
     } catch {
       continue;
     }
@@ -17720,7 +17850,7 @@ function printList(dir2) {
 
 `);
   for (const f of files.slice(0, 20)) {
-    const { meta, outcome } = peek(join32(dir2, f));
+    const { meta, outcome } = peek(join31(dir2, f));
     const when = fmtTime(rec(meta)?.ts);
     const ws = str2(rec(meta)?.workspaceSlug);
     const o = rec(outcome);
@@ -17756,13 +17886,13 @@ function peek(path) {
 function resolveTarget(dir2, target) {
   if (isAbsolute2(target) || target.includes("/")) {
     if (existsSync20(target)) return target;
-    if (!isAbsolute2(target) && existsSync20(join32(dir2, target))) return join32(dir2, target);
+    if (!isAbsolute2(target) && existsSync20(join31(dir2, target))) return join31(dir2, target);
     throw new CompanionError(`no transcript at ${target}.`);
   }
-  const exact = join32(dir2, target);
+  const exact = join31(dir2, target);
   if (existsSync20(exact)) return exact;
   const matches = listFiles(dir2).filter((f) => f.includes(target));
-  if (matches.length === 1) return join32(dir2, matches[0]);
+  if (matches.length === 1) return join31(dir2, matches[0]);
   if (matches.length === 0) {
     throw new CompanionError(
       `no transcript matching "${target}" in ${dir2}. Run \`${cabane("transcript")}\` to list them.`