agent-shim 8.5.1 → 8.5.3

package/dist/cli.cjs

@@ -35184,7 +35184,7 @@ function debugEnabled(env) {
 
 // src/claudeShim.ts
 var import_node_fs4 = __toESM(require("node:fs"), 1);
-var import_node_path7 = __toESM(require("node:path"), 1);
+var import_node_path9 = __toESM(require("node:path"), 1);
 
 // node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -55050,10 +55050,10 @@ function applyPatch(filePath, schema, patch, options = {}) {
 
 // src/realPorts.ts
 var import_node_child_process2 = require("node:child_process");
-var import_node_crypto3 = require("node:crypto");
+var import_node_crypto4 = require("node:crypto");
 var import_node_fs3 = __toESM(require("node:fs"), 1);
 var import_node_os2 = __toESM(require("node:os"), 1);
-var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_path8 = __toESM(require("node:path"), 1);
 var import_node_sea = require("node:sea");
 
 // src/versionDiscovery.ts
@@ -55107,18 +55107,14 @@ function discoverClaudeBinary(options) {
       version: highestVersion
     };
   }
-  const ownInstallDirs = new Set(options.ownInstallDirs.map((dir) => import_node_path3.default.resolve(dir)));
   for (const dir of options.pathDirs) {
-    if (ownInstallDirs.has(import_node_path3.default.resolve(dir))) {
-      continue;
-    }
     const found = options.findExecutableInDir(dir, "claude");
-    if (found !== void 0) {
+    if (found !== void 0 && !options.isOwnBinary(found)) {
       return { path: found, source: "path-fallback" };
     }
   }
   throw new Error(
-    `Could not find a claude binary. Looked for genuinely-executable versioned binaries under "${versionsDir}" (missing, empty, or containing nothing executable) and for a "claude" executable on PATH (excluding this tool's own install directory). Install Claude Code, or set the versions directory / PATH correctly, then try again.`
+    `Could not find a claude binary. Looked for genuinely-executable versioned binaries under "${versionsDir}" (missing, empty, or containing nothing executable) and for a "claude" executable on PATH (never this tool's own binary). Install Claude Code, or set the versions directory / PATH correctly, then try again.`
   );
 }
 
