claude-use 9.19.0 → 10.0.0

package/dist/index.mjs

@@ -450,7 +450,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 = 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. */
@@ -2585,9 +2585,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(path8.join(recordsDir, `${String(record.pid)}.json`), `${JSON.stringify({ directPort: record.directPort })}
+`);
+}
+function removeFrontDoorDirectRecord(fs12, recordsDir, pid) {
+  fs12.removeRecursive(path8.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(path8.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(path8.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);
@@ -2624,7 +2686,7 @@ function pruneDeadFrontDoorSessions(fs12, sessionsDir, isRunning) {
   }
   return removed;
 }
-var FRONT_DOOR_PROTOCOL, FrontDoorSessionSchema, FrontDoorStateSchema;
+var FRONT_DOOR_PROTOCOL, FrontDoorSessionSchema, FrontDoorStateSchema, MAX_TCP_PORT, FrontDoorDirectRecordSchema, RECORD_TEMPORARY_FILE;
 var init_state = __esm({
   "src/frontdoor/state.ts"() {
     "use strict";
@@ -2652,7 +2714,7 @@ var init_state = __esm({
        */
       lastConnectPort: z3.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: z3.number().int().positive().optional(),
       /** The sticky port preference for the direct listener, for the reason `directPort` gives. */
@@ -2660,6 +2722,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: z3.string().optional()
     });
+    MAX_TCP_PORT = 65535;
+    FrontDoorDirectRecordSchema = z3.strictObject({ directPort: z3.number().int().positive().max(MAX_TCP_PORT) });
+    RECORD_TEMPORARY_FILE = /^[1-9]\d*\.json\.([1-9]\d*)\.tmp$/;
   }
 });
 
@@ -2669,7 +2734,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>",
@@ -2794,11 +2859,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+)$/;
   }
 });
 
@@ -2851,22 +2980,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 createHash3("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;
+  }
+  if (entry.startsWith("[")) {
+    const close = entry.indexOf("]");
+    return close > 1 && !entry.slice(close + 1).includes(":");
   }
-  return [...urls].sort();
+  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 createHash3("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(path11.dirname(allowlistFile));
+  fs12.writeFilePrivate(allowlistFile, formatAllowlistFile(allowlist));
+}
+function pruneStaleAllowlistTemporaries(fs12, allowlistFile, isRunning) {
+  const prefix = `${path11.basename(allowlistFile)}.`;
+  for (const name of fs12.readdir(path11.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(path11.join(path11.dirname(allowlistFile), name));
+    }
+  }
 }
 function readAllProviders(fs12, providersDir) {
   const result = [];
@@ -2930,16 +3086,15 @@ function readStartLock(fs12, lockFile) {
     return void 0;
   }
 }
-var HEADROOM_ANTHROPIC_UPSTREAM, HeadroomStateSchema, HeadroomSessionSchema, HeadroomLockSchema;
+var 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";
     init_schema();
