@cabane/companion 0.5.0 → 0.6.0

package/dist/runtime.js

@@ -16,13 +16,13 @@ import { dirname, join } from "path";
 import { z as z3 } 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";
@@ -69,12 +69,12 @@ var pairingSchema = z.object({
   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.
+  // The `cabdev_` device token plaintext — the companion'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
+  // companion 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()
@@ -90,13 +90,18 @@ var prepareHookSchema = z2.object({
   env: z2.record(z2.string(), z2.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.
+  // fails with a clear timeout message rather than pinning the companion.
   timeoutMs: z2.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()
+  env: z2.record(z2.string(), z2.string()).optional(),
+  nativeWorkAssignment: z2.object({
+    itemId: z2.string(),
+    executionId: z2.string(),
+    activationEpoch: z2.number().int().nonnegative()
+  }).strict().optional()
 });
 function parsePrepareOutput(stdout) {
   const last = stdout.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).at(-1);
@@ -115,10 +120,14 @@ 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" or "nativeWorkAssignment")'
       );
     }
-    return { cwd: r.data.cwd, ...r.data.env ? { env: r.data.env } : {} };
+    return {
+      cwd: r.data.cwd,
+      ...r.data.env ? { env: r.data.env } : {},
+      ...r.data.nativeWorkAssignment ? { nativeWorkAssignment: r.data.nativeWorkAssignment } : {}
+    };
   }
   return { cwd: last };
 }
@@ -143,6 +152,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.
@@ -154,10 +164,10 @@ var runPrepareHook = (hook, input) => {
           CABANE_CONVERSATION_TITLE: input.title ?? ""
         }
       });
-    } catch (err) {
+    } catch (err2) {
       reject(
         new PrepareHookError(
-          `prepare hook failed to start: ${err instanceof Error ? err.message : String(err)}`
+          `prepare hook failed to start: ${err2 instanceof Error ? err2.message : String(err2)}`
         )
       );
       return;
@@ -177,8 +187,8 @@ var runPrepareHook = (hook, input) => {
     child.stderr?.on("data", (d) => {
       stderr += d.toString();
     });
-    child.on("error", (err) => {
-      finish(() => reject(new PrepareHookError(`prepare hook failed to start: ${err.message}`)));
+    child.on("error", (err2) => {
+      finish(() => reject(new PrepareHookError(`prepare hook failed to start: ${err2.message}`)));
     });
     child.on("close", (code) => {
       finish(() => {
@@ -191,8 +201,8 @@ var runPrepareHook = (hook, input) => {
         }
         try {
           resolve(parsePrepareOutput(stdout));
-        } catch (err) {
-          reject(err instanceof PrepareHookError ? err : new PrepareHookError(String(err)));
+        } catch (err2) {
+          reject(err2 instanceof PrepareHookError ? err2 : new PrepareHookError(String(err2)));
         }
       });
     });
@@ -217,12 +227,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).`
       );
     }
   }
@@ -235,22 +245,22 @@ var localAgentConfigSchema = z3.object({
   cwd: z3.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()
 }).strict();
-var bridgeConfigSchema = z3.object({
+var companionConfigSchema = z3.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, {
     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
@@ -261,19 +271,19 @@ var bridgeConfigSchema = z3.object({
   deviceId: z3.string().optional(),
   deviceLabel: z3.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(),
   // 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(),
   // 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
@@ -314,21 +324,21 @@ function loadConfig() {
   let raw;
   try {
     raw = readFileSync(path3, "utf8");
-  } catch (err) {
+  } catch (err2) {
     throw new ConfigError(
-      `couldn't read ${path3}: ${err instanceof Error ? err.message : String(err)}`
+      `couldn't read ${path3}: ${err2 instanceof Error ? err2.message : String(err2)}`
     );
   }
   if (raw.trim().length === 0) return null;
   let parsed;
   try {
     parsed = JSON.parse(raw);
-  } catch (err) {
+  } catch (err2) {
     throw new ConfigError(
-      `${path3} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
+      `${path3} is not valid JSON: ${err2 instanceof Error ? err2.message : String(err2)}`
     );
   }
-  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 +347,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;
@@ -357,19 +367,19 @@ function saveConfig(cfg) {
     } catch {
     }
     renameSync(tmp, path3);
-  } catch (err) {
+  } catch (err2) {
     try {
       rmSync(tmp, { force: true });
     } catch {
     }
-    throw err;
+    throw err2;
   }
 }
 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 +402,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 +413,7 @@ var CONSOLE_IGNORE = [
   "agentId",
   "messageId",
   "sessionId",
-  "bridgeId"
+  "companionId"
 ].join(",");
 function consoleShortId(log) {
   const id = log.conversationId ?? log.workspaceId;
@@ -417,10 +427,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 +462,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 +476,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 +668,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 +709,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);
@@ -835,15 +845,15 @@ var DEFAULT_PORT = 7474;
 var PORT_FALLBACK_SPAN = 10;
 function buildDashboardApp(deps) {
   const app = new Hono();
-  app.onError((err, c) => {
-    if (err instanceof ApiError) {
-      const status = err.status >= 400 && err.status < 600 ? err.status : 502;
-      return c.json({ error: err.message }, status);
+  app.onError((err2, c) => {
+    if (err2 instanceof ApiError) {
+      const status = err2.status >= 400 && err2.status < 600 ? err2.status : 502;
+      return c.json({ error: err2.message }, status);
     }
-    if (err instanceof BridgeError) {
-      return c.json({ error: err.message }, 400);
+    if (err2 instanceof CompanionError) {
+      return c.json({ error: err2.message }, 400);
     }
-    return c.json({ error: err instanceof Error ? err.message : "internal error" }, 500);
+    return c.json({ error: err2 instanceof Error ? err2.message : "internal error" }, 500);
   });
   registerRoutes(app, { ...deps, staticDir: resolveStaticDir() });
   return app;
@@ -864,15 +874,15 @@ async function startDashboard(opts) {
           server.closeAllConnections?.();
         })
       };
-    } catch (err) {
-      if (isAddrInUse(err)) {
-        lastErr = err;
+    } catch (err2) {
+      if (isAddrInUse(err2)) {
+        lastErr = err2;
         continue;
       }
-      throw err;
+      throw err2;
     }
   }
-  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)})`
   );
 }
@@ -885,16 +895,16 @@ function listen(app, port) {
         resolve(server);
       }
     });
-    server.on("error", (err) => {
+    server.on("error", (err2) => {
       if (!settled) {
         settled = true;
-        reject(err);
+        reject(err2);
       }
     });
   });
 }
-function isAddrInUse(err) {
-  return Boolean(err && typeof err === "object" && "code" in err && err.code === "EADDRINUSE");
+function isAddrInUse(err2) {
+  return Boolean(err2 && typeof err2 === "object" && "code" in err2 && err2.code === "EADDRINUSE");
 }
 function resolveStaticDir() {
   return join4(dirname3(fileURLToPath(import.meta.url)), "static");
@@ -1018,8 +1028,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)."
   );
 }
 
@@ -1091,8 +1101,8 @@ async function verifyRuntime(state, fetchImpl = fetch) {
   let res;
   try {
     res = await fetchImpl(url, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS) });
-  } catch (err) {
-    return isConnRefused(err) ? "stale" : "unknown";
+  } catch (err2) {
+    return isConnRefused(err2) ? "stale" : "unknown";
   }
   if (!res.ok) return "unknown";
   let body;
@@ -1104,9 +1114,9 @@ async function verifyRuntime(state, fetchImpl = fetch) {
   if (typeof body.instance_id !== "string") return "unknown";
   return body.instance_id === state.instanceId ? "ours" : "stale";
 }
-function isConnRefused(err) {
-  if (!err || typeof err !== "object") return false;
-  const cause = err.cause;
+function isConnRefused(err2) {
+  if (!err2 || typeof err2 !== "object") return false;
+  const cause = err2.cause;
   return !!cause && typeof cause === "object" && cause.code === "ECONNREFUSED";
 }
 function trimSlash(s) {
@@ -1169,10 +1179,10 @@ var CabaneApi = class {
     for (let attempt = 1; ; attempt++) {
       try {
         return await this.attempt(method, path3, body, signal);
-      } catch (err) {
-        if (attempt >= maxAttempts || signal?.aborted || !isRetryable(err)) throw err;
+      } catch (err2) {
+        if (attempt >= maxAttempts || signal?.aborted || !isRetryable(err2)) throw err2;
         await sleep(RETRY_BACKOFF_MS[attempt - 1], signal);
-        if (signal?.aborted) throw err;
+        if (signal?.aborted) throw err2;
       }
     }
   }
@@ -1200,15 +1210,15 @@ var CabaneApi = class {
         retry: true,
         ...signal ? { signal } : {}
       });
-    } catch (err) {
+    } catch (err2) {
       const outbox = this.opts.outbox;
-      if (!outbox) throw err;
-      if (signal?.aborted || isAbortError(err)) throw err;
-      if (!isRetryable(err)) throw err;
+      if (!outbox) throw err2;
+      if (signal?.aborted || isAbortError(err2)) throw err2;
+      if (!isRetryable(err2)) throw err2;
       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)"
+        { kind, turnId, seq, err: err2 instanceof Error ? err2.message : String(err2) },
+        "companion: commit queued to outbox after transient failure (will drain when the API returns)"
       );
     }
   }