@@ -55509,13 +55505,24 @@ function ensureHeadroom(params) {
   const { paths, ports } = params;
   const deadline = ports.now() + HEADROOM_START_TIMEOUT_MS;
   let spawnedSupervisor = false;
+  let awaitingAllowlist = false;
   for (; ; ) {
     const state = readHeadroomState(ports.fs, paths.headroomStateFile);
     if (state?.supervisorPid !== void 0 && ports.isRunning(state.supervisorPid)) {
       const daemonUp = state.socketPath !== void 0 && state.headroomPid !== void 0 && ports.isRunning(state.headroomPid);
       if (daemonUp && state.socketPath !== void 0) {
-        writeSession(ports.fs, paths.headroomSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), supervisorPid: state.supervisorPid });
-        return { socketPath: state.socketPath };
+        const required2 = params.requiredAllowlistHash?.();
+        if (required2 === void 0 || state.allowlistHash === required2) {
+          writeSession(ports.fs, paths.headroomSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), supervisorPid: state.supervisorPid });
+          return { socketPath: state.socketPath };
+        }
+        const holders = sessionsForSupervisor(ports.fs, paths.headroomSessionsDir, state.supervisorPid).filter((session) => ports.isRunning(session.pid));
+        if (holders.length > 0) {
+          throw new HeadroomStartError(
+            `agent-shim: the running headroom daemon was started before this launch's front door address and would refuse every request this launch sends through it. It restarts once the launches using it end (pid ${holders.map((session) => String(session.pid)).join(", ")}); end them and launch again, or launch with --no-headroom.`
+          );
+        }
+        awaitingAllowlist = true;
       }
       if (state.lastError !== void 0) {
         throw new HeadroomStartError(
@@ -55543,13 +55550,535 @@ function ensureHeadroom(params) {
     if (ports.now() >= deadline) {
       const lastError = state?.lastError;
       throw new HeadroomStartError(
-        `agent-shim: the headroom daemon did not become ready within ${String(HEADROOM_START_TIMEOUT_MS)}ms` + (lastError === void 0 ? "" : ` (last error: ${lastError})`) + `. Daemon log: ${paths.headroomLogPath}`
+        `agent-shim: the headroom daemon did not become ready within ${String(HEADROOM_START_TIMEOUT_MS)}ms` + (lastError === void 0 ? "" : ` (last error: ${lastError})`) + (awaitingAllowlist ? " (the running daemon's allowlist does not admit this launch's front door, and it did not restart)" : "") + `. Daemon log: ${paths.headroomLogPath}`
       );
     }
     ports.sleep(HEADROOM_LAUNCHER_POLL_MS);
   }
 }
 
+// src/frontdoor/state.ts
+var import_node_path6 = __toESM(require("node:path"), 1);
+var FRONT_DOOR_PROTOCOL = 2;
+var FrontDoorSessionSchema = external_exports.strictObject({ pid: external_exports.number().int().positive(), startedAt: external_exports.number(), token: external_exports.string().min(1) });
+var FrontDoorStateSchema = external_exports.strictObject({
+  /**
+   * The launcher-to-door wire protocol this supervisor speaks, written once it is serving; absent in state written by a release that predates the field, which `ensureFrontDoor` reads as protocol 0. A launcher replaces a door whose protocol is lower than its own (see `FRONT_DOOR_PROTOCOL`).
+   */
+  protocol: external_exports.number().int().nonnegative().optional(),
+  /** The supervisor process serving the front door. Alive means both listeners are up in that process. */
+  supervisorPid: external_exports.number().int().positive().optional(),
+  /** The loopback port the HTTPS provider listener serves on. Absent until the listener has bound and answered its health probe, so "port is set" is itself the ready signal a launcher polls for. */
+  port: external_exports.number().int().positive().optional(),
+  /**
+   * The sticky port preference for the provider listener: kept across crashes, restarts and idle shutdowns so every provider session, whose base URL was frozen at launch, keeps finding the front door at the same address.
+   */
+  lastPort: external_exports.number().int().positive().optional(),
+  /**
+   * The loopback port the CONNECT surface listens on. Absent whenever no supervisor is serving it, so "connectPort is set" is the ready signal an OAuth launch polls for alongside `port`.
+   */
+  connectPort: external_exports.number().int().positive().optional(),
+  /**
+   * The sticky port preference for the CONNECT surface, the exact analogue of `lastPort` for the second listener: it survives every shutdown, because every OAuth session's environment was frozen at launch with HTTPS_PROXY pointing at this address and a restart that moves strands them.
+   */
+  lastConnectPort: external_exports.number().int().positive().optional(),
+  /**
+   * The loopback port the direct listener serves on: the listener a headroom hop tells the daemon to forward routed traffic back to. Sticky like the others, because headroom's allowlist admits its exact origin and an ephemeral port would invalidate the allowlist on every restart.
+   */
+  directPort: external_exports.number().int().positive().optional(),
+  /** The sticky port preference for the direct listener, for the reason `directPort` gives. */
+  lastDirectPort: external_exports.number().int().positive().optional(),
+  /** The last fatal error, kept across shutdowns so `frontdoor status` can explain a front door that is not running. */
+  lastError: external_exports.string().optional()
+});
+function readFrontDoorState(fs19, stateFile) {
+  let raw;
+  try {
+    raw = fs19.readFileUtf8(stateFile);
+  } catch {
+    return void 0;
+  }
+  if (raw === void 0 || raw.trim() === "") {
+    return void 0;
+  }
+  try {
+    const parsed = FrontDoorStateSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeFrontDoorState(fs19, stateFile, state) {
+  fs19.mkdirp(import_node_path6.default.dirname(stateFile));
+  fs19.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
+`);
+}
+function frontDoorOrigin(state) {
+  const port = state?.directPort ?? state?.lastDirectPort;
+  return port === void 0 ? void 0 : `http://127.0.0.1:${String(port)}`;
+}
+function writeFrontDoorSession(fs19, sessionsDir, session) {
+  fs19.mkdirPrivate(sessionsDir);
+  fs19.writeFilePrivate(import_node_path6.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+`);
+}
+function listFrontDoorSessions(fs19, sessionsDir) {
+  const sessions = [];
+  for (const name of fs19.readdir(sessionsDir)) {
+    if (!name.endsWith(".json")) {
+      continue;
+    }
+    try {
+      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs19.readFileUtf8(import_node_path6.default.join(sessionsDir, name)) ?? ""));
+      if (parsed.success) {
+        sessions.push({ pid: parsed.data.pid, startedAt: parsed.data.startedAt });
+      }
+    } catch {
+      continue;
+    }
+  }
+  return sessions.sort((a2, b) => a2.pid - b.pid);
+}
+function removeFrontDoorSession(fs19, sessionsDir, pid) {
+  fs19.removeRecursive(import_node_path6.default.join(sessionsDir, `${String(pid)}.json`));
+}
+function pruneDeadFrontDoorSessions(fs19, sessionsDir, isRunning) {
+  const removed = [];
+  for (const session of listFrontDoorSessions(fs19, sessionsDir)) {
+    if (!isRunning(session.pid)) {
+      removeFrontDoorSession(fs19, sessionsDir, session.pid);
+      removed.push(session.pid);
+    }
+  }
+  return removed;
+}
+function liveSessionTokens(fs19, sessionsDir) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const name of fs19.readdir(sessionsDir)) {
+    if (!name.endsWith(".json")) {
+      continue;
+    }
+    try {
+      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs19.readFileUtf8(import_node_path6.default.join(sessionsDir, name)) ?? ""));
+      if (parsed.success) {
+        tokens.add(parsed.data.token);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return tokens;
+}
+
+// src/headroom/settings.ts
+var import_node_crypto3 = require("node:crypto");
+function settingsOf(config2) {
+  return {
+    ...config2.mode === void 0 ? {} : { mode: config2.mode },
+    ...config2.targetRatio === void 0 ? {} : { targetRatio: config2.targetRatio },
+    ...config2.ccr === void 0 ? {} : { ccr: config2.ccr },
+    ...config2.rolloutChannel === void 0 ? {} : { rolloutChannel: config2.rolloutChannel },
+    ...config2.interceptToolResults === void 0 ? {} : { interceptToolResults: config2.interceptToolResults },
+    ...config2.readMaturation === void 0 ? {} : { readMaturation: config2.readMaturation }
+  };
+}
+function settingsArgs(settings2) {
+  return [
+    ...settings2.mode === void 0 ? [] : ["--mode", settings2.mode],
+    ...settings2.targetRatio === void 0 ? [] : ["--target-ratio", String(settings2.targetRatio)],
+    ...settings2.ccr === "lossless" ? ["--lossless"] : [],
+    ...settings2.ccr === "none" ? ["--no-ccr"] : [],
+    ...settings2.interceptToolResults === true ? ["--intercept-tool-results"] : [],
+    ...settings2.readMaturation === true ? ["--read-maturation"] : []
+  ];
+}
+function settingsEnv(settings2) {
+  return settings2.rolloutChannel === void 0 ? {} : { HEADROOM_ROLLOUT_CHANNEL: settings2.rolloutChannel };
+}
+function hashSettings(settings2) {
+  return (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify([...settingsArgs(settings2), JSON.stringify(settingsEnv(settings2))])).digest("hex");
+}
+
+// src/headroom/socket.ts
+var import_node_path7 = __toESM(require("node:path"), 1);
+var GROUP_OR_OTHER_BITS = 63;
+var OCTAL_RADIX = 8;
+var MODE_DIGITS = 4;
+var HEADROOM_SOCKET_SUFFIX = ".sock";
+var HEADROOM_SOCKET_NAME = /^(\d+)\.sock$/;
+var UNIX_SOCKET_PATH_MAX_BYTES = 103;
+var PLATFORMS_WITHOUT_UNIX_SOCKETS = ["win32"];
+function headroomSocketPath(paths, supervisorPid) {
+  return import_node_path7.default.join(paths.headroomSocketDir, `${String(supervisorPid)}${HEADROOM_SOCKET_SUFFIX}`);
+}
+function platformRefusal(platform) {
+  return PLATFORMS_WITHOUT_UNIX_SOCKETS.includes(platform) ? `headroom routing needs a unix domain socket, which headroom cannot serve on ${platform}; agent-shim never falls back to a TCP port for this hop` : void 0;
+}
+function ownerOnlyRefusal(label, target, stat, expected, uid) {
+  if (stat === void 0) {
+    return `the headroom ${label} ${target} does not exist`;
+  }
+  if (stat.kind === "symlink") {
+    return `the headroom ${label} ${target} is a symlink; it must be the real ${expected === "dir" ? "directory" : "socket"}`;
+  }
+  if (stat.kind !== expected) {
+    return `the headroom ${label} ${target} is not a ${expected === "dir" ? "directory" : "socket"}`;
+  }
+  if (stat.uid !== uid) {
+    return `the headroom ${label} ${target} is owned by uid ${String(stat.uid)}, not by this user (uid ${String(uid)})`;
+  }
+  if ((stat.mode & GROUP_OR_OTHER_BITS) !== 0) {
+    return `the headroom ${label} ${target} has mode ${stat.mode.toString(OCTAL_RADIX).padStart(MODE_DIGITS, "0")}, which lets other users reach it; it must be accessible to its owner only`;
+  }
+  return void 0;
+}
+function verifyHeadroomSocket(socketPath, ports) {
+  const unsupported = platformRefusal(ports.platform);
+  if (unsupported !== void 0) {
+    return { refused: unsupported };
+  }
+  const uid = ports.currentUid();
+  const directory = import_node_path7.default.dirname(socketPath);
+  const refusal = ownerOnlyRefusal("socket directory", directory, ports.lstat(directory), "dir", uid) ?? ownerOnlyRefusal("socket", socketPath, ports.lstat(socketPath), "socket", uid);
+  return refusal === void 0 ? { socketPath } : { refused: refusal };
+}
+function prepareHeadroomSocket(fs19, ports, paths, supervisorPid) {
+  const unsupported = platformRefusal(ports.platform);
+  if (unsupported !== void 0) {
+    return { refused: unsupported };
+  }
+  const socketPath = headroomSocketPath(paths, supervisorPid);
+  const length = Buffer.byteLength(socketPath, "utf8");
+  if (length > UNIX_SOCKET_PATH_MAX_BYTES) {
+    return {
+      refused: `the headroom socket path ${socketPath} is ${String(length)} bytes, longer than the ${String(UNIX_SOCKET_PATH_MAX_BYTES)} a unix socket path can hold; set AGENT_SHIM_HOME to a shorter directory`
+    };
+  }
+  if (ports.lstat(paths.headroomSocketDir)?.kind === "symlink") {
+    return { refused: `the headroom socket directory ${paths.headroomSocketDir} is a symlink; it must be the real directory` };
+  }
+  fs19.mkdirPrivate(paths.headroomSocketDir);
+  const refusal = ownerOnlyRefusal("socket directory", paths.headroomSocketDir, ports.lstat(paths.headroomSocketDir), "dir", ports.currentUid());
+  return refusal === void 0 ? { socketPath } : { refused: refusal };
+}
+function pruneStaleHeadroomSockets(fs19, paths, isRunning) {
+  const removed = [];
+  for (const name of fs19.readdir(paths.headroomSocketDir)) {
+    const pid = HEADROOM_SOCKET_NAME.exec(name)?.[1];
+    if (pid === void 0 || isRunning(Number.parseInt(pid, 10))) {
+      continue;
+    }
+    fs19.removeRecursive(import_node_path7.default.join(paths.headroomSocketDir, name));
+    removed.push(name);
+  }
+  return removed;
+}
+
+// src/headroom/source.ts
+var GIT_SPEC_RE = /git\+[^@\s]+(?:@([^\s#]+))?/;
+var COMMIT_SHA_RE = /^[0-9a-f]{40}$/i;
+var DirectUrlSchema = external_exports.object({ vcs_info: external_exports.object({ commit_id: external_exports.string() }) });
+function isMovingGitSource(spec) {
+  const match = GIT_SPEC_RE.exec(spec);
+  if (match === null) {
+    return false;
+  }
+  const ref = match[1];
+  return ref === void 0 || !COMMIT_SHA_RE.test(ref);
+}
+function pinnedGitCommit(spec) {
+  const ref = GIT_SPEC_RE.exec(spec)?.[1];
+  return ref !== void 0 && COMMIT_SHA_RE.test(ref) ? ref.toLowerCase() : void 0;
+}
+function parseInstalledCommit(directUrlJson) {
+  try {
+    const parsed = DirectUrlSchema.safeParse(JSON.parse(directUrlJson));
+    return parsed.success ? parsed.data.vcs_info.commit_id.toLowerCase() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/headroom/supervisor.ts
+function resolveSupervisorConfig(configured) {
+  return {
+    source: configured.source ?? HEADROOM_DEFAULT_SOURCE,
+    idleShutdownMinutes: configured.idleShutdownMinutes ?? HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES,
+    settings: settingsOf(configured)
+  };
+}
+var HEADROOM_BACKOFF_BASE_MS = 500;
+var HEADROOM_BACKOFF_CAP_MS = 3e4;
+var HEADROOM_START_RETRY_BUDGET = 5;
+var HEADROOM_READY_TIMEOUT_MS = 15e3;
+var HEADROOM_POLL_MS = 1e3;
+var MS_PER_MINUTE = 6e4;
+var STOP_POLL_MS = 100;
+var TERM_GRACE_MS = 1500;
+var KILL_GRACE_MS = 1500;
+function stopSupervisedProcess(pid, primitives) {
+  const send = (signal) => {
+    try {
+      primitives.signal(pid, signal);
+    } catch {
+    }
+  };
+  send("SIGTERM");
+  if (awaitExit(pid, primitives, TERM_GRACE_MS)) {
+    return "exited-on-term";
+  }
+  send("SIGKILL");
+  if (awaitExit(pid, primitives, KILL_GRACE_MS)) {
+    return "killed";
+  }
+  return "still-running";
+}
+function awaitExit(pid, primitives, budgetMs) {
+  const deadline = primitives.now() + budgetMs;
+  while (primitives.isRunning(pid)) {
+    if (primitives.now() >= deadline) {
+      return false;
+    }
+    primitives.waitMs(STOP_POLL_MS);
+  }
+  return true;
+}
+function backoffForAttempt(attempt) {
+  return Math.min(HEADROOM_BACKOFF_CAP_MS, HEADROOM_BACKOFF_BASE_MS * 2 ** (attempt - 1));
+}
+function versionSatisfies(version2, source) {
+  if (version2 === void 0) {
+    return false;
+  }
+  const specifier = /==|>=|<=|!=|>|<|~=/.exec(source);
+  if (specifier === null) {
+    return true;
+  }
+  const installed = parseVersion(version2);
+  const wanted = parseVersion(source.slice(specifier.index + specifier[0].length));
+  if (installed === void 0 || wanted === void 0) {
+    return true;
+  }
+  const cmp = compareVersions2(installed, wanted);
+  switch (specifier[0]) {
+    case "==":
+      return cmp === 0;
+    case "!=":
+      return cmp !== 0;
+    case ">=":
+      return cmp >= 0;
+    case "<=":
+      return cmp <= 0;
+    case ">":
+      return cmp > 0;
+    case "<":
+      return cmp < 0;
+    case "~=":
+      return compareVersions2(installed.slice(0, Math.max(0, wanted.length - 1)), wanted.slice(0, Math.max(0, wanted.length - 1))) === 0 && cmp >= 0;
+    default:
+      return true;
+  }
+}
+function parseVersion(input2) {
+  const match = /(\d+)(\.\d+)*/.exec(input2);
+  if (match === null) {
+    return void 0;
+  }
+  return match[0].split(".").map((part) => Number.parseInt(part, 10));
+}
+function compareVersions2(a2, b) {
+  for (let index = 0; index < Math.max(a2.length, b.length); index += 1) {
+    const left = a2[index] ?? 0;
+    const right = b[index] ?? 0;
+    if (left !== right) {
+      return left - right;
+    }
+  }
+  return 0;
+}
+var HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
+async function runSupervisor(initialConfig, ports, options = {}) {
+  const { fs: fs19, paths } = ports;
+  let config2 = initialConfig;
+  const previousState = readHeadroomState(fs19, paths.headroomStateFile);
+  if (previousState?.supervisorPid !== void 0 && previousState.supervisorPid !== ports.ownPid && ports.isRunning(previousState.supervisorPid)) {
+    ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: supervisor ${String(previousState.supervisorPid)} already owns the daemon; exiting`);
+    return 0;
+  }
+  let installedSource = previousState?.installedSource;
+  const ownsState = () => {
+    const owner = readHeadroomState(fs19, paths.headroomStateFile)?.supervisorPid;
+    return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
+  };
+  const writeOwnState = (state) => {
+    if (!ownsState()) {
+      return false;
+    }
+    writeHeadroomState(fs19, paths.headroomStateFile, state);
+    return true;
+  };
+  const fail = (message) => {
+    if (writeOwnState({ lastError: message })) {
+      fs19.removeRecursive(paths.headroomLockFile);
+    }
+    ports.log(`agent-shim headroom supervisor: ${message}`);
+    return 1;
+  };
+  const ensureInstalled = () => {
+    const version3 = ports.headroomVersion();
+    const versionOk = version3 !== void 0 && versionSatisfies(version3, config2.source);
+    const pinned = pinnedGitCommit(config2.source);
+    const commitOk = pinned === void 0 || ports.installedCommit() === pinned;
+    if (versionOk && commitOk && (installedSource === void 0 || installedSource === config2.source)) {
+      installedSource = config2.source;
+      return true;
+    }
+    ports.log(`agent-shim headroom supervisor: installing headroom from ${config2.source}`);
+    const result = ports.install(config2.source);
+    if (!result.ok) {
+      return false;
+    }
+    installedSource = config2.source;
+    return true;
+  };
+  const socket = prepareHeadroomSocket(fs19, ports.socketTrust, paths, ports.ownPid);
+  if (socket.refused !== void 0) {
+    return fail(socket.refused);
+  }
+  const { socketPath } = socket;
+  pruneStaleHeadroomSockets(fs19, paths, ports.isRunning);
+  if (!ensureInstalled()) {
+    return fail(`could not install headroom from ${config2.source}: install failed (is uv installed and on PATH?)`);
+  }
+  const version2 = ports.headroomVersion() ?? "unknown";
+  writeOwnState({ supervisorPid: ports.ownPid, version: version2, installedSource });
+  ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${allowlistOf(ports).join(", ")}]`);
+  const orphanPid = previousState?.headroomPid;
+  if (orphanPid !== void 0 && ports.isRunning(orphanPid)) {
+    ports.log(`agent-shim headroom supervisor: stopping daemon pid ${String(orphanPid)} left behind by the previous supervisor`);
+    ports.stopProcess(orphanPid);
+  }
+  let headroomPid;
+  let runningHash;
+  let runningSettingsHash;
+  let consecutiveFailures = 0;
+  let idleSince;
+  let superseded = false;
+  let ticks = 0;
+  for (; ; ) {
+    if (options.tickLimit !== void 0 && ticks >= options.tickLimit) {
+      return HEADROOM_SUPERVISOR_STILL_RUNNING;
+    }
+    ticks += 1;
+    config2 = ports.readConfig();
+    const settingsHash = hashSettings(config2.settings);
+    const allowlist = allowlistOf(ports);
+    const allowlistHash = hashAllowlist(allowlist);
+    pruneDeadSessions(fs19, paths.headroomSessionsDir, ports.isRunning);
+    const ownsNow = ownsState();
+    if (!ownsNow && !superseded) {
+      ports.log("agent-shim headroom supervisor: another supervisor now owns the state file; serving this daemon's own sessions until they end");
+    }
+    superseded = !ownsNow;
+    const crashed = headroomPid !== void 0 && !ports.isRunning(headroomPid);
+    if (headroomPid === void 0 || crashed) {
+      if (crashed) {
+        ports.log(`agent-shim headroom supervisor: headroom pid ${String(headroomPid)} died`);
+        headroomPid = void 0;
+        runningHash = void 0;
+        runningSettingsHash = void 0;
+        writeOwnState({
+          supervisorPid: ports.ownPid,
+          version: version2,
+          installedSource
+        });
+      }
+      if (consecutiveFailures >= HEADROOM_START_RETRY_BUDGET) {
+        return fail(`headroom failed to become ready ${String(consecutiveFailures)} times in a row; giving up`);
+      }
+      if (installedSource !== config2.source && !ensureInstalled()) {
+        return fail(`could not install headroom from ${config2.source}: install failed (is uv installed and on PATH?)`);
+      }
+      const pid = ports.spawnHeadroom(socketPath, allowlist, config2.settings);
+      const ready = await waitUntilReady(ports, socketPath);
+      if (ready) {
+        consecutiveFailures = 0;
+        headroomPid = pid;
+        runningHash = allowlistHash;
+        runningSettingsHash = settingsHash;
+        const recorded = writeOwnState({
+          supervisorPid: ports.ownPid,
+          headroomPid: pid,
+          socketPath,
+          version: version2,
+          allowlistHash,
+          settingsHash,
+          installedSource: config2.source
+        });
+        if (recorded) {
+          fs19.removeRecursive(paths.headroomLockFile);
+        }
+        idleSince = void 0;
+        ports.log(`agent-shim headroom supervisor: headroom pid ${String(pid)} ready on unix socket ${socketPath}`);
+      } else {
+        ports.stopProcess(pid);
+        consecutiveFailures += 1;
+        ports.log(
+          `agent-shim headroom supervisor: headroom did not become ready on unix socket ${socketPath} (attempt ${String(consecutiveFailures)} of ${String(HEADROOM_START_RETRY_BUDGET)})`
+        );
+        await ports.sleep(backoffForAttempt(consecutiveFailures));
+        continue;
+      }
+    } else {
+      if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config2.source) {
+        if (sessionsForSupervisor(fs19, paths.headroomSessionsDir, ports.ownPid).length === 0) {
+          ports.log("agent-shim headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
+          ports.stopProcess(headroomPid);
+          headroomPid = void 0;
+          runningHash = void 0;
+          runningSettingsHash = void 0;
+          continue;
+        }
+      }
+      const sessions = sessionsForSupervisor(fs19, paths.headroomSessionsDir, ports.ownPid);
+      if (sessions.length === 0) {
+        idleSince ??= ports.now();
+        const idleMs = ports.now() - idleSince;
+        if (idleMs >= config2.idleShutdownMinutes * MS_PER_MINUTE) {
+          ports.log(
+            `agent-shim headroom supervisor: no sessions for ${String(config2.idleShutdownMinutes)} minute(s); stopping headroom and exiting`
+          );
+          ports.stopProcess(headroomPid);
+          writeOwnState({ version: version2 });
+          return 0;
+        }
+      } else {
+        idleSince = void 0;
+      }
+    }
+    await ports.sleep(HEADROOM_POLL_MS);
+  }
+}
+function currentHeadroomAllowlist(fs19, paths) {
+  const providers = readAllProviders(fs19, paths.providersDir).map((entry) => entry.provider);
+  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs19, paths.frontdoorStateFile))));
+}
+function allowlistOf(ports) {
+  return currentHeadroomAllowlist(ports.fs, ports.paths);
+}
+async function waitUntilReady(ports, socketPath) {
+  const deadline = ports.now() + HEADROOM_READY_TIMEOUT_MS;
+  for (; ; ) {
+    if (await ports.ready(socketPath)) {
+      return true;
+    }
+    if (ports.now() >= deadline) {
+      return false;
+    }
+    await ports.sleep(HEADROOM_POLL_MS);
+  }
+}
+
 // src/realPorts.ts
 function isEnoent2(error62) {
   return typeof error62 === "object" && error62 !== null && "code" in error62 && error62.code === "ENOENT";
@@ -55673,7 +56202,7 @@ var realFarmFs = {
   },
   hashFile(filePath) {
     try {
-      return (0, import_node_crypto3.createHash)("sha256").update(import_node_fs3.default.readFileSync(filePath)).digest("hex");
+      return (0, import_node_crypto4.createHash)("sha256").update(import_node_fs3.default.readFileSync(filePath)).digest("hex");
     } catch (error62) {
       if (isEnoent2(error62) || isErrorWithCode(error62, "EISDIR")) {
         return void 0;
@@ -55708,7 +56237,7 @@ var realRunPort = {
   }
 };
 function expandHome(filePath) {
-  return filePath.startsWith("~/") ? import_node_path6.default.join(import_node_os2.default.homedir(), filePath.slice(1)) : filePath;
+  return filePath.startsWith("~/") ? import_node_path8.default.join(import_node_os2.default.homedir(), filePath.slice(1)) : filePath;
 }
 var MACOS_GUI_SESSION_MANAGER = "Aqua";
 function hasDesktopSession() {
@@ -55784,7 +56313,7 @@ function spawnDetachedSupervisor(paths, subcommand, logPath) {
   return spawnDetachedDaemon(selfInvocation([subcommand]), paths, subcommand, logPath);
 }
 function spawnDetachedDaemon(invocation, paths, subcommand, logPath) {
-  import_node_fs3.default.mkdirSync(import_node_path6.default.dirname(logPath), { recursive: true });
+  import_node_fs3.default.mkdirSync(import_node_path8.default.dirname(logPath), { recursive: true });
   const logFd = import_node_fs3.default.openSync(logPath, "a");
   try {
     const child = (0, import_node_child_process2.spawn)(invocation.command, invocation.args, detachedDaemonSpawnOptions(logFd, { ...process.env, AGENT_SHIM_HOME: paths.root }));
@@ -55825,10 +56354,11 @@ var realHeadroomSocketTrust = {
 };
 function realHeadroomPort(paths, options) {
   return {
-    ensure: () => {
+    ensure: ({ routesProvider }) => {
       const up = ensureHeadroom({
         paths,
         launcherPid: process.pid,
+        ...routesProvider ? { requiredAllowlistHash: () => hashAllowlist(currentHeadroomAllowlist(realFarmFs, paths)) } : {},
         ports: {
           fs: realFarmFs,
           // Zombie-aware on purpose: a supervisor that died while still a child of this launcher sits unreaped until the launcher itself exits, and a defunct supervisor answering signal 0 as alive would stretch every launch to the full start timeout.
@@ -55882,7 +56412,7 @@ function listVersionsDir(dir) {
     throw error62;
   }
   return entries.filter((entry) => entry.isFile()).map((entry) => {
-    const fullPath = import_node_path6.default.join(dir, entry.name);
+    const fullPath = import_node_path8.default.join(dir, entry.name);
     const stat = import_node_fs3.default.statSync(fullPath);
     return {
       name: entry.name,
@@ -55897,7 +56427,7 @@ function windowsPathExtensions(pathext) {
   return (pathext ?? WINDOWS_DEFAULT_PATHEXT).split(";").map((ext) => ext.trim()).filter((ext) => ext.length > 0);
 }
 function resolveExecutableCandidate(dir, name, env) {
-  const candidate = import_node_path6.default.join(dir, name);
+  const candidate = import_node_path8.default.join(dir, name);
   if (env.platform === "win32") {
     const extensions = windowsPathExtensions(env.pathext);
     const alreadyHasRecognisedExtension = extensions.some((ext) => candidate.toLowerCase().endsWith(ext.toLowerCase()));
@@ -55946,13 +56476,13 @@ function resolveOwnExecutablePath(env) {
   if (env.argv1 !== void 0 && !env.argv1.includes("/") && !env.argv1.includes("\\")) {
     return searchPathForExecutable(env.pathDirs, env.argv1, env.findExecutableInDir) ?? env.execPath;
   }
-  const candidate = env.argv1 === void 0 ? env.execPath : import_node_path6.default.resolve(env.cwd, env.argv1);
-  const candidateDir = import_node_path6.default.dirname(candidate);
-  const candidateDirOnPath = env.pathDirs.some((dir) => import_node_path6.default.resolve(dir) === candidateDir);
+  const candidate = env.argv1 === void 0 ? env.execPath : import_node_path8.default.resolve(env.cwd, env.argv1);
+  const candidateDir = import_node_path8.default.dirname(candidate);
+  const candidateDirOnPath = env.pathDirs.some((dir) => import_node_path8.default.resolve(dir) === candidateDir);
   if (candidateDirOnPath) {
     return candidate;
   }
-  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path6.default.basename(candidate), env.findExecutableInDir);
+  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path8.default.basename(candidate), env.findExecutableInDir);
   return viaPath ?? candidate;
 }
 function realOwnExecutablePath() {
@@ -55960,7 +56490,7 @@ function realOwnExecutablePath() {
     argv1: process.argv[1],
     execPath: process.execPath,
     cwd: process.cwd(),
-    pathDirs: (process.env.PATH ?? "").split(import_node_path6.default.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(import_node_path8.default.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir
   });
 }
@@ -55970,12 +56500,12 @@ function resolveContentSourcePath(env) {
 function realContentSourcePath() {
   return resolveContentSourcePath({ isSea: (0, import_node_sea.isSea)(), execPath: process.execPath, argv1: process.argv[1] });
 }
-function realResolveClaudeBinary(ownInstallDirs) {
+function realResolveClaudeBinary(isOwnBinary) {
   return () => discoverClaudeBinary({
     listVersionsDir,
-    pathDirs: (process.env.PATH ?? "").split(import_node_path6.default.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(import_node_path8.default.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir,
-    ownInstallDirs: [...ownInstallDirs]
+    isOwnBinary
   });
 }
 
@@ -56017,16 +56547,22 @@ function commandFilename(ownExecutablePath, commandName) {
 function isInvokedAsClaude(invokedName) {
   return invokedName === "claude" || invokedName.toLowerCase() === "claude.exe";
 }
-function resolveOwnInstallDirs(paths, ownExecutablePath) {
-  const dirs = [import_node_path7.default.dirname(ownExecutablePath)];
+function resolveOwnBinaryCheck(paths, contentSourcePath) {
   const state = readJson(paths.claudeShimFile, ClaudeShimStateSchema);
-  if (state !== void 0) {
-    dirs.push(import_node_path7.default.dirname(state.targetPath));
-  }
-  return dirs;
+  const recordedTarget = state === void 0 ? void 0 : import_node_path9.default.resolve(state.targetPath);
+  let ownStat;
+  return (candidate) => {
+    if (recordedTarget !== void 0 && import_node_path9.default.resolve(candidate) === recordedTarget) {
+      return true;
+    }
+    ownStat ??= statOrUndefined(contentSourcePath);
+    const candidateStat = statOrUndefined(candidate);
+    return ownStat !== void 0 && candidateStat !== void 0 && // A platform reporting no inode number for either file must not read every candidate as this tool.
+    ownStat.ino !== 0 && candidateStat.ino !== 0 && candidateStat.dev === ownStat.dev && candidateStat.ino === ownStat.ino;
+  };
 }
 function resolveClaudeTargetPath(ownExecutablePath, dir) {
-  return import_node_path7.default.join(dir ?? import_node_path7.default.dirname(ownExecutablePath), claudeTargetFilename(ownExecutablePath));
+  return import_node_path9.default.join(dir ?? import_node_path9.default.dirname(ownExecutablePath), claudeTargetFilename(ownExecutablePath));
 }
 function isEnoent3(error62) {
   return typeof error62 === "object" && error62 !== null && "code" in error62 && error62.code === "ENOENT";
@@ -56044,6 +56580,16 @@ function lstatOrUndefined(target) {
     throw error62;
   }
 }
+function statOrUndefined(target) {
+  try {
+    return import_node_fs4.default.statSync(target);
+  } catch (error62) {
+    if (isEnoent3(error62)) {
+      return void 0;
+    }
+    throw error62;
+  }
+}
 var nodeLinkFs = { link: import_node_fs4.default.linkSync, copyFile: import_node_fs4.default.copyFileSync, chmod: import_node_fs4.default.chmodSync };
 function enableClaudeShim(params, linkFs = nodeLinkFs) {
   const realContentPath = import_node_fs4.default.realpathSync(params.contentSourcePath);
@@ -56051,13 +56597,13 @@ function enableClaudeShim(params, linkFs = nodeLinkFs) {
     throw new UnsupportedShimSourceError(realContentPath);
   }
   const targetPath = resolveClaudeTargetPath(params.ownExecutablePath, params.dir);
-  import_node_fs4.default.mkdirSync(import_node_path7.default.dirname(targetPath), { recursive: true });
+  import_node_fs4.default.mkdirSync(import_node_path9.default.dirname(targetPath), { recursive: true });
   const existing = lstatOrUndefined(targetPath);
   if (existing !== void 0) {
     const ownStat = import_node_fs4.default.statSync(realContentPath);
     const state = readJson(params.paths.claudeShimFile, ClaudeShimStateSchema);
     const sameInode = existing.dev === ownStat.dev && existing.ino === ownStat.ino;
-    const markerMatches = state !== void 0 && import_node_path7.default.resolve(state.targetPath) === targetPath;
+    const markerMatches = state !== void 0 && import_node_path9.default.resolve(state.targetPath) === targetPath;
     if (!sameInode && !markerMatches && !params.force) {
       throw new ForeignClaudeEntryError(targetPath, "enable");
     }
@@ -56082,7 +56628,7 @@ function enableClaudeShim(params, linkFs = nodeLinkFs) {
 function disableClaudeShim(params) {
   const realContentPath = import_node_fs4.default.realpathSync(params.contentSourcePath);
   const state = readJson(params.paths.claudeShimFile, ClaudeShimStateSchema);
-  const targetPath = params.dir !== void 0 ? import_node_path7.default.join(params.dir, claudeTargetFilename(params.ownExecutablePath)) : state?.targetPath ?? resolveClaudeTargetPath(params.ownExecutablePath);
+  const targetPath = params.dir !== void 0 ? import_node_path9.default.join(params.dir, claudeTargetFilename(params.ownExecutablePath)) : state?.targetPath ?? resolveClaudeTargetPath(params.ownExecutablePath);
   const existing = lstatOrUndefined(targetPath);
   if (existing === void 0) {
     if (state !== void 0) {
@@ -56092,7 +56638,7 @@ function disableClaudeShim(params) {
   }
   const ownStat = import_node_fs4.default.statSync(realContentPath);
   const sameInode = existing.dev === ownStat.dev && existing.ino === ownStat.ino;
-  const markerMatches = state !== void 0 && import_node_path7.default.resolve(state.targetPath) === targetPath;
+  const markerMatches = state !== void 0 && import_node_path9.default.resolve(state.targetPath) === targetPath;
   if (!sameInode && !markerMatches && !params.force) {
     throw new ForeignClaudeEntryError(targetPath, "disable");
   }
@@ -56101,15 +56647,15 @@ function disableClaudeShim(params) {
   return { action: "disabled", targetPath };
 }
 function findPathShadow(params) {
-  const resolvedTargetDir = import_node_path7.default.resolve(params.targetDir);
+  const resolvedTargetDir = import_node_path9.default.resolve(params.targetDir);
   for (const dir of params.pathDirs) {
     const found = params.findExecutableInDir(dir, params.targetFilename);
     if (found === void 0) {
       continue;
     }
-    return import_node_path7.default.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
+    return import_node_path9.default.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
   }
-  return params.pathDirs.some((dir) => import_node_path7.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
+  return params.pathDirs.some((dir) => import_node_path9.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
 }
 function registerShimCommand(program2, deps) {
   const { paths } = deps;
@@ -56127,21 +56673,21 @@ function registerShimCommand(program2, deps) {
       ownExecutablePath,
       contentSourcePath,
       platform: process.platform,
-      ...options.dir === void 0 ? {} : { dir: import_node_path7.default.resolve(options.dir) },
+      ...options.dir === void 0 ? {} : { dir: import_node_path9.default.resolve(options.dir) },
       force: options.force ?? false
     });
     console.log(`${result.action === "enabled" ? "Installed" : "Reinstalled"} \`claude\` at ${result.targetPath} (${result.method}).`);
     const shadow = findPathShadow({
-      pathDirs: (process.env.PATH ?? "").split(import_node_path7.default.delimiter).filter((dir) => dir !== ""),
-      targetDir: import_node_path7.default.dirname(result.targetPath),
-      targetFilename: import_node_path7.default.basename(result.targetPath),
+      pathDirs: (process.env.PATH ?? "").split(import_node_path9.default.delimiter).filter((dir) => dir !== ""),
+      targetDir: import_node_path9.default.dirname(result.targetPath),
+      targetFilename: import_node_path9.default.basename(result.targetPath),
       findExecutableInDir
     });
     if (shadow.status === "not-on-path") {
-      console.warn(`warning: ${import_node_path7.default.dirname(result.targetPath)} is not on PATH \u2014 add it, or use \`agent-shim run\` instead.`);
+      console.warn(`warning: ${import_node_path9.default.dirname(result.targetPath)} is not on PATH \u2014 add it, or use \`agent-shim run\` instead.`);
     } else if (shadow.status === "shadowed") {
       console.warn(
-        `warning: 'claude' on PATH currently resolves to ${shadow.by}, not ${result.targetPath}. Put ${import_node_path7.default.dirname(result.targetPath)} ahead of it on PATH.`
+        `warning: 'claude' on PATH currently resolves to ${shadow.by}, not ${result.targetPath}. Put ${import_node_path9.default.dirname(result.targetPath)} ahead of it on PATH.`
       );
     }
   });
