claude-use 9.19.0 → 10.0.0

package/dist/index.cjs

@@ -472,7 +472,7 @@ var init_schema = __esm({
         context.addIssue({ code: "custom", path: ["readMaturation"], message: "readMaturation needs rolloutChannel beta or dev" });
       }
     });
-    HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@53525f479f2f48e8ef6b08cf729601feab7d2382";
+    HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@ca7589c574bfd52919503a74f09f4d1fe5ecf106";
     HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES = 15;
     FrontDoorGlobalConfigSchema = import_zod.z.strictObject({
       /** How long the front door may sit with no registered sessions before it closes and exits. Defaults to FRONTDOOR_DEFAULT_IDLE_SHUTDOWN_MINUTES. */
@@ -2607,9 +2607,71 @@ function writeFrontDoorState(fs12, stateFile, state) {
   fs12.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
+function directOrigin(port) {
+  return `http://127.0.0.1:${String(port)}`;
+}
 function frontDoorOrigin(state) {
   const port = state?.directPort ?? state?.lastDirectPort;
-  return port === void 0 ? void 0 : `http://127.0.0.1:${String(port)}`;
+  return port === void 0 ? void 0 : directOrigin(port);
+}
+function writeFrontDoorDirectRecord(fs12, recordsDir, record) {
+  fs12.mkdirp(recordsDir);
+  fs12.writeFilePrivate(import_node_path8.default.join(recordsDir, `${String(record.pid)}.json`), `${JSON.stringify({ directPort: record.directPort })}
+`);
+}
+function removeFrontDoorDirectRecord(fs12, recordsDir, pid) {
+  fs12.removeRecursive(import_node_path8.default.join(recordsDir, `${String(pid)}.json`));
+}
+function recordPid(file) {
+  const pidText = /^([1-9]\d*)\.json$/.exec(file)?.[1];
+  const pid = pidText === void 0 ? void 0 : Number(pidText);
+  return pid !== void 0 && Number.isSafeInteger(pid) ? pid : void 0;
+}
+function readDirectRecordEntry(fs12, recordsDir, file) {
+  const pid = recordPid(file);
+  if (pid === void 0) {
+    return void 0;
+  }
+  let raw;
+  try {
+    raw = fs12.readFileUtf8(import_node_path8.default.join(recordsDir, file));
+  } catch {
+    return void 0;
+  }
+  if (raw === void 0) {
+    return void 0;
+  }
+  try {
+    const parsed = FrontDoorDirectRecordSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? { record: { pid, directPort: parsed.data.directPort } } : { malformed: true };
+  } catch {
+    return { malformed: true };
+  }
+}
+function listFrontDoorDirectRecords(fs12, recordsDir) {
+  return fs12.readdir(recordsDir).flatMap((file) => {
+    const entry = readDirectRecordEntry(fs12, recordsDir, file);
+    return entry?.record === void 0 ? [] : [entry.record];
+  }).sort((a, b) => a.pid - b.pid);
+}
+function pruneMalformedFrontDoorDirectFiles(fs12, recordsDir, isRunning) {
+  for (const file of fs12.readdir(recordsDir)) {
+    const writer = RECORD_TEMPORARY_FILE.exec(file)?.[1];
+    const stale = writer !== void 0 && !isRunning(Number(writer));
+    if (stale || readDirectRecordEntry(fs12, recordsDir, file)?.malformed === true) {
+      fs12.removeRecursive(import_node_path8.default.join(recordsDir, file));
+    }
+  }
+}
+function liveFrontDoorDirectRecords(records, liveness) {
+  return records.filter((record) => liveness.doors.has(record.pid) || liveness.unknown.has(record.pid));
+}
+function pruneDeadFrontDoorDirectRecords(fs12, recordsDir, records, liveness) {
+  for (const record of records) {
+    if (!liveness.doors.has(record.pid) && !liveness.unknown.has(record.pid)) {
+      removeFrontDoorDirectRecord(fs12, recordsDir, record.pid);
+    }
+  }
 }
 function writeFrontDoorSession(fs12, sessionsDir, session) {
   fs12.mkdirPrivate(sessionsDir);
@@ -2646,7 +2708,7 @@ function pruneDeadFrontDoorSessions(fs12, sessionsDir, isRunning) {
   }
   return removed;
 }
-var import_node_path8, import_zod3, FRONT_DOOR_PROTOCOL, FrontDoorSessionSchema, FrontDoorStateSchema;
+var import_node_path8, import_zod3, FRONT_DOOR_PROTOCOL, FrontDoorSessionSchema, FrontDoorStateSchema, MAX_TCP_PORT, FrontDoorDirectRecordSchema, RECORD_TEMPORARY_FILE;
 var init_state = __esm({
   "src/frontdoor/state.ts"() {
     "use strict";
@@ -2676,7 +2738,7 @@ var init_state = __esm({
        */
       lastConnectPort: import_zod3.z.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.
+       * 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: the headroom supervisor rewrites the daemon's allowlist file when the origin moves, but a provider launch waits at its gate until it has, so an ephemeral port would hold launches up after every restart.
        */
       directPort: import_zod3.z.number().int().positive().optional(),
       /** The sticky port preference for the direct listener, for the reason `directPort` gives. */
@@ -2684,6 +2746,9 @@ var init_state = __esm({
       /** The last fatal error, kept across shutdowns so `frontdoor status` can explain a front door that is not running. */
       lastError: import_zod3.z.string().optional()
     });
+    MAX_TCP_PORT = 65535;
+    FrontDoorDirectRecordSchema = import_zod3.z.strictObject({ directPort: import_zod3.z.number().int().positive().max(MAX_TCP_PORT) });
+    RECORD_TEMPORARY_FILE = /^[1-9]\d*\.json\.([1-9]\d*)\.tmp$/;
   }
 });
 
@@ -2693,7 +2758,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "9.19.0",
+      version: "10.0.0",
       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>",
@@ -2818,11 +2883,75 @@ function listFrontDoorSupervisors(run, uid) {
   }
   return { ok: true, pids: parseFrontDoorSupervisorPids(result.stdout) };
 }
-var FRONT_DOOR_SUPERVISOR_ARGUMENT;
+function frontDoorLivenessFromPs(run, asked) {
+  if (refusedEveryPidAsTooLarge(run, asked)) {
+    return { doors: /* @__PURE__ */ new Set(), unknown: /* @__PURE__ */ new Map() };
+  }
+  const failure = psFailure(run);
+  if (failure !== void 0) {
+    return { doors: /* @__PURE__ */ new Set(), unknown: new Map(asked.map((pid) => [pid, failure])) };
+  }
+  const askedSet = new Set(asked);
+  const seen = /* @__PURE__ */ new Set();
+  const doors = /* @__PURE__ */ new Set();
+  for (const line of run.stdout.split("\n")) {
+    const [pidText, stat, ...argumentsList] = line.trim().split(/\s+/);
+    const pid = Number(pidText);
+    if (!askedSet.has(pid) || seen.has(pid)) {
+      continue;
+    }
+    seen.add(pid);
+    if (stat !== void 0 && !stat.startsWith("Z") && argumentsList.includes(FRONT_DOOR_SUPERVISOR_ARGUMENT)) {
+      doors.add(pid);
+    }
+  }
+  return { doors, unknown: /* @__PURE__ */ new Map() };
+}
+function refusedEveryPidAsTooLarge(run, asked) {
+  const lines = run.stderr.split("\n").filter((line) => line.trim() !== "");
+  const tooLarge = new Set(lines.map((line) => Number(PID_TOO_LARGE.exec(line.trim())?.[1])));
+  return run.status === 1 && run.stdout.trim() === "" && lines.length > 0 && lines.every((line) => PID_TOO_LARGE.test(line.trim())) && asked.every((pid) => tooLarge.has(pid));
+}
+function psFailure(run) {
+  if (run.error !== void 0) {
+    return run.error.message;
+  }
+  if (run.status === null) {
+    return "ps was terminated before it answered";
+  }
+  const noneExist = run.status === 1 && run.stdout.trim() === "" && run.stderr.trim() === "";
+  if (run.status !== 0 && !noneExist) {
+    return `ps exited ${String(run.status)}${run.stderr.trim() === "" ? "" : `: ${run.stderr.trim()}`}`;
+  }
+  return void 0;
+}
+function frontDoorLivenessOf(pids, runPs) {
+  if (pids.length === 0) {
+    return { doors: /* @__PURE__ */ new Set(), unknown: /* @__PURE__ */ new Map() };
+  }
+  const batch = frontDoorLivenessFromPs(runPs(pids), pids);
+  if (batch.unknown.size === 0 || pids.length === 1) {
+    return batch;
+  }
+  const doors = /* @__PURE__ */ new Set();
+  const unknown = /* @__PURE__ */ new Map();
+  for (const pid of pids) {
+    const single = frontDoorLivenessFromPs(runPs([pid]), [pid]);
+    for (const door of single.doors) {
+      doors.add(door);
+    }
+    for (const [unanswered, reason] of single.unknown) {
+      unknown.set(unanswered, reason);
+    }
+  }
+  return { doors, unknown };
+}
+var FRONT_DOOR_SUPERVISOR_ARGUMENT, PID_TOO_LARGE;
 var init_supervisorProcesses = __esm({
   "src/frontdoor/supervisorProcesses.ts"() {
     "use strict";
     FRONT_DOOR_SUPERVISOR_ARGUMENT = "__frontdoor-supervisor";
+    PID_TOO_LARGE = /^ps: process id too large: (\d+)$/;
   }
 });
 
@@ -2872,22 +3001,49 @@ function migrateHeadroomState(fs12, files, isRunning) {
   }
   fs12.removeRecursive(files.legacyStateFile);
 }
-function headroomAllowlist(providers) {
-  const urls = /* @__PURE__ */ new Set([HEADROOM_ANTHROPIC_UPSTREAM]);
-  for (const provider of providers) {
-    urls.add(provider.baseUrl);
+function hashAllowlist(allowlist) {
+  return (0, import_node_crypto6.createHash)("sha256").update(allowlist.join("\n")).digest("hex");
+}
+function formatAllowlistFile(allowlist) {
+  return allowlist.map((entry) => `${entry}
+`).join("");
+}
+function hashAllowlistFile(content) {
+  return hashAllowlist([...new Set(parseAllowlistFile(content))].sort());
+}
+function isBareHost(entry) {
+  if (/[/?#@]/.test(entry)) {
+    return false;
   }
-  return [...urls].sort();
+  if (entry.startsWith("[")) {
+    const close = entry.indexOf("]");
+    return close > 1 && !entry.slice(close + 1).includes(":");
+  }
+  return entry !== "" && !entry.includes(":");
 }
-function headroomUpstreams(providers, frontDoorOrigin2) {
-  const upstreams = providers.filter((provider) => !isCodexProvider(provider)).map((provider) => ({ baseUrl: provider.baseUrl }));
-  if (providers.length > 0 && frontDoorOrigin2 !== void 0) {
-    upstreams.push({ baseUrl: frontDoorOrigin2 });
+function isAdmissibleUrl(entry) {
+  try {
+    const url = new URL(entry);
+    return ALLOWLIST_SAFE_SCHEMES.has(url.protocol) && url.hostname !== "";
+  } catch {
+    return false;
   }
-  return upstreams;
 }
-function hashAllowlist(allowlist) {
-  return (0, import_node_crypto6.createHash)("sha256").update(allowlist.join("\n")).digest("hex");
+function parseAllowlistFile(content) {
+  return content.replace(/^\uFEFF/, "").replace(ALLOWLIST_FILE_COMMENT, "").split(ALLOWLIST_FILE_SEPARATORS).map((entry) => entry.replace(ALLOWLIST_SURROUNDING_WHITESPACE, "")).filter((entry) => entry !== "" && !ALLOWLIST_ENTRY_WHITESPACE.test(entry) && (entry.includes("://") ? isAdmissibleUrl(entry) : isBareHost(entry)));
+}
+function writeAllowlistFile(fs12, allowlistFile, allowlist) {
+  fs12.mkdirPrivate(import_node_path11.default.dirname(allowlistFile));
+  fs12.writeFilePrivate(allowlistFile, formatAllowlistFile(allowlist));
+}
+function pruneStaleAllowlistTemporaries(fs12, allowlistFile, isRunning) {
+  const prefix = `${import_node_path11.default.basename(allowlistFile)}.`;
+  for (const name of fs12.readdir(import_node_path11.default.dirname(allowlistFile))) {
+    const writer = name.startsWith(prefix) ? /^([1-9]\d*)\.tmp$/.exec(name.slice(prefix.length))?.[1] : void 0;
+    if (writer !== void 0 && !isRunning(Number(writer))) {
+      fs12.removeRecursive(import_node_path11.default.join(import_node_path11.default.dirname(allowlistFile), name));
+    }
+  }
 }
 function readAllProviders(fs12, providersDir) {
   const result = [];
@@ -2951,7 +3107,7 @@ function readStartLock(fs12, lockFile) {
     return void 0;
   }
 }
-var import_node_crypto6, import_node_path11, import_zod8, HEADROOM_ANTHROPIC_UPSTREAM, HeadroomStateSchema, HeadroomSessionSchema, HeadroomLockSchema;
+var import_node_crypto6, import_node_path11, import_zod8, HeadroomStateSchema, HeadroomSessionSchema, HeadroomLockSchema, HEADROOM_ALLOWLIST_FILE_FLAG, ALLOWLIST_LINE_BREAKS, ALLOWLIST_WHITESPACE, ALLOWLIST_FILE_SEPARATORS, ALLOWLIST_FILE_COMMENT, ALLOWLIST_ENTRY_WHITESPACE, ALLOWLIST_SURROUNDING_WHITESPACE, ALLOWLIST_SAFE_SCHEMES;
 var init_state2 = __esm({
   "src/headroom/state.ts"() {
     "use strict";
@@ -2959,11 +3115,10 @@ var init_state2 = __esm({
     import_node_path11 = __toESM(require("node:path"), 1);
     import_zod8 = require("zod");
     init_schema();
-    HEADROOM_ANTHROPIC_UPSTREAM = "https://api.anthropic.com";
     HeadroomStateSchema = import_zod8.z.strictObject({
       /** The supervisor process owning the daemon. Alive means someone is keeping headroom running. */
       supervisorPid: import_zod8.z.number().int().positive().optional(),
-      /** The headroom proxy process itself. Absent while the supervisor is between restarts. */
+      /** The headroom proxy process itself, recorded as soon as it is spawned (before it is ready, which `socketPath` signals) so a successor can find a daemon whose supervisor died during its start. Absent while the supervisor is between restarts. */
       headroomPid: import_zod8.z.number().int().positive().optional(),
       /**
        * The unix socket the proxy serves on, inside the owner-only socket directory. Absent until the proxy has passed its readiness check, so "socketPath is set" is itself the ready signal a launcher polls for. The front door reads it on every hop, so a restart (which keeps the generation's path) is followed without anything being relaunched.
@@ -2971,7 +3126,9 @@ var init_state2 = __esm({
       socketPath: import_zod8.z.string().min(1).optional(),
       /** The `headroom --version` output of the running install. */
       version: import_zod8.z.string().optional(),
-      /** Hash of the allowlist the running proxy was started with, so a provider-file change is detected as drift. */
+      /**
+       * Hash of the allowlist the running proxy serves. The supervisor records it in the same tick it writes that allowlist to `LayoutPaths.headroomAllowlistFile`, which the proxy re-reads on its next request, so a provider launch, whose requests come back through its front door's direct origin, waits until this names an allowlist holding that origin. A supervisor from an earlier release records here the hash of the allowlist its daemon was started with instead (see `earlierRelease.ts`).
+       */
       allowlistHash: import_zod8.z.string().optional(),
       /** Hash of the token-saving settings the running proxy was started with, so a settings change is detected as drift. */
       settingsHash: import_zod8.z.string().optional(),
@@ -2982,33 +3139,133 @@ var init_state2 = __esm({
     });
     HeadroomSessionSchema = import_zod8.z.strictObject({ pid: import_zod8.z.number().int().positive(), startedAt: import_zod8.z.number(), supervisorPid: import_zod8.z.number().int().positive() });
     HeadroomLockSchema = import_zod8.z.strictObject({ pid: import_zod8.z.number().int().positive(), at: import_zod8.z.number() });
+    HEADROOM_ALLOWLIST_FILE_FLAG = "--allowed-base-urls-file";
+    ALLOWLIST_LINE_BREAKS = "\\n\\r\\u000b\\u000c\\u001c\\u001d\\u001e\\u0085\\u2028\\u2029";
+    ALLOWLIST_WHITESPACE = "\\t\\n\\u000b\\u000c\\r\\u001c-\\u001f \\u0085\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000";
+    ALLOWLIST_FILE_SEPARATORS = new RegExp(`[,\\t${ALLOWLIST_LINE_BREAKS}]`, "u");
+    ALLOWLIST_FILE_COMMENT = new RegExp(`(?:^|(?<=[${ALLOWLIST_WHITESPACE}]))#[^${ALLOWLIST_LINE_BREAKS}]*`, "gu");
+    ALLOWLIST_ENTRY_WHITESPACE = new RegExp(`[${ALLOWLIST_WHITESPACE}]`, "u");
+    ALLOWLIST_SURROUNDING_WHITESPACE = new RegExp(`^[${ALLOWLIST_WHITESPACE}]+|[${ALLOWLIST_WHITESPACE}]+$`, "gu");
+    ALLOWLIST_SAFE_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:", "ws:", "wss:"]);
+  }
+});
+
+// src/headroom/earlierRelease.ts
+function withoutOurSocket(commandLine, socketPath) {
+  for (const argument of [`--uds ${socketPath}`, `--uds=${socketPath}`]) {
+    let from = 0;
+    for (; ; ) {
+      const index = commandLine.indexOf(argument, from);
+      if (index === -1) {
+        break;
+      }
+      const end = index + argument.length;
+      const startsArgument = index === 0 || /\s/.test(commandLine.charAt(index - 1));
+      const endsArgument = end === commandLine.length || /\s/.test(commandLine.charAt(end));
+      if (startsArgument && endsArgument) {
+        return `${commandLine.slice(0, index)} ${commandLine.slice(end)}`;
+      }
+      from = index + 1;
+    }
+  }
+  return void 0;
+}
+function daemonIdentity(commandLine, socketPath) {
+  if (commandLine === void 0) {
+    return "unreadable";
+  }
+  const rest = withoutOurSocket(commandLine, socketPath);
+  const argumentsList = rest === void 0 ? [] : rest.trim().split(/\s+/);
+  if (rest === void 0 || !argumentsList.includes("proxy")) {
+    return "not-headroom";
+  }
+  return argumentsList.some((argument) => argument === HEADROOM_ALLOWLIST_FILE_FLAG || argument.startsWith(`${HEADROOM_ALLOWLIST_FILE_FLAG}=`)) ? "this-release" : "earlier-release";
+}
+function earlierReleaseAllowlistHash(providers, doorOrigin) {
+  const entries = /* @__PURE__ */ new Set([EARLIER_RELEASE_ANTHROPIC_UPSTREAM]);
+  for (const provider of providers) {
+    if (!isCodexProvider(provider)) {
+      entries.add(provider.baseUrl);
+    }
+  }
+  if (providers.length > 0 && doorOrigin !== void 0) {
+    entries.add(doorOrigin);
+  }
+  return hashAllowlist([...entries].sort());
+}
+function earlierReleaseDaemon(fs12, paths, daemon) {
+  if (daemonIdentity(daemon.commandLine, daemon.socketPath) !== "earlier-release") {
+    return void 0;
+  }
+  const providers = readAllProviders(fs12, paths.providersDir).map((entry) => entry.provider);
+  const expected = earlierReleaseAllowlistHash(providers, frontDoorOrigin(readFrontDoorState(fs12, paths.frontdoorStateFile)));
+  return { admitsServingDoor: daemon.recordedHash === expected };
+}
+var EARLIER_RELEASE_ALLOWLIST, EARLIER_RELEASE_ANTHROPIC_UPSTREAM;
+var init_earlierRelease = __esm({
+  "src/headroom/earlierRelease.ts"() {
+    "use strict";
+    init_schema();
+    init_state();
+    init_state2();
+    EARLIER_RELEASE_ALLOWLIST = "started by an earlier release with an allowlist fixed at start; it restarts once its sessions end";
+    EARLIER_RELEASE_ANTHROPIC_UPSTREAM = "https://api.anthropic.com";
   }
 });
 
 // src/headroom/ensure.ts
+function awaitingCause(daemonPid, identity, allowlistFile) {
+  if (identity === "unreadable") {
+    return `could not read the command line of the headroom daemon (pid ${String(daemonPid)}), so whether it reads an allowlist file is unknown, and its allowlist was not recorded as admitting this launch's upstreams within ${String(HEADROOM_START_TIMEOUT_MS)}ms`;
+  }
+  if (identity === "not-headroom") {
+    return `the headroom daemon pid ${String(daemonPid)} the state records is no longer a headroom proxy on its socket, and no daemon was recorded as admitting this launch's upstreams within ${String(HEADROOM_START_TIMEOUT_MS)}ms`;
+  }
+  return `the headroom supervisor has not written an allowlist admitting this launch's upstreams to ${allowlistFile} within ${String(HEADROOM_START_TIMEOUT_MS)}ms`;
+}
+function daemonAdmits(fs12, allowlistFile, recordedHash, required) {
+  const content = fs12.readFileUtf8(allowlistFile);
+  if (content === void 0 || recordedHash === void 0) {
+    return false;
+  }
+  const served = parseAllowlistFile(content);
+  return recordedHash === hashAllowlistFile(content) && required.every((upstream) => served.includes(upstream));
+}
 function ensureHeadroom(params) {
   const { paths, ports } = params;
   const deadline = ports.now() + HEADROOM_START_TIMEOUT_MS;
   let spawnedSupervisor = false;
-  let awaitingAllowlist = false;
   migrateHeadroomState(ports.fs, { stateFile: paths.headroomStateFile, legacyStateFile: paths.headroomLegacyStateFile }, ports.isRunning);
+  const commandLines = /* @__PURE__ */ new Map();
+  const commandLineOf = (pid) => {
+    if (!commandLines.has(pid)) {
+      commandLines.set(pid, ports.daemonCommandLine(pid));
+    }
+    return commandLines.get(pid);
+  };
   for (; ; ) {
+    let awaiting;
     const state = resolveServingHeadroomState(ports.fs, { stateFile: paths.headroomStateFile, legacyStateFile: paths.headroomLegacyStateFile }, ports.isRunning)?.state;
     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) {
-        const required = params.requiredAllowlistHash?.();
-        if (required === void 0 || state.allowlistHash === required) {
+      if (daemonUp && state.socketPath !== void 0 && state.headroomPid !== void 0) {
+        const required = params.requiredUpstreams?.();
+        if (required === void 0 || daemonAdmits(ports.fs, paths.headroomAllowlistFile, state.allowlistHash, required)) {
           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) {
+        const commandLine = commandLineOf(state.headroomPid);
+        const earlierRelease = earlierReleaseDaemon(ports.fs, paths, { commandLine, socketPath: state.socketPath, recordedHash: state.allowlistHash });
+        if (earlierRelease !== void 0) {
+          if (earlierRelease.admitsServingDoor) {
+            writeSession(ports.fs, paths.headroomSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), supervisorPid: state.supervisorPid });
+            return { socketPath: state.socketPath };
+          }
           throw new HeadroomStartError(
-            `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.`
+            `the running headroom daemon (pid ${String(state.headroomPid)}) was ${EARLIER_RELEASE_ALLOWLIST}, and its allowlist cannot be shown to admit the serving front door; launch with --no-headroom until then. Supervisor and daemon log: ${paths.headroomLogPath}`
           );
         }
-        awaitingAllowlist = true;
+        awaiting = { daemonPid: state.headroomPid, identity: daemonIdentity(commandLine, state.socketPath) };
       }
       if (state.lastError !== void 0) {
         throw new HeadroomStartError(
@@ -3034,10 +3291,11 @@ function ensureHeadroom(params) {
       }
     }
     if (ports.now() >= deadline) {
-      const lastError = state?.lastError;
-      throw new HeadroomStartError(
-        `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}`
-      );
+      const lastError = state?.lastError === void 0 ? "" : ` (last error: ${state.lastError})`;
+      if (awaiting !== void 0) {
+        throw new HeadroomStartError(`${awaitingCause(awaiting.daemonPid, awaiting.identity, paths.headroomAllowlistFile)}${lastError}, so the daemon would refuse every request this launch sends through it; launch with --no-headroom to bypass it. Supervisor and daemon log: ${paths.headroomLogPath}`);
+      }
+      throw new HeadroomStartError(`the headroom daemon did not become ready within ${String(HEADROOM_START_TIMEOUT_MS)}ms${lastError}. Daemon log: ${paths.headroomLogPath}`);
     }
     ports.sleep(HEADROOM_LAUNCHER_POLL_MS);
   }
@@ -3047,6 +3305,7 @@ var init_ensure = __esm({
   "src/headroom/ensure.ts"() {
     "use strict";
     init_cliError();
+    init_earlierRelease();
     init_state2();
     HEADROOM_START_TIMEOUT_MS = 12e4;
     HEADROOM_LAUNCHER_POLL_MS = 250;
@@ -3094,6 +3353,22 @@ var init_settings = __esm({
   }
 });
 
+// src/frontdoor/capture.ts
+function redactText(text) {
+  return SECRET_BODY_PATTERNS.reduce((accumulated, { pattern, replacement }) => accumulated.replace(pattern, replacement), text);
+}
+var SECRET_BODY_PATTERNS;
+var init_capture = __esm({
+  "src/frontdoor/capture.ts"() {
+    "use strict";
+    SECRET_BODY_PATTERNS = [
+      { pattern: /sk-ant-[A-Za-z0-9_-]{8,}/g, replacement: "<redacted>" },
+      { pattern: /Bearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, replacement: "Bearer <redacted>" },
+      { pattern: /eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{8,}/g, replacement: "<redacted>" }
+    ];
+  }
+});
+
 // src/headroom/socket.ts
 function headroomSocketPath(paths, supervisorPid) {
   return import_node_path12.default.join(paths.headroomSocketDir, `${String(supervisorPid)}${HEADROOM_SOCKET_SUFFIX}`);
@@ -3106,10 +3381,10 @@ function ownerOnlyRefusal(label, target, stat, expected, uid) {
     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"}`;
+    return `the headroom ${label} ${target} is a symlink; it must be the real ${KIND_NAMES[expected]}`;
   }
   if (stat.kind !== expected) {
-    return `the headroom ${label} ${target} is not a ${expected === "dir" ? "directory" : "socket"}`;
+    return `the headroom ${label} ${target} is not a ${KIND_NAMES[expected]}`;
   }
   if (stat.uid !== uid) {
     return `the headroom ${label} ${target} is owned by uid ${String(stat.uid)}, not by this user (uid ${String(uid)})`;
@@ -3129,6 +3404,86 @@ function verifyHeadroomSocket(socketPath, ports) {
   const refusal2 = ownerOnlyRefusal("socket directory", directory, ports.lstat(directory), "dir", uid) ?? ownerOnlyRefusal("socket", socketPath, ports.lstat(socketPath), "socket", uid);
   return refusal2 === void 0 ? { socketPath } : { refused: refusal2 };
 }
+function pathDirectories(target, ports) {
+  const pending = target.split("/").reverse();
+  let current = "/";
+  const directories = [];
+  let hops = 0;
+  for (let name = pending.pop(); name !== void 0; name = pending.pop()) {
+    if (name === "" || name === ".") {
+      continue;
+    }
+    if (name === "..") {
+      current = import_node_path12.default.dirname(current);
+      continue;
+    }
+    if (!directories.includes(current)) {
+      directories.push(current);
+    }
+    const entry = import_node_path12.default.join(current, name);
+    if (pending.length > 0 && ports.lstat(entry)?.kind === "symlink") {
+      hops += 1;
+      if (hops > MAX_SYMLINK_HOPS) {
+        return `the symlinks on the allowlist file's path go more than ${String(MAX_SYMLINK_HOPS)} deep`;
+      }
+      const linkTarget = ports.readlink(entry);
+      if (import_node_path12.default.isAbsolute(linkTarget)) {
+        current = "/";
+      }
+      pending.push(...linkTarget.split("/").reverse());
+    } else if (pending.length > 0) {
+      current = entry;
+    }
+  }
+  return directories;
+}
+function headroomDirectoryRefusal(directory, stat, uid, remedy) {
+  if (stat?.kind !== "dir") {
+    return `the directory ${directory} on the allowlist file's path is ${stat === void 0 ? "missing" : "not a directory"}, so headroom refuses the file`;
+  }
+  if (stat.uid !== uid && stat.uid !== ROOT_UID) {
+    return `the directory ${directory} on the allowlist file's path is owned by uid ${String(stat.uid)}, not by this user (uid ${String(uid)}) or root, so headroom refuses the file${remedy ? `; ${MOVE_ROOT_REMEDY}` : ""}`;
+  }
+  if ((stat.mode & GROUP_OR_OTHER_WRITE_BITS) !== 0) {
+    return `the directory ${directory} on the allowlist file's path is writable by group or others (mode ${stat.mode.toString(OCTAL_RADIX).padStart(MODE_DIGITS, "0")}), so headroom refuses the file${remedy ? `; ${stat.uid === uid && (stat.mode & STICKY_BIT) === 0 ? `run \`chmod go-w ${directory}\`` : MOVE_ROOT_REMEDY}` : ""}`;
+  }
+  return void 0;
+}
+function reportableAllowlistFileProblem(allowlistFile, ports, served) {
+  const problem = verifyAllowlistFile(allowlistFile, ports);
+  return problem?.repairable === false || served ? problem : void 0;
+}
+function verifyAllowlistFile(allowlistFile, ports) {
+  const uid = ports.currentUid();
+  const directories = pathDirectories(allowlistFile, ports);
+  if (typeof directories === "string") {
+    return { message: directories, repairable: false };
+  }
+  const socketDirectory = directories.at(-1);
+  const headroomDirectory = socketDirectory === void 0 ? void 0 : import_node_path12.default.dirname(socketDirectory);
+  for (const directory of directories) {
+    const stat = ports.lstat(directory);
+    if (directory === socketDirectory) {
+      const refusal4 = ownerOnlyRefusal("allowlist directory", directory, stat, "dir", uid);
+      if (refusal4 !== void 0) {
+        return { message: refusal4, repairable: true };
+      }
+      continue;
+    }
+    const own = directory === headroomDirectory;
+    const refusal3 = headroomDirectoryRefusal(directory, stat, uid, !own);
+    if (refusal3 !== void 0) {
+      return { message: refusal3, repairable: own };
+    }
+  }
+  const fileStat = ports.lstat(allowlistFile);
+  const refusal2 = ownerOnlyRefusal("allowlist file", allowlistFile, fileStat, "file", uid);
+  if (refusal2 === void 0) {
+    return void 0;
+  }
+  const replaceable = fileStat === void 0 || fileStat.kind === "file" || fileStat.kind === "symlink";
+  return { message: refusal2, repairable: replaceable };
+}
 function prepareHeadroomSocket(fs12, ports, paths, supervisorPid) {
   const unsupported = platformRefusal(ports.platform);
   if (unsupported !== void 0) {
@@ -3160,7 +3515,7 @@ function pruneStaleHeadroomSockets(fs12, paths, isRunning) {
   }
   return removed;
 }
-var import_node_path12, GROUP_OR_OTHER_BITS, OCTAL_RADIX, MODE_DIGITS, HEADROOM_SOCKET_SUFFIX, HEADROOM_SOCKET_NAME, UNIX_SOCKET_PATH_MAX_BYTES, PLATFORMS_WITHOUT_UNIX_SOCKETS;
+var import_node_path12, GROUP_OR_OTHER_BITS, OCTAL_RADIX, MODE_DIGITS, HEADROOM_SOCKET_SUFFIX, HEADROOM_SOCKET_NAME, UNIX_SOCKET_PATH_MAX_BYTES, PLATFORMS_WITHOUT_UNIX_SOCKETS, KIND_NAMES, MAX_SYMLINK_HOPS, ROOT_UID, GROUP_OR_OTHER_WRITE_BITS, STICKY_BIT, MOVE_ROOT_REMEDY;
 var init_socket = __esm({
   "src/headroom/socket.ts"() {
     "use strict";
@@ -3172,6 +3527,12 @@ var init_socket = __esm({
     HEADROOM_SOCKET_NAME = /^(\d+)\.sock$/;
     UNIX_SOCKET_PATH_MAX_BYTES = 103;
     PLATFORMS_WITHOUT_UNIX_SOCKETS = ["win32"];
+    KIND_NAMES = { dir: "directory", file: "file", socket: "socket" };
+    MAX_SYMLINK_HOPS = 40;
+    ROOT_UID = 0;
+    GROUP_OR_OTHER_WRITE_BITS = 18;
+    STICKY_BIT = 512;
+    MOVE_ROOT_REMEDY = "move the agent-shim root (AGENT_SHIM_HOME) to where every directory above it is owned by this user or root and not writable by group or others";
   }
 });
 
@@ -3288,6 +3649,36 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     ports.log(`agent-shim headroom supervisor: ${message}`);
     return 1;
   };
+  const syncAllowlistFile = (allowlist) => {
+    try {
+      if (fs12.readFileUtf8(paths.headroomAllowlistFile) !== formatAllowlistFile(allowlist)) {
+        writeAllowlistFile(fs12, paths.headroomAllowlistFile, allowlist);
+        ports.log(`agent-shim headroom supervisor: wrote allowlist [${allowlist.join(", ")}] to ${paths.headroomAllowlistFile}`);
+      }
+      return void 0;
+    } catch (error) {
+      return `could not write the headroom allowlist file ${paths.headroomAllowlistFile}: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  };
+  const allowlistFileRefusal = (allowlist) => {
+    const problem = verifyAllowlistFile(paths.headroomAllowlistFile, ports.socketTrust);
+    if (problem === void 0) {
+      return void 0;
+    }
+    if (!problem.repairable) {
+      return `headroom would refuse its allowlist file, and agent-shim cannot repair it: ${problem.message}`;
+    }
+    ports.log(`agent-shim headroom supervisor: repairing the allowlist file: ${problem.message}`);
+    try {
+      fs12.mkdirPrivate(paths.headroomDir);
+      fs12.mkdirPrivate(import_node_path13.default.dirname(paths.headroomAllowlistFile));
+      writeAllowlistFile(fs12, paths.headroomAllowlistFile, allowlist);
+    } catch (error) {
+      return `could not write the headroom allowlist file ${paths.headroomAllowlistFile}: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    const remaining = verifyAllowlistFile(paths.headroomAllowlistFile, ports.socketTrust);
+    return remaining === void 0 ? void 0 : `the allowlist file breaks agent-shim's rules for it, and rewriting it did not repair it: ${remaining.message}`;
+  };
   const ensureInstalled = () => {
     const version2 = ports.headroomVersion();
     const versionOk = version2 !== void 0 && versionSatisfies(version2, config.source);
@@ -3311,14 +3702,20 @@ async function runSupervisor(initialConfig, ports, options = {}) {
   }
   const { socketPath } = socket;
   pruneStaleHeadroomSockets(fs12, paths, ports.isRunning);
+  pruneStaleAllowlistTemporaries(fs12, paths.headroomAllowlistFile, ports.isRunning);
   if (!ensureInstalled()) {
     return fail(`could not install headroom from ${config.source}: install failed (is uv installed and on PATH?)`);
   }
   const version = ports.headroomVersion() ?? "unknown";
   writeOwnState({ supervisorPid: ports.ownPid, version, installedSource });
-  ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${allowlistOf(ports).join(", ")}]`);
+  ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${currentHeadroomAllowlistInputs(fs12, paths, ports.frontDoorLiveness).frontDoorOrigins.join(", ")}]`);
   const orphanPid = previousState?.headroomPid;
-  if (orphanPid !== void 0 && ports.isRunning(orphanPid)) {
+  const orphanSocket = previousState?.socketPath ?? (previousState?.supervisorPid === void 0 ? void 0 : headroomSocketPath(paths, previousState.supervisorPid));
+  const orphanIdentity = orphanPid === void 0 || orphanSocket === void 0 || !ports.isRunning(orphanPid) ? void 0 : daemonIdentity(ports.daemonCommandLine(orphanPid), orphanSocket);
+  if (orphanPid !== void 0 && (orphanIdentity === "not-headroom" || orphanIdentity === "unreadable")) {
+    ports.log(`agent-shim headroom supervisor: leaving pid ${String(orphanPid)} alone: the state records it as the previous daemon, but it ${orphanIdentity === "unreadable" ? "cannot be identified" : "is no longer a headroom proxy on that generation's socket"}`);
+  }
+  if (orphanPid !== void 0 && (orphanIdentity === "this-release" || orphanIdentity === "earlier-release")) {
     ports.log(`agent-shim headroom supervisor: stopping daemon pid ${String(orphanPid)} left behind by the previous supervisor`);
     ports.stopProcess(orphanPid);
   }
@@ -3326,9 +3723,19 @@ async function runSupervisor(initialConfig, ports, options = {}) {
   let runningHash;
   let runningSettingsHash;
   let consecutiveFailures = 0;
+  let lastExitOutput;
   let idleSince;
   let superseded = false;
   let ticks = 0;
+  const servingState = (pid) => ({
+    supervisorPid: ports.ownPid,
+    headroomPid: pid,
+    socketPath,
+    version,
+    allowlistHash: runningHash,
+    settingsHash: runningSettingsHash,
+    installedSource
+  });
   for (; ; ) {
     if (options.tickLimit !== void 0 && ticks >= options.tickLimit) {
       return HEADROOM_SUPERVISOR_STILL_RUNNING;
@@ -3336,7 +3743,10 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     ticks += 1;
     config = ports.readConfig();
     const settingsHash = hashSettings(config.settings);
-    const allowlist = allowlistOf(ports);
+    const inputs = currentHeadroomAllowlistInputs(fs12, paths, ports.frontDoorLiveness);
+    pruneDeadFrontDoorDirectRecords(fs12, paths.frontdoorDirectRecordsDir, inputs.frontDoorRecords, inputs.frontDoorLiveness);
+    pruneMalformedFrontDoorDirectFiles(fs12, paths.frontdoorDirectRecordsDir, ports.isRunning);
+    const allowlist = inputs.frontDoorOrigins;
     const allowlistHash = hashAllowlist(allowlist);
     pruneDeadSessions(fs12, paths.headroomSessionsDir, ports.isRunning);
     const ownsNow = ownsState();
@@ -3344,6 +3754,13 @@ async function runSupervisor(initialConfig, ports, options = {}) {
       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 allowlistFailure = ownsNow ? syncAllowlistFile(allowlist) ?? allowlistFileRefusal(allowlist) : void 0;
+    if (allowlistFailure !== void 0) {
+      if (headroomPid !== void 0 && ports.isRunning(headroomPid)) {
+        ports.stopProcess(headroomPid);
+      }
+      return fail(allowlistFailure);
+    }
     const crashed = headroomPid !== void 0 && !ports.isRunning(headroomPid);
     if (headroomPid === void 0 || crashed) {
       if (crashed) {
@@ -3358,43 +3775,53 @@ async function runSupervisor(initialConfig, ports, options = {}) {
         });
       }
       if (consecutiveFailures >= HEADROOM_START_RETRY_BUDGET) {
-        return fail(`headroom failed to become ready ${String(consecutiveFailures)} times in a row; giving up`);
+        return fail(
+          `headroom failed to become ready ${String(consecutiveFailures)} times in a row; giving up` + (lastExitOutput === void 0 ? "" : `; the last attempt exited before it was ready, and its log ends: ${lastExitOutput}`)
+        );
       }
       if (installedSource !== config.source && !ensureInstalled()) {
         return fail(`could not install headroom from ${config.source}: install failed (is uv installed and on PATH?)`);
       }
-      const pid = ports.spawnHeadroom(socketPath, allowlist, config.settings);
-      const ready = await waitUntilReady(ports, socketPath);
-      if (ready) {
+      const logOffset = ports.daemonLogSize();
+      const pid = ports.spawnHeadroom(socketPath, paths.headroomAllowlistFile, config.settings);
+      writeOwnState({ supervisorPid: ports.ownPid, headroomPid: pid, version, installedSource });
+      const outcome = await waitUntilReady(ports, socketPath, pid);
+      if (outcome === "ready") {
         consecutiveFailures = 0;
+        lastExitOutput = void 0;
         headroomPid = pid;
         runningHash = allowlistHash;
         runningSettingsHash = settingsHash;
-        const recorded = writeOwnState({
-          supervisorPid: ports.ownPid,
-          headroomPid: pid,
-          socketPath,
-          version,
-          allowlistHash,
-          settingsHash,
-          installedSource: config.source
-        });
+        const recorded = writeOwnState(servingState(pid));
         if (recorded) {
           fs12.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)})`
-        );
+        if (outcome === "exited") {
+          lastExitOutput = lastLines(ports.readDaemonLogTail(logOffset, DAEMON_LOG_TAIL_BYTES));
+          ports.log(
+            `agent-shim headroom supervisor: headroom exited before it was ready on unix socket ${socketPath} (attempt ${String(consecutiveFailures)} of ${String(HEADROOM_START_RETRY_BUDGET)})`
+          );
+        } else {
+          lastExitOutput = void 0;
+          ports.stopProcess(pid);
+          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 !== config.source) {
+      if (runningHash !== allowlistHash) {
+        runningHash = allowlistHash;
+        writeOwnState(servingState(headroomPid));
+        ports.log(`agent-shim headroom supervisor: headroom pid ${String(headroomPid)} now serves allowlist [${allowlist.join(", ")}]`);
+      }
+      if (runningSettingsHash !== settingsHash || installedSource !== config.source) {
         if (sessionsForSupervisor(fs12, paths.headroomSessionsDir, ports.ownPid).length === 0) {
           ports.log("agent-shim headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
           ports.stopProcess(headroomPid);
@@ -3423,45 +3850,66 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     await ports.sleep(HEADROOM_POLL_MS);
   }
 }
-function currentHeadroomAllowlistInputs(fs12, paths) {
+function undeterminedFrontDoors(inputs) {
+  return inputs.frontDoorRecords.flatMap((record) => {
+    const reason = inputs.frontDoorLiveness.unknown.get(record.pid);
+    return reason === void 0 ? [] : [{ pid: record.pid, origin: directOrigin(record.directPort), reason }];
+  });
+}
+function currentHeadroomAllowlistInputs(fs12, paths, frontDoorLiveness) {
+  const named = frontDoorOrigin(readFrontDoorState(fs12, paths.frontdoorStateFile));
+  const records = listFrontDoorDirectRecords(fs12, paths.frontdoorDirectRecordsDir);
+  const liveness = frontDoorLiveness(records.map((record) => record.pid));
+  const live = liveFrontDoorDirectRecords(records, liveness).map((record) => directOrigin(record.directPort));
   return {
-    providers: readAllProviders(fs12, paths.providersDir).map((entry) => entry.provider),
-    frontDoorOrigin: frontDoorOrigin(readFrontDoorState(fs12, paths.frontdoorStateFile))
+    frontDoorRecords: records,
+    frontDoorLiveness: liveness,
+    frontDoorOrigins: [.../* @__PURE__ */ new Set([...named === void 0 ? [] : [named], ...live])].sort()
   };
 }
-function currentHeadroomAllowlist(fs12, paths) {
-  const inputs = currentHeadroomAllowlistInputs(fs12, paths);
-  return headroomAllowlist(headroomUpstreams(inputs.providers, inputs.frontDoorOrigin));
-}
-function allowlistOf(ports) {
-  return currentHeadroomAllowlist(ports.fs, ports.paths);
+function launchRequiredUpstreams(fs12, paths) {
+  const door = frontDoorOrigin(readFrontDoorState(fs12, paths.frontdoorStateFile));
+  return door === void 0 ? [] : [door];
 }
-async function waitUntilReady(ports, socketPath) {
+async function waitUntilReady(ports, socketPath, pid) {
   const deadline = ports.now() + HEADROOM_READY_TIMEOUT_MS;
   for (; ; ) {
     if (await ports.ready(socketPath)) {
-      return true;
+      return "ready";
+    }
+    if (!ports.isRunning(pid)) {
+      return "exited";
     }
     if (ports.now() >= deadline) {
-      return false;
+      return "timed-out";
     }
     await ports.sleep(HEADROOM_POLL_MS);
   }
 }
-var HEADROOM_BACKOFF_BASE_MS, HEADROOM_BACKOFF_CAP_MS, HEADROOM_START_RETRY_BUDGET, HEADROOM_READY_TIMEOUT_MS, HEADROOM_POLL_MS, MS_PER_MINUTE2, HEADROOM_SUPERVISOR_STILL_RUNNING;
+function lastLines(output) {
+  const lines = redactText(output).split("\n").map((line) => line.trim()).filter((line) => line !== "").map((line) => line.length > DAEMON_EXIT_LOG_LINE_CHARS ? `${line.slice(0, DAEMON_EXIT_LOG_LINE_CHARS)}...` : line);
+  return lines.length === 0 ? "(the daemon wrote nothing)" : lines.slice(-DAEMON_EXIT_LOG_LINES).join(" | ");
+}
+var import_node_path13, HEADROOM_BACKOFF_BASE_MS, HEADROOM_BACKOFF_CAP_MS, HEADROOM_START_RETRY_BUDGET, HEADROOM_READY_TIMEOUT_MS, DAEMON_EXIT_LOG_LINES, DAEMON_EXIT_LOG_LINE_CHARS, DAEMON_LOG_TAIL_BYTES, HEADROOM_POLL_MS, MS_PER_MINUTE2, HEADROOM_SUPERVISOR_STILL_RUNNING;
 var init_supervisor = __esm({
   "src/headroom/supervisor.ts"() {
     "use strict";
+    import_node_path13 = __toESM(require("node:path"), 1);
     init_schema();
     init_state();
     init_settings();
+    init_capture();
     init_socket();
+    init_earlierRelease();
     init_source();
     init_state2();
     HEADROOM_BACKOFF_BASE_MS = 500;
     HEADROOM_BACKOFF_CAP_MS = 3e4;
     HEADROOM_START_RETRY_BUDGET = 5;
     HEADROOM_READY_TIMEOUT_MS = 15e3;
+    DAEMON_EXIT_LOG_LINES = 6;
+    DAEMON_EXIT_LOG_LINE_CHARS = 400;
+    DAEMON_LOG_TAIL_BYTES = 8192;
     HEADROOM_POLL_MS = 1e3;
     MS_PER_MINUTE2 = 6e4;
     HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
@@ -3497,8 +3945,18 @@ function realIsFrontDoorSupervisor(pid) {
   const result = (0, import_node_child_process2.spawnSync)("ps", ["-o", "pid=,command=", "-p", String(pid)], { encoding: "utf8" });
   return result.status === 0 && parseFrontDoorSupervisorPids(result.stdout).includes(pid);
 }
+function realProcessCommandLine(pid) {
+  const result = (0, import_node_child_process2.spawnSync)("ps", ["-o", "command=", "-p", String(pid)], { encoding: "utf8", timeout: PS_TIMEOUT_MS });
+  return result.status === 0 ? result.stdout.trim() : void 0;
+}
+function realFrontDoorLiveness(pids) {
+  return frontDoorLivenessOf(pids, (asked) => {
+    const result = (0, import_node_child_process2.spawnSync)("ps", ["-o", "pid=,stat=,command=", "-p", asked.map(String).join(",")], { encoding: "utf8", timeout: PS_TIMEOUT_MS });
+    return { status: result.status, stdout: result.stdout, stderr: result.stderr, ...result.error === void 0 ? {} : { error: result.error } };
+  });
+}
 function expandHome2(filePath) {
-  return filePath.startsWith("~/") ? import_node_path13.default.join(import_node_os2.default.homedir(), filePath.slice(1)) : filePath;
+  return filePath.startsWith("~/") ? import_node_path14.default.join(import_node_os2.default.homedir(), filePath.slice(1)) : filePath;
 }
 function hasDesktopSession() {
   if (process.platform === "darwin") {
@@ -3542,7 +4000,7 @@ function spawnDaemonThroughScript(script) {
   return (paths, subcommand, logPath) => spawnDetachedDaemon({ command: process.execPath, args: [script, subcommand] }, paths, subcommand, logPath);
 }
 function spawnDetachedDaemon(invocation, paths, subcommand, logPath) {
-  import_node_fs2.default.mkdirSync(import_node_path13.default.dirname(logPath), { recursive: true });
+  import_node_fs2.default.mkdirSync(import_node_path14.default.dirname(logPath), { recursive: true });
   const logFd = import_node_fs2.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 }));
@@ -3564,13 +4022,14 @@ function realHeadroomPort(paths, options) {
       const up = ensureHeadroom({
         paths,
         launcherPid: process.pid,
-        ...routesProvider ? { requiredAllowlistHash: () => hashAllowlist(currentHeadroomAllowlist(realFarmFs, paths)) } : {},
+        ...routesProvider ? { requiredUpstreams: () => launchRequiredUpstreams(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.
           isRunning: realIsProcessRunning,
           now: () => Date.now(),
           sleep: realSleepSync,
+          daemonCommandLine: realProcessCommandLine,
           spawnSupervisor: (layout) => spawnHeadroomSupervisor(layout, options.spawnDaemon)
         }
       });
@@ -3595,7 +4054,7 @@ function listVersionsDir(dir) {
     throw error;
   }
   return entries.filter((entry) => entry.isFile()).map((entry) => {
-    const fullPath = import_node_path13.default.join(dir, entry.name);
+    const fullPath = import_node_path14.default.join(dir, entry.name);
     const stat = import_node_fs2.default.statSync(fullPath);
     return {
       name: entry.name,
@@ -3609,7 +4068,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_path13.default.join(dir, name);
+  const candidate = import_node_path14.default.join(dir, name);
   if (env.platform === "win32") {
     const extensions = windowsPathExtensions(env.pathext);
     const alreadyHasRecognisedExtension = extensions.some((ext) => candidate.toLowerCase().endsWith(ext.toLowerCase()));
@@ -3658,13 +4117,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_path13.default.resolve(env.cwd, env.argv1);
-  const candidateDir = import_node_path13.default.dirname(candidate);
-  const candidateDirOnPath = env.pathDirs.some((dir) => import_node_path13.default.resolve(dir) === candidateDir);
+  const candidate = env.argv1 === void 0 ? env.execPath : import_node_path14.default.resolve(env.cwd, env.argv1);
+  const candidateDir = import_node_path14.default.dirname(candidate);
+  const candidateDirOnPath = env.pathDirs.some((dir) => import_node_path14.default.resolve(dir) === candidateDir);
   if (candidateDirOnPath) {
     return candidate;
   }
-  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path13.default.basename(candidate), env.findExecutableInDir);
+  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path14.default.basename(candidate), env.findExecutableInDir);
   return viaPath ?? candidate;
 }
 function realOwnExecutablePath() {
@@ -3672,7 +4131,7 @@ function realOwnExecutablePath() {
     argv1: process.argv[1],
     execPath: process.execPath,
     cwd: process.cwd(),
-    pathDirs: (process.env.PATH ?? "").split(import_node_path13.default.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(import_node_path14.default.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir
   });
 }
@@ -3685,7 +4144,7 @@ function realContentSourcePath() {
 function realResolveClaudeBinary(isOwnBinary) {
   return (request4) => discoverClaudeBinary({
     listVersionsDir,
-    pathDirs: (process.env.PATH ?? "").split(import_node_path13.default.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(import_node_path14.default.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir,
     isOwnBinary,
     ...request4?.version === void 0 ? {} : { version: request4.version }
@@ -3694,7 +4153,7 @@ function realResolveClaudeBinary(isOwnBinary) {
 function realInstalledClaudeVersions() {
   return installedVersions(listVersionsDir(defaultVersionsDir()));
 }
-var import_node_child_process2, import_node_crypto8, import_node_fs2, import_node_os2, import_node_path13, import_node_sea, realFsPort, OWNER_ONLY_DIR_MODE, OWNER_ONLY_FILE_MODE, PERMISSION_BITS, realFarmFs, INT32_BYTE_LENGTH, realRunPort, MACOS_GUI_SESSION_MANAGER, realCredentialPort, SOCKET_PERMISSION_BITS, realHeadroomSocketTrust, realSpawnPort, realProcPort, EXECUTE_BITS_MASK, WINDOWS_DEFAULT_PATHEXT;
+var import_node_child_process2, import_node_crypto8, import_node_fs2, import_node_os2, import_node_path14, import_node_sea, realFsPort, OWNER_ONLY_DIR_MODE, OWNER_ONLY_FILE_MODE, PERMISSION_BITS, realFarmFs, INT32_BYTE_LENGTH, PS_TIMEOUT_MS, realRunPort, MACOS_GUI_SESSION_MANAGER, realCredentialPort, SOCKET_PERMISSION_BITS, realHeadroomSocketTrust, realSpawnPort, realProcPort, EXECUTE_BITS_MASK, WINDOWS_DEFAULT_PATHEXT;
 var init_realPorts = __esm({
   "src/realPorts.ts"() {
     "use strict";
@@ -3702,7 +4161,7 @@ var init_realPorts = __esm({
     import_node_crypto8 = require("node:crypto");
     import_node_fs2 = __toESM(require("node:fs"), 1);
     import_node_os2 = __toESM(require("node:os"), 1);
-    import_node_path13 = __toESM(require("node:path"), 1);
+    import_node_path14 = __toESM(require("node:path"), 1);
     import_node_sea = require("node:sea");
     init_load();
     init_versionDiscovery();
@@ -3794,9 +4253,14 @@ var init_realPorts = __esm({
       },
       writeFilePrivate(filePath, contents) {
         const temp = `${filePath}.${String(process.pid)}.tmp`;
-        import_node_fs2.default.writeFileSync(temp, contents, { encoding: "utf8", mode: OWNER_ONLY_FILE_MODE });
-        import_node_fs2.default.chmodSync(temp, OWNER_ONLY_FILE_MODE);
-        import_node_fs2.default.renameSync(temp, filePath);
+        try {
+          import_node_fs2.default.writeFileSync(temp, contents, { encoding: "utf8", mode: OWNER_ONLY_FILE_MODE });
+          import_node_fs2.default.chmodSync(temp, OWNER_ONLY_FILE_MODE);
+          import_node_fs2.default.renameSync(temp, filePath);
+        } catch (error) {
+          import_node_fs2.default.rmSync(temp, { force: true });
+          throw error;
+        }
       },
       appendFilePrivate(filePath, contents) {
         const descriptor = import_node_fs2.default.openSync(filePath, "a", OWNER_ONLY_FILE_MODE);
@@ -3836,6 +4300,7 @@ var init_realPorts = __esm({
       }
     };
     INT32_BYTE_LENGTH = 4;
+    PS_TIMEOUT_MS = 2e3;
     realRunPort = {
       run(command, args) {
         const result = (0, import_node_child_process2.spawnSync)(command, [...args], { encoding: "utf8" });
@@ -3874,7 +4339,7 @@ var init_realPorts = __esm({
       },
       personPresent: () => process.stdin.isTTY || hasDesktopSession()
     };
-    SOCKET_PERMISSION_BITS = 511;
+    SOCKET_PERMISSION_BITS = 4095;
     realHeadroomSocketTrust = {
       platform: process.platform,
       currentUid: () => {
@@ -3893,9 +4358,10 @@ var init_realPorts = __esm({
           }
           throw error;
         }
-        const kind = stat.isSymbolicLink() ? "symlink" : stat.isDirectory() ? "dir" : stat.isSocket() ? "socket" : "other";
+        const kind = stat.isSymbolicLink() ? "symlink" : stat.isDirectory() ? "dir" : stat.isFile() ? "file" : stat.isSocket() ? "socket" : "other";
         return { kind, uid: stat.uid, mode: stat.mode & SOCKET_PERMISSION_BITS };
-      }
+      },
+      readlink: (target) => import_node_fs2.default.readlinkSync(target, "utf8")
     };
     realSpawnPort = {
       spawnSync(command, args, options) {
@@ -3919,18 +4385,18 @@ function expandTilde(value, home) {
     return home;
   }
   if (value.startsWith("~/")) {
-    return import_node_path14.default.join(home, value.slice(2));
+    return import_node_path15.default.join(home, value.slice(2));
   }
   return value;
 }
 function normaliseRulePath(rulePath, home) {
-  return import_node_path14.default.resolve(expandTilde(rulePath, home));
+  return import_node_path15.default.resolve(expandTilde(rulePath, home));
 }
-var import_node_path14;
+var import_node_path15;
 var init_pathNorm = __esm({
   "src/pathNorm.ts"() {
     "use strict";
-    import_node_path14 = __toESM(require("node:path"), 1);
+    import_node_path15 = __toESM(require("node:path"), 1);
   }
 });
 
@@ -3939,7 +4405,7 @@ function loadCascadeInput(params) {
   const globalConfig = loadConfigFile(params.paths.globalConfigFile, GlobalConfigSchema, params.read);
   const directoryRules = loadConfigFile(params.paths.directoryRulesFile, DirectoryRulesSchema, params.read);
   const loadProfile = (name) => {
-    const filepath = import_node_path15.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;
@@ -3954,8 +4420,8 @@ function loadCascadeInput(params) {
   });
   const levels = [];
   for (const dir of dirs) {
-    const portable = loadConfigFile(import_node_path15.default.join(dir, PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path15.default.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read);
-    const portableLocal = loadConfigFile(import_node_path15.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path15.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 {
@@ -4002,11 +4468,11 @@ function readDirectorySelections(loaded) {
   }
   return { ...identity === void 0 ? {} : { identity }, ...configProfile === void 0 ? {} : { configProfile } };
 }
-var import_node_path15, PORTABLE_CONFIG_FILENAME, PORTABLE_LOCAL_CONFIG_FILENAME;
+var import_node_path16, PORTABLE_CONFIG_FILENAME, PORTABLE_LOCAL_CONFIG_FILENAME;
 var init_cascade = __esm({
   "src/launcher/cascade.ts"() {
     "use strict";
-    import_node_path15 = __toESM(require("node:path"), 1);
+    import_node_path16 = __toESM(require("node:path"), 1);
     init_load();
     init_schema();
     init_pathNorm();
@@ -4070,13 +4536,13 @@ function decideConfigProfile(params) {
   return { source: "none" };
 }
 function loadIdentity(identitiesDir, name, fs12) {
-  return loadConfigFile(import_node_path16.default.join(identitiesDir, name, "identity.json"), IdentitySchema, fs12.readConfigFile);
+  return loadConfigFile(import_node_path17.default.join(identitiesDir, name, "identity.json"), IdentitySchema, fs12.readConfigFile);
 }
-var import_node_path16, IDENTITY_DECISION_SOURCES, CONFIG_PROFILE_DECISION_SOURCES;
+var import_node_path17, IDENTITY_DECISION_SOURCES, CONFIG_PROFILE_DECISION_SOURCES;
 var init_identity = __esm({
   "src/launcher/identity.ts"() {
     "use strict";
-    import_node_path16 = __toESM(require("node:path"), 1);
+    import_node_path17 = __toESM(require("node:path"), 1);
     init_load();
     init_schema();
     IDENTITY_DECISION_SOURCES = [
@@ -4298,7 +4764,7 @@ function isIdentityName(name) {
   return IdentitySchema.shape.name.safeParse(name).success;
 }
 function claudeJsonPath(identitiesDir, identity) {
-  return import_node_path17.default.join(identitiesDir, identity, CLAUDE_JSON);
+  return import_node_path18.default.join(identitiesDir, identity, CLAUDE_JSON);
 }
 function readAccountMetadata(fs12, identitiesDir, identity) {
   if (!isIdentityName(identity)) {
@@ -4352,11 +4818,11 @@ function createAccountReader(fs12, identitiesDir) {
     return account;
   };
 }
-var import_node_path17, CLAUDE_JSON, AccountMetadataError;
+var import_node_path18, CLAUDE_JSON, AccountMetadataError;
 var init_account = __esm({
   "src/usage/account.ts"() {
     "use strict";
-    import_node_path17 = __toESM(require("node:path"), 1);
+    import_node_path18 = __toESM(require("node:path"), 1);
     init_cliError();
     init_schema();
     init_schema2();
@@ -4915,7 +5381,7 @@ function readUsageLog(fs12, logDir, options = {}) {
     if (sinceMs !== void 0 && segment.endsAt <= sinceMs) {
       continue;
     }
-    const contents = fs12.readFileUtf8(import_node_path18.default.join(logDir, segment.name));
+    const contents = fs12.readFileUtf8(import_node_path19.default.join(logDir, segment.name));
     if (contents === void 0) {
       continue;
     }
@@ -4949,7 +5415,7 @@ function snapshotPath(snapshotsDir, identity) {
   if (!isIdentityName(identity)) {
     throw new Error(`"${identity}" is not a valid identity name.`);
   }
-  return import_node_path18.default.join(snapshotsDir, `${identity}.json`);
+  return import_node_path19.default.join(snapshotsDir, `${identity}.json`);
 }
 function readUsageSnapshot(fs12, snapshotsDir, identity) {
   const file = snapshotPath(snapshotsDir, identity);
@@ -4982,11 +5448,11 @@ function listUsageSnapshots(fs12, snapshotsDir) {
     return snapshot === void 0 ? [] : [snapshot];
   }).sort((left, right) => left.identity.localeCompare(right.identity));
 }
-var import_node_path18, SEGMENT_RE, DAY_MS, UsageSnapshotError;
+var import_node_path19, SEGMENT_RE, DAY_MS, UsageSnapshotError;
 var init_read = __esm({
   "src/usage/read.ts"() {
     "use strict";
-    import_node_path18 = __toESM(require("node:path"), 1);
+    import_node_path19 = __toESM(require("node:path"), 1);
     init_account();
     init_schema2();
     SEGMENT_RE = /^(\d{4}-\d{2}-\d{2})\.(\d+)\.jsonl$/;
@@ -5007,7 +5473,7 @@ function pruneUsageLog(fs12, logDir, nowMs) {
   const cutoff = nowMs - USAGE_RETENTION_MS;
   for (const segment of listLogSegments(fs12, logDir)) {
     if (segment.endsAt <= cutoff) {
-      fs12.removeRecursive(import_node_path19.default.join(logDir, segment.name));
+      fs12.removeRecursive(import_node_path20.default.join(logDir, segment.name));
     }
   }
 }
@@ -5089,7 +5555,7 @@ function createUsageStore(deps) {
         pruneUsageLog(fs12, paths.usageLogDir, nowMs);
         prunedDay = day;
       }
-      fs12.appendFilePrivate(import_node_path19.default.join(paths.usageLogDir, segmentName(day, deps.pid)), `${JSON.stringify(record)}
+      fs12.appendFilePrivate(import_node_path20.default.join(paths.usageLogDir, segmentName(day, deps.pid)), `${JSON.stringify(record)}
 `);
       if (record.identity !== void 0) {
         rewriteSnapshot(record.identity, (current) => ({ ...current?.providers, [record.provider]: foldProviderState(current?.providers[record.provider], record) }));
@@ -5112,11 +5578,11 @@ function createUsageStore(deps) {
     })
   };
 }
-var import_node_path19, DAY_MS2, DAYS_IN_WEEK, USAGE_RETENTION_MS;
+var import_node_path20, DAY_MS2, DAYS_IN_WEEK, USAGE_RETENTION_MS;
 var init_store2 = __esm({
   "src/usage/store.ts"() {
     "use strict";
-    import_node_path19 = __toESM(require("node:path"), 1);
+    import_node_path20 = __toESM(require("node:path"), 1);
     init_account();
     init_rateLimit();
     init_read();
@@ -5254,15 +5720,15 @@ function recordStickyPick(fs12, picksFile, directory, identity, nowMs) {
   const current = readPicksFile(fs12, 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() } } };
-  fs12.mkdirPrivate(import_node_path20.default.dirname(picksFile));
+  fs12.mkdirPrivate(import_node_path21.default.dirname(picksFile));
   fs12.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
 `);
 }
-var import_node_path20, import_zod13, PoolGraphError, SCHEMA_VERSION, PickEntrySchema, PicksFileSchema;
+var import_node_path21, import_zod13, PoolGraphError, SCHEMA_VERSION, PickEntrySchema, PicksFileSchema;
 var init_poolPick = __esm({
   "src/usage/poolPick.ts"() {
     "use strict";
-    import_node_path20 = __toESM(require("node:path"), 1);
+    import_node_path21 = __toESM(require("node:path"), 1);
     import_zod13 = require("zod");
     init_cliError();
     init_identity();
@@ -5293,8 +5759,8 @@ function resolveAgentShimHome(env = process.env, home = import_node_os4.default.
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  const current = import_node_path22.default.join(home, HOME_DIRNAME);
-  const legacy = import_node_path22.default.join(home, LEGACY_HOME_DIRNAME);
+  const current = import_node_path23.default.join(home, HOME_DIRNAME);
+  const legacy = import_node_path23.default.join(home, LEGACY_HOME_DIRNAME);
   return !isDirectory(current) && isDirectory(legacy) ? legacy : current;
 }
 function isExistingDirectory(candidate) {
@@ -5305,59 +5771,61 @@ function resolveClaudeHome() {
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  return import_node_path22.default.join(import_node_os4.default.homedir(), ".claude");
+  return import_node_path23.default.join(import_node_os4.default.homedir(), ".claude");
 }
 function buildLayoutPaths(root) {
   return {
     root,
-    identitiesDir: import_node_path22.default.join(root, "identities"),
-    configProfilesDir: import_node_path22.default.join(root, "config-profiles"),
-    providersDir: import_node_path22.default.join(root, "providers"),
-    directoryRulesFile: import_node_path22.default.join(root, "directory-rules.json"),
-    activeIdentityFile: import_node_path22.default.join(root, "active-identity"),
-    globalConfigFile: import_node_path22.default.join(root, "config.json"),
-    categoriesLocalFile: import_node_path22.default.join(root, "categories.local.json"),
-    claudeShimFile: import_node_path22.default.join(root, "claude-shim.json"),
-    headroomDir: import_node_path22.default.join(root, "headroom"),
-    headroomStateFile: import_node_path22.default.join(root, "headroom", "state.json"),
-    headroomLegacyStateFile: import_node_path22.default.join(root, "headroom", "state.v2.json"),
-    headroomSocketDir: import_node_path22.default.join(root, "headroom", "run"),
-    headroomLockFile: import_node_path22.default.join(root, "headroom", "start.lock"),
-    headroomSessionsDir: import_node_path22.default.join(root, "headroom", "sessions"),
-    logsDir: import_node_path22.default.join(root, "logs"),
-    headroomLogPath: import_node_path22.default.join(root, "logs", "headroom.log"),
-    frontdoorDir: import_node_path22.default.join(root, "frontdoor"),
-    frontdoorCaDir: import_node_path22.default.join(root, "frontdoor", "ca"),
-    frontdoorCaCertFile: import_node_path22.default.join(root, "frontdoor", "ca", "ca.pem"),
-    frontdoorCaKeyFile: import_node_path22.default.join(root, "frontdoor", "ca", "ca.key"),
-    frontdoorCaBundlesDir: import_node_path22.default.join(root, "frontdoor", "ca", "bundles"),
-    chatgptSignInFile: import_node_path22.default.join(root, "codex", "chatgpt-sign-in.json"),
-    frontdoorStateFile: import_node_path22.default.join(root, "frontdoor", "state.json"),
-    frontdoorLockFile: import_node_path22.default.join(root, "frontdoor", "start.lock"),
-    frontdoorControlTokenFile: import_node_path22.default.join(root, "frontdoor", "control-token"),
-    frontdoorSessionsDir: import_node_path22.default.join(root, "frontdoor", "sessions"),
-    frontdoorRcCredentialsDir: import_node_path22.default.join(root, "frontdoor", "rc-credentials"),
-    frontdoorLogPath: import_node_path22.default.join(root, "logs", "frontdoor.log"),
-    usageDir: import_node_path22.default.join(root, "usage"),
-    usageLogDir: import_node_path22.default.join(root, "usage", "log"),
-    usageSnapshotsDir: import_node_path22.default.join(root, "usage", "snapshots"),
-    usagePicksFile: import_node_path22.default.join(root, "usage", "picks.json"),
-    usageAnchorsFile: import_node_path22.default.join(root, "usage", "anchors.json"),
-    usageJobsFile: import_node_path22.default.join(root, "usage", "jobs.json"),
-    jobLogsDir: import_node_path22.default.join(root, "logs", "jobs"),
-    mcpPermissionsFile: import_node_path22.default.join(root, "mcp", "permissions.json")
+    identitiesDir: import_node_path23.default.join(root, "identities"),
+    configProfilesDir: import_node_path23.default.join(root, "config-profiles"),
+    providersDir: import_node_path23.default.join(root, "providers"),
+    directoryRulesFile: import_node_path23.default.join(root, "directory-rules.json"),
+    activeIdentityFile: import_node_path23.default.join(root, "active-identity"),
+    globalConfigFile: import_node_path23.default.join(root, "config.json"),
+    categoriesLocalFile: import_node_path23.default.join(root, "categories.local.json"),
+    claudeShimFile: import_node_path23.default.join(root, "claude-shim.json"),
+    headroomDir: import_node_path23.default.join(root, "headroom"),
+    headroomStateFile: import_node_path23.default.join(root, "headroom", "state.json"),
+    headroomLegacyStateFile: import_node_path23.default.join(root, "headroom", "state.v2.json"),
+    headroomAllowlistFile: import_node_path23.default.join(root, "headroom", "run", "allowlist.txt"),
+    headroomSocketDir: import_node_path23.default.join(root, "headroom", "run"),
+    headroomLockFile: import_node_path23.default.join(root, "headroom", "start.lock"),
+    headroomSessionsDir: import_node_path23.default.join(root, "headroom", "sessions"),
+    logsDir: import_node_path23.default.join(root, "logs"),
+    headroomLogPath: import_node_path23.default.join(root, "logs", "headroom.log"),
+    frontdoorDir: import_node_path23.default.join(root, "frontdoor"),
+    frontdoorCaDir: import_node_path23.default.join(root, "frontdoor", "ca"),
+    frontdoorCaCertFile: import_node_path23.default.join(root, "frontdoor", "ca", "ca.pem"),
+    frontdoorCaKeyFile: import_node_path23.default.join(root, "frontdoor", "ca", "ca.key"),
+    frontdoorCaBundlesDir: import_node_path23.default.join(root, "frontdoor", "ca", "bundles"),
+    chatgptSignInFile: import_node_path23.default.join(root, "codex", "chatgpt-sign-in.json"),
+    frontdoorStateFile: import_node_path23.default.join(root, "frontdoor", "state.json"),
+    frontdoorLockFile: import_node_path23.default.join(root, "frontdoor", "start.lock"),
+    frontdoorControlTokenFile: import_node_path23.default.join(root, "frontdoor", "control-token"),
+    frontdoorSessionsDir: import_node_path23.default.join(root, "frontdoor", "sessions"),
+    frontdoorDirectRecordsDir: import_node_path23.default.join(root, "frontdoor", "direct"),
+    frontdoorRcCredentialsDir: import_node_path23.default.join(root, "frontdoor", "rc-credentials"),
+    frontdoorLogPath: import_node_path23.default.join(root, "logs", "frontdoor.log"),
+    usageDir: import_node_path23.default.join(root, "usage"),
+    usageLogDir: import_node_path23.default.join(root, "usage", "log"),
+    usageSnapshotsDir: import_node_path23.default.join(root, "usage", "snapshots"),
+    usagePicksFile: import_node_path23.default.join(root, "usage", "picks.json"),
+    usageAnchorsFile: import_node_path23.default.join(root, "usage", "anchors.json"),
+    usageJobsFile: import_node_path23.default.join(root, "usage", "jobs.json"),
+    jobLogsDir: import_node_path23.default.join(root, "logs", "jobs"),
+    mcpPermissionsFile: import_node_path23.default.join(root, "mcp", "permissions.json")
   };
 }
 function resolveLayoutPaths() {
   return buildLayoutPaths(resolveAgentShimHome());
 }
-var import_node_fs4, import_node_os4, import_node_path22;
+var import_node_fs4, import_node_os4, import_node_path23;
 var init_paths = __esm({
   "src/paths.ts"() {
     "use strict";
     import_node_fs4 = __toESM(require("node:fs"), 1);
     import_node_os4 = __toESM(require("node:os"), 1);
-    import_node_path22 = __toESM(require("node:path"), 1);
+    import_node_path23 = __toESM(require("node:path"), 1);
     init_legacy();
   }
 });
@@ -5462,8 +5930,8 @@ function security(args, stdin) {
   return { status: result.status, stdout: result.stdout };
 }
 function createRealCredentialCache(root) {
-  const dir = import_node_path23.default.join(root, "credential-cache");
-  const filePath = (owner) => import_node_path23.default.join(dir, cacheFileNameFor(owner));
+  const dir = import_node_path24.default.join(root, "credential-cache");
+  const filePath = (owner) => import_node_path24.default.join(dir, cacheFileNameFor(owner));
   return {
     read(store, owner) {
       if (store === "file") {
@@ -5509,13 +5977,13 @@ function createRealCredentialCache(root) {
 function realCredentialCacheEnv(paths) {
   return { port: createRealCredentialCache(paths.root), platform: process.platform, now: () => Date.now() };
 }
-var import_node_child_process3, import_node_fs5, import_node_path23, KEYCHAIN_CACHE_SERVICE, CACHE_DIR_MODE, CACHE_FILE_MODE;
+var import_node_child_process3, import_node_fs5, import_node_path24, KEYCHAIN_CACHE_SERVICE, CACHE_DIR_MODE, CACHE_FILE_MODE;
 var init_realCredentialCache = __esm({
   "src/realCredentialCache.ts"() {
     "use strict";
     import_node_child_process3 = require("node:child_process");
     import_node_fs5 = __toESM(require("node:fs"), 1);
-    import_node_path23 = __toESM(require("node:path"), 1);
+    import_node_path24 = __toESM(require("node:path"), 1);
     init_credentialCache();
     KEYCHAIN_CACHE_SERVICE = "agent-shim-credential-cache";
     CACHE_DIR_MODE = 448;
@@ -5698,7 +6166,7 @@ var init_credential = __esm({
 
 // src/providersStore.ts
 function providerJsonPath(paths, name) {
-  return import_node_path24.default.join(paths.providersDir, `${name}.json`);
+  return import_node_path25.default.join(paths.providersDir, `${name}.json`);
 }
 function providerExists(paths, name) {
   return import_node_fs6.default.existsSync(providerJsonPath(paths, name));
@@ -5758,7 +6226,7 @@ function readProvider(paths, name) {
   return parseProviderFile(filePath, raw);
 }
 function loadProvider(providersDir, name, port) {
-  const filePath = import_node_path24.default.join(providersDir, `${name}.json`);
+  const filePath = import_node_path25.default.join(providersDir, `${name}.json`);
   const raw = port.readConfigFile(filePath);
   return raw === void 0 ? void 0 : parseProviderFile(filePath, raw);
 }
@@ -5920,12 +6388,12 @@ function resolveProvider(params) {
   }
   return { ok: true, provider: { name, definition, credential: resolution.credential }, warnings: resolution.credential.warnings };
 }
-var import_node_fs6, import_node_path24, ProviderNotFoundError, ProviderAlreadyExistsError, InvalidProviderNameError, PROVIDER_NAME_RE, LEGACY_PROVIDER_FIELDS, LEGACY_ENV_CREDENTIAL_KEYS, LEGACY_LITERAL_PLACEHOLDER, LegacyProviderFileError, ProviderKindMismatchError;
+var import_node_fs6, import_node_path25, ProviderNotFoundError, ProviderAlreadyExistsError, InvalidProviderNameError, PROVIDER_NAME_RE, LEGACY_PROVIDER_FIELDS, LEGACY_ENV_CREDENTIAL_KEYS, LEGACY_LITERAL_PLACEHOLDER, LegacyProviderFileError, ProviderKindMismatchError;
 var init_providersStore = __esm({
   "src/providersStore.ts"() {
     "use strict";
     import_node_fs6 = __toESM(require("node:fs"), 1);
-    import_node_path24 = __toESM(require("node:path"), 1);
+    import_node_path25 = __toESM(require("node:path"), 1);
     init_load();
     init_store();
     init_schema();
@@ -6137,10 +6605,10 @@ function commandFilename(ownExecutablePath, commandName) {
 }
 function resolveOwnBinaryCheck(paths, contentSourcePath) {
   const state = readJson(paths.claudeShimFile, ClaudeShimStateSchema);
-  const recordedTarget = state === void 0 ? void 0 : import_node_path26.default.resolve(state.targetPath);
+  const recordedTarget = state === void 0 ? void 0 : import_node_path27.default.resolve(state.targetPath);
   let ownStat;
   return (candidate) => {
-    if (recordedTarget !== void 0 && import_node_path26.default.resolve(candidate) === recordedTarget) {
+    if (recordedTarget !== void 0 && import_node_path27.default.resolve(candidate) === recordedTarget) {
       return true;
     }
     ownStat ??= statOrUndefined(contentSourcePath);
@@ -6163,22 +6631,22 @@ function statOrUndefined(target) {
   }
 }
 function findPathShadow(params) {
-  const resolvedTargetDir = import_node_path26.default.resolve(params.targetDir);
+  const resolvedTargetDir = import_node_path27.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_path26.default.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
+    return import_node_path27.default.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
   }
-  return params.pathDirs.some((dir) => import_node_path26.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
+  return params.pathDirs.some((dir) => import_node_path27.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
 }
-var import_node_fs7, import_node_path26, import_zod19, ClaudeShimStateSchema, nodeLinkFs;
+var import_node_fs7, import_node_path27, import_zod19, ClaudeShimStateSchema, nodeLinkFs;
 var init_claudeShim = __esm({
   "src/claudeShim.ts"() {
     "use strict";
     import_node_fs7 = __toESM(require("node:fs"), 1);
-    import_node_path26 = __toESM(require("node:path"), 1);
+    import_node_path27 = __toESM(require("node:path"), 1);
     import_zod19 = require("zod");
     init_commandDeps();
     init_store();
@@ -6692,7 +7160,7 @@ function buildEnv(params) {
   const parentCustomHeaders = params.baseEnv.ANTHROPIC_CUSTOM_HEADERS;
   let providerCustomHeaders;
   if (!params.configDirEscapeHatch && params.resolvedIdentityName !== void 0) {
-    env.CLAUDE_CONFIG_DIR = import_node_path35.default.join(params.identitiesDir, params.resolvedIdentityName);
+    env.CLAUDE_CONFIG_DIR = import_node_path36.default.join(params.identitiesDir, params.resolvedIdentityName);
   }
   if (params.provider !== void 0) {
     const providerEnv = params.provider.definition.env ?? {};
@@ -6736,11 +7204,11 @@ function buildEnv(params) {
   }
   return env;
 }
-var import_node_path35, LOOPBACK_HOSTS;
+var import_node_path36, LOOPBACK_HOSTS;
 var init_flags = __esm({
   "src/launcher/flags.ts"() {
     "use strict";
-    import_node_path35 = __toESM(require("node:path"), 1);
+    import_node_path36 = __toESM(require("node:path"), 1);
     init_envBool();
     init_credential();
     init_headers();
@@ -7073,7 +7541,7 @@ function decideLaunch(params, readOnly) {
     identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
     globalDefaultConfigProfile: params.globalDefaultConfigProfile
   });
-  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path36.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path37.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
     log.error(
       `agent-shim: no configuration profile named "${configProfileDecision.name}" (selected via ${configProfileDecision.source}). Run \`agent-shim profile add ${configProfileDecision.name}\` first.`
     );
@@ -7185,7 +7653,7 @@ function decideLaunch(params, readOnly) {
     extraFlags: splitExtraFlags(env.CLAUDE_EXTRA_FLAGS),
     passthrough: parsedArgv.rest
   });
-  const configDir = configDirEscapeHatchApplies || identityDecision.name === void 0 ? env.CLAUDE_CONFIG_DIR : import_node_path36.default.join(paths.identitiesDir, identityDecision.name);
+  const configDir = configDirEscapeHatchApplies || identityDecision.name === void 0 ? env.CLAUDE_CONFIG_DIR : import_node_path37.default.join(paths.identitiesDir, identityDecision.name);
   const decision = {
     identitySource: identityDecision.source,
     configDirEscapeHatch: identityDecision.configDirEscapeHatch,
@@ -7226,7 +7694,7 @@ function prepareLaunch(params) {
   );
   const updateCheck = runLaunchUpdateCheck({
     mode: params.updateMode ?? "off",
-    checkPath: import_node_path36.default.join(paths.root, "update.check"),
+    checkPath: import_node_path37.default.join(paths.root, "update.check"),
     currentVersion: package_default.version,
     port: params.update
   });
@@ -7357,12 +7825,12 @@ function runLaunchPlan(plan, spawn3) {
 function runLauncher(params) {
   params.proc.exit(runLaunchPlan(prepareLaunch(params), params.spawn));
 }
-var import_node_crypto10, import_node_path36;
+var import_node_crypto10, import_node_path37;
 var init_launcher = __esm({
   "src/launcher.ts"() {
     "use strict";
     import_node_crypto10 = require("node:crypto");
-    import_node_path36 = __toESM(require("node:path"), 1);
+    import_node_path37 = __toESM(require("node:path"), 1);
     init_package();
     init_envBool();
     init_argv();
@@ -7393,13 +7861,13 @@ function agentShimCliPath(distDir = typeof __AGENT_SHIM_DIST_DIR__ === "string"
   if (distDir === void 0) {
     throw new OwnCliPathUnknownError();
   }
-  return import_node_path37.default.join(distDir, OWN_CLI_FILE_NAME);
+  return import_node_path38.default.join(distDir, OWN_CLI_FILE_NAME);
 }
-var import_node_path37, OWN_CLI_FILE_NAME, OwnCliPathUnknownError;
+var import_node_path38, OWN_CLI_FILE_NAME, OwnCliPathUnknownError;
 var init_ownCli = __esm({
   "src/ownCli.ts"() {
     "use strict";
-    import_node_path37 = __toESM(require("node:path"), 1);
+    import_node_path38 = __toESM(require("node:path"), 1);
     init_cliError();
     OWN_CLI_FILE_NAME = "cli.cjs";
     OwnCliPathUnknownError = class extends CliError {
@@ -7484,7 +7952,7 @@ request.on("error", (error) => finish(failed, (error.code ? error.code + ": " :
 // src/frontdoor/trust.ts
 function resolveTrustBundle(params) {
   const { caCertFile, bundlesDir, variable, inherited, fs: fs12 } = params;
-  if (inherited === void 0 || inherited === "" || import_node_path38.default.resolve(inherited) === import_node_path38.default.resolve(caCertFile)) {
+  if (inherited === void 0 || inherited === "" || import_node_path39.default.resolve(inherited) === import_node_path39.default.resolve(caCertFile)) {
     return { path: caCertFile };
   }
   const caPem = fs12.readFileUtf8(caCertFile);
@@ -7502,19 +7970,19 @@ function resolveTrustBundle(params) {
   }
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
-  const bundle = import_node_path38.default.join(bundlesDir, `${(0, import_node_crypto11.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  const bundle = import_node_path39.default.join(bundlesDir, `${(0, import_node_crypto11.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
   if (!fs12.exists(bundle)) {
     fs12.mkdirp(bundlesDir);
     fs12.writeFileAtomic(bundle, combined);
   }
   return { path: bundle };
 }
-var import_node_crypto11, import_node_path38, BUNDLE_NAME_HEX_DIGITS;
+var import_node_crypto11, import_node_path39, BUNDLE_NAME_HEX_DIGITS;
 var init_trust = __esm({
   "src/frontdoor/trust.ts"() {
     "use strict";
     import_node_crypto11 = require("node:crypto");
-    import_node_path38 = __toESM(require("node:path"), 1);
+    import_node_path39 = __toESM(require("node:path"), 1);
     BUNDLE_NAME_HEX_DIGITS = 16;
   }
 });
@@ -8308,6 +8776,7 @@ __export(index_exports, {
   isRcReadFileEncoding: () => isRcReadFileEncoding,
   lateRcEventDial: () => lateRcEventDial,
   lateRcStreamDial: () => lateRcStreamDial,
+  launchRequiredUpstreams: () => launchRequiredUpstreams,
   listDirectoryRules: () => listDirectoryRules,
   listIdentities: () => listIdentities,
   listProfiles: () => listProfiles,
@@ -8748,6 +9217,7 @@ function pumpTapSession(secure, openUpstream, tap, prefix = Buffer.alloc(0)) {
 // src/frontdoor/connect.ts
 init_capability();
 init_route();
+init_state();
 
 // src/frontdoor/supervisor.ts
 var import_node_path9 = __toESM(require("node:path"), 1);
@@ -8819,9 +9289,10 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     return fail(`could not start the direct listener: ${error instanceof Error ? error.message : String(error)}`);
   }
   if (previousStickyDirect !== void 0 && direct.port !== previousStickyDirect) {
-    ports.log(`agent-shim frontdoor supervisor: sticky direct port ${String(previousStickyDirect)} was occupied; moving to ${String(direct.port)} (headroom must be restarted to admit the new address)`);
+    ports.log(`agent-shim frontdoor supervisor: sticky direct port ${String(previousStickyDirect)} was occupied; moving to ${String(direct.port)} (headroom admits the new address once its supervisor rewrites the allowlist file)`);
   }
   lastDirectPort = direct.port;
+  writeFrontDoorDirectRecord(fs12, paths.frontdoorDirectRecordsDir, { pid: ports.ownPid, directPort: direct.port });
   writeFrontDoorState(fs12, paths.frontdoorStateFile, { protocol: FRONT_DOOR_PROTOCOL, supervisorPid: ports.ownPid, port: http3.port, connectPort: connect3.port, directPort: direct.port, ...sticky() });
   ports.doorHealth.generation({ providerPort: http3.port, connectPort: connect3.port, directPort: direct.port });
   fs12.removeRecursive(paths.frontdoorLockFile);
@@ -8843,6 +9314,7 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     await connect3.close();
     await http3.close();
     ports.closeRcStreamHub();
+    removeFrontDoorDirectRecord(fs12, paths.frontdoorDirectRecordsDir, ports.ownPid);
   };
   const shutdown = async () => {
     await closeServing();
@@ -8906,7 +9378,6 @@ var CONNECT_INTERCEPT_HOST = "api.anthropic.com";
 var CONNECT_INTERCEPT_HOSTS = [CONNECT_INTERCEPT_HOST, "platform.claude.com"];
 var ROUTED_PATH_PREFIX = "/v1/";
 var HTTPS_PORT = 443;
-var MAX_PORT = 65535;
 var HTTP_BAD_GATEWAY = 502;
 var CA_KEY_FILE_MODE = 384;
 var CONNECT_LINE_TOKENS = 3;
@@ -8938,7 +9409,7 @@ function parseConnectTarget(authority) {
   }
   const host = authority.slice(0, colon).trim().toLowerCase();
   const port = Number.parseInt(authority.slice(colon + 1), 10);
-  if (host === "" || !Number.isInteger(port) || port <= 0 || port > MAX_PORT) {
+  if (host === "" || !Number.isInteger(port) || port <= 0 || port > MAX_TCP_PORT) {
     return void 0;
   }
   return { host, port };
@@ -8946,8 +9417,8 @@ function parseConnectTarget(authority) {
 function isInterceptedHost(host, interceptHosts) {
   return interceptHosts.includes(host);
 }
-function servedByPipeline(path39) {
-  return path39?.startsWith(ROUTED_PATH_PREFIX) === true;
+function servedByPipeline(path40) {
+  return path40?.startsWith(ROUTED_PATH_PREFIX) === true;
 }
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
@@ -9741,11 +10212,11 @@ function createRcSessionTracker(deps) {
   };
   const observeExchange = (request4) => {
     const method = (request4.method ?? "").toUpperCase();
-    const path39 = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
-    if (!path39.startsWith(RC_SESSIONS_PATH_PREFIX)) {
+    const path40 = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
+    if (!path40.startsWith(RC_SESSIONS_PATH_PREFIX)) {
       return void 0;
     }
-    const tail = path39.slice(RC_SESSIONS_PATH_PREFIX.length);
+    const tail = path40.slice(RC_SESSIONS_PATH_PREFIX.length);
     const facts = {
       oauthAuthorization: oauthAuthorizationOf(request4.headers),
       anthropicVersion: singleHeader(request4.headers, "anthropic-version"),
@@ -10135,8 +10606,8 @@ var RC_READ_FILE_ENCODINGS = ["utf-8", "base64"];
 function isRcReadFileEncoding(value) {
   return RC_READ_FILE_ENCODINGS.some((encoding) => encoding === value);
 }
-function buildRcReadFilePayload(requestId, path39, options) {
-  return buildRcControlRequestPayload(requestId, { subtype: "read_file", path: path39, ...options?.maxBytes === void 0 ? {} : { max_bytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } });
+function buildRcReadFilePayload(requestId, path40, options) {
+  return buildRcControlRequestPayload(requestId, { subtype: "read_file", path: path40, ...options?.maxBytes === void 0 ? {} : { max_bytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } });
 }
 function buildRcFileSuggestionsPayload(requestId, query) {
   return buildRcControlRequestPayload(requestId, { subtype: "file_suggestions", query });
@@ -10238,15 +10709,15 @@ async function getRcSessionContextUsage(deps, sessionId, detail) {
   const result = await deliverRcClientPayload(deps, sessionId, buildRcGetContextUsagePayload(requestId, detail), `request the context usage of session ${sessionId}`);
   return result.ok ? { ...result, requestId } : result;
 }
-async function readRcSessionFile(deps, sessionId, path39, options) {
-  if (path39 === "") {
+async function readRcSessionFile(deps, sessionId, path40, options) {
+  if (path40 === "") {
     return { ok: false, message: "a read-file write needs a non-empty path: the SDK's own field names the file the worker resolves against the session's cwd, and an empty string names none" };
   }
   if (options?.maxBytes !== void 0 && (!Number.isInteger(options.maxBytes) || options.maxBytes <= 0)) {
     return { ok: false, message: "a read-file write's max-bytes is a positive whole number of bytes: the SDK's own field caps the read, and a zero or negative cap reads nothing" };
   }
   const requestId = deps.newUuid();
-  const result = await deliverRcClientPayload(deps, sessionId, buildRcReadFilePayload(requestId, path39, options), `read ${path39} from session ${sessionId}`);
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcReadFilePayload(requestId, path40, options), `read ${path40} from session ${sessionId}`);
   return result.ok ? { ...result, requestId } : result;
 }
 async function suggestRcSessionFiles(deps, sessionId, query) {
@@ -10415,11 +10886,11 @@ function createRcControlHandler(deps) {
       path: "read-file",
       read: (body) => {
         const session = bodyString(body, "session");
-        const path39 = bodyString(body, "path");
+        const path40 = bodyString(body, "path");
         const maxBytes = "maxBytes" in body ? bodyPositiveInteger(body, "maxBytes") : void 0;
         const encoding = "encoding" in body && isRcReadFileEncoding(body.encoding) ? body.encoding : void 0;
-        const refused2 = session === void 0 || path39 === void 0 || "maxBytes" in body && maxBytes === void 0 || "encoding" in body && encoding === void 0;
-        return refused2 ? { error: `the read-file body must be JSON naming a non-empty session id and path, maxBytes only as a positive whole number or absent, and an encoding the SDK's own type permits (${RC_READ_FILE_ENCODINGS.join(", ")}) or none` } : { session, run: async () => await deps.readFile(session, path39, { ...maxBytes === void 0 ? {} : { maxBytes }, ...encoding === void 0 ? {} : { encoding } }) };
+        const refused2 = session === void 0 || path40 === void 0 || "maxBytes" in body && maxBytes === void 0 || "encoding" in body && encoding === void 0;
+        return refused2 ? { error: `the read-file body must be JSON naming a non-empty session id and path, maxBytes only as a positive whole number or absent, and an encoding the SDK's own type permits (${RC_READ_FILE_ENCODINGS.join(", ")}) or none` } : { session, run: async () => await deps.readFile(session, path40, { ...maxBytes === void 0 ? {} : { maxBytes }, ...encoding === void 0 ? {} : { encoding } }) };
       }
     },
     {
@@ -10729,9 +11200,9 @@ function requestIdOfBody(body) {
 }
 function frontDoorRcControl(transport, token) {
   const headers = { authorization: `Bearer ${token}` };
-  const listAnswerOf = async (path39, what) => {
+  const listAnswerOf = async (path40, what) => {
     try {
-      return await transport.request({ method: "GET", path: path39, headers });
+      return await transport.request({ method: "GET", path: path40, headers });
     } catch (error) {
       throw new Error(`${what}: could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
@@ -10803,10 +11274,10 @@ function frontDoorRcControl(transport, token) {
     }
     return pending;
   };
-  const writeOf = async (path39, body, describeFailure2) => {
+  const writeOf = async (path40, body, describeFailure2) => {
     let answer;
     try {
-      answer = await transport.request({ method: "POST", path: path39, headers: { ...headers, "content-type": "application/json" }, body });
+      answer = await transport.request({ method: "POST", path: path40, headers: { ...headers, "content-type": "application/json" }, body });
     } catch (error) {
       return { ok: false, message: `could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}` };
     }
@@ -10837,10 +11308,10 @@ function frontDoorRcControl(transport, token) {
     endSession: async (sessionId, reason) => await writeOf(`${CONTROL_PATH_PREFIX}/end-session`, JSON.stringify({ session: sessionId, ...reason === void 0 ? {} : { reason } }), (status, message) => `ending ${sessionId} failed (HTTP ${String(status)}): ${message}`),
     getUsage: async (sessionId, skipBehaviors) => await writeOf(`${CONTROL_PATH_PREFIX}/get-usage`, JSON.stringify({ session: sessionId, ...skipBehaviors === void 0 ? {} : { skipBehaviors } }), (status, message) => `requesting the usage of ${sessionId} failed (HTTP ${String(status)}): ${message}`),
     getContextUsage: async (sessionId, detail) => await writeOf(`${CONTROL_PATH_PREFIX}/get-context-usage`, JSON.stringify({ session: sessionId, ...detail === void 0 ? {} : { detail } }), (status, message) => `requesting the context usage of ${sessionId} failed (HTTP ${String(status)}): ${message}`),
-    readFile: async (sessionId, path39, options) => await writeOf(
+    readFile: async (sessionId, path40, options) => await writeOf(
       `${CONTROL_PATH_PREFIX}/read-file`,
-      JSON.stringify({ session: sessionId, path: path39, ...options?.maxBytes === void 0 ? {} : { maxBytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } }),
-      (status, message) => `reading ${path39} from ${sessionId} failed (HTTP ${String(status)}): ${message}`
+      JSON.stringify({ session: sessionId, path: path40, ...options?.maxBytes === void 0 ? {} : { maxBytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } }),
+      (status, message) => `reading ${path40} from ${sessionId} failed (HTTP ${String(status)}): ${message}`
     ),
     fileSuggestions: async (sessionId, query) => await writeOf(`${CONTROL_PATH_PREFIX}/file-suggestions`, JSON.stringify({ session: sessionId, query }), (status, message) => `requesting file suggestions from ${sessionId} failed (HTTP ${String(status)}): ${message}`),
     keepAlive: async (sessionId) => await writeOf(`${CONTROL_PATH_PREFIX}/keep-alive`, JSON.stringify({ session: sessionId }), (status, message) => `keeping ${sessionId} alive failed (HTTP ${String(status)}): ${message}`),
@@ -10999,12 +11470,12 @@ function tlsFacts(options) {
 }
 function realRcEventDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
   const agent = new ExemptTlsAgent();
-  const post = async (path39, headers, body) => await new Promise((resolve, reject) => {
+  const post = async (path40, headers, body) => await new Promise((resolve, reject) => {
     const options = {
       host: target.host,
       port: target.port,
       method: "POST",
-      path: path39,
+      path: path40,
       // The Host header names the host whose API this is, not the address dialled: a redirected test dials a loopback stand-in while still speaking to the API host by name, exactly as the forwarded paths present their SNI.
       headers: { ...headers, host: target.servername ?? target.host, "content-length": String(Buffer.byteLength(body, "utf8")) },
       agent
@@ -11069,12 +11540,12 @@ function lateRcStreamDial(resolve) {
 }
 function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
   const agent = new ExemptTlsAgent();
-  const request4 = async (method, path39, headers, body, signal) => await new Promise((resolve, reject) => {
+  const request4 = async (method, path40, headers, body, signal) => await new Promise((resolve, reject) => {
     const options = {
       host: target.host,
       port: target.port,
       method,
-      path: path39,
+      path: path40,
       // The Host header names the host whose API this is, not the address dialled: a redirected test dials a loopback stand-in while still speaking to the API host by name, exactly as the forwarded paths present their SNI.
       headers: { ...headers, host: target.servername ?? target.host, ...body === void 0 ? {} : { "content-length": String(Buffer.byteLength(body, "utf8")) } },
       agent,
@@ -11116,9 +11587,9 @@ function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_P
       return { status, body: await readAll(response) };
     },
     openStream: async (sessionId, headers, resume, signal) => {
-      const path39 = resume === void 0 ? `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream` : `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream?from_sequence_num=${String(resume.fromSequenceNum)}`;
+      const path40 = resume === void 0 ? `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream` : `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream?from_sequence_num=${String(resume.fromSequenceNum)}`;
       const streamHeaders = resume === void 0 ? headers : { ...headers, "last-event-id": String(resume.fromSequenceNum) };
-      const { status, response } = await request4("GET", path39, streamHeaders, void 0, signal);
+      const { status, response } = await request4("GET", path40, streamHeaders, void 0, signal);
       if (!isSuccessful2(status)) {
         await readAll(response);
         return { status, chunks: NO_CHUNKS };
@@ -12058,7 +12529,7 @@ init_cliError();
 
 // src/configProfilesStore.ts
 var import_node_fs3 = __toESM(require("node:fs"), 1);
-var import_node_path21 = __toESM(require("node:path"), 1);
+var import_node_path22 = __toESM(require("node:path"), 1);
 init_store();
 init_schema();
 init_cliError();
@@ -12088,7 +12559,7 @@ var InvalidCategoryNameError = class extends CliError {
   categoryName;
 };
 function profileJsonPath(paths, name) {
-  return import_node_path21.default.join(paths.configProfilesDir, `${name}.json`);
+  return import_node_path22.default.join(paths.configProfilesDir, `${name}.json`);
 }
 function profileExists(paths, name) {
   return import_node_fs3.default.existsSync(profileJsonPath(paths, name));
@@ -12270,19 +12741,19 @@ function writePools(paths, pools) {
   applyPatch(paths.globalConfigFile, GlobalConfigSchema, { pools }, { defaults: {} });
 }
 function poolCycleOf(pools, name) {
-  const walk = (current, path39) => {
+  const walk = (current, path40) => {
     for (const entry of pools[current]?.identities ?? []) {
       const nested = poolNameOf(poolMemberIdentity(entry));
       if (nested === void 0) {
         continue;
       }
       if (nested === name) {
-        return [...path39, nested];
+        return [...path40, nested];
       }
-      if (path39.includes(nested)) {
+      if (path40.includes(nested)) {
         continue;
       }
-      const found = walk(nested, [...path39, nested]);
+      const found = walk(nested, [...path40, nested]);
       if (found !== void 0) {
         return found;
       }
@@ -12381,7 +12852,7 @@ init_paths();
 init_realCredentialCache();
 init_providersStore();
 init_realPorts();
-var import_node_path25 = __toESM(require("node:path"), 1);
+var import_node_path26 = __toESM(require("node:path"), 1);
 var import_zod15 = require("zod");
 init_envBool();
 init_load();
@@ -12730,10 +13201,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_path25.default.join(paths.identitiesDir, identityDecision.name);
+  const farmRoot = identityDecision.name === void 0 ? void 0 : import_node_path26.default.join(paths.identitiesDir, identityDecision.name);
   const settingsFiles = {
-    "settings.json": realFsPort.readFileUtf8(import_node_path25.default.join(claudeHome, "settings.json")),
-    "settings.local.json": realFsPort.readFileUtf8(import_node_path25.default.join(claudeHome, "settings.local.json"))
+    "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"))
   };
   const report = runCheck({
     cwd,
@@ -13025,7 +13496,7 @@ var ResetRowSchema = import_zod18.z.strictObject({
 var ResetScheduleSchema = import_zod18.z.strictObject({ resets: import_zod18.z.readonly(import_zod18.z.array(ResetRowSchema)) });
 
 // src/frontdoor/controlSchemas.ts
-var import_node_path30 = __toESM(require("node:path"), 1);
+var import_node_path31 = __toESM(require("node:path"), 1);
 var import_zod23 = require("zod");
 
 // src/doctorReport.ts
@@ -13034,7 +13505,7 @@ init_store();
 
 // src/identityStore.ts
 var import_node_fs8 = __toESM(require("node:fs"), 1);
-var import_node_path27 = __toESM(require("node:path"), 1);
+var import_node_path28 = __toESM(require("node:path"), 1);
 init_load();
 init_store();
 init_schema();
@@ -13068,7 +13539,7 @@ var InvalidIdentityNameError = class extends CliError {
   attemptedName;
 };
 function identityJsonPath(paths, name) {
-  return import_node_path27.default.join(paths.identitiesDir, name, "identity.json");
+  return import_node_path28.default.join(paths.identitiesDir, name, "identity.json");
 }
 function requireIdentityNames(paths, names) {
   const existing = new Set(listIdentities(paths).map((entry) => entry.name));
@@ -13183,7 +13654,7 @@ function setIdentityCredential(paths, identityName, change) {
   });
 }
 function belongsToIdentity(entry, name) {
-  return entry === name || entry === import_node_path27.default.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
+  return entry === name || entry === import_node_path28.default.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
 }
 function removeIdentity(paths, name) {
   if (!identityExists(paths, name)) {
@@ -13191,7 +13662,7 @@ function removeIdentity(paths, name) {
   }
   for (const entry of import_node_fs8.default.readdirSync(paths.identitiesDir)) {
     if (belongsToIdentity(entry, name)) {
-      import_node_fs8.default.rmSync(import_node_path27.default.join(paths.identitiesDir, entry), { recursive: true, force: true });
+      import_node_fs8.default.rmSync(import_node_path28.default.join(paths.identitiesDir, entry), { recursive: true, force: true });
     }
   }
   if (readActiveIdentity2(paths) === name) {
@@ -13202,10 +13673,10 @@ function removeIdentity(paths, name) {
 // src/doctorReport.ts
 init_realPorts();
 var import_node_fs9 = __toESM(require("node:fs"), 1);
-var import_node_path29 = __toESM(require("node:path"), 1);
+var import_node_path30 = __toESM(require("node:path"), 1);
 
 // src/usage/signIn.ts
-var import_node_path28 = __toESM(require("node:path"), 1);
+var import_node_path29 = __toESM(require("node:path"), 1);
 var CREDENTIALS_FILE = ".credentials.json";
 function keychainHasItem(run, account) {
   return run.run("security", ["find-generic-password", "-a", account]).status === 0;
@@ -13223,7 +13694,7 @@ function decideSignIn(facts) {
   return { state: "signed-out", detail: facts.platform === "darwin" ? `no Keychain item and no ${CREDENTIALS_FILE}` : `no ${CREDENTIALS_FILE}` };
 }
 function credentialsFilePath(farmRoot) {
-  return import_node_path28.default.join(farmRoot, CREDENTIALS_FILE);
+  return import_node_path29.default.join(farmRoot, CREDENTIALS_FILE);
 }
 
 // src/codex/siwcStore.ts
@@ -13312,17 +13783,75 @@ init_realCredentialCache();
 init_source();
 
 // src/headroom/allowlistDrift.ts
+init_earlierRelease();
 init_state2();
 function diagnoseAllowlistDrift(params) {
-  const { recordedHash, providers, frontDoorOrigin: frontDoorOrigin2 } = params;
-  if (recordedHash === void 0 || recordedHash === hashAllowlist(headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin2)))) {
+  const { allowlist, fileContent, recordedHash, earlierRelease } = params;
+  if (recordedHash === void 0) {
+    return void 0;
+  }
+  if (earlierRelease !== void 0) {
+    return earlierRelease.admitsServingDoor ? void 0 : { startedByEarlierRelease: true };
+  }
+  const served = fileContent === void 0 ? [] : parseAllowlistFile(fileContent);
+  const listed = new Set(served);
+  const computed = new Set(allowlist);
+  const missingFromFile = allowlist.filter((entry) => !listed.has(entry));
+  const staleInFile = served.filter((entry) => !computed.has(entry)).sort();
+  const hashLags = recordedHash !== (fileContent === void 0 ? void 0 : hashAllowlistFile(fileContent));
+  if (missingFromFile.length === 0 && staleInFile.length === 0 && !hashLags) {
     return void 0;
   }
-  const originIsInput = providers.length > 0 && frontDoorOrigin2 !== void 0;
-  if (!originIsInput) {
-    return ["provider-files"];
+  return { missingFromFile, staleInFile, hashLags };
+}
+function describeAllowlistDrift(params) {
+  const { drift, allowlistFile, liveSupervisorPid } = params;
+  if (drift.startedByEarlierRelease === true) {
+    return `the daemon was ${EARLIER_RELEASE_ALLOWLIST}, its allowlist cannot be shown to admit the serving front door (the door moved, or a provider changed, since it started), and until then provider launches are refused`;
+  }
+  const parts = [];
+  if (drift.missingFromFile.length > 0) {
+    parts.push(`${allowlistFile} lacks ${drift.missingFromFile.join(", ")} (live front doors' direct origins, so the daemon refuses every request a provider launch sends back through those doors)`);
+  }
+  if (drift.staleInFile.length > 0) {
+    parts.push(`${allowlistFile} still lists ${drift.staleInFile.join(", ")}`);
+  }
+  if (drift.hashLags) {
+    parts.push("the supervisor has not yet recorded the file's allowlist as served, and provider launches through headroom wait until it does");
+  }
+  const healing = liveSupervisorPid === void 0 ? "the supervisor is not running, so nothing rewrites the file until the next launch through headroom starts one" : `supervisor ${String(liveSupervisorPid)} rewrites the file on its next tick, so drift that persists means it cannot write it (see ${params.logPath})`;
+  return `${parts.join("; ")}; ${healing}`;
+}
+
+// src/doctorReport.ts
+init_earlierRelease();
+init_socket();
+
+// src/doctorHeadroomAllowlist.ts
+function pushRefusedAllowlistFile(push, allowlist) {
+  const problem = allowlist.fileProblem;
+  if (problem?.repairable === false) {
+    push("headroom", "fail", `Headroom refuses its allowlist file, so it admits nothing and every provider request through headroom fails: ${problem.message}.`, allowlist.file);
+  }
+}
+function pushHeadroomAllowlist(push, allowlist, daemon) {
+  const { drift } = allowlist;
+  const problem = allowlist.fileProblem;
+  if (problem?.repairable === true) {
+    push("headroom", "warn", `Headroom's allowlist file breaks agent-shim's owner-only rule for it: ${problem.message}. Its supervisor repairs this on its next tick, and stops the daemon if it cannot.`, allowlist.file);
+  }
+  if (drift !== void 0) {
+    const blocking = drift.startedByEarlierRelease === true || drift.missingFromFile.length > 0 || drift.hashLags;
+    push(
+      "headroom",
+      blocking ? "fail" : "warn",
+      `Headroom daemon ${String(daemon.headroomPid)}'s allowlist lags the current one: ` + describeAllowlistDrift({ drift, allowlistFile: allowlist.file, liveSupervisorPid: daemon.liveSupervisorPid, logPath: allowlist.logPath }) + ". `--no-headroom` launches are unaffected.",
+      String(daemon.headroomPid)
+    );
+  }
+  for (const door of allowlist.undeterminedFrontDoors) {
+    push("headroom", "warn", `Could not tell whether front door ${String(door.pid)} is still running (${door.reason}), so headroom keeps admitting its direct origin ${door.origin} until a later read can.`, String(door.pid));
   }
-  return recordedHash === hashAllowlist(headroomAllowlist(headroomUpstreams(providers, void 0))) ? ["front-door-origin"] : ["provider-files", "front-door-origin"];
 }
 
 // src/doctorReport.ts
@@ -13331,7 +13860,7 @@ init_supervisor();
 init_state();
 
 // src/doctorFrontDoor.ts
-function pushFrontDoor(push, supervisors, registeredPid) {
+function pushFrontDoor(push, supervisors, registeredPid, liveSessions) {
   if (!supervisors.ok) {
     push("frontdoor", "warn", `Could not list processes to look for duplicate front door supervisors: ${supervisors.message}.`);
     return;
@@ -13348,6 +13877,16 @@ function pushFrontDoor(push, supervisors, registeredPid) {
   }
   const serving = registeredPid !== void 0 && pids.includes(registeredPid) ? `The front door state file names pid ${String(registeredPid)} as the serving supervisor.` : "The front door state file names no running supervisor.";
   for (const pid of pids.filter((candidate) => candidate !== registeredPid)) {
+    const served = liveSessions.filter((session) => session.supervisorPid === pid).length;
+    if (registeredPid !== void 0 && pids.includes(registeredPid) && served > 0) {
+      push(
+        "frontdoor",
+        "warn",
+        `Front door supervisor pid ${String(pid)} has been superseded by pid ${String(registeredPid)} and still serves ${String(served)} launch${served === 1 ? "" : "es"} registered against it; it exits once they end.`,
+        String(pid)
+      );
+      continue;
+    }
     push(
       "frontdoor",
       "fail",
@@ -13417,7 +13956,7 @@ function tcpPortEraRecord(raw) {
   return (has("port") || has("lastPort")) && !has("socketPath");
 }
 function pushPathResolution(push, resolution) {
-  const ownDir = import_node_path29.default.dirname(resolution.ownExecutablePath);
+  const ownDir = import_node_path30.default.dirname(resolution.ownExecutablePath);
   switch (resolution.agentShim.status) {
     case "ok":
       push("path-resolution", "pass", `\`agent-shim\` on PATH resolves to this running executable, ${resolution.ownExecutablePath}.`, "agent-shim");
@@ -13516,14 +14055,14 @@ function pushProvider(push, entry, cacheEnv, signIn) {
 }
 function pushLegacyName(push, params) {
   const legacyVariables = Object.keys(params.env).filter((name) => name.startsWith(LEGACY_ENV_PREFIX) && params.env[name] !== void 0).sort();
-  if (legacyVariables.length === 0 && import_node_path29.default.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
+  if (legacyVariables.length === 0 && import_node_path30.default.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
     push("legacy-name", "pass", "Nothing here still uses the former `claude-use` name.");
     return;
   }
   for (const name of legacyVariables) {
     push("legacy-name", "warn", `${name} is the former name of ${name.replace(LEGACY_ENV_PREFIX, ENV_PREFIX)}. Rename it; the old name still works but is only a fallback.`, name);
   }
-  if (import_node_path29.default.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
+  if (import_node_path30.default.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
     push(
       "legacy-name",
       "warn",
@@ -13779,15 +14318,11 @@ function runDoctor(params) {
         );
       }
       const allowlist = params.headroom.allowlist;
-      if (supervisorAlive && headroomAlive && state.socketPath !== void 0 && allowlist?.driftInputs?.includes("front-door-origin") === true) {
-        const origin = allowlist.frontDoorOrigin ?? "";
-        const certainty = allowlist.driftInputs.includes("provider-files") ? "may exclude" : "excludes";
-        push(
-          "headroom",
-          "fail",
-          `Headroom daemon ${String(state.headroomPid)} was started with an allowlist that ${certainty} the serving front door's direct origin ${origin}, so it refuses every request a provider launch sends back through the door. Its supervisor restarts it once no launch is registered against it; \`agent-shim headroom status\` lists the registered launches, and \`--no-headroom\` launches are unaffected.`,
-          String(state.headroomPid)
-        );
+      if (allowlist !== void 0) {
+        pushRefusedAllowlistFile(push, allowlist);
+      }
+      if (allowlist !== void 0 && headroomAlive && state.headroomPid !== void 0) {
+        pushHeadroomAllowlist(push, allowlist, { headroomPid: state.headroomPid, liveSupervisorPid: supervisorAlive ? state.supervisorPid : void 0 });
       }
       if (state.lastError !== void 0 && supervisorAlive) {
         push("headroom", "warn", `Headroom recorded a previous error: ${state.lastError}`);
@@ -13803,7 +14338,7 @@ function runDoctor(params) {
   }
   if (params.frontDoor !== void 0) {
     const validated3 = params.frontDoor.state.raw === void 0 ? void 0 : validateJson(FrontDoorStateSchema, params.frontDoor.state);
-    pushFrontDoor(push, params.frontDoor.supervisors, validated3?.ok === true ? validated3.data.supervisorPid : void 0);
+    pushFrontDoor(push, params.frontDoor.supervisors, validated3?.ok === true ? validated3.data.supervisorPid : void 0, params.frontDoor.liveSessions);
   }
   if (params.activeIdentity.raw === void 0) {
     push("active-identity", "pass", "No active identity set.");
@@ -13896,18 +14431,18 @@ function collectDoctorReport(params) {
   const { paths } = params;
   const identityNames = import_node_fs9.default.existsSync(paths.identitiesDir) ? import_node_fs9.default.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isIdentityDirectoryName(entry.name)).map((entry) => entry.name).sort() : [];
   const identities = identityNames.map((name) => {
-    const farmRoot = import_node_path29.default.join(paths.identitiesDir, name);
-    const identityPath = import_node_path29.default.join(farmRoot, "identity.json");
+    const farmRoot = import_node_path30.default.join(paths.identitiesDir, name);
+    const identityPath = import_node_path30.default.join(farmRoot, "identity.json");
     return { name, path: identityPath, raw: realFsPort.readFileUtf8(identityPath), farmRoot, credentialsFilePresent: import_node_fs9.default.existsSync(credentialsFilePath(farmRoot)) };
   });
   const profileNames = import_node_fs9.default.existsSync(paths.configProfilesDir) ? import_node_fs9.default.readdirSync(paths.configProfilesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
   const configProfiles = profileNames.map((name) => {
-    const profilePath = import_node_path29.default.join(paths.configProfilesDir, `${name}.json`);
+    const profilePath = import_node_path30.default.join(paths.configProfilesDir, `${name}.json`);
     return { name, path: profilePath, raw: realFsPort.readFileUtf8(profilePath) };
   });
   const providerNames = import_node_fs9.default.existsSync(paths.providersDir) ? import_node_fs9.default.readdirSync(paths.providersDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
   const providers = providerNames.map((name) => {
-    const providerPath = import_node_path29.default.join(paths.providersDir, `${name}.json`);
+    const providerPath = import_node_path30.default.join(paths.providersDir, `${name}.json`);
     return { name, path: providerPath, raw: realFsPort.readFileUtf8(providerPath) };
   });
   const ownExecutablePath = realOwnExecutablePath();
@@ -13919,20 +14454,24 @@ function collectDoctorReport(params) {
     binaryDiscovery = { ok: false, message: error instanceof Error ? error.message : String(error) };
   }
   const shimState = readJson(paths.claudeShimFile, ClaudeShimStateSchema);
-  const pathDirs = (params.env.PATH ?? "").split(import_node_path29.default.delimiter).filter((dir) => dir !== "");
+  const pathDirs = (params.env.PATH ?? "").split(import_node_path30.default.delimiter).filter((dir) => dir !== "");
   const claudeShimShadow = shimState === void 0 ? void 0 : refinePathShadow(
     findPathShadow({
       pathDirs,
-      targetDir: import_node_path29.default.dirname(shimState.targetPath),
-      targetFilename: import_node_path29.default.basename(shimState.targetPath),
+      targetDir: import_node_path30.default.dirname(shimState.targetPath),
+      targetFilename: import_node_path30.default.basename(shimState.targetPath),
       findExecutableInDir
     }),
     shimState.targetPath,
     realpathOrSelf
   );
   const uid = process.getuid?.();
-  const allowlistInputs = currentHeadroomAllowlistInputs(realFarmFs, paths);
+  const allowlistContent = realFarmFs.readFileUtf8(paths.headroomAllowlistFile);
+  const allowlistInputs = currentHeadroomAllowlistInputs(realFarmFs, paths, realFrontDoorLiveness);
   const servingHeadroom = resolveServingHeadroomState(realFarmFs, { stateFile: paths.headroomStateFile, legacyStateFile: paths.headroomLegacyStateFile }, realIsProcessRunning);
+  const servingState = servingHeadroom?.state;
+  const servingDaemon = servingState?.headroomPid !== void 0 && servingState.socketPath !== void 0 && realIsProcessRunning(servingState.headroomPid) ? { pid: servingState.headroomPid, socketPath: servingState.socketPath } : void 0;
+  const servingEarlierRelease = servingDaemon === void 0 ? void 0 : earlierReleaseDaemon(realFarmFs, paths, { commandLine: realProcessCommandLine(servingDaemon.pid), socketPath: servingDaemon.socketPath, recordedHash: servingState?.allowlistHash });
   const report = runDoctor({
     env: params.env,
     credentialCache: realCredentialCacheEnv(paths),
@@ -13953,7 +14492,7 @@ function collectDoctorReport(params) {
       agentShim: refinePathShadow(
         findPathShadow({
           pathDirs,
-          targetDir: import_node_path29.default.dirname(ownExecutablePath),
+          targetDir: import_node_path30.default.dirname(ownExecutablePath),
           targetFilename: commandFilename(ownExecutablePath, "agent-shim"),
           findExecutableInDir
         }),
@@ -13973,11 +14512,20 @@ function collectDoctorReport(params) {
       })(),
       isRunning: realIsProcessRunning,
       allowlist: {
-        driftInputs: diagnoseAllowlistDrift({ recordedHash: servingHeadroom?.state.allowlistHash, ...allowlistInputs }),
-        frontDoorOrigin: allowlistInputs.frontDoorOrigin
+        drift: diagnoseAllowlistDrift({
+          allowlist: allowlistInputs.frontDoorOrigins,
+          fileContent: allowlistContent,
+          recordedHash: servingHeadroom?.state.allowlistHash,
+          earlierRelease: servingEarlierRelease
+        }),
+        file: paths.headroomAllowlistFile,
+        undeterminedFrontDoors: undeterminedFrontDoors(allowlistInputs),
+        // An earlier release's daemon reads no allowlist file, so there is nothing to check while one serves.
+        fileProblem: servingEarlierRelease === void 0 ? reportableAllowlistFileProblem(paths.headroomAllowlistFile, realHeadroomSocketTrust, servingHeadroom?.state.allowlistHash !== void 0) : void 0,
+        logPath: paths.headroomLogPath
       }
     },
-    ...uid === void 0 ? {} : { frontDoor: { state: { path: paths.frontdoorStateFile, raw: realFsPort.readFileUtf8(paths.frontdoorStateFile) }, supervisors: listFrontDoorSupervisors(realRunPort, uid) } }
+    ...uid === void 0 ? {} : { frontDoor: { state: { path: paths.frontdoorStateFile, raw: realFsPort.readFileUtf8(paths.frontdoorStateFile) }, supervisors: listFrontDoorSupervisors(realRunPort, uid), liveSessions: listFrontDoorSessions(realFarmFs, paths.frontdoorSessionsDir).filter((session) => realIsProcessRunning(session.pid)) } }
   });
   return report;
 }
@@ -14032,11 +14580,11 @@ var FrontDoorSessionsOutputSchema = import_zod23.z.strictObject({ sessions: impo
 var CheckRunInputSchema = import_zod23.z.strictObject({
   path: import_zod23.z.string().min(1),
   identity: import_zod23.z.string().min(1).optional()
-}).refine((input) => import_node_path30.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+}).refine((input) => import_node_path31.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
 var PoolPickInputSchema = import_zod23.z.strictObject({
   pool: import_zod23.z.string().min(1),
   path: import_zod23.z.string().min(1)
-}).refine((input) => import_node_path30.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+}).refine((input) => import_node_path31.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
 var DoctorFindingSchema = import_zod23.z.strictObject({
   section: import_zod23.z.enum(DOCTOR_SECTIONS),
   subject: import_zod23.z.string().optional(),
@@ -14416,7 +14964,7 @@ function profileValue(name, paths) {
 function createConfigApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   const { paths } = deps;
-  const route = (path39, summary) => authed.meta((0, import_openapi3.openapi)({ method: "POST", path: path39, summary, tags: [CONFIG_API_TAG] }));
+  const route = (path40, summary) => authed.meta((0, import_openapi3.openapi)({ method: "POST", path: path40, summary, tags: [CONFIG_API_TAG] }));
   return {
     config: {
       identity: {
@@ -14780,7 +15328,7 @@ var import_openapi6 = require("@orpc/openapi");
 init_cliError();
 
 // src/frontdoor/launchSchemas.ts
-var import_node_path31 = __toESM(require("node:path"), 1);
+var import_node_path32 = __toESM(require("node:path"), 1);
 var import_zod26 = require("zod");
 init_claudeVersion();
 init_identity();
@@ -14790,7 +15338,7 @@ var LaunchResolveInputSchema = import_zod26.z.strictObject({
   argv: import_zod26.z.readonly(import_zod26.z.array(import_zod26.z.string())).optional(),
   /** The launch's inherited environment. Absent means an empty one: the door's own environment is never a substitute for the caller's, so a caller that wants `AGENT_SHIM_*` switches or a `CLAUDE_CONFIG_DIR` considered names them here. Values are read, never reported. */
   env: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.string()).optional()
-}).refine((input) => import_node_path31.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+}).refine((input) => import_node_path32.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
 var LaunchPoolDecisionSchema = import_zod26.z.strictObject({
   name: import_zod26.z.string(),
   reasons: import_zod26.z.readonly(import_zod26.z.array(import_zod26.z.string())),
@@ -16957,7 +17505,7 @@ data: ${JSON.stringify(envelope)}
 }
 
 // src/frontdoor/rcSelfHostMint.ts
-var import_node_path32 = __toESM(require("node:path"), 1);
+var import_node_path33 = __toESM(require("node:path"), 1);
 init_account();
 var CREDENTIALS_FILE2 = ".credentials.json";
 var CLAUDE_JSON2 = ".claude.json";
@@ -16982,7 +17530,7 @@ function readJsonObject(fs12, file) {
   return isRecord12(parsed) ? parsed : void 0;
 }
 function readRcSelfHostRecord(fs12, frontdoorDir) {
-  const parsed = readJsonObject(fs12, import_node_path32.default.join(frontdoorDir, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE));
+  const parsed = readJsonObject(fs12, import_node_path33.default.join(frontdoorDir, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE));
   if (parsed === void 0) {
     return void 0;
   }
@@ -16996,11 +17544,11 @@ function mintRcSelfHostCredential(deps) {
   if (!isIdentityName(deps.identity)) {
     throw new Error(`"${deps.identity}" is not a valid identity name.`);
   }
-  const identityDir = import_node_path32.default.join(deps.identitiesDir, deps.identity);
-  const credentialsFile = import_node_path32.default.join(identityDir, CREDENTIALS_FILE2);
-  const claudeJsonFile = import_node_path32.default.join(identityDir, CLAUDE_JSON2);
-  const recordDir = import_node_path32.default.join(deps.frontdoorDir, RC_SELF_HOST_RECORD_DIR);
-  const recordFile = import_node_path32.default.join(recordDir, RC_SELF_HOST_RECORD_FILE);
+  const identityDir = import_node_path33.default.join(deps.identitiesDir, deps.identity);
+  const credentialsFile = import_node_path33.default.join(identityDir, CREDENTIALS_FILE2);
+  const claudeJsonFile = import_node_path33.default.join(identityDir, CLAUDE_JSON2);
+  const recordDir = import_node_path33.default.join(deps.frontdoorDir, RC_SELF_HOST_RECORD_DIR);
+  const recordFile = import_node_path33.default.join(recordDir, RC_SELF_HOST_RECORD_FILE);
   const previousRecord = readRcSelfHostRecord(deps.fs, deps.frontdoorDir);
   const existingCredentials = readJsonObject(deps.fs, credentialsFile);
   const existingOauth = isRecord12(existingCredentials?.claudeAiOauth) ? existingCredentials.claudeAiOauth : void 0;
@@ -17016,7 +17564,7 @@ function mintRcSelfHostCredential(deps) {
   const organizationUuid = deps.newUuid();
   const accountUuid = deps.newUuid();
   const mintedAt = new Date(deps.now()).toISOString();
-  deps.fs.mkdirPrivate(import_node_path32.default.dirname(credentialsFile));
+  deps.fs.mkdirPrivate(import_node_path33.default.dirname(credentialsFile));
   deps.fs.writeFilePrivate(credentialsFile, `${JSON.stringify({ ...existingCredentials, claudeAiOauth: { accessToken, refreshToken, expiresAt: null, scopes: [...RC_SELF_HOST_SCOPE_LIST], subscriptionType: SELF_HOST_SUBSCRIPTION_TYPE, rateLimitTier: null } }, null, 2)}
 `);
   const claudeJson = readJsonObject(deps.fs, claudeJsonFile) ?? {};
@@ -17058,7 +17606,7 @@ init_plan2();
 init_poolPick();
 
 // src/agents/read.ts
-var import_node_path33 = __toESM(require("node:path"), 1);
+var import_node_path34 = __toESM(require("node:path"), 1);
 var import_zod28 = require("zod");
 var PROJECTS_DIR = "projects";
 var TASKS_DIR = "tasks";
@@ -17084,15 +17632,15 @@ function parseEntry2(project, entry) {
 }
 function listSessions2(fs12, configDir) {
   const found = [];
-  for (const project of fs12.readdir(import_node_path33.default.join(configDir, PROJECTS_DIR))) {
-    const projectDir = import_node_path33.default.join(configDir, PROJECTS_DIR, project);
+  for (const project of fs12.readdir(import_node_path34.default.join(configDir, PROJECTS_DIR))) {
+    const projectDir = import_node_path34.default.join(configDir, PROJECTS_DIR, project);
     const entries = /* @__PURE__ */ new Set();
     for (const name of fs12.readdir(projectDir)) {
       if (name.endsWith(TRANSCRIPT_SUFFIX)) {
         entries.add(name.slice(0, -TRANSCRIPT_SUFFIX.length));
         continue;
       }
-      const children = fs12.readdir(import_node_path33.default.join(projectDir, name));
+      const children = fs12.readdir(import_node_path34.default.join(projectDir, name));
       if (children.includes(SUBAGENTS_DIR) || children.includes(WORKFLOWS_DIR)) {
         entries.add(name);
       }
@@ -17112,8 +17660,8 @@ function locateAgents(fs12, configDir, relativeDir, workflowRunId, report) {
     const id = name.slice(AGENT_FILE_PREFIX.length, -META_SUFFIX.length);
     located.push({
       id,
-      metaPath: import_node_path33.default.join(relativeDir, name),
-      transcriptPath: import_node_path33.default.join(relativeDir, `${AGENT_FILE_PREFIX}${id}${TRANSCRIPT_SUFFIX}`),
+      metaPath: import_node_path34.default.join(relativeDir, name),
+      transcriptPath: import_node_path34.default.join(relativeDir, `${AGENT_FILE_PREFIX}${id}${TRANSCRIPT_SUFFIX}`),
       workflowRunId
     });
   }
@@ -17156,7 +17704,7 @@ function describeFailure(error) {
 }
 function readFileOrReport(fs12, configDir, relative, report) {
   try {
-    return fs12.readFileUtf8(import_node_path33.default.join(configDir, relative));
+    return fs12.readFileUtf8(import_node_path34.default.join(configDir, relative));
   } catch (error) {
     report({ path: relative, reason: `could not be read: ${describeFailure(error)}` });
     return void 0;
@@ -17164,7 +17712,7 @@ function readFileOrReport(fs12, configDir, relative, report) {
 }
 function listDirOrReport(fs12, configDir, relative, report) {
   try {
-    return fs12.readdir(import_node_path33.default.join(configDir, relative));
+    return fs12.readdir(import_node_path34.default.join(configDir, relative));
   } catch (error) {
     report({ path: relative, reason: `could not be listed: ${describeFailure(error)}` });
     return [];
@@ -17188,18 +17736,18 @@ var WorkflowRunFileSchema = import_zod28.z.object({
   summary: import_zod28.z.string().optional()
 });
 function summariseSession(fs12, configDir, ref) {
-  const sessionRelative = import_node_path33.default.join(PROJECTS_DIR, ref.project, ref.entry);
-  const subagentsRelative = import_node_path33.default.join(sessionRelative, SUBAGENTS_DIR);
-  const workflowsUnderSubagents = import_node_path33.default.join(subagentsRelative, WORKFLOWS_DIR);
+  const sessionRelative = import_node_path34.default.join(PROJECTS_DIR, ref.project, ref.entry);
+  const subagentsRelative = import_node_path34.default.join(sessionRelative, SUBAGENTS_DIR);
+  const workflowsUnderSubagents = import_node_path34.default.join(subagentsRelative, WORKFLOWS_DIR);
   const isMeta = (name) => name.startsWith(AGENT_FILE_PREFIX) && name.endsWith(META_SUFFIX);
-  let agentCount = fs12.readdir(import_node_path33.default.join(configDir, subagentsRelative)).filter(isMeta).length;
-  for (const runDir of fs12.readdir(import_node_path33.default.join(configDir, workflowsUnderSubagents))) {
+  let agentCount = fs12.readdir(import_node_path34.default.join(configDir, subagentsRelative)).filter(isMeta).length;
+  for (const runDir of fs12.readdir(import_node_path34.default.join(configDir, workflowsUnderSubagents))) {
     if (runDir.startsWith(WORKFLOW_RUN_PREFIX)) {
-      agentCount += fs12.readdir(import_node_path33.default.join(configDir, workflowsUnderSubagents, runDir)).filter(isMeta).length;
+      agentCount += fs12.readdir(import_node_path34.default.join(configDir, workflowsUnderSubagents, runDir)).filter(isMeta).length;
     }
   }
-  const workflowRunCount = fs12.readdir(import_node_path33.default.join(configDir, sessionRelative, WORKFLOWS_DIR)).filter((name) => name.startsWith(WORKFLOW_RUN_PREFIX) && name.endsWith(JSON_SUFFIX)).length;
-  const transcript = fs12.lstat(import_node_path33.default.join(configDir, PROJECTS_DIR, ref.project, `${ref.entry}${TRANSCRIPT_SUFFIX}`));
+  const workflowRunCount = fs12.readdir(import_node_path34.default.join(configDir, sessionRelative, WORKFLOWS_DIR)).filter((name) => name.startsWith(WORKFLOW_RUN_PREFIX) && name.endsWith(JSON_SUFFIX)).length;
+  const transcript = fs12.lstat(import_node_path34.default.join(configDir, PROJECTS_DIR, ref.project, `${ref.entry}${TRANSCRIPT_SUFFIX}`));
   return { ...ref, agentCount, workflowRunCount, ...transcript === void 0 ? {} : { updatedAt: new Date(transcript.mtimeMs).toISOString() } };
 }
 function readSessionAgentTree(fs12, configDir, ref, options = {}) {
@@ -17207,13 +17755,13 @@ function readSessionAgentTree(fs12, configDir, ref, options = {}) {
   const report = (problem) => {
     problems.push(problem);
   };
-  const sessionRelative = import_node_path33.default.join(PROJECTS_DIR, ref.project, ref.entry);
-  const subagentsRelative = import_node_path33.default.join(sessionRelative, SUBAGENTS_DIR);
-  const workflowsUnderSubagents = import_node_path33.default.join(subagentsRelative, WORKFLOWS_DIR);
+  const sessionRelative = import_node_path34.default.join(PROJECTS_DIR, ref.project, ref.entry);
+  const subagentsRelative = import_node_path34.default.join(sessionRelative, SUBAGENTS_DIR);
+  const workflowsUnderSubagents = import_node_path34.default.join(subagentsRelative, WORKFLOWS_DIR);
   const located = locateAgents(fs12, configDir, subagentsRelative, void 0, report);
   for (const runDir of listDirOrReport(fs12, configDir, workflowsUnderSubagents, report)) {
     if (runDir.startsWith(WORKFLOW_RUN_PREFIX)) {
-      located.push(...locateAgents(fs12, configDir, import_node_path33.default.join(workflowsUnderSubagents, runDir), runDir, report));
+      located.push(...locateAgents(fs12, configDir, import_node_path34.default.join(workflowsUnderSubagents, runDir), runDir, report));
     }
   }
   const agents = /* @__PURE__ */ new Map();
@@ -17254,7 +17802,7 @@ function readSessionAgentTree(fs12, configDir, ref, options = {}) {
     superseded: ref.superseded,
     agents: roots.sort().map(build),
     tasks: readTasks(fs12, configDir, ownTaskLists(ref.sessionId), [.../* @__PURE__ */ new Set([...teamNames, ...options.taskListIds ?? []])].filter((id) => !ownTaskLists(ref.sessionId).includes(id)), report),
-    workflowRuns: readWorkflowRuns(fs12, configDir, import_node_path33.default.join(sessionRelative, WORKFLOWS_DIR), report),
+    workflowRuns: readWorkflowRuns(fs12, configDir, import_node_path34.default.join(sessionRelative, WORKFLOWS_DIR), report),
     problems
   };
 }
@@ -17319,12 +17867,12 @@ function ownTaskLists(sessionId) {
 function readTasks(fs12, configDir, ownLists, sharedLists, report) {
   const tasks = [];
   [...ownLists, ...sharedLists].forEach((scope, index) => {
-    const relativeDir = import_node_path33.default.join(TASKS_DIR, scope);
+    const relativeDir = import_node_path34.default.join(TASKS_DIR, scope);
     for (const name of [...listDirOrReport(fs12, configDir, relativeDir, report)].sort()) {
       if (name.startsWith(".") || !name.endsWith(JSON_SUFFIX)) {
         continue;
       }
-      const relative = import_node_path33.default.join(relativeDir, name);
+      const relative = import_node_path34.default.join(relativeDir, name);
       const text = readFileOrReport(fs12, configDir, relative, report);
       const parsed = TaskFileSchema.safeParse(text === void 0 ? void 0 : parseJson2(text));
       if (parsed.success) {
@@ -17342,7 +17890,7 @@ function readWorkflowRuns(fs12, configDir, relativeDir, report) {
     if (!name.startsWith(WORKFLOW_RUN_PREFIX) || !name.endsWith(JSON_SUFFIX)) {
       continue;
     }
-    const relative = import_node_path33.default.join(relativeDir, name);
+    const relative = import_node_path34.default.join(relativeDir, name);
     const text = readFileOrReport(fs12, configDir, relative, report);
     const parsed = WorkflowRunFileSchema.safeParse(text === void 0 ? void 0 : parseJson2(text));
     if (!parsed.success) {
@@ -17358,7 +17906,7 @@ function readWorkflowRuns(fs12, configDir, relativeDir, report) {
 }
 
 // src/agents/sessions.ts
-var import_node_path34 = __toESM(require("node:path"), 1);
+var import_node_path35 = __toESM(require("node:path"), 1);
 init_cliError();
 var SessionLookupError = class extends CliError {
   constructor(message) {
@@ -17367,13 +17915,13 @@ var SessionLookupError = class extends CliError {
   }
 };
 function identityConfigDir(identitiesDir, identity) {
-  return import_node_path34.default.join(identitiesDir, identity);
+  return import_node_path35.default.join(identitiesDir, identity);
 }
 function historyStores(fs12, identitiesDir, identities) {
   const byRealPath = /* @__PURE__ */ new Map();
   for (const identity of identities) {
     const configDir = identityConfigDir(identitiesDir, identity);
-    const real = fs12.realpath(import_node_path34.default.join(configDir, "projects"));
+    const real = fs12.realpath(import_node_path35.default.join(configDir, "projects"));
     if (real === void 0) {
       continue;
     }
@@ -17826,6 +18374,7 @@ init_ownCli();
   isRcReadFileEncoding,
   lateRcEventDial,
   lateRcStreamDial,
+  launchRequiredUpstreams,
   listDirectoryRules,
   listIdentities,
   listProfiles,