-    HEADROOM_ANTHROPIC_UPSTREAM = "https://api.anthropic.com";
     HeadroomStateSchema = z8.strictObject({
       /** The supervisor process owning the daemon. Alive means someone is keeping headroom running. */
       supervisorPid: z8.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: z8.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.
@@ -2947,7 +3102,9 @@ var init_state2 = __esm({
       socketPath: z8.string().min(1).optional(),
       /** The `headroom --version` output of the running install. */
       version: z8.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: z8.string().optional(),
       /** Hash of the token-saving settings the running proxy was started with, so a settings change is detected as drift. */
       settingsHash: z8.string().optional(),
@@ -2958,33 +3115,133 @@ var init_state2 = __esm({
     });
     HeadroomSessionSchema = z8.strictObject({ pid: z8.number().int().positive(), startedAt: z8.number(), supervisorPid: z8.number().int().positive() });
     HeadroomLockSchema = z8.strictObject({ pid: z8.number().int().positive(), at: z8.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(
@@ -3010,10 +3267,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);
   }
@@ -3023,6 +3281,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;
@@ -3069,6 +3328,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
 import path12 from "node:path";
 function headroomSocketPath(paths, supervisorPid) {
@@ -3082,10 +3357,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)})`;
@@ -3105,6 +3380,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 = path12.dirname(current);
+      continue;
+    }
+    if (!directories.includes(current)) {
+      directories.push(current);
+    }
+    const entry = path12.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 (path12.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 : path12.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) {
@@ -3136,7 +3491,7 @@ function pruneStaleHeadroomSockets(fs12, paths, isRunning) {
   }
   return removed;
 }
-var GROUP_OR_OTHER_BITS, OCTAL_RADIX, MODE_DIGITS, HEADROOM_SOCKET_SUFFIX, HEADROOM_SOCKET_NAME, UNIX_SOCKET_PATH_MAX_BYTES, PLATFORMS_WITHOUT_UNIX_SOCKETS;
+var 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";
@@ -3147,6 +3502,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";
   }
 });
 
@@ -3175,6 +3536,7 @@ var init_source = __esm({
 });
 
 // src/headroom/supervisor.ts
+import path13 from "node:path";
 function resolveSupervisorConfig(configured) {
   return {
     source: configured.source ?? HEADROOM_DEFAULT_SOURCE,
@@ -3263,6 +3625,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(path13.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);
@@ -3286,14 +3678,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);
   }
@@ -3301,9 +3699,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;
@@ -3311,7 +3719,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();
@@ -3319,6 +3730,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) {
@@ -3333,43 +3751,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);
@@ -3398,45 +3826,65 @@ 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 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";
     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;
@@ -3448,7 +3896,7 @@ import { spawn as spawn2, spawnSync } from "node:child_process";
 import { createHash as createHash5 } from "node:crypto";
 import fs3 from "node:fs";
 import os3 from "node:os";
-import path13 from "node:path";
+import path14 from "node:path";
 import { isSea } from "node:sea";
 function isEnoent3(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
@@ -3478,8 +3926,18 @@ function realIsFrontDoorSupervisor(pid) {
   const result = spawnSync("ps", ["-o", "pid=,command=", "-p", String(pid)], { encoding: "utf8" });
   return result.status === 0 && parseFrontDoorSupervisorPids(result.stdout).includes(pid);
 }
+function realProcessCommandLine(pid) {
+  const result = 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 = 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("~/") ? path13.join(os3.homedir(), filePath.slice(1)) : filePath;
+  return filePath.startsWith("~/") ? path14.join(os3.homedir(), filePath.slice(1)) : filePath;
 }
 function hasDesktopSession() {
   if (process.platform === "darwin") {
@@ -3523,7 +3981,7 @@ function spawnDaemonThroughScript(script) {
   return (paths, subcommand, logPath) => spawnDetachedDaemon({ command: process.execPath, args: [script, subcommand] }, paths, subcommand, logPath);
 }
 function spawnDetachedDaemon(invocation, paths, subcommand, logPath) {
-  fs3.mkdirSync(path13.dirname(logPath), { recursive: true });
+  fs3.mkdirSync(path14.dirname(logPath), { recursive: true });
   const logFd = fs3.openSync(logPath, "a");
   try {
     const child = spawn2(invocation.command, invocation.args, detachedDaemonSpawnOptions(logFd, { ...process.env, AGENT_SHIM_HOME: paths.root }));
@@ -3545,13 +4003,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)
         }
       });
@@ -3576,7 +4035,7 @@ function listVersionsDir(dir) {
     throw error;
   }
   return entries.filter((entry) => entry.isFile()).map((entry) => {
-    const fullPath = path13.join(dir, entry.name);
+    const fullPath = path14.join(dir, entry.name);
     const stat = fs3.statSync(fullPath);
     return {
       name: entry.name,
@@ -3590,7 +4049,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 = path13.join(dir, name);
+  const candidate = path14.join(dir, name);
   if (env.platform === "win32") {
     const extensions = windowsPathExtensions(env.pathext);
     const alreadyHasRecognisedExtension = extensions.some((ext) => candidate.toLowerCase().endsWith(ext.toLowerCase()));
@@ -3639,13 +4098,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 : path13.resolve(env.cwd, env.argv1);
-  const candidateDir = path13.dirname(candidate);
-  const candidateDirOnPath = env.pathDirs.some((dir) => path13.resolve(dir) === candidateDir);
+  const candidate = env.argv1 === void 0 ? env.execPath : path14.resolve(env.cwd, env.argv1);
+  const candidateDir = path14.dirname(candidate);
+  const candidateDirOnPath = env.pathDirs.some((dir) => path14.resolve(dir) === candidateDir);
   if (candidateDirOnPath) {
     return candidate;
   }
-  const viaPath = searchPathForExecutable(env.pathDirs, path13.basename(candidate), env.findExecutableInDir);
+  const viaPath = searchPathForExecutable(env.pathDirs, path14.basename(candidate), env.findExecutableInDir);
   return viaPath ?? candidate;
 }
 function realOwnExecutablePath() {
@@ -3653,7 +4112,7 @@ function realOwnExecutablePath() {
     argv1: process.argv[1],
     execPath: process.execPath,
     cwd: process.cwd(),
-    pathDirs: (process.env.PATH ?? "").split(path13.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(path14.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir
   });
 }
@@ -3666,7 +4125,7 @@ function realContentSourcePath() {
 function realResolveClaudeBinary(isOwnBinary) {
   return (request4) => discoverClaudeBinary({
     listVersionsDir,
-    pathDirs: (process.env.PATH ?? "").split(path13.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(path14.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir,
     isOwnBinary,
     ...request4?.version === void 0 ? {} : { version: request4.version }
@@ -3675,7 +4134,7 @@ function realResolveClaudeBinary(isOwnBinary) {
 function realInstalledClaudeVersions() {
   return installedVersions(listVersionsDir(defaultVersionsDir()));
 }
-var 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 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";
@@ -3769,9 +4228,14 @@ var init_realPorts = __esm({
       },
       writeFilePrivate(filePath, contents) {
         const temp = `${filePath}.${String(process.pid)}.tmp`;
-        fs3.writeFileSync(temp, contents, { encoding: "utf8", mode: OWNER_ONLY_FILE_MODE });
-        fs3.chmodSync(temp, OWNER_ONLY_FILE_MODE);
-        fs3.renameSync(temp, filePath);
+        try {
+          fs3.writeFileSync(temp, contents, { encoding: "utf8", mode: OWNER_ONLY_FILE_MODE });
+          fs3.chmodSync(temp, OWNER_ONLY_FILE_MODE);
+          fs3.renameSync(temp, filePath);
+        } catch (error) {
+          fs3.rmSync(temp, { force: true });
+          throw error;
+        }
       },
       appendFilePrivate(filePath, contents) {
         const descriptor = fs3.openSync(filePath, "a", OWNER_ONLY_FILE_MODE);
@@ -3811,6 +4275,7 @@ var init_realPorts = __esm({
       }
     };
     INT32_BYTE_LENGTH = 4;
+    PS_TIMEOUT_MS = 2e3;
     realRunPort = {
       run(command, args) {
         const result = spawnSync(command, [...args], { encoding: "utf8" });
@@ -3849,7 +4314,7 @@ var init_realPorts = __esm({
       },
       personPresent: () => process.stdin.isTTY || hasDesktopSession()
     };
-    SOCKET_PERMISSION_BITS = 511;
+    SOCKET_PERMISSION_BITS = 4095;
     realHeadroomSocketTrust = {
       platform: process.platform,
       currentUid: () => {
@@ -3868,9 +4333,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) => fs3.readlinkSync(target, "utf8")
     };
     realSpawnPort = {
       spawnSync(command, args, options) {
@@ -3889,18 +4355,18 @@ var init_realPorts = __esm({
 });
 
 // src/pathNorm.ts
-import path14 from "node:path";
+import path15 from "node:path";
 function expandTilde(value, home) {
   if (value === "~") {
     return home;
   }
   if (value.startsWith("~/")) {
-    return path14.join(home, value.slice(2));
+    return path15.join(home, value.slice(2));
   }
   return value;
 }
 function normaliseRulePath(rulePath, home) {
-  return path14.resolve(expandTilde(rulePath, home));
+  return path15.resolve(expandTilde(rulePath, home));
 }
 var init_pathNorm = __esm({
   "src/pathNorm.ts"() {
@@ -3909,12 +4375,12 @@ var init_pathNorm = __esm({
 });
 
 // src/launcher/cascade.ts
-import path15 from "node:path";
+import path16 from "node:path";
 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 = path15.join(params.paths.configProfilesDir, `${name}.json`);
+    const filepath = path16.join(params.paths.configProfilesDir, `${name}.json`);
     const loaded = loadConfigFile(filepath, ConfigProfileSchema, params.read);
     if (loaded === void 0) {
       return void 0;
@@ -3929,8 +4395,8 @@ function loadCascadeInput(params) {
   });
   const levels = [];
   for (const dir of dirs) {
-    const portable = loadConfigFile(path15.join(dir, PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(path15.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read);
-    const portableLocal = loadConfigFile(path15.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(path15.join(dir, LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read);
+    const portable = loadConfigFile(path16.join(dir, PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(path16.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read);
+    const portableLocal = loadConfigFile(path16.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(path16.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 {
@@ -3992,7 +4458,7 @@ var init_cascade = __esm({
 });
 
 // src/launcher/identity.ts
-import path16 from "node:path";
+import path17 from "node:path";
 function poolNameOf(selector) {
   return selector.startsWith(POOL_SELECTOR_PREFIX) ? selector.slice(POOL_SELECTOR_PREFIX.length) : void 0;
 }
@@ -4045,7 +4511,7 @@ function decideConfigProfile(params) {
   return { source: "none" };
 }
 function loadIdentity(identitiesDir, name, fs12) {
-  return loadConfigFile(path16.join(identitiesDir, name, "identity.json"), IdentitySchema, fs12.readConfigFile);
+  return loadConfigFile(path17.join(identitiesDir, name, "identity.json"), IdentitySchema, fs12.readConfigFile);
 }
 var IDENTITY_DECISION_SOURCES, CONFIG_PROFILE_DECISION_SOURCES;
 var init_identity = __esm({
@@ -4265,7 +4731,7 @@ var init_schema2 = __esm({
 });
 
 // src/usage/account.ts
-import path17 from "node:path";
+import path18 from "node:path";
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -4273,7 +4739,7 @@ function isIdentityName(name) {
   return IdentitySchema.shape.name.safeParse(name).success;
 }
 function claudeJsonPath(identitiesDir, identity) {
-  return path17.join(identitiesDir, identity, CLAUDE_JSON);
+  return path18.join(identitiesDir, identity, CLAUDE_JSON);
 }
 function readAccountMetadata(fs12, identitiesDir, identity) {
   if (!isIdentityName(identity)) {
@@ -4865,7 +5331,7 @@ var init_pick = __esm({
 });
 
 // src/usage/read.ts
-import path18 from "node:path";
+import path19 from "node:path";
 function segmentDay(epochMs) {
   return new Date(epochMs).toISOString().slice(0, "YYYY-MM-DD".length);
 }
@@ -4890,7 +5356,7 @@ function readUsageLog(fs12, logDir, options = {}) {
     if (sinceMs !== void 0 && segment.endsAt <= sinceMs) {
       continue;
     }
-    const contents = fs12.readFileUtf8(path18.join(logDir, segment.name));
+    const contents = fs12.readFileUtf8(path19.join(logDir, segment.name));
     if (contents === void 0) {
       continue;
     }
@@ -4924,7 +5390,7 @@ function snapshotPath(snapshotsDir, identity) {
   if (!isIdentityName(identity)) {
     throw new Error(`"${identity}" is not a valid identity name.`);
   }
-  return path18.join(snapshotsDir, `${identity}.json`);
+  return path19.join(snapshotsDir, `${identity}.json`);
 }
 function readUsageSnapshot(fs12, snapshotsDir, identity) {
   const file = snapshotPath(snapshotsDir, identity);
@@ -4977,12 +5443,12 @@ var init_read = __esm({
 });
 
 // src/usage/store.ts
-import path19 from "node:path";
+import path20 from "node:path";
 function pruneUsageLog(fs12, logDir, nowMs) {
   const cutoff = nowMs - USAGE_RETENTION_MS;
   for (const segment of listLogSegments(fs12, logDir)) {
     if (segment.endsAt <= cutoff) {
-      fs12.removeRecursive(path19.join(logDir, segment.name));
+      fs12.removeRecursive(path20.join(logDir, segment.name));
     }
   }
 }
@@ -5064,7 +5530,7 @@ function createUsageStore(deps) {
         pruneUsageLog(fs12, paths.usageLogDir, nowMs);
         prunedDay = day;
       }
-      fs12.appendFilePrivate(path19.join(paths.usageLogDir, segmentName(day, deps.pid)), `${JSON.stringify(record)}
+      fs12.appendFilePrivate(path20.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) }));
@@ -5102,7 +5568,7 @@ var init_store2 = __esm({
 });
 
 // src/usage/poolPick.ts
