@cabane/companion 0.5.0 → 0.6.1

package/dist/runtime.js

@@ -13,16 +13,16 @@ import {
 } from "fs";
 import { homedir, userInfo } from "os";
 import { dirname, join } from "path";
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 
 // src/errors.ts
-var BridgeError = class extends Error {
+var CompanionError = class extends Error {
   constructor(message) {
     super(message);
-    this.name = "BridgeError";
+    this.name = "CompanionError";
   }
 };
-var ApiError = class extends BridgeError {
+var ApiError = class extends CompanionError {
   constructor(status, message, body) {
     super(message);
     this.status = status;
@@ -32,13 +32,13 @@ var ApiError = class extends BridgeError {
   status;
   body;
 };
-var ConfigError = class extends BridgeError {
+var ConfigError = class extends CompanionError {
   constructor(message) {
     super(message);
     this.name = "ConfigError";
   }
 };
-var PrepareHookError = class extends BridgeError {
+var PrepareHookError = class extends CompanionError {
   constructor(message) {
     super(message);
     this.name = "PrepareHookError";
@@ -46,9 +46,6 @@ var PrepareHookError = class extends BridgeError {
 };
 
 // src/pairing.ts
-import { z } from "zod";
-var PAIRING_VERSION = 1;
-var DEVICE_TOKEN_PREFIX = "cabdev_";
 function isAllowedBaseUrl(raw) {
   let url;
   try {
@@ -63,40 +60,24 @@ function isAllowedBaseUrl(raw) {
   }
   return false;
 }
-var pairingSchema = z.object({
-  // Bumped if the wire shape changes incompatibly. We only accept v1.
-  v: z.literal(PAIRING_VERSION),
-  baseUrl: z.string().url().refine(isAllowedBaseUrl, {
-    message: "baseUrl must be https (loopback http is allowed for local dev only)"
-  }),
-  // The `cabdev_` device token plaintext — the bridge's one durable credential.
-  deviceToken: z.string().min(1).startsWith(DEVICE_TOKEN_PREFIX, {
-    message: 'deviceToken must be a cabane device token (starts with "cabdev_")'
-  }),
-  // Optional identity hints the app may include for nicer local display. The
-  // bridge also learns these from the first assignments pull, so they're not
-  // required.
-  deviceId: z.string().min(1).optional(),
-  deviceLabel: z.string().min(1).optional()
-});
 
 // src/prepare-hook.ts
 import { spawn } from "child_process";
-import { z as z2 } from "zod";
-var prepareHookSchema = z2.object({
-  command: z2.string().min(1),
-  args: z2.array(z2.string()).optional(),
+import { z } from "zod";
+var prepareHookSchema = z.object({
+  command: z.string().min(1),
+  args: z.array(z.string()).optional(),
   // Extra env handed to the hook process itself (merged over process.env).
-  env: z2.record(z2.string(), z2.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
   // 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 bridge.
-  timeoutMs: z2.number().int().positive().optional()
+  // fails with a clear timeout message rather than pinning the companion.
+  timeoutMs: z.number().int().positive().optional()
 }).strict();
 var DEFAULT_TIMEOUT_MS = 10 * 6e4;
-var prepareResultSchema = z2.object({
-  cwd: z2.string().min(1),
-  env: z2.record(z2.string(), z2.string()).optional()
+var prepareResultSchema = z.object({
+  cwd: z.string().min(1),
+  env: z.record(z.string(), z.string()).optional()
 });
 function parsePrepareOutput(stdout) {
   const last = stdout.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).at(-1);
@@ -115,10 +96,13 @@ function parsePrepareOutput(stdout) {
     const r = prepareResultSchema.safeParse(parsed);
     if (!r.success) {
       throw new PrepareHookError(
-        'prepare hook JSON must carry a non-empty string "cwd" (and an optional string-map "env")'
+        'prepare hook JSON must carry a non-empty string "cwd" (plus optional "env")'
       );
     }
-    return { cwd: r.data.cwd, ...r.data.env ? { env: r.data.env } : {} };
+    return {
+      cwd: r.data.cwd,
+      ...r.data.env ? { env: r.data.env } : {}
+    };
   }
   return { cwd: last };
 }
@@ -143,6 +127,7 @@ var runPrepareHook = (hook, input) => {
           CABANE_CONVERSATION_ID: input.conversationId,
           CABANE_AGENT_ID: input.agentId,
           CABANE_AGENT_USERNAME: input.agentUsername,
+          CABANE_RUNTIME: input.runtime ?? "",
           // CT319: the conversation anchor is gone. These are kept as DEPRECATED
           // back-compat constants so an old user prepare script that still reads
           // them doesn't crash; a hook should key off CABANE_TRIGGER_ENTRY_PATHS.
@@ -217,12 +202,12 @@ function realAccountHome() {
   return realHomeCache;
 }
 function cabaneDir() {
-  const dir2 = join(process.env.CABANE_BRIDGE_HOME || homedir(), ".cabane");
+  const dir2 = join(process.env.CABANE_COMPANION_HOME || homedir(), ".cabane");
   if (process.env.VITEST) {
     const real = realAccountHome();
     if (real && dir2 === join(real, ".cabane")) {
       throw new Error(
-        `cabaneDir() resolved to the real ${dir2} during a test run. Bridge tests must swap process.env.HOME to a tmp dir before touching the config dir; this guard prevents wiping the operator's real bridge config (see apps/bridge/test/setup-home.ts).`
+        `cabaneDir() resolved to the real ${dir2} during a test run. Companion tests must swap process.env.HOME to a tmp dir before touching the config dir; this guard prevents wiping the operator's real companion config (see apps/companion/test/setup-home.ts).`
       );
     }
   }
@@ -231,55 +216,55 @@ function cabaneDir() {
 function configPath() {
   return join(cabaneDir(), "config.json");
 }
-var localAgentConfigSchema = z3.object({
-  cwd: z3.string().optional(),
+var localAgentConfigSchema = z2.object({
+  cwd: z2.string().optional(),
   prepareHook: prepareHookSchema.optional(),
   // CT289: the Claude Code auto-memory escape hatch. Auto-memory is forced OFF
-  // by default on every bridge (memory belongs in the Cabane workspace, and the
-  // house bridge would otherwise share one cwd-keyed memory dir across users).
-  // On a bridge you run yourself, set `claudeCode: { autoMemory: true }` to hand
+  // by default on every companion (memory belongs in the Cabane workspace, and a
+  // shared companion would otherwise pool one cwd-keyed memory dir across users).
+  // On a companion you run yourself, set `claudeCode: { autoMemory: true }` to hand
   // auto-memory back to your own `~/.claude/settings.json` — Cabane then stops
   // injecting the off switch and your normal Claude Code memory workflow applies
   // (in coding mode, where the checkout's project settings are read).
-  claudeCode: z3.object({ autoMemory: z3.boolean().optional() }).strict().optional()
+  claudeCode: z2.object({ autoMemory: z2.boolean().optional() }).strict().optional()
 }).strict();
-var bridgeConfigSchema = z3.object({
+var companionConfigSchema = z2.object({
   // The cabane instance this device is paired with. SJ515: https-enforced
   // (loopback exempt) so a hand-edited config can't smuggle a plaintext-http
   // base URL onto the MITM-able channel the device token + prompt ride.
-  baseUrl: z3.string().url().refine(isAllowedBaseUrl, {
+  baseUrl: z2.string().url().refine(isAllowedBaseUrl, {
     message: "baseUrl must be https (loopback http is allowed for local dev only)"
   }),
-  // The `cabdev_` device token plaintext — the bridge's one durable credential,
+  // The `cabdev_` device token plaintext — the companion's one durable credential,
   // presented as `Authorization: Bearer <token>` on the device-facing pull +
   // heartbeat endpoints. Optional so `cabane-companion logout` can strip it (a
   // "paired but logged out" state the supervisor refuses to run) while keeping
   // the rest of the config; `pair` always writes one.
-  deviceToken: z3.string().optional(),
-  // Identity hints, learned from the pairing string and refreshed on the first
+  deviceToken: z2.string().optional(),
+  // Identity hints, learned from the device flow and refreshed on the first
   // assignments pull. Cosmetic — used for `status`/dashboard display only.
-  deviceId: z3.string().optional(),
-  deviceLabel: z3.string().optional(),
+  deviceId: z2.string().optional(),
+  deviceLabel: z2.string().optional(),
   // Optional per-agent machine-local overrides (cwd / prepareHook), keyed by
-  // agentId / username / `slug/username`. Hand-added by the operator; the bridge
+  // agentId / username / `slug/username`. Hand-added by the operator; the companion
   // never writes this (it only persists credentials + the device, elsewhere).
-  agents: z3.record(z3.string(), localAgentConfigSchema).optional(),
+  agents: z2.record(z2.string(), localAgentConfigSchema).optional(),
   // Dashboard settings (all optional). dashboardPort: preferred bind port (next
   // free one if taken); autoOpen: whether `start` opens the browser (the
-  // `--no-open` flag / `BRIDGE_NO_OPEN=1` override per-run); logLevel: pino
+  // `--no-open` flag / `COMPANION_NO_OPEN=1` override per-run); logLevel: pino
   // level, live-editable from the dashboard settings panel.
-  dashboardPort: z3.number().int().min(1).max(65535).optional(),
-  autoOpen: z3.boolean().optional(),
-  logLevel: z3.enum(["warn", "info", "debug"]).optional(),
+  dashboardPort: z2.number().int().min(1).max(65535).optional(),
+  autoOpen: z2.boolean().optional(),
+  logLevel: z2.enum(["warn", "info", "debug"]).optional(),
   // CT270: the opencode runtime, when the operator runs one on this machine. The
   // operator installs opencode, starts `opencode serve` (auth via opencode's own
-  // `/connect` — Cabane never sees provider keys), and points the bridge at it
+  // `/connect` — Cabane never sees provider keys), and points the companion at it
   // here. Setting this makes the device advertise the `opencode` runtime on its
   // heartbeat manifest (so the server offers DeepSeek/opencode models here and
   // routes those turns to this device) AND registers the opencode adapter in the
   // dispatcher. Absent → the device is claude-code-only, exactly as before.
-  opencode: z3.object({
-    serverUrl: z3.string().url()
+  opencode: z2.object({
+    serverUrl: z2.string().url()
   }).strict().optional(),
   // CT481: the codex runtime, when the operator runs Codex on this machine. Unlike
   // opencode (a long-lived `opencode serve` addressed by URL), Codex is a local CLI
@@ -290,20 +275,13 @@ var bridgeConfigSchema = z3.object({
   // keeps the block but turns it off). Enabling makes the device advertise the
   // `codex` runtime on its heartbeat manifest AND registers the codex adapter in
   // the dispatcher. Absent → the device doesn't offer codex, exactly as before.
-  codex: z3.object({
-    enabled: z3.boolean().optional()
+  codex: z2.object({
+    enabled: z2.boolean().optional()
   }).strict().optional()
 });
 function isCodexEnabled(cfg) {
   return !!cfg.codex && cfg.codex.enabled !== false;
 }
-function cabaneNativeApiKey() {
-  const key = process.env.OPENROUTER_API_KEY?.trim();
-  return key ? key : void 0;
-}
-function isCabaneNativeEnabled() {
-  return cabaneNativeApiKey() !== void 0;
-}
 function localAgentConfig(cfg, agent) {
   const map = cfg.agents ?? {};
   return map[agent.agentId] ?? map[agent.agentUsername] ?? map[`${agent.workspaceSlug}/${agent.agentUsername}`] ?? {};
@@ -328,7 +306,7 @@ function loadConfig() {
       `${path3} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
     );
   }
-  const result = bridgeConfigSchema.safeParse(parsed);
+  const result = companionConfigSchema.safeParse(parsed);
   if (!result.success) {
     const agentIssue = result.error.issues.find((i) => i.path[0] === "agents");
     if (agentIssue) {
@@ -337,7 +315,7 @@ function loadConfig() {
       );
     }
     throw new ConfigError(
-      `${path3} is from an incompatible or older version of the bridge, or was hand-edited. Run \`cabane-companion pair\` to re-pair, or \`cabane-companion logout --purge\` to reset.`
+      `${path3} is from an incompatible or older version of the companion, or was hand-edited. Run \`cabane-companion pair\` to re-pair, or \`cabane-companion logout --purge\` to reset.`
     );
   }
   return result.data;
@@ -369,7 +347,7 @@ function requireConfig() {
   const cfg = loadConfig();
   if (!cfg) {
     throw new ConfigError(
-      "this bridge is not paired. Run `cabane-companion pair` \u2014 it shows a short code \u2014 then enter that code in the cabane app (Settings \u2192 Bridges) to connect this machine."
+      "this companion is not paired. Run `cabane-companion pair` \u2014 it shows a short code \u2014 then enter that code in the cabane app (Settings \u2192 Companions) to connect this machine."
     );
   }
   return cfg;
@@ -392,8 +370,8 @@ import { createWriteStream, mkdirSync as mkdirSync2 } from "fs";
 import { dirname as dirname2, join as join2 } from "path";
 import pino from "pino";
 import pretty from "pino-pretty";
-function bridgeLogPath() {
-  return join2(cabaneDir(), "bridge.log");
+function companionLogPath() {
+  return join2(cabaneDir(), "companion.log");
 }
 var CONSOLE_IGNORE = [
   "pid",
@@ -403,7 +381,7 @@ var CONSOLE_IGNORE = [
   "agentId",
   "messageId",
   "sessionId",
-  "bridgeId"
+  "companionId"
 ].join(",");
 function consoleShortId(log) {
   const id = log.conversationId ?? log.workspaceId;
@@ -417,10 +395,10 @@ function consoleMessageFormat(log, messageKey) {
 var cached = null;
 function getLogger() {
   if (cached) return cached;
-  const path3 = bridgeLogPath();
+  const path3 = companionLogPath();
   mkdirSync2(dirname2(path3), { recursive: true });
   const streams = [];
-  if (process.env.CABANE_BRIDGE_DAEMON !== "1") {
+  if (process.env.CABANE_COMPANION_DAEMON !== "1") {
     const consoleStream = pretty({
       colorize: true,
       ignore: CONSOLE_IGNORE,
@@ -452,7 +430,7 @@ var MAX_DISPATCHES = 50;
 function today() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
-var BridgeStateHub = class {
+var CompanionStateHub = class {
   constructor(opts) {
     this.opts = opts;
     this.emitter.setMaxListeners(0);
@@ -466,7 +444,7 @@ var BridgeStateHub = class {
   deviceLabel = null;
   deviceError = null;
   // CT586: the latest harness snapshot the supervisor probed, or null before the
-  // first probe (see BridgeStatusJson.harnesses).
+  // first probe (see CompanionStatusJson.harnesses).
   harnesses = null;
   // ---- subscription (SSE) ----
   on(listener) {
@@ -658,7 +636,7 @@ var BridgeStateHub = class {
       })),
       last_event_at_overall: lastOverall,
       dashboard_url: this.dashboardUrl,
-      bridge_version: this.opts.bridgeVersion,
+      companion_version: this.opts.companionVersion,
       instance_id: this.opts.instanceId ?? null,
       harnesses: this.harnesses
     };
@@ -699,7 +677,7 @@ function registerRoutes(app, deps) {
   });
   app.get("/api/logs", async (c) => {
     const lines = clampLimit(c.req.query("lines"), 200, 1e3);
-    return c.json({ lines: tailFile(bridgeLogPath(), lines) });
+    return c.json({ lines: tailFile(companionLogPath(), lines) });
   });
   app.post("/api/settings", async (c) => {
     const body = await readJson(c);
@@ -840,7 +818,7 @@ function buildDashboardApp(deps) {
       const status = err.status >= 400 && err.status < 600 ? err.status : 502;
       return c.json({ error: err.message }, status);
     }
-    if (err instanceof BridgeError) {
+    if (err instanceof CompanionError) {
       return c.json({ error: err.message }, 400);
     }
     return c.json({ error: err instanceof Error ? err.message : "internal error" }, 500);
@@ -872,7 +850,7 @@ async function startDashboard(opts) {
       throw err;
     }
   }
-  throw new BridgeError(
+  throw new CompanionError(
     `couldn't bind the dashboard to any port in ${preferred}\u2013${preferred + PORT_FALLBACK_SPAN - 1} (all in use). Free one up or pass --port. (last error: ${lastErr instanceof Error ? lastErr.message : String(lastErr)})`
   );
 }
@@ -1018,8 +996,8 @@ async function ensureRuntimeAvailable(cfg, deps = {}) {
     );
     return;
   }
-  throw new BridgeError(
-    "Claude Code, the bridge\u2019s default runtime, is not on your PATH. Install it with `npm i -g @anthropic-ai/claude-code`, log in (`claude` then follow the prompts), and run `cabane-companion start` again. The default runtime uses your local Claude Code subscription to run each agent turn; opencode is supported as an alternate runtime you configure per device (see the bridge README)."
+  throw new CompanionError(
+    "Claude Code, the companion\u2019s default runtime, is not on your PATH. Install it with `npm i -g @anthropic-ai/claude-code`, log in (`claude` then follow the prompts), and run `cabane-companion start` again. The default runtime uses your local Claude Code subscription to run each agent turn; opencode is supported as an alternate runtime you configure per device (see the companion README)."
   );
 }
 
@@ -1208,7 +1186,7 @@ var CabaneApi = class {
       outbox.persist({ enqueuedAt: Date.now(), turnId, seq, method: "POST", path: path3, body, kind });
       this.opts.log?.warn(
         { kind, turnId, seq, err: err instanceof Error ? err.message : String(err) },
-        "bridge: commit queued to outbox after transient failure (will drain when the API returns)"
+        "companion: commit queued to outbox after transient failure (will drain when the API returns)"
       );
     }
   }
@@ -1235,7 +1213,7 @@ var CabaneApi = class {
           if (err instanceof ApiError && err.status >= 400 && err.status < 500) {
             this.opts.log?.warn(
               { kind: entry.kind, turnId: entry.turnId, seq: entry.seq, status: err.status },
-              "bridge outbox: discarding entry on terminal 4xx (will never land)"
+              "companion outbox: discarding entry on terminal 4xx (will never land)"
             );
             outbox.remove(entry.turnId, entry.seq);
             progressed = true;
@@ -1262,7 +1240,7 @@ var CabaneApi = class {
   // the machinery the `sub_agent` turn-control tool is sugar over. Two things make
   // it distinct from an ordinary `request` call, so it does its own `fetch`:
   //   - a PER-CALL bearer — the turn's OBO token when the API minted one, else the
-  //     bridge PAT — so the spawn carries the same authority as the agent's other
+  //     companion PAT — so the spawn carries the same authority as the agent's other
   //     cabane calls this turn (mirrors build-options' `turnToken ?? agentPat`);
   //   - the `x-cabane-active-conversation` header naming the caller's turn, which
   //     the server verifies against the live run to resolve the caller pair for the
@@ -1295,15 +1273,15 @@ var CabaneApi = class {
     }
     return { status: res.status, body: parsed };
   }
-  // SJ383: bridge-only participant ops. All three authenticate with the
+  // SJ383: companion-only participant ops. All three authenticate with the
   // workspace's agent-bound PAT (passed as `token` on this client) — never
   // the user PAT.
-  // Recovery-path read: returns the bridge's `agentSessionId` for this
+  // Recovery-path read: returns the companion's `agentSessionId` for this
   // conversation so the dispatcher can pass it as `Options.resume`, plus
-  // the current `activeRunStartedAt` so a freshly-reconnected bridge can
+  // the current `activeRunStartedAt` so a freshly-reconnected companion can
   // see whether a prior run is still flagged in-flight.
   // SJ383: recovery-path read for a participant row — the `agentSessionId` a
-  // freshly-reconnected bridge resumes on. CT262: the per-turn piggybacks this
+  // freshly-reconnected companion resumes on. CT262: the per-turn piggybacks this
   // fetch grew (agentRules / visionBlocks / channel / members / conversationContext)
   // are gone — `getTurnContext` composes the whole turn now — so this is back to
   // the plain recovery read, with no `messageId` param.
@@ -1313,17 +1291,37 @@ var CabaneApi = class {
       `/api/workspaces/${workspaceId}/conversations/${conversationId}/participants/agents/${agentId}`
     );
   }
-  // CT262: the ONE turn-context fetch. Collapses the bridge's old four-fetch
+  // CT262: the ONE turn-context fetch. Collapses the companion's old four-fetch
   // choreography (getConversation + getMessage + getAgentSelf + getParticipantAgent)
   // into a single call: the server composes the whole server portion of the
   // `TurnRequest` — systemPrompt, per-turn prompt + vision content, effective
   // run-config, `HostPolicy`, prior session, the user MCP definitions to resolve
   // locally, plus the anchor/title + trigger-message summary the host needs.
   // Agent-PAT authed; the workspace is implied by the PAT.
-  getTurnContext(conversationId, messageId2) {
-    const q = `conversationId=${encodeURIComponent(conversationId)}&messageId=${encodeURIComponent(messageId2)}`;
+  // CT714: `turnId` is the host-minted id for THIS turn, passed so the server can
+  // bind the minted turn token to it — the turn-control surface then rejects a
+  // token whose turn has ended. The dispatcher mints it before this call and
+  // reuses the same value on its active-run PATCH, so the token's turn id and the
+  // pair's `active_turn_id` agree.
+  getTurnContext(conversationId, messageId2, turnId) {
+    const q = `conversationId=${encodeURIComponent(conversationId)}&messageId=${encodeURIComponent(messageId2)}` + (turnId ? `&turnId=${encodeURIComponent(turnId)}` : "");
     return this.request("GET", `/api/agent/turn-context?${q}`);
   }
+  // CT714: read a turn's recorded turn-control intent (ask/wake/summon/skip). An
+  // EXTERNAL adapter (Codex / opencode) records its turn-control verbs into
+  // `turn_intents` server-side (the URL MCP surface) rather than the dispatcher's
+  // in-memory closures, so the dispatcher fetches this once at settle — by
+  // `turnId` — and populates those closures, letting the unchanged settle path
+  // materialize the effects identically to claude-code. Agent-PAT authed +
+  // self-scoped (`:agentId` must match the PAT's agent). A turn that recorded no
+  // control verb returns all-empty fields.
+  getTurnIntent(workspaceId, conversationId, agentId, turnId) {
+    const q = `turnId=${encodeURIComponent(turnId)}`;
+    return this.request(
+      "GET",
+      `/api/workspaces/${workspaceId}/conversations/${conversationId}/participants/agents/${agentId}/turn-intent?${q}`
+    );
+  }
   // Flips `active_run_started_at` and optionally captures the SDK session
   // id. The dispatcher hits this twice per turn (now() before the SDK
   // loop; null when it settles) plus once with the session id on the
@@ -1336,7 +1334,7 @@ var CabaneApi = class {
   // `durableActiveRunWrite`). The session-id-only write (first-frame capture) is
   // left best-effort: it's lower-stakes and self-heals on the next turn, so it
   // stays a single-shot PATCH and is deliberately out of CT93's scope.
-  setBridgeActiveRun(workspaceId, conversationId, agentId, body) {
+  setActiveRun(workspaceId, conversationId, agentId, body) {
     const path3 = `/api/workspaces/${workspaceId}/conversations/${conversationId}/participants/agents/${agentId}/active-run`;
     const touchesFlag = Object.prototype.hasOwnProperty.call(body, "activeRunStartedAt");
     if (touchesFlag && this.opts.outbox) {
@@ -1379,16 +1377,16 @@ var CabaneApi = class {
       });
       this.opts.log?.warn(
         { conversationId, agentId, err: err instanceof Error ? err.message : String(err) },
-        "bridge: active-run write queued to outbox after transient failure (will drain when the API returns)"
+        "companion: active-run write queued to outbox after transient failure (will drain when the API returns)"
       );
     }
   }
   // CT29: per-device liveness moved off the per-workspace agent PAT and onto the
   // device token — see `DeviceApi.heartbeat`. There is no agent-PAT heartbeat
   // anymore.
-  // SJ477: commit one row of the bridge's turn (a `progress` interim note or
+  // SJ477: commit one row of the companion's turn (a `progress` interim note or
   // the `final` reply), derived from its own SDK transcript. Posts to the same
-  // public messages endpoint a user hits — the bridge holds an agent-bound
+  // public messages endpoint a user hits — the companion holds an agent-bound
   // PAT, so the server attributes the row to this agent (role `agent`) and
   // won't re-dispatch (the route gates re-dispatch on role `user`). `turnId`
   // groups every row of one turn so the chat drawer renders them as a single
@@ -1403,12 +1401,12 @@ var CabaneApi = class {
   // CT11: `kind` now includes `'stopped'` for the terminal marker the
   // dispatcher writes when a turn is cancelled — same wire shape as
   // `progress`/`final`, distinguished only by `kind` so the chat drawer's
-  // turn-group renderer treats it as a closing row. `seq` is the bridge's
+  // turn-group renderer treats it as a closing row. `seq` is the companion's
   // per-turn monotonic counter, stamped on the row so the merged timeline
   // orders the commit deterministically against the persisted tool/thinking
-  // rows. Both fields are optional on the wire — an older bridge that didn't
+  // rows. Both fields are optional on the wire — an older companion that didn't
   // mint seq still validates (the server defaults to 0); `stopped` is only
-  // emitted by post-CT11 bridges.
+  // emitted by post-CT11 companions.
   postTurnMessage(workspaceId, conversationId, body, signal) {
     return this.durableCommit(
       "message",
@@ -1449,11 +1447,11 @@ var CabaneApi = class {
     );
   }
   // SJ493: fetch the agent's self-view — identity + operating context. The
-  // bridge calls this on each dispatch to get its `systemPrompt` (composed
+  // companion calls this on each dispatch to get its `systemPrompt` (composed
   // server-side from the bundled default + the agent's charter) rather than
   // baking a copy of the prompt into the download. Cabane is the control plane
   // for the prompt, so changing it (or the per-agent charter) takes effect
-  // without shipping a new bridge. Agent-PAT authed; the workspace is implied
+  // without shipping a new companion. Agent-PAT authed; the workspace is implied
   // by the PAT, so no workspace arg.
   // CT245: pass the triggering turn's `conversationId` so the server returns the
   // run-config RESOLVED for this conversation (agent default + that
@@ -1464,10 +1462,10 @@ var CabaneApi = class {
     const path3 = conversationId ? `/api/agent/me?conversationId=${encodeURIComponent(conversationId)}` : `/api/agent/me`;
     return this.request("GET", path3);
   }
-  // The bridge fetches the triggering message body by listing the
+  // The companion fetches the triggering message body by listing the
   // conversation's messages and finding the one with `id === messageId`.
   // Cabane has no single-message GET endpoint; for v0 this is fine because
-  // the bridge only reaches for the specific row immediately after the
+  // the companion only reaches for the specific row immediately after the
   // event fires (the thread is small at that point).
   async getMessage(workspaceId, conversationId, messageId2) {
     const res = await this.request(
@@ -1546,7 +1544,10 @@ var DeviceApi = class {
   getAssignments() {
     return this.request("GET", "/api/companion/assignments");
   }
-  // Per-device liveness ping. Reports the bridge build version and the env-var
+  beginDrain() {
+    return this.request("POST", "/api/companion/drain", {});
+  }
+  // Per-device liveness ping. Reports the companion build version and the env-var
   // names the operator's secret store exposes (never values), so CT30's UI can
   // warn pre-emptively about an agent that needs a secret this device lacks.
   heartbeat(body) {
@@ -1573,11 +1574,11 @@ import {
   writeFileSync as writeFileSync3
 } from "fs";
 import { dirname as dirname4, join as join6 } from "path";
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 function credentialsPath() {
   return join6(cabaneDir(), "credentials.json");
 }
-var credentialStoreSchema = z4.record(z4.string(), z4.string());
+var credentialStoreSchema = z3.record(z3.string(), z3.string());
 function load() {
   const path3 = credentialsPath();
   if (!existsSync4(path3)) return {};
@@ -1781,54 +1782,55 @@ function bumpResumeAttempt(workspaceId, eventId) {
   return next;
 }
 function noResume() {
-  return process.env.CABANE_BRIDGE_NO_RESUME === "1";
+  return process.env.CABANE_COMPANION_NO_RESUME === "1";
 }
 
 // packages/agent-runtime/src/version.ts
 var TURN_PROTOCOL_VERSION = 1;
 
 // packages/agent-runtime/src/host-policy.ts
-import { z as z5 } from "zod";
-var hostPolicySchema = z5.object({
+import { z as z4 } from "zod";
+var hostPolicySchema = z4.object({
   // Host filesystem + shell: `Bash`/`Read`/`Write`/`Edit`/`Glob`/`Grep`, the
   // notebook read/write pair, git-worktree tools, and the `REPL` host code-exec
   // tool. Off under the locked assistant surface (today's `DISALLOWED_TOOLS`);
   // on under `coding` mode.
-  hostFs: z5.boolean(),
+  hostFs: z4.boolean(),
   // Public web (today's `WebSearch` / `WebFetch`, the `DEFAULT_WEB_TOOLS`). Public
   // web, not host reach — granted by default today, but expressible as a grant.
-  web: z5.boolean(),
-  // Browser automation (the Playwright MCP surface). Varies by host: a bridge has
+  web: z4.boolean(),
+  // Browser automation (the Playwright MCP surface). Varies by host: a companion has
   // it, the house executor does not (CT230).
-  browser: z5.boolean(),
+  browser: z4.boolean(),
   // User-configured MCP servers permitted. False for the house executor
-  // (CT227: Cabane agents run no user MCP servers), true for a personal bridge.
-  userMcp: z5.boolean(),
+  // (CT227: Cabane agents run no user MCP servers), true for a personal companion.
+  userMcp: z4.boolean(),
   // Subagent / sub-dispatch (`Task` / `Agent`). A per-host GRANT (see the CT261
   // amendment above): `false` on the locked assistant/house surface (banned via
   // `DISALLOWED_TOOLS`), `true` under coding / custom where the fan-out is left to
-  // `canUseTool` or the user allowlist. The subagent completes within the turn, so
+  // the coding allow-hook (which reaches sub-agent tool calls, CT680) or the user
+  // allowlist. The subagent completes within the turn, so
   // it's not the turn-model invariant `scheduling` is.
-  subagents: z5.boolean(),
+  subagents: z4.boolean(),
   // ── Hard platform invariants — always denied, never granted ────────────────
   // Deferred re-invocation / scheduling (`ScheduleWakeup`, the `Cron*` / `Task*`
   // families, `Monitor`, `Workflow`, …). A turn is one query that resolves when
   // `result` fires; a scheduled callback fires after the reply window has closed
   // and strands the agent (the CT155/CT156 rule).
-  scheduling: z5.literal("never"),
+  scheduling: z4.literal("never"),
   // Human-facing UI prompts (`AskUserQuestion`). A Cabane conversation has no
   // handler to answer a structured prompt, so the call hangs the turn
   // (`UNSUPPORTED_TOOLS`). The agent asks in its reply instead.
-  uiPrompts: z5.literal("never")
+  uiPrompts: z4.literal("never")
 });
 
 // packages/agent-runtime/src/turn-event.ts
-import { z as z6 } from "zod";
-var turnEventSchema = z6.discriminatedUnion("type", [
+import { z as z5 } from "zod";
+var turnEventSchema = z5.discriminatedUnion("type", [
   // The runtime's opaque session state, emitted when the adapter learns it (e.g.
   // the SDK `system/init` frame). The platform stores `state` verbatim per
   // (conversation, agent) and hands it back on the next turn; only the adapter
-  // knows what it means. Today's bridge captures the raw SDK session id here; a
+  // knows what it means. Today's companion captures the raw SDK session id here; a
   // future adapter may encode more (e.g. `{sdkSessionId, cwd}`) — still one
   // opaque string to the platform.
   //
@@ -1841,22 +1843,22 @@ var turnEventSchema = z6.discriminatedUnion("type", [
   // so the mark now over-reaches an empty session. The host relays `degraded`
   // on settle and the server rewinds the mark, so the NEXT turn rebuilds a full
   // catch-up (this failing turn is unavoidably lossy — the degrade is only known
-  // on the bridge, after the server committed the manifest). Runtime-neutral: a
+  // on the companion, after the server committed the manifest). Runtime-neutral: a
   // plain boolean, not a runtime-specific reason string (that stays in the
   // adapter's `onWarn` log). Additive + optional — an old receiver ignores it.
-  z6.object({
-    type: z6.literal("session"),
-    state: z6.string(),
-    degraded: z6.boolean().optional()
+  z5.object({
+    type: z5.literal("session"),
+    state: z5.string(),
+    degraded: z5.boolean().optional()
   }),
   // One readable thinking summary. Maps `onThinking({ text })`. Transient —
   // surfaced live, never persisted as durable content.
-  z6.object({ type: z6.literal("thinking"), text: z6.string() }),
+  z5.object({ type: z5.literal("thinking"), text: z5.string() }),
   // Assistant text. Maps `onAssistantText({ text, final })` — `text`→`body`,
   // `final`→`terminal`. `terminal: false` is interim narration (commits as a
   // `progress` row); `terminal: true` is the turn's closing reply (commits as
   // the `final` row).
-  z6.object({ type: z6.literal("text"), body: z6.string(), terminal: z6.boolean() }),
+  z5.object({ type: z5.literal("text"), body: z5.string(), terminal: z5.boolean() }),
   // A tool-activity transition. Maps `onToolActivity` — `toolUseId`→`id`,
   // `toolName`→`name` (already prefix-stripped: `cabane_read`, not
   // `mcp__cabane__cabane_read`), `summary` is the short card label. `phase`
@@ -1871,15 +1873,15 @@ var turnEventSchema = z6.discriminatedUnion("type", [
   // dropped the prefix; null for a host / built-in tool. The client tags Cabane
   // MCP calls (`=== 'cabane'`) with a subtle glyph. Nullable + optional so a
   // pre-CT496 producer that never sets it is unaffected (treated as null).
-  z6.object({
-    type: z6.literal("tool"),
-    id: z6.string(),
-    name: z6.string(),
-    phase: z6.enum(["start", "done", "error"]),
-    summary: z6.string(),
-    input: z6.unknown().optional(),
-    result: z6.unknown().optional(),
-    mcpServer: z6.string().nullable().optional()
+  z5.object({
+    type: z5.literal("tool"),
+    id: z5.string(),
+    name: z5.string(),
+    phase: z5.enum(["start", "done", "error"]),
+    summary: z5.string(),
+    input: z5.unknown().optional(),
+    result: z5.unknown().optional(),
+    mcpServer: z5.string().nullable().optional()
   }),
   // The turn's terminal outcome. Maps the `{ ok, reason }` both loops return
   // inline. `ok:false` carries a machine reason (`no_session`, an error code);
@@ -1889,7 +1891,7 @@ var turnEventSchema = z6.discriminatedUnion("type", [
   // dropped on the floor before. `inputTokens` is the full context the model saw
   // (uncached + cache-read + cache-creation input), so it doubles as the
   // context-window cost; `outputTokens` the generated tokens. Optional ⇒
-  // backward-compatible: an old bridge / adapter that never sets it, and a
+  // backward-compatible: an old companion / adapter that never sets it, and a
   // receiver that never reads it, are unaffected (the turn's token columns stay
   // null → the UI shows `—`).
   //
@@ -1899,6 +1901,19 @@ var turnEventSchema = z6.discriminatedUnion("type", [
   // the server just leaves the cache columns null. Captured now because honest
   // costing later prices a cache-read token far below a fresh input token.
   //
+  // CT699: `inputTokens` (and the cache slice) is a BILLING quantity — for
+  // claude-code/codex it's the runtime's CUMULATIVE total summed across every model
+  // request in the agentic turn, so it grows with the tool-call count and is NOT
+  // "how full is the window." `contextTokens` is the distinct CONTEXT-OCCUPANCY
+  // read: the input the model saw on its FINAL request of the turn (uncached +
+  // cache, since cached tokens still occupy the window) — the number the composer
+  // gauge wants. `contextWindow` is the model's true window in tokens when the
+  // runtime reports it (claude-code's SDK does, per model) — a real denominator so
+  // the gauge can show a fraction. Both optional: a runtime that can't source a
+  // clean final-request figure (codex's cumulative-only usage) omits `contextTokens`
+  // and the gauge falls back to the raw count; `contextWindow` falls back to the
+  // model catalog.
+  //
   // CT601: two more optional carry-homes on the terminal result, alongside
   // `usage`. `resolvedModel` is the CONCRETE model the runtime actually ran —
   // claude-code learns it from the `system/init` frame mid-run (even for a
@@ -1908,34 +1923,36 @@ var turnEventSchema = z6.discriminatedUnion("type", [
   // for claude-code today). Both only known after the run streams — so they ride
   // the terminal event home, the host relays them on settle, and the server writes
   // `message_turn_metadata.resolved_model` / `resolved_config`. Optional ⇒
-  // backward-compatible: an old adapter/bridge omits them, a cancel has no result
+  // backward-compatible: an old adapter/companion omits them, a cancel has no result
   // event at all, and the columns stay null → the UI shows `—`.
-  z6.object({
-    type: z6.literal("result"),
-    ok: z6.boolean(),
-    reason: z6.string().optional(),
-    usage: z6.object({
-      inputTokens: z6.number(),
-      outputTokens: z6.number(),
-      cacheReadTokens: z6.number().optional(),
-      cacheCreationTokens: z6.number().optional()
+  z5.object({
+    type: z5.literal("result"),
+    ok: z5.boolean(),
+    reason: z5.string().optional(),
+    usage: z5.object({
+      inputTokens: z5.number(),
+      outputTokens: z5.number(),
+      cacheReadTokens: z5.number().optional(),
+      cacheCreationTokens: z5.number().optional(),
+      contextTokens: z5.number().optional(),
+      contextWindow: z5.number().optional()
     }).optional(),
-    resolvedModel: z6.string().optional(),
-    resolvedConfig: z6.object({
-      effort: z6.string().optional(),
-      thinking: z6.string().optional(),
-      reasoningEffort: z6.string().optional()
+    resolvedModel: z5.string().optional(),
+    resolvedConfig: z5.object({
+      effort: z5.string().optional(),
+      thinking: z5.string().optional(),
+      reasoningEffort: z5.string().optional()
     }).optional()
   })
 ]);
 
 // packages/agent-runtime/src/failure.ts
-import { z as z7 } from "zod";
-var turnFailureSchema = z7.discriminatedUnion("kind", [
-  z7.object({ kind: z7.literal("usage_capped"), resetsAt: z7.string().optional() }),
-  z7.object({ kind: z7.literal("rate_limited") }),
-  z7.object({ kind: z7.literal("server_error") }),
-  z7.object({ kind: z7.literal("auth_expired") })
+import { z as z6 } from "zod";
+var turnFailureSchema = z6.discriminatedUnion("kind", [
+  z6.object({ kind: z6.literal("usage_capped"), resetsAt: z6.string().optional() }),
+  z6.object({ kind: z6.literal("rate_limited") }),
+  z6.object({ kind: z6.literal("server_error") }),
+  z6.object({ kind: z6.literal("auth_expired") })
 ]);
 var USAGE_CAPPED = "usage_capped";
 var RATE_LIMITED = "rate_limited";
@@ -2006,7 +2023,8 @@ function classifyErrorText(text) {
   const t = text.toLowerCase();
   if (AUTH_PATTERNS.some((re) => re.test(t))) return { kind: "auth_expired" };
   if (SERVER_PATTERNS.some((re) => re.test(t))) return { kind: "server_error" };
-  const capNoun = CAP_PATTERNS.some((re) => re.test(t));
+  const withoutNegatedCap = t.replace(NEGATED_CAP, "");
+  const capNoun = CAP_PATTERNS.some((re) => re.test(withoutNegatedCap));
   const rateToken = RATE_PATTERNS.some((re) => re.test(t));
   if (capNoun) return { kind: "usage_capped" };
   if (rateToken) return { kind: "rate_limited" };
@@ -2035,105 +2053,120 @@ var SERVER_PATTERNS = [
   /fetch failed/
 ];
 var CAP_PATTERNS = [/usage limit/, /weekly limit/, /session limit/, /\bquota\b/];
+var NEGATED_CAP = /not (your|a) usage limit/g;
 var RATE_PATTERNS = [/rate[_ ]?limit/, /\b429\b/, /too many requests/];
 var BARE_LIMIT = /\blimit (reached|exceeded)\b/;
 
 // packages/agent-runtime/src/turn-request.ts
-import { z as z8 } from "zod";
-var contentBlockSchema = z8.discriminatedUnion("type", [
-  z8.object({ type: z8.literal("text"), text: z8.string() }),
-  z8.object({
-    type: z8.literal("image"),
-    source: z8.object({ type: z8.literal("url"), url: z8.string() })
+import { z as z7 } from "zod";
+var contentBlockSchema = z7.discriminatedUnion("type", [
+  z7.object({ type: z7.literal("text"), text: z7.string() }),
+  z7.object({
+    type: z7.literal("image"),
+    source: z7.object({ type: z7.literal("url"), url: z7.string() })
   }),
-  z8.object({
-    type: z8.literal("document"),
-    source: z8.object({ type: z8.literal("url"), url: z8.string() })
+  z7.object({
+    type: z7.literal("document"),
+    source: z7.object({ type: z7.literal("url"), url: z7.string() })
   })
 ]);
-var effortLevelSchema = z8.enum(["low", "medium", "high", "xhigh", "max"]);
-var resolvedRunConfigSchema = z8.object({
-  model: z8.string().nullable(),
+var effortLevelSchema = z7.enum(["low", "medium", "high", "xhigh", "max"]);
+var resolvedRunConfigSchema = z7.object({
+  model: z7.string().nullable(),
   effort: effortLevelSchema.optional(),
-  runtimeOptions: z8.record(z8.string(), z8.unknown()).optional()
+  runtimeOptions: z7.record(z7.string(), z7.unknown()).optional()
 });
-var resolvedMcpServerSchema = z8.union([
-  z8.object({
-    type: z8.literal("stdio").optional(),
-    command: z8.string(),
-    args: z8.array(z8.string()).optional(),
-    env: z8.record(z8.string(), z8.string()).optional()
+var resolvedMcpServerSchema = z7.union([
+  z7.object({
+    type: z7.literal("stdio").optional(),
+    command: z7.string(),
+    args: z7.array(z7.string()).optional(),
+    env: z7.record(z7.string(), z7.string()).optional()
   }),
-  z8.object({
-    type: z8.literal("http"),
-    url: z8.string(),
-    headers: z8.record(z8.string(), z8.string()).optional()
+  z7.object({
+    type: z7.literal("http"),
+    url: z7.string(),
+    headers: z7.record(z7.string(), z7.string()).optional()
   }),
-  z8.object({
-    type: z8.literal("sse"),
-    url: z8.string(),
-    headers: z8.record(z8.string(), z8.string()).optional()
+  z7.object({
+    type: z7.literal("sse"),
+    url: z7.string(),
+    headers: z7.record(z7.string(), z7.string()).optional()
   })
 ]);
-var resolvedMcpServersSchema = z8.record(z8.string(), resolvedMcpServerSchema);
-var hostInjectedServersSchema = z8.record(z8.string(), z8.unknown());
-var turnRequestSchema = z8.object({
+var resolvedMcpServersSchema = z7.record(z7.string(), resolvedMcpServerSchema);
+var hostInjectedServersSchema = z7.record(z7.string(), z7.unknown());
+var turnRequestSchema = z7.object({
   // Server-composed system prompt (core + capability prose + adapter addendum +
   // charter). One string to the adapter.
-  systemPrompt: z8.string(),
+  systemPrompt: z7.string(),
   // Server-composed per-turn user text (anchor reminder + the triggering message).
-  prompt: z8.string(),
+  prompt: z7.string(),
   // The multi-block user-message body (text + vision).
-  content: z8.array(contentBlockSchema),
+  content: z7.array(contentBlockSchema),
   // Portable-or-dialect run-config (above).
   config: resolvedRunConfigSchema,
   // Abstract capability grants; the adapter maps them to tool names.
   policy: hostPolicySchema,
   // Prior opaque session state, or null for a fresh session.
-  session: z8.string().nullable(),
+  session: z7.string().nullable(),
   // The cabane control-plane coordinates for this turn's MCP + post-back.
-  cabane: z8.object({
-    mcpUrl: z8.string(),
-    bearer: z8.string(),
-    activeConversationId: z8.string(),
+  cabane: z7.object({
+    mcpUrl: z7.string(),
+    bearer: z7.string(),
+    activeConversationId: z7.string(),
+    // CT714: the scoped TURN-CONTROL MCP endpoint (`/api/turn-control`). The
+    // EXTERNAL adapters (Codex / opencode) mount it by URL under the key
+    // `cabane_companion` — using the same `bearer` (the turn token) and the same
+    // active-conversation header they send to the `cabane` server — so their
+    // agents get `ask`/`wake_me`/`summon_agent`/`sub_agent`/`skip_turn`, the
+    // verbs they can't get from the companion's in-process SDK server. Optional:
+    // claude-code ignores it (it mounts the in-process instance instead), and
+    // every existing `cabane`-block fixture keeps parsing unchanged; the
+    // companion always populates it (`build-options.ts`).
+    turnControlUrl: z7.string().optional(),
     // CT598: the workspace this turn runs in. The claude-code/opencode/codex
     // adapters never need it (they reach Cabane through the `cabane` MCP server,
     // which takes `workspaceId` as a per-tool arg the model supplies); the
     // native runtime's interim tool surface calls the workspace-scoped REST API
     // DIRECTLY, so it needs the id host-side rather than trusting the model to
     // pass it. Optional so every existing `cabane`-block constructor (the three
-    // adapters' conformance fixtures, tests) keeps parsing unchanged — the bridge
+    // adapters' conformance fixtures, tests) keeps parsing unchanged — the companion
     // always populates it (`build-options.ts`), and the native adapter fails the
     // turn loudly when it is somehow absent rather than guessing.
-    workspaceId: z8.string().optional()
+    workspaceId: z7.string().optional(),
+    // CT752: the server-resolved workspace surface this credential exposes.
+    // Readiness uses this explicit fact to require `sdk` for code mode and the
+    // granular floor for classic mode; inventory contents alone cannot infer it
+    // because `sdk` is intentionally also available on the classic surface.
+    workspaceToolSurface: z7.enum(["code", "classic"]).optional()
   }),
   // Machine-local resolution (host-filled): the checkout cwd, extra env from a
   // prepare hook, and the resolved user MCP servers.
-  local: z8.object({
-    cwd: z8.string().optional(),
-    env: z8.record(z8.string(), z8.string()).optional(),
+  local: z7.object({
+    cwd: z7.string().optional(),
+    env: z7.record(z7.string(), z7.string()).optional(),
     mcpServers: resolvedMcpServersSchema.optional(),
     // CT289: machine-local claude-code adapter knobs the operator sets on a
-    // bridge they run themselves — the auto-memory escape hatch. `autoMemory:
+    // companion they run themselves — the auto-memory escape hatch. `autoMemory:
     // true` opts back into Claude Code's auto-memory (governed by the operator's
     // own `.claude/settings.json`); absent/false leaves the adapter's force-off
-    // default in place (see `buildClaudeCodeOptions`). The house device never
-    // sets it, so house stays force-off unconditionally.
-    claudeCode: z8.object({ autoMemory: z8.boolean().optional() }).optional()
+    // default in place (see `buildClaudeCodeOptions`).
+    claudeCode: z7.object({ autoMemory: z7.boolean().optional() }).optional()
   }),
   // Host-owned injected servers (host-filled) — e.g. the summon server.
-  extra: z8.object({
+  extra: z7.object({
     mcpServers: hostInjectedServersSchema
   })
 });
 
 // packages/agent-runtime/src/conformance.ts
-import { z as z9 } from "zod";
-var conformanceFixtureSchema = z9.object({
-  name: z9.string(),
+import { z as z8 } from "zod";
+var conformanceFixtureSchema = z8.object({
+  name: z8.string(),
   request: turnRequestSchema,
-  nativeStream: z9.array(z9.unknown()),
-  expected: z9.array(turnEventSchema)
+  nativeStream: z8.array(z8.unknown()),
+  expected: z8.array(turnEventSchema)
 });
 
 // packages/agent-runtime/src/transcript.ts
@@ -2438,7 +2471,7 @@ import {
 var CLAUDE_CODE_ADDENDUM = "";
 
 // packages/agent-runtime/src/claude-code/policy.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 var HOST_FS_TOOLS = [
   // shell + local filesystem
   "Bash",
@@ -2488,30 +2521,20 @@ function withThinkingSummaries(thinking) {
   if (thinking.type === "disabled") return thinking;
   return { display: "summarized", ...thinking };
 }
-var claudeCodeDialectSchema = z10.object({
-  thinking: z10.discriminatedUnion("type", [
-    z10.object({
-      type: z10.literal("adaptive"),
-      display: z10.enum(["summarized", "omitted"]).optional()
+var claudeCodeDialectSchema = z9.object({
+  thinking: z9.discriminatedUnion("type", [
+    z9.object({
+      type: z9.literal("adaptive"),
+      display: z9.enum(["summarized", "omitted"]).optional()
     }),
-    z10.object({
-      type: z10.literal("enabled"),
-      budgetTokens: z10.number().int().positive().optional(),
-      display: z10.enum(["summarized", "omitted"]).optional()
+    z9.object({
+      type: z9.literal("enabled"),
+      budgetTokens: z9.number().int().positive().optional(),
+      display: z9.enum(["summarized", "omitted"]).optional()
     }),
-    z10.object({ type: z10.literal("disabled") })
+    z9.object({ type: z9.literal("disabled") })
   ]).optional(),
-  allowedTools: z10.array(z10.string()).optional(),
-  disallowedTools: z10.array(z10.string()).optional(),
-  // Which claude-code harness shape to run. `coding` switches to the
-  // `claude_code` preset + project settings + always-allow `canUseTool`;
-  // `custom`/`assistant` (or absent) use a plain-string prompt + bypass. This
-  // is the claude-code-specific PRESET selector — kept distinct from
-  // `policy.hostFs` (the host-fs BLOCK), because bridge `custom` mode wants host
-  // fs available (via its own allowlist) WITHOUT the coding harness, and in-app
-  // `custom` wants host fs blocked — neither of which a single `hostFs` boolean
-  // can express alongside the preset choice.
-  mode: z10.enum(["assistant", "coding", "custom"]).optional()
+  hostAccess: z9.boolean().optional()
 }).loose();
 function readThinking(runtimeOptions) {
   const dialect = runtimeOptions?.["claude-code"];
@@ -2555,10 +2578,18 @@ function decideResume(stored, currentCwd) {
 // packages/agent-runtime/src/claude-code/options.ts
 var CABANE_MCP_SERVER = "cabane";
 var ACTIVE_CONVERSATION_HEADER2 = "x-cabane-active-conversation";
-var allowEverything = async (_toolName, input) => ({
-  behavior: "allow",
-  updatedInput: input
-});
+async function allowEverythingHook(input) {
+  const toolInput = "tool_input" in input && input.tool_input && typeof input.tool_input === "object" ? input.tool_input : {};
+  return {
+    continue: true,
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow",
+      permissionDecisionReason: "coding mode: headless never-prompt (CT680)",
+      updatedInput: toolInput
+    }
+  };
+}
 function buildClaudeCodeOptions(req, augment) {
   const { policy, config } = req;
   const cwd = req.local.cwd;
@@ -2582,18 +2613,15 @@ function buildClaudeCodeOptions(req, augment) {
     };
   }
   const dialect = claudeCodeDialectSchema.safeParse(config.runtimeOptions?.["claude-code"] ?? {});
-  const customAllowed = dialect.success ? dialect.data.allowedTools ?? [] : [];
-  const customDisallowed = dialect.success ? dialect.data.disallowedTools ?? [] : [];
-  const useCodingPreset = (dialect.success ? dialect.data.mode : void 0) === "coding";
+  const useCodingPreset = dialect.success ? dialect.data.hostAccess ?? false : false;
   const cabaneGlob = `mcp__${CABANE_MCP_SERVER}__*`;
   const extraServerGlobs = Object.keys(req.extra.mcpServers).map((name) => `mcp__${name}__*`);
   const allowedTools = dedupe([
     cabaneGlob,
     ...extraServerGlobs,
-    ...policy.web ? DEFAULT_WEB_TOOLS : [],
-    ...customAllowed
+    ...policy.web ? DEFAULT_WEB_TOOLS : []
   ]);
-  const disallowedTools = dedupe([...disallowedToolsFor(policy), ...customDisallowed]);
+  const disallowedTools = dedupe([...disallowedToolsFor(policy)]);
   const resumeDecision = decideResume(req.session, cwd);
   const resume = "resume" in resumeDecision ? resumeDecision.resume : null;
   const freshReason = "fresh" in resumeDecision ? resumeDecision.reason : void 0;
@@ -2619,7 +2647,7 @@ function buildClaudeCodeOptions(req, augment) {
     ...devControlsAutoMemory ? {} : { settings: { autoMemoryEnabled: false } },
     mcpServers,
     ...cwd ? { cwd } : {},
-    // Extra env (a bridge prepare hook's tokens/ports; the in-app's debug flags)
+    // Extra env (a companion prepare hook's tokens/ports; the in-app's debug flags)
     // merged OVER the inherited environment.
     ...req.local.env ? { env: { ...process.env, ...req.local.env } } : {},
     ...resume ? { resume } : {}
@@ -2632,7 +2660,7 @@ function buildClaudeCodeOptions(req, augment) {
       settingSources: ["project"],
       allowedTools,
       disallowedTools,
-      canUseTool: allowEverything
+      hooks: { PreToolUse: [{ hooks: [allowEverythingHook] }] }
     };
   } else {
     options = {
@@ -2663,9 +2691,11 @@ async function* decodeSdkStream(iter, ctx) {
   let resultReason;
   let sawResult = false;
   let usage;
+  let lastRequestContextTokens;
   let resolvedModel;
   let sawRejectedLimit = false;
   let rateLimitResetIso;
+  let rateLimitType;
   let authError;
   let lastAssistantError;
   try {
@@ -2688,6 +2718,8 @@ async function* decodeSdkStream(iter, ctx) {
         if (typeof assistantErr === "string" && assistantErr.length > 0) {
           lastAssistantError = assistantErr;
         }
+        const reqContext = readRequestContextTokens(msg);
+        if (reqContext !== void 0) lastRequestContextTokens = reqContext;
         await processAssistantMessage(msg, emit, pending, buffer);
         yield* drain(out);
       } else if (msg.type === "user") {
@@ -2698,6 +2730,7 @@ async function* decodeSdkStream(iter, ctx) {
         if (info?.status === "rejected") {
           sawRejectedLimit = true;
           rateLimitResetIso = resetsAtToIso(info.resetsAt) ?? rateLimitResetIso;
+          if (typeof info.rateLimitType === "string") rateLimitType = info.rateLimitType;
         }
       } else if (msg.type === "auth_status") {
         const err = msg.error;
@@ -2705,6 +2738,12 @@ async function* decodeSdkStream(iter, ctx) {
       } else if (msg.type === "result") {
         sawResult = true;
         usage = readSdkUsage(msg);
+        if (usage) {
+          if (lastRequestContextTokens !== void 0)
+            usage.contextTokens = lastRequestContextTokens;
+          const window = readContextWindow(msg, resolvedModel);
+          if (window !== void 0) usage.contextWindow = window;
+        }
         const isError = msg.is_error === true;
         if (msg.subtype === "success" && !isError) {
           ok = true;
@@ -2715,7 +2754,8 @@ async function* decodeSdkStream(iter, ctx) {
           const errorText = [resultText, ...Array.isArray(errors) ? errors.map(String) : []].join(
             " "
           );
-          const failure = sawRejectedLimit || terminalReason === "blocking_limit" ? {
+          const rejectedIsCap = sawRejectedLimit && (rateLimitResetIso !== void 0 || isSubscriptionWindow(rateLimitType));
+          const failure = rejectedIsCap || terminalReason === "blocking_limit" ? {
             kind: "usage_capped",
             ...rateLimitResetIso ? { resetsAt: rateLimitResetIso } : {}
           } : classifyAssistantError(lastAssistantError) ?? classifyErrorText([authError, errorText].filter(Boolean).join(" "));
@@ -2745,6 +2785,9 @@ async function* decodeSdkStream(iter, ctx) {
     ...resolvedModel ? { resolvedModel } : {}
   };
 }
+function isSubscriptionWindow(value) {
+  return value === "five_hour" || value === "seven_day" || value === "seven_day_opus" || value === "seven_day_sonnet" || value === "overage";
+}
 function* drain(out) {
   while (out.length > 0) yield out.shift();
 }
@@ -2758,6 +2801,27 @@ function readSdkUsage(msg) {
   const outputTokens = num(usage.output_tokens);
   return { inputTokens, outputTokens, cacheReadTokens, cacheCreationTokens };
 }
+function readRequestContextTokens(msg) {
+  const usage = msg.message?.usage;
+  if (!usage || typeof usage !== "object") return void 0;
+  const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+  return num(usage.input_tokens) + num(usage.cache_read_input_tokens) + num(usage.cache_creation_input_tokens);
+}
+function readContextWindow(msg, resolvedModel) {
+  const modelUsage = msg.modelUsage;
+  if (!modelUsage || typeof modelUsage !== "object") return void 0;
+  const pos = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : void 0;
+  if (resolvedModel) {
+    const direct = pos(modelUsage[resolvedModel]?.contextWindow);
+    if (direct !== void 0) return direct;
+  }
+  let max;
+  for (const entry of Object.values(modelUsage)) {
+    const w = pos(entry?.contextWindow);
+    if (w !== void 0 && (max === void 0 || w > max)) max = w;
+  }
+  return max;
+}
 
 // packages/agent-runtime/src/claude-code/prompt-input.ts
 function buildQueryPrompt(req) {
@@ -2875,9 +2939,13 @@ var resultErrorFull = (subtype, extra = {}) => ({
   session_id: "s",
   ...extra
 });
-var rateLimitEvent = (status, resetsAt) => ({
+var rateLimitEvent = (status, resetsAt, rateLimitType) => ({
   type: "rate_limit_event",
-  rate_limit_info: { status, ...resetsAt !== void 0 ? { resetsAt } : {} },
+  rate_limit_info: {
+    status,
+    ...resetsAt !== void 0 ? { resetsAt } : {},
+    ...rateLimitType !== void 0 ? { rateLimitType } : {}
+  },
   session_id: "s"
 });
 var authStatus = (error) => ({
@@ -3041,17 +3109,16 @@ var CLAUDE_CODE_CONFORMANCE_FIXTURES = [
     ]
   },
   {
-    // CT558/CT592: a subscription cap. The SDK emits a `rate_limit_event` with
-    // `status: 'rejected'`; the terminal error result then classifies as the
-    // structured `usage_capped` reason (reset-less here — the reset-time extraction
-    // is pinned by a focused unit test, off the wall clock). Partial narration lands
-    // as `progress`. CT592: the cap event is `usage_capped`, distinct from a 429.
+    // CT558/CT592/CT731: a subscription cap. The SDK emits a rejected
+    // `rate_limit_event` with a named subscription window; the terminal error result
+    // then classifies as the structured `usage_capped` reason. Partial narration
+    // lands as `progress`. The cap event is distinct from a provider 429 throttle.
     name: "subscription cap \u2192 usage_capped",
     request: makeRequest(),
     nativeStream: [
       init("s1"),
       assistantText("Let me work on that."),
-      rateLimitEvent("rejected"),
+      rateLimitEvent("rejected", void 0, "five_hour"),
       resultError("error_during_execution")
     ],
     expected: [
@@ -3414,7 +3481,7 @@ function sealHeld(held, terminal) {
 }
 
 // packages/agent-runtime/src/opencode/policy.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 var OPENCODE_HOST_TOOLS = [
   "bash",
   "edit",
@@ -3441,8 +3508,8 @@ function opencodeToolPolicy(policy) {
   deny(OPENCODE_UI_PROMPT_TOOLS);
   return { tools, allowAllHostTools: policy.hostFs };
 }
-var opencodeDialectSchema = z11.object({
-  agent: z11.string().min(1).optional()
+var opencodeDialectSchema = z10.object({
+  agent: z10.string().min(1).optional()
 }).loose();
 function readOpencodeDialect(runtimeOptions) {
   const parsed = opencodeDialectSchema.safeParse(runtimeOptions?.["opencode"] ?? {});
@@ -3458,6 +3525,7 @@ function parseOpencodeModel(model) {
 
 // packages/agent-runtime/src/opencode/run-spec.ts
 var CABANE_MCP_SERVER2 = "cabane";
+var TURN_CONTROL_MCP_SERVER = "cabane_companion";
 var ACTIVE_CONVERSATION_HEADER3 = "x-cabane-active-conversation";
 function buildRunSpec(req, resumeSessionId) {
   const { policy, config } = req;
@@ -3519,6 +3587,17 @@ function buildMcp(req) {
     },
     enabled: true
   };
+  if (req.cabane.turnControlUrl) {
+    mcp[TURN_CONTROL_MCP_SERVER] = {
+      type: "remote",
+      url: req.cabane.turnControlUrl,
+      headers: {
+        Authorization: `Bearer ${req.cabane.bearer}`,
+        [ACTIVE_CONVERSATION_HEADER3]: req.cabane.activeConversationId
+      },
+      enabled: true
+    };
+  }
   for (const [name, raw] of Object.entries(req.extra.mcpServers)) {
     const server = raw;
     if (typeof server.url === "string") {
@@ -3784,7 +3863,7 @@ var opencodeAdapter = createOpencodeAdapter();
 // packages/agent-runtime/src/opencode/conformance.ts
 var ABORT_SENTINEL2 = { __abortHere: true };
 var NEW_SESSION_ID = "sess_new";
-var BRIDGE_POLICY = {
+var COMPANION_POLICY = {
   hostFs: false,
   web: true,
   browser: true,
@@ -3800,7 +3879,7 @@ function makeRequest2(overrides = {}) {
     prompt: "hi there",
     content: [{ type: "text", text: "hi there" }],
     config: { model: "deepseek/deepseek-chat" },
-    policy: BRIDGE_POLICY,
+    policy: COMPANION_POLICY,
     session: null,
     cabane: { mcpUrl: "https://cabane.test/api/mcp", bearer: "tok", activeConversationId: "conv" },
     local: { cwd: DIR },
@@ -4148,13 +4227,19 @@ var CODEX_ADDENDUM = [
   "as the turn\u2019s reply."
 ].join(" ");
 var CODEX_ADDENDUM_CODE_MODE = [
-  "Your one Cabane workspace tool has a plain name \u2014 `sdk` (you act on the",
-  "workspace by writing a TypeScript program and calling `sdk` with it); the",
+  "Your Cabane workspace tool is exposed to Codex as the qualified MCP tool",
+  "`mcp__cabane__sdk`. On Codex versions that defer MCP tools, locate it in the",
+  "`functions.exec` deferred-tool inventory and invoke that exact qualified tool",
+  "from the exec program; do not look for or call a bare top-level `sdk` tool.",
+  "If discovery or an invocation fails, report the recorded tool error; never",
+  "declare the SDK absent without attempting discovery and invocation. The SDK",
+  "call runs a TypeScript program against the ambient `cabane` object. The",
   "turn-control verbs (`ask`, `wake_me`, `summon_agent`, `skip_turn`) are",
-  "plain-named too. There is no `read`/`write`/`search`/`edit` tool here \u2014 those",
+  "qualified `mcp__cabane_companion__\u2026` tools (and may be deferred too). There is",
+  "no Cabane `read`/`write`/`search`/`edit` tool here \u2014 those",
   "are `cabane` SDK calls inside your program, not tools. If a tool appears in this",
-  "prompt with an `mcp__\u2026__` prefix, that prefix is not part of its name \u2014 call the",
-  "tool by its plain verb. Write your closing reply as the last thing you say in the",
+  "prompt with an `mcp__\u2026__` prefix, preserve that qualified name. Write your",
+  "closing reply as the last thing you say in the",
   "turn: you can interleave narration with tool calls, but only your final message",
   "is recorded as the turn\u2019s reply."
 ].join(" ");
@@ -4181,7 +4266,7 @@ function readItemMessage(item) {
 function isModelMetadataError(message) {
   return message.includes("Defaulting to fallback metadata");
 }
-function readToolItem(item) {
+function readToolItem(item, eventType) {
   const type = str(item.type);
   const id = str(item.id);
   if (!type || !id) return null;
@@ -4225,7 +4310,12 @@ function readToolItem(item) {
   }
   if (type === "web_search") {
     const query = str(item.query) ?? "";
-    return { id, name: "web_search", input: { query }, status: toStatus(item.status) };
+    return {
+      id,
+      name: "web_search",
+      input: { query },
+      status: eventType === "item.completed" ? "completed" : "in_progress"
+    };
   }
   return null;
 }
@@ -4343,7 +4433,7 @@ async function* decodeCodexStream(events, ctx) {
         if (text) yield { type: "thinking", text };
         continue;
       }
-      const tool2 = readToolItem(item);
+      const tool2 = readToolItem(item, ev.type);
       if (!tool2) continue;
       yield* flushInterim();
       const name = prettyToolName(tool2.name);
@@ -4421,20 +4511,23 @@ function sealHeld2(held, terminal) {
 }
 
 // packages/agent-runtime/src/codex/policy.ts
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 function codexToolPolicy(policy) {
-  return {
-    sandboxMode: policy.hostFs ? "workspace-write" : "read-only",
+  return policy.hostFs ? {
+    permissionProfile: "cabane-coding",
+    approvalPolicy: "never",
+    networkAccessEnabled: policy.web
+  } : {
+    sandboxMode: "read-only",
     // Headless: the sandbox is the boundary; never pause for a human.
     approvalPolicy: "never",
-    // Only consulted under workspace-write; the public-web grant governs whether
-    // Codex's shell commands may reach the network.
+    // Retained in the policy value for symmetry; read-only ignores it.
     networkAccessEnabled: policy.web
   };
 }
 var CODEX_REASONING_EFFORTS = ["minimal", "low", "medium", "high", "xhigh"];
-var codexDialectSchema = z12.object({
-  modelReasoningEffort: z12.enum(CODEX_REASONING_EFFORTS).optional()
+var codexDialectSchema = z11.object({
+  modelReasoningEffort: z11.enum(CODEX_REASONING_EFFORTS).optional()
 }).loose();
 function readCodexDialect(runtimeOptions) {
   const parsed = codexDialectSchema.safeParse(runtimeOptions?.["codex"] ?? {});
@@ -4442,7 +4535,7 @@ function readCodexDialect(runtimeOptions) {
 }
 
 // packages/agent-runtime/src/codex/model.ts
-var CODEX_DEFAULT_MODEL_BARES = /* @__PURE__ */ new Set(["default", "codex"]);
+var CODEX_DEFAULT_MODEL_BARES = /* @__PURE__ */ new Set(["default"]);
 function parseCodexModel(model) {
   const sep = model.indexOf("/");
   const bare = sep === -1 || model.slice(0, sep) !== "openai" ? model : model.slice(sep + 1);
@@ -4451,6 +4544,7 @@ function parseCodexModel(model) {
 
 // packages/agent-runtime/src/codex/run-spec.ts
 var CABANE_MCP_SERVER3 = "cabane";
+var TURN_CONTROL_MCP_SERVER2 = "cabane_companion";
 var ACTIVE_CONVERSATION_HEADER4 = "x-cabane-active-conversation";
 function buildRunSpec2(req, resumeThreadId) {
   const { policy, config } = req;
@@ -4481,13 +4575,15 @@ function buildConfig(req) {
     if ("url" in server) {
       mcp_servers[name] = {
         url: server.url,
-        ...server.headers ? { http_headers: server.headers } : {}
+        ...server.headers ? { http_headers: server.headers } : {},
+        default_tools_approval_mode: "approve"
       };
     } else if ("command" in server) {
       mcp_servers[name] = {
         command: server.command,
         ...server.args ? { args: server.args } : {},
-        ...server.env ? { env: server.env } : {}
+        ...server.env ? { env: server.env } : {},
+        default_tools_approval_mode: "approve"
       };
     }
   }
@@ -4496,12 +4592,14 @@ function buildConfig(req) {
     if (typeof server.url === "string") {
       mcp_servers[name] = {
         url: server.url,
-        ...isStringRecord2(server.headers) ? { http_headers: server.headers } : {}
+        ...isStringRecord2(server.headers) ? { http_headers: server.headers } : {},
+        default_tools_approval_mode: "approve"
       };
     } else if (typeof server.command === "string") {
       mcp_servers[name] = {
         command: server.command,
-        ...Array.isArray(server.args) ? { args: server.args } : {}
+        ...Array.isArray(server.args) ? { args: server.args } : {},
+        default_tools_approval_mode: "approve"
       };
     }
   }
@@ -4513,13 +4611,48 @@ function buildConfig(req) {
     },
     default_tools_approval_mode: "approve"
   };
-  return { mcp_servers, experimental_use_rmcp_client: true };
+  if (req.cabane.turnControlUrl) {
+    mcp_servers[TURN_CONTROL_MCP_SERVER2] = {
+      url: req.cabane.turnControlUrl,
+      http_headers: {
+        Authorization: `Bearer ${req.cabane.bearer}`,
+        [ACTIVE_CONVERSATION_HEADER4]: req.cabane.activeConversationId
+      },
+      default_tools_approval_mode: "approve"
+    };
+  }
+  const policy = codexToolPolicy(req.policy);
+  const tmpDir = req.local.env?.TMPDIR;
+  return {
+    mcp_servers,
+    experimental_use_rmcp_client: true,
+    ...tmpDir ? { shell_environment_policy: { set: { TMPDIR: tmpDir } } } : {},
+    ...policy.permissionProfile ? {
+      // CT733: named permission profiles are Codex's split-filesystem path.
+      // `:root = read` preserves coding-mode host reads; the one explicit
+      // workspace-root write grants the checkout, and the more-specific
+      // `.git` write reopens the metadata Codex protects by default. Neither
+      // rule grants an adjacent directory. Do not combine this with legacy `sandbox_mode` /
+      // `sandbox_workspace_write`, which would restore the `.git` carve-out.
+      approval_policy: policy.approvalPolicy,
+      default_permissions: policy.permissionProfile,
+      permissions: {
+        [policy.permissionProfile]: {
+          filesystem: {
+            ":root": "read",
+            ":workspace_roots": { ".": "write", ".git": "write" }
+          },
+          network: { enabled: policy.networkAccessEnabled, mode: "full" }
+        }
+      }
+    } : {}
+  };
 }
 function isStringRecord2(v) {
   return !!v && typeof v === "object" && Object.values(v).every((x) => typeof x === "string");
 }
 
-// node_modules/.pnpm/@openai+codex-sdk@0.144.6/node_modules/@openai/codex-sdk/dist/index.js
+// node_modules/.pnpm/@openai+codex-sdk@0.146.0/node_modules/@openai/codex-sdk/dist/index.js
 import { promises as fs } from "fs";
 import os from "os";
 import path from "path";
@@ -4608,6 +4741,8 @@ var Thread = class {
         }
         if (parsed.type === "thread.started") {
           this._id = parsed.thread_id;
+        } else if (parsed.type === "turn.completed") {
+          parsed.usage.cache_write_input_tokens ??= 0;
         }
         yield parsed;
       }
@@ -5047,6 +5182,17 @@ var Codex = class {
 };
 
 // packages/agent-runtime/src/codex/transport.ts
+function buildSdkThreadOptions(spec) {
+  return {
+    ...spec.model ? { model: spec.model } : {},
+    ...spec.policy.sandboxMode ? { sandboxMode: spec.policy.sandboxMode } : {},
+    workingDirectory: spec.directory,
+    skipGitRepoCheck: spec.skipGitRepoCheck,
+    ...spec.policy.sandboxMode ? { approvalPolicy: spec.policy.approvalPolicy } : {},
+    ...spec.policy.sandboxMode === "workspace-write" ? { networkAccessEnabled: spec.policy.networkAccessEnabled } : {},
+    ...spec.modelReasoningEffort ? { modelReasoningEffort: spec.modelReasoningEffort } : {}
+  };
+}
 function createSdkCodexTransport(opts = {}) {
   return {
     async run(spec, signal) {
@@ -5060,17 +5206,7 @@ function createSdkCodexTransport(opts = {}) {
         config: spec.config
       };
       const codex = new Codex(codexOptions);
-      const threadOptions = {
-        ...spec.model ? { model: spec.model } : {},
-        sandboxMode: spec.policy.sandboxMode,
-        workingDirectory: spec.directory,
-        skipGitRepoCheck: spec.skipGitRepoCheck,
-        approvalPolicy: spec.policy.approvalPolicy,
-        // `networkAccessEnabled` only bites under `workspace-write` (read-only
-        // denies command network regardless); set it there off the `web` grant.
-        ...spec.policy.sandboxMode === "workspace-write" ? { networkAccessEnabled: spec.policy.networkAccessEnabled } : {},
-        ...spec.modelReasoningEffort ? { modelReasoningEffort: spec.modelReasoningEffort } : {}
-      };
+      const threadOptions = buildSdkThreadOptions(spec);
       const thread = spec.resumeThreadId ? codex.resumeThread(spec.resumeThreadId, threadOptions) : codex.startThread(threadOptions);
       const streamed = await thread.runStreamed(spec.input, { signal });
       return { events: streamed.events };
@@ -5127,7 +5263,7 @@ var codexAdapter = createCodexAdapter();
 // packages/agent-runtime/src/codex/conformance.ts
 var ABORT_SENTINEL3 = { __abortHere: true };
 var NEW_THREAD_ID = "th_new";
-var BRIDGE_POLICY2 = {
+var COMPANION_POLICY2 = {
   hostFs: false,
   web: true,
   browser: true,
@@ -5148,7 +5284,7 @@ function makeRequest3(overrides = {}) {
     // emitted → their expected results stay unchanged; a dedicated capture fixture
     // sets a real model + effort.
     config: { model: null },
-    policy: BRIDGE_POLICY2,
+    policy: COMPANION_POLICY2,
     session: null,
     cabane: { mcpUrl: "https://cabane.test/api/mcp", bearer: "tok", activeConversationId: "conv" },
     local: { cwd: DIR2 },
@@ -5312,6 +5448,75 @@ var CODEX_CONFORMANCE_FIXTURES = [
       { type: "result", ok: true }
     ]
   },
+  {
+    // CT715: web_search LIFECYCLE. Unlike the other three tool kinds, a `web_search`
+    // item carries NO `status` field — completion is signaled by the frame TYPE
+    // (`item.started` → `item.completed`). The `start` fires off the first frame
+    // (empty query, no output card); the `done` must resolve off `item.completed`
+    // and carry the populated query the completed frame filled in. Before CT715 the
+    // card was pinned at "running" forever (status derived from a missing field).
+    name: "web_search lifecycle \u2014 completes off frame type, populated query on done",
+    request: makeRequest3(),
+    nativeStream: [
+      threadStarted(NEW_THREAD_ID),
+      toolFrame("item.started", { id: "ws1", type: "web_search", query: "" }),
+      toolFrame("item.completed", { id: "ws1", type: "web_search", query: "best pizza in nyc" }),
+      turnCompleted()
+    ],
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      {
+        type: "tool",
+        id: "ws1",
+        name: "web_search",
+        phase: "start",
+        summary: "",
+        input: { query: "" }
+      },
+      {
+        type: "tool",
+        id: "ws1",
+        name: "web_search",
+        phase: "done",
+        summary: "best pizza in nyc",
+        input: { query: "best pizza in nyc" }
+      },
+      { type: "result", ok: true }
+    ]
+  },
+  {
+    // CT715: a non-text web action (`action.type: "other"`) legitimately completes
+    // with an EMPTY query — that's Codex's own data, not our bug. It must still
+    // resolve to `done` (empty query acceptable; stuck-running is not).
+    name: "web_search lifecycle \u2014 empty-query completion still resolves to done",
+    request: makeRequest3(),
+    nativeStream: [
+      threadStarted(NEW_THREAD_ID),
+      toolFrame("item.started", { id: "ws2", type: "web_search", query: "" }),
+      toolFrame("item.completed", { id: "ws2", type: "web_search", query: "" }),
+      turnCompleted()
+    ],
+    expected: [
+      sessionEvent3(NEW_THREAD_ID),
+      {
+        type: "tool",
+        id: "ws2",
+        name: "web_search",
+        phase: "start",
+        summary: "",
+        input: { query: "" }
+      },
+      {
+        type: "tool",
+        id: "ws2",
+        name: "web_search",
+        phase: "done",
+        summary: "",
+        input: { query: "" }
+      },
+      { type: "result", ok: true }
+    ]
+  },
   {
     // HIGHEST-RISK: cancel mid-stream. The abort lands after the tool result; the
     // adapter stops before the closing reply — no final text, no `result` event.
@@ -5603,560 +5808,6 @@ var CODEX_CONFORMANCE_FIXTURES = [
   }
 ];
 
-// packages/agent-runtime/src/cabane-native/addendum.ts
-var CABANE_NATIVE_ADDENDUM = `## Your tools (native runtime)
-
-You are running on Cabane's own agent runtime. You have a small, fixed set of workspace tools, all prefixed \`cabane_\`:
-
-- \`cabane_list\` \u2014 list a folder's files and subfolders.
-- \`cabane_read\` \u2014 read one file's contents by path.
-- \`cabane_search\` \u2014 substring search across file names and contents.
-- \`cabane_write\` \u2014 create or overwrite a file (pass \`overwrite: true\` to replace).
-- \`cabane_edit\` \u2014 find/replace inside an existing file.
-
-Paths are workspace-relative with a leading slash (\`/notes/todo.md\`). This is a deliberately small interim tool set \u2014 if a job needs an operation that isn't here, say so plainly in your reply rather than inventing a tool. Your reply text is streamed straight into the conversation; there is no separate send step.`;
-
-// packages/agent-runtime/src/cabane-native/context.ts
-var DEFAULT_HISTORY_LIMIT = 20;
-var DEFAULT_MAX_HISTORY_CHARS = 24e3;
-async function assembleMessages(systemPrompt, content, fallbackPrompt, opts) {
-  const messages = [{ role: "system", content: systemPrompt }];
-  const history = await fetchRecentHistory(opts);
-  for (const m of history) messages.push(m);
-  messages.push({ role: "user", content: currentUserText(content, fallbackPrompt) });
-  return messages;
-}
-function currentUserText(content, fallbackPrompt) {
-  const text = content.filter((b) => b.type === "text").map((b) => b.text).join("\n").trim();
-  return text.length > 0 ? text : fallbackPrompt;
-}
-async function fetchRecentHistory(opts) {
-  const doFetch = opts.fetchImpl ?? fetch;
-  const limit = opts.historyLimit ?? DEFAULT_HISTORY_LIMIT;
-  const url = new URL(
-    `${opts.apiRoot}/workspaces/${opts.workspaceId}/conversations/${opts.conversationId}/messages`
-  );
-  url.searchParams.set("limit", String(limit));
-  url.searchParams.set("order", "desc");
-  let rows;
-  try {
-    const res = await doFetch(url.toString(), {
-      headers: { Authorization: `Bearer ${opts.bearer}` }
-    });
-    if (!res.ok) return [];
-    const body = await res.json();
-    rows = body.messages ?? [];
-  } catch {
-    return [];
-  }
-  const chronological = [...rows].reverse();
-  while (chronological.length > 0 && chronological[chronological.length - 1].role === "user") {
-    chronological.pop();
-  }
-  const mapped = [];
-  for (const r of chronological) {
-    const role = r.role === "agent" ? "assistant" : r.role === "user" ? "user" : null;
-    if (!role) continue;
-    const body = (r.body ?? "").trim();
-    if (body.length === 0) continue;
-    mapped.push({ role, content: body });
-  }
-  return capHistory(mapped, opts.maxHistoryChars ?? DEFAULT_MAX_HISTORY_CHARS);
-}
-function capHistory(messages, maxChars) {
-  let total = messages.reduce((n, m) => n + m.content.length, 0);
-  let start = 0;
-  while (total > maxChars && start < messages.length) {
-    total -= messages[start].content.length;
-    start += 1;
-  }
-  return messages.slice(start);
-}
-
-// packages/agent-runtime/src/cabane-native/model.ts
-var CABANE_NATIVE_MODEL_PREFIX = "cabane-native/";
-function parseCabaneNativeModel(model) {
-  return model.startsWith(CABANE_NATIVE_MODEL_PREFIX) ? model.slice(CABANE_NATIVE_MODEL_PREFIX.length) : model;
-}
-
-// packages/agent-runtime/src/cabane-native/tools.ts
-var TOOL_RESULT_MAX_CHARS = 8e3;
-var CABANE_NATIVE_TOOLS = [
-  {
-    type: "function",
-    function: {
-      name: "cabane_list",
-      description: "List the files and subfolders at a workspace folder path. Omit `path` for the root.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "Workspace folder path, e.g. /notes. Defaults to /."
-          }
-        }
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "cabane_read",
-      description: "Read the contents of one file at a workspace path.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Workspace file path, e.g. /notes/todo.md." }
-        },
-        required: ["path"]
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "cabane_search",
-      description: "Case-insensitive substring search across file names and file contents. Optionally scope to a subtree with `path`.",
-      parameters: {
-        type: "object",
-        properties: {
-          q: { type: "string", description: "The search string." },
-          path: {
-            type: "string",
-            description: "Optional workspace subtree to scope the search to."
-          }
-        },
-        required: ["q"]
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "cabane_write",
-      description: "Create a file at a workspace path (missing parent folders are created). Pass `overwrite: true` to replace an existing file instead of failing on a name conflict.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Workspace file path, e.g. /notes/new.md." },
-          content: { type: "string", description: "The file contents." },
-          overwrite: { type: "boolean", description: "Replace an existing file (default false)." }
-        },
-        required: ["path", "content"]
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "cabane_edit",
-      description: "Modify an existing file with a single find/replace. By default `find` must occur exactly once; set `replaceAll: true` to replace every occurrence.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Workspace file path to edit." },
-          find: { type: "string", description: "The substring to find." },
-          replace: { type: "string", description: "The replacement." },
-          replaceAll: { type: "boolean", description: "Replace every occurrence (default false)." }
-        },
-        required: ["path", "find", "replace"]
-      }
-    }
-  }
-];
-function summarizeCabaneToolArgs(name, args) {
-  if (name === "cabane_search") return typeof args.q === "string" ? args.q : "";
-  return typeof args.path === "string" ? args.path : "";
-}
-async function executeCabaneNativeTool(name, args, ctx, signal) {
-  const doFetch = ctx.fetchImpl ?? fetch;
-  const wsBase = `${ctx.apiRoot}/workspaces/${ctx.workspaceId}`;
-  const headers = { Authorization: `Bearer ${ctx.bearer}`, "Content-Type": "application/json" };
-  const call = async (method, path3, init2) => {
-    const url = new URL(`${wsBase}${path3}`);
-    for (const [k, v] of Object.entries(init2?.query ?? {})) {
-      if (v !== void 0) url.searchParams.set(k, v);
-    }
-    let res;
-    try {
-      res = await doFetch(url.toString(), {
-        method,
-        headers,
-        ...init2?.body !== void 0 ? { body: JSON.stringify(init2.body) } : {},
-        signal
-      });
-    } catch (err) {
-      return {
-        ok: false,
-        result: `error: request failed: ${err instanceof Error ? err.message : String(err)}`
-      };
-    }
-    const contentType = res.headers.get("content-type") ?? "";
-    const text = contentType.includes("application/json") ? JSON.stringify(await res.json().catch(() => ({}))) : await res.text().catch(() => "");
-    if (!res.ok) return { ok: false, result: truncate2(`error ${res.status}: ${text}`) };
-    return { ok: true, result: truncate2(text) };
-  };
-  switch (name) {
-    case "cabane_list":
-      return call("GET", "/files/tree", { query: { path: str2(args.path) ?? "/" } });
-    case "cabane_read":
-      return call("GET", "/files/content", { query: { path: str2(args.path) } });
-    case "cabane_search":
-      return call("GET", "/search", { query: { q: str2(args.q), path: str2(args.path) } });
-    case "cabane_write": {
-      const overwrite = args.overwrite === true;
-      return overwrite ? call("PUT", "/files/content", {
-        body: { path: str2(args.path), content: str2(args.content) }
-      }) : call("POST", "/files", {
-        body: { path: str2(args.path), content: str2(args.content), mkdirs: true }
-      });
-    }
-    case "cabane_edit":
-      return call("PATCH", "/files", {
-        body: {
-          path: str2(args.path),
-          find: str2(args.find),
-          replace: str2(args.replace) ?? "",
-          ...args.replaceAll === true ? { replaceAll: true } : {}
-        }
-      });
-    default:
-      return { ok: false, result: `error: unknown tool "${name}"` };
-  }
-}
-function str2(v) {
-  return typeof v === "string" ? v : void 0;
-}
-function truncate2(s) {
-  return s.length > TOOL_RESULT_MAX_CHARS ? `${s.slice(0, TOOL_RESULT_MAX_CHARS)}
-\u2026 [truncated]` : s;
-}
-
-// packages/agent-runtime/src/cabane-native/loop.ts
-var DEFAULT_MAX_ITERATIONS = 12;
-async function* runCabaneNativeTurn(req, signal, deps) {
-  if (!req.config.model) {
-    yield { type: "result", ok: false, reason: "no_model" };
-    return;
-  }
-  const model = parseCabaneNativeModel(req.config.model);
-  const toolCtx = {
-    apiRoot: deps.apiRoot,
-    workspaceId: deps.workspaceId,
-    bearer: deps.bearer,
-    ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}
-  };
-  const messages = await assembleMessages(req.systemPrompt, req.content, req.prompt, {
-    apiRoot: deps.apiRoot,
-    workspaceId: deps.workspaceId,
-    bearer: deps.bearer,
-    conversationId: deps.conversationId,
-    ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {},
-    ...deps.historyLimit !== void 0 ? { historyLimit: deps.historyLimit } : {}
-  });
-  if (signal.aborted) return;
-  const maxIterations = deps.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-  let usage;
-  let resolvedModel = model;
-  for (let iteration = 0; iteration < maxIterations; iteration++) {
-    let text = "";
-    const toolAcc = /* @__PURE__ */ new Map();
-    let finishReason;
-    let errored2;
-    for await (const ev of deps.provider.stream(
-      { model, messages, tools: CABANE_NATIVE_TOOLS },
-      signal
-    )) {
-      if (signal.aborted) return;
-      switch (ev.type) {
-        case "text":
-          text += ev.delta;
-          break;
-        case "tool_call": {
-          const cur = toolAcc.get(ev.index) ?? { id: `call_${ev.index}`, name: "", args: "" };
-          if (ev.id) cur.id = ev.id;
-          if (ev.name) cur.name = ev.name;
-          if (ev.argumentsDelta) cur.args += ev.argumentsDelta;
-          toolAcc.set(ev.index, cur);
-          break;
-        }
-        case "usage":
-          usage = { inputTokens: ev.inputTokens, outputTokens: ev.outputTokens };
-          break;
-        case "model":
-          resolvedModel = ev.model;
-          break;
-        case "error":
-          errored2 = ev.message;
-          break;
-        case "done":
-          finishReason = ev.finishReason;
-          break;
-      }
-    }
-    if (signal.aborted) return;
-    if (errored2 !== void 0) {
-      const sealed = sealText(text, false);
-      if (sealed) yield sealed;
-      const failure = classifyErrorText(errored2);
-      yield {
-        type: "result",
-        ok: false,
-        reason: failure ? encodeFailureReason(failure) : `error:${errored2.slice(0, 200)}`,
-        ...usage ? { usage } : {},
-        ...resolvedModel ? { resolvedModel } : {}
-      };
-      return;
-    }
-    const toolCalls = [...toolAcc.entries()].sort((a, b) => a[0] - b[0]).map(([, v]) => v);
-    if (toolCalls.length === 0) {
-      const sealed = sealText(text, true);
-      if (sealed) yield sealed;
-      yield {
-        type: "result",
-        ok: true,
-        ...usage ? { usage } : {},
-        ...resolvedModel ? { resolvedModel } : {}
-      };
-      return;
-    }
-    const sealedInterim = sealText(text, false);
-    if (sealedInterim) yield sealedInterim;
-    const assistantToolCalls = toolCalls.map((t) => ({
-      id: t.id,
-      type: "function",
-      function: { name: t.name, arguments: t.args || "{}" }
-    }));
-    messages.push({ role: "assistant", content: text, tool_calls: assistantToolCalls });
-    for (const t of toolCalls) {
-      if (signal.aborted) return;
-      const args = parseArgs(t.args);
-      const displayName = prettyToolName(t.name);
-      const summary = summarizeCabaneToolArgs(t.name, args);
-      yield { type: "tool", id: t.id, name: displayName, phase: "start", summary, input: args };
-      const result = await executeCabaneNativeTool(t.name, args, toolCtx, signal);
-      if (signal.aborted) return;
-      yield {
-        type: "tool",
-        id: t.id,
-        name: displayName,
-        phase: result.ok ? "done" : "error",
-        summary,
-        input: args,
-        result: result.result
-      };
-      messages.push({ role: "tool", tool_call_id: t.id, content: result.result });
-    }
-  }
-  deps.onWarn?.("cabane-native: turn hit the tool-iteration cap; force-settling", {
-    maxIterations
-  });
-  yield {
-    type: "text",
-    body: `(Stopped after ${maxIterations} tool steps without a final answer.)`,
-    terminal: true
-  };
-  yield {
-    type: "result",
-    ok: true,
-    ...usage ? { usage } : {},
-    ...resolvedModel ? { resolvedModel } : {}
-  };
-}
-function sealText(text, terminal) {
-  const body = text.trim();
-  if (body.length === 0) return null;
-  return { type: "text", body, terminal };
-}
-function parseArgs(raw) {
-  if (!raw.trim()) return {};
-  try {
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-
-// packages/agent-runtime/src/cabane-native/policy.ts
-import { z as z13 } from "zod";
-var cabaneNativeDialectSchema = z13.object({}).loose();
-
-// packages/agent-runtime/src/cabane-native/provider.ts
-var DEFAULT_OPENROUTER_BASE = "https://openrouter.ai/api/v1";
-function createOpenRouterProvider(opts) {
-  const base = (opts.baseUrl ?? DEFAULT_OPENROUTER_BASE).replace(/\/$/, "");
-  const doFetch = opts.fetchImpl ?? fetch;
-  return {
-    async *stream(req, signal) {
-      let res;
-      try {
-        res = await doFetch(`${base}/chat/completions`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${opts.apiKey}`,
-            "Content-Type": "application/json",
-            // OpenRouter attribution headers (optional, but polite + used for
-            // routing/analytics on their side).
-            "HTTP-Referer": "https://cabane.ai",
-            "X-Title": "Cabane"
-          },
-          body: JSON.stringify({
-            model: req.model,
-            messages: req.messages,
-            ...req.tools.length > 0 ? { tools: req.tools } : {},
-            stream: true,
-            // Ask OpenRouter to append a trailing usage chunk to the stream.
-            stream_options: { include_usage: true }
-          }),
-          signal
-        });
-      } catch (err) {
-        if (signal.aborted) return;
-        yield { type: "error", message: `request failed: ${errText(err)}` };
-        return;
-      }
-      if (!res.ok || !res.body) {
-        const bodyText = await res.text().catch(() => "");
-        yield { type: "error", message: providerErrorMessage(res.status, bodyText) };
-        return;
-      }
-      const decoder = new TextDecoder();
-      const reader = res.body.getReader();
-      let buffer = "";
-      let finishReason;
-      let modelEmitted = false;
-      try {
-        for (; ; ) {
-          if (signal.aborted) return;
-          const { value, done } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          let nl;
-          while ((nl = buffer.indexOf("\n")) !== -1) {
-            const line = buffer.slice(0, nl).trim();
-            buffer = buffer.slice(nl + 1);
-            if (!line || line.startsWith(":")) continue;
-            if (!line.startsWith("data:")) continue;
-            const data = line.slice("data:".length).trim();
-            if (data === "[DONE]") {
-              yield { type: "done", ...finishReason ? { finishReason } : {} };
-              return;
-            }
-            let chunk;
-            try {
-              chunk = JSON.parse(data);
-            } catch {
-              continue;
-            }
-            if (chunk.error) {
-              yield { type: "error", message: chunk.error.message ?? "provider error" };
-              return;
-            }
-            if (!modelEmitted && chunk.model) {
-              modelEmitted = true;
-              yield { type: "model", model: chunk.model };
-            }
-            const choice = chunk.choices?.[0];
-            if (choice) {
-              const delta = choice.delta;
-              if (delta?.content) yield { type: "text", delta: delta.content };
-              if (delta?.tool_calls) {
-                for (const tc of delta.tool_calls) {
-                  yield {
-                    type: "tool_call",
-                    index: tc.index,
-                    ...tc.id ? { id: tc.id } : {},
-                    ...tc.function?.name ? { name: tc.function.name } : {},
-                    ...tc.function?.arguments !== void 0 ? { argumentsDelta: tc.function.arguments } : {}
-                  };
-                }
-              }
-              if (choice.finish_reason) finishReason = choice.finish_reason;
-            }
-            if (chunk.usage) {
-              yield {
-                type: "usage",
-                inputTokens: chunk.usage.prompt_tokens ?? 0,
-                outputTokens: chunk.usage.completion_tokens ?? 0
-              };
-            }
-          }
-        }
-      } catch (err) {
-        if (signal.aborted) return;
-        yield { type: "error", message: `stream read failed: ${errText(err)}` };
-        return;
-      }
-      yield { type: "done", ...finishReason ? { finishReason } : {} };
-    }
-  };
-}
-function providerErrorMessage(status, body) {
-  let detail = body.slice(0, 300);
-  try {
-    const parsed = JSON.parse(body);
-    if (parsed.error?.message) detail = parsed.error.message;
-  } catch {
-  }
-  return `HTTP ${status}: ${detail}`;
-}
-function errText(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-
-// packages/agent-runtime/src/cabane-native/index.ts
-var CABANE_NATIVE_RUNTIME_NAME = "cabane-native";
-function createCabaneNativeAdapter(deps = {}) {
-  const provider = deps.provider ?? (deps.apiKey ? createOpenRouterProvider({
-    apiKey: deps.apiKey,
-    ...deps.baseUrl ? { baseUrl: deps.baseUrl } : {},
-    ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}
-  }) : null);
-  return {
-    name: CABANE_NATIVE_RUNTIME_NAME,
-    // CT614: the native runtime carries its OWN `cabane_*` tool surface (not the
-    // `cabane` MCP server), so the CT609 code-mode lever — which filters the MCP
-    // server down to `code` — never touches what's mounted here. The addendum is
-    // therefore flag-INDEPENDENT: it always teaches the `cabane_*` names that are
-    // actually mounted (the `codeMode` arg is accepted-and-ignored). Native's
-    // adoption of `code` as its primary surface is a separate, later track.
-    promptAddendum: () => CABANE_NATIVE_ADDENDUM,
-    dialectSchema: cabaneNativeDialectSchema,
-    async *runTurn(req, signal) {
-      if (!provider) {
-        yield {
-          type: "result",
-          ok: false,
-          reason: "cabane_native_unavailable:no OPENROUTER_API_KEY configured on this device"
-        };
-        return;
-      }
-      const workspaceId = req.cabane.workspaceId;
-      if (!workspaceId) {
-        yield {
-          type: "result",
-          ok: false,
-          reason: "cabane_native_unavailable:turn carried no workspaceId"
-        };
-        return;
-      }
-      const apiRoot = req.cabane.mcpUrl.replace(/\/mcp\/?$/, "");
-      yield* runCabaneNativeTurn(req, signal, {
-        provider,
-        apiRoot,
-        workspaceId,
-        bearer: req.cabane.bearer,
-        conversationId: req.cabane.activeConversationId,
-        ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {},
-        ...deps.onWarn ? { onWarn: deps.onWarn } : {},
-        ...deps.maxIterations !== void 0 ? { maxIterations: deps.maxIterations } : {}
-      });
-    }
-  };
-}
-var cabaneNativeAdapter = createCabaneNativeAdapter();
-
 // packages/agent-runtime/src/claude-code/sdk.ts
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
 
@@ -6195,8 +5846,8 @@ var ConnectorHealthStore = class {
     return this.byRuntime.get(runtime);
   }
   // The per-connector reports to attach to a heartbeat — one entry per runtime the
-  // bridge has an observation for. Empty until the first classified failure/heal,
-  // so a bridge that has seen nothing sends no `connectors[]` and the server's
+  // 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]) => ({
@@ -6210,22 +5861,23 @@ var ConnectorHealthStore = class {
 
 // src/dispatcher.ts
 import { randomUUID } from "crypto";
-import { existsSync as existsSync9 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync9 } from "fs";
+import { join as join12 } from "path";
 
 // src/summon.ts
-import { z as z14 } from "zod";
-var BRIDGE_LOCAL_MCP_SERVER = "cabane_bridge";
+import { z as z12 } from "zod";
+var COMPANION_LOCAL_MCP_SERVER = "cabane_companion";
 var SUMMON_AGENT_TOOL = "summon_agent";
-var SUMMON_AGENT_TOOL_NAME = `mcp__${BRIDGE_LOCAL_MCP_SERVER}__${SUMMON_AGENT_TOOL}`;
-var BRIDGE_LOCAL_TOOL_GLOB = `mcp__${BRIDGE_LOCAL_MCP_SERVER}__*`;
+var SUMMON_AGENT_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${SUMMON_AGENT_TOOL}`;
+var COMPANION_LOCAL_TOOL_GLOB = `mcp__${COMPANION_LOCAL_MCP_SERVER}__*`;
 var SKIP_TURN_TOOL = "skip_turn";
-var SKIP_TURN_TOOL_NAME = `mcp__${BRIDGE_LOCAL_MCP_SERVER}__${SKIP_TURN_TOOL}`;
+var SKIP_TURN_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${SKIP_TURN_TOOL}`;
 var ASK_TOOL = "ask";
-var ASK_TOOL_NAME = `mcp__${BRIDGE_LOCAL_MCP_SERVER}__${ASK_TOOL}`;
+var ASK_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${ASK_TOOL}`;
 var SUB_AGENT_TOOL = "sub_agent";
-var SUB_AGENT_TOOL_NAME = `mcp__${BRIDGE_LOCAL_MCP_SERVER}__${SUB_AGENT_TOOL}`;
+var SUB_AGENT_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${SUB_AGENT_TOOL}`;
 var WAKE_ME_TOOL = "wake_me";
-var WAKE_ME_TOOL_NAME = `mcp__${BRIDGE_LOCAL_MCP_SERVER}__${WAKE_ME_TOOL}`;
+var WAKE_ME_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${WAKE_ME_TOOL}`;
 function createSummonState() {
   return { agentId: null };
 }
@@ -6240,14 +5892,14 @@ function createWakeState() {
 }
 function createSummonMcpServer(summonState, skipState, askState, subAgentCreate, wakeState) {
   return createSdkMcpServer({
-    name: BRIDGE_LOCAL_MCP_SERVER,
+    name: COMPANION_LOCAL_MCP_SERVER,
     version: "0.0.0",
     tools: [
       tool(
         SUMMON_AGENT_TOOL,
         "Summon another agent into THIS conversation \u2014 dispatch a peer to reply here on your turn. Use it to hand part of the work to a teammate, or pull in an expert, without leaving the conversation. Pass the peer's `agentId` (discover handles + ids via `list_agents`). The peer is dispatched on your turn's final reply, so write the context/ask into that reply first \u2014 it receives your message + this conversation to work from. Writing `@handle` in your prose does NOT summon anyone (agent prose never dispatches); this tool is the only in-thread lever. Single target \u2014 the last call wins. Summoning yourself is a no-op. Reach for it when the human wants the peer's answer right HERE, in front of them \u2014 the reply lands in this thread, so there's no return to wire (a return is for work YOU consume, never a courtesy notification). A handoff to a DIFFERENT conversation is `create_conversation` / `post_message` with their `dispatch` field instead.",
         {
-          agentId: z14.string().uuid().describe("The peer agent to summon \u2014 a workspace agent id from `list_agents`.")
+          agentId: z12.string().uuid().describe("The peer agent to summon \u2014 a workspace agent id from `list_agents`.")
         },
         async (args) => {
           summonState.agentId = args.agentId;
@@ -6262,7 +5914,7 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
           SKIP_TURN_TOOL,
           `End your current turn WITHOUT posting a reply. Call this when you've been dispatched but the message genuinely doesn't need a response from you \u2014 a thanks/aside, a question already answered, chatter outside your lane, or a pile-on where someone else has it. 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.`,
           {
-            reason: z14.string().min(1).max(500).describe("Short reason you are declining \u2014 used for telemetry/debugging.")
+            reason: z12.string().min(1).max(500).describe("Short reason you are declining \u2014 used for telemetry/debugging.")
           },
           async (args) => {
             skipState.skipped = true;
@@ -6279,21 +5931,21 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
           ASK_TOOL,
           "Ask a HUMAN a structured question (or a short LIST of them) you need answered to continue, then END your turn \u2014 don't wait for the reply. Use it when you genuinely can't proceed without a person's input (a decision only they can make, a missing fact, a go/no-go). Pass `targetUserId` (a workspace member's user id \u2014 get it from `mcp__cabane__list_members`). Two forms: a SINGLE question \u2014 a `headline` (the actual question as one clear, capitalized sentence ending in `?`, \"Do we go to prod?\") plus a short `question` body for the framing the headline can't hold \u2014 OR, when a plan ends with SEVERAL bounded decisions at once (\"three calls before I build: A? B? C?\"), a `questions` array of 1\u20135 items, each `{ headline, body?, options? }`. **Prefer the list over cramming the extra decisions into prose or dropping them** \u2014 end the turn with one ask carrying every question, never pick one and bury the rest. Each question keeps the same form rules: a one-sentence `headline`, a short `body` frame (NOT a report \u2014 your status, links, and detail go in your REPLY, and the body renders inline markdown only: links/emphasis/inline code, no bulleted lists or headings), and 2\u20134 `options` when the answer is a bounded choice \u2014 for a yes/no go-ahead always pass them, so it's one click, not a typed reply. An option can be a short button label OR a sentence that carries its own context; short/binary sets render as inline buttons, long ones stack full-width. Provide EITHER `question` (single) or `questions` (array), never both. The ask is recorded as a first-class attention item aimed at that person; your final reply carries the surrounding CONTEXT (what you found, why you're stuck), the ask carries the QUESTION(S). An open ask marks you as blocked until EVERY question is answered, so raise one only when you truly can't proceed \u2014 never ceremonially. One ask per turn (last call wins). After asking, stop \u2014 when the person replies addressed to you, the ask resolves and you resume; other people's or agents' messages may wake you but leave it open. Targets a human only; to hand work to another AGENT use summon/dispatch instead.",
           {
-            targetUserId: z14.string().uuid().describe("The workspace member (human) to ask \u2014 a user id from `list_members`."),
-            question: z14.string().min(1).max(400).optional().describe(
+            targetUserId: z12.string().uuid().describe("The workspace member (human) to ask \u2014 a user id from `list_members`."),
+            question: z12.string().min(1).max(400).optional().describe(
               "SINGLE-question form: a short body \u2014 one or two sentences of framing the headline can't hold. NOT a report (capped, inline markdown only). Provide EITHER this or `questions`, not both. Put the crisp one-sentence question in `headline`."
             ),
-            headline: z14.string().min(1).max(120).optional().describe(
+            headline: z12.string().min(1).max(120).optional().describe(
               'SINGLE-question form: the question itself as ONE clear, capitalized sentence ending in `?` ("Do we go to prod?"). What the human reads first in the inbox and the chip \u2014 one scannable question, no elaboration (that goes in `question`). Strongly encouraged.'
             ),
-            options: z14.array(z14.string().min(1).max(200)).min(2).max(4).optional().describe("SINGLE-question form: optional 2\u20134 suggested one-click answers."),
-            questions: z14.array(
-              z14.object({
-                headline: z14.string().min(1).max(120).describe(
+            options: z12.array(z12.string().min(1).max(200)).min(2).max(4).optional().describe("SINGLE-question form: optional 2\u20134 suggested one-click answers."),
+            questions: z12.array(
+              z12.object({
+                headline: z12.string().min(1).max(120).describe(
                   'The one-sentence question ("Do we go to prod?") \u2014 required for each item.'
                 ),
-                body: z14.string().min(1).max(400).optional().describe("Optional short framing beneath the headline. NOT a report."),
-                options: z14.array(z14.string().min(1).max(200)).min(2).max(4).optional().describe("Optional 2\u20134 one-click answers for this question.")
+                body: z12.string().min(1).max(400).optional().describe("Optional short framing beneath the headline. NOT a report."),
+                options: z12.array(z12.string().min(1).max(200)).min(2).max(4).optional().describe("Optional 2\u20134 one-click answers for this question.")
               })
             ).min(1).max(5).optional().describe(
               "MULTI-question form: 1\u20135 questions to ask at once, when a plan ends with several bounded decisions. Provide EITHER this or `question`/`headline`/`options`, not both."
@@ -6350,13 +6002,13 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
           SUB_AGENT_TOOL,
           "Spawn a sub-agent \u2014 hand a piece of work to a private worker with a fresh context window, whose result comes back to you automatically. Modeled on the Task tool, with ONE deliberate difference: it does NOT return the result inline. A callee's turn can run for minutes and no turn may hold an unbounded wait, so the shape is spawn-now, results-on-wake \u2014 this returns immediately with the child's `conversationId`, and the outcome lands LATER as a message in THIS conversation; you're woken once every sub-agent you have out in this conversation has returned. So DON'T wait for it: after spawning, finish whatever else this turn can do and end your turn (never poll the child with reads in a loop \u2014 the wake is automatic). Parallel fan-out = call this N times in one turn (they run concurrently; ONE wake when all are in); series = one call per turn. `prompt` is the child's opening instruction \u2014 make it self-contained (the sub-agent starts fresh, with only this prompt + the thread it lands in). `agentId` (optional) dispatches a PEER instead of yourself \u2014 same mechanics, a different mind (use for capability/context you lack); default (self) is the pure sub-worker with a clean context window. `title` (optional) names the child thread (results link it, so a legible title helps). A single sub-agent has no wall-clock advantage (you idle either way) \u2014 it pays when the callee has capability/context you lack, or to isolate a big read from your own session; the real win is fan-out. Don't spawn one for a lookup you can do in-turn with your own tools. The result returns to YOU to act on \u2014 reach for it when you're the consumer of the output, not as a way to notify a human: if a person just wants to read the result, dispatch a plain (no-return) conversation and link it instead of spawning a sub-agent.",
           {
-            prompt: z14.string().min(1).max(65536).describe(
+            prompt: z12.string().min(1).max(65536).describe(
               "The sub-agent's opening instruction \u2014 self-contained (it starts with a fresh context window; only this prompt + the thread it lands in)."
             ),
-            agentId: z14.string().uuid().optional().describe(
+            agentId: z12.string().uuid().optional().describe(
               "Optional peer to run the sub-agent as (a workspace agent id from `list_agents`); omit to spawn yourself with a fresh context window."
             ),
-            title: z14.string().max(200).optional().describe("Optional title for the child thread (result chips link it).")
+            title: z12.string().max(200).optional().describe("Optional title for the child thread (result chips link it).")
           },
           async (args) => {
             const result = await subAgentCreate(args);
@@ -6386,13 +6038,13 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
           WAKE_ME_TOOL,
           'Wake yourself later \u2014 end this turn now and be re-dispatched at a time you pick, with a note you write to yourself. Use it for "wait until X": when the thing you need hasn\'t happened yet (a conversation isn\'t done, a PR isn\'t merged, a human hasn\'t answered), arm a wake, end your turn, and you\'re woken later to CHECK \u2014 read the workspace, and either act or re-arm. This is the loop behind "check back in five minutes", "keep checking until {condition}", and a scheduled re-try ("re-send once that agent\'s limit resets"). Ground the delay before you arm it. Almost every wake is short \u2014 seconds to a couple of hours \u2014 waiting on a condition you can name: a session limit resetting, a PR merging, a deploy landing, a throttled dispatch to re-send. Reach past a few hours only when (a) a human asked for that timing, or (b) the wait is pinned to a real external event you can name \u2014 a report that only runs Mondays, a scheduled appointment, a known reset time. A speculative far-future check-in you invented yourself \u2014 "in two weeks I\'ll see whether this feature is used" \u2014 is the one thing not to arm: if no one asked and you can\'t name both what clears the wait and why it takes that long, don\'t arm it \u2014 finish now, or raise an `ask`. Pass EXACTLY ONE of `afterSeconds` (a relative delay \u2014 `300` for five minutes) or `at` (an absolute ISO-8601 timestamp WITH a zone, e.g. `2026-07-16T09:00:00-07:00` \u2014 YOU compute it from a phrase like "tomorrow morning"; the system never parses natural-language time). `note` is a message to your future self \u2014 it becomes the body of the wake message that re-dispatches you, so write the condition to re-check ("check whether CT441 merged yet"). The wake is armed when your turn SETTLES, not now, so the delay counts from the turn ending; one wake per turn (last call wins). This is the sanctioned way to schedule your own continuation \u2014 the ONLY one; never reach for a host cron/scheduler. Guardrails: at least 60s out, at most 14 days; widen the interval as a loop ages (5m \u2192 15m \u2192 1h\u2026) rather than hammering; after many consecutive re-arms with no other activity you\'ll be steered to raise an `ask` to the human instead. If a wake can\'t be armed you\'re re-dispatched with a note explaining why \u2014 never a silent drop.',
           {
-            afterSeconds: z14.number().int().positive().optional().describe(
+            afterSeconds: z12.number().int().positive().optional().describe(
               "Relative delay in seconds from when this turn ends (e.g. 300 = five minutes). Provide EITHER this or `at`, not both. Floor 60s, horizon 14 days \u2014 enforced server-side."
             ),
-            at: z14.string().datetime({ offset: true }).optional().describe(
+            at: z12.string().datetime({ offset: true }).optional().describe(
               "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: z14.string().min(1).max(2e3).describe(
+            note: z12.string().min(1).max(2e3).describe(
               'A note to your future self \u2014 becomes the body of the wake message that re-dispatches you. Write the condition to re-check ("check whether the PR merged").'
             )
           },
@@ -6442,7 +6094,10 @@ function createSummonMcpServer(summonState, skipState, askState, subAgentCreate,
 function cabaneMcpUrl(baseUrl) {
   return `${trimSlash3(baseUrl)}/api/mcp`;
 }
-function buildBridgeTurnRequest(params) {
+function turnControlMcpUrl(baseUrl) {
+  return `${trimSlash3(baseUrl)}/api/turn-control`;
+}
+function buildCompanionTurnRequest(params) {
   const { turnContext: t } = params;
   return {
     systemPrompt: t.systemPrompt,
@@ -6453,11 +6108,18 @@ function buildBridgeTurnRequest(params) {
     session: t.session,
     cabane: {
       mcpUrl: cabaneMcpUrl(params.baseUrl),
-      // CT306: prefer the per-turn OBO credential; fall back to the bridge PAT
+      // CT306: prefer the per-turn OBO credential; fall back to the companion PAT
       // when the API didn't mint one (older API / unresolvable delegation).
       bearer: params.turnToken ?? params.agentPat,
       activeConversationId: params.activeConversationId,
-      workspaceId: params.workspaceId
+      workspaceId: params.workspaceId,
+      ...t.workspaceToolSurface ? { workspaceToolSurface: t.workspaceToolSurface } : {},
+      // CT714: mount the turn-control surface ONLY when a real turn token backs
+      // this turn — the surface admits `turn_token` auth exclusively, so a
+      // PAT-fallback bearer (older API / unresolved delegation) would be rejected
+      // there. Absent it, external adapters simply don't mount it that turn (the
+      // same graceful degrade as the rest of the OBO path).
+      ...params.turnToken ? { turnControlUrl: turnControlMcpUrl(params.baseUrl) } : {}
     },
     local: {
       ...params.cwd ? { cwd: params.cwd } : {},
@@ -6468,8 +6130,11 @@ function buildBridgeTurnRequest(params) {
       // CT289: the auto-memory escape hatch, when the operator set it.
       ...params.claudeCode ? { claudeCode: params.claudeCode } : {}
     },
-    // Host-injected: the bridge-local summon server, under its own namespace.
-    extra: { mcpServers: { [BRIDGE_LOCAL_MCP_SERVER]: params.summonServer } }
+    // Host-injected: the companion-local summon server (for the subprocess adapters,
+    // under its own namespace).
+    extra: {
+      mcpServers: { [COMPANION_LOCAL_MCP_SERVER]: params.summonServer }
+    }
   };
 }
 function trimSlash3(s) {
@@ -6482,11 +6147,14 @@ import { join as join9 } from "path";
 function dirFor(workspaceId) {
   return join9(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
 }
-function pathFor3(workspaceId, conversationId) {
-  return join9(dirFor(workspaceId), `${encodeURIComponent(conversationId)}.json`);
+function conversationDir(workspaceId, conversationId) {
+  return join9(dirFor(workspaceId), encodeURIComponent(conversationId));
 }
-function readPrepared(workspaceId, conversationId) {
-  const path3 = pathFor3(workspaceId, conversationId);
+function pathFor3(workspaceId, conversationId, agentId) {
+  return join9(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
+}
+function readPrepared(workspaceId, conversationId, agentId) {
+  const path3 = pathFor3(workspaceId, conversationId, agentId);
   if (!existsSync7(path3)) return null;
   try {
     const parsed = JSON.parse(readFileSync6(path3, "utf8"));
@@ -6501,20 +6169,24 @@ function readPrepared(workspaceId, conversationId) {
     return null;
   }
 }
-function writePrepared(workspaceId, conversationId, result) {
-  mkdirSync7(dirFor(workspaceId), { recursive: true });
-  writeFileSync6(pathFor3(workspaceId, conversationId), JSON.stringify(result) + "\n", "utf8");
+function writePrepared(workspaceId, conversationId, agentId, result) {
+  mkdirSync7(conversationDir(workspaceId, conversationId), { recursive: true });
+  writeFileSync6(
+    pathFor3(workspaceId, conversationId, agentId),
+    JSON.stringify(result) + "\n",
+    "utf8"
+  );
 }
 
 // src/secrets.ts
 import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
 import { join as join10 } from "path";
-import { z as z15 } from "zod";
+import { z as z13 } from "zod";
 var PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
 function secretsPath() {
   return join10(cabaneDir(), "secrets.json");
 }
-var secretStoreSchema = z15.record(z15.string(), z15.string());
+var secretStoreSchema = z13.record(z13.string(), z13.string());
 function loadSecretStore() {
   const path3 = secretsPath();
   if (!existsSync8(path3)) return makeStore({});
@@ -6844,17 +6516,132 @@ var TurnCommitter = class {
   }
 };
 
+// src/workspace-readiness.ts
+var CLASSIC_REQUIRED = ["read", "list", "search", "write", "edit"];
+async function proveWorkspaceTools(req, runtime, opts = {}) {
+  const base = {
+    ok: false,
+    proofType: "authenticated_mcp_tools_list",
+    runtime,
+    harnessFingerprint: opts.harnessFingerprint ?? runtime,
+    endpoint: safeEndpoint(req.cabane.mcpUrl),
+    initialized: false,
+    authenticated: false,
+    discoveredTools: [],
+    requiredTools: [],
+    acceptedNames: ["sdk", "mcp__cabane__sdk"],
+    failedCapability: null,
+    detail: null
+  };
+  if (!req.cabane.mcpUrl) return fail(base, "server_not_configured", "Cabane MCP URL absent");
+  if (!req.cabane.bearer) return fail(base, "authentication_failed", "Cabane bearer absent");
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const headers = {
+    authorization: `Bearer ${req.cabane.bearer}`,
+    accept: "application/json, text/event-stream",
+    "content-type": "application/json",
+    "x-cabane-active-conversation": req.cabane.activeConversationId
+  };
+  try {
+    const initialized = await rpc(fetchImpl, req.cabane.mcpUrl, headers, {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: {
+        protocolVersion: "2025-03-26",
+        capabilities: {},
+        clientInfo: { name: "cabane-companion-readiness", version: "1" }
+      }
+    });
+    if (initialized.status === 401 || initialized.status === 403)
+      return fail(base, "authentication_failed", `initialize returned HTTP ${initialized.status}`);
+    if (!initialized.ok) return fail(base, "initialization_failed", initialized.detail);
+    base.initialized = true;
+    base.authenticated = true;
+    if (initialized.sessionId) headers["mcp-session-id"] = initialized.sessionId;
+    const listed = await rpc(fetchImpl, req.cabane.mcpUrl, headers, {
+      jsonrpc: "2.0",
+      id: 2,
+      method: "tools/list",
+      params: {}
+    });
+    if (listed.status === 401 || listed.status === 403)
+      return fail(base, "authentication_failed", `tools/list returned HTTP ${listed.status}`);
+    if (!listed.ok) return fail(base, "tool_discovery_failed", listed.detail);
+    const result = asRecord3(asRecord3(listed.value)?.result);
+    const tools = Array.isArray(result?.tools) ? result.tools : null;
+    if (!tools) return fail(base, "tool_discovery_failed", "tools/list returned no tool inventory");
+    base.discoveredTools = tools.map(
+      (tool2) => tool2 && typeof tool2 === "object" && typeof tool2.name === "string" ? tool2.name : null
+    ).filter((name) => name !== null).sort();
+    if (!req.cabane.workspaceToolSurface)
+      return fail(base, "required_tool_missing", "resolved workspace tool surface absent");
+    base.requiredTools = req.cabane.workspaceToolSurface === "code" ? ["sdk"] : CLASSIC_REQUIRED;
+    const missing = base.requiredTools.filter((name) => !base.discoveredTools.includes(name));
+    if (missing.length > 0)
+      return fail(
+        base,
+        "required_tool_missing",
+        `missing initialized tools: ${missing.join(", ")}`
+      );
+    base.ok = true;
+    return base;
+  } catch (error) {
+    return fail(
+      base,
+      "initialization_failed",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function fail(proof, capability, detail) {
+  proof.failedCapability = capability;
+  proof.detail = detail.slice(0, 300);
+  return proof;
+}
+function safeEndpoint(value) {
+  try {
+    const url = new URL(value);
+    return `${url.origin}${url.pathname}`;
+  } catch {
+    return null;
+  }
+}
+async function rpc(fetchImpl, url, headers, body) {
+  const response = await fetchImpl(url, { method: "POST", headers, body: JSON.stringify(body) });
+  const text = await response.text();
+  const value = parseRpcBody(text);
+  return {
+    ok: response.ok && !!value && !value.error,
+    status: response.status,
+    sessionId: response.headers.get("mcp-session-id"),
+    value,
+    detail: typeof asRecord3(value?.error)?.message === "string" ? String(asRecord3(value?.error)?.message) : `HTTP ${response.status}`
+  };
+}
+function parseRpcBody(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{")) return JSON.parse(trimmed);
+  for (const line of trimmed.split("\n")) {
+    if (line.startsWith("data:")) return JSON.parse(line.slice(5).trim());
+  }
+  return null;
+}
+function asRecord3(value) {
+  return value !== null && typeof value === "object" ? value : null;
+}
+
 // src/dispatcher.ts
 var PREPARING_TOOL_NAME = "preparing";
 var PREPARE_FAILED_PREFIX = "**Couldn't prepare your environment.** I wasn't able to provision a working directory for this conversation, so I can't run this turn. The provisioning command reported:";
-var MISSING_SECRET_PREFIX = "**Missing secret on this bridge.** This agent's tools need a credential this device hasn't been given, so I can't run this turn safely. Declare it in this bridge\u2019s secret store (`~/.cabane/secrets.json`) and try again. Missing:";
+var MISSING_SECRET_PREFIX = "**Missing secret on this companion.** This agent's tools need a credential this device hasn't been given, so I can't run this turn safely. Declare it in this companion\u2019s secret store (`~/.cabane/secrets.json`) and try again. Missing:";
 var STOPPED_MARKER_BODY = "(stopped)";
-var RUNTIME_UNAVAILABLE_PREFIX = "**This agent's runtime isn't available on this bridge.** The model this agent uses needs a runtime this device isn't running, so I can't run this turn here. Details:";
-var UNEXPECTED_ROLE_REASON = `refused the wake trigger (role "system" isn't dispatchable on this bridge) \u2014 the bridge is likely running outdated code; refresh it, then re-address the agent`;
+var RUNTIME_UNAVAILABLE_PREFIX = "**This agent's runtime isn't available on this companion.** The model this agent uses needs a runtime this device isn't running, so I can't run this turn here. Details:";
+var UNEXPECTED_ROLE_REASON = `refused the wake trigger (role "system" isn't dispatchable on this companion) \u2014 the companion is likely running outdated code; refresh it, then re-address the agent`;
 var SKIPPED_MARKER_BODY = "(skipped)";
 var DEFAULT_PREPARING_ROW_DELAY_MS = 1500;
 var DEFAULT_AGENT_IDLE_TIMEOUT_MS = 10 * 6e4;
-var DEFAULT_AGENT_TOTAL_TIMEOUT_MS = 45 * 6e4;
+var DEFAULT_AGENT_TOTAL_TIMEOUT_MS = 6 * 60 * 6e4;
 function runKey(conversationId, agentId) {
   return `${conversationId}|${agentId}`;
 }
@@ -6895,13 +6682,13 @@ var Dispatcher = class {
     }
   }
   // CT138: shared pre-run teardown for every early-return that happens BEFORE
-  // the active-run flag is flipped (the `setBridgeActiveRun` working-flip below).
+  // the active-run flag is flipped (the `setActiveRun` working-flip below).
   // The server lights the "X is replying…" indicator eagerly at dispatch
-  // (chat-dispatch.ts `scheduleRun`), and from that point only the bridge can
+  // (chat-dispatch.ts `scheduleRun`), and from that point only the companion can
   // clear it — the SJ383 `finally` after the SDK loop is the one clear, and
   // every pre-run exit returns before reaching it. So each pre-run failure has
   // to clear `active_run_started_at` itself, mirroring that `finally`, or the
-  // indicator strands until the 90-min age sweep.
+  // indicator strands until the 12h age sweep.
   //
   // `errorReason` controls the server's duplicate-notice rule (the active-run
   // PATCH handler in conversations.ts): a clear carrying `errorReason` makes the
@@ -6915,7 +6702,7 @@ var Dispatcher = class {
     const body = { activeRunStartedAt: null };
     if (errorReason) body.errorReason = errorReason.slice(0, 200);
     try {
-      await this.opts.api.setBridgeActiveRun(
+      await this.opts.api.setActiveRun(
         this.opts.workspaceId,
         payload.conversationId,
         payload.agentId,
@@ -6941,9 +6728,14 @@ var Dispatcher = class {
       agentId: payload.agentId,
       messageId: payload.messageId
     });
+    const turnId = randomUUID();
     let turnContext;
     try {
-      turnContext = await this.opts.api.getTurnContext(payload.conversationId, payload.messageId);
+      turnContext = await this.opts.api.getTurnContext(
+        payload.conversationId,
+        payload.messageId,
+        turnId
+      );
     } catch (err) {
       const status = err instanceof ApiError ? err.status : 0;
       if (status === 404) {
@@ -6984,7 +6776,7 @@ var Dispatcher = class {
     );
     if (missing.length > 0) {
       const list = missing.map((n) => `\`${n}\``).join(", ");
-      turnLog.error({ missing }, "dispatcher: turn needs secrets not declared on this bridge");
+      turnLog.error({ missing }, "dispatcher: turn needs secrets not declared on this companion");
       try {
         await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
           body: `${MISSING_SECRET_PREFIX} ${list}`,
@@ -7005,7 +6797,6 @@ var Dispatcher = class {
     const localCwd = this.opts.local.cwd;
     const prepareHook = this.opts.local.prepareHook;
     const cabaneCwd = turnContext.cwd;
-    const turnId = randomUUID();
     let seqCounter = 0;
     const nextSeq = () => ++seqCounter;
     let effectiveCwd = localCwd ?? cabaneCwd;
@@ -7018,7 +6809,7 @@ var Dispatcher = class {
     }
     let hookEnv;
     if (prepareHook) {
-      const cached2 = readPrepared(workspaceId, payload.conversationId);
+      const cached2 = readPrepared(workspaceId, payload.conversationId, payload.agentId);
       if (cached2) {
         effectiveCwd = cached2.cwd;
         hookEnv = cached2.env;
@@ -7055,6 +6846,7 @@ var Dispatcher = class {
             conversationId: payload.conversationId,
             agentId: payload.agentId,
             agentUsername: this.opts.agentUsername,
+            runtime: turnContext.runtime,
             // CT317/CT319: the trigger message's referenced-entry paths — what the
             // tasker prepare hook keys its per-task env off. Defaults to `[]` for
             // an older API. The conversation anchor is gone (CT319).
@@ -7063,7 +6855,7 @@ var Dispatcher = class {
           });
           clearTimeout(preparingTimer);
           if (preparingStarted) reportPreparing("done");
-          writePrepared(workspaceId, payload.conversationId, result);
+          writePrepared(workspaceId, payload.conversationId, payload.agentId, result);
           effectiveCwd = result.cwd;
           hookEnv = result.env;
         } catch (err) {
@@ -7092,12 +6884,25 @@ ${reason}`,
         }
       }
     }
+    let turnEnv = hookEnv;
+    if (effectiveCwd && turnContext.runtime === "codex") {
+      const tmpDir = join12(effectiveCwd, "node_modules", ".cache", "cabane-tmp", turnId);
+      try {
+        mkdirSync9(tmpDir, { recursive: true });
+        turnEnv = { ...hookEnv, TMPDIR: tmpDir };
+      } catch (err) {
+        turnLog.warn(
+          { err: err instanceof Error ? err.message : String(err), tmpDir },
+          "dispatcher: failed to create per-turn TMPDIR \u2014 proceeding with the inherited temp dir"
+        );
+      }
+    }
     const key = runKey(payload.conversationId, payload.agentId);
     const abortController = new AbortController();
     this.aborts.set(key, abortController);
     let timeoutReason = null;
     try {
-      await this.opts.api.setBridgeActiveRun(workspaceId, payload.conversationId, payload.agentId, {
+      await this.opts.api.setActiveRun(workspaceId, payload.conversationId, payload.agentId, {
         activeRunStartedAt: (/* @__PURE__ */ new Date()).toISOString(),
         // CT33: hand the server this turn's id so the new-run chokepoint's
         // `closeAbandonedTurns` sweep excludes it. The prepare hook may have
@@ -7145,16 +6950,18 @@ ${reason}`,
       subAgentCreate,
       wakeState
     );
-    const request = buildBridgeTurnRequest({
+    const request = buildCompanionTurnRequest({
       turnContext,
       baseUrl: this.opts.baseUrl,
       agentPat: this.opts.credential,
       // CT306: the per-turn OBO credential when the API minted one; falls back to
-      // the bridge PAT (`agentPat`) inside `buildBridgeTurnRequest` otherwise.
+      // the companion PAT (`agentPat`) inside `buildCompanionTurnRequest` otherwise.
       ...turnContext.turnToken ? { turnToken: turnContext.turnToken } : {},
       // SJ524: the hook-resolved cwd overrides the static local cwd.
       ...effectiveCwd ? { cwd: effectiveCwd } : {},
-      ...hookEnv ? { env: hookEnv } : {},
+      // CT804: `turnEnv` = the prepare-hook env plus the per-turn checkout-local
+      // TMPDIR (falls back to `hookEnv` when no cwd was resolved).
+      ...turnEnv ? { env: turnEnv } : {},
       mcpServers: resolvedMcpServers,
       summonServer,
       // CT238: this turn's conversation, forwarded as the active-conversation
@@ -7174,9 +6981,6 @@ ${reason}`,
     if (this.opts.codexEnabled) {
       adapters.push(createCodexAdapter({ enabled: true, onWarn }));
     }
-    if (this.opts.cabaneNativeApiKey) {
-      adapters.push(createCabaneNativeAdapter({ apiKey: this.opts.cabaneNativeApiKey, onWarn }));
-    }
     const registry = createAdapterRegistry(adapters);
     let adapter;
     try {
@@ -7207,6 +7011,58 @@ ${reason}`,
         `runtime_unavailable:${err.runtime}`
       );
     }
+    if (prepareHook && hookEnv?.CABANE_TASK_ID) {
+      const proof = await proveWorkspaceTools(request, adapter.name, {
+        ...this.opts.workspaceProofFetch ? { fetchImpl: this.opts.workspaceProofFetch } : {},
+        harnessFingerprint: turnContext.runtime
+      });
+      turnLog[proof.ok ? "info" : "error"](
+        { workspaceProof: proof, checkout: effectiveCwd ?? null },
+        `dispatcher: workspace tool proof ${proof.ok ? "passed" : "failed"}`
+      );
+      if (effectiveCwd) {
+        try {
+          const diagnosticDir = join12(effectiveCwd, ".git", "cabane");
+          mkdirSync9(diagnosticDir, { recursive: true });
+          appendFileSync2(
+            join12(diagnosticDir, "readiness.jsonl"),
+            `${JSON.stringify({
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              taskId: hookEnv.CABANE_TASK_ID,
+              binding: hookEnv.CABANE_TASK_BINDING ?? null,
+              checkout: effectiveCwd,
+              classification: proof.ok ? "ready" : "workspace_tools_missing",
+              failedCapability: proof.failedCapability,
+              workspaceTools: proof
+            })}
+`,
+            { mode: 384 }
+          );
+        } catch (error) {
+          turnLog.warn(
+            { err: error instanceof Error ? error.message : String(error) },
+            "dispatcher: workspace-proof diagnostic write failed"
+          );
+        }
+      }
+      if (!proof.ok) {
+        const reason = `workspace_tools_missing: ${proof.failedCapability}; checkout=${effectiveCwd ?? "unknown"}; runtime=${adapter.name}; recovery=restart the connector after restoring the Cabane workspace tool mount`;
+        try {
+          await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
+            body: `**Couldn't prepare your environment.** ${reason}`,
+            kind: "final",
+            turnId,
+            parentMessageId: payload.messageId
+          });
+        } catch (postErr) {
+          turnLog.warn(
+            { err: postErr instanceof Error ? postErr.message : String(postErr) },
+            "dispatcher: workspace-proof failure notice post failed"
+          );
+        }
+        return this.concludeBeforeRun(payload, turnLog, startedAt, reason);
+      }
+    }
     const transcript = this.opts.transcriptDir ? new TranscriptWriter(
       this.opts.transcriptDir,
       {
@@ -7250,6 +7106,49 @@ ${reason}`,
       // server arms the wake schedule atomically with the reply it rode on.
       wakeState
     });
+    const usesHttpTurnControl = turnRuntime === "codex" || turnRuntime === "opencode";
+    let turnControlIntentFetched = false;
+    const applyRecordedTurnControlIntent = async () => {
+      if (turnControlIntentFetched || !usesHttpTurnControl || !turnContext.turnToken) return;
+      turnControlIntentFetched = true;
+      try {
+        const intent = await this.opts.api.getTurnIntent(
+          workspaceId,
+          payload.conversationId,
+          payload.agentId,
+          turnId
+        );
+        if (intent.ask) {
+          askState.targetUserId = intent.ask.targetUserId;
+          if (intent.ask.questions && intent.ask.questions.length > 0) {
+            askState.questions = intent.ask.questions;
+            askState.question = null;
+            askState.headline = null;
+            askState.options = null;
+          } else {
+            askState.question = intent.ask.question ?? null;
+            askState.headline = intent.ask.headline ?? null;
+            askState.options = intent.ask.options ?? null;
+            askState.questions = null;
+          }
+        }
+        if (intent.wake) {
+          wakeState.afterSeconds = intent.wake.afterSeconds ?? null;
+          wakeState.at = intent.wake.at ?? null;
+          wakeState.note = intent.wake.note;
+        }
+        if (intent.summonAgentId) summonState.agentId = intent.summonAgentId;
+        if (intent.skipped) {
+          skipState.skipped = true;
+          skipState.reason = intent.skipReason;
+        }
+      } catch (err) {
+        turnLog.warn(
+          { err: err instanceof Error ? err.message : String(err) },
+          "dispatcher: turn-control intent fetch failed; turn-control effects for this turn are dropped"
+        );
+      }
+    };
     const idleTimeoutMs = this.opts.idleTimeoutMs ?? DEFAULT_AGENT_IDLE_TIMEOUT_MS;
     const totalTimeoutMs = this.opts.totalTimeoutMs ?? DEFAULT_AGENT_TOTAL_TIMEOUT_MS;
     const fireTimeout = (reason) => {
@@ -7285,7 +7184,7 @@ ${reason}`,
           if (!sessionWritten) {
             sessionWritten = true;
             try {
-              await this.opts.api.setBridgeActiveRun(
+              await this.opts.api.setActiveRun(
                 workspaceId,
                 payload.conversationId,
                 payload.agentId,
@@ -7306,6 +7205,9 @@ ${reason}`,
           turnResolvedConfig = event.resolvedConfig;
         } else if (event.type === "text" && skipState.skipped) {
         } else {
+          if (event.type === "text" && event.terminal) {
+            await applyRecordedTurnControlIntent();
+          }
           await committer.ingestEvent(event);
         }
       }
@@ -7316,18 +7218,28 @@ ${reason}`,
       if (!okResult && !resultReason) {
         resultReason = "no_result";
       }
+      if (!abortController.signal.aborted) {
+        await applyRecordedTurnControlIntent();
+      }
       if (!abortController.signal.aborted && skipState.skipped) {
         turnLog.info(
           { reason: skipState.reason, turnId, ok: okResult },
           "agent skipped turn (skip_turn)"
         );
+        const { afterSeconds: wakeAfter, at: wakeAt, note: wakeNote } = wakeState;
+        const skipWake = wakeNote && (wakeAfter !== null || wakeAt !== null) ? {
+          ...wakeAfter !== null ? { afterSeconds: wakeAfter } : {},
+          ...wakeAt !== null ? { at: wakeAt } : {},
+          note: wakeNote
+        } : void 0;
         try {
           await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
             body: SKIPPED_MARKER_BODY,
             kind: "skipped",
             turnId,
             seq: nextSeq(),
-            parentMessageId: payload.messageId
+            parentMessageId: payload.messageId,
+            ...skipWake ? { wake: skipWake } : {}
           });
         } catch (err) {
           turnLog.warn(
@@ -7413,7 +7325,7 @@ ${reason}`,
         errorReason: body.errorReason ?? null
       });
       try {
-        await this.opts.api.setBridgeActiveRun(
+        await this.opts.api.setActiveRun(
           workspaceId,
           payload.conversationId,
           payload.agentId,
@@ -7465,7 +7377,7 @@ ${reason}`,
     };
   }
   // SJ383: cancel a specific (conversation, agent) run if one is in flight in
-  // THIS bridge process. Returns true if an in-flight run was aborted.
+  // THIS companion process. Returns true if an in-flight run was aborted.
   cancel(conversationId, agentId) {
     const key = runKey(conversationId, agentId);
     const ac = this.aborts.get(key);
@@ -7479,27 +7391,17 @@ ${reason}`,
 };
 
 // src/manifest.ts
-var BRIDGE_MANIFEST = {
+var DEVICE_MANIFEST = {
   runtimes: [{ name: "claude-code", version: null }],
   capabilities: { hostFs: true, browser: true, userMcp: true }
 };
-var HOUSE_MANIFEST = {
-  runtimes: [{ name: "claude-code", version: null }],
-  capabilities: { hostFs: false, browser: false, userMcp: false }
-};
-function buildBridgeManifest(opts) {
-  if (process.env.CABANE_BRIDGE_CLASS === "house") {
-    const runtimes2 = [{ name: "claude-code", version: null }];
-    if (opts.cabaneNative) runtimes2.push({ name: "cabane-native", version: null });
-    return { runtimes: runtimes2, capabilities: { ...HOUSE_MANIFEST.capabilities } };
-  }
+function buildCompanionManifest(opts) {
   const v = opts.versions ?? {};
   const runtimes = [];
   if (opts.claudeCode) runtimes.push({ name: "claude-code", version: v.claudeCode ?? null });
   if (opts.opencode) runtimes.push({ name: "opencode", version: v.opencode ?? null });
   if (opts.codex) runtimes.push({ name: "codex", version: v.codex ?? null });
-  if (opts.cabaneNative) runtimes.push({ name: "cabane-native", version: null });
-  return { runtimes, capabilities: { ...BRIDGE_MANIFEST.capabilities } };
+  return { runtimes, capabilities: { ...DEVICE_MANIFEST.capabilities } };
 }
 
 // src/harness-status.ts
@@ -7510,7 +7412,7 @@ var LABELS = {
 };
 function deriveHarnessSnapshot(signals) {
   const advertised = new Set(
-    buildBridgeManifest({
+    buildCompanionManifest({
       claudeCode: signals.claudeOnPath,
       opencode: signals.opencodeConfigured,
       codex: signals.codexEnabled
@@ -7700,14 +7602,14 @@ async function enumerateOpencodeModels(serverUrl, fetchImpl = fetch) {
 // src/outbox.ts
 import {
   existsSync as existsSync10,
-  mkdirSync as mkdirSync9,
+  mkdirSync as mkdirSync10,
   readdirSync as readdirSync2,
   readFileSync as readFileSync8,
   renameSync as renameSync3,
   rmSync as rmSync5,
   writeFileSync as writeFileSync7
 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var MAX_ENTRIES = 2e3;
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var Outbox = class {
@@ -7720,17 +7622,17 @@ var Outbox = class {
   // Resolved lazily (per call, like cursor.ts) so tests that swap HOME between
   // cases route writes at the right tmpdir.
   dir() {
-    return join12(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
+    return join13(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
   }
   fileFor(turnId, seq) {
-    return join12(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
+    return join13(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
   // per-workspace bounds.
   persist(entry) {
     const dir2 = this.dir();
-    mkdirSync9(dir2, { recursive: true });
+    mkdirSync10(dir2, { recursive: true });
     const target = this.fileFor(entry.turnId, entry.seq);
     const tmp = `${target}.${process.pid}.tmp`;
     try {
@@ -7743,7 +7645,7 @@ var Outbox = class {
       }
       this.log?.warn(
         { workspaceId: this.workspaceId, err: err instanceof Error ? err.message : String(err) },
-        "bridge outbox: failed to persist entry"
+        "companion outbox: failed to persist entry"
       );
       return;
     }
@@ -7765,7 +7667,7 @@ var Outbox = class {
     const entries = [];
     for (const name of names) {
       if (!name.endsWith(".json")) continue;
-      const full = join12(dir2, name);
+      const full = join13(dir2, name);
       try {
         const parsed = JSON.parse(readFileSync8(full, "utf8"));
         if (parsed && typeof parsed.turnId === "string" && typeof parsed.seq === "number" && typeof parsed.path === "string") {
@@ -7801,7 +7703,7 @@ var Outbox = class {
   dropCorrupt(full) {
     this.log?.warn(
       { workspaceId: this.workspaceId, file: full },
-      "bridge outbox: dropping unreadable entry"
+      "companion outbox: dropping unreadable entry"
     );
     try {
       rmSync5(full, { force: true });
@@ -7818,7 +7720,7 @@ var Outbox = class {
       if (now - e.enqueuedAt > MAX_AGE_MS) {
         this.log?.warn(
           { workspaceId: this.workspaceId, turnId: e.turnId, seq: e.seq, kind: e.kind },
-          "bridge outbox: evicting entry past max age (undeliverable)"
+          "companion outbox: evicting entry past max age (undeliverable)"
         );
         this.remove(e.turnId, e.seq);
       } else {
@@ -7830,7 +7732,7 @@ var Outbox = class {
       for (const e of survivors.slice(0, overflow)) {
         this.log?.warn(
           { workspaceId: this.workspaceId, turnId: e.turnId, seq: e.seq, kind: e.kind },
-          "bridge outbox: evicting oldest entry past max size"
+          "companion outbox: evicting oldest entry past max size"
         );
         this.remove(e.turnId, e.seq);
       }
@@ -7839,40 +7741,43 @@ var Outbox = class {
 };
 
 // src/run-config.ts
-import { z as z16 } from "zod";
-var mcpStdioServerSchema = z16.object({
-  type: z16.literal("stdio").optional(),
-  command: z16.string().min(1),
-  args: z16.array(z16.string()).optional(),
-  env: z16.record(z16.string(), z16.string()).optional()
+import { z as z14 } from "zod";
+var mcpStdioServerSchema = z14.object({
+  type: z14.literal("stdio").optional(),
+  command: z14.string().min(1),
+  args: z14.array(z14.string()).optional(),
+  env: z14.record(z14.string(), z14.string()).optional()
 });
-var mcpHttpServerSchema = z16.object({
-  type: z16.literal("http"),
-  url: z16.string().url(),
-  headers: z16.record(z16.string(), z16.string()).optional()
+var mcpHttpServerSchema = z14.object({
+  type: z14.literal("http"),
+  url: z14.string().url(),
+  headers: z14.record(z14.string(), z14.string()).optional()
 });
-var mcpSseServerSchema = z16.object({
-  type: z16.literal("sse"),
-  url: z16.string().url(),
-  headers: z16.record(z16.string(), z16.string()).optional()
+var mcpSseServerSchema = z14.object({
+  type: z14.literal("sse"),
+  url: z14.string().url(),
+  headers: z14.record(z14.string(), z14.string()).optional()
 });
-var mcpServerDefSchema = z16.union([
+var mcpServerDefSchema = z14.union([
   mcpHttpServerSchema,
   mcpSseServerSchema,
   mcpStdioServerSchema
 ]);
-var thinkingConfigSchema = z16.discriminatedUnion("type", [
-  z16.object({ type: z16.literal("adaptive") }),
-  z16.object({ type: z16.literal("enabled"), budgetTokens: z16.number().int().positive().optional() }),
-  z16.object({ type: z16.literal("disabled") })
+var thinkingConfigSchema = z14.discriminatedUnion("type", [
+  z14.object({ type: z14.literal("adaptive") }),
+  z14.object({ type: z14.literal("enabled"), budgetTokens: z14.number().int().positive().optional() }),
+  z14.object({ type: z14.literal("disabled") })
 ]);
-var effortSchema = z16.enum(["low", "medium", "high", "xhigh", "max"]);
-var runConfigSchema = z16.object({
-  mode: z16.enum(["assistant", "coding", "custom"]).optional(),
-  allowedTools: z16.array(z16.string()).optional(),
-  disallowedTools: z16.array(z16.string()).optional(),
-  mcpServers: z16.record(z16.string(), mcpServerDefSchema).optional(),
-  model: z16.string().min(1).optional(),
+var effortSchema = z14.enum(["low", "medium", "high", "xhigh", "max"]);
+var runConfigSchema = z14.object({
+  // CT788: the host-access binary replaced the `assistant`/`coding`/`custom` mode
+  // trio + its custom tool lists — `true` grants the host filesystem/shell, absent
+  // is the locked surface. Kept in lockstep with `@cabane/shared`'s
+  // `agentRunConfigSchema` (independent zod, forward-compatible: unknown keys are
+  // stripped, so an older companion riding a newer server never rejects the config).
+  hostAccess: z14.boolean().optional(),
+  mcpServers: z14.record(z14.string(), mcpServerDefSchema).optional(),
+  model: z14.string().min(1).optional(),
   thinking: thinkingConfigSchema.optional(),
   effort: effortSchema.optional()
 });
@@ -7993,7 +7898,7 @@ function sleep2(ms) {
 // src/version.ts
 import { createRequire as createRequire2 } from "module";
 var pkg = createRequire2(import.meta.url)("../package.json");
-var BRIDGE_VERSION = pkg.version;
+var COMPANION_VERSION = pkg.version;
 
 // src/supervisor.ts
 var HEARTBEAT_INTERVAL_MS = 3e4;
@@ -8007,7 +7912,7 @@ var ASSIGNMENTS_POLL_MS = 6e4;
 var DRAIN_BASE_MS = 1e3;
 var DRAIN_MAX_MS = 3e4;
 var DRAIN_IDLE_MS = 15e3;
-var BridgeSupervisor = class {
+var CompanionSupervisor = class {
   workspaces = /* @__PURE__ */ new Map();
   config;
   log;
@@ -8031,10 +7936,12 @@ var BridgeSupervisor = class {
   dispatcherFactory;
   deviceApi = null;
   heartbeatTimer = null;
+  inFlightHeartbeat = null;
   pollTimer = null;
   refreshing = false;
   stopped = false;
-  // CT484: latch so the bridge/server version-skew warning is logged once, not
+  draining = false;
+  // CT484: latch so the companion/server version-skew warning is logged once, not
   // on every 30s heartbeat.
   versionSkewWarned = false;
   // This device's id, captured from the heartbeat / assignments response. The SSE
@@ -8060,18 +7967,18 @@ var BridgeSupervisor = class {
     this.dispatcherFactory = opts.dispatcherFactory;
   }
   // Stand up the data plane: pair check, initial assignments pull, then the
-  // heartbeat + poll loops. A bridge with no device token (logged out) does
+  // heartbeat + poll loops. A companion with no device token (logged out) does
   // nothing but say so.
   async start() {
     this.log.info(
-      { protocolVersion: TURN_PROTOCOL_VERSION, version: BRIDGE_VERSION },
-      "bridge: starting"
+      { protocolVersion: TURN_PROTOCOL_VERSION, version: COMPANION_VERSION },
+      "companion: starting"
     );
     void this.refreshHarnessStatuses();
     if (!this.config.deviceToken) {
-      this.log.warn("bridge: not paired (no device token) \u2014 run `cabane-companion pair`");
+      this.log.warn("companion: not paired (no device token) \u2014 run `cabane-companion pair`");
       process.stdout.write(
-        "bridge: this device is not paired \u2014 run `cabane-companion pair` and paste the string from the cabane app.\n"
+        "companion: this device is not paired \u2014 run `cabane-companion pair`, then confirm the short code in Settings \u2192 Connectors.\n"
       );
       return;
     }
@@ -8080,8 +7987,8 @@ var BridgeSupervisor = class {
       deviceToken: this.config.deviceToken
     });
     await this.refreshAssignments();
-    void this.sendHeartbeat();
-    this.heartbeatTimer = setInterval(() => void this.sendHeartbeat(), HEARTBEAT_INTERVAL_MS);
+    this.kickHeartbeat();
+    this.heartbeatTimer = setInterval(() => this.kickHeartbeat(), HEARTBEAT_INTERVAL_MS);
     this.heartbeatTimer.unref?.();
     this.pollTimer = setInterval(() => void this.refreshAssignments(), ASSIGNMENTS_POLL_MS);
     this.pollTimer.unref?.();
@@ -8094,20 +8001,28 @@ var BridgeSupervisor = class {
     return [...this.workspaces.values()].flatMap((w) => w.sub ? [w.sub.finished] : []);
   }
   // ---- device-level loops ----
+  kickHeartbeat() {
+    if (this.draining || this.inFlightHeartbeat) return;
+    const pending = this.sendHeartbeat();
+    this.inFlightHeartbeat = pending;
+    void pending.finally(() => {
+      if (this.inFlightHeartbeat === pending) this.inFlightHeartbeat = null;
+    });
+  }
   async sendHeartbeat() {
     if (!this.deviceApi) return;
     await this.refreshHarnessStatuses();
     try {
-      const store = loadSecretStoreTolerant((m) => this.log.warn({ msg: m }, "bridge: secrets"));
+      const store = loadSecretStoreTolerant((m) => this.log.warn({ msg: m }, "companion: secrets"));
       const connectorReports = this.connectorHealth.reports();
       const opencodeModels = this.config.opencode?.serverUrl ? await enumerateOpencodeModels(this.config.opencode.serverUrl) : null;
       const res = await this.deviceApi.heartbeat({
-        version: BRIDGE_VERSION,
+        version: COMPANION_VERSION,
         exposedSecretNames: store.names(),
         // Report each runtime only when this device can actually run it: CT309
         // claude-code when `claude` is on PATH, CT270 opencode when the operator
         // configured an `opencode serve`.
-        manifest: buildBridgeManifest({
+        manifest: buildCompanionManifest({
           // CT586: prefer the live re-probe's presence; fall back to the boot probe
           // until the first re-probe lands. Same exit-0 `claude --version` signal
           // either way, so the manifest's claude-code advertising is unchanged in
@@ -8118,17 +8033,13 @@ var BridgeSupervisor = class {
           // like opencode — the CLI's presence is the operator's responsibility;
           // a misconfigured device fails the turn loudly, never silently).
           codex: isCodexEnabled(this.config),
-          // CT598: advertise the native runtime when an OpenRouter key is set — the
-          // env flag that mounts "In Cabane" native turns on this device (house or
-          // user). Key absent → not advertised, so a native turn never routes here.
-          cabaneNative: isCabaneNativeEnabled(),
           // CT571/CT586: each runtime's `version` from the latest harness probe
           // (fail-soft to null). Informational only — the server matches on name.
           versions: this.harnessVersions
         }),
         // CT566: echo the last classified credential state per runtime, when the
-        // bridge has seen any. Omitted (undefined) until the first observed
-        // failure/heal, so a fresh bridge's beat is unchanged and the server's
+        // companion has seen any. Omitted (undefined) until the first observed
+        // failure/heal, so a fresh companion's beat is unchanged and the server's
         // manifest synthesis (status-less rows) still runs.
         ...connectorReports.length > 0 ? { connectors: connectorReports } : {},
         // CT584: include enumerated models only when the probe SUCCEEDED (non-null).
@@ -8142,22 +8053,22 @@ var BridgeSupervisor = class {
     } catch (err) {
       this.log.warn(
         { err: err instanceof Error ? err.message : String(err) },
-        "bridge: device heartbeat failed (will retry on next tick)"
+        "companion: device heartbeat failed (will retry on next tick)"
       );
     }
   }
-  // CT484: belt-and-suspenders beside shipping the bridge in lockstep inside the
+  // CT484: belt-and-suspenders beside shipping the companion in lockstep inside the
   // artifact — if the server reports a build version that differs from this
-  // bridge's, warn loudly (once). This is exactly the skew that bit the M1 walk:
-  // an npm-pinned bridge lagging a from-develop server. The elimination (bundled
-  // bridge) makes it match by construction; this catches a bridge run out of band.
+  // companion's, warn loudly (once). This is exactly the skew that bit the M1 walk:
+  // an npm-pinned companion lagging a from-develop server. The elimination (bundled
+  // companion) makes it match by construction; this catches a companion run out of band.
   checkVersionSkew(serverVersion) {
     if (this.versionSkewWarned) return;
-    if (!serverVersion || serverVersion === BRIDGE_VERSION) return;
+    if (!serverVersion || serverVersion === COMPANION_VERSION) return;
     this.versionSkewWarned = true;
     this.log.warn(
-      { bridgeVersion: BRIDGE_VERSION, serverVersion },
-      "bridge: VERSION SKEW \u2014 this bridge and its server were built from different versions. Turns may misbehave. The self-host artifact ships a matching bridge; run `cabane update` so the bridge matches its server."
+      { companionVersion: COMPANION_VERSION, serverVersion },
+      "companion: VERSION SKEW \u2014 this companion and its server were built from different versions. Turns may misbehave. The self-host artifact ships a matching companion; run `cabane update` so the companion matches its server."
     );
   }
   // Pull assignments and reconcile the live runner set against them. Re-entrancy
@@ -8180,7 +8091,7 @@ var BridgeSupervisor = class {
         } catch (err) {
           this.log.error(
             { err: err instanceof Error ? err.message : String(err) },
-            "bridge: assignments pull failed \u2014 check the device is still active in the cabane app"
+            "companion: assignments pull failed \u2014 check the device is still active in the cabane app"
           );
           this.hub.setDeviceError(err instanceof Error ? err.message : String(err));
           return;
@@ -8245,21 +8156,21 @@ var BridgeSupervisor = class {
       const credential = it.credential ?? getCredential(it.agentId);
       const runConfig = parseRunConfig(
         it.runConfig,
-        (m) => this.log.warn({ agentId: it.agentId, msg: m }, "bridge: run-config")
+        (m) => this.log.warn({ agentId: it.agentId, msg: m }, "companion: run-config")
       );
       const required = requiredSecretNames(runConfig.mcpServers);
       const missing = required.filter((n) => !exposed.has(n));
       if (!credential) {
         this.log.error(
           { workspaceId, agentId: it.agentId, username: it.agentUsername },
-          "bridge: agent assigned but no credential on this device \u2014 re-assign it in the cabane app"
+          "companion: agent assigned but no credential on this device \u2014 re-assign it in the cabane app"
         );
         this.removeAgent(wr, it.agentId);
         this.hub.setAgent(workspaceId, {
           agentId: it.agentId,
           username: it.agentUsername,
           displayName: it.agentDisplayName,
-          mode: runConfig.mode ?? "assistant",
+          mode: runConfig.hostAccess ? "full" : "none",
           hasCredential: false,
           missingSecrets: missing
         });
@@ -8279,14 +8190,14 @@ var BridgeSupervisor = class {
         agentId: it.agentId,
         username: it.agentUsername,
         displayName: it.agentDisplayName,
-        mode: runConfig.mode ?? "assistant",
+        mode: runConfig.hostAccess ? "full" : "none",
         hasCredential: true,
         missingSecrets: missing
       });
       if (missing.length > 0) {
         this.log.warn(
           { workspaceId, agentId: it.agentId, missing },
-          "bridge: agent needs secrets this device does not expose (turns using them will fail)"
+          "companion: agent needs secrets this device does not expose (turns using them will fail)"
         );
       }
     }
@@ -8325,7 +8236,7 @@ var BridgeSupervisor = class {
     drain2.kick();
     this.log.info(
       { workspaceId: it.workspaceId, agentId: it.agentId, username: it.agentUsername },
-      "bridge: running agent"
+      "companion: running agent"
     );
   }
   removeAgent(wr, agentId) {
@@ -8334,7 +8245,10 @@ var BridgeSupervisor = class {
     runner.cancelDrain();
     wr.agents.delete(agentId);
     this.hub.removeAgent(wr.workspaceId, agentId);
-    this.log.info({ workspaceId: wr.workspaceId, agentId }, "bridge: stopped agent (unassigned)");
+    this.log.info(
+      { workspaceId: wr.workspaceId, agentId },
+      "companion: stopped agent (unassigned)"
+    );
   }
   buildDispatcher(ctx) {
     if (this.dispatcherFactory) return this.dispatcherFactory(ctx);
@@ -8360,12 +8274,9 @@ var BridgeSupervisor = class {
       // CT481: register the codex adapter when this device offers codex; unset
       // leaves an `openai/…` turn to fail loudly (no silent claude-code fallback).
       ...isCodexEnabled(this.config) ? { codexEnabled: true } : {},
-      // CT598: register the cabane-native adapter when an OpenRouter key is set;
-      // unset leaves a `cabane-native/…` turn to fail loudly (no silent fallback).
-      ...cabaneNativeApiKey() ? { cabaneNativeApiKey: cabaneNativeApiKey() } : {},
-      // CT556: per-turn timeout watchdog windows, from the bridge's own env
+      // CT556: per-turn timeout watchdog windows, from the companion's own env
       // (`AGENT_IDLE_TIMEOUT_MS` / `AGENT_TOTAL_TIMEOUT_MS`). Unset → the
-      // dispatcher's baked-in defaults (10 min idle / 45 min total).
+      // dispatcher's baked-in defaults (10 min idle / 6h total).
       ...positiveIntEnv("AGENT_IDLE_TIMEOUT_MS") !== void 0 ? { idleTimeoutMs: positiveIntEnv("AGENT_IDLE_TIMEOUT_MS") } : {},
       ...positiveIntEnv("AGENT_TOTAL_TIMEOUT_MS") !== void 0 ? { totalTimeoutMs: positiveIntEnv("AGENT_TOTAL_TIMEOUT_MS") } : {},
       observer: this.hub.observerFor(ctx.workspaceId, ctx.agentId, ctx.workspaceSlug),
@@ -8402,14 +8313,14 @@ var BridgeSupervisor = class {
         this.hub.setAuthFailed(wr.workspaceId);
         this.log.error(
           { workspaceId: wr.workspaceId, status, sseAgentId: wr.sseAgentId },
-          "bridge: workspace stream auth failed \u2014 re-pulling assignments"
+          "companion: workspace stream auth failed \u2014 re-pulling assignments"
         );
         wr.sseAgentId = null;
         void this.refreshAssignments();
       }
     });
     wr.sub.start();
-    this.log.info({ workspaceId: wr.workspaceId }, "bridge: subscribed");
+    this.log.info({ workspaceId: wr.workspaceId }, "companion: subscribed");
   }
   async removeWorkspace(workspaceId) {
     const wr = this.workspaces.get(workspaceId);
@@ -8440,9 +8351,9 @@ var BridgeSupervisor = class {
       return;
     }
     if (ev.id) wr.cursor.observe(ev.id);
-    if (wire.type === "bridge:cancel_requested") {
+    if (wire.type === "device:cancel_requested") {
       const payload2 = {
-        type: "bridge:cancel_requested",
+        type: "device:cancel_requested",
         ...wire.payload
       };
       const agent2 = wr.agents.get(payload2.agentId);
@@ -8462,12 +8373,13 @@ var BridgeSupervisor = class {
       if (ev.id) wr.cursor.settle(ev.id);
       return;
     }
-    if (wire.type !== "bridge:dispatch_requested") {
+    if (wire.type !== "device:dispatch_requested") {
       if (ev.id) wr.cursor.settle(ev.id);
       return;
     }
+    if (this.draining) return;
     const payload = {
-      type: "bridge:dispatch_requested",
+      type: "device:dispatch_requested",
       ...wire.payload
     };
     let agent = wr.agents.get(payload.agentId);
@@ -8488,7 +8400,7 @@ var BridgeSupervisor = class {
           agentId: payload.agentId,
           err: err instanceof Error ? err.message : String(err)
         },
-        "bridge: conversation turn handler threw"
+        "companion: conversation turn handler threw"
       );
     });
     wr.chains.set(chainKey, tail);
@@ -8516,7 +8428,7 @@ var BridgeSupervisor = class {
       if (hasCompleted(workspaceId, ev.id)) {
         this.log.info(
           { workspaceId, eventId: ev.id },
-          "bridge: skipping already-completed event (resume after restart)"
+          "companion: skipping already-completed event (resume after restart)"
         );
         wr.cursor.settle(ev.id);
         return;
@@ -8524,7 +8436,7 @@ var BridgeSupervisor = class {
       if (noResume()) {
         this.log.warn(
           { workspaceId, eventId: ev.id },
-          "bridge: skipping interrupted turn (CABANE_BRIDGE_NO_RESUME=1) \u2014 resume disabled for this boot"
+          "companion: skipping interrupted turn (CABANE_COMPANION_NO_RESUME=1) \u2014 resume disabled for this boot"
         );
         markCompleted(workspaceId, ev.id);
         wr.cursor.settle(ev.id);
@@ -8534,7 +8446,7 @@ var BridgeSupervisor = class {
       if (attempt > MAX_RESUME_ATTEMPTS) {
         this.log.error(
           { workspaceId, eventId: ev.id, attempt, cap: MAX_RESUME_ATTEMPTS },
-          "bridge: giving up on an interrupted turn after too many resume attempts \u2014 retiring it so boot is never wedged (run `cabane bridge reset` to clear resume state)"
+          "companion: giving up on an interrupted turn after too many resume attempts \u2014 retiring it so boot is never wedged (run `cabane companion reset` to clear resume state)"
         );
         markCompleted(workspaceId, ev.id);
         wr.cursor.settle(ev.id);
@@ -8542,7 +8454,7 @@ var BridgeSupervisor = class {
       }
       this.log.info(
         { workspaceId, eventId: ev.id, attempt, cap: MAX_RESUME_ATTEMPTS },
-        "bridge: re-dispatching interrupted turn (resume after restart)"
+        "companion: re-dispatching interrupted turn (resume after restart)"
       );
     }
     if (ev.id) markDispatched(workspaceId, ev.id);
@@ -8582,7 +8494,7 @@ var BridgeSupervisor = class {
         drainDelay = Math.min(drainDelay * 2, DRAIN_MAX_MS);
         this.log.warn(
           { agentId, err: err instanceof Error ? err.message : String(err) },
-          "bridge: outbox drain pass threw (will retry with backoff)"
+          "companion: outbox drain pass threw (will retry with backoff)"
         );
       } finally {
         if (!drainStopped) {
@@ -8651,7 +8563,7 @@ var BridgeSupervisor = class {
     } catch (err) {
       this.log.warn(
         { err: err instanceof Error ? err.message : String(err) },
-        "bridge: harness probe failed (will retry on next beat)"
+        "companion: harness probe failed (will retry on next beat)"
       );
     }
   }
@@ -8676,7 +8588,7 @@ var BridgeSupervisor = class {
       next = { ...this.config, codex: { enabled: true } };
     } else {
       const serverUrl = input.serverUrl.trim();
-      const parsed = bridgeConfigSchema.shape.opencode.safeParse({ serverUrl });
+      const parsed = companionConfigSchema.shape.opencode.safeParse({ serverUrl });
       if (!parsed.success) {
         return {
           ok: false,
@@ -8697,7 +8609,7 @@ var BridgeSupervisor = class {
     saveConfig(next);
     this.rebuildDispatchers();
     await this.refreshHarnessStatuses();
-    void this.sendHeartbeat();
+    this.kickHeartbeat();
     return { ok: true };
   }
   // Re-create every running agent's Dispatcher from the CURRENT config, keeping
@@ -8733,6 +8645,41 @@ var BridgeSupervisor = class {
       [...this.workspaces.values()].flatMap((wr) => wr.sub ? [wr.sub.finished] : [])
     );
   }
+  async drainForRestart(graceMs) {
+    this.draining = true;
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    if (this.inFlightHeartbeat) await this.inFlightHeartbeat;
+    if (!this.deviceApi) throw new Error("cannot establish deploy drain before pairing");
+    await this.deviceApi.beginDrain();
+    for (const wr of this.workspaces.values()) wr.sub?.stop();
+    const turns = [...this.workspaces.values()].flatMap((wr) => [...wr.chains.values()]);
+    let timedOut = false;
+    if (turns.length > 0) {
+      let timer;
+      await Promise.race([
+        Promise.allSettled(turns),
+        new Promise((resolve) => {
+          timer = setTimeout(
+            () => {
+              timedOut = true;
+              resolve();
+            },
+            Math.max(0, graceMs)
+          );
+          timer.unref?.();
+        })
+      ]);
+      if (timer) clearTimeout(timer);
+    }
+    await Promise.allSettled(
+      [...this.workspaces.values()].flatMap(
+        (wr) => [...wr.agents.values()].map((agent) => agent.api.drainOutbox())
+      )
+    );
+    await this.shutdown();
+    return { drained: !timedOut };
+  }
   async requestStop() {
     await this.shutdown();
     this.exitFn(0);
@@ -8804,25 +8751,25 @@ function handleUncaught(log, err, origin) {
   if (isRecoverableSocketError(err)) {
     log.warn(
       { origin, code, err: message },
-      "bridge: recovered from a socket error (kept running \u2014 a broken pipe never kills the bridge)"
+      "companion: recovered from a socket error (kept running \u2014 a broken pipe never kills the companion)"
     );
     return;
   }
   log.error(
     { origin, code, err: message, stack: err instanceof Error ? err.stack : void 0 },
-    "bridge: uncaught error (kept running \u2014 see the stack above)"
+    "companion: uncaught error (kept running \u2014 see the stack above)"
   );
 }
 
 // src/crash-marker.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync10, readFileSync as readFileSync9, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync11, readFileSync as readFileSync9, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "fs";
+import { join as join14 } from "path";
 function crashMarkerPath() {
-  return join13(cabaneDir(), "last-error.json");
+  return join14(cabaneDir(), "last-error.json");
 }
 function recordCrash(rec) {
   try {
-    mkdirSync10(cabaneDir(), { recursive: true });
+    mkdirSync11(cabaneDir(), { recursive: true });
     writeFileSync8(crashMarkerPath(), JSON.stringify(rec, null, 2) + "\n");
   } catch {
   }
@@ -8836,7 +8783,7 @@ function clearCrash() {
 }
 
 // src/runtime.ts
-async function createBridgeRuntime(opts = {}) {
+async function createCompanionRuntime(opts = {}) {
   const log = getLogger();
   installProcessSafetyNet(log);
   const probeClaude = opts.probeClaude ?? claudeOnPath;
@@ -8870,23 +8817,29 @@ async function createBridgeRuntime(opts = {}) {
     url: "",
     port: 0,
     startedAt,
-    daemon: process.env.CABANE_BRIDGE_DAEMON === "1",
+    daemon: process.env.CABANE_COMPANION_DAEMON === "1",
     instanceId
   });
   if (!claim.acquired) {
     return { ok: false, reason: "already-running", existing: claim.existing ?? null };
   }
   process.on("exit", () => clearRuntimeState());
-  const hub = new BridgeStateHub({
+  const hub = new CompanionStateHub({
     // CT29: one device, one base URL — the cabane instance this device is paired
     // with. The dashboard's connection line shows it.
     baseUrl: cfg.baseUrl,
-    bridgeVersion: BRIDGE_VERSION,
+    companionVersion: COMPANION_VERSION,
     // SJ516 F4: surfaced on `/api/status` so `stop`/`status` can confirm the
-    // process behind the marker pid is this bridge (not a recycled pid).
+    // process behind the marker pid is this companion (not a recycled pid).
     instanceId
   });
-  const supervisor = new BridgeSupervisor({ config: cfg, log, hub, claudeCode, harnessVersions });
+  const supervisor = new CompanionSupervisor({
+    config: cfg,
+    log,
+    hub,
+    claudeCode,
+    harnessVersions
+  });
   await supervisor.start();
   const preferredPort = opts.port ?? cfg.dashboardPort;
   const dashboard = await startDashboard({
@@ -8901,9 +8854,9 @@ async function createBridgeRuntime(opts = {}) {
     port: dashboard.port,
     startedAt,
     // SJ495: the daemon launcher sets this env on the detached child, so the
-    // marker records whether this bridge is backgrounded (foreground start
+    // marker records whether this companion is backgrounded (foreground start
     // leaves it unset → false).
-    daemon: process.env.CABANE_BRIDGE_DAEMON === "1",
+    daemon: process.env.CABANE_COMPANION_DAEMON === "1",
     instanceId
   });
   clearCrash();
@@ -8920,9 +8873,21 @@ async function createBridgeRuntime(opts = {}) {
   };
   return {
     ok: true,
-    runtime: { url: dashboard.url, port: dashboard.port, config: cfg, stop }
+    runtime: {
+      url: dashboard.url,
+      port: dashboard.port,
+      config: cfg,
+      stop,
+      drainForRestart: async (graceMs) => {
+        clearRuntimeState();
+        const result = await supervisor.drainForRestart(graceMs);
+        await dashboard.close();
+        stopped = true;
+        return result;
+      }
+    }
   };
 }
 export {
-  createBridgeRuntime
+  createCompanionRuntime
 };