@cabane/companion 0.5.0 → 0.6.0

package/dist/cli.js

@@ -23,13 +23,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(status2, message, body) {
     super(message);
     this.status = status2;
@@ -39,13 +39,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";
@@ -76,12 +76,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()
@@ -89,7 +89,7 @@ var pairingSchema = z.object({
 function decodePairing(raw) {
   const cleaned = raw.replace(/\s+/g, "");
   if (cleaned.length === 0) {
-    throw new BridgeError("empty pairing string. Copy it from the cabane app and try again.");
+    throw new CompanionError("empty pairing string. Copy it from the cabane app and try again.");
   }
   const bytes = Buffer.from(cleaned, "base64url");
   const json = bytes.toString("utf8");
@@ -97,23 +97,23 @@ function decodePairing(raw) {
   try {
     parsed = JSON.parse(json);
   } catch {
-    throw new BridgeError(
+    throw new CompanionError(
       `that doesn't look like a complete pairing string \u2014 received ${cleaned.length} characters that decoded to ${bytes.length} bytes, but they weren't valid JSON. Copy the WHOLE block from the cabane app (a partial or truncated copy is the usual cause).`
     );
   }
   if (parsed && typeof parsed === "object" && "v" in parsed && parsed.v !== PAIRING_VERSION) {
-    throw new BridgeError(
-      `this pairing string is version ${String(parsed.v)}, but this bridge only understands version ${PAIRING_VERSION}. Update cabane-companion (\`git pull\` + rebuild) and try again.`
+    throw new CompanionError(
+      `this pairing string is version ${String(parsed.v)}, but this companion only understands version ${PAIRING_VERSION}. Update cabane-companion (\`git pull\` + rebuild) and try again.`
     );
   }
   const result = pairingSchema.safeParse(parsed);
   if (!result.success) {
     if (result.error.issues.some((i) => i.path[0] === "baseUrl")) {
-      throw new BridgeError(
-        "this pairing string points at a non-https cabane URL. The bridge runs the server's prompt with permissions bypassed and sends its credentials over the same channel, so it refuses plaintext http (except localhost for local dev). Use an https base URL."
+      throw new CompanionError(
+        "this pairing string points at a non-https cabane URL. The companion runs the server's prompt with permissions bypassed and sends its credentials over the same channel, so it refuses plaintext http (except localhost for local dev). Use an https base URL."
       );
     }
-    throw new BridgeError(
+    throw new CompanionError(
       `the pairing string is missing or malformed fields: ${result.error.issues.map((i) => i.path.join(".") || "(root)").join(", ")}. Re-copy it from the cabane app.`
     );
   }
@@ -130,13 +130,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);
@@ -155,10 +160,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 };
 }
@@ -183,6 +192,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.
@@ -194,10 +204,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;
@@ -217,8 +227,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(() => {
@@ -231,8 +241,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)));
         }
       });
     });
@@ -257,12 +267,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).`
       );
     }
   }
@@ -275,22 +285,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
@@ -301,19 +311,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
@@ -354,21 +364,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) {
@@ -377,7 +387,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;
@@ -399,7 +409,7 @@ function loadConfigTolerant() {
   } catch {
     return { local: empty, note: `${path3} was unreadable (invalid JSON) and has been reset.` };
   }
-  const strict = bridgeConfigSchema.safeParse(parsed);
+  const strict = companionConfigSchema.safeParse(parsed);
   if (strict.success) {
     const { agents: agents2, dashboardPort, autoOpen, logLevel } = strict.data;
     return {
@@ -423,7 +433,7 @@ function loadConfigTolerant() {
   }
   return {
     local,
-    note: `the existing ${path3} was from an older or incompatible bridge; re-pairing rewrote it.`
+    note: `the existing ${path3} was from an older or incompatible companion; re-pairing rewrote it.`
   };
 }
 function saveConfig(cfg) {
@@ -441,19 +451,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;
@@ -470,8 +480,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",
@@ -481,7 +491,7 @@ var CONSOLE_IGNORE = [
   "agentId",
   "messageId",
   "sessionId",
-  "bridgeId"
+  "companionId"
 ].join(",");
 function consoleShortId(log) {
   const id = log.conversationId ?? log.workspaceId;
@@ -495,10 +505,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,
@@ -548,8 +558,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)."
   );
 }
 
@@ -621,8 +631,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;
@@ -634,9 +644,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) {
@@ -660,7 +670,7 @@ async function startDaemon(opts = {}, deps = {}) {
   if (existing) {
     if (await verify(existing) !== "stale") {
       process.stdout.write(
-        `Cabane Bridge is already running (pid ${existing.pid}).
+        `Cabane Companion is already running (pid ${existing.pid}).
 \u2192 Dashboard: ${existing.url}
 Stop it first with \`cabane-companion stop\` if you want to relaunch.
 `