-import path20 from "node:path";
+import path21 from "node:path";
 import { z as z13 } from "zod";
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -5230,7 +5696,7 @@ 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(path20.dirname(picksFile));
+  fs12.mkdirPrivate(path21.dirname(picksFile));
   fs12.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
 `);
 }
@@ -5264,14 +5730,14 @@ var init_poolPick = __esm({
 // src/paths.ts
 import fs5 from "node:fs";
 import os5 from "node:os";
-import path22 from "node:path";
+import path23 from "node:path";
 function resolveAgentShimHome(env = process.env, home = os5.homedir(), isDirectory = isExistingDirectory) {
   const fromEnv = env.AGENT_SHIM_HOME;
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  const current = path22.join(home, HOME_DIRNAME);
-  const legacy = path22.join(home, LEGACY_HOME_DIRNAME);
+  const current = path23.join(home, HOME_DIRNAME);
+  const legacy = path23.join(home, LEGACY_HOME_DIRNAME);
   return !isDirectory(current) && isDirectory(legacy) ? legacy : current;
 }
 function isExistingDirectory(candidate) {
@@ -5282,47 +5748,49 @@ function resolveClaudeHome() {
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  return path22.join(os5.homedir(), ".claude");
+  return path23.join(os5.homedir(), ".claude");
 }
 function buildLayoutPaths(root) {
   return {
     root,
-    identitiesDir: path22.join(root, "identities"),
-    configProfilesDir: path22.join(root, "config-profiles"),
-    providersDir: path22.join(root, "providers"),
-    directoryRulesFile: path22.join(root, "directory-rules.json"),
-    activeIdentityFile: path22.join(root, "active-identity"),
-    globalConfigFile: path22.join(root, "config.json"),
-    categoriesLocalFile: path22.join(root, "categories.local.json"),
-    claudeShimFile: path22.join(root, "claude-shim.json"),
-    headroomDir: path22.join(root, "headroom"),
-    headroomStateFile: path22.join(root, "headroom", "state.json"),
-    headroomLegacyStateFile: path22.join(root, "headroom", "state.v2.json"),
-    headroomSocketDir: path22.join(root, "headroom", "run"),
-    headroomLockFile: path22.join(root, "headroom", "start.lock"),
-    headroomSessionsDir: path22.join(root, "headroom", "sessions"),
-    logsDir: path22.join(root, "logs"),
-    headroomLogPath: path22.join(root, "logs", "headroom.log"),
-    frontdoorDir: path22.join(root, "frontdoor"),
-    frontdoorCaDir: path22.join(root, "frontdoor", "ca"),
-    frontdoorCaCertFile: path22.join(root, "frontdoor", "ca", "ca.pem"),
-    frontdoorCaKeyFile: path22.join(root, "frontdoor", "ca", "ca.key"),
-    frontdoorCaBundlesDir: path22.join(root, "frontdoor", "ca", "bundles"),
-    chatgptSignInFile: path22.join(root, "codex", "chatgpt-sign-in.json"),
-    frontdoorStateFile: path22.join(root, "frontdoor", "state.json"),
-    frontdoorLockFile: path22.join(root, "frontdoor", "start.lock"),
-    frontdoorControlTokenFile: path22.join(root, "frontdoor", "control-token"),
-    frontdoorSessionsDir: path22.join(root, "frontdoor", "sessions"),
-    frontdoorRcCredentialsDir: path22.join(root, "frontdoor", "rc-credentials"),
-    frontdoorLogPath: path22.join(root, "logs", "frontdoor.log"),
-    usageDir: path22.join(root, "usage"),
-    usageLogDir: path22.join(root, "usage", "log"),
-    usageSnapshotsDir: path22.join(root, "usage", "snapshots"),
-    usagePicksFile: path22.join(root, "usage", "picks.json"),
-    usageAnchorsFile: path22.join(root, "usage", "anchors.json"),
-    usageJobsFile: path22.join(root, "usage", "jobs.json"),
-    jobLogsDir: path22.join(root, "logs", "jobs"),
-    mcpPermissionsFile: path22.join(root, "mcp", "permissions.json")
+    identitiesDir: path23.join(root, "identities"),
+    configProfilesDir: path23.join(root, "config-profiles"),
+    providersDir: path23.join(root, "providers"),
+    directoryRulesFile: path23.join(root, "directory-rules.json"),
+    activeIdentityFile: path23.join(root, "active-identity"),
+    globalConfigFile: path23.join(root, "config.json"),
+    categoriesLocalFile: path23.join(root, "categories.local.json"),
+    claudeShimFile: path23.join(root, "claude-shim.json"),
+    headroomDir: path23.join(root, "headroom"),
+    headroomStateFile: path23.join(root, "headroom", "state.json"),
+    headroomLegacyStateFile: path23.join(root, "headroom", "state.v2.json"),
+    headroomAllowlistFile: path23.join(root, "headroom", "run", "allowlist.txt"),
+    headroomSocketDir: path23.join(root, "headroom", "run"),
+    headroomLockFile: path23.join(root, "headroom", "start.lock"),
+    headroomSessionsDir: path23.join(root, "headroom", "sessions"),
+    logsDir: path23.join(root, "logs"),
+    headroomLogPath: path23.join(root, "logs", "headroom.log"),
+    frontdoorDir: path23.join(root, "frontdoor"),
+    frontdoorCaDir: path23.join(root, "frontdoor", "ca"),
+    frontdoorCaCertFile: path23.join(root, "frontdoor", "ca", "ca.pem"),
+    frontdoorCaKeyFile: path23.join(root, "frontdoor", "ca", "ca.key"),
+    frontdoorCaBundlesDir: path23.join(root, "frontdoor", "ca", "bundles"),
+    chatgptSignInFile: path23.join(root, "codex", "chatgpt-sign-in.json"),
+    frontdoorStateFile: path23.join(root, "frontdoor", "state.json"),
+    frontdoorLockFile: path23.join(root, "frontdoor", "start.lock"),
+    frontdoorControlTokenFile: path23.join(root, "frontdoor", "control-token"),
+    frontdoorSessionsDir: path23.join(root, "frontdoor", "sessions"),
+    frontdoorDirectRecordsDir: path23.join(root, "frontdoor", "direct"),
+    frontdoorRcCredentialsDir: path23.join(root, "frontdoor", "rc-credentials"),
+    frontdoorLogPath: path23.join(root, "logs", "frontdoor.log"),
+    usageDir: path23.join(root, "usage"),
+    usageLogDir: path23.join(root, "usage", "log"),
+    usageSnapshotsDir: path23.join(root, "usage", "snapshots"),
+    usagePicksFile: path23.join(root, "usage", "picks.json"),
+    usageAnchorsFile: path23.join(root, "usage", "anchors.json"),
+    usageJobsFile: path23.join(root, "usage", "jobs.json"),
+    jobLogsDir: path23.join(root, "logs", "jobs"),
+    mcpPermissionsFile: path23.join(root, "mcp", "permissions.json")
   };
 }
 function resolveLayoutPaths() {
@@ -5414,7 +5882,7 @@ var init_credentialCache = __esm({
 // src/realCredentialCache.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 import fs6 from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 function cacheFileNameFor(owner) {
   return `${owner.replace(/[^A-Za-z0-9._-]/g, "_")}.json`;
 }
@@ -5438,8 +5906,8 @@ function security(args, stdin) {
   return { status: result.status, stdout: result.stdout };
 }
 function createRealCredentialCache(root) {
-  const dir = path23.join(root, "credential-cache");
-  const filePath = (owner) => path23.join(dir, cacheFileNameFor(owner));
+  const dir = path24.join(root, "credential-cache");
+  const filePath = (owner) => path24.join(dir, cacheFileNameFor(owner));
   return {
     read(store, owner) {
       if (store === "file") {
@@ -5671,9 +6139,9 @@ var init_credential = __esm({
 
 // src/providersStore.ts
 import fs7 from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 function providerJsonPath(paths, name) {
-  return path24.join(paths.providersDir, `${name}.json`);
+  return path25.join(paths.providersDir, `${name}.json`);
 }
 function providerExists(paths, name) {
   return fs7.existsSync(providerJsonPath(paths, name));
@@ -5733,7 +6201,7 @@ function readProvider(paths, name) {
   return parseProviderFile(filePath, raw);
 }
 function loadProvider(providersDir, name, port) {
-  const filePath = path24.join(providersDir, `${name}.json`);
+  const filePath = path25.join(providersDir, `${name}.json`);
   const raw = port.readConfigFile(filePath);
   return raw === void 0 ? void 0 : parseProviderFile(filePath, raw);
 }
@@ -6106,17 +6574,17 @@ var init_commandDeps = __esm({
 
 // src/claudeShim.ts
 import fs8 from "node:fs";
-import path26 from "node:path";
+import path27 from "node:path";
 import { z as z19 } from "zod";
 function commandFilename(ownExecutablePath, commandName) {
   return ownExecutablePath.toLowerCase().endsWith(".exe") ? `${commandName}.exe` : commandName;
 }
 function resolveOwnBinaryCheck(paths, contentSourcePath) {
   const state = readJson(paths.claudeShimFile, ClaudeShimStateSchema);
-  const recordedTarget = state === void 0 ? void 0 : path26.resolve(state.targetPath);
+  const recordedTarget = state === void 0 ? void 0 : path27.resolve(state.targetPath);
   let ownStat;
   return (candidate) => {
-    if (recordedTarget !== void 0 && path26.resolve(candidate) === recordedTarget) {
+    if (recordedTarget !== void 0 && path27.resolve(candidate) === recordedTarget) {
       return true;
     }
     ownStat ??= statOrUndefined(contentSourcePath);
@@ -6139,15 +6607,15 @@ function statOrUndefined(target) {
   }
 }
 function findPathShadow(params) {
-  const resolvedTargetDir = path26.resolve(params.targetDir);
+  const resolvedTargetDir = path27.resolve(params.targetDir);
   for (const dir of params.pathDirs) {
     const found = params.findExecutableInDir(dir, params.targetFilename);
     if (found === void 0) {
       continue;
     }
-    return path26.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
+    return path27.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
   }
-  return params.pathDirs.some((dir) => path26.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
+  return params.pathDirs.some((dir) => path27.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
 }
 var ClaudeShimStateSchema, nodeLinkFs;
 var init_claudeShim = __esm({
@@ -6635,7 +7103,7 @@ var init_headers = __esm({
 });
 
 // src/launcher/flags.ts
-import path35 from "node:path";
+import path36 from "node:path";
 function resolveLaunchFlags(params) {
   return {
     skipPermissions: params.flags?.skipPermissions ?? parseEnvBool("AGENT_SHIM_SKIP_PERMISSIONS", params.env.AGENT_SHIM_SKIP_PERMISSIONS) ?? params.cascade?.skipPermissions ?? false,
@@ -6666,7 +7134,7 @@ function buildEnv(params) {
   const parentCustomHeaders = params.baseEnv.ANTHROPIC_CUSTOM_HEADERS;
   let providerCustomHeaders;
   if (!params.configDirEscapeHatch && params.resolvedIdentityName !== void 0) {
-    env.CLAUDE_CONFIG_DIR = path35.join(params.identitiesDir, params.resolvedIdentityName);
+    env.CLAUDE_CONFIG_DIR = path36.join(params.identitiesDir, params.resolvedIdentityName);
   }
   if (params.provider !== void 0) {
     const providerEnv = params.provider.definition.env ?? {};
@@ -6938,7 +7406,7 @@ var init_launchHook = __esm({
 
 // src/launcher.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import path36 from "node:path";
+import path37 from "node:path";
 function resolveIdentityCredential(identity, credential, env, port) {
   if (port === void 0) {
     return { ok: false, status: 1, message: `agent-shim: identity ${identity} needs its credential resolved, but this launcher has no credential port wired` };
@@ -7048,7 +7516,7 @@ function decideLaunch(params, readOnly) {
     identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
     globalDefaultConfigProfile: params.globalDefaultConfigProfile
   });
-  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(path36.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(path37.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.`
     );
