@cabane/companion 0.6.203 → 0.6.204

package/dist/cli.js

@@ -321,25 +321,7 @@ var init_prepare_hook = __esm({
       // Wall-clock cap for the hook. Provisioning is slow (minutes), so the
       // default is generous; a hook that hangs past this is killed and the turn
       // fails with a clear timeout message rather than pinning the companion.
-      timeoutMs: z.number().int().positive().optional(),
-      // Re-invoke the hook when a prepared result already exists, in VALIDATE
-      // mode: the cached result is handed back as `prepared` and stdout is
-      // ignored, so the cwd cannot move. Its only power is to exit non-zero and
-      // fail the turn. The hook resolves once per (conversation, agent), so a
-      // later message asking for a different environment is otherwise silently
-      // ignored; this lets a hook refuse it out loud.
-      //
-      // Default OFF: a hook that provisions unconditionally must not start
-      // running on every turn because the companion upgraded.
-      validateCached: z.boolean().optional(),
-      // Independent operator-owned reporter. Receives sanitized failure metadata
-      // on stdin; never re-enters this hook and cannot change the turn outcome.
-      failureReporter: z.object({
-        command: z.string().min(1),
-        args: z.array(z.string()).optional(),
-        env: z.record(z.string(), z.string()).optional(),
-        timeoutMs: z.number().int().positive().max(3e4).optional()
-      }).strict().optional()
+      timeoutMs: z.number().int().positive().optional()
     }).strict();
     DEFAULT_TIMEOUT_MS = 10 * 6e4;
     prepareResultSchema = z.object({
@@ -369,15 +351,7 @@ var init_prepare_hook = __esm({
               CABANE_AGENT_USERNAME: input.agentUsername,
               CABANE_DEFAULT_CWD: input.defaultCwd,
               CABANE_RUNTIME: input.runtime ?? "",
-              // Newline-joined — workspace paths never contain a newline, so a
-              // hook splits on `\n` unambiguously. Empty string when none.
-              CABANE_TRIGGER_ENTRY_PATHS: input.triggerEntryPaths.join("\n"),
-              CABANE_CONVERSATION_TITLE: input.title ?? "",
-              // The dispatching message's text, and — in validate mode only —
-              // the prepared result the hook is being asked to check this dispatch
-              // against. Both empty/absent on an ordinary first run.
-              CABANE_TRIGGER_MESSAGE: input.messageBody ?? "",
-              ...input.prepared ? { CABANE_PREPARED: JSON.stringify(input.prepared) } : {}
+              CABANE_CONVERSATION_TITLE: input.title ?? ""
             }
           });
         } catch (err) {
@@ -415,10 +389,6 @@ var init_prepare_hook = __esm({
               );
               return;
             }
-            if (input.prepared) {
-              resolve2(input.prepared);
-              return;
-            }
             try {
               resolve2(parsePrepareOutput(stdout));
             } catch (err) {
@@ -487,33 +457,36 @@ function workRoot(cfg) {
   if (root.startsWith("~/")) return join4(homedir5(), root.slice(2));
   return root;
 }
-function retiredConfigKeys(raw) {
-  if (!raw || typeof raw !== "object") return [];
-  const obj = raw;
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function splitRetired(raw) {
   const keys = [];
-  if ("runners" in obj) keys.push("runners");
-  const agents = obj.agents;
-  if (agents && typeof agents === "object") {
-    for (const [key, row3] of Object.entries(agents)) {
-      if (row3 && typeof row3 === "object" && "sandbox" in row3) keys.push(`agents.${key}.sandbox`);
+  const without = (obj, names, path) => {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      if (names.includes(k)) keys.push(`${path}${k}`);
+      else out[k] = v;
+    }
+    return out;
+  };
+  const hook = (row3, path) => isObject(row3.prepareHook) ? { ...row3, prepareHook: without(row3.prepareHook, RETIRED_HOOK_KEYS, `${path}prepareHook.`) } : row3;
+  const kept = hook(without(raw, ["runners"], ""), "");
+  if (isObject(kept.agents)) {
+    const agents = {};
+    for (const [key, row3] of Object.entries(kept.agents)) {
+      const path = `agents.${key}.`;
+      agents[key] = isObject(row3) ? hook(without(row3, RETIRED_ROW_KEYS, path), path) : row3;
     }
+    kept.agents = agents;
   }
-  return keys;
+  return { keys, kept };
+}
+function retiredConfigKeys(raw) {
+  return isObject(raw) ? splitRetired(raw).keys : [];
 }
 function withoutRetiredKeys(raw) {
-  if (retiredConfigKeys(raw).length === 0) return raw;
-  const { runners: _runners, ...rest } = raw;
-  if (!rest.agents || typeof rest.agents !== "object") return rest;
-  const agents = {};
-  for (const [key, row3] of Object.entries(rest.agents)) {
-    if (row3 && typeof row3 === "object" && "sandbox" in row3) {
-      const { sandbox: _sandbox, ...kept } = row3;
-      agents[key] = kept;
-    } else {
-      agents[key] = row3;
-    }
-  }
-  return { ...rest, agents };
+  return isObject(raw) ? splitRetired(raw).kept : raw;
 }
 function retiredConfigKeysOnDisk() {
   try {
@@ -708,7 +681,7 @@ function deleteConfig() {
     writeFileSync(path, "", { mode: 384 });
   }
 }
-var HARNESS_RUNTIMES, realHomeCache, localAgentConfigSchema, agentsConfigSchema, companionConfigSchema, legacyOfferSchema;
+var HARNESS_RUNTIMES, realHomeCache, localAgentConfigSchema, agentsConfigSchema, companionConfigSchema, RETIRED_ROW_KEYS, RETIRED_HOOK_KEYS, legacyOfferSchema;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
@@ -753,8 +726,7 @@ var init_config = __esm({
       // The DEVICE-LEVEL prepare hook, for every agent assigned here unless its own
       // `agents` row names one. Per-agent hooks alone make the config a second
       // silent roster: an agent nobody listed gets no hook and no error, and starts
-      // in the operator's `$HOME` (an agent woke in `/home/joshed` this way on
-      // 2026-08-17).
+      // in the operator's `$HOME`.
       prepareHook: prepareHookSchema.optional(),
       // `dashboardPort` and `autoOpen` are IGNORED by the CLI (no port, no browser)
       // but stay in the schema so an existing file still parses; the Electron shell
@@ -791,13 +763,16 @@ var init_config = __esm({
       root: z2.string().min(1).refine(isRootPath, { message: "must be an absolute path, or start with ~/" }).optional(),
       // An argv prefix the operator puts in front of every turn's runner: the companion starts
       // `<prefix…> <its own run-turn command…>` instead of the runner bare. What the prefix does
-      // is the operator's (a box of their own making, ENG225); the companion knows nothing of it
+      // is the operator's (a container or VM per turn, say); the companion knows nothing of it
       // beyond handing the runner over, with the turn's inputs in its environment and the
-      // credential and secrets on its stdin (`runner/launch.ts`, `boxed`).
+      // credential and secrets on its stdin (`runner/launch.ts`, `wrapped`). The README lists
+      // what a wrapper can rely on.
       runner: z2.object({
         command: z2.array(z2.string().min(1)).min(1)
       }).strict().optional()
     });
+    RETIRED_ROW_KEYS = ["sandbox"];
+    RETIRED_HOOK_KEYS = ["validateCached", "failureReporter"];
     legacyOfferSchema = z2.object({
       claudeCode: z2.object({ enabled: z2.boolean().optional() }).passthrough().optional(),
       codex: z2.object({ enabled: z2.boolean().optional() }).passthrough().optional(),
@@ -6255,7 +6230,7 @@ function createCodexAdapter(deps = {}) {
         if (signal.aborted) return;
         if (compactions === null) {
           deps.onWarn?.(
-            "codex adapter: the thread's compaction count could not be read \u2014 re-sending the standing instructions (ENG210)",
+            "codex adapter: the thread's compaction count could not be read \u2014 re-sending the standing instructions",
             { threadId: decision.resume }
           );
         } else if (decision.compactions === compactions) {
@@ -6265,7 +6240,7 @@ function createCodexAdapter(deps = {}) {
           };
         } else if (decision.compactions !== null && compactions > decision.compactions) {
           deps.onWarn?.(
-            "codex adapter: the thread compacted since the last turn \u2014 re-sending the standing instructions (ENG210)",
+            "codex adapter: the thread compacted since the last turn \u2014 re-sending the standing instructions",
             {
               threadId: decision.resume,
               compactions,
@@ -7866,11 +7841,10 @@ function required(env, name) {
 function runnerPlace(env) {
   const workRoot2 = env[PLACE_ENV.workRoot];
   const transcriptDir = env[PLACE_ENV.transcriptDir];
-  const box = env[PLACE_ENV.box];
   return {
     ...workRoot2 ? { workRoot: workRoot2 } : {},
     ...transcriptDir ? { transcriptDir } : {},
-    ...box ? { box } : {}
+    ...env[PLACE_ENV.dedicatedRoot] === "1" ? { dedicatedRoot: true } : {}
   };
 }
 function parseRunnerInput(env, stdin) {
@@ -7955,7 +7929,7 @@ var init_protocol = __esm({
     PLACE_ENV = {
       workRoot: "CABANE_WORK_ROOT",
       transcriptDir: "CABANE_TRANSCRIPT_DIR",
-      box: "CABANE_BOX"
+      dedicatedRoot: "CABANE_WORK_ROOT_DEDICATED"
     };
     runtimeHealthSchema = z14.object({
       quotaState: z14.enum(["ok", "limited", "auth_expired", "unknown"]),
@@ -8013,1258 +7987,780 @@ var init_protocol = __esm({
   }
 });
 
-// src/runner/launch.ts
-import { createInterface } from "readline";
-function selfRunnerCommand() {
-  const script = process.argv[1];
-  if (!script) throw new Error("runner: cannot tell which script started this companion");
-  return [process.execPath, ...process.execArgv, script, "run-turn"];
+// src/grants.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { join as join14 } from "path";
+import { z as z15 } from "zod";
+function allowedGrantVariable(name) {
+  return name.length <= 100 && VARIABLE_NAME_RE.test(name) && !name.startsWith("CABANE_");
 }
-function wrappedRunnerCommand(prefix, own) {
-  return [...prefix ?? [], ...own];
+function environmentSafe(value) {
+  return !value.includes("\0");
 }
-function runnerExecEnv(base, boxed) {
-  const env = {};
-  for (const [k, v] of Object.entries(base)) {
-    if (v === void 0) continue;
-    if (boxed && BOXED_ENV_DROPPED.includes(k)) continue;
-    env[k] = v;
-  }
-  return env;
+function grantsPath() {
+  return join14(cabaneDir(), "grants.json");
 }
-function healthSnapshot(store) {
+function readGrants(keys, report) {
+  if (keys.length === 0) return {};
+  const file = loadGrantsFile(report);
   const out = {};
-  for (const r of store?.reports() ?? []) {
-    out[r.runtime] = {
-      quotaState: r.quotaState ?? "unknown",
-      limitedUntil: r.limitedUntil ?? null,
-      lastError: r.lastError ?? null
-    };
+  for (const key of keys) {
+    if (!allowedGrantVariable(key) || !Object.hasOwn(file, key)) continue;
+    const entry = {};
+    for (const [variable, value] of Object.entries(file[key])) {
+      if (allowedGrantVariable(variable) && environmentSafe(value)) entry[variable] = value;
+      else report.refusedVariable(key, variable);
+    }
+    out[key] = entry;
   }
   return out;
 }
-function runnerSpec(opts, launch, duties, runnerId) {
-  return {
-    runnerId,
-    ...opts.deviceId ? { deviceId: opts.deviceId } : {},
-    bootId,
-    workspaceId: opts.workspaceId,
-    workspaceSlug: opts.workspaceSlug,
-    agentId: opts.agentId,
-    agentUsername: opts.agentUsername,
-    agentName: String(opts.log.bindings().agentName ?? opts.agentUsername),
-    local: opts.local,
-    runConfig: opts.runConfig,
-    workRoot: opts.workRoot,
-    ...opts.opencodeServerUrl ? { opencodeServerUrl: opts.opencodeServerUrl } : {},
-    // Read now, per turn, the way adapter selection reads them.
-    claudeCodeAvailable: opts.claudeCodeAvailable?.() ?? true,
-    codexAvailable: opts.codexAvailable?.() ?? false,
-    ...opts.idleTimeoutMs !== void 0 ? { idleTimeoutMs: opts.idleTimeoutMs } : {},
-    ...opts.totalTimeoutMs !== void 0 ? { totalTimeoutMs: opts.totalTimeoutMs } : {},
-    ...opts.leaseRenewalMs !== void 0 ? { leaseRenewalMs: opts.leaseRenewalMs } : {},
-    ...opts.preparingRowDelayMs !== void 0 ? { preparingRowDelayMs: opts.preparingRowDelayMs } : {},
-    transcripts: opts.transcriptDir !== void 0,
-    logLevel: opts.log.level,
-    connectorHealth: healthSnapshot(launch.connectorHealth),
-    sessionWriteNoticeClaimed: duties.sessionWriteNoticeClaimed()
-  };
-}
-function relayRunnerLog(line, log2) {
-  if (!line.trim()) return;
-  let record = null;
+function loadGrantsFile(report) {
+  const path = grantsPath();
+  if (!existsSync9(path)) return {};
+  let raw;
   try {
-    const parsed = JSON.parse(line);
-    if (parsed && typeof parsed === "object") record = parsed;
+    raw = readFileSync7(path, "utf8");
+  } catch (err) {
+    const code = err.code ?? "unknown error";
+    report.unreadable(`couldn't read ${path}: ${code}`);
+    return {};
+  }
+  if (raw.trim().length === 0) return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
   } catch {
-    record = null;
+    report.unreadable(`${path} is not valid JSON.`);
+    return {};
   }
-  if (!record || typeof record.level !== "number") {
-    log2.debug({ runnerStderr: line }, "runner: output");
-    return;
+  const result = grantsFileSchema.safeParse(parsed);
+  if (!result.success) {
+    report.unreadable(
+      `${path} must map a secret's variable name to an object of "VARIABLE": "value" pairs (e.g. { "HAS_STAGING_DB": { "DATABASE_URL": "postgres://\u2026" } }).`
+    );
+    return {};
   }
-  const {
-    level,
-    msg,
-    time: _time,
-    pid: _pid,
-    hostname: _hostname,
-    agentName: _agentName,
-    ...fields
-  } = record;
-  const method = PINO_LEVELS[level] ?? "info";
-  log2[method](fields, typeof msg === "string" ? msg : "");
+  return result.data;
 }
-function lines(stream, onLine) {
-  const rl = createInterface({ input: stream, crlfDelay: Infinity });
-  rl.on("line", onLine);
-  return new Promise((resolve2) => rl.once("close", resolve2));
+function harnessSecretEnv(parts) {
+  const env = {};
+  const dropped = [];
+  for (const [name, value] of Object.entries({
+    ...parts.deviceDefaults,
+    ...parts.granted,
+    ...parts.issued
+  })) {
+    if (environmentSafe(value)) env[name] = value;
+    else dropped.push(name);
+  }
+  return { env, dropped };
 }
-function giveBackLocks(locks, prefix, remote, launch, log2) {
-  locks.withdraw(prefix);
-  const stop2 = launch.stopRemoteSession ?? ((url, id) => stopRemoteOpencodeSession(url, id));
-  for (const { key, owner } of locks.heldBy(prefix)) {
-    const left = remote.filter((r) => opencodeLockKey(r.serverUrl) === key);
-    if (!left.length) {
-      locks.release(owner);
-      continue;
+function grantEnv(sent, issuedBySecret, issued) {
+  const env = {};
+  for (const [key, entry] of Object.entries(sent ?? {})) {
+    if (!Object.hasOwn(issuedBySecret, key)) continue;
+    for (const [variable, value] of Object.entries(entry)) {
+      if (Object.hasOwn(issued, variable) || Object.hasOwn(env, variable)) continue;
+      env[variable] = value;
     }
-    void (async () => {
-      for (let attempt = 1; ; attempt++) {
-        const stopped = await Promise.all(left.map((r) => stop2(r.serverUrl, r.sessionId))).catch(
-          () => [false]
-        );
-        if (stopped.every(Boolean)) break;
-        if (attempt === 1)
-          log2.warn(
-            { key, sessions: left.map((r) => r.sessionId) },
-            "runner: a dead runner left work on a shared server that could not be confirmed stopped; holding the server until it is"
-          );
-        await new Promise((resolve2) => setTimeout(resolve2, launch.reconcileRetryMs ?? 5e3));
-      }
-      locks.release(owner);
-    })();
   }
+  return env;
 }
-async function mintForRunner(opts, payload, handleOpts, signal, log2) {
-  try {
-    const minted = await opts.api.mintRunnerCredential({
-      conversationId: payload.conversationId,
-      messageId: payload.messageId,
-      ...payload.episode !== void 0 ? { episode: payload.episode } : {},
-      // The one turn the credential will operate: this run's.
-      turnId: handleOpts.turnId
-    });
-    return {
-      ok: true,
-      credential: minted.credential,
-      runnerId: minted.runnerId,
-      deviceGrants: minted.deviceGrants ?? []
-    };
-  } catch (err) {
-    if (signal.aborted) return { ok: false, reason: "cancelled" };
-    const status2 = err instanceof ApiError ? err.status : 0;
-    if (status2 === 404) return { ok: false, reason: "runner_credential_not_found" };
-    if (status2 === 409 && apiErrorCode(err) === "dispatch_not_admitted")
-      return { ok: false, reason: "runner_credential_not_admitted" };
-    log2.warn(apiErrorLogFields(err), "runner: couldn't get a credential for the turn's runner");
-    const reason = `fetch_failed: ${describeError(err)}`;
-    return { ok: false, reason, errorReason: reason };
+var VARIABLE_NAME_RE, grantsFileSchema;
+var init_grants = __esm({
+  "src/grants.ts"() {
+    "use strict";
+    init_config();
+    VARIABLE_NAME_RE = /^[A-Z_][A-Z0-9_]*$/;
+    grantsFileSchema = z15.record(z15.string(), z15.record(z15.string(), z15.string()));
+  }
+});
+
+// src/work-dir.ts
+import { statSync as statSync3 } from "fs";
+import { join as join15 } from "path";
+function pairDirectory(root, pair) {
+  return join15(root, pair.workspaceSlug, pair.agentUsername, pair.conversationId);
+}
+function chooseStandingDirectory(named, pairDir, isDirectory = directoryExists) {
+  const skipped = [];
+  for (const candidate of named) {
+    if (isDirectory(candidate.path)) return { cwd: candidate.path, skipped };
+    skipped.push(candidate);
   }
+  return { cwd: pairDir, skipped };
 }
-async function settleUnstarted(opts, payload, turnId, errorReason, log2) {
+function directoryExists(path) {
   try {
-    await opts.api.setActiveRun(opts.workspaceId, payload.conversationId, payload.agentId, {
-      activeRunStartedAt: null,
-      turnId,
-      outcome: "failed",
-      ...errorReason ? { errorReason: errorReason.slice(0, ERROR_REASON_MAX) } : {},
-      readThrough: payload.messageId
-    });
-  } catch (err) {
-    log2.warn(
-      { ...apiErrorLogFields(err), turnId },
-      "Couldn't update the turn's status in Cabane. Check the conversation before trying again."
-    );
+    return statSync3(path).isDirectory();
+  } catch {
+    return false;
   }
 }
-async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
-  const startedAt = Date.now();
-  const { turnId } = handleOpts;
-  const oomKilled = (id) => (launch.oomKilled ?? turnScopeOomKilled)(id).catch(() => false);
-  const log2 = opts.log.child({
-    workspaceId: opts.workspaceId,
-    conversationId: payload.conversationId,
-    agentId: payload.agentId,
-    messageId: payload.messageId
-  });
-  const controller = new AbortController();
-  duties.registerAbort(turnId, controller);
-  const stopRunner = new AbortController();
-  let ready = false;
-  let child;
-  let stopAnnounced = false;
-  const announceStop = () => {
-    if (stopAnnounced || !child?.stdin.writable) return;
-    stopAnnounced = true;
-    child.stdin.write(encodeLauncherMessage({ cabaneLauncher: "stop" }));
-  };
-  const forwardStop = () => {
-    announceStop();
-    if (ready) stopRunner.abort();
-  };
-  controller.signal.addEventListener("abort", forwardStop, { once: true });
-  const attempt = {
-    workspaceId: opts.workspaceId,
-    conversationId: payload.conversationId,
-    agentId: payload.agentId,
-    turnId
-  };
-  const minted = await mintForRunner(opts, payload, handleOpts, controller.signal, log2);
-  if (!minted.ok) {
-    controller.signal.removeEventListener("abort", forwardStop);
-    duties.releaseAbort(turnId, controller);
-    const durationMs2 = Date.now() - startedAt;
-    await settleUnstarted(opts, payload, turnId, minted.errorReason, log2);
-    duties.notifyEnd({ id: payload.messageId, ok: false, durationMs: durationMs2, reason: minted.reason });
-    return { ok: false, durationMs: durationMs2, reason: minted.reason };
+var init_work_dir = __esm({
+  "src/work-dir.ts"() {
+    "use strict";
   }
+});
+
+// src/turn-control-tools.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { z as z16 } from "zod";
+function createSkipState() {
+  return { skipped: false, reason: null };
+}
+function toolError(text) {
+  return { isError: true, content: [{ type: "text", text }] };
+}
+async function performAct(acts, act) {
   let result;
-  let thrown;
-  let code;
-  let handle;
-  const groups = [];
-  const remote = [];
-  const lockOwner = (id) => `${turnId}#${id}`;
-  const locks = launch.locks;
-  try {
-    handle = await launch.provider.acquire(attempt);
-  } catch (err) {
-    const reason2 = `runner_unavailable: ${describeError(err)}`;
-    log2.warn(
-      { turnId, provider: launch.provider.name, err: describeError(err) },
-      "runner: no place to run the turn"
-    );
-    controller.signal.removeEventListener("abort", forwardStop);
-    duties.releaseAbort(turnId, controller);
-    await settleUnstarted(opts, payload, turnId, reason2, log2);
-    await launch.reportRunnerGone?.({
-      workspaceId: opts.workspaceId,
-      conversationId: payload.conversationId,
-      agentId: payload.agentId,
-      messageId: payload.messageId,
-      runnerId: minted.runnerId,
-      reason: "provider_failed"
-    });
-    const durationMs2 = Date.now() - startedAt;
-    duties.notifyEnd({ id: payload.messageId, ok: false, durationMs: durationMs2, reason: reason2 });
-    return { ok: false, durationMs: durationMs2, reason: reason2 };
-  }
   try {
-    const boxed = launch.boxed === true;
-    const env = runnerExecEnv(launch.env ?? process.env, boxed);
-    const grants = minted.deviceGrants.length > 0 ? launch.grants?.(minted.deviceGrants) ?? {} : {};
-    const input = {
-      baseUrl: opts.baseUrl,
-      credential: minted.credential,
-      ...boxed ? { secrets: launch.secrets?.() ?? {} } : {},
-      ...Object.keys(grants).length > 0 ? { grants } : {},
-      dispatch: payload,
-      turnId,
-      resumed: handleOpts.resumed,
-      spec: runnerSpec(opts, launch, duties, minted.runnerId)
-    };
-    Object.assign(env, runnerEnv(input));
-    const running = launch.provider.exec(handle, launch.command, env, {
-      signal: stopRunner.signal,
-      stdin: runnerStdin(input)
-    });
-    child = running;
-    if (controller.signal.aborted) announceStop();
-    log2.debug(
-      { turnId, runnerPid: running.pid, provider: launch.provider.name },
-      "runner: started"
+    result = await acts.api.turnAct(
+      acts.workspaceId,
+      acts.turnId,
+      act,
+      AbortSignal.timeout(TURN_ACT_TIMEOUT_MS)
     );
-    const stdoutDone = lines(running.stdout, (line) => {
-      const event = decodeRunnerEvent(line);
-      if (!event) {
-        log2.debug({ runnerStdout: line }, "runner: output");
-        return;
+  } catch (err) {
+    if (err instanceof ApiError && err.status >= 500) {
+      return uncertainOutcome(`${err.status}: ${apiErrorMessage(err)}`);
+    }
+    if (err instanceof ApiError) {
+      if (err.status === 409 && apiErrorCode(err) === "no_active_turn") {
+        return toolError(
+          "No active turn: this turn has already settled, so the act was not performed."
+        );
       }
-      switch (event.cabaneRunner) {
-        case "ready":
-          ready = true;
-          if (controller.signal.aborted) stopRunner.abort();
-          return;
-        case "start":
-          duties.notifyStart({
-            id: event.id,
-            conversationId: event.conversationId,
-            message: event.message
-          });
-          return;
-        case "end": {
-          const { cabaneRunner: _kind, ...info } = event;
-          duties.notifyEnd(info);
-          return;
-        }
-        case "session_write_notice":
-          duties.markSessionWriteNotice();
-          return;
-        case "connector_health":
-          launch.connectorHealth?.recordSettle(event.runtime, {
-            ok: event.ok,
-            errorReason: event.errorReason
-          });
-          return;
-        case "result":
-          result = event.result;
-          return;
-        case "error":
-          thrown = event.message;
-          return;
-        case "lock":
-          if (!locks) {
-            log2.warn(
-              { key: event.key },
-              "runner: asked for a device lock this launcher has none of"
+      return toolError(`The act was refused (${err.status}): ${apiErrorMessage(err)}`);
+    }
+    return uncertainOutcome(err instanceof Error ? err.message : String(err));
+  }
+  if (!result.ok) return toolError(JSON.stringify(result));
+  return { content: [{ type: "text", text: JSON.stringify(result) }] };
+}
+function uncertainOutcome(cause) {
+  return toolError(
+    `The outcome of this act could not be confirmed (${cause}). It may already have been performed, with only the response lost. Do NOT simply repeat the call: a repeat is a second, separate act, not a retry. Carry on, and say in your reply that you could not confirm it.`
+  );
+}
+function createTurnControlMcpServer(acts, skipState) {
+  const ACT_TOOL = { readOnlyHint: false, destructiveHint: false, openWorldHint: false };
+  const CANCEL_TOOL = { ...ACT_TOOL, idempotentHint: true };
+  const RECORDER_TOOL = { readOnlyHint: true, openWorldHint: false };
+  return createSdkMcpServer({
+    name: COMPANION_LOCAL_MCP_SERVER,
+    version: "0.0.0",
+    tools: [
+      ...skipState ? [
+        tool(
+          SKIP_TURN_TOOL,
+          TURN_CONTROL_TOOL_DESCRIPTIONS.skip_turn,
+          {
+            reason: z16.string().min(1).max(MAX_SKIP_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.skip_turn.reason)
+          },
+          async (args) => {
+            skipState.skipped = true;
+            skipState.reason = args.reason;
+            return {
+              content: [{ type: "text", text: JSON.stringify({ skipped: true }) }]
+            };
+          },
+          { annotations: RECORDER_TOOL, alwaysLoad: true }
+        )
+      ] : [],
+      tool(
+        ASK_TOOL,
+        TURN_CONTROL_TOOL_DESCRIPTIONS.ask,
+        {
+          targetUserId: z16.string().regex(ASK_TARGET_PATTERN, { error: ASK_TARGET_INVALID }).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.targetUserId),
+          question: z16.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.question),
+          headline: z16.string().min(1).max(MAX_ASK_HEADLINE_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.headline),
+          options: z16.array(z16.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)).min(MIN_ASK_OPTIONS).max(MAX_ASK_OPTIONS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.options),
+          questions: z16.array(
+            z16.object({
+              headline: z16.string().min(1).max(MAX_ASK_HEADLINE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.headline"]),
+              body: z16.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.body"]),
+              options: z16.array(
+                z16.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)
+              ).min(MIN_ASK_OPTIONS).max(MAX_ASK_OPTIONS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.options"])
+            })
+          ).min(1).max(MAX_ASK_ITEMS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.questions),
+          replaces: z16.object({
+            askId: z16.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.askId"]),
+            reason: z16.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.reason"])
+          }).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.replaces)
+        },
+        async (args) => {
+          const hasSingle = args.question !== void 0;
+          const hasArray = args.questions !== void 0 && args.questions.length > 0;
+          if (hasSingle && hasArray) {
+            return toolError(
+              "Provide either `question` (single) or `questions` (array), not both."
             );
-            return;
           }
-          locks.request(
-            event.key,
-            lockOwner(event.id),
-            () => running.stdin.write(encodeLauncherMessage({ cabaneLauncher: "granted", id: event.id }))
-          );
-          return;
-        case "unlock":
-          locks?.release(lockOwner(event.id));
-          return;
-        case "process_group":
-          if (!boxed) groups.push(event.pgid);
-          return;
-        case "remote_session":
-          remote.push({ serverUrl: event.serverUrl, sessionId: event.sessionId });
-          return;
-        case "terminated":
-          void oomKilled(turnId).then((oom) => {
-            if (running.stdin.writable) {
-              running.stdin.write(
-                encodeLauncherMessage({
-                  cabaneLauncher: "cause",
-                  cause: oom ? "out_of_memory" : null
-                })
-              );
+          if (!hasSingle && !hasArray) {
+            return toolError("Provide `question` (single) or `questions` (array).");
+          }
+          return performAct(acts, {
+            kind: "ask",
+            callId: randomUUID2(),
+            // The swap rides the ask, so the server commits both halves
+            // in one transaction — the person never sees neither or both.
+            ...args.replaces ? { replaces: args.replaces } : {},
+            ask: hasArray ? {
+              targetUserId: args.targetUserId,
+              questions: args.questions.map((q) => ({
+                headline: q.headline,
+                ...q.body ? { body: q.body } : {},
+                ...q.options && q.options.length > 0 ? { options: q.options } : {}
+              }))
+            } : {
+              targetUserId: args.targetUserId,
+              question: args.question,
+              ...args.headline ? { headline: args.headline } : {},
+              ...args.options && args.options.length > 0 ? { options: args.options } : {}
             }
           });
-          return;
-      }
-    });
-    const stderrDone = lines(running.stderr, (line) => relayRunnerLog(line, opts.log));
-    code = await running.exit;
-    await Promise.all([stdoutDone, stderrDone]);
-  } finally {
-    if (locks) giveBackLocks(locks, `${turnId}#`, remote, launch, log2);
-    child?.stdin.end();
-    controller.signal.removeEventListener("abort", forwardStop);
-    duties.releaseAbort(turnId, controller);
-    await launch.provider.release(handle, { destroy: false }).catch(
-      (err) => log2.warn({ err: describeError(err) }, "runner: couldn't give its place back")
-    );
-  }
-  if (result) return result;
-  const durationMs = Date.now() - startedAt;
-  const stopped = controller.signal.aborted && thrown === void 0;
-  const reason = stopped ? "cancelled" : thrown !== void 0 ? `runner_failed: ${thrown}` : await oomKilled(turnId) ? "out_of_memory" : `runner_exited: ${code}`;
-  await child?.reap(groups);
-  const reaped = await (launch.reapTurn ?? reapTurnScopes)(turnId).catch((err) => ({
-    failures: [err instanceof Error ? err.message : String(err)]
-  }));
-  if (reaped.failures.length) {
-    log2.warn(
-      { turnId, failures: reaped.failures },
-      "runner: couldn't stop what the dead runner's turn left running"
-    );
-  }
-  try {
-    await opts.api.setActiveRun(opts.workspaceId, payload.conversationId, payload.agentId, {
-      activeRunStartedAt: null,
-      turnId,
-      ...stopped ? { outcome: "interrupted" } : { outcome: "failed", errorReason: reason.slice(0, ERROR_REASON_MAX) },
-      readThrough: payload.messageId
-    });
-  } catch (err) {
-    log2.warn(
-      { ...apiErrorLogFields(err), turnId },
-      "Couldn't update the turn's status in Cabane. Check the conversation before trying again."
-    );
-  }
-  await launch.reportRunnerGone?.({
-    workspaceId: opts.workspaceId,
-    conversationId: payload.conversationId,
-    agentId: payload.agentId,
-    messageId: payload.messageId,
-    runnerId: minted.runnerId,
-    reason: "exited"
+        },
+        { annotations: ACT_TOOL, alwaysLoad: true }
+      ),
+      tool(
+        WAKE_ME_TOOL,
+        TURN_CONTROL_TOOL_DESCRIPTIONS.wake_me,
+        {
+          afterSeconds: z16.number().int().positive().optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.afterSeconds),
+          at: z16.string().datetime({ offset: true }).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.at),
+          note: z16.string().min(1).max(MAX_WAKE_NOTE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.note)
+        },
+        async (args) => {
+          const hasAfter = args.afterSeconds !== void 0;
+          const hasAt = args.at !== void 0;
+          if (hasAfter && hasAt) {
+            return toolError(
+              "Provide either `afterSeconds` (relative) or `at` (absolute), not both."
+            );
+          }
+          if (!hasAfter && !hasAt) {
+            return toolError("Provide `afterSeconds` or `at`.");
+          }
+          return performAct(acts, {
+            kind: "wake",
+            callId: randomUUID2(),
+            wake: {
+              ...hasAfter ? { afterSeconds: args.afterSeconds } : {},
+              ...hasAt ? { at: args.at } : {},
+              note: args.note
+            }
+          });
+        },
+        { annotations: ACT_TOOL, alwaysLoad: true }
+      ),
+      // The standalone withdrawal. Not annotated destructive — an ask
+      // is a question, not data, and a harness that gated this on a live
+      // operator would hang a turn nobody is watching (the `cancel_wake`
+      // reasoning). Not idempotent either: a second call with the same id is
+      // refused with `ask_not_open`, which is information, not a no-op.
+      tool(
+        WITHDRAW_ASK_TOOL,
+        TURN_CONTROL_TOOL_DESCRIPTIONS.withdraw_ask,
+        {
+          askId: z16.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.askId),
+          reason: z16.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.reason)
+        },
+        async (args) => performAct(acts, {
+          kind: "withdraw_ask",
+          callId: randomUUID2(),
+          withdraw: { askId: args.askId, reason: args.reason }
+        }),
+        { annotations: ACT_TOOL, alwaysLoad: true }
+      ),
+      tool(
+        ANSWER_TOOL2,
+        TURN_CONTROL_TOOL_DESCRIPTIONS.answer,
+        {},
+        async () => performAct(acts, { kind: "answer", callId: randomUUID2() }),
+        { annotations: ACT_TOOL, alwaysLoad: true }
+      ),
+      // The inverse. No arguments — it can only ever stand down the
+      // caller's own wake in the conversation it's holding a turn in.
+      tool(
+        CANCEL_WAKE_TOOL,
+        TURN_CONTROL_TOOL_DESCRIPTIONS.cancel_wake,
+        {},
+        async () => performAct(acts, { kind: "cancel_wake", callId: randomUUID2() }),
+        { annotations: CANCEL_TOOL, alwaysLoad: true }
+      )
+    ]
   });
-  if (thrown !== void 0) throw new Error(thrown);
-  if (stopped) log2.info({ turnId, code }, "runner: stopped before it could report");
-  else log2.warn({ turnId, code }, "runner: exited without reporting a result");
-  duties.notifyEnd({ id: payload.messageId, ok: false, durationMs, reason });
-  return { ok: false, durationMs, reason };
 }
-var BOXED_ENV_DROPPED, PINO_LEVELS;
-var init_launch = __esm({
-  "src/runner/launch.ts"() {
+var COMPANION_LOCAL_MCP_SERVER, COMPANION_LOCAL_TOOL_GLOB, SKIP_TURN_TOOL, ASK_TOOL, ASK_TOOL_NAME, WITHDRAW_ASK_TOOL, WITHDRAW_ASK_TOOL_NAME, ANSWER_TOOL2, WAKE_ME_TOOL, WAKE_ME_TOOL_NAME, CANCEL_WAKE_TOOL, CANCEL_WAKE_TOOL_NAME, TURN_ACT_TIMEOUT_MS;
+var init_turn_control_tools = __esm({
+  "src/turn-control-tools.ts"() {
     "use strict";
     init_src();
-    init_opencode_lock();
-    init_api_error_shape();
+    init_descriptions();
     init_errors();
-    init_boot_id();
-    init_turn_containment();
-    init_protocol();
-    BOXED_ENV_DROPPED = [
-      "ANTHROPIC_API_KEY",
-      "CLAUDE_CODE_OAUTH_TOKEN",
-      "CODEX_API_KEY",
-      "GH_TOKEN",
-      "GITHUB_TOKEN",
-      "DBUS_SESSION_BUS_ADDRESS",
-      "XDG_RUNTIME_DIR"
-    ];
-    PINO_LEVELS = {
-      10: "trace",
-      20: "debug",
-      30: "info",
-      40: "warn",
-      50: "error",
-      60: "fatal"
-    };
+    init_api_error_shape();
+    COMPANION_LOCAL_MCP_SERVER = TURN_CONTROL_MCP_SERVER;
+    COMPANION_LOCAL_TOOL_GLOB = `mcp__${COMPANION_LOCAL_MCP_SERVER}__*`;
+    SKIP_TURN_TOOL = "skip_turn";
+    ASK_TOOL = "ask";
+    ASK_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${ASK_TOOL}`;
+    WITHDRAW_ASK_TOOL = "withdraw_ask";
+    WITHDRAW_ASK_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${WITHDRAW_ASK_TOOL}`;
+    ANSWER_TOOL2 = "answer";
+    WAKE_ME_TOOL = "wake_me";
+    WAKE_ME_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${WAKE_ME_TOOL}`;
+    CANCEL_WAKE_TOOL = "cancel_wake";
+    CANCEL_WAKE_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${CANCEL_WAKE_TOOL}`;
+    TURN_ACT_TIMEOUT_MS = 45e3;
   }
 });
 
-// src/grants.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { join as join14 } from "path";
-import { z as z15 } from "zod";
-function allowedGrantVariable(name) {
-  return name.length <= 100 && VARIABLE_NAME_RE.test(name) && !name.startsWith("CABANE_");
-}
-function environmentSafe(value) {
-  return !value.includes("\0");
+// src/build-options.ts
+function cabaneMcpUrl(baseUrl) {
+  return `${trimSlash2(baseUrl)}/api/mcp`;
 }
-function grantsPath() {
-  return join14(cabaneDir(), "grants.json");
+function turnControlMcpUrl(baseUrl) {
+  return `${trimSlash2(baseUrl)}/api/turn-control`;
 }
-function readGrants(keys, report) {
-  if (keys.length === 0) return {};
-  const file = loadGrantsFile(report);
-  const out = {};
-  for (const key of keys) {
-    if (!allowedGrantVariable(key) || !Object.hasOwn(file, key)) continue;
-    const entry = {};
-    for (const [variable, value] of Object.entries(file[key])) {
-      if (allowedGrantVariable(variable) && environmentSafe(value)) entry[variable] = value;
-      else report.refusedVariable(key, variable);
+function buildCompanionTurnRequest(params) {
+  const { turnContext: t } = params;
+  return {
+    systemPrompt: t.systemPrompt,
+    ...t.standing ? { standing: t.standing } : {},
+    prompt: t.prompt,
+    content: t.content,
+    config: t.config,
+    session: t.session,
+    cabane: {
+      mcpUrl: cabaneMcpUrl(params.baseUrl),
+      bearer: params.turnToken,
+      activeConversationId: params.activeConversationId,
+      workspaceId: params.workspaceId,
+      turnControlUrl: turnControlMcpUrl(params.baseUrl)
+    },
+    local: {
+      ...params.cwd ? { cwd: params.cwd } : {},
+      ...params.env ? { env: params.env } : {},
+      // User MCP servers (already `${PLACEHOLDER}`-resolved). Structurally the
+      // adapter's `ResolvedMcpServers`.
+      ...Object.keys(params.mcpServers).length > 0 ? { mcpServers: params.mcpServers } : {},
+      ...params.secretEnv && Object.keys(params.secretEnv).length > 0 ? { secretEnv: params.secretEnv } : {},
+      // The auto-memory escape hatch, when the operator set it.
+      ...params.claudeCode ? { claudeCode: params.claudeCode } : {},
+      // Whether the person's Codex config sets its own sandbox mode.
+      ...params.codex ? { codex: params.codex } : {}
+    },
+    // Host-injected turn-control tools, under their own namespace.
+    extra: {
+      mcpServers: { [COMPANION_LOCAL_MCP_SERVER]: params.turnControlServer }
     }
-    out[key] = entry;
+  };
+}
+function trimSlash2(s) {
+  return s.endsWith("/") ? s.slice(0, -1) : s;
+}
+var init_build_options = __esm({
+  "src/build-options.ts"() {
+    "use strict";
+    init_turn_control_tools();
   }
-  return out;
+});
+
+// src/codex-config.ts
+import { readFile as readFile2 } from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { join as join16 } from "path";
+import { parse } from "smol-toml";
+function codexConfigPath(env = process.env, home = homedir7()) {
+  return join16(env.CODEX_HOME || join16(home, ".codex"), "config.toml");
 }
-function loadGrantsFile(report) {
-  const path = grantsPath();
-  if (!existsSync9(path)) return {};
-  let raw;
+async function readCodexConfigSetsSandboxMode(path = codexConfigPath()) {
+  let text;
   try {
-    raw = readFileSync7(path, "utf8");
-  } catch (err) {
-    const code = err.code ?? "unknown error";
-    report.unreadable(`couldn't read ${path}: ${code}`);
-    return {};
+    text = await readFile2(path, "utf8");
+  } catch {
+    return false;
   }
-  if (raw.trim().length === 0) return {};
-  let parsed;
+  return configSetsSandboxMode(text);
+}
+function configSetsSandboxMode(text) {
   try {
-    parsed = JSON.parse(raw);
+    return parse(text).sandbox_mode !== void 0;
   } catch {
-    report.unreadable(`${path} is not valid JSON.`);
-    return {};
-  }
-  const result = grantsFileSchema.safeParse(parsed);
-  if (!result.success) {
-    report.unreadable(
-      `${path} must map a secret's variable name to an object of "VARIABLE": "value" pairs (e.g. { "HAS_PROD_ACCESS": { "RENDER_API_KEY": "rnd_\u2026" } }).`
-    );
-    return {};
+    return false;
   }
-  return result.data;
 }
-function harnessSecretEnv(parts) {
-  const env = {};
-  const dropped = [];
-  for (const [name, value] of Object.entries({
-    ...parts.deviceDefaults,
-    ...parts.granted,
-    ...parts.issued
-  })) {
-    if (environmentSafe(value)) env[name] = value;
-    else dropped.push(name);
+var init_codex_config = __esm({
+  "src/codex-config.ts"() {
+    "use strict";
   }
-  return { env, dropped };
+});
+
+// src/codex-images.ts
+import { mkdtemp, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join17 } from "path";
+function createCodexImagePreparer(opts) {
+  const doFetch = opts.fetch ?? fetch;
+  const timeoutMs = opts.timeoutMs ?? FETCH_TIMEOUT_MS;
+  return async (urls, signal) => {
+    signal.throwIfAborted();
+    const dir2 = await mkdtemp(join17(tmpdir(), `cabane-codex-images-${opts.turnId}-`));
+    const cleanup = async () => {
+      try {
+        await rm(dir2, { recursive: true, force: true });
+      } catch (err) {
+        opts.warn(
+          { dir: dir2, err: message(err) },
+          "codex images: could not remove the scratch directory"
+        );
+      }
+    };
+    const prepareOne = async (url, index) => {
+      try {
+        const res = await doFetch(url, {
+          signal: AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)])
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const type = (res.headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
+        const ext = EXTENSIONS[type];
+        if (!ext) throw new Error(`not a vision image type: ${type || "none"}`);
+        const bytes = new Uint8Array(await res.arrayBuffer());
+        const path = join17(dir2, `image-${index + 1}.${ext}`);
+        await writeFile(path, bytes, { mode: 384 });
+        return path;
+      } catch (err) {
+        if (!signal.aborted) {
+          opts.warn(
+            { image: index + 1, of: urls.length, err: message(err) },
+            "codex images: an image could not be prepared; the turn runs without it"
+          );
+        }
+        return null;
+      }
+    };
+    const paths = await Promise.all(urls.map(prepareOne));
+    if (signal.aborted) {
+      await cleanup();
+      signal.throwIfAborted();
+    }
+    return { paths: paths.filter((p) => p !== null), cleanup };
+  };
 }
-function grantEnv(sent, issuedBySecret, issued) {
-  const env = {};
-  for (const [key, entry] of Object.entries(sent ?? {})) {
-    if (!Object.hasOwn(issuedBySecret, key)) continue;
-    for (const [variable, value] of Object.entries(entry)) {
-      if (Object.hasOwn(issued, variable) || Object.hasOwn(env, variable)) continue;
-      env[variable] = value;
+function message(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var FETCH_TIMEOUT_MS, EXTENSIONS;
+var init_codex_images = __esm({
+  "src/codex-images.ts"() {
+    "use strict";
+    FETCH_TIMEOUT_MS = 3e4;
+    EXTENSIONS = {
+      "image/png": "png",
+      "image/jpeg": "jpg",
+      "image/gif": "gif",
+      "image/webp": "webp"
+    };
+  }
+});
+
+// src/codex-compactions.ts
+import { createReadStream } from "fs";
+import { readdir } from "fs/promises";
+import { homedir as homedir8 } from "os";
+import { join as join18 } from "path";
+import { createInterface as createInterface2 } from "readline";
+function createCodexCompactionCounter(codexHome = process.env.CODEX_HOME || join18(homedir8(), ".codex")) {
+  return async (threadId) => {
+    try {
+      const rollout = await findRollout(codexHome, threadId);
+      return rollout ? await countCompactions(rollout) : null;
+    } catch {
+      return null;
+    }
+  };
+}
+async function findRollout(codexHome, threadId) {
+  const id = UUID_V7.exec(threadId);
+  if (!id) return null;
+  const createdAt = parseInt(`${id[1]}${id[2]}`, 16);
+  const suffix = `-${threadId}.jsonl`;
+  for (const offset of [0, -DAY_MS, DAY_MS]) {
+    const day = new Date(createdAt + offset);
+    const dir2 = join18(
+      codexHome,
+      "sessions",
+      String(day.getUTCFullYear()),
+      String(day.getUTCMonth() + 1).padStart(2, "0"),
+      String(day.getUTCDate()).padStart(2, "0")
+    );
+    let names;
+    try {
+      names = await readdir(dir2);
+    } catch {
+      continue;
     }
+    const name = names.find((n) => n.startsWith("rollout-") && n.endsWith(suffix));
+    if (name) return join18(dir2, name);
   }
-  return env;
+  return null;
 }
-var VARIABLE_NAME_RE, grantsFileSchema;
-var init_grants = __esm({
-  "src/grants.ts"() {
+async function countCompactions(rollout) {
+  const lines2 = createInterface2({
+    input: createReadStream(rollout, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  let count = 0;
+  for await (const line of lines2) {
+    if (line.slice(0, RECORD_HEAD_CHARS).includes('"type":"compacted"')) count += 1;
+  }
+  return count;
+}
+var DAY_MS, UUID_V7, RECORD_HEAD_CHARS;
+var init_codex_compactions = __esm({
+  "src/codex-compactions.ts"() {
     "use strict";
-    init_config();
-    VARIABLE_NAME_RE = /^[A-Z_][A-Z0-9_]*$/;
-    grantsFileSchema = z15.record(z15.string(), z15.record(z15.string(), z15.string()));
+    DAY_MS = 864e5;
+    UUID_V7 = /^([0-9a-f]{8})-([0-9a-f]{4})-7[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    RECORD_HEAD_CHARS = 200;
   }
 });
 
-// src/work-dir.ts
-import { statSync as statSync3 } from "fs";
-import { join as join15 } from "path";
-function pairDirectory(root, pair) {
-  return join15(root, pair.workspaceSlug, pair.agentUsername, pair.conversationId);
-}
-function chooseStandingDirectory(named, pairDir, isDirectory = directoryExists) {
-  const skipped = [];
-  for (const candidate of named) {
-    if (isDirectory(candidate.path)) return { cwd: candidate.path, skipped };
-    skipped.push(candidate);
+// src/turn-seq-floor.ts
+function resolveSeqFloor(sources, ctx2) {
+  const { serverFloor, outboxFloor } = sources;
+  if (serverFloor === void 0) {
+    throw new SeqFloorUnavailable("server sent no committed floor for a resumed turn");
   }
-  return { cwd: pairDir, skipped };
+  const floor = Math.max(serverFloor, outboxFloor);
+  ctx2.log.debug(
+    { turnId: ctx2.turnId, floor, outboxFloor, serverFloor },
+    "companion: resumed turn \u2014 seq counter seeded above its committed high-water mark"
+  );
+  return floor;
 }
-function directoryExists(path) {
+function readOutboxFloor(read2, turnId, log2) {
   try {
-    return statSync3(path).isDirectory();
-  } catch {
-    return false;
+    return read2(turnId);
+  } catch (err) {
+    log2.debug(
+      { turnId, err: err instanceof Error ? err.message : String(err) },
+      "companion: the on-disk outbox floor is unreadable; refusing to resume"
+    );
+    throw new SeqFloorUnavailable("outbox unreadable");
   }
 }
-var init_work_dir = __esm({
-  "src/work-dir.ts"() {
+var SeqFloorUnavailable;
+var init_turn_seq_floor = __esm({
+  "src/turn-seq-floor.ts"() {
     "use strict";
+    SeqFloorUnavailable = class extends Error {
+      constructor(detail) {
+        super(`seq_floor_unavailable: ${detail}`);
+        this.detail = detail;
+        this.name = "SeqFloorUnavailable";
+      }
+      detail;
+    };
   }
 });
 
-// src/turn-control-tools.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { z as z16 } from "zod";
-function createSkipState() {
-  return { skipped: false, reason: null };
+// src/prepared.ts
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, rmSync as rmSync5, writeFileSync as writeFileSync5, existsSync as existsSync10 } from "fs";
+import { join as join19 } from "path";
+function dirFor(workspaceId) {
+  return join19(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
 }
-function toolError(text) {
-  return { isError: true, content: [{ type: "text", text }] };
+function conversationDir(workspaceId, conversationId) {
+  return join19(dirFor(workspaceId), encodeURIComponent(conversationId));
 }
-async function performAct(acts, act) {
-  let result;
+function pathFor2(workspaceId, conversationId, agentId) {
+  return join19(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
+}
+function readPrepared(workspaceId, conversationId, agentId) {
+  const path = pathFor2(workspaceId, conversationId, agentId);
+  if (!existsSync10(path)) return null;
   try {
-    result = await acts.api.turnAct(
-      acts.workspaceId,
-      acts.turnId,
-      act,
-      AbortSignal.timeout(TURN_ACT_TIMEOUT_MS)
-    );
-  } catch (err) {
-    if (err instanceof ApiError && err.status >= 500) {
-      return uncertainOutcome(`${err.status}: ${apiErrorMessage(err)}`);
-    }
-    if (err instanceof ApiError) {
-      if (err.status === 409 && apiErrorCode(err) === "no_active_turn") {
-        return toolError(
-          "No active turn: this turn has already settled, so the act was not performed."
-        );
-      }
-      return toolError(`The act was refused (${err.status}): ${apiErrorMessage(err)}`);
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
+    if (parsed && typeof parsed.cwd === "string" && parsed.cwd.length > 0) {
+      return {
+        cwd: parsed.cwd,
+        ...parsed.env && typeof parsed.env === "object" ? { env: parsed.env } : {}
+      };
     }
-    return uncertainOutcome(err instanceof Error ? err.message : String(err));
+    return null;
+  } catch {
+    return null;
   }
-  if (!result.ok) return toolError(JSON.stringify(result));
-  return { content: [{ type: "text", text: JSON.stringify(result) }] };
-}
-function uncertainOutcome(cause) {
-  return toolError(
-    `The outcome of this act could not be confirmed (${cause}). It may already have been performed, with only the response lost. Do NOT simply repeat the call: a repeat is a second, separate act, not a retry. Carry on, and say in your reply that you could not confirm it.`
-  );
 }
-function createTurnControlMcpServer(acts, skipState) {
-  const ACT_TOOL = { readOnlyHint: false, destructiveHint: false, openWorldHint: false };
-  const CANCEL_TOOL = { ...ACT_TOOL, idempotentHint: true };
-  const RECORDER_TOOL = { readOnlyHint: true, openWorldHint: false };
-  return createSdkMcpServer({
-    name: COMPANION_LOCAL_MCP_SERVER,
-    version: "0.0.0",
-    tools: [
-      ...skipState ? [
-        tool(
-          SKIP_TURN_TOOL,
-          TURN_CONTROL_TOOL_DESCRIPTIONS.skip_turn,
-          {
-            reason: z16.string().min(1).max(MAX_SKIP_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.skip_turn.reason)
-          },
-          async (args) => {
-            skipState.skipped = true;
-            skipState.reason = args.reason;
-            return {
-              content: [{ type: "text", text: JSON.stringify({ skipped: true }) }]
-            };
-          },
-          { annotations: RECORDER_TOOL, alwaysLoad: true }
-        )
-      ] : [],
-      tool(
-        ASK_TOOL,
-        TURN_CONTROL_TOOL_DESCRIPTIONS.ask,
-        {
-          targetUserId: z16.string().regex(ASK_TARGET_PATTERN, { error: ASK_TARGET_INVALID }).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.targetUserId),
-          question: z16.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.question),
-          headline: z16.string().min(1).max(MAX_ASK_HEADLINE_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.headline),
-          options: z16.array(z16.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)).min(MIN_ASK_OPTIONS).max(MAX_ASK_OPTIONS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.options),
-          questions: z16.array(
-            z16.object({
-              headline: z16.string().min(1).max(MAX_ASK_HEADLINE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.headline"]),
-              body: z16.string().min(1).max(MAX_ASK_QUESTION_BYTES).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.body"]),
-              options: z16.array(
-                z16.string({ error: ASK_OPTION_NOT_A_STRING }).min(1).max(MAX_ASK_OPTION_BYTES)
-              ).min(MIN_ASK_OPTIONS).max(MAX_ASK_OPTIONS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["questions.options"])
-            })
-          ).min(1).max(MAX_ASK_ITEMS).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.questions),
-          replaces: z16.object({
-            askId: z16.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.askId"]),
-            reason: z16.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask["replaces.reason"])
-          }).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.ask.replaces)
-        },
-        async (args) => {
-          const hasSingle = args.question !== void 0;
-          const hasArray = args.questions !== void 0 && args.questions.length > 0;
-          if (hasSingle && hasArray) {
-            return toolError(
-              "Provide either `question` (single) or `questions` (array), not both."
-            );
-          }
-          if (!hasSingle && !hasArray) {
-            return toolError("Provide `question` (single) or `questions` (array).");
-          }
-          return performAct(acts, {
-            kind: "ask",
-            callId: randomUUID2(),
-            // The swap rides the ask, so the server commits both halves
-            // in one transaction — the person never sees neither or both.
-            ...args.replaces ? { replaces: args.replaces } : {},
-            ask: hasArray ? {
-              targetUserId: args.targetUserId,
-              questions: args.questions.map((q) => ({
-                headline: q.headline,
-                ...q.body ? { body: q.body } : {},
-                ...q.options && q.options.length > 0 ? { options: q.options } : {}
-              }))
-            } : {
-              targetUserId: args.targetUserId,
-              question: args.question,
-              ...args.headline ? { headline: args.headline } : {},
-              ...args.options && args.options.length > 0 ? { options: args.options } : {}
-            }
-          });
-        },
-        { annotations: ACT_TOOL, alwaysLoad: true }
-      ),
-      tool(
-        WAKE_ME_TOOL,
-        TURN_CONTROL_TOOL_DESCRIPTIONS.wake_me,
-        {
-          afterSeconds: z16.number().int().positive().optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.afterSeconds),
-          at: z16.string().datetime({ offset: true }).optional().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.at),
-          note: z16.string().min(1).max(MAX_WAKE_NOTE_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.wake_me.note)
-        },
-        async (args) => {
-          const hasAfter = args.afterSeconds !== void 0;
-          const hasAt = args.at !== void 0;
-          if (hasAfter && hasAt) {
-            return toolError(
-              "Provide either `afterSeconds` (relative) or `at` (absolute), not both."
-            );
-          }
-          if (!hasAfter && !hasAt) {
-            return toolError("Provide `afterSeconds` or `at`.");
-          }
-          return performAct(acts, {
-            kind: "wake",
-            callId: randomUUID2(),
-            wake: {
-              ...hasAfter ? { afterSeconds: args.afterSeconds } : {},
-              ...hasAt ? { at: args.at } : {},
-              note: args.note
-            }
-          });
-        },
-        { annotations: ACT_TOOL, alwaysLoad: true }
-      ),
-      // The standalone withdrawal. Not annotated destructive — an ask
-      // is a question, not data, and a harness that gated this on a live
-      // operator would hang a turn nobody is watching (the `cancel_wake`
-      // reasoning). Not idempotent either: a second call with the same id is
-      // refused with `ask_not_open`, which is information, not a no-op.
-      tool(
-        WITHDRAW_ASK_TOOL,
-        TURN_CONTROL_TOOL_DESCRIPTIONS.withdraw_ask,
-        {
-          askId: z16.string().uuid().describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.askId),
-          reason: z16.string().min(1).max(MAX_WITHDRAW_REASON_BYTES).describe(TURN_CONTROL_FIELD_DESCRIPTIONS.withdraw_ask.reason)
-        },
-        async (args) => performAct(acts, {
-          kind: "withdraw_ask",
-          callId: randomUUID2(),
-          withdraw: { askId: args.askId, reason: args.reason }
-        }),
-        { annotations: ACT_TOOL, alwaysLoad: true }
-      ),
-      tool(
-        ANSWER_TOOL2,
-        TURN_CONTROL_TOOL_DESCRIPTIONS.answer,
-        {},
-        async () => performAct(acts, { kind: "answer", callId: randomUUID2() }),
-        { annotations: ACT_TOOL, alwaysLoad: true }
-      ),
-      // The inverse. No arguments — it can only ever stand down the
-      // caller's own wake in the conversation it's holding a turn in.
-      tool(
-        CANCEL_WAKE_TOOL,
-        TURN_CONTROL_TOOL_DESCRIPTIONS.cancel_wake,
-        {},
-        async () => performAct(acts, { kind: "cancel_wake", callId: randomUUID2() }),
-        { annotations: CANCEL_TOOL, alwaysLoad: true }
-      )
-    ]
-  });
-}
-var COMPANION_LOCAL_MCP_SERVER, COMPANION_LOCAL_TOOL_GLOB, SKIP_TURN_TOOL, ASK_TOOL, ASK_TOOL_NAME, WITHDRAW_ASK_TOOL, WITHDRAW_ASK_TOOL_NAME, ANSWER_TOOL2, WAKE_ME_TOOL, WAKE_ME_TOOL_NAME, CANCEL_WAKE_TOOL, CANCEL_WAKE_TOOL_NAME, TURN_ACT_TIMEOUT_MS;
-var init_turn_control_tools = __esm({
-  "src/turn-control-tools.ts"() {
-    "use strict";
-    init_src();
-    init_descriptions();
-    init_errors();
-    init_api_error_shape();
-    COMPANION_LOCAL_MCP_SERVER = TURN_CONTROL_MCP_SERVER;
-    COMPANION_LOCAL_TOOL_GLOB = `mcp__${COMPANION_LOCAL_MCP_SERVER}__*`;
-    SKIP_TURN_TOOL = "skip_turn";
-    ASK_TOOL = "ask";
-    ASK_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${ASK_TOOL}`;
-    WITHDRAW_ASK_TOOL = "withdraw_ask";
-    WITHDRAW_ASK_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${WITHDRAW_ASK_TOOL}`;
-    ANSWER_TOOL2 = "answer";
-    WAKE_ME_TOOL = "wake_me";
-    WAKE_ME_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${WAKE_ME_TOOL}`;
-    CANCEL_WAKE_TOOL = "cancel_wake";
-    CANCEL_WAKE_TOOL_NAME = `mcp__${COMPANION_LOCAL_MCP_SERVER}__${CANCEL_WAKE_TOOL}`;
-    TURN_ACT_TIMEOUT_MS = 45e3;
-  }
-});
-
-// src/build-options.ts
-function cabaneMcpUrl(baseUrl) {
-  return `${trimSlash2(baseUrl)}/api/mcp`;
-}
-function turnControlMcpUrl(baseUrl) {
-  return `${trimSlash2(baseUrl)}/api/turn-control`;
-}
-function buildCompanionTurnRequest(params) {
-  const { turnContext: t } = params;
-  return {
-    systemPrompt: t.systemPrompt,
-    ...t.standing ? { standing: t.standing } : {},
-    prompt: t.prompt,
-    content: t.content,
-    config: t.config,
-    session: t.session,
-    cabane: {
-      mcpUrl: cabaneMcpUrl(params.baseUrl),
-      bearer: params.turnToken,
-      activeConversationId: params.activeConversationId,
-      workspaceId: params.workspaceId,
-      turnControlUrl: turnControlMcpUrl(params.baseUrl)
-    },
-    local: {
-      ...params.cwd ? { cwd: params.cwd } : {},
-      ...params.env ? { env: params.env } : {},
-      // User MCP servers (already `${PLACEHOLDER}`-resolved). Structurally the
-      // adapter's `ResolvedMcpServers`.
-      ...Object.keys(params.mcpServers).length > 0 ? { mcpServers: params.mcpServers } : {},
-      ...params.secretEnv && Object.keys(params.secretEnv).length > 0 ? { secretEnv: params.secretEnv } : {},
-      // The auto-memory escape hatch, when the operator set it.
-      ...params.claudeCode ? { claudeCode: params.claudeCode } : {},
-      // Whether the person's Codex config sets its own sandbox mode.
-      ...params.codex ? { codex: params.codex } : {}
-    },
-    // Host-injected turn-control tools, under their own namespace.
-    extra: {
-      mcpServers: { [COMPANION_LOCAL_MCP_SERVER]: params.turnControlServer }
-    }
-  };
+function writePrepared(workspaceId, conversationId, agentId, result) {
+  mkdirSync7(conversationDir(workspaceId, conversationId), { recursive: true });
+  writeFileSync5(
+    pathFor2(workspaceId, conversationId, agentId),
+    JSON.stringify(result) + "\n",
+    "utf8"
+  );
 }
-function trimSlash2(s) {
-  return s.endsWith("/") ? s.slice(0, -1) : s;
+function clearPrepared(workspaceId, conversationId, agentId) {
+  rmSync5(pathFor2(workspaceId, conversationId, agentId), { force: true });
 }
-var init_build_options = __esm({
-  "src/build-options.ts"() {
+var init_prepared = __esm({
+  "src/prepared.ts"() {
     "use strict";
-    init_turn_control_tools();
+    init_config();
   }
 });
 
-// src/codex-config.ts
-import { readFile as readFile2 } from "fs/promises";
-import { homedir as homedir7 } from "os";
-import { join as join16 } from "path";
-import { parse } from "smol-toml";
-function codexConfigPath(env = process.env, home = homedir7()) {
-  return join16(env.CODEX_HOME || join16(home, ".codex"), "config.toml");
+// src/secrets.ts
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+import { join as join20 } from "path";
+import { z as z17 } from "zod";
+function secretsPath() {
+  return join20(cabaneDir(), "secrets.json");
 }
-async function readCodexConfigSetsSandboxMode(path = codexConfigPath()) {
-  let text;
+function loadSecretValues() {
+  const path = secretsPath();
+  if (!existsSync11(path)) return {};
+  let raw;
   try {
-    text = await readFile2(path, "utf8");
-  } catch {
-    return false;
+    raw = readFileSync9(path, "utf8");
+  } catch (err) {
+    throw new ConfigError(
+      `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
-  return configSetsSandboxMode(text);
-}
-function configSetsSandboxMode(text) {
+  if (raw.trim().length === 0) return {};
+  let parsed;
   try {
-    return parse(text).sandbox_mode !== void 0;
-  } catch {
-    return false;
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new ConfigError(
+      `${path} is not valid JSON: ${err instanceof Error ? err.message : String(err)}. It must be a flat object of "NAME": "value" secret pairs.`
+    );
+  }
+  const result = secretStoreSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ConfigError(
+      `${path} must be a flat object mapping secret names to string values (e.g. { "GITHUB_TOKEN": "ghp_\u2026" }).`
+    );
   }
+  return result.data;
 }
-var init_codex_config = __esm({
-  "src/codex-config.ts"() {
-    "use strict";
+function loadSecretStoreTolerant(onWarn) {
+  return makeStore(loadSecretValuesTolerant(onWarn));
+}
+function loadSecretValuesTolerant(onWarn) {
+  try {
+    return loadSecretValues();
+  } catch (err) {
+    onWarn?.(err instanceof Error ? err.message : String(err));
+    return {};
   }
-});
-
-// src/codex-images.ts
-import { mkdtemp, rm, writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import { join as join17 } from "path";
-function createCodexImagePreparer(opts) {
-  const doFetch = opts.fetch ?? fetch;
-  const timeoutMs = opts.timeoutMs ?? FETCH_TIMEOUT_MS;
-  return async (urls, signal) => {
-    signal.throwIfAborted();
-    const dir2 = await mkdtemp(join17(tmpdir(), `cabane-codex-images-${opts.turnId}-`));
-    const cleanup = async () => {
-      try {
-        await rm(dir2, { recursive: true, force: true });
-      } catch (err) {
-        opts.warn(
-          { dir: dir2, err: message(err) },
-          "codex images: could not remove the scratch directory"
-        );
-      }
-    };
-    const prepareOne = async (url, index) => {
-      try {
-        const res = await doFetch(url, {
-          signal: AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)])
-        });
-        if (!res.ok) throw new Error(`HTTP ${res.status}`);
-        const type = (res.headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
-        const ext = EXTENSIONS[type];
-        if (!ext) throw new Error(`not a vision image type: ${type || "none"}`);
-        const bytes = new Uint8Array(await res.arrayBuffer());
-        const path = join17(dir2, `image-${index + 1}.${ext}`);
-        await writeFile(path, bytes, { mode: 384 });
-        return path;
-      } catch (err) {
-        if (!signal.aborted) {
-          opts.warn(
-            { image: index + 1, of: urls.length, err: message(err) },
-            "codex images: an image could not be prepared; the turn runs without it"
-          );
-        }
-        return null;
-      }
-    };
-    const paths = await Promise.all(urls.map(prepareOne));
-    if (signal.aborted) {
-      await cleanup();
-      signal.throwIfAborted();
-    }
-    return { paths: paths.filter((p) => p !== null), cleanup };
+}
+function makeStore(map) {
+  return {
+    get: (name) => map[name],
+    names: () => Object.keys(map).sort()
   };
 }
-function message(err) {
-  return err instanceof Error ? err.message : String(err);
+function requiredSecretNames(mcpServers) {
+  const names = /* @__PURE__ */ new Set();
+  for (const server of Object.values(mcpServers ?? {})) {
+    const bags = [
+      "env" in server ? server.env : void 0,
+      "headers" in server ? server.headers : void 0
+    ];
+    for (const bag of bags) {
+      for (const value of Object.values(bag ?? {})) {
+        for (const [, name] of value.matchAll(PLACEHOLDER_RE)) names.add(name);
+      }
+    }
+  }
+  return [...names].sort();
 }
-var FETCH_TIMEOUT_MS, EXTENSIONS;
-var init_codex_images = __esm({
-  "src/codex-images.ts"() {
-    "use strict";
-    FETCH_TIMEOUT_MS = 3e4;
-    EXTENSIONS = {
-      "image/png": "png",
-      "image/jpeg": "jpg",
-      "image/gif": "gif",
-      "image/webp": "webp"
-    };
+function resolveMcpSecrets(mcpServers, store, serverSecretEnv = {}) {
+  const missing = /* @__PURE__ */ new Set();
+  const secretEnv = { ...serverSecretEnv };
+  let counter = 0;
+  for (const name of Object.keys(serverSecretEnv)) {
+    const n = SECRET_ENV_NAME.exec(name);
+    if (n) counter = Math.max(counter, Number(n[1]));
   }
-});
-
-// src/codex-compactions.ts
-import { createReadStream } from "fs";
-import { readdir } from "fs/promises";
-import { homedir as homedir8 } from "os";
-import { join as join18 } from "path";
-import { createInterface as createInterface2 } from "readline";
-function createCodexCompactionCounter(codexHome = process.env.CODEX_HOME || join18(homedir8(), ".codex")) {
-  return async (threadId) => {
-    try {
-      const rollout = await findRollout(codexHome, threadId);
-      return rollout ? await countCompactions(rollout) : null;
-    } catch {
-      return null;
+  const interpolate = (value) => value.replace(PLACEHOLDER_RE, (_match, name) => {
+    const resolved = store.get(name);
+    if (resolved === void 0) {
+      missing.add(name);
+      return _match;
     }
+    return resolved;
+  });
+  const mapBag = (bag) => {
+    const out = {};
+    for (const [k, v] of Object.entries(bag)) out[k] = interpolate(v);
+    return out;
   };
-}
-async function findRollout(codexHome, threadId) {
-  const id = UUID_V7.exec(threadId);
-  if (!id) return null;
-  const createdAt = parseInt(`${id[1]}${id[2]}`, 16);
-  const suffix = `-${threadId}.jsonl`;
-  for (const offset of [0, -DAY_MS, DAY_MS]) {
-    const day = new Date(createdAt + offset);
-    const dir2 = join18(
-      codexHome,
-      "sessions",
-      String(day.getUTCFullYear()),
-      String(day.getUTCMonth() + 1).padStart(2, "0"),
-      String(day.getUTCDate()).padStart(2, "0")
-    );
-    let names;
-    try {
-      names = await readdir(dir2);
-    } catch {
-      continue;
+  const servers = {};
+  for (const [name, server] of Object.entries(mcpServers)) {
+    const next = { ...server };
+    if ("env" in next && next.env) next.env = mapBag(next.env);
+    if ("url" in next && next.headers) {
+      const headers = {};
+      const fromEnv = { ...next.headersFromEnv };
+      for (const [header, value] of Object.entries(next.headers)) {
+        if (!value.match(PLACEHOLDER_RE)) {
+          headers[header] = value;
+          continue;
+        }
+        const envName = `CABANE_MCP_${++counter}`;
+        secretEnv[envName] = interpolate(value);
+        fromEnv[header] = envName;
+      }
+      next.headers = headers;
+      if (Object.keys(headers).length === 0) delete next.headers;
+      if (Object.keys(fromEnv).length > 0) next.headersFromEnv = fromEnv;
     }
-    const name = names.find((n) => n.startsWith("rollout-") && n.endsWith(suffix));
-    if (name) return join18(dir2, name);
+    servers[name] = next;
   }
-  return null;
+  return { servers, secretEnv, missing: [...missing].sort() };
 }
-async function countCompactions(rollout) {
-  const lines2 = createInterface2({
-    input: createReadStream(rollout, { encoding: "utf8" }),
-    crlfDelay: Infinity
-  });
-  let count = 0;
-  for await (const line of lines2) {
-    if (line.slice(0, RECORD_HEAD_CHARS).includes('"type":"compacted"')) count += 1;
+function missingSecretReason(missing) {
+  const prefix = "missing_secret: ";
+  for (let shown = missing.length; shown >= 0; shown--) {
+    const omitted = missing.length - shown;
+    const parts = [...missing.slice(0, shown), ...omitted > 0 ? [`+${omitted}`] : []];
+    const reason = prefix + parts.join(",");
+    if (reason.length <= ERROR_REASON_MAX) return reason;
   }
-  return count;
+  return `${prefix}+${missing.length}`;
 }
-var DAY_MS, UUID_V7, RECORD_HEAD_CHARS;
-var init_codex_compactions = __esm({
-  "src/codex-compactions.ts"() {
+var PLACEHOLDER_RE, secretStoreSchema, SECRET_ENV_NAME;
+var init_secrets = __esm({
+  "src/secrets.ts"() {
     "use strict";
-    DAY_MS = 864e5;
-    UUID_V7 = /^([0-9a-f]{8})-([0-9a-f]{4})-7[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    RECORD_HEAD_CHARS = 200;
+    init_src();
+    init_config();
+    init_errors();
+    PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+    secretStoreSchema = z17.record(z17.string(), z17.string());
+    SECRET_ENV_NAME = /^CABANE_MCP_(\d+)$/;
   }
 });
 
-// src/turn-seq-floor.ts
-function resolveSeqFloor(sources, ctx2) {
-  const { serverFloor, outboxFloor } = sources;
-  if (serverFloor === void 0) {
-    throw new SeqFloorUnavailable("server sent no committed floor for a resumed turn");
+// src/turn-env.ts
+function harnessLoginEnv(store, runtime) {
+  const names = [
+    ...runtime in API_KEY_VARIABLES ? API_KEY_VARIABLES[runtime] : [],
+    GITHUB_TOKEN_NAME
+  ];
+  const env = {};
+  for (const name of names) {
+    const value = store.get(name);
+    if (value) env[name] = value;
   }
-  const floor = Math.max(serverFloor, outboxFloor);
-  ctx2.log.debug(
-    { turnId: ctx2.turnId, floor, outboxFloor, serverFloor },
-    "companion: resumed turn \u2014 seq counter seeded above its committed high-water mark"
-  );
-  return floor;
-}
-function readOutboxFloor(read2, turnId, log2) {
-  try {
-    return read2(turnId);
-  } catch (err) {
-    log2.debug(
-      { turnId, err: err instanceof Error ? err.message : String(err) },
-      "companion: the on-disk outbox floor is unreadable; refusing to resume"
-    );
-    throw new SeqFloorUnavailable("outbox unreadable");
-  }
-}
-var SeqFloorUnavailable;
-var init_turn_seq_floor = __esm({
-  "src/turn-seq-floor.ts"() {
-    "use strict";
-    SeqFloorUnavailable = class extends Error {
-      constructor(detail) {
-        super(`seq_floor_unavailable: ${detail}`);
-        this.detail = detail;
-        this.name = "SeqFloorUnavailable";
-      }
-      detail;
-    };
-  }
-});
-
-// src/prepare-failure.ts
-import { spawn as spawn4 } from "child_process";
-import { hostname } from "os";
-function prepareFailureCause(error) {
-  const message2 = error instanceof Error ? error.message : String(error);
-  if (/timed out/i.test(message2)) return "prepare hook timed out";
-  if (/MODULE_NOT_FOUND|Cannot find (?:module|package)/.test(message2))
-    return "prepare hook module missing; check the configured command and its installation for this device";
-  if (/not valid JSON|JSON must carry|produced no output/.test(message2))
-    return "prepare hook returned malformed output; expected a cwd path or JSON with a non-empty cwd";
-  if (/ENOENT/.test(message2)) return "prepare hook executable missing (ENOENT)";
-  if (/EACCES/.test(message2)) return "prepare hook executable is not accessible (EACCES)";
-  const exit = message2.match(/exited with code (\d+)/)?.[1];
-  return exit ? `prepare hook exited with code ${exit}` : "prepare hook failed; inspect the device-local hook log";
-}
-async function runPrepareWithReporting(runner, hook, input, context, reportError) {
-  try {
-    return await runner(hook, input);
-  } catch (error) {
-    if (hook.failureReporter) {
-      try {
-        await reportFailure(hook.failureReporter, {
-          workspaceId: input.workspaceId,
-          conversationId: input.conversationId,
-          agentId: input.agentId,
-          agentUsername: input.agentUsername,
-          turnId: context.turnId,
-          deviceId: context.deviceId ?? hostname(),
-          cause: prepareFailureCause(error)
-        });
-      } catch {
-        reportError();
-      }
-    }
-    throw error;
-  }
-}
-function reportFailure(config, body) {
-  return new Promise((resolve2, reject) => {
-    const child = spawn4(config.command, config.args ?? [], {
-      stdio: ["pipe", "ignore", "ignore"],
-      env: { ...process.env, ...config.env }
-    });
-    const timer = setTimeout(() => {
-      child.kill("SIGKILL");
-      reject(new Error("reporter timeout"));
-    }, config.timeoutMs ?? 15e3);
-    child.stdin.on("error", () => {
-    });
-    child.once("error", () => {
-      clearTimeout(timer);
-      reject(new Error("reporter failed to start"));
-    });
-    child.once("close", (code) => {
-      clearTimeout(timer);
-      if (code === 0) resolve2();
-      else reject(new Error("reporter failed"));
-    });
-    child.stdin.end(JSON.stringify(body));
-  });
-}
-var init_prepare_failure = __esm({
-  "src/prepare-failure.ts"() {
-    "use strict";
-  }
-});
-
-// src/prepared.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, rmSync as rmSync5, writeFileSync as writeFileSync5, existsSync as existsSync10 } from "fs";
-import { join as join19 } from "path";
-function dirFor(workspaceId) {
-  return join19(cabaneDir(), "prepared", encodeURIComponent(workspaceId));
-}
-function conversationDir(workspaceId, conversationId) {
-  return join19(dirFor(workspaceId), encodeURIComponent(conversationId));
-}
-function pathFor2(workspaceId, conversationId, agentId) {
-  return join19(conversationDir(workspaceId, conversationId), `${encodeURIComponent(agentId)}.json`);
-}
-function readPrepared(workspaceId, conversationId, agentId) {
-  const path = pathFor2(workspaceId, conversationId, agentId);
-  if (!existsSync10(path)) return null;
-  try {
-    const parsed = JSON.parse(readFileSync8(path, "utf8"));
-    if (parsed && typeof parsed.cwd === "string" && parsed.cwd.length > 0) {
-      return {
-        cwd: parsed.cwd,
-        ...parsed.env && typeof parsed.env === "object" ? { env: parsed.env } : {}
-      };
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function writePrepared(workspaceId, conversationId, agentId, result) {
-  mkdirSync7(conversationDir(workspaceId, conversationId), { recursive: true });
-  writeFileSync5(
-    pathFor2(workspaceId, conversationId, agentId),
-    JSON.stringify(result) + "\n",
-    "utf8"
-  );
-}
-function clearPrepared(workspaceId, conversationId, agentId) {
-  rmSync5(pathFor2(workspaceId, conversationId, agentId), { force: true });
-}
-var init_prepared = __esm({
-  "src/prepared.ts"() {
-    "use strict";
-    init_config();
-  }
-});
-
-// src/secrets.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
-import { join as join20 } from "path";
-import { z as z17 } from "zod";
-function secretsPath() {
-  return join20(cabaneDir(), "secrets.json");
-}
-function loadSecretValues() {
-  const path = secretsPath();
-  if (!existsSync11(path)) return {};
-  let raw;
-  try {
-    raw = readFileSync9(path, "utf8");
-  } catch (err) {
-    throw new ConfigError(
-      `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  if (raw.trim().length === 0) return {};
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    throw new ConfigError(
-      `${path} is not valid JSON: ${err instanceof Error ? err.message : String(err)}. It must be a flat object of "NAME": "value" secret pairs.`
-    );
-  }
-  const result = secretStoreSchema.safeParse(parsed);
-  if (!result.success) {
-    throw new ConfigError(
-      `${path} must be a flat object mapping secret names to string values (e.g. { "GITHUB_TOKEN": "ghp_\u2026" }).`
-    );
-  }
-  return result.data;
-}
-function loadSecretStoreTolerant(onWarn) {
-  return makeStore(loadSecretValuesTolerant(onWarn));
-}
-function loadSecretValuesTolerant(onWarn) {
-  try {
-    return loadSecretValues();
-  } catch (err) {
-    onWarn?.(err instanceof Error ? err.message : String(err));
-    return {};
-  }
-}
-function makeStore(map) {
-  return {
-    get: (name) => map[name],
-    names: () => Object.keys(map).sort()
-  };
-}
-function requiredSecretNames(mcpServers) {
-  const names = /* @__PURE__ */ new Set();
-  for (const server of Object.values(mcpServers ?? {})) {
-    const bags = [
-      "env" in server ? server.env : void 0,
-      "headers" in server ? server.headers : void 0
-    ];
-    for (const bag of bags) {
-      for (const value of Object.values(bag ?? {})) {
-        for (const [, name] of value.matchAll(PLACEHOLDER_RE)) names.add(name);
-      }
-    }
-  }
-  return [...names].sort();
-}
-function resolveMcpSecrets(mcpServers, store, serverSecretEnv = {}) {
-  const missing = /* @__PURE__ */ new Set();
-  const secretEnv = { ...serverSecretEnv };
-  let counter = 0;
-  for (const name of Object.keys(serverSecretEnv)) {
-    const n = SECRET_ENV_NAME.exec(name);
-    if (n) counter = Math.max(counter, Number(n[1]));
-  }
-  const interpolate = (value) => value.replace(PLACEHOLDER_RE, (_match, name) => {
-    const resolved = store.get(name);
-    if (resolved === void 0) {
-      missing.add(name);
-      return _match;
-    }
-    return resolved;
-  });
-  const mapBag = (bag) => {
-    const out = {};
-    for (const [k, v] of Object.entries(bag)) out[k] = interpolate(v);
-    return out;
-  };
-  const servers = {};
-  for (const [name, server] of Object.entries(mcpServers)) {
-    const next = { ...server };
-    if ("env" in next && next.env) next.env = mapBag(next.env);
-    if ("url" in next && next.headers) {
-      const headers = {};
-      const fromEnv = { ...next.headersFromEnv };
-      for (const [header, value] of Object.entries(next.headers)) {
-        if (!value.match(PLACEHOLDER_RE)) {
-          headers[header] = value;
-          continue;
-        }
-        const envName = `CABANE_MCP_${++counter}`;
-        secretEnv[envName] = interpolate(value);
-        fromEnv[header] = envName;
-      }
-      next.headers = headers;
-      if (Object.keys(headers).length === 0) delete next.headers;
-      if (Object.keys(fromEnv).length > 0) next.headersFromEnv = fromEnv;
-    }
-    servers[name] = next;
-  }
-  return { servers, secretEnv, missing: [...missing].sort() };
-}
-function missingSecretReason(missing) {
-  const prefix = "missing_secret: ";
-  for (let shown = missing.length; shown >= 0; shown--) {
-    const omitted = missing.length - shown;
-    const parts = [...missing.slice(0, shown), ...omitted > 0 ? [`+${omitted}`] : []];
-    const reason = prefix + parts.join(",");
-    if (reason.length <= ERROR_REASON_MAX) return reason;
-  }
-  return `${prefix}+${missing.length}`;
-}
-var PLACEHOLDER_RE, secretStoreSchema, SECRET_ENV_NAME;
-var init_secrets = __esm({
-  "src/secrets.ts"() {
-    "use strict";
-    init_src();
-    init_config();
-    init_errors();
-    PLACEHOLDER_RE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
-    secretStoreSchema = z17.record(z17.string(), z17.string());
-    SECRET_ENV_NAME = /^CABANE_MCP_(\d+)$/;
-  }
-});
-
-// src/turn-env.ts
-function harnessLoginEnv(store, runtime) {
-  const names = [
-    ...runtime in API_KEY_VARIABLES ? API_KEY_VARIABLES[runtime] : [],
-    GITHUB_TOKEN_NAME
-  ];
-  const env = {};
-  for (const name of names) {
-    const value = store.get(name);
-    if (value) env[name] = value;
-  }
-  return env;
+  return env;
 }
 function turnIdentityEnv(ids) {
   return { CABANE_CONVERSATION_ID: ids.conversationId, CABANE_AGENT_ID: ids.agentId };
@@ -9614,7 +9110,7 @@ var init_turn_runtime_integrity = __esm({
 
 // src/turn-execution.ts
 import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
-import { mkdirSync as mkdirSync9 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9 } from "fs";
 function resolveIdleTimeoutMs(override) {
   return override ?? DEFAULT_AGENT_IDLE_TIMEOUT_MS;
 }
@@ -9671,7 +9167,6 @@ var init_turn_execution = __esm({
     init_errors();
     init_turn_seq_floor();
     init_prepare_hook();
-    init_prepare_failure();
     init_prepared();
     init_secrets();
     init_turn_env();
@@ -9680,7 +9175,6 @@ var init_turn_execution = __esm({
     init_turn_containment();
     init_turn_committer();
     init_turn_runtime_integrity();
-    init_dispatcher();
     PREPARING_TOOL_NAME = "preparing";
     HARNESS_UNAVAILABLE_NOTICE = "**This harness isn't available on the companion.** Check the harness on the device, or choose another harness in the agent's settings. Then reply to try again.";
     NO_TURN_TOKEN_REASON = "no_turn_token: the server issued no turn credential for this turn";
@@ -10078,7 +9572,7 @@ var init_turn_execution = __esm({
       async prepareEnvironment() {
         const { payload, workspaceId, turnId, turnLog } = this;
         const prepareHook = this.opts.local.prepareHook;
-        const pairDir = this.opts.boxed ? this.opts.workRoot : pairDirectory(this.opts.workRoot, {
+        const pairDir = this.opts.dedicatedRoot ? this.opts.workRoot : pairDirectory(this.opts.workRoot, {
           workspaceSlug: this.opts.workspaceSlug,
           agentUsername: this.opts.agentUsername,
           conversationId: payload.conversationId
@@ -10106,10 +9600,10 @@ var init_turn_execution = __esm({
         let hookEnv;
         if (prepareHook) {
           let cached2 = readPrepared(workspaceId, payload.conversationId, payload.agentId);
-          if (cached2 && !checkoutState(cached2.cwd).ok) {
+          if (cached2 && !existsSync12(cached2.cwd)) {
             turnLog.debug(
-              { cwd: cached2.cwd, reason: checkoutState(cached2.cwd).reason },
-              "dispatcher: the prepared checkout is no longer usable \u2014 re-running the prepare hook to restore it"
+              { cwd: cached2.cwd },
+              "dispatcher: the prepared directory is gone \u2014 re-running the prepare hook"
             );
             clearPrepared(workspaceId, payload.conversationId, payload.agentId);
             cached2 = null;
@@ -10117,38 +9611,6 @@ var init_turn_execution = __esm({
           if (cached2) {
             effectiveCwd = cached2.cwd;
             hookEnv = cached2.env;
-            if (prepareHook.validateCached) {
-              const runHook = this.opts.prepareHookRunner ?? runPrepareHook;
-              try {
-                await runPrepareWithReporting(
-                  runHook,
-                  prepareHook,
-                  {
-                    workspaceId,
-                    conversationId: payload.conversationId,
-                    agentId: payload.agentId,
-                    agentUsername: this.opts.agentUsername,
-                    defaultCwd: pairDir,
-                    runtime: this.turnContext.runtime,
-                    triggerEntryPaths: this.turnContext.conversation.triggerEntryPaths ?? [],
-                    title: this.turnContext.conversation.title,
-                    messageBody: this.turnContext.message.body,
-                    prepared: cached2
-                  },
-                  { turnId, deviceId: this.opts.deviceId },
-                  () => {
-                    turnLog.error(
-                      "dispatcher: prepare failure reporter failed; original failure preserved"
-                    );
-                  }
-                );
-              } catch (err) {
-                const reason = err instanceof Error ? err.message : String(err);
-                turnLog.debug({ err: reason }, "dispatcher: prepare hook rejected a prepared turn");
-                const failReason = `prepare_failed: ${reason}`;
-                throw this.concluded(failReason, failReason);
-              }
-            }
           } else {
             const delayMs = this.opts.preparingRowDelayMs ?? DEFAULT_PREPARING_ROW_DELAY_MS;
             let preparingStarted = false;
@@ -10180,33 +9642,17 @@ var init_turn_execution = __esm({
             preparingTimer.unref?.();
             const runHook = this.opts.prepareHookRunner ?? runPrepareHook;
             try {
-              const result = await runPrepareWithReporting(
-                runHook,
-                prepareHook,
-                {
-                  workspaceId,
-                  conversationId: payload.conversationId,
-                  agentId: payload.agentId,
-                  agentUsername: this.opts.agentUsername,
-                  // The pair's own directory, already made, for a hook that only
-                  // wants to add to it.
-                  defaultCwd: pairDir,
-                  runtime: this.turnContext.runtime,
-                  // The trigger message's referenced-entry paths, which a prepare hook
-                  // may key its per-task env off. `[]` from an older API.
-                  triggerEntryPaths: this.turnContext.conversation.triggerEntryPaths ?? [],
-                  title: this.turnContext.conversation.title,
-                  // Where an `env:` directive rides, so a dispatch can ask for its
-                  // environment in words.
-                  messageBody: this.turnContext.message.body
-                },
-                { turnId, deviceId: this.opts.deviceId },
-                () => {
-                  turnLog.error(
-                    "dispatcher: prepare failure reporter failed; original failure preserved"
-                  );
-                }
-              );
+              const result = await runHook(prepareHook, {
+                workspaceId,
+                conversationId: payload.conversationId,
+                agentId: payload.agentId,
+                agentUsername: this.opts.agentUsername,
+                // The pair's own directory, already made, for a hook that only
+                // wants to add to it.
+                defaultCwd: pairDir,
+                runtime: this.turnContext.runtime,
+                title: this.turnContext.conversation.title
+              });
               clearTimeout(preparingTimer);
               if (preparingStarted) reportPreparing("done");
               writePrepared(workspaceId, payload.conversationId, payload.agentId, result);
@@ -10853,150 +10299,17 @@ var init_turn_execution = __esm({
   }
 });
 
-// src/dispatcher.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync12, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
-import { join as join22 } from "path";
-function checkoutState(cwd) {
-  if (!cwd) return { ok: false, reason: "no working directory was resolved for this turn" };
-  if (!existsSync12(cwd)) return { ok: false, reason: `the working directory is gone (${cwd})` };
-  let entries;
-  try {
-    entries = readdirSync2(cwd);
-  } catch (error) {
-    return { ok: false, reason: `${cwd} is unreadable (${error.message})` };
-  }
-  if (entries.length === 0) {
-    return { ok: false, reason: `${cwd} is empty \u2014 a recreated shell, not a prepared directory` };
-  }
-  const gitPath = join22(cwd, ".git");
-  if (!existsSync12(gitPath)) return { ok: true, reason: "usable" };
-  let stat;
-  try {
-    stat = statSync4(gitPath);
-  } catch (error) {
-    return { ok: false, reason: `${gitPath} is unreadable (${error.message})` };
-  }
-  if (stat.isDirectory() && !existsSync12(join22(gitPath, "HEAD")))
-    return { ok: false, reason: `${gitPath} has no HEAD \u2014 an empty shell, not a checkout` };
-  return { ok: true, reason: "usable" };
-}
-function runKey(conversationId, agentId) {
-  return `${conversationId}|${agentId}`;
-}
-var Dispatcher;
-var init_dispatcher = __esm({
-  "src/dispatcher.ts"() {
-    "use strict";
-    init_launch();
-    init_turn_execution();
-    Dispatcher = class {
-      constructor(opts) {
-        this.opts = opts;
-        this.aborts = opts.aborts ?? /* @__PURE__ */ new Map();
-      }
-      opts;
-      // (conversation|agent) → per-turn controllers. A delayed cancel for an old
-      // turn must never reach its successor.
-      aborts;
-      // Pairs already told their session couldn't be saved: the notice is once per
-      // pair, while the rejection repeats every turn.
-      sessionWriteNotified = /* @__PURE__ */ new Set();
-      notifyStart(info) {
-        try {
-          this.opts.observer?.onStart(info);
-        } catch {
-        }
-      }
-      notifyEnd(info) {
-        try {
-          this.opts.observer?.onEnd(info);
-        } catch {
-        }
-      }
-      // The supervisor supplies a stable turnId on both fresh and resumed dispatch.
-      // resumed is separate: only replay seeds sequence/speech recovery from the
-      // prior span. A direct caller omitting turnId gets a fresh id.
-      async handle(payload, opts = {}) {
-        const key = runKey(payload.conversationId, payload.agentId);
-        return runTurnInRunner(
-          this.opts.turn,
-          this.opts.runner,
-          {
-            registerAbort: (turnId, controller) => {
-              let pairAborts = this.aborts.get(key);
-              if (!pairAborts) {
-                pairAborts = /* @__PURE__ */ new Map();
-                this.aborts.set(key, pairAborts);
-              }
-              pairAborts.set(turnId, controller);
-            },
-            releaseAbort: (turnId, controller) => {
-              const pair = this.aborts.get(key);
-              if (pair?.get(turnId) !== controller) return;
-              pair.delete(turnId);
-              if (pair.size === 0) this.aborts.delete(key);
-            },
-            sessionWriteNoticeClaimed: () => this.sessionWriteNotified.has(key),
-            markSessionWriteNotice: () => {
-              this.sessionWriteNotified.add(key);
-            },
-            notifyStart: (info) => this.notifyStart(info),
-            notifyEnd: (info) => this.notifyEnd(info)
-          },
-          payload,
-          { turnId: opts.turnId ?? randomUUID4(), resumed: opts.resumed === true }
-        );
-      }
-      // Cancel the named turn. An older server omits turnId and cancels the pair.
-      cancel(conversationId, agentId, turnId) {
-        const key = runKey(conversationId, agentId);
-        const pair = this.aborts.get(key);
-        if (!pair || pair.size === 0) return false;
-        const controllers = turnId === void 0 ? [...pair.values()] : [pair.get(turnId)];
-        let aborted = false;
-        for (const ac of controllers) {
-          if (!ac) continue;
-          aborted = true;
-          try {
-            ac.abort();
-          } catch {
-          }
-        }
-        return aborted;
-      }
-      // Abort every run in flight in THIS process, whatever its conversation. For
-      // an agent taken off this device: nothing it is still running here is
-      // legitimate, and a cancel frame that arrives after it is dropped from the
-      // roster finds no dispatcher to reach. True if any was aborted.
-      cancelAll() {
-        let aborted = false;
-        for (const pair of this.aborts.values()) {
-          for (const ac of [...pair.values()]) {
-            try {
-              ac.abort();
-              aborted = true;
-            } catch {
-            }
-          }
-        }
-        return aborted;
-      }
-    };
-  }
-});
-
 // src/outbox.ts
 import {
   existsSync as existsSync14,
   mkdirSync as mkdirSync10,
-  readdirSync as readdirSync3,
+  readdirSync as readdirSync2,
   readFileSync as readFileSync11,
   renameSync as renameSync5,
   rmSync as rmSync7,
   writeFileSync as writeFileSync6
 } from "fs";
-import { join as join23 } from "path";
+import { join as join22 } from "path";
 var MAX_ENTRIES, MAX_AGE_MS, Outbox;
 var init_outbox = __esm({
   "src/outbox.ts"() {
@@ -11014,10 +10327,10 @@ var init_outbox = __esm({
       // Resolved lazily (per call) so tests that swap HOME between
       // cases route writes at the right tmpdir.
       dir() {
-        return join23(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
+        return join22(cabaneDir(), "outbox", encodeURIComponent(this.workspaceId));
       }
       fileFor(turnId, seq) {
-        return join23(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
+        return join22(this.dir(), `${encodeURIComponent(turnId)}__${seq}.json`);
       }
       // Persist a commit for later draining. Atomic (temp file + rename) so a
       // concurrent `list()` never reads a half-written entry, then enforces the
@@ -11052,14 +10365,14 @@ var init_outbox = __esm({
         if (!existsSync14(dir2)) return [];
         let names;
         try {
-          names = readdirSync3(dir2);
+          names = readdirSync2(dir2);
         } catch {
           return [];
         }
         const entries = [];
         for (const name of names) {
           if (!name.endsWith(".json")) continue;
-          const full = join23(dir2, name);
+          const full = join22(dir2, name);
           try {
             const parsed = JSON.parse(readFileSync11(full, "utf8"));
             if (parsed && typeof parsed.turnId === "string" && typeof parsed.seq === "number" && typeof parsed.path === "string") {
@@ -11096,7 +10409,7 @@ var init_outbox = __esm({
       maxSeqForTurn(turnId) {
         const dir2 = this.dir();
         if (!existsSync14(dir2)) return 0;
-        const names = readdirSync3(dir2);
+        const names = readdirSync2(dir2);
         const prefix = `${encodeURIComponent(turnId)}__`;
         let max = 0;
         for (const name of names) {
@@ -11117,7 +10430,7 @@ var init_outbox = __esm({
         const dir2 = this.dir();
         if (!existsSync14(dir2)) return 0;
         try {
-          return readdirSync3(dir2).filter((n) => n.endsWith(".json")).length;
+          return readdirSync2(dir2).filter((n) => n.endsWith(".json")).length;
         } catch {
           return 0;
         }
@@ -11166,7 +10479,7 @@ var init_outbox = __esm({
 
 // src/runner/exec-shim.ts
 import { chmodSync as chmodSync6, mkdirSync as mkdirSync18, mkdtempSync, rmSync as rmSync13, writeFileSync as writeFileSync11 } from "fs";
-import { join as join33 } from "path";
+import { join as join32 } from "path";
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -11176,10 +10489,10 @@ function createShimDir() {
   return {
     write(argv) {
       if (!dir2) {
-        mkdirSync18(join33(cabaneDir(), "runner"), { recursive: true });
-        dir2 = mkdtempSync(join33(cabaneDir(), "runner", "turn-"));
+        mkdirSync18(join32(cabaneDir(), "runner"), { recursive: true });
+        dir2 = mkdtempSync(join32(cabaneDir(), "runner", "turn-"));
       }
-      const path = join33(dir2, `exec-${++count}`);
+      const path = join32(dir2, `exec-${++count}`);
       writeFileSync11(path, `#!/bin/sh
 exec ${argv.map(shellQuote).join(" ")} "$@"
 `);
@@ -11346,13 +10659,13 @@ function runnerTurnOptions(input, log2, emit, extras = {}) {
     local: spec.local,
     // The place the runner stands in names its own root and transcript
     // directory when it has them (`PLACE_ENV`); the launcher's host-computed
-    // values are what a runner on the person's own machine gets. A box is one
-    // conversation × agent's, so the turn stands in its root itself.
+    // values are what a runner on the person's own machine gets. A dedicated
+    // root is one conversation × agent's, so the turn stands in it itself.
     workRoot: input.place?.workRoot ?? spec.workRoot,
-    ...input.place?.box ? { boxed: true } : {},
+    ...input.place?.dedicatedRoot ? { dedicatedRoot: true } : {},
     runConfig: spec.runConfig,
-    // The launcher's copy of the device's secrets, when it sent one: a runner
-    // in a box has no `secrets.json` to read.
+    // The launcher's copy of the device's secrets, when it sent one: a wrapped
+    // runner may have no `secrets.json` to read.
     ...input.secrets ? { secretStore: makeStore(input.secrets) } : {},
     // The grants-file entries the launcher read for this dispatch's turn.
     ...input.grants ? { deviceGrants: input.grants } : {},
@@ -12216,7 +11529,7 @@ async function liveCompanionState() {
 // src/commands/setup.ts
 init_cabane_command();
 init_config();
-import { hostname as hostname3 } from "os";
+import { hostname as hostname2 } from "os";
 
 // src/logger.ts
 init_config();
@@ -12442,8 +11755,8 @@ async function claimSetupCode(baseUrl, input) {
     ..."deviceLabel" in body && typeof body.deviceLabel === "string" ? { deviceLabel: body.deviceLabel } : {}
   };
 }
-function deviceLabelFromHostname(hostname4) {
-  const trimmed = hostname4.trim().replace(/\.local$/i, "");
+function deviceLabelFromHostname(hostname3) {
+  const trimmed = hostname3.trim().replace(/\.local$/i, "");
   return trimmed.length ? trimmed.slice(0, 120) : void 0;
 }
 
@@ -12988,7 +12301,7 @@ var emptyHeartbeatStatus = () => ({
 
 // src/supervisor.ts
 init_cabane_command();
-import { hostname as hostname2 } from "os";
+import { hostname } from "os";
 
 // src/log-copy.ts
 init_failure();
@@ -13214,241 +12527,745 @@ function save(deviceId, map) {
     } catch {
     }
   }
-  const path = devicePath(deviceId);
-  const tmp = `${path}.${process.pid}.tmp`;
-  try {
-    writeFileSync3(tmp, JSON.stringify(map, null, 2) + "\n", { mode: 384 });
+  const path = devicePath(deviceId);
+  const tmp = `${path}.${process.pid}.tmp`;
+  try {
+    writeFileSync3(tmp, JSON.stringify(map, null, 2) + "\n", { mode: 384 });
+    try {
+      chmodSync3(tmp, 384);
+    } catch {
+    }
+    renameSync3(tmp, path);
+  } catch (err) {
+    try {
+      rmSync4(tmp, { force: true });
+    } catch {
+    }
+    throw err;
+  }
+}
+function getCredential(deviceId, agentId) {
+  return load(deviceId)[agentId] ?? null;
+}
+function setCredential(deviceId, agentId, pat) {
+  if (read(devicePath(deviceId))?.[agentId] === pat) return;
+  const map = load(deviceId);
+  map[agentId] = pat;
+  save(deviceId, map);
+}
+function pruneCredentials(deviceId, keepAgentIds) {
+  const keep = new Set(keepAgentIds);
+  if (keep.size === 0) return [];
+  const own = read(devicePath(deviceId));
+  const map = own ?? load(deviceId);
+  const removed = Object.keys(map).filter((id) => !keep.has(id));
+  for (const id of removed) delete map[id];
+  if (removed.length > 0 || own === null) save(deviceId, map);
+  return removed;
+}
+function clearCredentials() {
+  rmSync4(credentialsDir(), { recursive: true, force: true });
+  if (existsSync7(legacyPath())) writeFileSync3(legacyPath(), "", { mode: 384 });
+}
+
+// src/dispatch-dedupe.ts
+init_config();
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync as renameSync4, existsSync as existsSync8 } from "fs";
+import { join as join13 } from "path";
+var MAX_IDS = 256;
+function dir(log2) {
+  return join13(cabaneDir(), log2);
+}
+function pathFor(log2, workspaceId) {
+  return join13(dir(log2), encodeURIComponent(workspaceId));
+}
+function readIds(log2, workspaceId) {
+  const path = pathFor(log2, workspaceId);
+  if (!existsSync8(path)) return [];
+  try {
+    return readFileSync5(path, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+  } catch {
+    return [];
+  }
+}
+function has(log2, workspaceId, eventId) {
+  return readIds(log2, workspaceId).includes(eventId);
+}
+function mark(log2, workspaceId, eventId) {
+  const ids = readIds(log2, workspaceId);
+  if (ids.includes(eventId)) return;
+  ids.push(eventId);
+  const trimmed = ids.length > MAX_IDS ? ids.slice(-MAX_IDS) : ids;
+  mkdirSync6(dir(log2), { recursive: true });
+  writeFileSync4(pathFor(log2, workspaceId), trimmed.join("\n") + "\n", "utf8");
+}
+function hasDispatched(workspaceId, eventId) {
+  return has("dispatched", workspaceId, eventId);
+}
+function markDispatched(workspaceId, eventId) {
+  mark("dispatched", workspaceId, eventId);
+}
+function hasCompleted(workspaceId, eventId) {
+  return has("completed", workspaceId, eventId);
+}
+function markCompleted(workspaceId, eventId) {
+  mark("completed", workspaceId, eventId);
+  forgetTurnId(workspaceId, eventId);
+}
+var MAX_RESUME_ATTEMPTS = 3;
+function resumeDir() {
+  return join13(cabaneDir(), "resume-attempts");
+}
+function resumePathFor(workspaceId) {
+  return join13(resumeDir(), encodeURIComponent(workspaceId));
+}
+function readResumeCounts(workspaceId) {
+  const out = /* @__PURE__ */ new Map();
+  const path = resumePathFor(workspaceId);
+  if (!existsSync8(path)) return out;
+  try {
+    for (const line of readFileSync5(path, "utf8").split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const tab = trimmed.lastIndexOf("	");
+      if (tab <= 0) continue;
+      const id = trimmed.slice(0, tab);
+      const count = Number.parseInt(trimmed.slice(tab + 1), 10);
+      if (id && Number.isFinite(count)) out.set(id, count);
+    }
+  } catch {
+    return out;
+  }
+  return out;
+}
+function bumpResumeAttempt(workspaceId, eventId) {
+  const counts = readResumeCounts(workspaceId);
+  const next = (counts.get(eventId) ?? 0) + 1;
+  counts.set(eventId, next);
+  const entries = [...counts.entries()];
+  const trimmed = entries.length > MAX_IDS ? entries.slice(-MAX_IDS) : entries;
+  mkdirSync6(resumeDir(), { recursive: true });
+  writeFileSync4(
+    resumePathFor(workspaceId),
+    trimmed.map(([id, c]) => `${id}	${c}`).join("\n") + "\n",
+    "utf8"
+  );
+  return next;
+}
+function turnDir() {
+  return join13(cabaneDir(), "turns");
+}
+function turnPathFor(workspaceId) {
+  return join13(turnDir(), encodeURIComponent(workspaceId));
+}
+var TURN_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function readTurnIds(workspaceId) {
+  const out = /* @__PURE__ */ new Map();
+  const path = turnPathFor(workspaceId);
+  if (!existsSync8(path)) return out;
+  try {
+    for (const line of readFileSync5(path, "utf8").split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const tab = trimmed.lastIndexOf("	");
+      if (tab <= 0) continue;
+      const id = trimmed.slice(0, tab);
+      const turnId = trimmed.slice(tab + 1);
+      if (id && TURN_ID_RE.test(turnId)) out.set(id, turnId);
+    }
+  } catch {
+    return out;
+  }
+  return out;
+}
+function turnIdForEvent(workspaceId, eventId) {
+  return readTurnIds(workspaceId).get(eventId) ?? null;
+}
+var TURN_ID_OVERFLOW_WARN = 8192;
+function writeTurnIds(workspaceId, turns) {
+  const entries = [...turns.entries()];
+  mkdirSync6(turnDir(), { recursive: true });
+  const path = turnPathFor(workspaceId);
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync4(tmp, entries.map(([id, t]) => `${id}	${t}`).join("\n") + "\n", "utf8");
+  renameSync4(tmp, path);
+  return entries.length;
+}
+function rememberTurnId(workspaceId, eventId, turnId) {
+  const turns = readTurnIds(workspaceId);
+  if (turns.get(eventId) === turnId) return turns.size;
+  turns.set(eventId, turnId);
+  return writeTurnIds(workspaceId, turns);
+}
+function forgetTurnId(workspaceId, eventId) {
+  const turns = readTurnIds(workspaceId);
+  if (!turns.delete(eventId)) return;
+  writeTurnIds(workspaceId, turns);
+}
+function noResume() {
+  return process.env.CABANE_COMPANION_NO_RESUME === "1";
+}
+
+// src/supervisor.ts
+init_bundled_binaries();
+init_install_kind();
+
+// src/connector-health.ts
+init_src();
+var ConnectorHealthStore = class {
+  byRuntime = /* @__PURE__ */ new Map();
+  // Record a settled turn's outcome for `runtime`. A success heals to `ok`; a
+  // classified failure sets `limited`(+reset) / `auth_expired` with the reason as
+  // `last_error`; anything else (a user Stop, a timeout, an unclassified error)
+  // leaves the last-known status untouched — we only ever move state on real
+  // evidence.
+  recordSettle(runtime, outcome) {
+    if (outcome.ok) {
+      this.byRuntime.set(runtime, { quotaState: "ok", limitedUntil: null, lastError: null });
+      return;
+    }
+    const failure = decodeFailureReason(outcome.errorReason);
+    if (!failure) return;
+    const quota = quotaForFailure(failure);
+    if (!quota) return;
+    this.byRuntime.set(runtime, {
+      quotaState: quota.quotaState,
+      limitedUntil: quota.limitedUntil,
+      lastError: outcome.errorReason ?? null
+    });
+  }
+  // The store's current opinion for one runtime, or undefined when it has
+  // no observation. Read by the dispatcher at idle-timeout fire: an idle reap
+  // while this runtime is definitively `limited` (a present, future `limitedUntil`
+  // recorded by a sibling/earlier turn's classified cap settle) is the account cap
+  // surfacing as silence, not a genuine hang — so the settle reclassifies to
+  // `usage_capped` instead of `timeout_idle`. Returns the stored shape verbatim
+  // (the dispatcher reads `quotaState` + `limitedUntil` and applies its own
+  // future-instant gate); a read never mutates state.
+  lookup(runtime) {
+    return this.byRuntime.get(runtime);
+  }
+  // The per-connector reports to attach to a heartbeat — one entry per runtime the
+  // companion has an observation for. Empty until the first classified failure/heal,
+  // so a companion that has seen nothing sends no `connectors[]` and the server's
+  // manifest synthesis (status-less rows) is unaffected.
+  reports() {
+    return [...this.byRuntime.entries()].map(([runtime, h]) => ({
+      runtime,
+      quotaState: h.quotaState,
+      limitedUntil: h.limitedUntil,
+      lastError: h.lastError
+    }));
+  }
+};
+
+// src/dispatcher.ts
+import { randomUUID as randomUUID4 } from "crypto";
+
+// src/runner/launch.ts
+init_src();
+init_opencode_lock();
+init_api_error_shape();
+init_errors();
+init_boot_id();
+init_turn_containment();
+init_protocol();
+import { createInterface } from "readline";
+function selfRunnerCommand() {
+  const script = process.argv[1];
+  if (!script) throw new Error("runner: cannot tell which script started this companion");
+  return [process.execPath, ...process.execArgv, script, "run-turn"];
+}
+function wrappedRunnerCommand(prefix, own) {
+  return [...prefix ?? [], ...own];
+}
+var WRAPPED_ENV_DROPPED = [
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CODEX_API_KEY",
+  "GH_TOKEN",
+  "GITHUB_TOKEN",
+  "DBUS_SESSION_BUS_ADDRESS",
+  "XDG_RUNTIME_DIR"
+];
+function runnerExecEnv(base, wrapped) {
+  const env = {};
+  for (const [k, v] of Object.entries(base)) {
+    if (v === void 0) continue;
+    if (wrapped && WRAPPED_ENV_DROPPED.includes(k)) continue;
+    env[k] = v;
+  }
+  return env;
+}
+function healthSnapshot(store) {
+  const out = {};
+  for (const r of store?.reports() ?? []) {
+    out[r.runtime] = {
+      quotaState: r.quotaState ?? "unknown",
+      limitedUntil: r.limitedUntil ?? null,
+      lastError: r.lastError ?? null
+    };
+  }
+  return out;
+}
+function runnerSpec(opts, launch, duties, runnerId) {
+  return {
+    runnerId,
+    ...opts.deviceId ? { deviceId: opts.deviceId } : {},
+    bootId,
+    workspaceId: opts.workspaceId,
+    workspaceSlug: opts.workspaceSlug,
+    agentId: opts.agentId,
+    agentUsername: opts.agentUsername,
+    agentName: String(opts.log.bindings().agentName ?? opts.agentUsername),
+    local: opts.local,
+    runConfig: opts.runConfig,
+    workRoot: opts.workRoot,
+    ...opts.opencodeServerUrl ? { opencodeServerUrl: opts.opencodeServerUrl } : {},
+    // Read now, per turn, the way adapter selection reads them.
+    claudeCodeAvailable: opts.claudeCodeAvailable?.() ?? true,
+    codexAvailable: opts.codexAvailable?.() ?? false,
+    ...opts.idleTimeoutMs !== void 0 ? { idleTimeoutMs: opts.idleTimeoutMs } : {},
+    ...opts.totalTimeoutMs !== void 0 ? { totalTimeoutMs: opts.totalTimeoutMs } : {},
+    ...opts.leaseRenewalMs !== void 0 ? { leaseRenewalMs: opts.leaseRenewalMs } : {},
+    ...opts.preparingRowDelayMs !== void 0 ? { preparingRowDelayMs: opts.preparingRowDelayMs } : {},
+    transcripts: opts.transcriptDir !== void 0,
+    logLevel: opts.log.level,
+    connectorHealth: healthSnapshot(launch.connectorHealth),
+    sessionWriteNoticeClaimed: duties.sessionWriteNoticeClaimed()
+  };
+}
+var PINO_LEVELS = {
+  10: "trace",
+  20: "debug",
+  30: "info",
+  40: "warn",
+  50: "error",
+  60: "fatal"
+};
+function relayRunnerLog(line, log2) {
+  if (!line.trim()) return;
+  let record = null;
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed && typeof parsed === "object") record = parsed;
+  } catch {
+    record = null;
+  }
+  if (!record || typeof record.level !== "number") {
+    log2.debug({ runnerStderr: line }, "runner: output");
+    return;
+  }
+  const {
+    level,
+    msg,
+    time: _time,
+    pid: _pid,
+    hostname: _hostname,
+    agentName: _agentName,
+    ...fields
+  } = record;
+  const method = PINO_LEVELS[level] ?? "info";
+  log2[method](fields, typeof msg === "string" ? msg : "");
+}
+function lines(stream, onLine) {
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  rl.on("line", onLine);
+  return new Promise((resolve2) => rl.once("close", resolve2));
+}
+function giveBackLocks(locks, prefix, remote, launch, log2) {
+  locks.withdraw(prefix);
+  const stop2 = launch.stopRemoteSession ?? ((url, id) => stopRemoteOpencodeSession(url, id));
+  for (const { key, owner } of locks.heldBy(prefix)) {
+    const left = remote.filter((r) => opencodeLockKey(r.serverUrl) === key);
+    if (!left.length) {
+      locks.release(owner);
+      continue;
+    }
+    void (async () => {
+      for (let attempt = 1; ; attempt++) {
+        const stopped = await Promise.all(left.map((r) => stop2(r.serverUrl, r.sessionId))).catch(
+          () => [false]
+        );
+        if (stopped.every(Boolean)) break;
+        if (attempt === 1)
+          log2.warn(
+            { key, sessions: left.map((r) => r.sessionId) },
+            "runner: a dead runner left work on a shared server that could not be confirmed stopped; holding the server until it is"
+          );
+        await new Promise((resolve2) => setTimeout(resolve2, launch.reconcileRetryMs ?? 5e3));
+      }
+      locks.release(owner);
+    })();
+  }
+}
+async function mintForRunner(opts, payload, handleOpts, signal, log2) {
+  try {
+    const minted = await opts.api.mintRunnerCredential({
+      conversationId: payload.conversationId,
+      messageId: payload.messageId,
+      ...payload.episode !== void 0 ? { episode: payload.episode } : {},
+      // The one turn the credential will operate: this run's.
+      turnId: handleOpts.turnId
+    });
+    return {
+      ok: true,
+      credential: minted.credential,
+      runnerId: minted.runnerId,
+      deviceGrants: minted.deviceGrants ?? []
+    };
+  } catch (err) {
+    if (signal.aborted) return { ok: false, reason: "cancelled" };
+    const status2 = err instanceof ApiError ? err.status : 0;
+    if (status2 === 404) return { ok: false, reason: "runner_credential_not_found" };
+    if (status2 === 409 && apiErrorCode(err) === "dispatch_not_admitted")
+      return { ok: false, reason: "runner_credential_not_admitted" };
+    log2.warn(apiErrorLogFields(err), "runner: couldn't get a credential for the turn's runner");
+    const reason = `fetch_failed: ${describeError(err)}`;
+    return { ok: false, reason, errorReason: reason };
+  }
+}
+async function settleUnstarted(opts, payload, turnId, errorReason, log2) {
+  try {
+    await opts.api.setActiveRun(opts.workspaceId, payload.conversationId, payload.agentId, {
+      activeRunStartedAt: null,
+      turnId,
+      outcome: "failed",
+      ...errorReason ? { errorReason: errorReason.slice(0, ERROR_REASON_MAX) } : {},
+      readThrough: payload.messageId
+    });
+  } catch (err) {
+    log2.warn(
+      { ...apiErrorLogFields(err), turnId },
+      "Couldn't update the turn's status in Cabane. Check the conversation before trying again."
+    );
+  }
+}
+async function runTurnInRunner(opts, launch, duties, payload, handleOpts) {
+  const startedAt = Date.now();
+  const { turnId } = handleOpts;
+  const oomKilled = (id) => (launch.oomKilled ?? turnScopeOomKilled)(id).catch(() => false);
+  const log2 = opts.log.child({
+    workspaceId: opts.workspaceId,
+    conversationId: payload.conversationId,
+    agentId: payload.agentId,
+    messageId: payload.messageId
+  });
+  const controller = new AbortController();
+  duties.registerAbort(turnId, controller);
+  const stopRunner = new AbortController();
+  let ready = false;
+  let child;
+  let stopAnnounced = false;
+  const announceStop = () => {
+    if (stopAnnounced || !child?.stdin.writable) return;
+    stopAnnounced = true;
+    child.stdin.write(encodeLauncherMessage({ cabaneLauncher: "stop" }));
+  };
+  const forwardStop = () => {
+    announceStop();
+    if (ready) stopRunner.abort();
+  };
+  controller.signal.addEventListener("abort", forwardStop, { once: true });
+  const attempt = {
+    workspaceId: opts.workspaceId,
+    conversationId: payload.conversationId,
+    agentId: payload.agentId,
+    turnId
+  };
+  const minted = await mintForRunner(opts, payload, handleOpts, controller.signal, log2);
+  if (!minted.ok) {
+    controller.signal.removeEventListener("abort", forwardStop);
+    duties.releaseAbort(turnId, controller);
+    const durationMs2 = Date.now() - startedAt;
+    await settleUnstarted(opts, payload, turnId, minted.errorReason, log2);
+    duties.notifyEnd({ id: payload.messageId, ok: false, durationMs: durationMs2, reason: minted.reason });
+    return { ok: false, durationMs: durationMs2, reason: minted.reason };
+  }
+  let result;
+  let thrown;
+  let code;
+  let handle;
+  const groups = [];
+  const remote = [];
+  const lockOwner = (id) => `${turnId}#${id}`;
+  const locks = launch.locks;
+  try {
+    handle = await launch.provider.acquire(attempt);
+  } catch (err) {
+    const reason2 = `runner_unavailable: ${describeError(err)}`;
+    log2.warn(
+      { turnId, provider: launch.provider.name, err: describeError(err) },
+      "runner: no place to run the turn"
+    );
+    controller.signal.removeEventListener("abort", forwardStop);
+    duties.releaseAbort(turnId, controller);
+    await settleUnstarted(opts, payload, turnId, reason2, log2);
+    await launch.reportRunnerGone?.({
+      workspaceId: opts.workspaceId,
+      conversationId: payload.conversationId,
+      agentId: payload.agentId,
+      messageId: payload.messageId,
+      runnerId: minted.runnerId,
+      reason: "provider_failed"
+    });
+    const durationMs2 = Date.now() - startedAt;
+    duties.notifyEnd({ id: payload.messageId, ok: false, durationMs: durationMs2, reason: reason2 });
+    return { ok: false, durationMs: durationMs2, reason: reason2 };
+  }
+  try {
+    const wrapped = launch.wrapped === true;
+    const env = runnerExecEnv(launch.env ?? process.env, wrapped);
+    const grants = minted.deviceGrants.length > 0 ? launch.grants?.(minted.deviceGrants) ?? {} : {};
+    const input = {
+      baseUrl: opts.baseUrl,
+      credential: minted.credential,
+      ...wrapped ? { secrets: launch.secrets?.() ?? {} } : {},
+      ...Object.keys(grants).length > 0 ? { grants } : {},
+      dispatch: payload,
+      turnId,
+      resumed: handleOpts.resumed,
+      spec: runnerSpec(opts, launch, duties, minted.runnerId)
+    };
+    Object.assign(env, runnerEnv(input));
+    const running = launch.provider.exec(handle, launch.command, env, {
+      signal: stopRunner.signal,
+      stdin: runnerStdin(input)
+    });
+    child = running;
+    if (controller.signal.aborted) announceStop();
+    log2.debug(
+      { turnId, runnerPid: running.pid, provider: launch.provider.name },
+      "runner: started"
+    );
+    const stdoutDone = lines(running.stdout, (line) => {
+      const event = decodeRunnerEvent(line);
+      if (!event) {
+        log2.debug({ runnerStdout: line }, "runner: output");
+        return;
+      }
+      switch (event.cabaneRunner) {
+        case "ready":
+          ready = true;
+          if (controller.signal.aborted) stopRunner.abort();
+          return;
+        case "start":
+          duties.notifyStart({
+            id: event.id,
+            conversationId: event.conversationId,
+            message: event.message
+          });
+          return;
+        case "end": {
+          const { cabaneRunner: _kind, ...info } = event;
+          duties.notifyEnd(info);
+          return;
+        }
+        case "session_write_notice":
+          duties.markSessionWriteNotice();
+          return;
+        case "connector_health":
+          launch.connectorHealth?.recordSettle(event.runtime, {
+            ok: event.ok,
+            errorReason: event.errorReason
+          });
+          return;
+        case "result":
+          result = event.result;
+          return;
+        case "error":
+          thrown = event.message;
+          return;
+        case "lock":
+          if (!locks) {
+            log2.warn(
+              { key: event.key },
+              "runner: asked for a device lock this launcher has none of"
+            );
+            return;
+          }
+          locks.request(
+            event.key,
+            lockOwner(event.id),
+            () => running.stdin.write(encodeLauncherMessage({ cabaneLauncher: "granted", id: event.id }))
+          );
+          return;
+        case "unlock":
+          locks?.release(lockOwner(event.id));
+          return;
+        case "process_group":
+          if (!wrapped) groups.push(event.pgid);
+          return;
+        case "remote_session":
+          remote.push({ serverUrl: event.serverUrl, sessionId: event.sessionId });
+          return;
+        case "terminated":
+          void oomKilled(turnId).then((oom) => {
+            if (running.stdin.writable) {
+              running.stdin.write(
+                encodeLauncherMessage({
+                  cabaneLauncher: "cause",
+                  cause: oom ? "out_of_memory" : null
+                })
+              );
+            }
+          });
+          return;
+      }
+    });
+    const stderrDone = lines(running.stderr, (line) => relayRunnerLog(line, opts.log));
+    code = await running.exit;
+    await Promise.all([stdoutDone, stderrDone]);
+  } finally {
+    if (locks) giveBackLocks(locks, `${turnId}#`, remote, launch, log2);
+    child?.stdin.end();
+    controller.signal.removeEventListener("abort", forwardStop);
+    duties.releaseAbort(turnId, controller);
+    await launch.provider.release(handle, { destroy: false }).catch(
+      (err) => log2.warn({ err: describeError(err) }, "runner: couldn't give its place back")
+    );
+  }
+  if (result) return result;
+  const durationMs = Date.now() - startedAt;
+  const stopped = controller.signal.aborted && thrown === void 0;
+  const reason = stopped ? "cancelled" : thrown !== void 0 ? `runner_failed: ${thrown}` : await oomKilled(turnId) ? "out_of_memory" : `runner_exited: ${code}`;
+  await child?.reap(groups);
+  const reaped = await (launch.reapTurn ?? reapTurnScopes)(turnId).catch((err) => ({
+    failures: [err instanceof Error ? err.message : String(err)]
+  }));
+  if (reaped.failures.length) {
+    log2.warn(
+      { turnId, failures: reaped.failures },
+      "runner: couldn't stop what the dead runner's turn left running"
+    );
+  }
+  try {
+    await opts.api.setActiveRun(opts.workspaceId, payload.conversationId, payload.agentId, {
+      activeRunStartedAt: null,
+      turnId,
+      ...stopped ? { outcome: "interrupted" } : { outcome: "failed", errorReason: reason.slice(0, ERROR_REASON_MAX) },
+      readThrough: payload.messageId
+    });
+  } catch (err) {
+    log2.warn(
+      { ...apiErrorLogFields(err), turnId },
+      "Couldn't update the turn's status in Cabane. Check the conversation before trying again."
+    );
+  }
+  await launch.reportRunnerGone?.({
+    workspaceId: opts.workspaceId,
+    conversationId: payload.conversationId,
+    agentId: payload.agentId,
+    messageId: payload.messageId,
+    runnerId: minted.runnerId,
+    reason: "exited"
+  });
+  if (thrown !== void 0) throw new Error(thrown);
+  if (stopped) log2.info({ turnId, code }, "runner: stopped before it could report");
+  else log2.warn({ turnId, code }, "runner: exited without reporting a result");
+  duties.notifyEnd({ id: payload.messageId, ok: false, durationMs, reason });
+  return { ok: false, durationMs, reason };
+}
+
+// src/dispatcher.ts
+init_turn_execution();
+function runKey(conversationId, agentId) {
+  return `${conversationId}|${agentId}`;
+}
+var Dispatcher = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.aborts = opts.aborts ?? /* @__PURE__ */ new Map();
+  }
+  opts;
+  // (conversation|agent) → per-turn controllers. A delayed cancel for an old
+  // turn must never reach its successor.
+  aborts;
+  // Pairs already told their session couldn't be saved: the notice is once per
+  // pair, while the rejection repeats every turn.
+  sessionWriteNotified = /* @__PURE__ */ new Set();
+  notifyStart(info) {
     try {
-      chmodSync3(tmp, 384);
+      this.opts.observer?.onStart(info);
     } catch {
     }
-    renameSync3(tmp, path);
-  } catch (err) {
+  }
+  notifyEnd(info) {
     try {
-      rmSync4(tmp, { force: true });
+      this.opts.observer?.onEnd(info);
     } catch {
     }
-    throw err;
-  }
-}
-function getCredential(deviceId, agentId) {
-  return load(deviceId)[agentId] ?? null;
-}
-function setCredential(deviceId, agentId, pat) {
-  if (read(devicePath(deviceId))?.[agentId] === pat) return;
-  const map = load(deviceId);
-  map[agentId] = pat;
-  save(deviceId, map);
-}
-function pruneCredentials(deviceId, keepAgentIds) {
-  const keep = new Set(keepAgentIds);
-  if (keep.size === 0) return [];
-  const own = read(devicePath(deviceId));
-  const map = own ?? load(deviceId);
-  const removed = Object.keys(map).filter((id) => !keep.has(id));
-  for (const id of removed) delete map[id];
-  if (removed.length > 0 || own === null) save(deviceId, map);
-  return removed;
-}
-function clearCredentials() {
-  rmSync4(credentialsDir(), { recursive: true, force: true });
-  if (existsSync7(legacyPath())) writeFileSync3(legacyPath(), "", { mode: 384 });
-}
-
-// src/dispatch-dedupe.ts
-init_config();
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync as renameSync4, existsSync as existsSync8 } from "fs";
-import { join as join13 } from "path";
-var MAX_IDS = 256;
-function dir(log2) {
-  return join13(cabaneDir(), log2);
-}
-function pathFor(log2, workspaceId) {
-  return join13(dir(log2), encodeURIComponent(workspaceId));
-}
-function readIds(log2, workspaceId) {
-  const path = pathFor(log2, workspaceId);
-  if (!existsSync8(path)) return [];
-  try {
-    return readFileSync5(path, "utf8").split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
-  } catch {
-    return [];
   }
-}
-function has(log2, workspaceId, eventId) {
-  return readIds(log2, workspaceId).includes(eventId);
-}
-function mark(log2, workspaceId, eventId) {
-  const ids = readIds(log2, workspaceId);
-  if (ids.includes(eventId)) return;
-  ids.push(eventId);
-  const trimmed = ids.length > MAX_IDS ? ids.slice(-MAX_IDS) : ids;
-  mkdirSync6(dir(log2), { recursive: true });
-  writeFileSync4(pathFor(log2, workspaceId), trimmed.join("\n") + "\n", "utf8");
-}
-function hasDispatched(workspaceId, eventId) {
-  return has("dispatched", workspaceId, eventId);
-}
-function markDispatched(workspaceId, eventId) {
-  mark("dispatched", workspaceId, eventId);
-}
-function hasCompleted(workspaceId, eventId) {
-  return has("completed", workspaceId, eventId);
-}
-function markCompleted(workspaceId, eventId) {
-  mark("completed", workspaceId, eventId);
-  forgetTurnId(workspaceId, eventId);
-}
-var MAX_RESUME_ATTEMPTS = 3;
-function resumeDir() {
-  return join13(cabaneDir(), "resume-attempts");
-}
-function resumePathFor(workspaceId) {
-  return join13(resumeDir(), encodeURIComponent(workspaceId));
-}
-function readResumeCounts(workspaceId) {
-  const out = /* @__PURE__ */ new Map();
-  const path = resumePathFor(workspaceId);
-  if (!existsSync8(path)) return out;
-  try {
-    for (const line of readFileSync5(path, "utf8").split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      const tab = trimmed.lastIndexOf("	");
-      if (tab <= 0) continue;
-      const id = trimmed.slice(0, tab);
-      const count = Number.parseInt(trimmed.slice(tab + 1), 10);
-      if (id && Number.isFinite(count)) out.set(id, count);
-    }
-  } catch {
-    return out;
+  // The supervisor supplies a stable turnId on both fresh and resumed dispatch.
+  // resumed is separate: only replay seeds sequence/speech recovery from the
+  // prior span. A direct caller omitting turnId gets a fresh id.
+  async handle(payload, opts = {}) {
+    const key = runKey(payload.conversationId, payload.agentId);
+    return runTurnInRunner(
+      this.opts.turn,
+      this.opts.runner,
+      {
+        registerAbort: (turnId, controller) => {
+          let pairAborts = this.aborts.get(key);
+          if (!pairAborts) {
+            pairAborts = /* @__PURE__ */ new Map();
+            this.aborts.set(key, pairAborts);
+          }
+          pairAborts.set(turnId, controller);
+        },
+        releaseAbort: (turnId, controller) => {
+          const pair = this.aborts.get(key);
+          if (pair?.get(turnId) !== controller) return;
+          pair.delete(turnId);
+          if (pair.size === 0) this.aborts.delete(key);
+        },
+        sessionWriteNoticeClaimed: () => this.sessionWriteNotified.has(key),
+        markSessionWriteNotice: () => {
+          this.sessionWriteNotified.add(key);
+        },
+        notifyStart: (info) => this.notifyStart(info),
+        notifyEnd: (info) => this.notifyEnd(info)
+      },
+      payload,
+      { turnId: opts.turnId ?? randomUUID4(), resumed: opts.resumed === true }
+    );
   }
-  return out;
-}
-function bumpResumeAttempt(workspaceId, eventId) {
-  const counts = readResumeCounts(workspaceId);
-  const next = (counts.get(eventId) ?? 0) + 1;
-  counts.set(eventId, next);
-  const entries = [...counts.entries()];
-  const trimmed = entries.length > MAX_IDS ? entries.slice(-MAX_IDS) : entries;
-  mkdirSync6(resumeDir(), { recursive: true });
-  writeFileSync4(
-    resumePathFor(workspaceId),
-    trimmed.map(([id, c]) => `${id}	${c}`).join("\n") + "\n",
-    "utf8"
-  );
-  return next;
-}
-function turnDir() {
-  return join13(cabaneDir(), "turns");
-}
-function turnPathFor(workspaceId) {
-  return join13(turnDir(), encodeURIComponent(workspaceId));
-}
-var TURN_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function readTurnIds(workspaceId) {
-  const out = /* @__PURE__ */ new Map();
-  const path = turnPathFor(workspaceId);
-  if (!existsSync8(path)) return out;
-  try {
-    for (const line of readFileSync5(path, "utf8").split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      const tab = trimmed.lastIndexOf("	");
-      if (tab <= 0) continue;
-      const id = trimmed.slice(0, tab);
-      const turnId = trimmed.slice(tab + 1);
-      if (id && TURN_ID_RE.test(turnId)) out.set(id, turnId);
+  // Cancel the named turn. An older server omits turnId and cancels the pair.
+  cancel(conversationId, agentId, turnId) {
+    const key = runKey(conversationId, agentId);
+    const pair = this.aborts.get(key);
+    if (!pair || pair.size === 0) return false;
+    const controllers = turnId === void 0 ? [...pair.values()] : [pair.get(turnId)];
+    let aborted = false;
+    for (const ac of controllers) {
+      if (!ac) continue;
+      aborted = true;
+      try {
+        ac.abort();
+      } catch {
+      }
     }
-  } catch {
-    return out;
-  }
-  return out;
-}
-function turnIdForEvent(workspaceId, eventId) {
-  return readTurnIds(workspaceId).get(eventId) ?? null;
-}
-var TURN_ID_OVERFLOW_WARN = 8192;
-function writeTurnIds(workspaceId, turns) {
-  const entries = [...turns.entries()];
-  mkdirSync6(turnDir(), { recursive: true });
-  const path = turnPathFor(workspaceId);
-  const tmp = `${path}.${process.pid}.tmp`;
-  writeFileSync4(tmp, entries.map(([id, t]) => `${id}	${t}`).join("\n") + "\n", "utf8");
-  renameSync4(tmp, path);
-  return entries.length;
-}
-function rememberTurnId(workspaceId, eventId, turnId) {
-  const turns = readTurnIds(workspaceId);
-  if (turns.get(eventId) === turnId) return turns.size;
-  turns.set(eventId, turnId);
-  return writeTurnIds(workspaceId, turns);
-}
-function forgetTurnId(workspaceId, eventId) {
-  const turns = readTurnIds(workspaceId);
-  if (!turns.delete(eventId)) return;
-  writeTurnIds(workspaceId, turns);
-}
-function noResume() {
-  return process.env.CABANE_COMPANION_NO_RESUME === "1";
-}
-
-// src/supervisor.ts
-init_bundled_binaries();
-init_install_kind();
-
-// src/connector-health.ts
-init_src();
-var ConnectorHealthStore = class {
-  byRuntime = /* @__PURE__ */ new Map();
-  // Record a settled turn's outcome for `runtime`. A success heals to `ok`; a
-  // classified failure sets `limited`(+reset) / `auth_expired` with the reason as
-  // `last_error`; anything else (a user Stop, a timeout, an unclassified error)
-  // leaves the last-known status untouched — we only ever move state on real
-  // evidence.
-  recordSettle(runtime, outcome) {
-    if (outcome.ok) {
-      this.byRuntime.set(runtime, { quotaState: "ok", limitedUntil: null, lastError: null });
-      return;
+    return aborted;
+  }
+  // Abort every run in flight in THIS process, whatever its conversation. For
+  // an agent taken off this device: nothing it is still running here is
+  // legitimate, and a cancel frame that arrives after it is dropped from the
+  // roster finds no dispatcher to reach. True if any was aborted.
+  cancelAll() {
+    let aborted = false;
+    for (const pair of this.aborts.values()) {
+      for (const ac of [...pair.values()]) {
+        try {
+          ac.abort();
+          aborted = true;
+        } catch {
+        }
+      }
     }
-    const failure = decodeFailureReason(outcome.errorReason);
-    if (!failure) return;
-    const quota = quotaForFailure(failure);
-    if (!quota) return;
-    this.byRuntime.set(runtime, {
-      quotaState: quota.quotaState,
-      limitedUntil: quota.limitedUntil,
-      lastError: outcome.errorReason ?? null
-    });
-  }
-  // The store's current opinion for one runtime, or undefined when it has
-  // no observation. Read by the dispatcher at idle-timeout fire: an idle reap
-  // while this runtime is definitively `limited` (a present, future `limitedUntil`
-  // recorded by a sibling/earlier turn's classified cap settle) is the account cap
-  // surfacing as silence, not a genuine hang — so the settle reclassifies to
-  // `usage_capped` instead of `timeout_idle`. Returns the stored shape verbatim
-  // (the dispatcher reads `quotaState` + `limitedUntil` and applies its own
-  // future-instant gate); a read never mutates state.
-  lookup(runtime) {
-    return this.byRuntime.get(runtime);
-  }
-  // The per-connector reports to attach to a heartbeat — one entry per runtime the
-  // companion has an observation for. Empty until the first classified failure/heal,
-  // so a companion that has seen nothing sends no `connectors[]` and the server's
-  // manifest synthesis (status-less rows) is unaffected.
-  reports() {
-    return [...this.byRuntime.entries()].map(([runtime, h]) => ({
-      runtime,
-      quotaState: h.quotaState,
-      limitedUntil: h.limitedUntil,
-      lastError: h.lastError
-    }));
+    return aborted;
   }
 };
 
-// src/supervisor.ts
-init_dispatcher();
-
 // src/host-report.ts
 import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
 import { userInfo as userInfo2 } from "os";
@@ -13487,7 +13304,7 @@ function hostReport() {
 }
 
 // src/providers/local-process.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { constants as constants2 } from "os";
 var DEFAULT_KILL_GRACE_MS = 3e4;
 var DEFAULT_REAP_GRACE_MS = 3e3;
@@ -13498,7 +13315,7 @@ function exitCode(code, signal) {
 }
 function createLocalProcessProvider(opts = {}) {
   const killGraceMs = opts.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
-  const spawnFn = opts.spawnFn ?? spawn5;
+  const spawnFn = opts.spawnFn ?? spawn4;
   const reapGraceMs = opts.reapGraceMs ?? DEFAULT_REAP_GRACE_MS;
   const killFn = opts.killFn ?? ((pid, signal) => process.kill(pid, signal));
   const groupAlive = (pgid) => {
@@ -13632,9 +13449,6 @@ var DeviceLocks = class {
   }
 };
 
-// src/supervisor.ts
-init_launch();
-
 // src/manifest.ts
 var DEVICE_MANIFEST = {
   runtimes: [{ name: "claude-code", version: null }],
@@ -13877,9 +13691,9 @@ var SseSubscriber = class {
 init_transcript_writer();
 
 // src/updater.ts
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { copyFileSync as copyFileSync2, existsSync as existsSync16, mkdirSync as mkdirSync14, renameSync as renameSync9, rmSync as rmSync10 } from "fs";
-import { dirname as dirname11, join as join27 } from "path";
+import { dirname as dirname11, join as join26 } from "path";
 
 // src/boot-rule.ts
 import {
@@ -13891,7 +13705,7 @@ import {
   symlinkSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { dirname as dirname8, join as join24 } from "path";
+import { dirname as dirname8, join as join23 } from "path";
 var UNCONFIRMED_WINDOW_MS = 10 * 6e4;
 var MAX_STAGE_ATTEMPTS = 3;
 function superseded(pending, ...running) {
@@ -13919,38 +13733,38 @@ import {
   lstatSync,
   mkdirSync as mkdirSync12,
   readFileSync as readFileSync13,
-  readdirSync as readdirSync4,
+  readdirSync as readdirSync3,
   realpathSync as realpathSync5,
   renameSync as renameSync7,
   rmSync as rmSync9,
   symlinkSync as symlinkSync2
 } from "fs";
-import { dirname as dirname9, join as join25 } from "path";
+import { dirname as dirname9, join as join24 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 function versionsDir() {
-  return join25(cabaneDir(), "versions");
+  return join24(cabaneDir(), "versions");
 }
 function currentLink() {
-  return join25(cabaneDir(), "current");
+  return join24(cabaneDir(), "current");
 }
 function bootGuardPath() {
-  return join25(cabaneDir(), "boot-guard.mjs");
+  return join24(cabaneDir(), "boot-guard.mjs");
 }
 function pinnedNodeDir() {
-  return join25(cabaneDir(), "node");
+  return join24(cabaneDir(), "node");
 }
 function pinnedNodePath() {
-  return join25(pinnedNodeDir(), "bin", "node");
+  return join24(pinnedNodeDir(), "bin", "node");
 }
 function versionPackageRoot(version) {
-  return join25(versionsDir(), version, "node_modules", "@cabane", "companion");
+  return join24(versionsDir(), version, "node_modules", "@cabane", "companion");
 }
 function ownPackageRoot(moduleUrl = import.meta.url) {
   return dirname9(dirname9(fileURLToPath5(moduleUrl)));
 }
 function packageVersion(root) {
   try {
-    const pkg2 = JSON.parse(readFileSync13(join25(root, "package.json"), "utf8"));
+    const pkg2 = JSON.parse(readFileSync13(join24(root, "package.json"), "utf8"));
     return typeof pkg2.version === "string" ? pkg2.version : null;
   } catch {
     return null;
@@ -13959,7 +13773,7 @@ function packageVersion(root) {
 function currentRoot() {
   try {
     const root = realpathSync5(currentLink());
-    return existsSync15(join25(root, "dist", "cli.js")) ? root : null;
+    return existsSync15(join24(root, "dist", "cli.js")) ? root : null;
   } catch {
     return null;
   }
@@ -13980,9 +13794,9 @@ function pruneVersions(keep) {
   const dir2 = versionsDir();
   if (!existsSync15(dir2)) return [];
   const removed = [];
-  for (const name of readdirSync4(dir2)) {
+  for (const name of readdirSync3(dir2)) {
     if (keep.includes(name)) continue;
-    rmSync9(join25(dir2, name), { recursive: true, force: true });
+    rmSync9(join24(dir2, name), { recursive: true, force: true });
     removed.push(name);
   }
   return removed;
@@ -14002,7 +13816,7 @@ function compareVersions(a, b) {
 // src/update-state.ts
 init_config();
 import { mkdirSync as mkdirSync13, readFileSync as readFileSync14, renameSync as renameSync8, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname10, join as join26 } from "path";
+import { dirname as dirname10, join as join25 } from "path";
 import { z as z18 } from "zod";
 var resultSchema = z18.object({
   kind: z18.enum(["updated", "rolled_back", "failed"]),
@@ -14026,7 +13840,7 @@ var stateSchema = z18.object({
   failed: z18.object({ version: z18.string(), attempts: z18.number().int(), at: z18.string() }).optional()
 });
 function updateStatePath(dir2 = cabaneDir()) {
-  return join26(dir2, "update.json");
+  return join25(dir2, "update.json");
 }
 function readUpdateState(path = updateStatePath()) {
   try {
@@ -14075,7 +13889,7 @@ function rollBack(pending, reason, now = /* @__PURE__ */ new Date()) {
   return updateUpdateState((state) => rolledBackState(state, pending, reason, now));
 }
 function writeBootGuard(root = ownPackageRoot()) {
-  const built = join27(root, "dist", "boot-guard.js");
+  const built = join26(root, "dist", "boot-guard.js");
   if (!existsSync16(built)) return false;
   const target = bootGuardPath();
   mkdirSync14(dirname11(target), { recursive: true });
@@ -14092,7 +13906,7 @@ var runProcess = (command, args, opts = {}) => new Promise((resolve2) => {
   let stderr = "";
   let child;
   try {
-    child = spawn6(command, [...args], {
+    child = spawn5(command, [...args], {
       stdio: ["ignore", "pipe", "pipe"],
       env: opts.env ?? process.env
     });
@@ -14115,17 +13929,17 @@ var runProcess = (command, args, opts = {}) => new Promise((resolve2) => {
 async function stageVersion(version, harnesses, deps = {}) {
   const run = deps.run ?? runProcess;
   const node = deps.execPath ?? process.execPath;
-  const target = join27(versionsDir(), version);
+  const target = join26(versionsDir(), version);
   const placed = versionPackageRoot(version);
   if (existsSync16(placed)) {
     if (!await verifyInstall(placed, version, harnesses, { run, execPath: node }))
       return { ok: true, root: placed };
   }
-  const npm = join27(dirname11(node), "npm");
+  const npm = join26(dirname11(node), "npm");
   if (!existsSync16(npm))
     return { ok: false, reason: `there is no npm beside Node at ${dirname11(node)}` };
   mkdirSync14(versionsDir(), { recursive: true });
-  const staging = join27(versionsDir(), `.${version}.staging-${process.pid}`);
+  const staging = join26(versionsDir(), `.${version}.staging-${process.pid}`);
   rmSync10(staging, { recursive: true, force: true });
   const installed = await run(
     npm,
@@ -14154,7 +13968,7 @@ async function stageVersion(version, harnesses, deps = {}) {
       return { ok: false, reason: `version ${version} isn't published yet`, unpublished: true };
     return { ok: false, reason: `npm couldn't install it: ${lastLine(installed.stderr)}` };
   }
-  const root = join27(staging, "node_modules", "@cabane", "companion");
+  const root = join26(staging, "node_modules", "@cabane", "companion");
   const verdict = await verifyInstall(root, version, harnesses, { run, execPath: node });
   if (verdict) {
     rmSync10(staging, { recursive: true, force: true });
@@ -14166,7 +13980,7 @@ async function stageVersion(version, harnesses, deps = {}) {
 }
 async function verifyInstall(root, version, harnesses, deps) {
   if (packageVersion(root) !== version) return `the installed package isn't version ${version}`;
-  const answered = await deps.run(deps.execPath, [join27(root, "dist", "bin.js"), "--version"], {
+  const answered = await deps.run(deps.execPath, [join26(root, "dist", "bin.js"), "--version"], {
     timeoutMs: 6e4,
     env: { ...process.env, CABANE_LAUNCH_SELF: "1" }
   });
@@ -14174,7 +13988,7 @@ async function verifyInstall(root, version, harnesses, deps) {
     return `it doesn't start: ${lastLine(answered.stderr) || "no version printed"}`;
   }
   if (harnesses.length === 0) return null;
-  const probed = await deps.run(deps.execPath, [join27(root, "dist", "postinstall.js"), "--json"], {
+  const probed = await deps.run(deps.execPath, [join26(root, "dist", "postinstall.js"), "--json"], {
     timeoutMs: 6e4
   });
   let resolutions = {};
@@ -14592,13 +14406,13 @@ var CompanionSupervisor = class {
     if (this.stopped) return;
     this.log.info(
       { protocolVersion: TURN_PROTOCOL_VERSION, version: COMPANION_VERSION },
-      `Companion ${COMPANION_VERSION} starting on ${this.config.deviceLabel ?? hostname2()}`
+      `Companion ${COMPANION_VERSION} starting on ${this.config.deviceLabel ?? hostname()}`
     );
     const retired = retiredConfigKeysOnDisk();
     if (retired.length > 0) {
       this.log.warn(
         { keys: retired },
-        `config.json: ${retired.join(", ")} ${retired.length === 1 ? "is" : "are"} no longer read and can be removed. The companion does no sandboxing, and every turn runs in a child process of its own.`
+        `config.json: ${retired.join(", ")} ${retired.length === 1 ? "is" : "are"} no longer read and can be removed.`
       );
     }
     if (this.config.deviceToken) {
@@ -14638,7 +14452,7 @@ var CompanionSupervisor = class {
       log: this.log,
       lastEventId: null,
       onOpen: () => {
-        this.log.info(`Connected to Cabane as ${this.hub.statusJson().device_label ?? hostname2()}`);
+        this.log.info(`Connected to Cabane as ${this.hub.statusJson().device_label ?? hostname()}`);
         this.deviceConnected = true;
         for (const wr of this.workspaces.values()) {
           this.hub.setConnected(wr.workspaceId, true);
@@ -15184,9 +14998,9 @@ var CompanionSupervisor = class {
           this.runnerCommand ?? selfRunnerCommand()
         ),
         ...this.config.runner?.command ? {
-          boxed: true,
+          wrapped: true,
           secrets: () => loadSecretValuesTolerant(
-            (m) => this.log.warn({ err: m }, "Could not read the secrets file for a boxed turn.")
+            (m) => this.log.warn({ err: m }, "Could not read the secrets file for a wrapped turn.")
           )
         } : {},
         // Read per dispatch, for the secret variables its mint named and no others.
@@ -15865,9 +15679,9 @@ async function waitForBoundedHeartbeat(heartbeat) {
 }
 function defaultReexec() {
   clearRuntimeState();
-  void import("child_process").then(({ spawn: spawn8 }) => {
+  void import("child_process").then(({ spawn: spawn7 }) => {
     try {
-      const child = spawn8(process.execPath, process.argv.slice(1), {
+      const child = spawn7(process.execPath, process.argv.slice(1), {
         stdio: "inherit",
         detached: false
       });
@@ -15939,9 +15753,9 @@ function handleUncaught(log2, err, origin) {
 // src/crash-marker.ts
 init_config();
 import { existsSync as existsSync17, mkdirSync as mkdirSync15, readFileSync as readFileSync15, rmSync as rmSync11, writeFileSync as writeFileSync9 } from "fs";
-import { join as join28 } from "path";
+import { join as join27 } from "path";
 function crashMarkerPath() {
-  return join28(cabaneDir(), "last-error.json");
+  return join27(cabaneDir(), "last-error.json");
 }
 function recordCrash(rec2) {
   try {
@@ -15962,7 +15776,7 @@ function clearCrash() {
 init_config();
 import { spawnSync } from "child_process";
 import { readFileSync as readFileSync16 } from "fs";
-import { join as join29 } from "path";
+import { join as join28 } from "path";
 var COMPANION_ENTRY = /@cabane\/companion\/|cabane-companion|(^|[\s/])cabane\s|\.cabane\/(versions|current|boot-guard)/;
 var START = /\sstart(\s|$)/;
 function companionStarts(psOutput) {
@@ -15979,7 +15793,7 @@ function companionStarts(psOutput) {
 }
 function stateDirOf(env) {
   const home = env.CABANE_COMPANION_HOME || env.HOME;
-  return home ? join29(home, ".cabane") : null;
+  return home ? join28(home, ".cabane") : null;
 }
 function envFromPsE(output, command) {
   const line = output.replace(/\n$/, "");
@@ -16254,7 +16068,7 @@ import {
   writeFileSync as writeFileSync10
 } from "fs";
 import { homedir as homedir9, userInfo as userInfo3 } from "os";
-import { dirname as dirname12, join as join30, sep as sep3 } from "path";
+import { dirname as dirname12, join as join29, sep as sep3 } from "path";
 function servicePlatform(platform = process.platform) {
   if (platform === "linux") return "systemd";
   if (platform === "darwin") return "launchd";
@@ -16272,15 +16086,15 @@ function serviceNode(execPath = process.execPath) {
   return existsSync18(pinnedNodePath()) ? pinnedNodePath() : execPath;
 }
 function servicePaths(platform, env = process.env, home = homedir9(), node = serviceNode()) {
-  const unitFile = platform === "systemd" ? join30(
-    env.XDG_CONFIG_HOME || join30(home, ".config"),
+  const unitFile = platform === "systemd" ? join29(
+    env.XDG_CONFIG_HOME || join29(home, ".config"),
     "systemd",
     "user",
     `${serviceName(env)}.service`
-  ) : join30(home, "Library", "LaunchAgents", `${launchdLabel(env)}.plist`);
+  ) : join29(home, "Library", "LaunchAgents", `${launchdLabel(env)}.plist`);
   return {
     unitFile,
-    envFile: join30(cabaneDir(), "service.env"),
+    envFile: join29(cabaneDir(), "service.env"),
     node,
     entry: bootGuardPath()
   };
@@ -16347,7 +16161,7 @@ function renderLaunchdPlist(paths, env = process.env, servicePath) {
     "  <key>ThrottleInterval</key><integer>5</integer>",
     // The companion writes its own log; the console copy would only grow a second one.
     "  <key>StandardOutPath</key><string>/dev/null</string>",
-    `  <key>StandardErrorPath</key><string>${xml(join30(cabaneDir(), "service-error.log"))}</string>`,
+    `  <key>StandardErrorPath</key><string>${xml(join29(cabaneDir(), "service-error.log"))}</string>`,
     "</dict>",
     "</plist>",
     ""
@@ -16487,15 +16301,15 @@ async function seedManagedInstall(deps) {
   }
   const target = versionPackageRoot(version);
   if (!existsSync18(target)) {
-    const staging = join30(versionsDir(), `.${version}.seed-${process.pid}`);
+    const staging = join29(versionsDir(), `.${version}.seed-${process.pid}`);
     rmSync12(staging, { recursive: true, force: true });
     try {
-      cpSync(own, join30(staging, "node_modules", "@cabane", "companion"), {
+      cpSync(own, join29(staging, "node_modules", "@cabane", "companion"), {
         recursive: true,
         verbatimSymlinks: true
       });
-      rmSync12(join30(versionsDir(), version), { recursive: true, force: true });
-      renameSync10(staging, join30(versionsDir(), version));
+      rmSync12(join29(versionsDir(), version), { recursive: true, force: true });
+      renameSync10(staging, join29(versionsDir(), version));
     } catch (err) {
       rmSync12(staging, { recursive: true, force: true });
       return {
@@ -16506,7 +16320,7 @@ async function seedManagedInstall(deps) {
   }
   const unrunnable = await verifyInstall(target, version, [], deps);
   if (unrunnable) {
-    rmSync12(join30(versionsDir(), version), { recursive: true, force: true });
+    rmSync12(join29(versionsDir(), version), { recursive: true, force: true });
     return { ok: false, reason: `The copy of Cabane for the service can't run: ${unrunnable}.` };
   }
   pointCurrentAt(target);
@@ -16588,9 +16402,9 @@ function userName() {
     return process.env.USER ?? "";
   }
 }
-function rewriteScriptWrappers(dir2 = join30(cabaneDir(), "bin")) {
+function rewriteScriptWrappers(dir2 = join29(cabaneDir(), "bin")) {
   for (const name of ["cabane", "cabane-companion"]) {
-    const path = join30(dir2, name);
+    const path = join29(dir2, name);
     let text;
     try {
       text = readFileSync17(path, "utf8");
@@ -16640,7 +16454,7 @@ async function controlService(action, deps) {
 init_cabane_command();
 init_cli_entry();
 init_config();
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { closeSync as closeSync3, mkdirSync as mkdirSync17, openSync as openSync4 } from "fs";
 init_config();
 async function startDaemon(opts = {}, deps = {}) {
@@ -16722,7 +16536,7 @@ function defaultSpawnDetached(args) {
   mkdirSync17(cabaneDir(), { recursive: true });
   const logFd = openSync4(companionLogPath(), "a");
   try {
-    const child = spawn7(process.execPath, [cliPath, ...args], {
+    const child = spawn6(process.execPath, [cliPath, ...args], {
       detached: true,
       stdio: ["ignore", logFd, logFd],
       env: { ...process.env, CABANE_COMPANION_DAEMON: "1" }
@@ -17148,7 +16962,7 @@ async function setupScript(opts, deps) {
     }
     device = await (deps.claim ?? claimSetupCode)(baseUrl, {
       userCode: opts.code,
-      label: deviceLabelFromHostname(hostname3()) ?? "Computer",
+      label: deviceLabelFromHostname(hostname2()) ?? "Computer",
       ...paired && cfg?.deviceToken ? { deviceToken: cfg.deviceToken } : {}
     });
     writePairedConfig(device);
@@ -17347,9 +17161,9 @@ async function logs(opts = {}) {
 init_cabane_command();
 init_install_kind();
 init_cabane_command();
-import { readdirSync as readdirSync5, realpathSync as realpathSync6, existsSync as existsSync19 } from "fs";
+import { readdirSync as readdirSync4, realpathSync as realpathSync6, existsSync as existsSync19 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname13, join as join31 } from "path";
+import { dirname as dirname13, join as join30 } from "path";
 init_config();
 init_secrets();
 init_term();
@@ -17635,7 +17449,7 @@ function versionLine() {
   const install = companionInstall();
   const own = installedCommandPath({ install });
   if (install === "script") {
-    return `Cabane ${COMPANION_VERSION} \xB7 installed by the install script (${tildePath(join31(homedir10(), ".cabane"))})`;
+    return `Cabane ${COMPANION_VERSION} \xB7 installed by the install script (${tildePath(join30(homedir10(), ".cabane"))})`;
   }
   if (own)
     return `Cabane ${COMPANION_VERSION} \xB7 installed with npm (${tildePath(dirname13(dirname13(own)))})`;
@@ -17661,7 +17475,7 @@ function otherInstall(install, own) {
     }
   };
   if (install === "npm") {
-    const script = join31(
+    const script = join30(
       homedir10(),
       ".cabane",
       "node",
@@ -17670,11 +17484,11 @@ function otherInstall(install, own) {
       "@cabane",
       "companion"
     );
-    return existsSync19(script) ? join31(homedir10(), ".cabane") : null;
+    return existsSync19(script) ? join30(homedir10(), ".cabane") : null;
   }
   const found = firstOnPath("cabane-companion", process.env.PATH);
   if (!found) return null;
-  const ownAlias = own ? real(join31(dirname13(own), "cabane-companion")) : null;
+  const ownAlias = own ? real(join30(dirname13(own), "cabane-companion")) : null;
   return real(found) === ownAlias ? null : dirname13(found);
 }
 function runningMode(running, service2) {
@@ -17712,7 +17526,7 @@ function transcriptsLine() {
   let count = 0;
   let newest;
   try {
-    const files = readdirSync5(dir2).filter((f) => f.endsWith(".jsonl")).sort();
+    const files = readdirSync4(dir2).filter((f) => f.endsWith(".jsonl")).sort();
     count = files.length;
     newest = files[files.length - 1];
   } catch {
@@ -17880,8 +17694,8 @@ init_cabane_command();
 init_errors();
 init_src();
 init_transcript_writer();
-import { existsSync as existsSync20, readFileSync as readFileSync18, readdirSync as readdirSync6 } from "fs";
-import { basename as basename4, isAbsolute as isAbsolute2, join as join32 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync18, readdirSync as readdirSync5 } from "fs";
+import { basename as basename4, isAbsolute as isAbsolute2, join as join31 } from "path";
 async function transcript(opts = {}) {
   const dir2 = transcriptsDir();
   if (opts.follow) {
@@ -17898,7 +17712,7 @@ async function transcript(opts = {}) {
       process.stdout.write(emptyMessage(dir2));
       return;
     }
-    process.stdout.write(renderFile(join32(dir2, newest)) + "\n");
+    process.stdout.write(renderFile(join31(dir2, newest)) + "\n");
     return;
   }
   printList(dir2);
@@ -17981,7 +17795,7 @@ function isComplete(content) {
 async function followTranscripts(dir2) {
   const follower = new TranscriptFollower({
     listFiles: () => listFiles(dir2),
-    read: (f) => readFileSync18(join32(dir2, f), "utf8"),
+    read: (f) => readFileSync18(join31(dir2, f), "utf8"),
     write: (s) => process.stdout.write(s),
     // CSI: cursor up `n` lines, then erase from cursor to end of screen.
     clearLines: (n) => process.stdout.write(`\x1B[${n}A\x1B[0J`),
@@ -18007,7 +17821,7 @@ async function followTranscripts(dir2) {
 function listTranscriptFiles(dir2) {
   let entries;
   try {
-    entries = readdirSync6(dir2, { withFileTypes: true });
+    entries = readdirSync5(dir2, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -18017,7 +17831,7 @@ function listTranscriptFiles(dir2) {
     if (!entry.isDirectory() || entry.name === "anomalies") continue;
     let inner;
     try {
-      inner = readdirSync6(join32(dir2, entry.name));
+      inner = readdirSync5(join31(dir2, entry.name));
     } catch {
       continue;
     }
@@ -18036,7 +17850,7 @@ function printList(dir2) {
 
 `);
   for (const f of files.slice(0, 20)) {
-    const { meta, outcome } = peek(join32(dir2, f));
+    const { meta, outcome } = peek(join31(dir2, f));
     const when = fmtTime(rec(meta)?.ts);
     const ws = str2(rec(meta)?.workspaceSlug);
     const o = rec(outcome);
@@ -18072,13 +17886,13 @@ function peek(path) {
 function resolveTarget(dir2, target) {
   if (isAbsolute2(target) || target.includes("/")) {
     if (existsSync20(target)) return target;
-    if (!isAbsolute2(target) && existsSync20(join32(dir2, target))) return join32(dir2, target);
+    if (!isAbsolute2(target) && existsSync20(join31(dir2, target))) return join31(dir2, target);
     throw new CompanionError(`no transcript at ${target}.`);
   }
-  const exact = join32(dir2, target);
+  const exact = join31(dir2, target);
   if (existsSync20(exact)) return exact;
   const matches = listFiles(dir2).filter((f) => f.includes(target));
-  if (matches.length === 1) return join32(dir2, matches[0]);
+  if (matches.length === 1) return join31(dir2, matches[0]);
   if (matches.length === 0) {
     throw new CompanionError(
       `no transcript matching "${target}" in ${dir2}. Run \`${cabane("transcript")}\` to list them.`