@@ -682,17 +692,17 @@ Stop it first with \`cabane-companion stop\` if you want to relaunch.
   }
   if (!ready(state)) {
     process.stdout.write(
-      `Cabane Bridge was launched (pid ${child.pid ?? "?"}) but didn't report ready within ${STARTUP_TIMEOUT_MS / 1e3}s.
-Check ${bridgeLogPath()} for errors, or run \`cabane-companion status\`.
+      `Cabane Companion was launched (pid ${child.pid ?? "?"}) but didn't report ready within ${STARTUP_TIMEOUT_MS / 1e3}s.
+Check ${companionLogPath()} for errors, or run \`cabane-companion status\`.
 `
     );
     process.exitCode = 1;
     return;
   }
   process.stdout.write(
-    `Cabane Bridge started in the background (pid ${state.pid}).
+    `Cabane Companion started in the background (pid ${state.pid}).
 \u2192 Dashboard: ${state.url}
-Logs:    ${bridgeLogPath()}
+Logs:    ${companionLogPath()}
 Status:  cabane-companion status
 Stop:    cabane-companion stop
 `
@@ -701,12 +711,12 @@ Stop:    cabane-companion stop
 function defaultSpawnDetached(args) {
   const cliPath = fileURLToPath(new URL("../cli.js", import.meta.url));
   mkdirSync4(cabaneDir(), { recursive: true });
-  const logFd = openSync2(bridgeLogPath(), "a");
+  const logFd = openSync2(companionLogPath(), "a");
   try {
     return spawn3(process.execPath, [cliPath, ...args], {
       detached: true,
       stdio: ["ignore", logFd, logFd],
-      env: { ...process.env, CABANE_BRIDGE_DAEMON: "1" }
+      env: { ...process.env, CABANE_COMPANION_DAEMON: "1" }
     });
   } finally {
     closeSync2(logFd);
@@ -764,12 +774,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) {
@@ -807,14 +817,14 @@ async function logout(opts = {}) {
     return;
   }
   if (!opts.yes) {
-    const message = opts.purge ? "Purge the entire local bridge config (device + agent overrides + settings)?" : "Log out this device (removes the device token + cached agent credentials; keeps your config)?";
-    const ok = await confirm({ message, default: false });
-    if (!ok) {
+    const message = opts.purge ? "Purge the entire local companion config (device + agent overrides + settings)?" : "Log out this device (removes the device token + cached agent credentials; keeps your config)?";
+    const ok2 = await confirm({ message, default: false });
+    if (!ok2) {
       process.stdout.write("cancelled\n");
       return;
     }
   }
-  const serverNote = `the device remains registered server-side \u2014 remove it in the cabane app (Settings \u2192 Agents \u2192 Bridges) if you want it gone there too.`;
+  const serverNote = `the device remains registered server-side \u2014 remove it in the cabane app (Settings \u2192 Agents \u2192 Companions) if you want it gone there too.`;
   if (opts.purge) {
     deleteConfig();
     clearCredentials();
@@ -826,7 +836,7 @@ async function logout(opts = {}) {
   saveConfig(rest);
   clearCredentials();
   process.stdout.write(
-    `Logged out \u2014 removed the device token and cached agent credentials, kept your bridge config. Re-pair with \`cabane-companion pair\` (agent credentials are re-delivered when the agents are re-assigned to this device). NOTE: ${serverNote}
+    `Logged out \u2014 removed the device token and cached agent credentials, kept your companion config. Re-pair with \`cabane-companion pair\` (agent credentials are re-delivered when the agents are re-assigned to this device). NOTE: ${serverNote}
 `
   );
 }
@@ -847,9 +857,9 @@ async function postJson(baseUrl, path3, body) {
       headers: { "content-type": "application/json", accept: "application/json" },
       body: JSON.stringify(body)
     });