@@ -1231,11 +1241,11 @@ var CabaneApi = class {
           await this.request(entry.method, entry.path, entry.body, { retry: true });
           outbox.remove(entry.turnId, entry.seq);
           progressed = true;
-        } catch (err) {
-          if (err instanceof ApiError && err.status >= 400 && err.status < 500) {
+        } catch (err2) {
+          if (err2 instanceof ApiError && err2.status >= 400 && err2.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)"
+              { kind: entry.kind, turnId: entry.turnId, seq: entry.seq, status: err2.status },
+              "companion outbox: discarding entry on terminal 4xx (will never land)"
             );
             outbox.remove(entry.turnId, entry.seq);
             progressed = true;
@@ -1262,7 +1272,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 +1305,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 +1323,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 +1366,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) {
@@ -1362,11 +1392,11 @@ var CabaneApi = class {
     try {
       await this.request("PATCH", path3, body, { retry: true });
       outbox?.remove(key, ACTIVE_RUN_OUTBOX_SEQ);
-    } catch (err) {
-      if (!outbox) throw err;
-      if (!isRetryable(err)) {
+    } catch (err2) {
+      if (!outbox) throw err2;
+      if (!isRetryable(err2)) {
         outbox.remove(key, ACTIVE_RUN_OUTBOX_SEQ);
-        throw err;
+        throw err2;
       }
       outbox.persist({
         enqueuedAt: Date.now(),
@@ -1378,17 +1408,17 @@ var CabaneApi = class {
         kind: "active-run"
       });
       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)"
+        { conversationId, agentId, err: err2 instanceof Error ? err2.message : String(err2) },
+        "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 +1433,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 +1479,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 +1494,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(
@@ -1477,13 +1507,13 @@ var CabaneApi = class {
     return res.messages.find((m) => m.id === messageId2) ?? null;
   }
 };
-function isRetryable(err) {
-  if (err instanceof ApiError) return err.status >= 500;
-  if (isAbortError(err)) return false;
+function isRetryable(err2) {
+  if (err2 instanceof ApiError) return err2.status >= 500;
+  if (isAbortError(err2)) return false;
   return true;
 }
-function isAbortError(err) {
-  return err instanceof Error && err.name === "AbortError";
+function isAbortError(err2) {
+  return err2 instanceof Error && err2.name === "AbortError";
 }
 function sleep(ms, signal) {
   return new Promise((resolve) => {
@@ -1501,8 +1531,8 @@ function sleep(ms, signal) {
 }
 function errorMessage(status, body) {
   if (body && typeof body === "object" && "error" in body) {
-    const err = body.error;
-    if (typeof err === "string") return `${status} ${err}`;
+    const err2 = body.error;
+    if (typeof err2 === "string") return `${status} ${err2}`;
   }
   if (typeof body === "string" && body.length > 0) return `${status} ${body.slice(0, 200)}`;
   return `${status} error`;
@@ -1546,7 +1576,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) {
@@ -1555,8 +1588,8 @@ var DeviceApi = class {
 };
 function errorMessage2(status, body) {
   if (body && typeof body === "object" && "error" in body) {
-    const err = body.error;
-    if (typeof err === "string") return `${status} ${err}`;
+    const err2 = body.error;
+    if (typeof err2 === "string") return `${status} ${err2}`;
   }
   if (typeof body === "string" && body.length > 0) return `${status} ${body.slice(0, 200)}`;
   return `${status} error`;
@@ -1610,12 +1643,12 @@ function save(map) {
     } catch {
     }
     renameSync2(tmp, path3);
-  } catch (err) {
+  } catch (err2) {
     try {
       rmSync3(tmp, { force: true });
     } catch {
     }
-    throw err;
+    throw err2;
   }
 }
 function getCredential(agentId) {
@@ -1781,7 +1814,7 @@ 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
@@ -1798,16 +1831,17 @@ var hostPolicySchema = z5.object({
   // 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
+  // Browser automation (the Playwright MCP surface). Varies by host: a companion has
   // it, the house executor does not (CT230).
   browser: z5.boolean(),
   // User-configured MCP servers permitted. False for the house executor
-  // (CT227: Cabane agents run no user MCP servers), true for a personal bridge.
+  // (CT227: Cabane agents run no user MCP servers), true for a personal companion.
   userMcp: z5.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(),
   // ── Hard platform invariants — always denied, never granted ────────────────
@@ -1828,7 +1862,7 @@ var turnEventSchema = z6.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,7 +1875,7 @@ 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({
@@ -1889,7 +1923,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 +1933,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,7 +1955,7 @@ 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"),
@@ -1918,7 +1965,9 @@ var turnEventSchema = z6.discriminatedUnion("type", [
       inputTokens: z6.number(),
       outputTokens: z6.number(),
       cacheReadTokens: z6.number().optional(),
-      cacheCreationTokens: z6.number().optional()
+      cacheCreationTokens: z6.number().optional(),
+      contextTokens: z6.number().optional(),
+      contextWindow: z6.number().optional()
     }).optional(),
     resolvedModel: z6.string().optional(),
     resolvedConfig: z6.object({
@@ -2006,7 +2055,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,6 +2085,7 @@ 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/;
 
@@ -2096,34 +2147,62 @@ var turnRequestSchema = z8.object({
     mcpUrl: z8.string(),
     bearer: z8.string(),
     activeConversationId: z8.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: z8.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: z8.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: z8.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(),
+    nativeWorkAssignment: z8.object({
+      itemId: z8.string(),
+      executionId: z8.string(),
+      activationEpoch: z8.number().int().nonnegative()
+    }).strict().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
+    // default in place (see `buildClaudeCodeOptions`). The In-Cabane executor never
     // sets it, so house stays force-off unconditionally.
     claudeCode: z8.object({ autoMemory: z8.boolean().optional() }).optional()
   }),
   // Host-owned injected servers (host-filled) — e.g. the summon server.
   extra: z8.object({
-    mcpServers: hostInjectedServersSchema
+    mcpServers: hostInjectedServersSchema,
+    // CT666: the per-turn turn-control HANDLER for the in-process cabane-native
+    // runtime — the seam that gives it ask/wake_me/summon_agent/sub_agent/skip_turn
+    // without a subprocess `cabane_companion` MCP server. Typed `unknown` for the same
+    // reason as `mcpServers`: it's a live host object (a `NativeTurnControl` whose
+    // methods close over the dispatcher's per-turn state), passed to the native
+    // adapter WITHOUT the contract package inspecting it. The subprocess adapters
+    // ignore it (they get the same verbs from the injected SDK server instead).
+    turnControl: z8.unknown().optional()
   })
 });
 
@@ -2143,8 +2222,8 @@ function createTerminalTextBuffer() {
 async function safeEmit(emit, event, onError) {
   try {
     await emit(event);
-  } catch (err) {
-    onError?.(err, event.type);
+  } catch (err2) {
+    onError?.(err2, event.type);
   }
 }
 async function processAssistantMessage(msg, emit, pending, buffer, onError) {
@@ -2405,16 +2484,16 @@ var TurnPump = class {
   // minimal note. Skipped when cancelled or already final. The held-text flush
   // that precedes it is a classification concern, driven by the caller before
   // this runs.
-  async finalize(ok) {
-    if (!ok || this.opts.signal.aborted || this.emittedFinal) return;
+  async finalize(ok2) {
+    if (!ok2 || this.opts.signal.aborted || this.emittedFinal) return;
     const body = this.lastProgressBody ?? this.opts.emptyFinalBody;
     const seq = this.opts.nextSeq();
     try {
       await this.opts.commit.commitMessage({ body, kind: "final", seq });
       this.emittedFinal = true;
       this.finalReplyBody = body;
-    } catch (err) {
-      this.opts.onError?.(err, "empty-final");
+    } catch (err2) {
+      this.opts.onError?.(err2, "empty-final");
     }
   }
   // Whether the turn has committed its `final` row — read by the host to decide
@@ -2504,10 +2583,10 @@ var claudeCodeDialectSchema = z10.object({
   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`;
+  // `claude_code` preset + project settings + always-allow `PreToolUse` hook;
   // `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
+  // `policy.hostFs` (the host-fs BLOCK), because companion `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.
@@ -2555,10 +2634,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;
@@ -2619,7 +2706,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 +2719,7 @@ function buildClaudeCodeOptions(req, augment) {
       settingSources: ["project"],
       allowedTools,
       disallowedTools,
-      canUseTool: allowEverything
+      hooks: { PreToolUse: [{ hooks: [allowEverythingHook] }] }
     };
   } else {
     options = {
@@ -2659,13 +2746,15 @@ async function* decodeSdkStream(iter, ctx) {
     out.push(event);
   };
   let sessionEmitted = false;
-  let ok = false;
+  let ok2 = false;
   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 +2777,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,16 +2789,23 @@ 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;
-        if (typeof err === "string" && err.length > 0) authError = err;
+        const err2 = msg.error;
+        if (typeof err2 === "string" && err2.length > 0) authError = err2;
       } 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;
+          ok2 = true;
         } else {
           const resultText = msg.result ?? "";
           const terminalReason = msg.terminal_reason;
@@ -2715,36 +2813,40 @@ 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(" "));
           resultReason = failure ? encodeFailureReason(failure) : isError ? `error:${resultText.slice(0, 200) || "unknown"}` : `result_error:${msg.subtype}`;
-          ok = false;
+          ok2 = false;
         }
         break;
       }
     }
-  } catch (err) {
-    if (ctx.signal.aborted) throw err;
-    const failure = classifyErrorText(err instanceof Error ? err.message : String(err));
-    if (!failure) throw err;
-    ok = false;
+  } catch (err2) {
+    if (ctx.signal.aborted) throw err2;
+    const failure = classifyErrorText(err2 instanceof Error ? err2.message : String(err2));
+    if (!failure) throw err2;
+    ok2 = false;
     resultReason = encodeFailureReason(failure);
     sawResult = true;
   }
   if (ctx.signal.aborted) return;
-  await flushHeldText(buffer, emit, ok);
+  await flushHeldText(buffer, emit, ok2);
   yield* drain(out);
-  if (!ok && !resultReason && !sawResult) resultReason = "no_result";
+  if (!ok2 && !resultReason && !sawResult) resultReason = "no_result";
   yield {
     type: "result",
-    ok,
+    ok: ok2,
     ...resultReason ? { reason: resultReason } : {},
     ...usage ? { usage } : {},
     ...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 +2860,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 +2998,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 +3168,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: [
@@ -3275,9 +3401,9 @@ function readSessionId(properties) {
 }
 function readSessionError(properties) {
   const props = asRecord(properties);
-  const err = props?.error;
-  if (typeof err === "string") return err;
-  const rec = asRecord(err);
+  const err2 = props?.error;
+  if (typeof err2 === "string") return err2;
+  const rec = asRecord(err2);
   if (!rec) return "unknown";
   const { name, message } = deepestError(rec);
   if (message && name && !isGenericErrorName(name)) return `${name}: ${message}`;
@@ -3313,7 +3439,7 @@ async function* decodeOpencodeStream(events, ctx) {
   const pending = /* @__PURE__ */ new Map();
   const startedTools = /* @__PURE__ */ new Set();
   const finishedTools = /* @__PURE__ */ new Set();
-  let ok = false;
+  let ok2 = false;
   let reason;
   let settled = false;
   const userMessageIds = /* @__PURE__ */ new Set();
@@ -3376,7 +3502,7 @@ async function* decodeOpencodeStream(events, ctx) {
       const sealed = sealHeld(held, true);
       held = null;
       if (sealed) yield sealed;
-      ok = true;
+      ok2 = true;
       settled = true;
       break;
     } else if (ev.type === "session.error") {
@@ -3385,7 +3511,7 @@ async function* decodeOpencodeStream(events, ctx) {
       const sealed = sealHeld(held, false);
       held = null;
       if (sealed) yield sealed;
-      ok = false;
+      ok2 = false;
       const errorText = readSessionError(ev.properties);
       const failure = classifyErrorText(errorText);
       reason = failure ? encodeFailureReason(failure) : `error:${errorText.slice(0, 200)}`;
@@ -3400,7 +3526,7 @@ async function* decodeOpencodeStream(events, ctx) {
     if (sealed) yield sealed;
     reason = "no_terminal";
   }
-  yield { type: "result", ok, ...reason ? { reason } : {} };
+  yield { type: "result", ok: ok2, ...reason ? { reason } : {} };
 }
 function hasToolInput(input) {
   return !!input && typeof input === "object" && Object.keys(input).length > 0;
@@ -3458,6 +3584,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 +3646,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") {
@@ -3651,9 +3789,9 @@ function createHttpOpencodeTransport(opts) {
           // The lock is released when this stream finishes draining.
           events: releaseAfter(parseSseStream(eventRes.body, sessionId, signal), release)
         };
-      } catch (err) {
+      } catch (err2) {
         release();
-        throw err;
+        throw err2;
       }
     }
   };
@@ -3784,7 +3922,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 +3938,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 +4286,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 +4325,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 +4369,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;
 }
@@ -4235,9 +4384,9 @@ function readItemType(item) {
 function readErrorMessage(ev) {
   const direct = str(ev.message);
   if (direct) return direct;
-  const err = asRecord2(ev.error);
-  if (err) {
-    const m = str(err.message);
+  const err2 = asRecord2(ev.error);
+  if (err2) {
+    const m = str(err2.message);
     if (m) return m;
   }
   return "unknown";
@@ -4293,7 +4442,7 @@ async function* decodeCodexStream(events, ctx) {
   const startedTools = /* @__PURE__ */ new Set();
   const finishedTools = /* @__PURE__ */ new Set();
   let sessionEmitted = false;
-  let ok = false;
+  let ok2 = false;
   let reason;
   let usage;
   let settled = false;
@@ -4324,7 +4473,7 @@ async function* decodeCodexStream(events, ctx) {
         const message = readItemMessage(item);
         if (isModelMetadataError(message)) {
           yield* flushInterim();
-          ok = false;
+          ok2 = false;
           reason = `model_unavailable:${message.slice(0, 200)}`;
           settled = true;
           break;
@@ -4343,7 +4492,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);
@@ -4379,13 +4528,13 @@ async function* decodeCodexStream(events, ctx) {
       held = null;
       if (sealed) yield sealed;
       usage = readUsage(ev);
-      ok = true;
+      ok2 = true;
       settled = true;
       break;
     }
     if (ev.type === "turn.failed" || ev.type === "error") {
       yield* flushInterim();
-      ok = false;
+      ok2 = false;
       const text = readErrorMessage(ev);
       const failure = classifyErrorText(text);
       reason = failure ? encodeFailureReason(failure) : `error:${text.slice(0, 200)}`;
@@ -4403,7 +4552,7 @@ async function* decodeCodexStream(events, ctx) {
   const resolvedConfig = ctx.resolvedReasoningEffort ? { reasoningEffort: ctx.resolvedReasoningEffort } : void 0;
   yield {
     type: "result",
-    ok,
+    ok: ok2,
     ...reason ? { reason } : {},
     ...usage ? { usage } : {},
     ...ctx.resolvedModel ? { resolvedModel: ctx.resolvedModel } : {},
@@ -4423,12 +4572,15 @@ function sealHeld2(held, terminal) {
 // packages/agent-runtime/src/codex/policy.ts
 import { z as z12 } 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
   };
 }
@@ -4451,6 +4603,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 +4634,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 +4651,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 +4670,46 @@ 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);
+  return {
+    mcp_servers,
+    experimental_use_rmcp_client: true,
+    ...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 +4798,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;
       }
@@ -4769,7 +4961,7 @@ var CodexExec = class {
       signal: args.signal
     });
     let spawnError = null;
-    child.once("error", (err) => spawnError = err);
+    child.once("error", (err2) => spawnError = err2);
     if (!child.stdin) {
       child.kill();
       throw new Error("Child process has no stdin");
@@ -5047,6 +5239,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 +5263,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 +5320,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 +5341,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 +5505,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.
@@ -5606,15 +5868,35 @@ 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_\`:
+You are running on Cabane's own agent runtime. You have a small, curated 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_search\` \u2014 substring search across file/folder names, file contents, and conversations.
 - \`cabane_write\` \u2014 create or overwrite a file (pass \`overwrite: true\` to replace).
 - \`cabane_edit\` \u2014 find/replace inside an existing file.
+- \`cabane_mkdir\` \u2014 create a folder (pass \`recursive: true\` to also make missing parents).
+- \`cabane_move\` \u2014 move or rename a file or folder.
+- \`cabane_delete\` \u2014 delete a file or folder (folders need \`recursive: true\`; soft-delete, recoverable).
+- \`cabane_context\` \u2014 gather an object plus its related context (files, conversations, people) in one call \u2014 your first move to understand what surrounds something.
+- \`cabane_messages\` \u2014 read a conversation's messages by id (from \`cabane_search\` / \`cabane_context\`).
+
+Paths are workspace-relative with a leading slash (\`/notes/todo.md\`). This is a deliberately curated 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.`;
+var CABANE_NATIVE_ADDENDUM_CODE_MODE = `## Your tools (native runtime \u2014 code mode)
+
+You are running on Cabane's own agent runtime, in **code mode**. Your one workspace tool is \`sdk\`: you act on the workspace by writing a short TypeScript program against the ambient \`cabane\` object and submitting it as the \`code\` argument. Only what your program \`return\`s (plus \`console.log\`) comes back \u2014 so gather, filter, and summarize *inside* the program and return the small answer, not the raw material.
 
-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.`;
+There is **no** \`cabane_read\` / \`cabane_write\` / \`cabane_search\` / \`cabane_edit\` tool \u2014 those are \`cabane\` SDK calls *inside* your program (\`cabane.files.read(path)\`, \`cabane.find.search(q)\`, \u2026), not tools you call directly. The full SDK surface \u2014 every method and its options \u2014 is documented below this note in your prompt.
+
+Beside \`sdk\` you also have a few **plain-named** tools that act on the TURN itself, not the workspace (they can't be a program's \`return\` value):
+- \`ask\` \u2014 put a structured question to a human and END your turn (they may answer in days).
+- \`wake_me\` \u2014 end this turn now and be re-dispatched later to check a condition (a PR merging, a reply landing).
+- \`summon_agent\` \u2014 pull a peer agent into THIS conversation to reply on your turn.
+- \`sub_agent\` \u2014 spawn a private worker with a fresh context window; its result comes back here later (don't wait \u2014 end your turn).
+- \`skip_turn\` \u2014 end your turn with NO reply, when the message doesn't need one from you.
+- \`mint_render_token\` \u2014 mint a short-lived credential to load a workspace HTML page in a browser.
+
+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;
@@ -5679,6 +5961,18 @@ function parseCabaneNativeModel(model) {
   return model.startsWith(CABANE_NATIVE_MODEL_PREFIX) ? model.slice(CABANE_NATIVE_MODEL_PREFIX.length) : model;
 }
 
+// packages/agent-runtime/src/cabane-native/policy.ts
+import { z as z13 } from "zod";
+var NATIVE_SURFACES = ["code", "classic"];
+var cabaneNativeDialectSchema = z13.object({ surface: z13.enum(NATIVE_SURFACES).optional() }).loose();
+function readCabaneNativeDialect(runtimeOptions) {
+  const parsed = cabaneNativeDialectSchema.safeParse(runtimeOptions?.["cabane-native"] ?? {});
+  return parsed.success ? parsed.data : {};
+}
+function cabaneNativeSurface(runtimeOptions) {
+  return readCabaneNativeDialect(runtimeOptions).surface ?? "code";
+}
+
 // packages/agent-runtime/src/cabane-native/tools.ts
 var TOOL_RESULT_MAX_CHARS = 8e3;
 var CABANE_NATIVE_TOOLS = [
@@ -5762,11 +6056,157 @@ var CABANE_NATIVE_TOOLS = [
         required: ["path", "find", "replace"]
       }
     }
+  },
+  {
+    type: "function",
+    function: {
+      name: "cabane_mkdir",
+      description: "Create a folder at a workspace path. Pass `recursive: true` to also create any missing parent folders (like `mkdir -p`); otherwise the parent must already exist.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Workspace folder path, e.g. /notes/archive." },
+          recursive: {
+            type: "boolean",
+            description: "Create missing parent folders too (default false)."
+          }
+        },
+        required: ["path"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "cabane_move",
+      description: "Move and/or rename a file or folder. `fromPath` is the current path; `toPath` is the new full path (its parent must already exist). Same parent + new name renames in place; a different parent moves it.",
+      parameters: {
+        type: "object",
+        properties: {
+          fromPath: { type: "string", description: "The current file/folder path." },
+          toPath: { type: "string", description: "The new full path (parent + name)." }
+        },
+        required: ["fromPath", "toPath"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "cabane_delete",
+      description: "Delete the file or folder at a workspace path. Folders require `recursive: true` (deletes everything inside). Soft delete \u2014 the entry is recoverable from the trash, not erased.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Workspace file/folder path to delete." },
+          recursive: {
+            type: "boolean",
+            description: "Required to delete a non-empty folder (default false)."
+          }
+        },
+        required: ["path"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "cabane_context",
+      description: "Gather a workspace object plus its most relevant connected context \u2014 related files, conversations, people \u2014 in one call. Your first move to understand what surrounds something before acting. `ref` is the object id, or its workspace path when `kind` is `file` or `folder`.",
+      parameters: {
+        type: "object",
+        properties: {
+          kind: {
+            type: "string",
+            enum: ["conversation", "file", "folder", "user", "agent", "channel"],
+            description: "The kind of object to orient around."
+          },
+          ref: {
+            type: "string",
+            description: "The object id (or the workspace path for a file/folder)."
+          }
+        },
+        required: ["kind", "ref"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "cabane_messages",
+      description: 'Read a page of messages from a conversation by id (get ids from `cabane_search` or `cabane_context`). `order: "desc"` (default) returns newest-first \u2014 where a thread is now; `order: "asc"` returns oldest-first \u2014 how it began. Your own current thread is already in context; use this to catch up on other conversations or to page further back.',
+      parameters: {
+        type: "object",
+        properties: {
+          conversationId: { type: "string", description: "The conversation id to read." },
+          order: {
+            type: "string",
+            enum: ["asc", "desc"],
+            description: "newest-first (desc, default) or oldest-first (asc)."
+          },
+          limit: {
+            type: "number",
+            description: "Max messages to return (default 50, max 100)."
+          }
+        },
+        required: ["conversationId"]
+      }
+    }
   }
 ];
+var CABANE_NATIVE_CODE_TOOL = {
+  type: "function",
+  function: {
+    name: "sdk",
+    description: "Run a TypeScript program against the workspace. `code` is the program \u2014 the body of an async function, so top-level `await` works and `return <value>` produces the result. Write against the ambient `cabane` object (no imports); only what you `return` plus `console.log` comes back, so gather/filter/summarize inside the program and return the small answer. The full `cabane` SDK surface \u2014 every method and its options \u2014 is documented in your system prompt above.",
+    parameters: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "The TypeScript program to run (an async function body)."
+        }
+      },
+      required: ["code"]
+    }
+  }
+};
+var CABANE_NATIVE_RENDER_TOKEN_TOOL = {
+  type: "function",
+  function: {
+    name: "mint_render_token",
+    description: "Mint a short-lived, scoped credential that lets a browser load a workspace HTML page at the content-isolation origin. Returns `{ url, cookieName, cookieValue, expiresAt, pathPrefix }`. `pathPrefix` (default `/`) narrows the grant to a folder or single file; `ttlSeconds` (default 30 min, max 86400) overrides the TTL.",
+    parameters: {
+      type: "object",
+      properties: {
+        pathPrefix: {
+          type: "string",
+          description: "Workspace-rooted path-prefix the token authorizes; `/` for whole-workspace."
+        },
+        ttlSeconds: {
+          type: "number",
+          description: "Override the default 30-minute TTL; capped at 24h (86400s)."
+        }
+      }
+    }
+  }
+};
 function summarizeCabaneToolArgs(name, args) {
-  if (name === "cabane_search") return typeof args.q === "string" ? args.q : "";
-  return typeof args.path === "string" ? args.path : "";
+  if (name === "mint_render_token") return str2(args.pathPrefix) ?? "/";
+  if (name === "sdk") {
+    const code = str2(args.code) ?? "";
+    const firstLine = code.split("\n").find((l) => l.trim().length > 0)?.trim() ?? "";
+    return firstLine.length > 80 ? `${firstLine.slice(0, 80)}\u2026` : firstLine;
+  }
+  if (name === "cabane_search") return str2(args.q) ?? "";
+  if (name === "cabane_move") {
+    const from = str2(args.fromPath) ?? "";
+    const to = str2(args.toPath) ?? "";
+    return from && to ? `${from} \u2192 ${to}` : from || to;
+  }
+  if (name === "cabane_context") return str2(args.ref) ?? "";
+  if (name === "cabane_messages") return str2(args.conversationId) ?? "";
+  return str2(args.path) ?? "";
 }
 async function executeCabaneNativeTool(name, args, ctx, signal) {
   const doFetch = ctx.fetchImpl ?? fetch;
@@ -5785,10 +6225,10 @@ async function executeCabaneNativeTool(name, args, ctx, signal) {
         ...init2?.body !== void 0 ? { body: JSON.stringify(init2.body) } : {},
         signal
       });
-    } catch (err) {
+    } catch (err2) {
       return {
         ok: false,
-        result: `error: request failed: ${err instanceof Error ? err.message : String(err)}`
+        result: `error: request failed: ${err2 instanceof Error ? err2.message : String(err2)}`
       };
     }
     const contentType = res.headers.get("content-type") ?? "";
@@ -5797,6 +6237,20 @@ async function executeCabaneNativeTool(name, args, ctx, signal) {
     return { ok: true, result: truncate2(text) };
   };
   switch (name) {
+    case "sdk":
+      return call("POST", "/sdk", {
+        body: {
+          program: str2(args.code) ?? "",
+          ...ctx.conversationId ? { activeConversationId: ctx.conversationId } : {}
+        }
+      });
+    case "mint_render_token":
+      return call("POST", "/render-tokens", {
+        body: {
+          pathPrefix: str2(args.pathPrefix) ?? "/",
+          ...typeof args.ttlSeconds === "number" ? { ttlSeconds: args.ttlSeconds } : {}
+        }
+      });
     case "cabane_list":
       return call("GET", "/files/tree", { query: { path: str2(args.path) ?? "/" } });
     case "cabane_read":
@@ -5820,6 +6274,39 @@ async function executeCabaneNativeTool(name, args, ctx, signal) {
           ...args.replaceAll === true ? { replaceAll: true } : {}
         }
       });
+    case "cabane_mkdir":
+      return call("POST", "/folders", {
+        body: {
+          path: str2(args.path),
+          ...args.recursive === true ? { recursive: true } : {}
+        }
+      });
+    case "cabane_move":
+      return call("POST", "/entries/move", {
+        body: { fromPath: str2(args.fromPath), toPath: str2(args.toPath) }
+      });
+    case "cabane_delete":
+      return call("DELETE", "/entries", {
+        query: {
+          path: str2(args.path),
+          recursive: args.recursive === true ? "true" : void 0
+        }
+      });
+    case "cabane_context":
+      return call("POST", "/graph/query", {
+        body: { preset: "orient", args: { kind: str2(args.kind), ref: str2(args.ref) } }
+      });
+    case "cabane_messages":
+      return call(
+        "GET",
+        `/conversations/${encodeURIComponent(str2(args.conversationId) ?? "")}/messages`,
+        {
+          query: {
+            order: str2(args.order),
+            limit: typeof args.limit === "number" ? String(args.limit) : void 0
+          }
+        }
+      );
     default:
       return { ok: false, result: `error: unknown tool "${name}"` };
   }
@@ -5832,6 +6319,238 @@ function truncate2(s) {
 \u2026 [truncated]` : s;
 }
 
+// packages/agent-runtime/src/cabane-native/turn-control.ts
+function describeSubAgentError(status, body) {
+  const code = body && typeof body === "object" && "error" in body ? String(body.error) : void 0;
+  switch (code) {
+    case "callout_cap_exceeded":
+      return "sub_agent: you already have the maximum open sub-agents for this thread. Wait for some to return \u2014 you're woken once they're all back \u2014 before spawning more.";
+    case "callout_depth_exceeded":
+      return "sub_agent: this would nest sub-agents too deep (max 3 levels). Have the current worker report back rather than spawning another layer.";
+    case "dispatch_agent_not_found":
+      return "sub_agent: no live agent in this workspace matches that `agentId`. Check `list_agents`, or omit `agentId` to spawn yourself.";
+    case "dispatch_return_requires_turn":
+    case "dispatch_return_requires_agent":
+    case "dispatch_return_requires_dispatch":
+      return `sub_agent: the spawn was rejected (${code}). This is a turn-context problem, not something to retry blindly \u2014 report it rather than looping.`;
+    default:
+      return `sub_agent: the spawn failed (${code ?? `HTTP ${status}`}).`;
+  }
+}
+var CABANE_NATIVE_TURN_CONTROL_TOOLS = [
+  {
+    type: "function",
+    function: {
+      name: "ask",
+      description: "Ask a HUMAN a structured question you need answered to continue, then END your turn (do not wait \u2014 a reply may take days). Pass `targetUserId` (a workspace member id). Single form: a one-sentence `headline` (the question, capitalized, ending in `?`) + a short `question` body of framing, with 2\u20134 `options` when the answer is a bounded/yes-no choice. Or `questions`: 1\u20135 items each `{ headline, body?, options? }` when several decisions land at once. Provide EITHER `question` or `questions`, never both. Your surrounding context goes in your reply; the ask carries the question.",
+      parameters: {
+        type: "object",
+        properties: {
+          targetUserId: {
+            type: "string",
+            description: "The workspace member (human) to ask \u2014 a user id from the roster."
+          },
+          question: {
+            type: "string",
+            description: "Single-question form: a short body of framing (one or two sentences)."
+          },
+          headline: {
+            type: "string",
+            description: "Single-question form: the question itself as one clear capitalized sentence ending in `?`."
+          },
+          options: {
+            type: "array",
+            items: { type: "string" },
+            description: "Single-question form: 2\u20134 suggested one-click answers."
+          },
+          questions: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                headline: { type: "string" },
+                body: { type: "string" },
+                options: { type: "array", items: { type: "string" } }
+              },
+              required: ["headline"]
+            },
+            description: "Multi-question form: 1\u20135 questions to ask at once."
+          }
+        },
+        required: ["targetUserId"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "wake_me",
+      description: 'Wake yourself later \u2014 end this turn now and be re-dispatched at a time you pick, to CHECK a condition that has not happened yet (a PR merging, a reply landing, "check back in five minutes"). Pass EXACTLY ONE of `afterSeconds` (a relative delay, \u226560) or `at` (an absolute ISO-8601 timestamp WITH a zone you compute yourself). `note` is the message to your future self \u2014 write the condition to re-check. It arms when the turn ends; one wake per turn.',
+      parameters: {
+        type: "object",
+        properties: {
+          afterSeconds: {
+            type: "number",
+            description: "Relative delay in seconds from when this turn ends (floor 60)."
+          },
+          at: {
+            type: "string",
+            description: "Absolute ISO-8601 timestamp with a zone (e.g. 2026-07-16T09:00:00-07:00)."
+          },
+          note: {
+            type: "string",
+            description: "A note to your future self \u2014 becomes the wake body (the condition to re-check)."
+          }
+        },
+        required: ["note"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "summon_agent",
+      description: "Summon another agent into THIS conversation \u2014 dispatch a peer to reply here on your turn. Pass the peer `agentId` (from the agent roster). The peer is dispatched on your final reply and picks up this conversation as context, so write the context/ask into your reply first. Writing `@handle` in prose summons no one \u2014 this tool is the only in-thread lever. Single target, last call wins; summoning yourself is a no-op.",
+      parameters: {
+        type: "object",
+        properties: {
+          agentId: {
+            type: "string",
+            description: "The peer agent to summon \u2014 a workspace agent id from the roster."
+          }
+        },
+        required: ["agentId"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "sub_agent",
+      description: "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. It does NOT return inline: this returns the child's id immediately and the outcome lands LATER as a message in this conversation (you're woken once every sub-agent you have out here has returned). So don't wait \u2014 finish what else this turn can do and end your turn. `prompt` is the child's self-contained opening instruction; `agentId` (optional) dispatches a peer instead of yourself; `title` (optional) names the child thread. Reach for it to isolate a big read or fan out N independent pieces in parallel.",
+      parameters: {
+        type: "object",
+        properties: {
+          prompt: {
+            type: "string",
+            description: "The sub-agent's self-contained opening instruction."
+          },
+          agentId: {
+            type: "string",
+            description: "Optional peer to run the sub-agent as; omit to spawn yourself."
+          },
+          title: { type: "string", description: "Optional title for the child thread." }
+        },
+        required: ["prompt"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "skip_turn",
+      description: "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 an aside, a question already answered, a pile-on someone else has. Your turn ends silently (no message bubble). `reason` is a short free-text note for telemetry. Prefer this over posting a low-value \"ok!\"; skipping IS the whole turn.",
+      parameters: {
+        type: "object",
+        properties: {
+          reason: {
+            type: "string",
+            description: "Short reason you are declining \u2014 used for telemetry."
+          }
+        },
+        required: ["reason"]
+      }
+    }
+  }
+];
+var CABANE_NATIVE_TURN_CONTROL_NAMES = new Set(
+  CABANE_NATIVE_TURN_CONTROL_TOOLS.map((t) => t.function.name)
+);
+function summarizeTurnControlArgs(name, args) {
+  if (name === "ask") return str3(args.headline) ?? str3(args.question) ?? "";
+  if (name === "wake_me") return str3(args.note) ?? "";
+  if (name === "summon_agent") return str3(args.agentId) ?? "";
+  if (name === "sub_agent") return str3(args.title) ?? truncateHead(str3(args.prompt) ?? "", 60);
+  if (name === "skip_turn") return str3(args.reason) ?? "";
+  return "";
+}
+async function executeNativeTurnControl(name, args, tc) {
+  switch (name) {
+    case "summon_agent": {
+      const agentId = str3(args.agentId);
+      if (!agentId) return err("summon_agent: `agentId` is required.");
+      tc.summon(agentId);
+      return ok({ summoned: agentId });
+    }
+    case "skip_turn": {
+      const reason = str3(args.reason);
+      if (!reason) return err("skip_turn: `reason` is required.");
+      tc.skip(reason);
+      return ok({ skipped: true });
+    }
+    case "ask": {
+      const targetUserId = str3(args.targetUserId);
+      if (!targetUserId) return err("ask: `targetUserId` is required.");
+      const hasSingle = args.question !== void 0;
+      const hasArray = Array.isArray(args.questions) && args.questions.length > 0;
+      if (hasSingle && hasArray)
+        return err("ask: provide either `question` or `questions`, not both.");
+      if (!hasSingle && !hasArray) return err("ask: provide `question` or `questions`.");
+      const payload = hasArray ? { targetUserId, questions: args.questions } : {
+        targetUserId,
+        question: str3(args.question),
+        ...str3(args.headline) ? { headline: str3(args.headline) } : {},
+        ...Array.isArray(args.options) ? { options: args.options } : {}
+      };
+      tc.ask(payload);
+      return ok({ asked: targetUserId });
+    }
+    case "wake_me": {
+      const note = str3(args.note);
+      if (!note) return err("wake_me: `note` is required.");
+      const hasAfter = typeof args.afterSeconds === "number";
+      const hasAt = typeof args.at === "string";
+      if (hasAfter && hasAt)
+        return err("wake_me: provide either `afterSeconds` or `at`, not both.");
+      if (!hasAfter && !hasAt) return err("wake_me: provide `afterSeconds` or `at`.");
+      tc.wake({
+        ...hasAfter ? { afterSeconds: args.afterSeconds } : {},
+        ...hasAt ? { at: args.at } : {},
+        note
+      });
+      return ok({ armed: hasAt ? { at: args.at } : { afterSeconds: args.afterSeconds } });
+    }
+    case "sub_agent": {
+      const prompt = str3(args.prompt);
+      if (!prompt) return err("sub_agent: `prompt` is required.");
+      const result = await tc.subAgent({
+        prompt,
+        ...str3(args.agentId) ? { agentId: str3(args.agentId) } : {},
+        ...str3(args.title) ? { title: str3(args.title) } : {}
+      });
+      if (!result.ok) return err(result.error);
+      return ok({
+        conversationId: result.conversationId,
+        note: "Spawned. Don't wait \u2014 finish what else this turn can do, then end your turn; the result posts back here."
+      });
+    }
+    default:
+      return err(`unknown turn-control tool "${name}"`);
+  }
+}
+function ok(payload) {
+  return { ok: true, result: JSON.stringify(payload) };
+}
+function err(message) {
+  return { ok: false, result: `error: ${message}` };
+}
+function str3(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function truncateHead(s, n) {
+  return s.length > n ? `${s.slice(0, n)}\u2026` : s;
+}
+
 // packages/agent-runtime/src/cabane-native/loop.ts
 var DEFAULT_MAX_ITERATIONS = 12;
 async function* runCabaneNativeTurn(req, signal, deps) {
@@ -5840,10 +6559,20 @@ async function* runCabaneNativeTurn(req, signal, deps) {
     return;
   }
   const model = parseCabaneNativeModel(req.config.model);
+  const surface = cabaneNativeSurface(req.config.runtimeOptions);
+  const turnControl = req.extra.turnControl;
+  const tools = surface === "code" ? [
+    CABANE_NATIVE_CODE_TOOL,
+    CABANE_NATIVE_RENDER_TOKEN_TOOL,
+    ...turnControl ? CABANE_NATIVE_TURN_CONTROL_TOOLS : []
+  ] : CABANE_NATIVE_TOOLS;
   const toolCtx = {
     apiRoot: deps.apiRoot,
     workspaceId: deps.workspaceId,
     bearer: deps.bearer,
+    // CT666: the origin conversation, forwarded by the `sdk` tool to the `/sdk`
+    // endpoint so a code-mode program's returning callout binds to this turn.
+    ...deps.conversationId ? { conversationId: deps.conversationId } : {},
     ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}
   };
   const messages = await assembleMessages(req.systemPrompt, req.content, req.prompt, {
@@ -5863,10 +6592,7 @@ async function* runCabaneNativeTurn(req, signal, deps) {
     const toolAcc = /* @__PURE__ */ new Map();
     let finishReason;
     let errored2;
-    for await (const ev of deps.provider.stream(
-      { model, messages, tools: CABANE_NATIVE_TOOLS },
-      signal
-    )) {
+    for await (const ev of deps.provider.stream({ model, messages, tools }, signal)) {
       if (signal.aborted) return;
       switch (ev.type) {
         case "text":
@@ -5881,7 +6607,11 @@ async function* runCabaneNativeTurn(req, signal, deps) {
           break;
         }
         case "usage":
-          usage = { inputTokens: ev.inputTokens, outputTokens: ev.outputTokens };
+          usage = {
+            inputTokens: ev.inputTokens,
+            outputTokens: ev.outputTokens,
+            contextTokens: ev.inputTokens
+          };
           break;
         case "model":
           resolvedModel = ev.model;
@@ -5932,9 +6662,10 @@ async function* runCabaneNativeTurn(req, signal, deps) {
       if (signal.aborted) return;
       const args = parseArgs(t.args);
       const displayName = prettyToolName(t.name);
-      const summary = summarizeCabaneToolArgs(t.name, args);
+      const isTurnControl = CABANE_NATIVE_TURN_CONTROL_NAMES.has(t.name);
+      const summary = isTurnControl ? summarizeTurnControlArgs(t.name, args) : 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);
+      const result = isTurnControl && turnControl ? await executeNativeTurnControl(t.name, args, turnControl) : await executeCabaneNativeTool(t.name, args, toolCtx, signal);
       if (signal.aborted) return;
       yield {
         type: "tool",
@@ -5978,10 +6709,6 @@ function parseArgs(raw) {
   }
 }
 
-// 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) {
@@ -6011,9 +6738,9 @@ function createOpenRouterProvider(opts) {
           }),
           signal
         });
-      } catch (err) {
+      } catch (err2) {
         if (signal.aborted) return;
-        yield { type: "error", message: `request failed: ${errText(err)}` };
+        yield { type: "error", message: `request failed: ${errText(err2)}` };
         return;
       }
       if (!res.ok || !res.body) {
@@ -6083,9 +6810,9 @@ function createOpenRouterProvider(opts) {
             }
           }
         }
-      } catch (err) {
+      } catch (err2) {
         if (signal.aborted) return;
-        yield { type: "error", message: `stream read failed: ${errText(err)}` };
+        yield { type: "error", message: `stream read failed: ${errText(err2)}` };
         return;
       }
       yield { type: "done", ...finishReason ? { finishReason } : {} };
@@ -6101,8 +6828,8 @@ function providerErrorMessage(status, body) {
   }
   return `HTTP ${status}: ${detail}`;
 }
-function errText(err) {
-  return err instanceof Error ? err.message : String(err);
+function errText(err2) {
+  return err2 instanceof Error ? err2.message : String(err2);
 }
 
 // packages/agent-runtime/src/cabane-native/index.ts
@@ -6115,13 +6842,15 @@ function createCabaneNativeAdapter(deps = {}) {
   }) : 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,
+    // CT666: the native runtime's addendum is now SURFACE-aware. Code mode (the
+    // default In-Cabane surface) mounts the single `sdk` tool, so it's taught the
+    // code-mode addendum (act by writing a `cabane` SDK program; the `cabane_*`
+    // names don't exist here); classic (the retained CT663 10-tool fallback) is
+    // taught the granular `cabane_*` listing. The caller (turn-context) passes
+    // `codeMode` off the SAME lifted surface value the loop mounts tools from, so
+    // the prompt and the mounted surface can't drift. (Supersedes CT614's
+    // flag-independent addendum: native no longer ignores this arg.)
+    promptAddendum: (codeMode) => codeMode ? CABANE_NATIVE_ADDENDUM_CODE_MODE : CABANE_NATIVE_ADDENDUM,
     dialectSchema: cabaneNativeDialectSchema,
     async *runTurn(req, signal) {
       if (!provider) {
@@ -6195,8 +6924,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 +6939,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";
+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,7 +6970,7 @@ 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(
@@ -6442,7 +7172,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,23 +7186,35 @@ 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 } : {},
       ...params.env ? { env: params.env } : {},
+      ...params.nativeWorkAssignment ? { nativeWorkAssignment: params.nativeWorkAssignment } : {},
       // User MCP servers (already `${PLACEHOLDER}`-resolved). Structurally the
       // adapter's `ResolvedMcpServers`.
       ...Object.keys(params.mcpServers).length > 0 ? { mcpServers: params.mcpServers } : {},
       // 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) + the cabane-native turn-control handler (CT666).
+    extra: {
+      mcpServers: { [COMPANION_LOCAL_MCP_SERVER]: params.summonServer },
+      turnControl: params.turnControl
+    }
   };
 }
 function trimSlash3(s) {
@@ -6482,18 +7227,26 @@ 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, assignmentKey) {
+  const suffix = assignmentKey ? `--${encodeURIComponent(assignmentKey)}` : "";
+  return join9(
+    conversationDir(workspaceId, conversationId),
+    `${encodeURIComponent(agentId)}${suffix}.json`
+  );
+}
+function readPrepared(workspaceId, conversationId, agentId, assignmentKey) {
+  const path3 = pathFor3(workspaceId, conversationId, agentId, assignmentKey);
   if (!existsSync7(path3)) return null;
   try {
     const parsed = JSON.parse(readFileSync6(path3, "utf8"));
     if (parsed && typeof parsed.cwd === "string" && parsed.cwd.length > 0) {
       return {
         cwd: parsed.cwd,
-        ...parsed.env && typeof parsed.env === "object" ? { env: parsed.env } : {}
+        ...parsed.env && typeof parsed.env === "object" ? { env: parsed.env } : {},
+        ...parsed.nativeWorkAssignment && typeof parsed.nativeWorkAssignment === "object" ? { nativeWorkAssignment: parsed.nativeWorkAssignment } : {}
       };
     }
     return null;
@@ -6501,9 +7254,13 @@ 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, assignmentKey) {
+  mkdirSync7(conversationDir(workspaceId, conversationId), { recursive: true });
+  writeFileSync6(
+    pathFor3(workspaceId, conversationId, agentId, assignmentKey),
+    JSON.stringify(result) + "\n",
+    "utf8"
+  );
 }
 
 // src/secrets.ts
@@ -6521,18 +7278,18 @@ function loadSecretStore() {
   let raw;
   try {
     raw = readFileSync7(path3, "utf8");
-  } catch (err) {
+  } catch (err2) {
     throw new ConfigError(
-      `couldn't read ${path3}: ${err instanceof Error ? err.message : String(err)}`
+      `couldn't read ${path3}: ${err2 instanceof Error ? err2.message : String(err2)}`
     );
   }
   if (raw.trim().length === 0) return makeStore({});
   let parsed;
   try {
     parsed = JSON.parse(raw);
-  } catch (err) {
+  } catch (err2) {
     throw new ConfigError(
-      `${path3} is not valid JSON: ${err instanceof Error ? err.message : String(err)}. It must be a flat object of "NAME": "value" secret pairs.`
+      `${path3} is not valid JSON: ${err2 instanceof Error ? err2.message : String(err2)}. It must be a flat object of "NAME": "value" secret pairs.`
     );
   }
   const result = secretStoreSchema.safeParse(parsed);
@@ -6546,8 +7303,8 @@ function loadSecretStore() {
 function loadSecretStoreTolerant(onWarn) {
   try {
     return loadSecretStore();
-  } catch (err) {
-    onWarn?.(err instanceof Error ? err.message : String(err));
+  } catch (err2) {
+    onWarn?.(err2 instanceof Error ? err2.message : String(err2));
     return makeStore({});
   }
 }
@@ -6618,8 +7375,8 @@ var TranscriptWriter = class {
       } catch {
       }
       pruneOld(dir2, RETAIN);
-    } catch (err) {
-      this.fail(err);
+    } catch (err2) {
+      this.fail(err2);
     }
     this.line({ type: "_meta", ...meta });
   }
@@ -6635,14 +7392,14 @@ var TranscriptWriter = class {
     if (this.broken) return;
     try {
       appendFileSync(this.path, JSON.stringify(obj) + "\n", { mode: 384 });
-    } catch (err) {
-      this.fail(err);
+    } catch (err2) {
+      this.fail(err2);
     }
   }
-  fail(err) {
+  fail(err2) {
     if (this.broken) return;
     this.broken = true;
-    this.onWarn?.(`transcript write failed (${err instanceof Error ? err.message : String(err)})`);
+    this.onWarn?.(`transcript write failed (${err2 instanceof Error ? err2.message : String(err2)})`);
   }
 };
 function fileName(meta) {
@@ -6680,9 +7437,9 @@ var EMPTY_FINAL_BODY = "Done \u2014 see the changes above.";
 var TurnCommitter = class {
   constructor(deps) {
     this.deps = deps;
-    this.onError = (err, hook) => {
+    this.onError = (err2, hook) => {
       deps.log.warn(
-        { err: err instanceof Error ? err.message : String(err), hook },
+        { err: err2 instanceof Error ? err2.message : String(err2), hook },
         "dispatcher: transcript callback failed"
       );
     };
@@ -6747,9 +7504,9 @@ var TurnCommitter = class {
       signal: deps.signal,
       nextSeq: deps.nextSeq,
       emptyFinalBody: EMPTY_FINAL_BODY,
-      onError: (err) => {
+      onError: (err2) => {
         deps.log.warn(
-          { err: err instanceof Error ? err.message : String(err) },
+          { err: err2 instanceof Error ? err2.message : String(err2) },
           "dispatcher: empty-final commit failed"
         );
       }
@@ -6772,8 +7529,8 @@ var TurnCommitter = class {
     if (event.type === "session" || event.type === "result") return;
     try {
       await this.emit(event);
-    } catch (err) {
-      this.onError(err, event.type);
+    } catch (err2) {
+      this.onError(err2, event.type);
     }
   }
   // End-of-turn empty-final promotion. The held-text flush is now the adapter's
@@ -6844,13 +7601,128 @@ 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;
@@ -6858,23 +7730,6 @@ var DEFAULT_AGENT_TOTAL_TIMEOUT_MS = 45 * 6e4;
 function runKey(conversationId, agentId) {
   return `${conversationId}|${agentId}`;
 }
-function describeSubAgentError(status, body) {
-  const code = body && typeof body === "object" && "error" in body ? String(body.error) : void 0;
-  switch (code) {
-    case "callout_cap_exceeded":
-      return "sub_agent: you already have the maximum open sub-agents for this thread. Wait for some to return \u2014 you're woken once they're all back \u2014 before spawning more.";
-    case "callout_depth_exceeded":
-      return "sub_agent: this would nest sub-agents too deep (max 3 levels). Have the current worker report back rather than spawning another layer.";
-    case "dispatch_agent_not_found":
-      return "sub_agent: no live agent in this workspace matches that `agentId`. Check `list_agents`, or omit `agentId` to spawn yourself.";
-    case "dispatch_return_requires_turn":
-    case "dispatch_return_requires_agent":
-    case "dispatch_return_requires_dispatch":
-      return `sub_agent: the spawn was rejected (${code}). This is a turn-context problem, not something to retry blindly \u2014 report it rather than looping.`;
-    default:
-      return `sub_agent: the spawn failed (${code ?? `HTTP ${status}`}).`;
-  }
-}
 var Dispatcher = class {
   constructor(opts) {
     this.opts = opts;
@@ -6895,9 +7750,9 @@ 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
@@ -6915,15 +7770,15 @@ 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,
         body
       );
-    } catch (err) {
+    } catch (err2) {
       turnLog.warn(
-        { err: err instanceof Error ? err.message : String(err) },
+        { err: err2 instanceof Error ? err2.message : String(err2) },
         "dispatcher: pre-run active-run clear failed terminally; server age-sweep is the backstop"
       );
     }
@@ -6941,19 +7796,24 @@ 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);
-    } catch (err) {
-      const status = err instanceof ApiError ? err.status : 0;
+      turnContext = await this.opts.api.getTurnContext(
+        payload.conversationId,
+        payload.messageId,
+        turnId
+      );
+    } catch (err2) {
+      const status = err2 instanceof ApiError ? err2.status : 0;
       if (status === 404) {
         turnLog.warn(
-          { err: err instanceof Error ? err.message : String(err) },
+          { err: err2 instanceof Error ? err2.message : String(err2) },
           "dispatcher: turn-context 404 (stale event \u2014 conversation/message/participant gone); skipping"
         );
         return this.concludeBeforeRun(payload, turnLog, startedAt, "turn_context_not_found");
       }
-      const reason = err instanceof Error ? err.message : String(err);
+      const reason = err2 instanceof Error ? err2.message : String(err2);
       turnLog.error({ err: reason }, "dispatcher: failed to fetch turn context");
       const fetchReason = `fetch_failed: ${reason}`;
       return this.concludeBeforeRun(payload, turnLog, startedAt, fetchReason, fetchReason);
@@ -6984,7 +7844,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 +7865,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;
@@ -7017,11 +7876,20 @@ var Dispatcher = class {
       effectiveCwd = void 0;
     }
     let hookEnv;
+    let preparedNativeAssignment;
     if (prepareHook) {
-      const cached2 = readPrepared(workspaceId, payload.conversationId);
+      const assignment = turnContext.conversation.nativeWorkAssignment;
+      const assignmentKey = assignment ? `${assignment.executionId}:${assignment.activationEpoch}` : void 0;
+      const cached2 = readPrepared(
+        workspaceId,
+        payload.conversationId,
+        payload.agentId,
+        assignmentKey
+      );
       if (cached2) {
         effectiveCwd = cached2.cwd;
         hookEnv = cached2.env;
+        preparedNativeAssignment = cached2.nativeWorkAssignment;
       } else {
         const delayMs = this.opts.preparingRowDelayMs ?? DEFAULT_PREPARING_ROW_DELAY_MS;
         let preparingStarted = false;
@@ -7036,9 +7904,9 @@ var Dispatcher = class {
             summary: "",
             phase,
             seq
-          }).catch((err) => {
+          }).catch((err2) => {
             turnLog.warn(
-              { err: err instanceof Error ? err.message : String(err), phase },
+              { err: err2 instanceof Error ? err2.message : String(err2), phase },
               "dispatcher: preparing-activity report failed (continuing with the hook)"
             );
           });
@@ -7055,21 +7923,30 @@ 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).
             triggerEntryPaths: turnContext.conversation.triggerEntryPaths ?? [],
+            ...turnContext.conversation.nativeWorkAssignment ? { nativeWorkAssignment: turnContext.conversation.nativeWorkAssignment } : {},
             title: turnContext.conversation.title
           });
           clearTimeout(preparingTimer);
           if (preparingStarted) reportPreparing("done");
-          writePrepared(workspaceId, payload.conversationId, result);
+          writePrepared(
+            workspaceId,
+            payload.conversationId,
+            payload.agentId,
+            result,
+            assignmentKey
+          );
           effectiveCwd = result.cwd;
           hookEnv = result.env;
-        } catch (err) {
+          preparedNativeAssignment = result.nativeWorkAssignment;
+        } catch (err2) {
           clearTimeout(preparingTimer);
           if (preparingStarted) reportPreparing("error");
-          const reason = err instanceof Error ? err.message : String(err);
+          const reason = err2 instanceof Error ? err2.message : String(err2);
           turnLog.error({ err: reason }, "dispatcher: prepare hook failed");
           try {
             await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
@@ -7097,7 +7974,7 @@ ${reason}`,
     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
@@ -7106,9 +7983,9 @@ ${reason}`,
         // this live turn for an abandoned one and close it with a `stopped`.
         turnId
       });
-    } catch (err) {
+    } catch (err2) {
       turnLog.warn(
-        { err: err instanceof Error ? err.message : String(err) },
+        { err: err2 instanceof Error ? err2.message : String(err2) },
         "dispatcher: active-run flag set failed terminally; proceeding"
       );
     }
@@ -7145,18 +8022,49 @@ ${reason}`,
       subAgentCreate,
       wakeState
     );
-    const request = buildBridgeTurnRequest({
+    const nativeTurnControl = {
+      summon: (agentId) => {
+        summonState.agentId = agentId;
+      },
+      skip: (reason) => {
+        skipState.skipped = true;
+        skipState.reason = reason;
+      },
+      ask: (p) => {
+        askState.targetUserId = p.targetUserId;
+        if (p.questions && p.questions.length > 0) {
+          askState.questions = p.questions;
+          askState.question = null;
+          askState.headline = null;
+          askState.options = null;
+        } else {
+          askState.question = p.question ?? null;
+          askState.headline = p.headline ?? null;
+          askState.options = p.options ?? null;
+          askState.questions = null;
+        }
+      },
+      wake: (p) => {
+        wakeState.afterSeconds = p.afterSeconds ?? null;
+        wakeState.at = p.at ?? null;
+        wakeState.note = p.note;
+      },
+      subAgent: subAgentCreate
+    };
+    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 } : {},
+      ...preparedNativeAssignment ? { nativeWorkAssignment: preparedNativeAssignment } : {},
       mcpServers: resolvedMcpServers,
       summonServer,
+      turnControl: nativeTurnControl,
       // CT238: this turn's conversation, forwarded as the active-conversation
       // header so a cross-thread post/spawn stamps its origin.
       activeConversationId: payload.conversationId,
@@ -7181,15 +8089,15 @@ ${reason}`,
     let adapter;
     try {
       adapter = selectAdapter(registry, turnContext.runtime);
-    } catch (err) {
-      if (!(err instanceof RuntimeUnavailableError)) throw err;
+    } catch (err2) {
+      if (!(err2 instanceof RuntimeUnavailableError)) throw err2;
       turnLog.error(
-        { runtime: err.runtime, available: err.available },
+        { runtime: err2.runtime, available: err2.available },
         "dispatcher: turn runtime not available on this device"
       );
       try {
         await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
-          body: `${RUNTIME_UNAVAILABLE_PREFIX} ${err.message}`,
+          body: `${RUNTIME_UNAVAILABLE_PREFIX} ${err2.message}`,
           kind: "final",
           turnId,
           parentMessageId: payload.messageId
@@ -7204,8 +8112,60 @@ ${reason}`,
         payload,
         turnLog,
         startedAt,
-        `runtime_unavailable:${err.runtime}`
+        `runtime_unavailable:${err2.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 +8210,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 (err2) {
+        turnLog.warn(
+          { err: err2 instanceof Error ? err2.message : String(err2) },
+          "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,15 +8288,15 @@ ${reason}`,
           if (!sessionWritten) {
             sessionWritten = true;
             try {
-              await this.opts.api.setBridgeActiveRun(
+              await this.opts.api.setActiveRun(
                 workspaceId,
                 payload.conversationId,
                 payload.agentId,
                 { agentSessionId: event.state }
               );
-            } catch (err) {
+            } catch (err2) {
               turnLog.warn(
-                { err: err instanceof Error ? err.message : String(err) },
+                { err: err2 instanceof Error ? err2.message : String(err2) },
                 "dispatcher: session-id write failed (will retry next turn)"
               );
             }
@@ -7306,6 +8309,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,31 +8322,41 @@ ${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) {
+        } catch (err2) {
           turnLog.warn(
-            { err: err instanceof Error ? err.message : String(err) },
+            { err: err2 instanceof Error ? err2.message : String(err2) },
             "dispatcher: skipped-marker commit failed"
           );
         }
       } else {
         await committer.finalize(okResult);
       }
-    } catch (err) {
+    } catch (err2) {
       okResult = false;
-      resultReason = err instanceof Error ? err.message : String(err);
+      resultReason = err2 instanceof Error ? err2.message : String(err2);
       turnLog.error({ err: resultReason }, "dispatcher: SDK query threw");
     } finally {
       if (idleTimer) clearTimeout(idleTimer);
@@ -7376,9 +8392,9 @@ ${reason}`,
             // CT113: the stopped marker is still "about" the triggering message.
             parentMessageId: payload.messageId
           });
-        } catch (err) {
+        } catch (err2) {
           turnLog.warn(
-            { err: err instanceof Error ? err.message : String(err) },
+            { err: err2 instanceof Error ? err2.message : String(err2) },
             "dispatcher: stopped-marker commit failed"
           );
         }
@@ -7413,15 +8429,15 @@ ${reason}`,
         errorReason: body.errorReason ?? null
       });
       try {
-        await this.opts.api.setBridgeActiveRun(
+        await this.opts.api.setActiveRun(
           workspaceId,
           payload.conversationId,
           payload.agentId,
           body
         );
-      } catch (err) {
+      } catch (err2) {
         turnLog.warn(
-          { err: err instanceof Error ? err.message : String(err) },
+          { err: err2 instanceof Error ? err2.message : String(err2) },
           "dispatcher: active-run clear failed terminally; server age-sweep is the backstop"
         );
       }
@@ -7465,7 +8481,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 +8495,18 @@ ${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 +8517,7 @@ var LABELS = {
 };
 function deriveHarnessSnapshot(signals) {
   const advertised = new Set(
-    buildBridgeManifest({
+    buildCompanionManifest({
       claudeCode: signals.claudeOnPath,
       opencode: signals.opencodeConfigured,
       codex: signals.codexEnabled
@@ -7700,14 +8707,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,30 +8727,30 @@ 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 {
       writeFileSync7(tmp, JSON.stringify(entry) + "\n", "utf8");
       renameSync3(tmp, target);
-    } catch (err) {
+    } catch (err2) {
       try {
         rmSync5(tmp, { force: true });
       } catch {
       }
       this.log?.warn(
-        { workspaceId: this.workspaceId, err: err instanceof Error ? err.message : String(err) },
-        "bridge outbox: failed to persist entry"
+        { workspaceId: this.workspaceId, err: err2 instanceof Error ? err2.message : String(err2) },
+        "companion outbox: failed to persist entry"
       );
       return;
     }
@@ -7765,7 +8772,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 +8808,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 +8825,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 +8837,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);
       }
@@ -7917,20 +8924,20 @@ var SseSubscriber = class {
       try {
         await this.connect();
         backoff = 500;
-      } catch (err) {
+      } catch (err2) {
         if (this.aborted) return;
-        if (err instanceof ApiError && (err.status === 401 || err.status === 403)) {
+        if (err2 instanceof ApiError && (err2.status === 401 || err2.status === 403)) {
           this.opts.log.error(
-            { workspaceId: this.opts.workspaceId, status: err.status },
+            { workspaceId: this.opts.workspaceId, status: err2.status },
             "SSE auth failed \u2014 tearing down this workspace subscriber"
           );
-          this.opts.onAuthFailure(err.status);
+          this.opts.onAuthFailure(err2.status);
           return;
         }
         this.opts.log.warn(
           {
             workspaceId: this.opts.workspaceId,
-            err: err instanceof Error ? err.message : String(err),
+            err: err2 instanceof Error ? err2.message : String(err2),
             backoff
           },
           "SSE disconnected; reconnecting"
@@ -7993,7 +9000,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 +9014,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 +9038,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 +9069,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` and paste the string from the cabane app.\n"
       );
       return;
     }
@@ -8080,8 +9089,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 +9103,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 +9135,16 @@ 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.
+          // CT598: advertise the native runtime when an OpenRouter key is set. 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).
@@ -8139,25 +9155,25 @@ var BridgeSupervisor = class {
       this.hub.setDevice({ deviceId: res.deviceId });
       this.deviceId = res.deviceId;
       this.checkVersionSkew(res.serverVersion);
-    } catch (err) {
+    } catch (err2) {
       this.log.warn(
-        { err: err instanceof Error ? err.message : String(err) },
-        "bridge: device heartbeat failed (will retry on next tick)"
+        { err: err2 instanceof Error ? err2.message : String(err2) },
+        "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
@@ -8177,12 +9193,12 @@ var BridgeSupervisor = class {
           const resp = await this.deviceApi.getAssignments();
           items = resp.assignments;
           device = resp.device;
-        } catch (err) {
+        } catch (err2) {
           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"
+            { err: err2 instanceof Error ? err2.message : String(err2) },
+            "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));
+          this.hub.setDeviceError(err2 instanceof Error ? err2.message : String(err2));
           return;
         }
         this.hub.setDevice({ deviceId: device.id, deviceLabel: device.label });
@@ -8245,14 +9261,14 @@ 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, {
@@ -8286,7 +9302,7 @@ var BridgeSupervisor = class {
       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 +9341,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 +9350,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);
@@ -8363,7 +9382,7 @@ var BridgeSupervisor = class {
       // 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).
       ...positiveIntEnv("AGENT_IDLE_TIMEOUT_MS") !== void 0 ? { idleTimeoutMs: positiveIntEnv("AGENT_IDLE_TIMEOUT_MS") } : {},
@@ -8402,14 +9421,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);
@@ -8432,17 +9451,17 @@ var BridgeSupervisor = class {
     let wire;
     try {
       wire = JSON.parse(ev.data);
-    } catch (err) {
+    } catch (err2) {
       this.log.warn(
-        { err: err instanceof Error ? err.message : String(err) },
+        { err: err2 instanceof Error ? err2.message : String(err2) },
         "malformed SSE payload"
       );
       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 +9481,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);
@@ -8480,15 +9500,15 @@ var BridgeSupervisor = class {
     }
     const chainKey = `${payload.conversationId}|${payload.agentId}`;
     const prev = wr.chains.get(chainKey) ?? Promise.resolve();
-    const tail = prev.then(() => this.runDispatch(wr, ev, payload, agent)).catch((err) => {
+    const tail = prev.then(() => this.runDispatch(wr, ev, payload, agent)).catch((err2) => {
       this.log.warn(
         {
           workspaceId: wr.workspaceId,
           conversationId: payload.conversationId,
           agentId: payload.agentId,
-          err: err instanceof Error ? err.message : String(err)
+          err: err2 instanceof Error ? err2.message : String(err2)
         },
-        "bridge: conversation turn handler threw"
+        "companion: conversation turn handler threw"
       );
     });
     wr.chains.set(chainKey, tail);
@@ -8516,7 +9536,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 +9544,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 +9554,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 +9562,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);
@@ -8578,11 +9598,11 @@ var BridgeSupervisor = class {
         } else {
           drainDelay = DRAIN_BASE_MS;
         }
-      } catch (err) {
+      } catch (err2) {
         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)"
+          { agentId, err: err2 instanceof Error ? err2.message : String(err2) },
+          "companion: outbox drain pass threw (will retry with backoff)"
         );
       } finally {
         if (!drainStopped) {
@@ -8648,10 +9668,10 @@ var BridgeSupervisor = class {
         codex: signals.codexVersion
       };
       this.hub.setHarnesses(deriveHarnessSnapshot(signals).harnesses);
-    } catch (err) {
+    } catch (err2) {
       this.log.warn(
-        { err: err instanceof Error ? err.message : String(err) },
-        "bridge: harness probe failed (will retry on next beat)"
+        { err: err2 instanceof Error ? err2.message : String(err2) },
+        "companion: harness probe failed (will retry on next beat)"
       );
     }
   }
@@ -8676,7 +9696,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 +9717,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 +9753,38 @@ 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);
@@ -8773,17 +9825,17 @@ var RECOVERABLE_CODES = /* @__PURE__ */ new Set([
   "ERR_STREAM_DESTROYED",
   "ERR_STREAM_WRITE_AFTER_END"
 ]);
-function errorCode(err) {
-  if (err && typeof err === "object" && "code" in err) {
-    const code = err.code;
+function errorCode(err2) {
+  if (err2 && typeof err2 === "object" && "code" in err2) {
+    const code = err2.code;
     if (typeof code === "string") return code;
   }
   return void 0;
 }
-function isRecoverableSocketError(err) {
-  const code = errorCode(err);
+function isRecoverableSocketError(err2) {
+  const code = errorCode(err2);
   if (code && RECOVERABLE_CODES.has(code)) return true;
-  const message = err instanceof Error ? err.message : String(err);
+  const message = err2 instanceof Error ? err2.message : String(err2);
   return /\bEPIPE\b|\bECONNRESET\b/.test(message);
 }
 function installProcessSafetyNet(log, opts = {}) {
@@ -8792,37 +9844,37 @@ function installProcessSafetyNet(log, opts = {}) {
     stream.on("error", () => {
     });
   }
-  proc.on("uncaughtException", (err) => handleUncaught(log, err, "uncaughtException"));
+  proc.on("uncaughtException", (err2) => handleUncaught(log, err2, "uncaughtException"));
   proc.on(
     "unhandledRejection",
     (reason) => handleUncaught(log, reason, "unhandledRejection")
   );
 }
-function handleUncaught(log, err, origin) {
-  const message = err instanceof Error ? err.message : String(err);
-  const code = errorCode(err);
-  if (isRecoverableSocketError(err)) {
+function handleUncaught(log, err2, origin) {
+  const message = err2 instanceof Error ? err2.message : String(err2);
+  const code = errorCode(err2);
+  if (isRecoverableSocketError(err2)) {
     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)"
+    { origin, code, err: message, stack: err2 instanceof Error ? err2.stack : void 0 },
+    "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 +9888,7 @@ function clearCrash() {
 }
 
 // src/runtime.ts
-async function createBridgeRuntime(opts = {}) {
+async function createCompanionRuntime(opts = {}) {
   const log = getLogger();
   installProcessSafetyNet(log);
   const probeClaude = opts.probeClaude ?? claudeOnPath;
@@ -8846,14 +9898,14 @@ async function createBridgeRuntime(opts = {}) {
     cfg = requireConfig();
     claudeCode = await probeClaude();
     await ensureRuntimeAvailable(cfg, { probeClaude: async () => claudeCode });
-  } catch (err) {
+  } catch (err2) {
     recordCrash({
-      reason: err instanceof Error ? err.message : String(err),
-      ...errorCode(err) ? { code: errorCode(err) } : {},
+      reason: err2 instanceof Error ? err2.message : String(err2),
+      ...errorCode(err2) ? { code: errorCode(err2) } : {},
       origin: "startup",
       at: (/* @__PURE__ */ new Date()).toISOString()
     });
-    throw err;
+    throw err2;
   }
   if (cfg.logLevel) log.level = cfg.logLevel;
   const harnessVersions = await probeHarnessVersions({
@@ -8870,23 +9922,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 +9959,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 +9978,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
 };