@@ -56153,7 +56699,7 @@ function registerShimCommand(program2, deps) {
       paths,
       ownExecutablePath,
       contentSourcePath,
-      ...options.dir === void 0 ? {} : { dir: import_node_path7.default.resolve(options.dir) },
+      ...options.dir === void 0 ? {} : { dir: import_node_path9.default.resolve(options.dir) },
       force: options.force ?? false
     });
     console.log(
@@ -56209,7 +56755,7 @@ function aliasLegacyWireHeaders(headers) {
 // src/configure.ts
 var import_node_fs8 = __toESM(require("node:fs"), 1);
 var import_node_os4 = __toESM(require("node:os"), 1);
-var import_node_path18 = __toESM(require("node:path"), 1);
+var import_node_path20 = __toESM(require("node:path"), 1);
 
 // node_modules/.pnpm/@clack+core@1.5.1/node_modules/@clack/core/dist/index.mjs
 var import_node_util3 = require("node:util");
@@ -57478,10 +58024,10 @@ function classifyEntries(names, options) {
 
 // src/identityStore.ts
 var import_node_fs6 = __toESM(require("node:fs"), 1);
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 
 // src/launcher/identity.ts
-var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_path10 = __toESM(require("node:path"), 1);
 function poolNameOf(selector) {
   return selector.startsWith(POOL_SELECTOR_PREFIX) ? selector.slice(POOL_SELECTOR_PREFIX.length) : void 0;
 }
@@ -57530,12 +58076,12 @@ function decideConfigProfile(params) {
   return { source: "none" };
 }
 function loadIdentity(identitiesDir, name, fs19) {
-  return loadConfigFile(import_node_path8.default.join(identitiesDir, name, "identity.json"), IdentitySchema, fs19.readConfigFile);
+  return loadConfigFile(import_node_path10.default.join(identitiesDir, name, "identity.json"), IdentitySchema, fs19.readConfigFile);
 }
 
 // src/configProfilesStore.ts
 var import_node_fs5 = __toESM(require("node:fs"), 1);
-var import_node_path9 = __toESM(require("node:path"), 1);
+var import_node_path11 = __toESM(require("node:path"), 1);
 var ProfileNotFoundError = class extends CliError {
   constructor(profileName) {
     super(`No configuration profile named "${profileName}". Run \`agent-shim profile add ${profileName}\` first.`);
@@ -57561,7 +58107,7 @@ var InvalidCategoryNameError = class extends CliError {
   categoryName;
 };
 function profileJsonPath(paths, name) {
-  return import_node_path9.default.join(paths.configProfilesDir, `${name}.json`);
+  return import_node_path11.default.join(paths.configProfilesDir, `${name}.json`);
 }
 function profileExists(paths, name) {
   return import_node_fs5.default.existsSync(profileJsonPath(paths, name));
@@ -57722,8 +58268,8 @@ function removePool(paths, name) {
 }
 
 // src/launcher/lock.ts
-var import_node_crypto4 = require("node:crypto");
-var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_crypto5 = require("node:crypto");
+var import_node_path12 = __toESM(require("node:path"), 1);
 var DEFAULT_STALE_AFTER_MS = 12e4;
 var DEFAULT_RETRY_DELAY_MS = 50;
 var DEFAULT_MAX_ATTEMPTS = 200;
@@ -57742,7 +58288,7 @@ var IdentityLockBusyError = class extends CliError {
   holderPid;
 };
 function identityLockPath(dir, identity) {
-  return import_node_path10.default.join(dir, `.${identity}.lock`);
+  return import_node_path12.default.join(dir, `.${identity}.lock`);
 }
 function parseLockRecord(raw) {
   if (raw === void 0) {
@@ -57771,7 +58317,7 @@ function acquireIdentityLock(params) {
   const staleAfterMs = params.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
   const retryDelayMs = params.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
   const maxAttempts = params.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-  const token = (0, import_node_crypto4.randomUUID)();
+  const token = (0, import_node_crypto5.randomUUID)();
   if (params.fs.lstat(params.dir) === void 0) {
     params.fs.mkdirp(params.dir);
   }
@@ -57836,7 +58382,7 @@ var InvalidIdentityNameError = class extends CliError {
   attemptedName;
 };
 function identityJsonPath(paths, name) {
-  return import_node_path11.default.join(paths.identitiesDir, name, "identity.json");
+  return import_node_path13.default.join(paths.identitiesDir, name, "identity.json");
 }
 function identityExists(paths, name) {
   return import_node_fs6.default.existsSync(identityJsonPath(paths, name));
@@ -57937,7 +58483,7 @@ function setIdentityCredential(paths, identityName, change) {
   });
 }
 function belongsToIdentity(entry, name) {
-  return entry === name || entry === import_node_path11.default.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
+  return entry === name || entry === import_node_path13.default.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
 }
 function removeIdentity(paths, name) {
   if (!identityExists(paths, name)) {
@@ -57945,7 +58491,7 @@ function removeIdentity(paths, name) {
   }
   for (const entry of import_node_fs6.default.readdirSync(paths.identitiesDir)) {
     if (belongsToIdentity(entry, name)) {
-      import_node_fs6.default.rmSync(import_node_path11.default.join(paths.identitiesDir, entry), { recursive: true, force: true });
+      import_node_fs6.default.rmSync(import_node_path13.default.join(paths.identitiesDir, entry), { recursive: true, force: true });
     }
   }
   if (readActiveIdentity(paths) === name) {
@@ -58044,32 +58590,32 @@ function removeDirectoryRule(paths, rulePath) {
 }
 
 // src/launcher/cascade.ts
-var import_node_path14 = __toESM(require("node:path"), 1);
+var import_node_path16 = __toESM(require("node:path"), 1);
 
 // src/pathNorm.ts
-var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
 function expandTilde(value, home) {
   if (value === "~") {
     return home;
   }
   if (value.startsWith("~/")) {
-    return import_node_path12.default.join(home, value.slice(2));
+    return import_node_path14.default.join(home, value.slice(2));
   }
   return value;
 }
 function normaliseRulePath(rulePath, home) {
-  return import_node_path12.default.resolve(expandTilde(rulePath, home));
+  return import_node_path14.default.resolve(expandTilde(rulePath, home));
 }
 function isAncestorOrSelf(ancestor, descendant) {
   if (ancestor === descendant) {
     return true;
   }
-  const withSeparator = ancestor.endsWith(import_node_path12.default.sep) ? ancestor : `${ancestor}${import_node_path12.default.sep}`;
+  const withSeparator = ancestor.endsWith(import_node_path14.default.sep) ? ancestor : `${ancestor}${import_node_path14.default.sep}`;
   return descendant.startsWith(withSeparator);
 }
 
 // src/resolve/walk.ts
-var import_node_path13 = __toESM(require("node:path"), 1);
+var import_node_path15 = __toESM(require("node:path"), 1);
 
 // src/resolve/extends.ts
 function lineariseProfile(rootName, load) {
@@ -58137,10 +58683,10 @@ function profileLayers(rootName, load, startId) {
 
 // src/resolve/walk.ts
 function walkDirectoryAncestors(cwd, options) {
-  const limit = import_node_path13.default.resolve(options.limit ?? options.home);
+  const limit = import_node_path15.default.resolve(options.limit ?? options.home);
   const isReadable = options.isReadable ?? (() => true);
   const collected = [];
-  let current = import_node_path13.default.resolve(cwd);
+  let current = import_node_path15.default.resolve(cwd);
   for (; ; ) {
     if (!isReadable(current)) {
       break;
@@ -58149,7 +58695,7 @@ function walkDirectoryAncestors(cwd, options) {
     if (current === limit) {
       break;
     }
-    const parent = import_node_path13.default.dirname(current);
+    const parent = import_node_path15.default.dirname(current);
     if (parent === current) {
       break;
     }
@@ -58242,7 +58788,7 @@ function loadCascadeInput(params) {
   const globalConfig2 = loadConfigFile(params.paths.globalConfigFile, GlobalConfigSchema, params.read);
   const directoryRules = loadConfigFile(params.paths.directoryRulesFile, DirectoryRulesSchema, params.read);
   const loadProfile = (name) => {
-    const filepath = import_node_path14.default.join(params.paths.configProfilesDir, `${name}.json`);
+    const filepath = import_node_path16.default.join(params.paths.configProfilesDir, `${name}.json`);
     const loaded = loadConfigFile(filepath, ConfigProfileSchema, params.read);
     if (loaded === void 0) {
       return void 0;
@@ -58257,8 +58803,8 @@ function loadCascadeInput(params) {
   });
   const levels = [];
   for (const dir of dirs) {
-    const portable = loadConfigFile(import_node_path14.default.join(dir, PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path14.default.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read);
-    const portableLocal = loadConfigFile(import_node_path14.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path14.default.join(dir, LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read);
+    const portable = loadConfigFile(import_node_path16.default.join(dir, PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path16.default.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read);
+    const portableLocal = loadConfigFile(import_node_path16.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path16.default.join(dir, LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read);
     const rules = (directoryRules?.config.rules ?? []).map((rule, index) => ({ rule, index })).filter(({ rule }) => normaliseRulePath(rule.path, params.home) === dir).map(({ rule, index }) => {
       const entryOrder = directoryRules?.ruleEntryOrders[index];
       return {
@@ -58307,7 +58853,7 @@ function readDirectorySelections(loaded) {
 }
 
 // src/launcher/farm.ts
-var import_node_path16 = __toESM(require("node:path"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 
 // src/resolve/reconcile.ts
 function parentOf(rel) {
@@ -58975,7 +59521,7 @@ function dedupeDiagnostics(diagnostics) {
 }
 
 // src/resolve/plan.ts
-var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
 function parentOf2(rel) {
   const index = rel.lastIndexOf("/");
   return index === -1 ? "" : rel.slice(0, index);
@@ -59025,7 +59571,7 @@ function planFarm(params) {
     }
     return value;
   };
-  const linkTarget = (rel) => import_node_path15.default.join(params.facts.claudeHome, rel);
+  const linkTarget = (rel) => import_node_path17.default.join(params.facts.claudeHome, rel);
   const visit2 = (rel) => {
     const fact = params.facts.entries.get(rel);
     const decision = params.decisions.get(rel);
@@ -59158,7 +59704,7 @@ var FarmManifestSchema = external_exports.strictObject({
   links: external_exports.array(external_exports.strictObject({ rel: external_exports.string(), target: external_exports.string() }))
 });
 function readFarmManifest(fs19, farmRoot) {
-  const raw = fs19.readFileUtf8(import_node_path16.default.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs19.readFileUtf8(import_node_path16.default.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
+  const raw = fs19.readFileUtf8(import_node_path18.default.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs19.readFileUtf8(import_node_path18.default.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
   if (raw === void 0) {
     return void 0;
   }
@@ -59174,7 +59720,7 @@ function readFarmManifest(fs19, farmRoot) {
 function buildEntryFacts(params) {
   const entries = /* @__PURE__ */ new Map();
   const visit2 = (rel) => {
-    const absolute = import_node_path16.default.join(params.claudeHome, rel);
+    const absolute = import_node_path18.default.join(params.claudeHome, rel);
     const stat = params.fs.lstat(absolute);
     if (stat === void 0) {
       return void 0;
@@ -59217,7 +59763,7 @@ function buildEntryFacts(params) {
   };
 }
 function listSubtree(fs19, root, rel) {
-  const absolute = import_node_path16.default.join(root, rel);
+  const absolute = import_node_path18.default.join(root, rel);
   const stat = fs19.lstat(absolute);
   if (stat === void 0) {
     return [];
@@ -59247,7 +59793,7 @@ function reconciliationScope(fs19, farmRoot, manifest) {
   if (manifest !== void 0) {
     return topLevelScopeRoots(manifest.materialised);
   }
-  return [...fs19.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs19.lstat(import_node_path16.default.join(farmRoot, name))?.kind === "dir").sort();
+  return [...fs19.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs19.lstat(import_node_path18.default.join(farmRoot, name))?.kind === "dir").sort();
 }
 function collectFarmListing(fs19, farmRoot, scopeRoots) {
   return scopeRoots.flatMap((root) => listSubtree(fs19, farmRoot, root));
@@ -59255,7 +59801,7 @@ function collectFarmListing(fs19, farmRoot, scopeRoots) {
 function collectCanonicalCounterparts(fs19, claudeHome, farmListing) {
   const out = [];
   for (const entry of farmListing) {
-    const absolute = import_node_path16.default.join(claudeHome, entry.rel);
+    const absolute = import_node_path18.default.join(claudeHome, entry.rel);
     const stat = fs19.lstat(absolute);
     if (stat === void 0) {
       continue;
@@ -59285,21 +59831,21 @@ function carryOver(params) {
     if (accounted.has(name)) {
       continue;
     }
-    const stat = params.fs.lstat(import_node_path16.default.join(params.previousRoot, name));
+    const stat = params.fs.lstat(import_node_path18.default.join(params.previousRoot, name));
     if (stat === void 0 || stat.kind === "symlink") {
       continue;
     }
-    if (params.fs.lstat(import_node_path16.default.join(params.farmRoot, name)) !== void 0) {
+    if (params.fs.lstat(import_node_path18.default.join(params.farmRoot, name)) !== void 0) {
       const category = params.classification === void 0 ? void 0 : classifyEntries([name], params.classification).classification.get(name);
       if (category === "runtime") {
-        params.fs.removeRecursive(import_node_path16.default.join(params.previousRoot, name));
+        params.fs.removeRecursive(import_node_path18.default.join(params.previousRoot, name));
         autoResolved.push(name);
         continue;
       }
       collided.push(name);
       continue;
     }
-    params.fs.rename(import_node_path16.default.join(params.previousRoot, name), import_node_path16.default.join(params.farmRoot, name));
+    params.fs.rename(import_node_path18.default.join(params.previousRoot, name), import_node_path18.default.join(params.farmRoot, name));
     carried.push(name);
   }
   return { carried, autoResolved, collided };
@@ -59307,9 +59853,9 @@ function carryOver(params) {
 function buildScratchTree(params) {
   params.fs.mkdirp(params.scratchRoot);
   for (const entry of params.plan.entries) {
-    const absolute = import_node_path16.default.join(params.scratchRoot, entry.rel);
+    const absolute = import_node_path18.default.join(params.scratchRoot, entry.rel);
     if (entry.kind === "link") {
-      params.fs.mkdirp(import_node_path16.default.dirname(absolute));
+      params.fs.mkdirp(import_node_path18.default.dirname(absolute));
       params.fs.symlink(entry.target, absolute);
       continue;
     }
@@ -59318,14 +59864,14 @@ function buildScratchTree(params) {
     }
   }
   params.fs.writeFileUtf8(
-    import_node_path16.default.join(params.scratchRoot, FARM_MANIFEST_FILENAME),
+    import_node_path18.default.join(params.scratchRoot, FARM_MANIFEST_FILENAME),
     `${JSON.stringify(params.manifest, null, 2)}
 `
   );
 }
 function swapIn(params) {
   if (params.fs.lstat(params.farmRoot) === void 0) {
-    params.fs.mkdirp(import_node_path16.default.dirname(params.farmRoot));
+    params.fs.mkdirp(import_node_path18.default.dirname(params.farmRoot));
     params.fs.rename(params.scratchRoot, params.farmRoot);
     return { carried: [], autoResolved: [], collided: [] };
   }
@@ -59349,14 +59895,14 @@ function recoverInterruptedSwap(params) {
   const names = [...params.fs.readdir(params.identitiesDir)].sort();
   const removedScratch = [];
   for (const name of names.filter((candidate) => candidate.startsWith(scratchPrefix))) {
-    params.fs.removeRecursive(import_node_path16.default.join(params.identitiesDir, name));
+    params.fs.removeRecursive(import_node_path18.default.join(params.identitiesDir, name));
     removedScratch.push(name);
   }
   let previous = names.filter((candidate) => candidate.startsWith(previousPrefix));
   let restoredFrom;
   const first = previous[0];
   if (first !== void 0 && params.fs.lstat(params.farmRoot) === void 0) {
-    params.fs.rename(import_node_path16.default.join(params.identitiesDir, first), params.farmRoot);
+    params.fs.rename(import_node_path18.default.join(params.identitiesDir, first), params.farmRoot);
     restoredFrom = first;
     previous = previous.slice(1);
   }
@@ -59364,7 +59910,7 @@ function recoverInterruptedSwap(params) {
   const autoResolved = [];
   const retained = [];
   for (const name of previous) {
-    const previousRoot = import_node_path16.default.join(params.identitiesDir, name);
+    const previousRoot = import_node_path18.default.join(params.identitiesDir, name);
     const result = carryOver({
       fs: params.fs,
       previousRoot,
@@ -59389,7 +59935,7 @@ function recoverInterruptedSwap(params) {
   };
 }
 function recoverFarm(params) {
-  const farmRoot = import_node_path16.default.join(params.identitiesDir, params.identity);
+  const farmRoot = import_node_path18.default.join(params.identitiesDir, params.identity);
   const lock = acquireIdentityLock({
     identity: params.identity,
     dir: params.identitiesDir,
@@ -59448,16 +59994,16 @@ function executeReconciliation(params) {
       });
       continue;
     }
-    const from = import_node_path16.default.join(params.farmRoot, action.rel);
-    const canonical = import_node_path16.default.join(params.claudeHome, action.rel);
+    const from = import_node_path18.default.join(params.farmRoot, action.rel);
+    const canonical = import_node_path18.default.join(params.claudeHome, action.rel);
     if (action.kind === "adopt") {
-      params.fs.mkdirp(import_node_path16.default.dirname(canonical));
+      params.fs.mkdirp(import_node_path18.default.dirname(canonical));
       params.fs.copyRecursive(from, canonical);
       adopted.push(action.rel);
       continue;
     }
     const preserved = `${canonical}.farm-conflict-${String(params.nowMs)}`;
-    params.fs.mkdirp(import_node_path16.default.dirname(canonical));
+    params.fs.mkdirp(import_node_path18.default.dirname(canonical));
     params.fs.copyRecursive(from, preserved);
     conflicts.push(action.rel);
   }
@@ -59482,7 +60028,7 @@ function farmAlreadyMatches(existing, next) {
   return existing.identity === next.identity && existing.claudeHome === next.claudeHome && sameStrings(existing.materialised, next.materialised) && sameLinks(existing.links, next.links);
 }
 function resyncFarm(params) {
-  const farmRoot = import_node_path16.default.join(params.identitiesDir, params.identity);
+  const farmRoot = import_node_path18.default.join(params.identitiesDir, params.identity);
   const lock = acquireIdentityLock({
     identity: params.identity,
     dir: params.identitiesDir,
@@ -59562,8 +60108,8 @@ function resyncFarm(params) {
         diagnostics
       };
     }
-    const scratchRoot = import_node_path16.default.join(params.identitiesDir, `.${params.identity}.scratch.${params.uniqueSuffix}`);
-    const previousRoot = import_node_path16.default.join(params.identitiesDir, `.${params.identity}.previous.${params.uniqueSuffix}`);
+    const scratchRoot = import_node_path18.default.join(params.identitiesDir, `.${params.identity}.scratch.${params.uniqueSuffix}`);
+    const previousRoot = import_node_path18.default.join(params.identitiesDir, `.${params.identity}.previous.${params.uniqueSuffix}`);
     buildScratchTree({ fs: params.fs, scratchRoot, plan: resolved.farm, manifest });
     const swap = swapIn({ fs: params.fs, farmRoot, scratchRoot, previousRoot, classification: params.classification });
     if (swap.retainedPrevious !== void 0) {
@@ -59622,14 +60168,14 @@ function recoveryDiagnostics(recovery, identity) {
 // src/paths.ts
 var import_node_fs7 = __toESM(require("node:fs"), 1);
 var import_node_os3 = __toESM(require("node:os"), 1);
-var import_node_path17 = __toESM(require("node:path"), 1);
+var import_node_path19 = __toESM(require("node:path"), 1);
 function resolveAgentShimHome(env = process.env, home = import_node_os3.default.homedir(), isDirectory = isExistingDirectory) {
   const fromEnv = env.AGENT_SHIM_HOME;
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  const current = import_node_path17.default.join(home, HOME_DIRNAME);
-  const legacy = import_node_path17.default.join(home, LEGACY_HOME_DIRNAME);
+  const current = import_node_path19.default.join(home, HOME_DIRNAME);
+  const legacy = import_node_path19.default.join(home, LEGACY_HOME_DIRNAME);
   return !isDirectory(current) && isDirectory(legacy) ? legacy : current;
 }
 function isExistingDirectory(candidate) {
@@ -59640,40 +60186,40 @@ function resolveClaudeHome() {
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  return import_node_path17.default.join(import_node_os3.default.homedir(), ".claude");
+  return import_node_path19.default.join(import_node_os3.default.homedir(), ".claude");
 }
 function buildLayoutPaths(root) {
   return {
     root,
-    identitiesDir: import_node_path17.default.join(root, "identities"),
-    configProfilesDir: import_node_path17.default.join(root, "config-profiles"),
-    providersDir: import_node_path17.default.join(root, "providers"),
-    directoryRulesFile: import_node_path17.default.join(root, "directory-rules.json"),
-    activeIdentityFile: import_node_path17.default.join(root, "active-identity"),
-    globalConfigFile: import_node_path17.default.join(root, "config.json"),
-    categoriesLocalFile: import_node_path17.default.join(root, "categories.local.json"),
-    claudeShimFile: import_node_path17.default.join(root, "claude-shim.json"),
-    headroomDir: import_node_path17.default.join(root, "headroom"),
-    headroomStateFile: import_node_path17.default.join(root, "headroom", `state.v${String(HEADROOM_STATE_SCHEMA_VERSION)}.json`),
-    headroomSocketDir: import_node_path17.default.join(root, "headroom", "run"),
-    headroomLockFile: import_node_path17.default.join(root, "headroom", "start.lock"),
-    headroomSessionsDir: import_node_path17.default.join(root, "headroom", "sessions"),
-    logsDir: import_node_path17.default.join(root, "logs"),
-    headroomLogPath: import_node_path17.default.join(root, "logs", "headroom.log"),
-    frontdoorDir: import_node_path17.default.join(root, "frontdoor"),
-    frontdoorCaDir: import_node_path17.default.join(root, "frontdoor", "ca"),
-    frontdoorCaCertFile: import_node_path17.default.join(root, "frontdoor", "ca", "ca.pem"),
-    frontdoorCaKeyFile: import_node_path17.default.join(root, "frontdoor", "ca", "ca.key"),
-    frontdoorCaBundlesDir: import_node_path17.default.join(root, "frontdoor", "ca", "bundles"),
-    frontdoorStateFile: import_node_path17.default.join(root, "frontdoor", "state.json"),
-    frontdoorLockFile: import_node_path17.default.join(root, "frontdoor", "start.lock"),
-    frontdoorControlTokenFile: import_node_path17.default.join(root, "frontdoor", "control-token"),
-    frontdoorSessionsDir: import_node_path17.default.join(root, "frontdoor", "sessions"),
-    frontdoorLogPath: import_node_path17.default.join(root, "logs", "frontdoor.log"),
-    usageDir: import_node_path17.default.join(root, "usage"),
-    usageLogDir: import_node_path17.default.join(root, "usage", "log"),
-    usageSnapshotsDir: import_node_path17.default.join(root, "usage", "snapshots"),
-    usagePicksFile: import_node_path17.default.join(root, "usage", "picks.json")
+    identitiesDir: import_node_path19.default.join(root, "identities"),
+    configProfilesDir: import_node_path19.default.join(root, "config-profiles"),
+    providersDir: import_node_path19.default.join(root, "providers"),
+    directoryRulesFile: import_node_path19.default.join(root, "directory-rules.json"),
+    activeIdentityFile: import_node_path19.default.join(root, "active-identity"),
+    globalConfigFile: import_node_path19.default.join(root, "config.json"),
+    categoriesLocalFile: import_node_path19.default.join(root, "categories.local.json"),
+    claudeShimFile: import_node_path19.default.join(root, "claude-shim.json"),
+    headroomDir: import_node_path19.default.join(root, "headroom"),
+    headroomStateFile: import_node_path19.default.join(root, "headroom", `state.v${String(HEADROOM_STATE_SCHEMA_VERSION)}.json`),
+    headroomSocketDir: import_node_path19.default.join(root, "headroom", "run"),
+    headroomLockFile: import_node_path19.default.join(root, "headroom", "start.lock"),
+    headroomSessionsDir: import_node_path19.default.join(root, "headroom", "sessions"),
+    logsDir: import_node_path19.default.join(root, "logs"),
+    headroomLogPath: import_node_path19.default.join(root, "logs", "headroom.log"),
+    frontdoorDir: import_node_path19.default.join(root, "frontdoor"),
+    frontdoorCaDir: import_node_path19.default.join(root, "frontdoor", "ca"),
+    frontdoorCaCertFile: import_node_path19.default.join(root, "frontdoor", "ca", "ca.pem"),
+    frontdoorCaKeyFile: import_node_path19.default.join(root, "frontdoor", "ca", "ca.key"),
+    frontdoorCaBundlesDir: import_node_path19.default.join(root, "frontdoor", "ca", "bundles"),
+    frontdoorStateFile: import_node_path19.default.join(root, "frontdoor", "state.json"),
+    frontdoorLockFile: import_node_path19.default.join(root, "frontdoor", "start.lock"),
+    frontdoorControlTokenFile: import_node_path19.default.join(root, "frontdoor", "control-token"),
+    frontdoorSessionsDir: import_node_path19.default.join(root, "frontdoor", "sessions"),
+    frontdoorLogPath: import_node_path19.default.join(root, "logs", "frontdoor.log"),
+    usageDir: import_node_path19.default.join(root, "usage"),
+    usageLogDir: import_node_path19.default.join(root, "usage", "log"),
+    usageSnapshotsDir: import_node_path19.default.join(root, "usage", "snapshots"),
+    usagePicksFile: import_node_path19.default.join(root, "usage", "picks.json")
   };
 }
 function resolveLayoutPaths() {
@@ -59755,7 +60301,7 @@ function chooseWriteTarget(params) {
   for (let index = params.levels.length - 1; index >= 0; index -= 1) {
     const level = params.levels[index];
     if (level !== void 0 && (level.hasPortable || level.hasPortableLocal)) {
-      return { tier: "portable-local", localConfigPath: import_node_path18.default.join(level.dir, level.portableLocalFilename) };
+      return { tier: "portable-local", localConfigPath: import_node_path20.default.join(level.dir, level.portableLocalFilename) };
     }
   }
   const normalisedCwd = normaliseRulePath(params.cwd, params.home);
@@ -59848,11 +60394,11 @@ function buildWriteTargetLevels(cwd, home, walkUpLimit) {
   const limit = walkUpLimit === void 0 ? void 0 : expandTilde(walkUpLimit, home);
   const dirs = walkDirectoryAncestors(cwd, { home, ...limit === void 0 ? {} : { limit } });
   return dirs.map((dir) => {
-    const hasLocal = import_node_fs8.default.existsSync(import_node_path18.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME));
-    const hasLegacyLocal = import_node_fs8.default.existsSync(import_node_path18.default.join(dir, LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME));
+    const hasLocal = import_node_fs8.default.existsSync(import_node_path20.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME));
+    const hasLegacyLocal = import_node_fs8.default.existsSync(import_node_path20.default.join(dir, LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME));
     return {
       dir,
-      hasPortable: import_node_fs8.default.existsSync(import_node_path18.default.join(dir, PORTABLE_CONFIG_FILENAME)) || import_node_fs8.default.existsSync(import_node_path18.default.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME)),
+      hasPortable: import_node_fs8.default.existsSync(import_node_path20.default.join(dir, PORTABLE_CONFIG_FILENAME)) || import_node_fs8.default.existsSync(import_node_path20.default.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME)),
       hasPortableLocal: hasLocal || hasLegacyLocal,
       portableLocalFilename: !hasLocal && hasLegacyLocal ? LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME : PORTABLE_LOCAL_CONFIG_FILENAME
     };
@@ -60196,7 +60742,7 @@ function resolveLaunchIdentity(paths, cwd) {
 }
 
 // src/identityManager.ts
-var import_node_path20 = __toESM(require("node:path"), 1);
+var import_node_path22 = __toESM(require("node:path"), 1);
 
 // src/cli/credentialOption.ts
 var CREDENTIAL_SOURCE_SYNTAX = "env:<VAR>, file:<path>, command:<program and arguments>, op:<op://reference>, keychain:<service>[:<account>], literal:<placeholder>, or a JSON source object";
@@ -60304,7 +60850,7 @@ var CREDENTIAL_COMMAND_TIMEOUT_MS = 1e4;
 var CREDENTIAL_INTERACTIVE_TIMEOUT_MS = 12e4;
 var GROUP_OTHER_PERMISSION_BITS = 63;
 var PERMISSION_BITS2 = 511;
-var OCTAL_RADIX = 8;
+var OCTAL_RADIX2 = 8;
 function commandArgv(source) {
   if ("command" in source) {
     return source.command;
@@ -60397,7 +60943,7 @@ function trySource(source, params) {
     }
     if (read.mode !== void 0 && (read.mode & GROUP_OTHER_PERMISSION_BITS) !== 0) {
       return none(
-        `is readable or writable by group or others (mode ${(read.mode & PERMISSION_BITS2).toString(OCTAL_RADIX)}); run \`chmod 600 ${source.file}\``,
+        `is readable or writable by group or others (mode ${(read.mode & PERMISSION_BITS2).toString(OCTAL_RADIX2)}); run \`chmod 600 ${source.file}\``,
         true
       );
     }
@@ -60465,11 +61011,11 @@ function credentialVariables(target, token) {
 }
 
 // src/launcher/farmResolve.ts
-var import_node_path19 = __toESM(require("node:path"), 1);
+var import_node_path21 = __toESM(require("node:path"), 1);
 async function resolveFarmConflicts(params) {
-  const farmRoot = import_node_path19.default.join(params.identitiesDir, params.identity);
+  const farmRoot = import_node_path21.default.join(params.identitiesDir, params.identity);
   const previousPrefix = `.${params.identity}.previous.`;
-  const previousRoots = [...params.fs.readdir(params.identitiesDir)].filter((name) => name.startsWith(previousPrefix)).sort().map((name) => import_node_path19.default.join(params.identitiesDir, name));
+  const previousRoots = [...params.fs.readdir(params.identitiesDir)].filter((name) => name.startsWith(previousPrefix)).sort().map((name) => import_node_path21.default.join(params.identitiesDir, name));
   const resolved = [];
   const autoResolved = [];
   const removed = [];
@@ -60492,11 +61038,11 @@ async function resolveFarmConflicts(params) {
         continue;
       }
       if (choice === "keep-new") {
-        params.fs.removeRecursive(import_node_path19.default.join(previousRoot, name));
+        params.fs.removeRecursive(import_node_path21.default.join(previousRoot, name));
         continue;
       }
-      params.fs.removeRecursive(import_node_path19.default.join(farmRoot, name));
-      params.fs.rename(import_node_path19.default.join(previousRoot, name), import_node_path19.default.join(farmRoot, name));
+      params.fs.removeRecursive(import_node_path21.default.join(farmRoot, name));
+      params.fs.rename(import_node_path21.default.join(previousRoot, name), import_node_path21.default.join(farmRoot, name));
     }
     if (anySkipped) {
       retained.push(previousRoot);
@@ -60835,7 +61381,7 @@ function toIdentityView(paths, entry) {
   return {
     name: entry.name,
     active: entry.isActive,
-    directory: import_node_path20.default.join(paths.identitiesDir, entry.name),
+    directory: import_node_path22.default.join(paths.identitiesDir, entry.name),
     ...entry.problem === void 0 ? {
       ...entry.identity.defaultConfigProfile === void 0 ? {} : { defaultConfigProfile: entry.identity.defaultConfigProfile },
       allowAmbientCredential: entry.identity.allowAmbientCredential,
@@ -60982,7 +61528,7 @@ function registerIdentityCommand(program2, deps) {
       if (!identityExists(paths, name)) {
         throw new IdentityNotFoundError(name);
       }
-      await confirmRemoval(deps, options.yes, `identity "${name}" and its directory ${import_node_path20.default.join(paths.identitiesDir, name)}`);
+      await confirmRemoval(deps, options.yes, `identity "${name}" and its directory ${import_node_path22.default.join(paths.identitiesDir, name)}`);
       removeIdentity(paths, name);
       reportMutation(options.json, { action: "removed", kind: "identity", name }, () => {
         console.log(`Removed identity "${name}".`);
@@ -61040,7 +61586,7 @@ function registerIdentityCommand(program2, deps) {
 // package.json
 var package_default = {
   name: "agent-shim",
-  version: "8.5.1",
+  version: "8.5.3",
   description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   license: "MIT",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -61136,7 +61682,7 @@ var package_default = {
 };
 
 // src/check.ts
-var import_node_path27 = __toESM(require("node:path"), 1);
+var import_node_path29 = __toESM(require("node:path"), 1);
 
 // src/checkReport.ts
 var import_node_os5 = __toESM(require("node:os"), 1);
@@ -61190,10 +61736,10 @@ function quotaWarnings(snapshot, provider, nowMs) {
 }
 
 // src/usage/poolPick.ts
-var import_node_path24 = __toESM(require("node:path"), 1);
+var import_node_path26 = __toESM(require("node:path"), 1);
 
 // src/usage/account.ts
-var import_node_path21 = __toESM(require("node:path"), 1);
+var import_node_path23 = __toESM(require("node:path"), 1);
 
 // src/usage/schema.ts
 var USAGE_SCHEMA_VERSION = 1;
@@ -61362,7 +61908,7 @@ function isIdentityName(name) {
   return IdentitySchema.shape.name.safeParse(name).success;
 }
 function claudeJsonPath(identitiesDir, identity) {
-  return import_node_path21.default.join(identitiesDir, identity, CLAUDE_JSON);
+  return import_node_path23.default.join(identitiesDir, identity, CLAUDE_JSON);
 }
 function readAccountMetadata(fs19, identitiesDir, identity) {
   if (!isIdentityName(identity)) {
@@ -62170,7 +62716,7 @@ function rankPool(input2) {
 }
 
 // src/usage/read.ts
-var import_node_path22 = __toESM(require("node:path"), 1);
+var import_node_path24 = __toESM(require("node:path"), 1);
 var SEGMENT_RE = /^(\d{4}-\d{2}-\d{2})\.(\d+)\.jsonl$/;
 var DAY_MS = 864e5;
 function segmentDay(epochMs) {
@@ -62197,7 +62743,7 @@ function readUsageLog(fs19, logDir, options = {}) {
     if (sinceMs !== void 0 && segment.endsAt <= sinceMs) {
       continue;
     }
-    const contents = fs19.readFileUtf8(import_node_path22.default.join(logDir, segment.name));
+    const contents = fs19.readFileUtf8(import_node_path24.default.join(logDir, segment.name));
     if (contents === void 0) {
       continue;
     }
@@ -62239,7 +62785,7 @@ function snapshotPath(snapshotsDir, identity) {
   if (!isIdentityName(identity)) {
     throw new Error(`"${identity}" is not a valid identity name.`);
   }
-  return import_node_path22.default.join(snapshotsDir, `${identity}.json`);
+  return import_node_path24.default.join(snapshotsDir, `${identity}.json`);
 }
 function readUsageSnapshot(fs19, snapshotsDir, identity) {
   const file2 = snapshotPath(snapshotsDir, identity);
@@ -62323,7 +62869,7 @@ function summariseUsage(records) {
 }
 
 // src/usage/store.ts
-var import_node_path23 = __toESM(require("node:path"), 1);
+var import_node_path25 = __toESM(require("node:path"), 1);
 var DAY_MS2 = 864e5;
 var DAYS_IN_WEEK = 7;
 var USAGE_RETENTION_MS = DAYS_IN_WEEK * DAY_MS2;
@@ -62331,7 +62877,7 @@ function pruneUsageLog(fs19, logDir, nowMs) {
   const cutoff = nowMs - USAGE_RETENTION_MS;
   for (const segment of listLogSegments(fs19, logDir)) {
     if (segment.endsAt <= cutoff) {
-      fs19.removeRecursive(import_node_path23.default.join(logDir, segment.name));
+      fs19.removeRecursive(import_node_path25.default.join(logDir, segment.name));
     }
   }
 }
@@ -62412,7 +62958,7 @@ function createUsageStore(deps) {
         pruneUsageLog(fs19, paths.usageLogDir, nowMs);
         prunedDay = day;
       }
-      fs19.appendFilePrivate(import_node_path23.default.join(paths.usageLogDir, segmentName(day, deps.pid)), `${JSON.stringify(record2)}
+      fs19.appendFilePrivate(import_node_path25.default.join(paths.usageLogDir, segmentName(day, deps.pid)), `${JSON.stringify(record2)}
 `);
       if (record2.identity !== void 0) {
         rewriteSnapshot(record2.identity, (current) => ({ ...current?.providers, [record2.provider]: foldProviderState(current?.providers[record2.provider], record2) }));
@@ -62488,7 +63034,7 @@ function recordStickyPick(fs19, picksFile, directory, identity, nowMs) {
   const current = readPicksFile(fs19, picksFile).file.picks;
   const kept = Object.entries(current).filter(([, entry]) => nowMs - Date.parse(entry.at) <= USAGE_RETENTION_MS);
   const next = { schemaVersion: SCHEMA_VERSION, picks: { ...Object.fromEntries(kept), [directory]: { identity, at: new Date(nowMs).toISOString() } } };
-  fs19.mkdirPrivate(import_node_path24.default.dirname(picksFile));
+  fs19.mkdirPrivate(import_node_path26.default.dirname(picksFile));
   fs19.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
 `);
 }
@@ -62582,7 +63128,7 @@ function collectPoolPick(params) {
 
 // src/providersStore.ts
 var import_node_fs9 = __toESM(require("node:fs"), 1);
-var import_node_path25 = __toESM(require("node:path"), 1);
+var import_node_path27 = __toESM(require("node:path"), 1);
 var ProviderNotFoundError = class extends CliError {
   constructor(name) {
     super(`No provider named "${name}". Run \`agent-shim provider add ${name}\` first.`);
@@ -62611,7 +63157,7 @@ var InvalidProviderNameError = class extends CliError {
 };
 var PROVIDER_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._@-]*$/;
 function providerJsonPath(paths, name) {
-  return import_node_path25.default.join(paths.providersDir, `${name}.json`);
+  return import_node_path27.default.join(paths.providersDir, `${name}.json`);
 }
 function providerExists(paths, name) {
   return import_node_fs9.default.existsSync(providerJsonPath(paths, name));
@@ -62687,7 +63233,7 @@ function readProvider(paths, name) {
   return parseProviderFile(filePath, raw);
 }
 function loadProvider(providersDir, name, port) {
-  const filePath = import_node_path25.default.join(providersDir, `${name}.json`);
+  const filePath = import_node_path27.default.join(providersDir, `${name}.json`);
   const raw = port.readConfigFile(filePath);
   return raw === void 0 ? void 0 : parseProviderFile(filePath, raw);
 }
@@ -62849,7 +63395,7 @@ function resolveProvider(params) {
 }
 
 // src/checkReport.ts
-var import_node_path26 = __toESM(require("node:path"), 1);
+var import_node_path28 = __toESM(require("node:path"), 1);
 
 // src/cli/envBool.ts
 var InvalidEnvBoolError = class extends UsageError {
@@ -63249,10 +63795,10 @@ function collectCheckReport(params) {
   }).input;
   const providerName = cascadeProviderName(cascade);
   const provider = providerName === void 0 ? void 0 : loadCheckProvider(paths, providerName);
-  const farmRoot = identityDecision.name === void 0 ? void 0 : import_node_path26.default.join(paths.identitiesDir, identityDecision.name);
+  const farmRoot = identityDecision.name === void 0 ? void 0 : import_node_path28.default.join(paths.identitiesDir, identityDecision.name);
   const settingsFiles = {
-    "settings.json": realFsPort.readFileUtf8(import_node_path26.default.join(claudeHome, "settings.json")),
-    "settings.local.json": realFsPort.readFileUtf8(import_node_path26.default.join(claudeHome, "settings.local.json"))
+    "settings.json": realFsPort.readFileUtf8(import_node_path28.default.join(claudeHome, "settings.json")),
+    "settings.local.json": realFsPort.readFileUtf8(import_node_path28.default.join(claudeHome, "settings.local.json"))
   };
   const report = runCheck({
     cwd,
@@ -63286,7 +63832,7 @@ function registerCheckCommand(program2, deps) {
   const command = program2.command("check [path]").description(
     "Show what a launch in a directory would share or hide and why, plus credential and settings diagnostics. Never touches the farm or spawns claude."
   ).option("--identity <name>", "Identity to check (defaults to the identity a launch there would resolve).").option("--json", "Print the report as JSON.").option("--strict", "Exit 1 when the report carries any warning, not only on errors.").action((pathArg, options) => {
-    const cwd = pathArg === void 0 ? process.cwd() : import_node_path27.default.resolve(pathArg);
+    const cwd = pathArg === void 0 ? process.cwd() : import_node_path29.default.resolve(pathArg);
     const report = collectCheckReport({ paths, cwd, ...options.identity === void 0 ? {} : { identity: options.identity }, env: process.env });
     if (options.json === true) {
       printJson(checkReportToJson(report));
@@ -63303,123 +63849,10 @@ function registerCheckCommand(program2, deps) {
 }
 
 // src/codex/commands.ts
-var import_node_crypto6 = require("node:crypto");
+var import_node_crypto7 = require("node:crypto");
 var import_node_fs10 = __toESM(require("node:fs"), 1);
 var import_node_os6 = __toESM(require("node:os"), 1);
-var import_node_path29 = __toESM(require("node:path"), 1);
-
-// src/frontdoor/state.ts
-var import_node_path28 = __toESM(require("node:path"), 1);
-var FRONT_DOOR_PROTOCOL = 2;
-var FrontDoorSessionSchema = external_exports.strictObject({ pid: external_exports.number().int().positive(), startedAt: external_exports.number(), token: external_exports.string().min(1) });
-var FrontDoorStateSchema = external_exports.strictObject({
-  /**
-   * The launcher-to-door wire protocol this supervisor speaks, written once it is serving; absent in state written by a release that predates the field, which `ensureFrontDoor` reads as protocol 0. A launcher replaces a door whose protocol is lower than its own (see `FRONT_DOOR_PROTOCOL`).
-   */
-  protocol: external_exports.number().int().nonnegative().optional(),
-  /** The supervisor process serving the front door. Alive means both listeners are up in that process. */
-  supervisorPid: external_exports.number().int().positive().optional(),
-  /** The loopback port the HTTPS provider listener serves on. Absent until the listener has bound and answered its health probe, so "port is set" is itself the ready signal a launcher polls for. */
-  port: external_exports.number().int().positive().optional(),
-  /**
-   * The sticky port preference for the provider listener: kept across crashes, restarts and idle shutdowns so every provider session, whose base URL was frozen at launch, keeps finding the front door at the same address.
-   */
-  lastPort: external_exports.number().int().positive().optional(),
-  /**
-   * The loopback port the CONNECT surface listens on. Absent whenever no supervisor is serving it, so "connectPort is set" is the ready signal an OAuth launch polls for alongside `port`.
-   */
-  connectPort: external_exports.number().int().positive().optional(),
-  /**
-   * The sticky port preference for the CONNECT surface, the exact analogue of `lastPort` for the second listener: it survives every shutdown, because every OAuth session's environment was frozen at launch with HTTPS_PROXY pointing at this address and a restart that moves strands them.
-   */
-  lastConnectPort: external_exports.number().int().positive().optional(),
-  /**
-   * The loopback port the direct listener serves on: the listener a headroom hop tells the daemon to forward routed traffic back to. Sticky like the others, because headroom's allowlist admits its exact origin and an ephemeral port would invalidate the allowlist on every restart.
-   */
-  directPort: external_exports.number().int().positive().optional(),
-  /** The sticky port preference for the direct listener, for the reason `directPort` gives. */
-  lastDirectPort: external_exports.number().int().positive().optional(),
-  /** The last fatal error, kept across shutdowns so `frontdoor status` can explain a front door that is not running. */
-  lastError: external_exports.string().optional()
-});
-function readFrontDoorState(fs19, stateFile) {
-  let raw;
-  try {
-    raw = fs19.readFileUtf8(stateFile);
-  } catch {
-    return void 0;
-  }
-  if (raw === void 0 || raw.trim() === "") {
-    return void 0;
-  }
-  try {
-    const parsed = FrontDoorStateSchema.safeParse(JSON.parse(raw));
-    return parsed.success ? parsed.data : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function writeFrontDoorState(fs19, stateFile, state) {
-  fs19.mkdirp(import_node_path28.default.dirname(stateFile));
-  fs19.writeFileUtf8(stateFile, `${JSON.stringify(state, null, 2)}
-`);
-}
-function frontDoorOrigin(state) {
-  const port = state?.directPort ?? state?.lastDirectPort;
-  return port === void 0 ? void 0 : `http://127.0.0.1:${String(port)}`;
-}
-function writeFrontDoorSession(fs19, sessionsDir, session) {
-  fs19.mkdirPrivate(sessionsDir);
-  fs19.writeFilePrivate(import_node_path28.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
-`);
-}
-function listFrontDoorSessions(fs19, sessionsDir) {
-  const sessions = [];
-  for (const name of fs19.readdir(sessionsDir)) {
-    if (!name.endsWith(".json")) {
-      continue;
-    }
-    try {
-      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs19.readFileUtf8(import_node_path28.default.join(sessionsDir, name)) ?? ""));
-      if (parsed.success) {
-        sessions.push({ pid: parsed.data.pid, startedAt: parsed.data.startedAt });
-      }
-    } catch {
-      continue;
-    }
-  }
-  return sessions.sort((a2, b) => a2.pid - b.pid);
-}
-function removeFrontDoorSession(fs19, sessionsDir, pid) {
-  fs19.removeRecursive(import_node_path28.default.join(sessionsDir, `${String(pid)}.json`));
-}
-function pruneDeadFrontDoorSessions(fs19, sessionsDir, isRunning) {
-  const removed = [];
-  for (const session of listFrontDoorSessions(fs19, sessionsDir)) {
-    if (!isRunning(session.pid)) {
-      removeFrontDoorSession(fs19, sessionsDir, session.pid);
-      removed.push(session.pid);
-    }
-  }
-  return removed;
-}
-function liveSessionTokens(fs19, sessionsDir) {
-  const tokens = /* @__PURE__ */ new Set();
-  for (const name of fs19.readdir(sessionsDir)) {
-    if (!name.endsWith(".json")) {
-      continue;
-    }
-    try {
-      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs19.readFileUtf8(import_node_path28.default.join(sessionsDir, name)) ?? ""));
-      if (parsed.success) {
-        tokens.add(parsed.data.token);
-      }
-    } catch {
-      continue;
-    }
-  }
-  return tokens;
-}
+var import_node_path30 = __toESM(require("node:path"), 1);
 
 // src/codex/agent.ts
 var import_undici = __toESM(require_undici(), 1);
@@ -63568,7 +64001,7 @@ function createCodexAuthStore(authPath, ports) {
 }
 
 // src/codex/upstream.ts
-var import_node_crypto5 = require("node:crypto");
+var import_node_crypto6 = require("node:crypto");
 
 // src/codex/http.ts
 var HTTP_STATUS = {
@@ -63622,7 +64055,7 @@ function sessionIdFor(userId, randomId) {
   if (userId === void 0 || userId === "") {
     return randomId();
   }
-  const hex3 = (0, import_node_crypto5.createHash)("sha256").update(`agent-shim codex session
+  const hex3 = (0, import_node_crypto6.createHash)("sha256").update(`agent-shim codex session
 ${userId}`).digest("hex");
   let next = 0;
   return UUID_TEMPLATE.replace(/x/g, () => hex3.charAt(next++));
@@ -63658,10 +64091,10 @@ async function callCodex(ports, request7, sessionId, signal) {
 // src/codex/commands.ts
 function codexHome(env, home) {
   const fromEnv = env.CODEX_HOME;
-  return fromEnv !== void 0 && fromEnv !== "" ? fromEnv : import_node_path29.default.join(home, ".codex");
+  return fromEnv !== void 0 && fromEnv !== "" ? fromEnv : import_node_path30.default.join(home, ".codex");
 }
 function codexUsageSnapshotPath() {
-  return import_node_path29.default.join(resolveClaudeHome(), "codex-quota.json");
+  return import_node_path30.default.join(resolveClaudeHome(), "codex-quota.json");
 }
 function isEnoent4(error62) {
   return typeof error62 === "object" && error62 !== null && "code" in error62 && error62.code === "ENOENT";
@@ -63690,7 +64123,7 @@ function writeUsageSnapshot(log, snapshot) {
   const target = codexUsageSnapshotPath();
   const temp = `${target}.${String(process.pid)}.tmp`;
   try {
-    import_node_fs10.default.mkdirSync(import_node_path29.default.dirname(target), { recursive: true });
+    import_node_fs10.default.mkdirSync(import_node_path30.default.dirname(target), { recursive: true });
     import_node_fs10.default.writeFileSync(temp, `${JSON.stringify(snapshot, null, 2)}
 `);
     import_node_fs10.default.renameSync(temp, target);
@@ -63701,14 +64134,14 @@ function writeUsageSnapshot(log, snapshot) {
 function createCodexRoutePorts(log) {
   const agent = createUpstreamAgent();
   const upstreamFetch = createUpstreamFetch(agent);
-  const auth = createCodexAuthStore(import_node_path29.default.join(codexHome(process.env, import_node_os6.default.homedir()), "auth.json"), {
+  const auth = createCodexAuthStore(import_node_path30.default.join(codexHome(process.env, import_node_os6.default.homedir()), "auth.json"), {
     fs: realCodexAuthFs,
     fetch: upstreamFetch,
     now: () => /* @__PURE__ */ new Date(),
-    tempSuffix: `${String(process.pid)}.${(0, import_node_crypto6.randomUUID)()}`
+    tempSuffix: `${String(process.pid)}.${(0, import_node_crypto7.randomUUID)()}`
   });
   return {
-    upstream: { fetch: upstreamFetch, auth, timers: realTimers, randomId: import_node_crypto6.randomUUID },
+    upstream: { fetch: upstreamFetch, auth, timers: realTimers, randomId: import_node_crypto7.randomUUID },
     writeUsageSnapshot: (snapshot) => {
       writeUsageSnapshot(log, snapshot);
     },
@@ -63775,85 +64208,10 @@ function registerCodexCommand(program2, deps) {
 }
 
 // src/frontdoor/commands.ts
-var import_node_crypto11 = require("node:crypto");
+var import_node_crypto12 = require("node:crypto");
 var import_node_path31 = __toESM(require("node:path"), 1);
 var import_node_fs11 = __toESM(require("node:fs"), 1);
 
-// src/headroom/socket.ts
-var import_node_path30 = __toESM(require("node:path"), 1);
-var GROUP_OR_OTHER_BITS = 63;
-var OCTAL_RADIX2 = 8;
-var MODE_DIGITS = 4;
-var HEADROOM_SOCKET_SUFFIX = ".sock";
-var HEADROOM_SOCKET_NAME = /^(\d+)\.sock$/;
-var UNIX_SOCKET_PATH_MAX_BYTES = 103;
-var PLATFORMS_WITHOUT_UNIX_SOCKETS = ["win32"];
-function headroomSocketPath(paths, supervisorPid) {
-  return import_node_path30.default.join(paths.headroomSocketDir, `${String(supervisorPid)}${HEADROOM_SOCKET_SUFFIX}`);
-}
-function platformRefusal(platform) {
-  return PLATFORMS_WITHOUT_UNIX_SOCKETS.includes(platform) ? `headroom routing needs a unix domain socket, which headroom cannot serve on ${platform}; agent-shim never falls back to a TCP port for this hop` : void 0;
-}
-function ownerOnlyRefusal(label, target, stat, expected, uid) {
-  if (stat === void 0) {
-    return `the headroom ${label} ${target} does not exist`;
-  }
-  if (stat.kind === "symlink") {
-    return `the headroom ${label} ${target} is a symlink; it must be the real ${expected === "dir" ? "directory" : "socket"}`;
-  }
-  if (stat.kind !== expected) {
-    return `the headroom ${label} ${target} is not a ${expected === "dir" ? "directory" : "socket"}`;
-  }
-  if (stat.uid !== uid) {
-    return `the headroom ${label} ${target} is owned by uid ${String(stat.uid)}, not by this user (uid ${String(uid)})`;
-  }
-  if ((stat.mode & GROUP_OR_OTHER_BITS) !== 0) {
-    return `the headroom ${label} ${target} has mode ${stat.mode.toString(OCTAL_RADIX2).padStart(MODE_DIGITS, "0")}, which lets other users reach it; it must be accessible to its owner only`;
-  }
-  return void 0;
-}
-function verifyHeadroomSocket(socketPath, ports) {
-  const unsupported = platformRefusal(ports.platform);
-  if (unsupported !== void 0) {
-    return { refused: unsupported };
-  }
-  const uid = ports.currentUid();
-  const directory = import_node_path30.default.dirname(socketPath);
-  const refusal = ownerOnlyRefusal("socket directory", directory, ports.lstat(directory), "dir", uid) ?? ownerOnlyRefusal("socket", socketPath, ports.lstat(socketPath), "socket", uid);
-  return refusal === void 0 ? { socketPath } : { refused: refusal };
-}
-function prepareHeadroomSocket(fs19, ports, paths, supervisorPid) {
-  const unsupported = platformRefusal(ports.platform);
-  if (unsupported !== void 0) {
-    return { refused: unsupported };
-  }
-  const socketPath = headroomSocketPath(paths, supervisorPid);
-  const length = Buffer.byteLength(socketPath, "utf8");
-  if (length > UNIX_SOCKET_PATH_MAX_BYTES) {
-    return {
-      refused: `the headroom socket path ${socketPath} is ${String(length)} bytes, longer than the ${String(UNIX_SOCKET_PATH_MAX_BYTES)} a unix socket path can hold; set AGENT_SHIM_HOME to a shorter directory`
-    };
-  }
-  if (ports.lstat(paths.headroomSocketDir)?.kind === "symlink") {
-    return { refused: `the headroom socket directory ${paths.headroomSocketDir} is a symlink; it must be the real directory` };
-  }
-  fs19.mkdirPrivate(paths.headroomSocketDir);
-  const refusal = ownerOnlyRefusal("socket directory", paths.headroomSocketDir, ports.lstat(paths.headroomSocketDir), "dir", ports.currentUid());
-  return refusal === void 0 ? { socketPath } : { refused: refusal };
-}
-function pruneStaleHeadroomSockets(fs19, paths, isRunning) {
-  const removed = [];
-  for (const name of fs19.readdir(paths.headroomSocketDir)) {
-    const pid = HEADROOM_SOCKET_NAME.exec(name)?.[1];
-    if (pid === void 0 || isRunning(Number.parseInt(pid, 10))) {
-      continue;
-    }
-    fs19.removeRecursive(import_node_path30.default.join(paths.headroomSocketDir, name));
-    removed.push(name);
-  }
-  return removed;
-}
-
 // src/frontdoor/custody.ts
 var CREDENTIAL_HEADERS = ["authorization", "x-api-key"];
 var SEQUESTERED_CREDENTIAL = "agent-shim-sequestered";
@@ -63955,7 +64313,7 @@ function createDoorPipelines(deps) {
 }
 
 // src/frontdoor/capability.ts
-var import_node_crypto7 = require("node:crypto");
+var import_node_crypto8 = require("node:crypto");
 var CONNECT_PROXY_USER = "agent-shim";
 var CONNECT_PROXY_REALM = "agent-shim front door";
 var BASIC_SCHEME = "basic";
@@ -63977,13 +64335,13 @@ function capabilityFromProxyAuthorization(value) {
   return password === "" ? void 0 : password;
 }
 function digest(token) {
-  return (0, import_node_crypto7.createHash)("sha256").update(token, "utf8").digest();
+  return (0, import_node_crypto8.createHash)("sha256").update(token, "utf8").digest();
 }
 function isLiveCapability(presented, live) {
   const presentedDigest = digest(presented);
   let matched = false;
   for (const token of live) {
-    const equal = (0, import_node_crypto7.timingSafeEqual)(presentedDigest, digest(token));
+    const equal = (0, import_node_crypto8.timingSafeEqual)(presentedDigest, digest(token));
     matched = equal || matched;
   }
   return matched;
@@ -64127,11 +64485,11 @@ function createFileCapture(file2, now = () => /* @__PURE__ */ new Date()) {
 }
 
 // src/frontdoor/connect.ts
-var import_node_crypto9 = require("node:crypto");
+var import_node_crypto10 = require("node:crypto");
 var fs12 = __toESM(require("node:fs"), 1);
 
 // src/frontdoor/x509.ts
-var import_node_crypto8 = require("node:crypto");
+var import_node_crypto9 = require("node:crypto");
 var import_node_net = __toESM(require("node:net"), 1);
 var TAG_BOOLEAN = 1;
 var TAG_INTEGER = 2;
@@ -64283,7 +64641,7 @@ function ipBytes(address) {
   return bytes;
 }
 function keyIdentifier(publicKey) {
-  return (0, import_node_crypto8.createHash)("sha1").update(publicKey.export({ type: "pkcs1", format: "der" })).digest();
+  return (0, import_node_crypto9.createHash)("sha1").update(publicKey.export({ type: "pkcs1", format: "der" })).digest();
 }
 function readElement(buffer, offset) {
   const tag = buffer[offset];
@@ -64329,7 +64687,7 @@ ${body.join("\n")}
 `;
 }
 function randomSerial() {
-  const bytes = (0, import_node_crypto8.randomBytes)(SERIAL_NUMBER_BYTES);
+  const bytes = (0, import_node_crypto9.randomBytes)(SERIAL_NUMBER_BYTES);
   bytes[0] = (bytes[0] ?? 0) & BASE_128_PAYLOAD_MASK | HIGH_BIT >> 1;
   return bytes;
 }
@@ -64344,7 +64702,7 @@ function assemble(spec) {
     spec.subjectPublicKey.export({ type: "spki", format: "der" }),
     tlv(TAG_EXTENSIONS, sequence(...spec.extensions))
   );
-  const signature = (0, import_node_crypto8.sign)("sha256", tbs, spec.signingKey);
+  const signature = (0, import_node_crypto9.sign)("sha256", tbs, spec.signingKey);
   return sequence(tbs, SIGNATURE_ALGORITHM, wholeBitString(signature));
 }
 function subjectKeyIdentifierExtension(publicKey) {
@@ -64354,7 +64712,7 @@ function basicConstraintsExtension(isCa) {
   return extension(OID_BASIC_CONSTRAINTS, true, sequence(...isCa ? [boolean4(true)] : []));
 }
 function rsaKeyPair() {
-  return (0, import_node_crypto8.generateKeyPairSync)("rsa", { modulusLength: RSA_MODULUS_BITS });
+  return (0, import_node_crypto9.generateKeyPairSync)("rsa", { modulusLength: RSA_MODULUS_BITS });
 }
 function keyPem(privateKey) {
   return privateKey.export({ type: "pkcs8", format: "pem" });
@@ -64378,8 +64736,8 @@ function issueLeafCertificate(ca, names, notBefore, notAfter) {
   if (commonName === void 0) {
     throw new Error("a leaf certificate needs at least one name");
   }
-  const caCertificate = new import_node_crypto8.X509Certificate(ca.certPem);
-  const caPrivateKey = (0, import_node_crypto8.createPrivateKey)(ca.keyPem);
+  const caCertificate = new import_node_crypto9.X509Certificate(ca.certPem);
+  const caPrivateKey = (0, import_node_crypto9.createPrivateKey)(ca.keyPem);
   const { publicKey, privateKey } = rsaKeyPair();
   const generalNames = names.map((name) => import_node_net.default.isIP(name) === 0 ? tlv(TAG_GENERAL_NAME_DNS, Buffer.from(name, "ascii")) : tlv(TAG_GENERAL_NAME_IP, ipBytes(name)));
   const der = assemble({
@@ -64455,7 +64813,7 @@ function pumpTapSession(secure, openUpstream, tap, prefix = Buffer.alloc(0)) {
 // src/frontdoor/supervisor.ts
 var FRONTDOOR_SUPERVISOR_STILL_RUNNING = -1;
 var FRONTDOOR_POLL_MS = 1e3;
-var MS_PER_MINUTE = 6e4;
+var MS_PER_MINUTE2 = 6e4;
 async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {}) {
   const { fs: fs19, paths } = ports;
   const previous = readFrontDoorState(fs19, paths.frontdoorStateFile);
@@ -64523,7 +64881,7 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     pruneDeadFrontDoorSessions(fs19, paths.frontdoorSessionsDir, ports.isRunning);
     if (listFrontDoorSessions(fs19, paths.frontdoorSessionsDir).length === 0) {
       idleSince ??= ports.now();
-      if (ports.now() - idleSince >= idleShutdownMinutes * MS_PER_MINUTE) {
+      if (ports.now() - idleSince >= idleShutdownMinutes * MS_PER_MINUTE2) {
         ports.log(`agent-shim frontdoor supervisor: no sessions for ${String(idleShutdownMinutes)} minute(s); closing the front door and exiting`);
         await direct.close();
         await connect3.close();
@@ -64642,8 +65000,8 @@ function ensureCa(store, generate) {
 }
 function caParses(ca) {
   try {
-    new import_node_crypto9.X509Certificate(ca.certPem);
-    (0, import_node_crypto9.createPrivateKey)(ca.keyPem);
+    new import_node_crypto10.X509Certificate(ca.certPem);
+    (0, import_node_crypto10.createPrivateKey)(ca.keyPem);
     return true;
   } catch {
     return false;
@@ -66018,7 +66376,7 @@ async function serveRouted(request7, deps) {
 }
 
 // src/codex/translate.ts
-var import_node_crypto10 = require("node:crypto");
+var import_node_crypto11 = require("node:crypto");
 
 // src/codex/anthropic.ts
 var TextBlockSchema = external_exports.looseObject({ type: external_exports.literal("text"), text: external_exports.string() });
@@ -66130,7 +66488,7 @@ function shortToolName(name, names) {
   if (name.length <= CODEX_TOOL_NAME_LIMIT) {
     return name;
   }
-  const hash2 = (0, import_node_crypto10.createHash)("sha256").update(name).digest("hex").slice(0, TOOL_NAME_HASH_CHARS);
+  const hash2 = (0, import_node_crypto11.createHash)("sha256").update(name).digest("hex").slice(0, TOOL_NAME_HASH_CHARS);
   const shortened = `${name.slice(0, CODEX_TOOL_NAME_LIMIT - TOOL_NAME_HASH_CHARS - 1)}_${hash2}`;
   names.set(shortened, name);
   return shortened;
@@ -66988,6 +67346,11 @@ function singleHeader(headers, name) {
   const value = headers[name];
   return typeof value === "string" ? value : void 0;
 }
+var OAUTH_AUTHORIZATION_PREFIX = "Bearer sk-ant-oat";
+function oauthAuthorizationOf(headers) {
+  const value = singleHeader(headers, "authorization");
+  return value?.startsWith(OAUTH_AUTHORIZATION_PREFIX) === true ? value : void 0;
+}
 function sessionCreateId(body) {
   let parsed;
   try {
@@ -67131,7 +67494,7 @@ function createRcSessionTracker(deps) {
     }
     const tail = path41.slice(RC_SESSIONS_PATH_PREFIX.length);
     const facts = {
-      authorization: singleHeader(request7.headers, "authorization"),
+      oauthAuthorization: oauthAuthorizationOf(request7.headers),
       anthropicVersion: singleHeader(request7.headers, "anthropic-version"),
       anthropicClientPlatform: singleHeader(request7.headers, "anthropic-client-platform")
     };
@@ -67173,7 +67536,7 @@ function createRcSessionTracker(deps) {
     }
     const entry = entries.get(id) ?? birth(id, facts);
     entry.lastSeenAt = deps.now();
-    entry.authorization = facts.authorization ?? entry.authorization;
+    entry.oauthAuthorization = facts.oauthAuthorization ?? entry.oauthAuthorization;
     entry.anthropicVersion = facts.anthropicVersion ?? entry.anthropicVersion;
     entry.anthropicClientPlatform = facts.anthropicClientPlatform ?? entry.anthropicClientPlatform;
     const bodyKind = method === "POST" && rest === `${id}/worker/events` ? "worker-events" : method === "POST" && rest === `${id}/events` ? "client-events" : method === "POST" && rest === `${id}/worker/heartbeat` ? "heartbeat" : method === "PUT" && rest === `${id}/worker` ? "worker-registration" : void 0;
@@ -67261,7 +67624,7 @@ function createRcSessionTracker(deps) {
     },
     credentialOf: (sessionId) => {
       const entry = entries.get(sessionId);
-      return entry === void 0 ? void 0 : { authorization: entry.authorization, anthropicVersion: entry.anthropicVersion, anthropicClientPlatform: entry.anthropicClientPlatform };
+      return entry === void 0 ? void 0 : { authorization: entry.oauthAuthorization, anthropicVersion: entry.anthropicVersion, anthropicClientPlatform: entry.anthropicClientPlatform };
     },
     completePending: (sessionId, requestId) => {
       entries.get(sessionId)?.pending.delete(requestId);
@@ -67363,6 +67726,9 @@ function rcEventWriteResultFromAnswer(answer) {
   }
   return { ok: true, sequenceNums };
 }
+function noOAuthCredentialResult(sessionId) {
+  return { ok: false, message: `no claude.ai OAuth bearer has been observed for session ${sessionId}: only worker calls crossed this door, and the worker JWT they carry is answered 401 on the client half. Reconnect Remote Control through this door and the create's own bearer will be observed` };
+}
 function rcWriteHeaders(credential) {
   const headers = { "content-type": "application/json" };
   if (credential.authorization !== void 0) {
@@ -67381,6 +67747,9 @@ async function injectRcUserMessage(deps, sessionId, text2) {
   if (credential === void 0) {
     return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
   }
+  if (credential.authorization === void 0) {
+    return noOAuthCredentialResult(sessionId);
+  }
   const body = JSON.stringify(buildRcEventWriteBody(buildRcUserMessagePayload(deps.newUuid(), sessionId, text2)));
   let answer;
   try {
@@ -67399,6 +67768,9 @@ async function answerRcControlRequest(deps, sessionId, requestId, decision) {
   if (credential === void 0) {
     return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
   }
+  if (credential.authorization === void 0) {
+    return noOAuthCredentialResult(sessionId);
+  }
   if (!deps.pendingOf(sessionId).some((pending) => pending.requestId === requestId)) {
     return { ok: false, message: `the front door has not observed control request ${requestId} pending on session ${sessionId}: it was answered already (by this door or by an attached client), it passed its answer deadline (the protocol's permission round-trip bound), or it never passed through this door` };
   }
@@ -67720,7 +68092,7 @@ function realFrontDoorSupervisorPorts(paths) {
   let directPort = 0;
   const codexPorts = createCodexRoutePorts(log);
   const rcTracker = createRcSessionTracker({ now: () => Date.now(), idleMs: RC_IDLE_EXPIRY_MS });
-  const rcControlToken = (0, import_node_crypto11.randomUUID)();
+  const rcControlToken = (0, import_node_crypto12.randomUUID)();
   const resolveRoute = rcObservingResolver(createProviderRouteResolver({ fs: realFsPort, providersDir: paths.providersDir, codexPorts, directPort: () => directPort }), rcTracker);
   const isLiveToken = (token) => isLiveCapability(token, liveSessionTokens(realFarmFs, paths.frontdoorSessionsDir));
   const usageStore = createUsageStore({
@@ -67747,8 +68119,8 @@ function realFrontDoorSupervisorPorts(paths) {
     now: () => Date.now(),
     headroomSocket: () => headroomSocketTarget(realFarmFs, realHeadroomSocketTrust, paths),
     // The per-generation capability the direct listener demands: held only in this process's memory, so a loopback process that discovers the direct port still cannot use it.
-    hopSecret: (0, import_node_crypto11.randomUUID)(),
-    custody: createCredentialCustody(() => (0, import_node_crypto11.randomUUID)()),
+    hopSecret: (0, import_node_crypto12.randomUUID)(),
+    custody: createCredentialCustody(() => (0, import_node_crypto12.randomUUID)()),
     log
   });
   let ca;
@@ -67774,7 +68146,7 @@ function realFrontDoorSupervisorPorts(paths) {
     startProviderListener: async (preferredPort) => {
       const authority = loadCa();
       const rcDial = realRcEventDial();
-      const rcInject = async (sessionId, text2) => await injectRcUserMessage({ credentialOf: rcTracker.credentialOf, dial: rcDial, newUuid: import_node_crypto11.randomUUID }, sessionId, text2);
+      const rcInject = async (sessionId, text2) => await injectRcUserMessage({ credentialOf: rcTracker.credentialOf, dial: rcDial, newUuid: import_node_crypto12.randomUUID }, sessionId, text2);
       const rcAnswer = async (sessionId, requestId, decision) => await answerRcControlRequest({ credentialOf: rcTracker.credentialOf, pendingOf: (id) => rcTracker.pendingOf(id), completePending: rcTracker.completePending, dial: rcDial }, sessionId, requestId, decision);
       realFarmFs.mkdirp(paths.frontdoorDir);
       realFarmFs.writeFilePrivate(paths.frontdoorControlTokenFile, `${rcControlToken}
@@ -67798,7 +68170,7 @@ function realFrontDoorSupervisorPorts(paths) {
     },
     startConnectListener: async (preferredPort) => {
       const transparentPort = process.env.AGENT_SHIM_TRANSPARENT_SURFACE === void 0 ? void 0 : Number(process.env.AGENT_SHIM_TRANSPARENT_SURFACE);
-      const transparentCapability = transparentPort === void 0 || Number.isNaN(transparentPort) ? void 0 : (0, import_node_crypto11.randomUUID)();
+      const transparentCapability = transparentPort === void 0 || Number.isNaN(transparentPort) ? void 0 : (0, import_node_crypto12.randomUUID)();
       if (transparentCapability !== void 0) {
         writeFrontDoorSession(realFarmFs, paths.frontdoorSessionsDir, { pid: process.pid, startedAt: Date.now(), token: transparentCapability });
       }
@@ -68584,33 +68956,6 @@ function subjectName(positional, provider) {
 // src/doctorReport.ts
 var import_node_fs14 = __toESM(require("node:fs"), 1);
 var import_node_path34 = __toESM(require("node:path"), 1);
-
-// src/headroom/source.ts
-var GIT_SPEC_RE = /git\+[^@\s]+(?:@([^\s#]+))?/;
-var COMMIT_SHA_RE = /^[0-9a-f]{40}$/i;
-var DirectUrlSchema = external_exports.object({ vcs_info: external_exports.object({ commit_id: external_exports.string() }) });
-function isMovingGitSource(spec) {
-  const match = GIT_SPEC_RE.exec(spec);
-  if (match === null) {
-    return false;
-  }
-  const ref = match[1];
-  return ref === void 0 || !COMMIT_SHA_RE.test(ref);
-}
-function pinnedGitCommit(spec) {
-  const ref = GIT_SPEC_RE.exec(spec)?.[1];
-  return ref !== void 0 && COMMIT_SHA_RE.test(ref) ? ref.toLowerCase() : void 0;
-}
-function parseInstalledCommit(directUrlJson) {
-  try {
-    const parsed = DirectUrlSchema.safeParse(JSON.parse(directUrlJson));
-    return parsed.success ? parsed.data.vcs_info.commit_id.toLowerCase() : void 0;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/doctorReport.ts
 function refinePathShadow(status, ownExecutablePath, realpath) {
   if (status.status !== "shadowed") {
     return status;
@@ -69034,7 +69379,7 @@ function collectDoctorReport(params) {
   const ownExecutablePath = realOwnExecutablePath();
   let binaryDiscovery;
   try {
-    const binary = realResolveClaudeBinary(resolveOwnInstallDirs(paths, ownExecutablePath))();
+    const binary = realResolveClaudeBinary(resolveOwnBinaryCheck(paths, realContentSourcePath()))();
     binaryDiscovery = { ok: true, binary };
   } catch (error62) {
     binaryDiscovery = { ok: false, message: error62 instanceof Error ? error62.message : String(error62) };
@@ -69118,7 +69463,7 @@ var import_node_child_process5 = require("node:child_process");
 var import_node_fs15 = __toESM(require("node:fs"), 1);
 
 // src/frontdoor/ensure.ts
-var import_node_crypto12 = require("node:crypto");
+var import_node_crypto13 = require("node:crypto");
 var FRONTDOOR_START_TIMEOUT_MS = 3e4;
 var FRONTDOOR_LAUNCHER_POLL_MS = 100;
 var FrontDoorStartError = class extends CliError {
@@ -69152,7 +69497,7 @@ function ensureFrontDoor(params) {
           continue;
         }
         if (verdict.ok) {
-          const token = (0, import_node_crypto12.randomUUID)();
+          const token = (0, import_node_crypto13.randomUUID)();
           writeFrontDoorSession(ports.fs, paths.frontdoorSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), token });
           return { port: state.port, connectPort: state.connectPort, token };
         }
@@ -69256,7 +69601,7 @@ function probeFrontDoorSync(port, caPem) {
 }
 
 // src/frontdoor/trust.ts
-var import_node_crypto13 = require("node:crypto");
+var import_node_crypto14 = require("node:crypto");
 var import_node_path35 = __toESM(require("node:path"), 1);
 var BUNDLE_NAME_HEX_DIGITS = 16;
 function resolveTrustBundle(params) {
@@ -69279,7 +69624,7 @@ function resolveTrustBundle(params) {
   }
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
-  const bundle = import_node_path35.default.join(bundlesDir, `${(0, import_node_crypto13.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  const bundle = import_node_path35.default.join(bundlesDir, `${(0, import_node_crypto14.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
   if (!fs19.exists(bundle)) {
     fs19.mkdirp(bundlesDir);
     fs19.writeFileAtomic(bundle, combined);
@@ -69332,315 +69677,6 @@ function realFrontDoorPort(paths, spawnDaemon) {
   };
 }
 
-// src/headroom/settings.ts
-var import_node_crypto14 = require("node:crypto");
-function settingsOf(config2) {
-  return {
-    ...config2.mode === void 0 ? {} : { mode: config2.mode },
-    ...config2.targetRatio === void 0 ? {} : { targetRatio: config2.targetRatio },
-    ...config2.ccr === void 0 ? {} : { ccr: config2.ccr },
-    ...config2.rolloutChannel === void 0 ? {} : { rolloutChannel: config2.rolloutChannel },
-    ...config2.interceptToolResults === void 0 ? {} : { interceptToolResults: config2.interceptToolResults },
-    ...config2.readMaturation === void 0 ? {} : { readMaturation: config2.readMaturation }
-  };
-}
-function settingsArgs(settings2) {
-  return [
-    ...settings2.mode === void 0 ? [] : ["--mode", settings2.mode],
-    ...settings2.targetRatio === void 0 ? [] : ["--target-ratio", String(settings2.targetRatio)],
-    ...settings2.ccr === "lossless" ? ["--lossless"] : [],
-    ...settings2.ccr === "none" ? ["--no-ccr"] : [],
-    ...settings2.interceptToolResults === true ? ["--intercept-tool-results"] : [],
-    ...settings2.readMaturation === true ? ["--read-maturation"] : []
-  ];
-}
-function settingsEnv(settings2) {
-  return settings2.rolloutChannel === void 0 ? {} : { HEADROOM_ROLLOUT_CHANNEL: settings2.rolloutChannel };
-}
-function hashSettings(settings2) {
-  return (0, import_node_crypto14.createHash)("sha256").update(JSON.stringify([...settingsArgs(settings2), JSON.stringify(settingsEnv(settings2))])).digest("hex");
-}
-
-// src/headroom/supervisor.ts
-function resolveSupervisorConfig(configured) {
-  return {
-    source: configured.source ?? HEADROOM_DEFAULT_SOURCE,
-    idleShutdownMinutes: configured.idleShutdownMinutes ?? HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES,
-    settings: settingsOf(configured)
-  };
-}
-var HEADROOM_BACKOFF_BASE_MS = 500;
-var HEADROOM_BACKOFF_CAP_MS = 3e4;
-var HEADROOM_START_RETRY_BUDGET = 5;
-var HEADROOM_READY_TIMEOUT_MS = 15e3;
-var HEADROOM_POLL_MS = 1e3;
-var MS_PER_MINUTE2 = 6e4;
-var STOP_POLL_MS = 100;
-var TERM_GRACE_MS = 1500;
-var KILL_GRACE_MS = 1500;
-function stopSupervisedProcess(pid, primitives) {
-  const send = (signal) => {
-    try {
-      primitives.signal(pid, signal);
-    } catch {
-    }
-  };
-  send("SIGTERM");
-  if (awaitExit(pid, primitives, TERM_GRACE_MS)) {
-    return "exited-on-term";
-  }
-  send("SIGKILL");
-  if (awaitExit(pid, primitives, KILL_GRACE_MS)) {
-    return "killed";
-  }
-  return "still-running";
-}
-function awaitExit(pid, primitives, budgetMs) {
-  const deadline = primitives.now() + budgetMs;
-  while (primitives.isRunning(pid)) {
-    if (primitives.now() >= deadline) {
-      return false;
-    }
-    primitives.waitMs(STOP_POLL_MS);
-  }
-  return true;
-}
-function backoffForAttempt(attempt) {
-  return Math.min(HEADROOM_BACKOFF_CAP_MS, HEADROOM_BACKOFF_BASE_MS * 2 ** (attempt - 1));
-}
-function versionSatisfies(version2, source) {
-  if (version2 === void 0) {
-    return false;
-  }
-  const specifier = /==|>=|<=|!=|>|<|~=/.exec(source);
-  if (specifier === null) {
-    return true;
-  }
-  const installed = parseVersion(version2);
-  const wanted = parseVersion(source.slice(specifier.index + specifier[0].length));
-  if (installed === void 0 || wanted === void 0) {
-    return true;
-  }
-  const cmp = compareVersions2(installed, wanted);
-  switch (specifier[0]) {
-    case "==":
-      return cmp === 0;
-    case "!=":
-      return cmp !== 0;
-    case ">=":
-      return cmp >= 0;
-    case "<=":
-      return cmp <= 0;
-    case ">":
-      return cmp > 0;
-    case "<":
-      return cmp < 0;
-    case "~=":
-      return compareVersions2(installed.slice(0, Math.max(0, wanted.length - 1)), wanted.slice(0, Math.max(0, wanted.length - 1))) === 0 && cmp >= 0;
-    default:
-      return true;
-  }
-}
-function parseVersion(input2) {
-  const match = /(\d+)(\.\d+)*/.exec(input2);
-  if (match === null) {
-    return void 0;
-  }
-  return match[0].split(".").map((part) => Number.parseInt(part, 10));
-}
-function compareVersions2(a2, b) {
-  for (let index = 0; index < Math.max(a2.length, b.length); index += 1) {
-    const left = a2[index] ?? 0;
-    const right = b[index] ?? 0;
-    if (left !== right) {
-      return left - right;
-    }
-  }
-  return 0;
-}
-var HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
-async function runSupervisor(initialConfig, ports, options = {}) {
-  const { fs: fs19, paths } = ports;
-  let config2 = initialConfig;
-  const previousState = readHeadroomState(fs19, paths.headroomStateFile);
-  if (previousState?.supervisorPid !== void 0 && previousState.supervisorPid !== ports.ownPid && ports.isRunning(previousState.supervisorPid)) {
-    ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: supervisor ${String(previousState.supervisorPid)} already owns the daemon; exiting`);
-    return 0;
-  }
-  let installedSource = previousState?.installedSource;
-  const ownsState = () => {
-    const owner = readHeadroomState(fs19, paths.headroomStateFile)?.supervisorPid;
-    return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
-  };
-  const writeOwnState = (state) => {
-    if (!ownsState()) {
-      return false;
-    }
-    writeHeadroomState(fs19, paths.headroomStateFile, state);
-    return true;
-  };
-  const fail = (message) => {
-    if (writeOwnState({ lastError: message })) {
-      fs19.removeRecursive(paths.headroomLockFile);
-    }
-    ports.log(`agent-shim headroom supervisor: ${message}`);
-    return 1;
-  };
-  const ensureInstalled = () => {
-    const version3 = ports.headroomVersion();
-    const versionOk = version3 !== void 0 && versionSatisfies(version3, config2.source);
-    const pinned = pinnedGitCommit(config2.source);
-    const commitOk = pinned === void 0 || ports.installedCommit() === pinned;
-    if (versionOk && commitOk && (installedSource === void 0 || installedSource === config2.source)) {
-      installedSource = config2.source;
-      return true;
-    }
-    ports.log(`agent-shim headroom supervisor: installing headroom from ${config2.source}`);
-    const result = ports.install(config2.source);
-    if (!result.ok) {
-      return false;
-    }
-    installedSource = config2.source;
-    return true;
-  };
-  const socket = prepareHeadroomSocket(fs19, ports.socketTrust, paths, ports.ownPid);
-  if (socket.refused !== void 0) {
-    return fail(socket.refused);
-  }
-  const { socketPath } = socket;
-  pruneStaleHeadroomSockets(fs19, paths, ports.isRunning);
-  if (!ensureInstalled()) {
-    return fail(`could not install headroom from ${config2.source}: install failed (is uv installed and on PATH?)`);
-  }
-  const version2 = ports.headroomVersion() ?? "unknown";
-  writeOwnState({ supervisorPid: ports.ownPid, version: version2, installedSource });
-  ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${allowlistOf(ports).join(", ")}]`);
-  const orphanPid = previousState?.headroomPid;
-  if (orphanPid !== void 0 && ports.isRunning(orphanPid)) {
-    ports.log(`agent-shim headroom supervisor: stopping daemon pid ${String(orphanPid)} left behind by the previous supervisor`);
-    ports.stopProcess(orphanPid);
-  }
-  let headroomPid;
-  let runningHash;
-  let runningSettingsHash;
-  let consecutiveFailures = 0;
-  let idleSince;
-  let superseded = false;
-  let ticks = 0;
-  for (; ; ) {
-    if (options.tickLimit !== void 0 && ticks >= options.tickLimit) {
-      return HEADROOM_SUPERVISOR_STILL_RUNNING;
-    }
-    ticks += 1;
-    config2 = ports.readConfig();
-    const settingsHash = hashSettings(config2.settings);
-    const allowlist = allowlistOf(ports);
-    const allowlistHash = hashAllowlist(allowlist);
-    pruneDeadSessions(fs19, paths.headroomSessionsDir, ports.isRunning);
-    const ownsNow = ownsState();
-    if (!ownsNow && !superseded) {
-      ports.log("agent-shim headroom supervisor: another supervisor now owns the state file; serving this daemon's own sessions until they end");
-    }
-    superseded = !ownsNow;
-    const crashed = headroomPid !== void 0 && !ports.isRunning(headroomPid);
-    if (headroomPid === void 0 || crashed) {
-      if (crashed) {
-        ports.log(`agent-shim headroom supervisor: headroom pid ${String(headroomPid)} died`);
-        headroomPid = void 0;
-        runningHash = void 0;
-        runningSettingsHash = void 0;
-        writeOwnState({
-          supervisorPid: ports.ownPid,
-          version: version2,
-          installedSource
-        });
-      }
-      if (consecutiveFailures >= HEADROOM_START_RETRY_BUDGET) {
-        return fail(`headroom failed to become ready ${String(consecutiveFailures)} times in a row; giving up`);
-      }
-      if (installedSource !== config2.source && !ensureInstalled()) {
-        return fail(`could not install headroom from ${config2.source}: install failed (is uv installed and on PATH?)`);
-      }
-      const pid = ports.spawnHeadroom(socketPath, allowlist, config2.settings);
-      const ready = await waitUntilReady(ports, socketPath);
-      if (ready) {
-        consecutiveFailures = 0;
-        headroomPid = pid;
-        runningHash = allowlistHash;
-        runningSettingsHash = settingsHash;
-        const recorded = writeOwnState({
-          supervisorPid: ports.ownPid,
-          headroomPid: pid,
-          socketPath,
-          version: version2,
-          allowlistHash,
-          settingsHash,
-          installedSource: config2.source
-        });
-        if (recorded) {
-          fs19.removeRecursive(paths.headroomLockFile);
-        }
-        idleSince = void 0;
-        ports.log(`agent-shim headroom supervisor: headroom pid ${String(pid)} ready on unix socket ${socketPath}`);
-      } else {
-        ports.stopProcess(pid);
-        consecutiveFailures += 1;
-        ports.log(
-          `agent-shim headroom supervisor: headroom did not become ready on unix socket ${socketPath} (attempt ${String(consecutiveFailures)} of ${String(HEADROOM_START_RETRY_BUDGET)})`
-        );
-        await ports.sleep(backoffForAttempt(consecutiveFailures));
-        continue;
-      }
-    } else {
-      if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config2.source) {
-        if (sessionsForSupervisor(fs19, paths.headroomSessionsDir, ports.ownPid).length === 0) {
-          ports.log("agent-shim headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
-          ports.stopProcess(headroomPid);
-          headroomPid = void 0;
-          runningHash = void 0;
-          runningSettingsHash = void 0;
-          continue;
-        }
-      }
-      const sessions = sessionsForSupervisor(fs19, paths.headroomSessionsDir, ports.ownPid);
-      if (sessions.length === 0) {
-        idleSince ??= ports.now();
-        const idleMs = ports.now() - idleSince;
-        if (idleMs >= config2.idleShutdownMinutes * MS_PER_MINUTE2) {
-          ports.log(
-            `agent-shim headroom supervisor: no sessions for ${String(config2.idleShutdownMinutes)} minute(s); stopping headroom and exiting`
-          );
-          ports.stopProcess(headroomPid);
-          writeOwnState({ version: version2 });
-          return 0;
-        }
-      } else {
-        idleSince = void 0;
-      }
-    }
-    await ports.sleep(HEADROOM_POLL_MS);
-  }
-}
-function currentHeadroomAllowlist(fs19, paths) {
-  const providers = readAllProviders(fs19, paths.providersDir).map((entry) => entry.provider);
-  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs19, paths.frontdoorStateFile))));
-}
-function allowlistOf(ports) {
-  return currentHeadroomAllowlist(ports.fs, ports.paths);
-}
-async function waitUntilReady(ports, socketPath) {
-  const deadline = ports.now() + HEADROOM_READY_TIMEOUT_MS;
-  for (; ; ) {
-    if (await ports.ready(socketPath)) {
-      return true;
-    }
-    if (ports.now() >= deadline) {
-      return false;
-    }
-    await ports.sleep(HEADROOM_POLL_MS);
-  }
-}
-
 // src/headroom/commands.ts
 function collectHeadroomStatus(fsPort, paths, isRunning) {
   const state = readHeadroomState(fsPort, paths.headroomStateFile) ?? {};
@@ -71028,7 +71064,7 @@ function prepareLaunch(params) {
   let headroom;
   const headroomPort = params.headroom;
   if (resolvedFlags.headroom && headroomPort !== void 0) {
-    headroom = headroomPort.ensure();
+    headroom = headroomPort.ensure({ routesProvider: resolvedProvider !== void 0 });
     const via = resolvedProvider === void 0 ? `OAuth via the door's CONNECT surface on 127.0.0.1:${String(frontDoor?.connectPort ?? 0)}` : `provider ${resolvedProvider.name}`;
     log.info(`agent-shim: routing through the front door on 127.0.0.1:${String(frontDoor?.port ?? 0)} with headroom on unix socket ${headroom.socketPath} (${via}, project ${headroom.projectId})`);
   } else if (resolvedFlags.headroom) {
@@ -71114,7 +71150,7 @@ function realPrepareLaunchParams(paths, options) {
     fs: realFsPort,
     proc: options.proc,
     log: options.log,
-    resolveClaudeBinary: realResolveClaudeBinary(resolveOwnInstallDirs(paths, realOwnExecutablePath())),
+    resolveClaudeBinary: realResolveClaudeBinary(resolveOwnBinaryCheck(paths, realContentSourcePath())),
     farm: farm.runtime,
     headroom: realHeadroomPort(paths, { spawnDaemon: options.spawnDaemon, cwd: farm.runtime.cwd }),
     frontdoor: realFrontDoorPort(paths, options.spawnDaemon),