-  } catch (err) {
-    throw new BridgeError(
-      `couldn't reach cabane at ${baseUrl}: ${err instanceof Error ? err.message : String(err)}. Check the server URL (pass --server <url>) and your connection.`
+  } catch (err2) {
+    throw new CompanionError(
+      `couldn't reach cabane at ${baseUrl}: ${err2 instanceof Error ? err2.message : String(err2)}. Check the server URL (pass --server <url>) and your connection.`
     );
   }
   const raw = await res.text();
@@ -863,7 +873,7 @@ async function postJson(baseUrl, path3, body) {
   }
   if (res.status >= 400) {
     if (res.status === 404 && path3.endsWith("/code")) {
-      throw new BridgeError(
+      throw new CompanionError(
         `this cabane server (${baseUrl}) doesn't support device-flow pairing yet. Update the server, or use \`cabane-companion pair --legacy\` with a pairing string from the app.`
       );
     }
@@ -873,16 +883,16 @@ async function postJson(baseUrl, path3, body) {
   return parsed;
 }
 function requestEnrollmentCode(baseUrl) {
-  return postJson(baseUrl, "/api/bridge-enrollment/code", {});
+  return postJson(baseUrl, "/api/device-enrollment/code", {});
 }
 function pollOnce(baseUrl, deviceCode) {
-  return postJson(baseUrl, "/api/bridge-enrollment/poll", { deviceCode });
+  return postJson(baseUrl, "/api/device-enrollment/poll", { deviceCode });
 }
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function runDeviceFlow(baseUrl, print, opts = {}) {
   const now = opts.now ?? (() => Date.now());
   const wait = opts.sleepMs ?? sleep;
-  if (opts.signal?.aborted) throw new BridgeError("pairing was cancelled.");
+  if (opts.signal?.aborted) throw new CompanionError("pairing was cancelled.");
   const code = await requestEnrollmentCode(baseUrl);
   if (opts.onCode) await opts.onCode(code);
   print("");
@@ -897,11 +907,11 @@ async function runDeviceFlow(baseUrl, print, opts = {}) {
   let intervalMs = Math.max(1, code.interval) * 1e3;
   while (now() < deadline) {
     await wait(intervalMs);
-    if (opts.signal?.aborted) throw new BridgeError("pairing was cancelled.");
+    if (opts.signal?.aborted) throw new CompanionError("pairing was cancelled.");
     const res = await pollOnce(baseUrl, code.deviceCode);
     if (res.status === "complete") {
       if (!res.deviceToken || !res.baseUrl) {
-        throw new BridgeError("the server reported the pairing complete but returned no token.");
+        throw new CompanionError("the server reported the pairing complete but returned no token.");
       }
       return {
         baseUrl: res.baseUrl,
@@ -911,13 +921,13 @@ async function runDeviceFlow(baseUrl, print, opts = {}) {
       };
     }
     if (res.status === "expired") {
-      throw new BridgeError(
+      throw new CompanionError(
         "this pairing code expired before it was confirmed. Run `cabane-companion pair` again for a fresh one."
       );
     }
     if (res.status === "slow_down") intervalMs += 1e3;
   }
-  throw new BridgeError(
+  throw new CompanionError(
     "this pairing code expired before it was confirmed. Run `cabane-companion pair` again for a fresh one."
   );
 }
@@ -927,7 +937,7 @@ var DEFAULT_BASE_URL = "https://cabane.ai";
 function resolvePairBaseUrl(server) {
   const raw = (server ?? process.env.CABANE_BASE_URL ?? DEFAULT_BASE_URL).trim();
   if (!isAllowedBaseUrl(raw)) {
-    throw new BridgeError(
+    throw new CompanionError(
       `invalid server URL "${raw}": must be an https URL (loopback http is allowed for local dev). Pass it as \`cabane-companion pair --server https://your-cabane\`.`
     );
   }
@@ -958,9 +968,9 @@ async function resolvePairingString(opts) {
   if (opts.file !== void 0) {
     try {
       return readFileSync4(opts.file, "utf8");
-    } catch (err) {
-      throw new BridgeError(
-        `couldn't read the pairing string from ${opts.file}: ${err instanceof Error ? err.message : String(err)}`
+    } catch (err2) {
+      throw new CompanionError(
+        `couldn't read the pairing string from ${opts.file}: ${err2 instanceof Error ? err2.message : String(err2)}`
       );
     }
   }
@@ -1031,7 +1041,7 @@ function openerFor(url) {
 function shouldAutoOpen(opts) {
   if (opts.flagOpen === true) return true;
   if (opts.flagOpen === false) return false;
-  if (process.env.BRIDGE_NO_OPEN === "1") return false;
+  if (process.env.COMPANION_NO_OPEN === "1") return false;
   if (opts.configAutoOpen === true) return true;
   return false;
 }
@@ -1070,7 +1080,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);
@@ -1084,7 +1094,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) {
@@ -1276,7 +1286,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
     };
@@ -1317,7 +1327,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);
@@ -1453,15 +1463,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 status2 = err.status >= 400 && err.status < 600 ? err.status : 502;
-      return c.json({ error: err.message }, status2);
+  app.onError((err2, c) => {
+    if (err2 instanceof ApiError) {
+      const status2 = err2.status >= 400 && err2.status < 600 ? err2.status : 502;
+      return c.json({ error: err2.message }, status2);
     }
-    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;
@@ -1482,15 +1492,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)})`
   );
 }
@@ -1503,16 +1513,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 join6(dirname4(fileURLToPath2(import.meta.url)), "static");
@@ -1655,10 +1665,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 sleep2(RETRY_BACKOFF_MS[attempt - 1], signal);
-        if (signal?.aborted) throw err;
+        if (signal?.aborted) throw err2;
       }
     }
   }
@@ -1686,15 +1696,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)"
       );
     }
   }
@@ -1717,11 +1727,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;
@@ -1748,7 +1758,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
@@ -1781,15 +1791,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.
@@ -1799,17 +1809,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
@@ -1822,7 +1852,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) {
@@ -1848,11 +1878,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(),
@@ -1864,17 +1894,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
@@ -1889,12 +1919,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",
@@ -1935,11 +1965,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
@@ -1950,10 +1980,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(
@@ -1963,13 +1993,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 sleep2(ms, signal) {
   return new Promise((resolve) => {
@@ -1987,8 +2017,8 @@ function sleep2(ms, signal) {
 }
 function errorMessage(status2, body) {
   if (body && typeof body === "object" && "error" in body) {
-    const err = body.error;
-    if (typeof err === "string") return `${status2} ${err}`;
+    const err2 = body.error;
+    if (typeof err2 === "string") return `${status2} ${err2}`;
   }
   if (typeof body === "string" && body.length > 0) return `${status2} ${body.slice(0, 200)}`;
   return `${status2} error`;
@@ -2032,7 +2062,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) {
@@ -2041,8 +2074,8 @@ var DeviceApi = class {
 };
 function errorMessage2(status2, body) {
   if (body && typeof body === "object" && "error" in body) {
-    const err = body.error;
-    if (typeof err === "string") return `${status2} ${err}`;
+    const err2 = body.error;
+    if (typeof err2 === "string") return `${status2} ${err2}`;
   }
   if (typeof body === "string" && body.length > 0) return `${status2} ${body.slice(0, 200)}`;
   return `${status2} error`;
@@ -2188,7 +2221,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
@@ -2205,16 +2238,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 ────────────────
@@ -2235,7 +2269,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.
   //
@@ -2248,7 +2282,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({
@@ -2296,7 +2330,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 `—`).
   //
@@ -2306,6 +2340,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
@@ -2315,7 +2362,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"),
@@ -2325,7 +2372,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({
@@ -2413,7 +2462,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" };
@@ -2442,6 +2492,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/;
 
@@ -2503,34 +2554,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()
   })
 });
 
@@ -2550,8 +2629,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) {
@@ -2812,16 +2891,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
@@ -2911,10 +2990,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.
@@ -2962,10 +3041,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;
@@ -3026,7 +3113,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 } : {}
@@ -3039,7 +3126,7 @@ function buildClaudeCodeOptions(req, augment) {
       settingSources: ["project"],
       allowedTools,
       disallowedTools,
-      canUseTool: allowEverything
+      hooks: { PreToolUse: [{ hooks: [allowEverythingHook] }] }
     };
   } else {
     options = {
@@ -3066,13 +3153,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 {
@@ -3095,6 +3184,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") {
@@ -3105,16 +3196,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;
@@ -3122,36 +3220,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();
 }
@@ -3165,6 +3267,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) {
@@ -3282,9 +3405,13 @@ var resultErrorFull = (subtype, extra = {}) => ({
   session_id: "s",
   ...extra
 });
-var rateLimitEvent = (status2, resetsAt) => ({
+var rateLimitEvent = (status2, resetsAt, rateLimitType) => ({
   type: "rate_limit_event",
-  rate_limit_info: { status: status2, ...resetsAt !== void 0 ? { resetsAt } : {} },
+  rate_limit_info: {
+    status: status2,
+    ...resetsAt !== void 0 ? { resetsAt } : {},
+    ...rateLimitType !== void 0 ? { rateLimitType } : {}
+  },
   session_id: "s"
 });
 var authStatus = (error) => ({
@@ -3448,17 +3575,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: [
@@ -3682,9 +3808,9 @@ function readSessionId(properties) {
 }
 function readSessionError(properties) {
   const props = asRecord(properties);
-  const err = props?.error;
-  if (typeof err === "string") return err;
-  const rec2 = asRecord(err);
+  const err2 = props?.error;
+  if (typeof err2 === "string") return err2;
+  const rec2 = asRecord(err2);
   if (!rec2) return "unknown";
   const { name, message } = deepestError(rec2);
   if (message && name && !isGenericErrorName(name)) return `${name}: ${message}`;
@@ -3720,7 +3846,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();
@@ -3783,7 +3909,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") {
@@ -3792,7 +3918,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)}`;
@@ -3807,7 +3933,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;
@@ -3865,6 +3991,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;
@@ -3926,6 +4053,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") {
@@ -4058,9 +4196,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;
       }
     }
   };
@@ -4191,7 +4329,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,
@@ -4207,7 +4345,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 },
@@ -4555,13 +4693,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(" ");
@@ -4588,7 +4732,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;
@@ -4632,7 +4776,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;
 }
@@ -4642,9 +4791,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";
@@ -4700,7 +4849,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;
@@ -4731,7 +4880,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;
@@ -4750,7 +4899,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);
@@ -4786,13 +4935,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)}`;
@@ -4810,7 +4959,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 } : {},
@@ -4830,12 +4979,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
   };
 }
@@ -4858,6 +5010,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;
@@ -4888,13 +5041,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"
       };
     }
   }
@@ -4903,12 +5058,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"
       };
     }
   }
@@ -4920,13 +5077,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";
@@ -5015,6 +5205,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;
       }
@@ -5176,7 +5368,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");
@@ -5454,6 +5646,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) {
@@ -5467,17 +5670,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 };
@@ -5534,7 +5727,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,
@@ -5555,7 +5748,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 },
@@ -5719,6 +5912,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.
@@ -6013,15 +6275,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)
 
-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.`;
+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.
+
+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;
@@ -6086,6 +6368,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 = [
@@ -6169,11 +6463,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;
@@ -6192,10 +6632,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") ?? "";
@@ -6204,6 +6644,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":
@@ -6227,6 +6681,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}"` };
   }