@@ -7160,7 +7628,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 : path36.join(paths.identitiesDir, identityDecision.name);
+  const configDir = configDirEscapeHatchApplies || identityDecision.name === void 0 ? env.CLAUDE_CONFIG_DIR : path37.join(paths.identitiesDir, identityDecision.name);
   const decision = {
     identitySource: identityDecision.source,
     configDirEscapeHatch: identityDecision.configDirEscapeHatch,
@@ -7201,7 +7669,7 @@ function prepareLaunch(params) {
   );
   const updateCheck = runLaunchUpdateCheck({
     mode: params.updateMode ?? "off",
-    checkPath: path36.join(paths.root, "update.check"),
+    checkPath: path37.join(paths.root, "update.check"),
     currentVersion: package_default.version,
     port: params.update
   });
@@ -7361,12 +7829,12 @@ var init_launcher = __esm({
 });
 
 // src/ownCli.ts
-import path37 from "node:path";
+import path38 from "node:path";
 function agentShimCliPath(distDir = typeof __AGENT_SHIM_DIST_DIR__ === "string" ? __AGENT_SHIM_DIST_DIR__ : void 0) {
   if (distDir === void 0) {
     throw new OwnCliPathUnknownError();
   }
-  return path37.join(distDir, OWN_CLI_FILE_NAME);
+  return path38.join(distDir, OWN_CLI_FILE_NAME);
 }
 var OWN_CLI_FILE_NAME, OwnCliPathUnknownError;
 var init_ownCli = __esm({
@@ -7455,10 +7923,10 @@ request.on("error", (error) => finish(failed, (error.code ? error.code + ": " :
 
 // src/frontdoor/trust.ts
 import { createHash as createHash6 } from "node:crypto";
-import path38 from "node:path";
+import path39 from "node:path";
 function resolveTrustBundle(params) {
   const { caCertFile, bundlesDir, variable, inherited, fs: fs12 } = params;
-  if (inherited === void 0 || inherited === "" || path38.resolve(inherited) === path38.resolve(caCertFile)) {
+  if (inherited === void 0 || inherited === "" || path39.resolve(inherited) === path39.resolve(caCertFile)) {
     return { path: caCertFile };
   }
   const caPem = fs12.readFileUtf8(caCertFile);
@@ -7476,7 +7944,7 @@ function resolveTrustBundle(params) {
   }
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
-  const bundle = path38.join(bundlesDir, `${createHash6("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  const bundle = path39.join(bundlesDir, `${createHash6("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
   if (!fs12.exists(bundle)) {
     fs12.mkdirp(bundlesDir);
     fs12.writeFileAtomic(bundle, combined);
@@ -8337,6 +8805,7 @@ function pumpTapSession(secure, openUpstream, tap, prefix = Buffer.alloc(0)) {
 // src/frontdoor/connect.ts
 init_capability();
 init_route();
+init_state();
 
 // src/frontdoor/supervisor.ts
 init_state();
@@ -8408,9 +8877,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);
@@ -8432,6 +8902,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();
@@ -8495,7 +8966,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;
@@ -8527,7 +8997,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 };
@@ -8535,8 +9005,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",
@@ -9330,11 +9800,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"),
@@ -9724,8 +10194,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 });
@@ -9827,15 +10297,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) {
@@ -10004,11 +10474,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 } }) };
       }
     },
     {
@@ -10318,9 +10788,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 });
     }
@@ -10392,10 +10862,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)}` };
     }
@@ -10426,10 +10896,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}`),
@@ -10588,12 +11058,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
@@ -10658,12 +11128,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,
@@ -10705,9 +11175,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 };
@@ -11651,7 +12121,7 @@ init_schema();
 init_cliError();
 init_load();
 import fs4 from "node:fs";