@@ -6239,6 +6726,238 @@ function truncate2(s) {
 \u2026 [truncated]` : s;
 }
 
+// packages/agent-runtime/src/cabane-native/turn-control.ts
+function describeSubAgentError(status2, 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 ${status2}`}).`;
+  }
+}
+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) {
@@ -6247,10 +6966,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, {
@@ -6270,10 +6999,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":
@@ -6288,7 +7014,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;
@@ -6339,9 +7069,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",
@@ -6385,10 +7116,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) {
@@ -6418,9 +7145,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) {
@@ -6490,9 +7217,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 } : {} };
@@ -6508,8 +7235,8 @@ function providerErrorMessage(status2, body) {
   }
   return `HTTP ${status2}: ${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
@@ -6522,13 +7249,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) {
@@ -6602,8 +7331,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]) => ({
@@ -6617,22 +7346,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 mkdirSync10 } 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 };
 }
@@ -6647,7 +7377,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(
@@ -6849,7 +7579,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,
@@ -6860,23 +7593,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) {
@@ -6889,18 +7634,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(readFileSync7(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;
@@ -6908,9 +7661,13 @@ function readPrepared(workspaceId, conversationId) {
     return null;
   }
 }
-function writePrepared(workspaceId, conversationId, result) {
-  mkdirSync8(dirFor(workspaceId), { recursive: true });
-  writeFileSync6(pathFor3(workspaceId, conversationId), JSON.stringify(result) + "\n", "utf8");
+function writePrepared(workspaceId, conversationId, agentId, result, assignmentKey) {
+  mkdirSync8(conversationDir(workspaceId, conversationId), { recursive: true });
+  writeFileSync6(
+    pathFor3(workspaceId, conversationId, agentId, assignmentKey),
+    JSON.stringify(result) + "\n",
+    "utf8"
+  );
 }
 
 // src/secrets.ts
@@ -6928,18 +7685,18 @@ function loadSecretStore() {
   let raw;
   try {
     raw = readFileSync8(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);
@@ -6953,8 +7710,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({});
   }
 }
@@ -7025,8 +7782,8 @@ var TranscriptWriter = class {
       } catch {
       }
       pruneOld(dir2, RETAIN);
-    } catch (err) {
-      this.fail(err);
+    } catch (err2) {
+      this.fail(err2);
     }
     this.line({ type: "_meta", ...meta });
   }
@@ -7042,14 +7799,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) {
@@ -7087,9 +7844,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"
       );
     };
@@ -7154,9 +7911,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"
         );
       }
@@ -7179,8 +7936,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
@@ -7251,13 +8008,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;
@@ -7265,23 +8137,6 @@ var DEFAULT_AGENT_TOTAL_TIMEOUT_MS = 45 * 6e4;
 function runKey(conversationId, agentId) {
   return `${conversationId}|${agentId}`;
 }
-function describeSubAgentError(status2, 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 ${status2}`}).`;
-  }
-}
 var Dispatcher = class {
   constructor(opts) {
     this.opts = opts;
@@ -7302,9 +8157,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
@@ -7322,15 +8177,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"
       );
     }
@@ -7348,19 +8203,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 status2 = err instanceof ApiError ? err.status : 0;
+      turnContext = await this.opts.api.getTurnContext(
+        payload.conversationId,
+        payload.messageId,
+        turnId
+      );
+    } catch (err2) {
+      const status2 = err2 instanceof ApiError ? err2.status : 0;
       if (status2 === 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);
@@ -7391,7 +8251,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}`,
@@ -7412,7 +8272,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;
@@ -7424,11 +8283,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;
@@ -7443,9 +8311,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)"
             );
           });
@@ -7462,21 +8330,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, {
@@ -7504,7 +8381,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
@@ -7513,9 +8390,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"
       );
     }
@@ -7552,18 +8429,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,
@@ -7588,15 +8496,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
@@ -7611,9 +8519,61 @@ ${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");
+          mkdirSync10(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 transcript2 = this.opts.transcriptDir ? new TranscriptWriter(
       this.opts.transcriptDir,
       {
@@ -7657,6 +8617,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) => {
@@ -7692,15 +8695,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)"
               );
             }
@@ -7713,6 +8716,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);
         }
       }
@@ -7723,31 +8729,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);
@@ -7783,9 +8799,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"
           );
         }
@@ -7820,15 +8836,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"
         );
       }
@@ -7872,7 +8888,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);
@@ -7886,27 +8902,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
@@ -7917,7 +8924,7 @@ var LABELS = {
 };
 function deriveHarnessSnapshot(signals) {
   const advertised = new Set(
-    buildBridgeManifest({
+    buildCompanionManifest({
       claudeCode: signals.claudeOnPath,
       opencode: signals.opencodeConfigured,
       codex: signals.codexEnabled
@@ -8107,14 +9114,14 @@ async function enumerateOpencodeModels(serverUrl, fetchImpl = fetch) {
 // src/outbox.ts
 import {
   existsSync as existsSync10,
-  mkdirSync as mkdirSync10,
+  mkdirSync as mkdirSync11,
   readdirSync as readdirSync2,
   readFileSync as readFileSync9,
   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 {
@@ -8127,30 +9134,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();
-    mkdirSync10(dir2, { recursive: true });
+    mkdirSync11(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;
     }
@@ -8172,7 +9179,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(readFileSync9(full, "utf8"));
         if (parsed && typeof parsed.turnId === "string" && typeof parsed.seq === "number" && typeof parsed.path === "string") {
@@ -8208,7 +9215,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 });
@@ -8225,7 +9232,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 {
@@ -8237,7 +9244,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);
       }
@@ -8324,20 +9331,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"
@@ -8400,7 +9407,7 @@ function sleep3(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;
@@ -8414,7 +9421,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;
@@ -8438,10 +9445,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
@@ -8467,18 +9476,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;
     }
@@ -8487,8 +9496,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?.();
@@ -8501,20 +9510,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
@@ -8525,17 +9542,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).
@@ -8546,25 +9562,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
@@ -8584,12 +9600,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 });
@@ -8652,14 +9668,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, {
@@ -8693,7 +9709,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)"
         );
       }
     }
@@ -8732,7 +9748,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) {
@@ -8741,7 +9757,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);
@@ -8770,7 +9789,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") } : {},
@@ -8809,14 +9828,14 @@ var BridgeSupervisor = class {
         this.hub.setAuthFailed(wr.workspaceId);
         this.log.error(
           { workspaceId: wr.workspaceId, status: status2, 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);
@@ -8839,17 +9858,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);
@@ -8869,12 +9888,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);
@@ -8887,15 +9907,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);
@@ -8923,7 +9943,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;
@@ -8931,7 +9951,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);
@@ -8941,7 +9961,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);
@@ -8949,7 +9969,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);
@@ -8985,11 +10005,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) {
@@ -9055,10 +10075,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)"
       );
     }
   }
@@ -9083,7 +10103,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,
@@ -9104,7 +10124,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
@@ -9140,6 +10160,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);
@@ -9180,17 +10232,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 = {}) {
@@ -9199,37 +10251,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 mkdirSync11, readFileSync as readFileSync10, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync12, readFileSync as readFileSync10, 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(rec2) {
   try {
-    mkdirSync11(cabaneDir(), { recursive: true });
+    mkdirSync12(cabaneDir(), { recursive: true });
     writeFileSync8(crashMarkerPath(), JSON.stringify(rec2, null, 2) + "\n");
   } catch {
   }
@@ -9243,7 +10295,7 @@ function clearCrash() {
 }
 
 // src/runtime.ts
-async function createBridgeRuntime(opts = {}) {
+async function createCompanionRuntime(opts = {}) {
   const log = getLogger();
   installProcessSafetyNet(log);
   const probeClaude = opts.probeClaude ?? claudeOnPath;
@@ -9253,14 +10305,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({
@@ -9277,23 +10329,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({
@@ -9308,9 +10366,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();
@@ -9327,20 +10385,32 @@ async function createBridgeRuntime(opts = {}) {
   };
   return {
     ok: true,
-    runtime: { url: dashboard.url, port: dashboard.port, config: cfg, stop: stop2 }
+    runtime: {
+      url: dashboard.url,
+      port: dashboard.port,
+      config: cfg,
+      stop: stop2,
+      drainForRestart: async (graceMs) => {
+        clearRuntimeState();
+        const result = await supervisor.drainForRestart(graceMs);
+        await dashboard.close();
+        stopped = true;
+        return result;
+      }
+    }
   };
 }
 
 // src/commands/start.ts
 var FORCE_EXIT_MS = 4e3;
 async function start(opts = {}) {
-  const result = await createBridgeRuntime({
+  const result = await createCompanionRuntime({
     ...opts.port !== void 0 ? { port: opts.port } : {}
   });
   if (!result.ok) {
     const existing = result.existing;
     process.stdout.write(
-      `Cabane Bridge is already running (pid ${existing?.pid ?? "?"}).
+      `Cabane Companion is already running (pid ${existing?.pid ?? "?"}).
 ` + (existing?.url ? `\u2192 Dashboard: ${existing.url}
 ` : "") + `Stop it first with \`cabane-companion stop\` if you want to relaunch.
 `