-import path21 from "node:path";
+import path22 from "node:path";
 var ProfileNotFoundError = class extends CliError {
   constructor(profileName) {
     super(`No configuration profile named "${profileName}". Run \`agent-shim profile add ${profileName}\` first.`);
@@ -11677,7 +12147,7 @@ var InvalidCategoryNameError = class extends CliError {
   categoryName;
 };
 function profileJsonPath(paths, name) {
-  return path21.join(paths.configProfilesDir, `${name}.json`);
+  return path22.join(paths.configProfilesDir, `${name}.json`);
 }
 function profileExists(paths, name) {
   return fs4.existsSync(profileJsonPath(paths, name));
@@ -11859,19 +12329,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;
       }
@@ -11981,7 +12451,7 @@ init_guard();
 init_providersStore();
 init_projects();
 init_pipeline();
-import path25 from "node:path";
+import path26 from "node:path";
 import { z as z15 } from "zod";
 var HISTORY_PROJECTS_KEY_PREFIX = "history/projects/";
 function projectFragmentOf(rawKey) {
@@ -12319,10 +12789,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 : path25.join(paths.identitiesDir, identityDecision.name);
+  const farmRoot = identityDecision.name === void 0 ? void 0 : path26.join(paths.identitiesDir, identityDecision.name);
   const settingsFiles = {
-    "settings.json": realFsPort.readFileUtf8(path25.join(claudeHome, "settings.json")),
-    "settings.local.json": realFsPort.readFileUtf8(path25.join(claudeHome, "settings.local.json"))
+    "settings.json": realFsPort.readFileUtf8(path26.join(claudeHome, "settings.json")),
+    "settings.local.json": realFsPort.readFileUtf8(path26.join(claudeHome, "settings.local.json"))
   };
   const report = runCheck({
     cwd,
@@ -12614,7 +13084,7 @@ var ResetRowSchema = z18.strictObject({
 var ResetScheduleSchema = z18.strictObject({ resets: z18.readonly(z18.array(ResetRowSchema)) });
 
 // src/frontdoor/controlSchemas.ts
-import path30 from "node:path";
+import path31 from "node:path";
 import { z as z23 } from "zod";
 
 // src/doctorReport.ts
@@ -12628,7 +13098,7 @@ init_schema();
 init_cliError();
 init_identity();
 import fs9 from "node:fs";
-import path27 from "node:path";
+import path28 from "node:path";
 init_lock();
 var IdentityNotFoundError = class extends CliError {
   constructor(name) {
@@ -12657,7 +13127,7 @@ var InvalidIdentityNameError = class extends CliError {
   attemptedName;
 };
 function identityJsonPath(paths, name) {
-  return path27.join(paths.identitiesDir, name, "identity.json");
+  return path28.join(paths.identitiesDir, name, "identity.json");
 }
 function requireIdentityNames(paths, names) {
   const existing = new Set(listIdentities(paths).map((entry) => entry.name));
@@ -12772,7 +13242,7 @@ function setIdentityCredential(paths, identityName, change) {
   });
 }
 function belongsToIdentity(entry, name) {
-  return entry === name || entry === path27.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
+  return entry === name || entry === path28.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
 }
 function removeIdentity(paths, name) {
   if (!identityExists(paths, name)) {
@@ -12780,7 +13250,7 @@ function removeIdentity(paths, name) {
   }
   for (const entry of fs9.readdirSync(paths.identitiesDir)) {
     if (belongsToIdentity(entry, name)) {
-      fs9.rmSync(path27.join(paths.identitiesDir, entry), { recursive: true, force: true });
+      fs9.rmSync(path28.join(paths.identitiesDir, entry), { recursive: true, force: true });
     }
   }
   if (readActiveIdentity2(paths) === name) {
@@ -12791,10 +13261,10 @@ function removeIdentity(paths, name) {
 // src/doctorReport.ts
 init_realPorts();
 import fs10 from "node:fs";
-import path29 from "node:path";
+import path30 from "node:path";
 
 // src/usage/signIn.ts
-import path28 from "node:path";
+import path29 from "node:path";
 var CREDENTIALS_FILE = ".credentials.json";
 function keychainHasItem(run, account) {
   return run.run("security", ["find-generic-password", "-a", account]).status === 0;
@@ -12812,7 +13282,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 path28.join(farmRoot, CREDENTIALS_FILE);
+  return path29.join(farmRoot, CREDENTIALS_FILE);
 }
 
 // src/codex/siwcStore.ts
@@ -12901,17 +13371,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;
   }
-  const originIsInput = providers.length > 0 && frontDoorOrigin2 !== void 0;
-  if (!originIsInput) {
-    return ["provider-files"];
+  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;
+  }
+  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
@@ -12920,7 +13448,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;
@@ -12937,6 +13465,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",
@@ -13006,7 +13544,7 @@ function tcpPortEraRecord(raw) {
   return (has("port") || has("lastPort")) && !has("socketPath");
 }
 function pushPathResolution(push, resolution) {
-  const ownDir = path29.dirname(resolution.ownExecutablePath);
+  const ownDir = path30.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");
@@ -13105,14 +13643,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 && path29.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
+  if (legacyVariables.length === 0 && path30.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 (path29.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
+  if (path30.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
     push(
       "legacy-name",
       "warn",
@@ -13368,15 +13906,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}`);
@@ -13392,7 +13926,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.");
@@ -13485,18 +14019,18 @@ function collectDoctorReport(params) {
   const { paths } = params;
   const identityNames = fs10.existsSync(paths.identitiesDir) ? fs10.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isIdentityDirectoryName(entry.name)).map((entry) => entry.name).sort() : [];
   const identities = identityNames.map((name) => {
-    const farmRoot = path29.join(paths.identitiesDir, name);
-    const identityPath = path29.join(farmRoot, "identity.json");
+    const farmRoot = path30.join(paths.identitiesDir, name);
+    const identityPath = path30.join(farmRoot, "identity.json");
     return { name, path: identityPath, raw: realFsPort.readFileUtf8(identityPath), farmRoot, credentialsFilePresent: fs10.existsSync(credentialsFilePath(farmRoot)) };
   });
   const profileNames = fs10.existsSync(paths.configProfilesDir) ? fs10.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 = path29.join(paths.configProfilesDir, `${name}.json`);
+    const profilePath = path30.join(paths.configProfilesDir, `${name}.json`);
     return { name, path: profilePath, raw: realFsPort.readFileUtf8(profilePath) };
   });
   const providerNames = fs10.existsSync(paths.providersDir) ? fs10.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 = path29.join(paths.providersDir, `${name}.json`);
+    const providerPath = path30.join(paths.providersDir, `${name}.json`);
     return { name, path: providerPath, raw: realFsPort.readFileUtf8(providerPath) };
   });
   const ownExecutablePath = realOwnExecutablePath();
@@ -13508,20 +14042,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(path29.delimiter).filter((dir) => dir !== "");
+  const pathDirs = (params.env.PATH ?? "").split(path30.delimiter).filter((dir) => dir !== "");
   const claudeShimShadow = shimState === void 0 ? void 0 : refinePathShadow(
     findPathShadow({
       pathDirs,
-      targetDir: path29.dirname(shimState.targetPath),
-      targetFilename: path29.basename(shimState.targetPath),
+      targetDir: path30.dirname(shimState.targetPath),
+      targetFilename: path30.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),
@@ -13542,7 +14080,7 @@ function collectDoctorReport(params) {
       agentShim: refinePathShadow(
         findPathShadow({
           pathDirs,
-          targetDir: path29.dirname(ownExecutablePath),
+          targetDir: path30.dirname(ownExecutablePath),
           targetFilename: commandFilename(ownExecutablePath, "agent-shim"),
           findExecutableInDir
         }),
@@ -13562,11 +14100,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;
 }
@@ -13621,11 +14168,11 @@ var FrontDoorSessionsOutputSchema = z23.strictObject({ sessions: z23.readonly(z2
 var CheckRunInputSchema = z23.strictObject({
   path: z23.string().min(1),
   identity: z23.string().min(1).optional()
-}).refine((input) => path30.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+}).refine((input) => path31.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
 var PoolPickInputSchema = z23.strictObject({
   pool: z23.string().min(1),
   path: z23.string().min(1)
-}).refine((input) => path30.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+}).refine((input) => path31.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
 var DoctorFindingSchema = z23.strictObject({
   section: z23.enum(DOCTOR_SECTIONS),
   subject: z23.string().optional(),
@@ -14005,7 +14552,7 @@ function profileValue(name, paths) {
 function createConfigApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   const { paths } = deps;
-  const route = (path39, summary) => authed.meta(openapi3({ method: "POST", path: path39, summary, tags: [CONFIG_API_TAG] }));
+  const route = (path40, summary) => authed.meta(openapi3({ method: "POST", path: path40, summary, tags: [CONFIG_API_TAG] }));
   return {
     config: {
       identity: {
@@ -14369,7 +14916,7 @@ import { ORPCError as ORPCError5 } from "@orpc/client";
 import { openapi as openapi6 } from "@orpc/openapi";
 
 // src/frontdoor/launchSchemas.ts
-import path31 from "node:path";
+import path32 from "node:path";
 import { z as z26 } from "zod";
 init_claudeVersion();
 init_identity();
@@ -14379,7 +14926,7 @@ var LaunchResolveInputSchema = z26.strictObject({
   argv: z26.readonly(z26.array(z26.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: z26.record(z26.string(), z26.string()).optional()
-}).refine((input) => path31.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+}).refine((input) => path32.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
 var LaunchPoolDecisionSchema = z26.strictObject({
   name: z26.string(),
   reasons: z26.readonly(z26.array(z26.string())),
@@ -16547,7 +17094,7 @@ data: ${JSON.stringify(envelope)}
 
 // src/frontdoor/rcSelfHostMint.ts
 init_account();
-import path32 from "node:path";
+import path33 from "node:path";
 var CREDENTIALS_FILE2 = ".credentials.json";
 var CLAUDE_JSON2 = ".claude.json";
 var RC_SELF_HOST_RECORD_DIR = "rc-selfhost";
@@ -16571,7 +17118,7 @@ function readJsonObject(fs12, file) {
   return isRecord12(parsed) ? parsed : void 0;
 }
 function readRcSelfHostRecord(fs12, frontdoorDir) {
-  const parsed = readJsonObject(fs12, path32.join(frontdoorDir, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE));
+  const parsed = readJsonObject(fs12, path33.join(frontdoorDir, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE));
   if (parsed === void 0) {
     return void 0;
   }
@@ -16585,11 +17132,11 @@ function mintRcSelfHostCredential(deps) {
   if (!isIdentityName(deps.identity)) {
     throw new Error(`"${deps.identity}" is not a valid identity name.`);
   }
-  const identityDir = path32.join(deps.identitiesDir, deps.identity);
-  const credentialsFile = path32.join(identityDir, CREDENTIALS_FILE2);
-  const claudeJsonFile = path32.join(identityDir, CLAUDE_JSON2);
-  const recordDir = path32.join(deps.frontdoorDir, RC_SELF_HOST_RECORD_DIR);
-  const recordFile = path32.join(recordDir, RC_SELF_HOST_RECORD_FILE);
+  const identityDir = path33.join(deps.identitiesDir, deps.identity);
+  const credentialsFile = path33.join(identityDir, CREDENTIALS_FILE2);
+  const claudeJsonFile = path33.join(identityDir, CLAUDE_JSON2);
+  const recordDir = path33.join(deps.frontdoorDir, RC_SELF_HOST_RECORD_DIR);
+  const recordFile = path33.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;
@@ -16605,7 +17152,7 @@ function mintRcSelfHostCredential(deps) {
   const organizationUuid = deps.newUuid();
   const accountUuid = deps.newUuid();
   const mintedAt = new Date(deps.now()).toISOString();
-  deps.fs.mkdirPrivate(path32.dirname(credentialsFile));
+  deps.fs.mkdirPrivate(path33.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) ?? {};
@@ -16647,7 +17194,7 @@ init_plan2();
 init_poolPick();
 
 // src/agents/read.ts
-import path33 from "node:path";
+import path34 from "node:path";
 import { z as z28 } from "zod";
 var PROJECTS_DIR = "projects";
 var TASKS_DIR = "tasks";
@@ -16673,15 +17220,15 @@ function parseEntry2(project, entry) {
 }
 function listSessions2(fs12, configDir) {
   const found = [];
-  for (const project of fs12.readdir(path33.join(configDir, PROJECTS_DIR))) {
-    const projectDir = path33.join(configDir, PROJECTS_DIR, project);
+  for (const project of fs12.readdir(path34.join(configDir, PROJECTS_DIR))) {
+    const projectDir = path34.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(path33.join(projectDir, name));
+      const children = fs12.readdir(path34.join(projectDir, name));
       if (children.includes(SUBAGENTS_DIR) || children.includes(WORKFLOWS_DIR)) {
         entries.add(name);
       }
@@ -16701,8 +17248,8 @@ function locateAgents(fs12, configDir, relativeDir, workflowRunId, report) {
     const id = name.slice(AGENT_FILE_PREFIX.length, -META_SUFFIX.length);
     located.push({
       id,
-      metaPath: path33.join(relativeDir, name),
-      transcriptPath: path33.join(relativeDir, `${AGENT_FILE_PREFIX}${id}${TRANSCRIPT_SUFFIX}`),
+      metaPath: path34.join(relativeDir, name),
+      transcriptPath: path34.join(relativeDir, `${AGENT_FILE_PREFIX}${id}${TRANSCRIPT_SUFFIX}`),
       workflowRunId
     });
   }
@@ -16745,7 +17292,7 @@ function describeFailure(error) {
 }
 function readFileOrReport(fs12, configDir, relative, report) {
   try {
-    return fs12.readFileUtf8(path33.join(configDir, relative));
+    return fs12.readFileUtf8(path34.join(configDir, relative));
   } catch (error) {
     report({ path: relative, reason: `could not be read: ${describeFailure(error)}` });
     return void 0;
@@ -16753,7 +17300,7 @@ function readFileOrReport(fs12, configDir, relative, report) {
 }
 function listDirOrReport(fs12, configDir, relative, report) {
   try {
-    return fs12.readdir(path33.join(configDir, relative));
+    return fs12.readdir(path34.join(configDir, relative));
   } catch (error) {
     report({ path: relative, reason: `could not be listed: ${describeFailure(error)}` });
     return [];
@@ -16777,18 +17324,18 @@ var WorkflowRunFileSchema = z28.object({
   summary: z28.string().optional()
 });
 function summariseSession(fs12, configDir, ref) {
-  const sessionRelative = path33.join(PROJECTS_DIR, ref.project, ref.entry);
-  const subagentsRelative = path33.join(sessionRelative, SUBAGENTS_DIR);
-  const workflowsUnderSubagents = path33.join(subagentsRelative, WORKFLOWS_DIR);
+  const sessionRelative = path34.join(PROJECTS_DIR, ref.project, ref.entry);
+  const subagentsRelative = path34.join(sessionRelative, SUBAGENTS_DIR);
+  const workflowsUnderSubagents = path34.join(subagentsRelative, WORKFLOWS_DIR);
   const isMeta = (name) => name.startsWith(AGENT_FILE_PREFIX) && name.endsWith(META_SUFFIX);
-  let agentCount = fs12.readdir(path33.join(configDir, subagentsRelative)).filter(isMeta).length;
-  for (const runDir of fs12.readdir(path33.join(configDir, workflowsUnderSubagents))) {
+  let agentCount = fs12.readdir(path34.join(configDir, subagentsRelative)).filter(isMeta).length;
+  for (const runDir of fs12.readdir(path34.join(configDir, workflowsUnderSubagents))) {
     if (runDir.startsWith(WORKFLOW_RUN_PREFIX)) {
-      agentCount += fs12.readdir(path33.join(configDir, workflowsUnderSubagents, runDir)).filter(isMeta).length;
+      agentCount += fs12.readdir(path34.join(configDir, workflowsUnderSubagents, runDir)).filter(isMeta).length;
     }
   }
-  const workflowRunCount = fs12.readdir(path33.join(configDir, sessionRelative, WORKFLOWS_DIR)).filter((name) => name.startsWith(WORKFLOW_RUN_PREFIX) && name.endsWith(JSON_SUFFIX)).length;
-  const transcript = fs12.lstat(path33.join(configDir, PROJECTS_DIR, ref.project, `${ref.entry}${TRANSCRIPT_SUFFIX}`));
+  const workflowRunCount = fs12.readdir(path34.join(configDir, sessionRelative, WORKFLOWS_DIR)).filter((name) => name.startsWith(WORKFLOW_RUN_PREFIX) && name.endsWith(JSON_SUFFIX)).length;
+  const transcript = fs12.lstat(path34.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 = {}) {
@@ -16796,13 +17343,13 @@ function readSessionAgentTree(fs12, configDir, ref, options = {}) {
   const report = (problem) => {
     problems.push(problem);
   };
-  const sessionRelative = path33.join(PROJECTS_DIR, ref.project, ref.entry);
-  const subagentsRelative = path33.join(sessionRelative, SUBAGENTS_DIR);
-  const workflowsUnderSubagents = path33.join(subagentsRelative, WORKFLOWS_DIR);
+  const sessionRelative = path34.join(PROJECTS_DIR, ref.project, ref.entry);
+  const subagentsRelative = path34.join(sessionRelative, SUBAGENTS_DIR);
+  const workflowsUnderSubagents = path34.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, path33.join(workflowsUnderSubagents, runDir), runDir, report));
+      located.push(...locateAgents(fs12, configDir, path34.join(workflowsUnderSubagents, runDir), runDir, report));
     }
   }
   const agents = /* @__PURE__ */ new Map();
@@ -16843,7 +17390,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, path33.join(sessionRelative, WORKFLOWS_DIR), report),
+    workflowRuns: readWorkflowRuns(fs12, configDir, path34.join(sessionRelative, WORKFLOWS_DIR), report),
     problems
   };
 }
@@ -16908,12 +17455,12 @@ function ownTaskLists(sessionId) {
 function readTasks(fs12, configDir, ownLists, sharedLists, report) {
   const tasks = [];
   [...ownLists, ...sharedLists].forEach((scope, index) => {
-    const relativeDir = path33.join(TASKS_DIR, scope);
+    const relativeDir = path34.join(TASKS_DIR, scope);
     for (const name of [...listDirOrReport(fs12, configDir, relativeDir, report)].sort()) {
       if (name.startsWith(".") || !name.endsWith(JSON_SUFFIX)) {
         continue;
       }
-      const relative = path33.join(relativeDir, name);
+      const relative = path34.join(relativeDir, name);
       const text = readFileOrReport(fs12, configDir, relative, report);
       const parsed = TaskFileSchema.safeParse(text === void 0 ? void 0 : parseJson2(text));
       if (parsed.success) {
@@ -16931,7 +17478,7 @@ function readWorkflowRuns(fs12, configDir, relativeDir, report) {
     if (!name.startsWith(WORKFLOW_RUN_PREFIX) || !name.endsWith(JSON_SUFFIX)) {
       continue;
     }
-    const relative = path33.join(relativeDir, name);
+    const relative = path34.join(relativeDir, name);
     const text = readFileOrReport(fs12, configDir, relative, report);
     const parsed = WorkflowRunFileSchema.safeParse(text === void 0 ? void 0 : parseJson2(text));
     if (!parsed.success) {
@@ -16948,7 +17495,7 @@ function readWorkflowRuns(fs12, configDir, relativeDir, report) {
 
 // src/agents/sessions.ts
 init_cliError();
-import path34 from "node:path";
+import path35 from "node:path";
 var SessionLookupError = class extends CliError {
   constructor(message) {
     super(message);
@@ -16956,13 +17503,13 @@ var SessionLookupError = class extends CliError {
   }
 };
 function identityConfigDir(identitiesDir, identity) {
-  return path34.join(identitiesDir, identity);
+  return path35.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(path34.join(configDir, "projects"));
+    const real = fs12.realpath(path35.join(configDir, "projects"));
     if (real === void 0) {
       continue;
     }
@@ -17414,6 +17961,7 @@ export {
   isRcReadFileEncoding,
   lateRcEventDial,
   lateRcStreamDial,
+  launchRequiredUpstreams,
   listDirectoryRules,
   listIdentities,
   listProfiles,