@@ -9349,7 +10419,7 @@ async function start(opts = {}) {
   }
   const runtime = result.runtime;
   process.stdout.write(`
-Cabane Bridge is running.
+Cabane Companion is running.
 `);
   process.stdout.write(`\u2192 Dashboard: ${runtime.url}
 
@@ -9371,16 +10441,16 @@ Cabane Bridge is running.
     const shutdown = async (signal) => {
       if (shuttingDown) {
         process.stdout.write(`
-bridge: second ${signal}, force-quitting.
+companion: second ${signal}, force-quitting.
 `);
         process.exit(1);
       }
       shuttingDown = true;
       process.stdout.write(`
-bridge: received ${signal}, shutting down\u2026
+companion: received ${signal}, shutting down\u2026
 `);
       const forceExit = setTimeout(() => {
-        process.stdout.write(`bridge: shutdown timed out, force-quitting.
+        process.stdout.write(`companion: shutdown timed out, force-quitting.
 `);
         process.exit(1);
       }, FORCE_EXIT_MS);
@@ -9392,6 +10462,31 @@ bridge: received ${signal}, shutting down\u2026
     };
     process.on("SIGINT", () => void shutdown("SIGINT"));
     process.on("SIGTERM", () => void shutdown("SIGTERM"));
+    process.on("SIGUSR2", () => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      const configuredGrace = Number.parseInt(
+        process.env.CABANE_COMPANION_DEPLOY_GRACE_MS ?? "60000",
+        10
+      );
+      const graceMs = Number.isFinite(configuredGrace) ? configuredGrace : 6e4;
+      process.stdout.write(`
+companion: deploy drain requested (${graceMs}ms grace)\u2026
+`);
+      void runtime.drainForRestart(graceMs).then(({ drained }) => {
+        process.stdout.write(
+          drained ? "companion: deploy drain complete.\n" : "companion: deploy grace expired; unfinished turns will resume after restart.\n"
+        );
+        resolve();
+        process.exit(0);
+      }).catch((err2) => {
+        process.stderr.write(
+          `companion: deploy drain failed: ${err2 instanceof Error ? err2.message : String(err2)}
+`
+        );
+        process.exit(1);
+      });
+    });
   });
 }
 
@@ -9401,7 +10496,7 @@ async function status() {
   const cfg = loadConfig();
   if (!cfg || !cfg.deviceToken) {
     process.stdout.write(
-      "bridge: not paired. Register a device in the cabane app (Settings \u2192 Agents \u2192 Bridges), then run `cabane-companion pair` and paste the string when prompted.\n"
+      "companion: not paired. Register a device in the cabane app (Settings \u2192 Agents \u2192 Companions), then run `cabane-companion pair` and paste the string when prompted.\n"
     );
     process.exitCode = 1;
     return;
@@ -9410,7 +10505,7 @@ async function status() {
 `);
   if (cfg.deviceLabel) process.stdout.write(`device:       ${cfg.deviceLabel}
 `);
-  process.stdout.write(`log file:     ${bridgeLogPath()}
+  process.stdout.write(`log file:     ${companionLogPath()}
 `);
   process.stdout.write(`transcripts:  ${transcriptsLine()}
 `);
@@ -9423,7 +10518,7 @@ async function status() {
     const mode = running.daemon ? "background" : "foreground";
     const uptime = formatUptime(running.startedAt);
     process.stdout.write(
-      `bridge:       running in ${mode} (pid ${running.pid}${uptime ? `, up ${uptime}` : ""})
+      `companion:       running in ${mode} (pid ${running.pid}${uptime ? `, up ${uptime}` : ""})
 `
     );
     process.stdout.write(`dashboard:    ${running.url}  (assigned agents + run state live here)
@@ -9432,7 +10527,7 @@ async function status() {
 `);
   } else {
     process.stdout.write(
-      `bridge:       not running \u2014 \`cabane-companion start\` (foreground) or \`cabane-companion start --daemon\` (background)
+      `companion:       not running \u2014 \`cabane-companion start\` (foreground) or \`cabane-companion start --daemon\` (background)
 `
     );
   }
@@ -9486,40 +10581,42 @@ async function stop(deps = {}) {
   const now = deps.now ?? (() => Date.now());
   const state = readState();
   if (!state) {
-    process.stdout.write("bridge: not running (nothing to stop).\n");
+    process.stdout.write("companion: not running (nothing to stop).\n");
     return;
   }
   if (await verify(state) === "stale") {
     clearRuntimeState();
-    process.stdout.write("bridge: not running (stale marker swept).\n");
+    process.stdout.write("companion: not running (stale marker swept).\n");
     return;
   }
   const { pid } = state;
-  process.stdout.write(`bridge: stopping (pid ${pid})\u2026
+  process.stdout.write(`companion: stopping (pid ${pid})\u2026
 `);
   try {
     kill(pid, "SIGTERM");
   } catch {
     clearRuntimeState();
-    process.stdout.write("bridge: already stopped.\n");
+    process.stdout.write("companion: already stopped.\n");
     return;
   }
   const deadline = now() + TERM_GRACE_MS;
   while (now() < deadline) {
     if (!isAlive(kill, pid)) {
-      process.stdout.write("bridge: stopped.\n");
+      process.stdout.write("companion: stopped.\n");
       return;
     }
     await sleep4(POLL_INTERVAL_MS2);
   }
-  process.stdout.write(`bridge: didn't exit within ${TERM_GRACE_MS / 1e3}s, sending SIGKILL.
-`);
+  process.stdout.write(
+    `companion: didn't exit within ${TERM_GRACE_MS / 1e3}s, sending SIGKILL.
+`
+  );
   try {
     kill(pid, "SIGKILL");
   } catch {
   }
   clearRuntimeState();
-  process.stdout.write("bridge: force-stopped.\n");
+  process.stdout.write("companion: force-stopped.\n");
 }
 function isAlive(kill, pid) {
   try {
@@ -9532,7 +10629,7 @@ function isAlive(kill, pid) {
 
 // src/commands/transcript.ts
 import { existsSync as existsSync12, readFileSync as readFileSync11, readdirSync as readdirSync4 } from "fs";
-import { isAbsolute, join as join14 } from "path";
+import { isAbsolute, join as join15 } from "path";
 async function transcript(opts = {}) {
   const dir2 = transcriptsDir();
   if (opts.follow) {
@@ -9549,7 +10646,7 @@ async function transcript(opts = {}) {
       process.stdout.write(emptyMessage(dir2));
       return;
     }
-    process.stdout.write(renderFile(join14(dir2, newest)) + "\n");
+    process.stdout.write(renderFile(join15(dir2, newest)) + "\n");
     return;
   }
   printList(dir2);
@@ -9625,14 +10722,14 @@ var TranscriptFollower = class {
 function isComplete(content) {
   for (const line of content.split("\n")) {
     if (!line.trim()) continue;
-    if (str3(rec(safeParse(line))?.type) === "_outcome") return true;
+    if (str4(rec(safeParse(line))?.type) === "_outcome") return true;
   }
   return false;
 }
 async function followTranscripts(dir2) {
   const follower = new TranscriptFollower({
     listFiles: () => listFiles(dir2),
-    read: (f) => readFileSync11(join14(dir2, f), "utf8"),
+    read: (f) => readFileSync11(join15(dir2, f), "utf8"),
     write: (s) => process.stdout.write(s),
     // CSI: cursor up `n` lines, then erase from cursor to end of screen.
     clearLines: (n) => process.stdout.write(`\x1B[${n}A\x1B[0J`),
@@ -9672,15 +10769,15 @@ function printList(dir2) {
 
 `);
   for (const f of files.slice(0, 20)) {
-    const { meta, outcome } = peek(join14(dir2, f));
+    const { meta, outcome } = peek(join15(dir2, f));
     const when = fmtTime(rec(meta)?.ts);
-    const ws = str3(rec(meta)?.workspaceSlug);
+    const ws = str4(rec(meta)?.workspaceSlug);
     const o = rec(outcome);
-    const verdict = o ? o.ok === true ? "ok" : `ERROR${str3(o.reason) ? ` (${str3(o.reason)})` : ""}` : "\u2026";
+    const verdict = o ? o.ok === true ? "ok" : `ERROR${str4(o.reason) ? ` (${str4(o.reason)})` : ""}` : "\u2026";
     process.stdout.write(
       `  ${f}
      ${when}  \xB7  ${ws}  \xB7  ${verdict}
-     \u201C${excerpt(str3(rec(meta)?.message), 70)}\u201D
+     \u201C${excerpt(str4(rec(meta)?.message), 70)}\u201D
 
 `
     );
@@ -9696,7 +10793,7 @@ function peek(path3) {
     for (const line of readFileSync11(path3, "utf8").split("\n")) {
       if (!line.trim()) continue;
       const o = safeParse(line);
-      const t = str3(rec(o)?.type);
+      const t = str4(rec(o)?.type);
       if (t === "_meta") meta = o;
       else if (t === "_outcome") outcome = o;
     }
@@ -9707,18 +10804,18 @@ function peek(path3) {
 function resolveTarget(dir2, target) {
   if (isAbsolute(target) || target.includes("/")) {
     if (existsSync12(target)) return target;
-    throw new BridgeError(`no transcript at ${target}.`);
+    throw new CompanionError(`no transcript at ${target}.`);
   }
-  const exact = join14(dir2, target);
+  const exact = join15(dir2, target);
   if (existsSync12(exact)) return exact;
   const matches = listFiles(dir2).filter((f) => f.includes(target));
-  if (matches.length === 1) return join14(dir2, matches[0]);
+  if (matches.length === 1) return join15(dir2, matches[0]);
   if (matches.length === 0) {
-    throw new BridgeError(
+    throw new CompanionError(
       `no transcript matching "${target}" in ${dir2}. Run \`cabane-companion transcript\` to list them.`
     );
   }
-  throw new BridgeError(
+  throw new CompanionError(
     `"${target}" matches ${matches.length} transcripts \u2014 be more specific:
 ` + matches.slice(0, 10).map((m) => `  ${m}`).join("\n")
   );
@@ -9727,9 +10824,9 @@ function renderFile(path3) {
   let content;
   try {
     content = readFileSync11(path3, "utf8");
-  } catch (err) {
-    throw new BridgeError(
-      `couldn't read ${path3}: ${err instanceof Error ? err.message : String(err)}`
+  } catch (err2) {
+    throw new CompanionError(
+      `couldn't read ${path3}: ${err2 instanceof Error ? err2.message : String(err2)}`
     );
   }
   return renderTranscript(content.split("\n"));
@@ -9741,19 +10838,19 @@ function renderTranscript(jsonlLines) {
     if (!raw.trim()) continue;
     const obj = rec(safeParse(raw));
     if (!obj) continue;
-    switch (str3(obj.type)) {
+    switch (str4(obj.type)) {
       case "_meta":
         out.push(
-          `${fmtTime(obj.ts)}  \xB7  workspace=${str3(obj.workspaceSlug)}  \xB7  conversation=${str3(obj.conversationId)}`
+          `${fmtTime(obj.ts)}  \xB7  workspace=${str4(obj.workspaceSlug)}  \xB7  conversation=${str4(obj.conversationId)}`
         );
-        out.push("", `> USER: ${str3(obj.message)}`, "");
+        out.push("", `> USER: ${str4(obj.message)}`, "");
         break;
       case "system":
-        if (str3(obj.subtype) === "init") {
-          out.push(`[session ${str3(obj.session_id) || "?"} \xB7 model ${str3(obj.model) || "?"}]`);
+        if (str4(obj.subtype) === "init") {
+          out.push(`[session ${str4(obj.session_id) || "?"} \xB7 model ${str4(obj.model) || "?"}]`);
           const servers = Array.isArray(obj.mcp_servers) ? obj.mcp_servers.map((s) => {
             const r = rec(s);
-            return r ? `${str3(r.name) || "?"}${str3(r.status) ? `(${str3(r.status)})` : ""}` : "";
+            return r ? `${str4(r.name) || "?"}${str4(r.status) ? `(${str4(r.status)})` : ""}` : "";
           }).filter(Boolean).join(", ") : "";
           if (servers) out.push(`  MCP servers: ${servers}`);
           if (Array.isArray(obj.tools)) out.push(`  tools: ${obj.tools.length} available`);
@@ -9779,8 +10876,8 @@ function renderTranscript(jsonlLines) {
         if (!Array.isArray(content)) break;
         for (const b of content) {
           const block = rec(b);
-          if (!block || str3(block.type) !== "tool_result") continue;
-          const id = str3(block.tool_use_id);
+          if (!block || str4(block.type) !== "tool_result") continue;
+          const id = str4(block.tool_use_id);
           const label = pending.get(id) ?? "tool";
           pending.delete(id);
           const tag = block.is_error === true ? "ERROR" : "ok";
@@ -9789,18 +10886,18 @@ function renderTranscript(jsonlLines) {
         break;
       }
       case "result": {
-        const isErr = obj.is_error === true || str3(obj.subtype) !== "success";
+        const isErr = obj.is_error === true || str4(obj.subtype) !== "success";
         const dur = typeof obj.duration_ms === "number" ? ` \xB7 ${obj.duration_ms}ms` : "";
         out.push(
-          `[result ${isErr ? "error" : "ok"}${str3(obj.subtype) ? ` \xB7 ${str3(obj.subtype)}` : ""}${dur}]`
+          `[result ${isErr ? "error" : "ok"}${str4(obj.subtype) ? ` \xB7 ${str4(obj.subtype)}` : ""}${dur}]`
         );
-        if (isErr && str3(obj.result).trim()) out.push(`  ${indent(str3(obj.result))}`);
+        if (isErr && str4(obj.result).trim()) out.push(`  ${indent(str4(obj.result))}`);
         break;
       }
       case "_outcome": {
         const dur = typeof obj.durationMs === "number" ? ` \xB7 ${obj.durationMs}ms` : "";
         out.push(
-          `[outcome ${obj.ok === true ? "ok" : "error"}${str3(obj.reason) ? ` \xB7 ${str3(obj.reason)}` : ""}${dur}]`
+          `[outcome ${obj.ok === true ? "ok" : "error"}${str4(obj.reason) ? ` \xB7 ${str4(obj.reason)}` : ""}${dur}]`
         );
         break;
       }
@@ -9818,7 +10915,7 @@ function safeParse(s) {
 function rec(v) {
   return v && typeof v === "object" ? v : null;
 }
-function str3(v) {
+function str4(v) {
   return typeof v === "string" ? v : "";
 }
 function fmtTime(ts) {
@@ -9854,7 +10951,7 @@ They are written per dispatch while \`cabane-companion start\` is running.
 var program = new Command();
 program.name("cabane-companion").description(
   "Connect a coding agent on your machine to your Cabane workspace as a responder \u2014 reply to Cabane messages while staying a full local AI client (Claude Code or OpenCode)."
-).version(BRIDGE_VERSION);
+).version(COMPANION_VERSION);
 program.command("pair").description(
   "pair this device with cabane \u2014 shows a short code you confirm in Settings \u2192 Devices."
 ).argument(
@@ -9887,10 +10984,10 @@ program.command("start").description("pull this device\u2019s assigned agents fr
     ...opts.port !== void 0 ? { port: opts.port } : {}
   });
 });
-program.command("stop").description("stop a running bridge (SIGTERM, then force-kill after a timeout).").action(async () => {
+program.command("stop").description("stop a running companion (SIGTERM, then force-kill after a timeout).").action(async () => {
   await stop();
 });
-program.command("status").description("print the bridge's local state (pairing, secrets, log path).").action(async () => {
+program.command("status").description("print the companion's local state (pairing, secrets, log path).").action(async () => {
   await status();
 });
 program.command("transcript").description("show the full agent transcript for a recent dispatch (the agent's whole turn).").argument("[file]", "a transcript filename or substring; omit to list recent transcripts").option("--last", "render the most recent transcript").option("-f, --follow", "watch for new turns and live-render them as they land (Ctrl-C to stop)").action(async (file, opts) => {
@@ -9914,23 +11011,23 @@ program.command("logout").description(
 function parsePort(raw) {
   const n = Number(raw);
   if (!Number.isInteger(n) || n < 1 || n > 65535) {
-    throw new BridgeError(`invalid --port "${raw}": expected an integer between 1 and 65535.`);
+    throw new CompanionError(`invalid --port "${raw}": expected an integer between 1 and 65535.`);
   }
   return n;
 }
-program.parseAsync(process.argv).catch((err) => {
-  if (err instanceof BridgeError) {
-    process.stderr.write(`error: ${err.message}
+program.parseAsync(process.argv).catch((err2) => {
+  if (err2 instanceof CompanionError) {
+    process.stderr.write(`error: ${err2.message}
 `);
     process.exitCode = 1;
     return;
   }
-  if (err && typeof err === "object" && "name" in err && err.name === "ExitPromptError") {
+  if (err2 && typeof err2 === "object" && "name" in err2 && err2.name === "ExitPromptError") {
     process.stderr.write("cancelled\n");
     process.exitCode = 130;
     return;
   }
-  process.stderr.write(`${err instanceof Error ? err.stack ?? err.message : String(err)}
+  process.stderr.write(`${err2 instanceof Error ? err2.stack ?? err2.message : String(err2)}
 `);
   process.exitCode = 1;
 });