agent-shim 7.12.0 → 7.13.0

package/dist/index.mjs

@@ -1626,8 +1626,8 @@ var FarmManifestSchema = z2.strictObject({
   materialised: z2.array(z2.string()),
   links: z2.array(z2.strictObject({ rel: z2.string(), target: z2.string() }))
 });
-function readFarmManifest(fs10, farmRoot) {
-  const raw = fs10.readFileUtf8(path6.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs10.readFileUtf8(path6.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
+function readFarmManifest(fs12, farmRoot) {
+  const raw = fs12.readFileUtf8(path6.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs12.readFileUtf8(path6.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
   if (raw === void 0) {
     return void 0;
   }
@@ -1685,9 +1685,9 @@ function buildEntryFacts(params) {
     entries
   };
 }
-function listSubtree(fs10, root, rel) {
+function listSubtree(fs12, root, rel) {
   const absolute = path6.join(root, rel);
-  const stat = fs10.lstat(absolute);
+  const stat = fs12.lstat(absolute);
   if (stat === void 0) {
     return [];
   }
@@ -1695,10 +1695,10 @@ function listSubtree(fs10, root, rel) {
     return [{ rel, kind: "symlink" }];
   }
   if (stat.kind === "dir") {
-    const children = [...fs10.readdir(absolute)].sort().flatMap((name) => listSubtree(fs10, root, `${rel}/${name}`));
+    const children = [...fs12.readdir(absolute)].sort().flatMap((name) => listSubtree(fs12, root, `${rel}/${name}`));
     return [{ rel, kind: "dir" }, ...children];
   }
-  const contentHash = fs10.hashFile(absolute);
+  const contentHash = fs12.hashFile(absolute);
   return [{ rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } }];
 }
 function topLevelScopeRoots(roots) {
@@ -1712,25 +1712,25 @@ function topLevelScopeRoots(roots) {
   }
   return kept;
 }
-function reconciliationScope(fs10, farmRoot, manifest) {
+function reconciliationScope(fs12, farmRoot, manifest) {
   if (manifest !== void 0) {
     return topLevelScopeRoots(manifest.materialised);
   }
-  return [...fs10.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs10.lstat(path6.join(farmRoot, name))?.kind === "dir").sort();
+  return [...fs12.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs12.lstat(path6.join(farmRoot, name))?.kind === "dir").sort();
 }
-function collectFarmListing(fs10, farmRoot, scopeRoots) {
-  return scopeRoots.flatMap((root) => listSubtree(fs10, farmRoot, root));
+function collectFarmListing(fs12, farmRoot, scopeRoots) {
+  return scopeRoots.flatMap((root) => listSubtree(fs12, farmRoot, root));
 }
-function collectCanonicalCounterparts(fs10, claudeHome, farmListing) {
+function collectCanonicalCounterparts(fs12, claudeHome, farmListing) {
   const out = [];
   for (const entry of farmListing) {
     const absolute = path6.join(claudeHome, entry.rel);
-    const stat = fs10.lstat(absolute);
+    const stat = fs12.lstat(absolute);
     if (stat === void 0) {
       continue;
     }
     if (stat.kind === "file") {
-      const contentHash = fs10.hashFile(absolute);
+      const contentHash = fs12.hashFile(absolute);
       out.push({ rel: entry.rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } });
       continue;
     }
@@ -2414,8 +2414,12 @@ function pumpTapSession(secure, openUpstream, tap, prefix = Buffer.alloc(0)) {
 }
 
 // src/frontdoor/capability.ts
+var CONNECT_PROXY_USER = "agent-shim";
 var CONNECT_PROXY_REALM = "agent-shim front door";
 var BASIC_SCHEME = "basic";
+function connectProxyUrl(port, token) {
+  return `http://${encodeURIComponent(CONNECT_PROXY_USER)}:${encodeURIComponent(token)}@127.0.0.1:${String(port)}`;
+}
 function capabilityFromProxyAuthorization(value) {
   const trimmed = value.trim();
   const space = trimmed.indexOf(" ");
@@ -2432,7 +2436,15 @@ function capabilityFromProxyAuthorization(value) {
 }
 
 // src/frontdoor/route.ts
+var IDENTITY_HEADER = "x-agent-shim-identity";
+var SESSION_HEADER = "x-agent-shim-session";
+var HEADROOM_FLAG_HEADER = "x-agent-shim-headroom";
+var PROJECT_ID_HEADER = "x-headroom-project-id";
 var AUTH_HEADER = "x-agent-shim-auth";
+var PROVIDER_PATH_PREFIX = "/providers/";
+function providerBaseUrl(port, provider) {
+  return `https://127.0.0.1:${String(port)}${PROVIDER_PATH_PREFIX}${encodeURIComponent(provider)}`;
+}
 
 // src/frontdoor/state.ts
 import path7 from "node:path";
@@ -2469,10 +2481,10 @@ var FrontDoorStateSchema = z3.strictObject({
   /** The last fatal error, kept across shutdowns so `frontdoor status` can explain a front door that is not running. */
   lastError: z3.string().optional()
 });
-function readFrontDoorState(fs10, stateFile) {
+function readFrontDoorState(fs12, stateFile) {
   let raw;
   try {
-    raw = fs10.readFileUtf8(stateFile);
+    raw = fs12.readFileUtf8(stateFile);
   } catch {
     return void 0;
   }
@@ -2486,28 +2498,28 @@ function readFrontDoorState(fs10, stateFile) {
     return void 0;
   }
 }
-function writeFrontDoorState(fs10, stateFile, state) {
-  fs10.mkdirp(path7.dirname(stateFile));
-  fs10.writeFileUtf8(stateFile, `${JSON.stringify(state, null, 2)}
+function writeFrontDoorState(fs12, stateFile, state) {
+  fs12.mkdirp(path7.dirname(stateFile));
+  fs12.writeFileUtf8(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
 function frontDoorOrigin(state) {
   const port = state?.directPort ?? state?.lastDirectPort;
   return port === void 0 ? void 0 : `http://127.0.0.1:${String(port)}`;
 }
-function writeFrontDoorSession(fs10, sessionsDir, session) {
-  fs10.mkdirPrivate(sessionsDir);
-  fs10.writeFilePrivate(path7.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeFrontDoorSession(fs12, sessionsDir, session) {
+  fs12.mkdirPrivate(sessionsDir);
+  fs12.writeFilePrivate(path7.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function listFrontDoorSessions(fs10, sessionsDir) {
+function listFrontDoorSessions(fs12, sessionsDir) {
   const sessions = [];
-  for (const name of fs10.readdir(sessionsDir)) {
+  for (const name of fs12.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs10.readFileUtf8(path7.join(sessionsDir, name)) ?? ""));
+      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs12.readFileUtf8(path7.join(sessionsDir, name)) ?? ""));
       if (parsed.success) {
         sessions.push({ pid: parsed.data.pid, startedAt: parsed.data.startedAt });
       }
@@ -2517,14 +2529,14 @@ function listFrontDoorSessions(fs10, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
-function removeFrontDoorSession(fs10, sessionsDir, pid) {
-  fs10.removeRecursive(path7.join(sessionsDir, `${String(pid)}.json`));
+function removeFrontDoorSession(fs12, sessionsDir, pid) {
+  fs12.removeRecursive(path7.join(sessionsDir, `${String(pid)}.json`));
 }
-function pruneDeadFrontDoorSessions(fs10, sessionsDir, isRunning) {
+function pruneDeadFrontDoorSessions(fs12, sessionsDir, isRunning) {
   const removed = [];
-  for (const session of listFrontDoorSessions(fs10, sessionsDir)) {
+  for (const session of listFrontDoorSessions(fs12, sessionsDir)) {
     if (!isRunning(session.pid)) {
-      removeFrontDoorSession(fs10, sessionsDir, session.pid);
+      removeFrontDoorSession(fs12, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
@@ -2536,8 +2548,8 @@ var FRONTDOOR_SUPERVISOR_STILL_RUNNING = -1;
 var FRONTDOOR_POLL_MS = 1e3;
 var MS_PER_MINUTE = 6e4;
 async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {}) {
-  const { fs: fs10, paths } = ports;
-  const previous = readFrontDoorState(fs10, paths.frontdoorStateFile);
+  const { fs: fs12, paths } = ports;
+  const previous = readFrontDoorState(fs12, paths.frontdoorStateFile);
   let lastPort = previous?.lastPort;
   let lastConnectPort = previous?.lastConnectPort;
   let lastDirectPort = previous?.lastDirectPort;
@@ -2547,12 +2559,12 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     ...lastDirectPort === void 0 ? {} : { lastDirectPort }
   });
   const fail = (message) => {
-    writeFrontDoorState(fs10, paths.frontdoorStateFile, { lastError: message, ...sticky() });
-    fs10.removeRecursive(paths.frontdoorLockFile);
+    writeFrontDoorState(fs12, paths.frontdoorStateFile, { lastError: message, ...sticky() });
+    fs12.removeRecursive(paths.frontdoorLockFile);
     ports.log(`agent-shim frontdoor supervisor: ${message}`);
     return 1;
   };
-  writeFrontDoorState(fs10, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
+  writeFrontDoorState(fs12, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
   const previousSticky = lastPort;
   let http2;
   try {
@@ -2589,8 +2601,8 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     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)`);
   }
   lastDirectPort = direct.port;
-  writeFrontDoorState(fs10, paths.frontdoorStateFile, { protocol: FRONT_DOOR_PROTOCOL, supervisorPid: ports.ownPid, port: http2.port, connectPort: connect3.port, directPort: direct.port, ...sticky() });
-  fs10.removeRecursive(paths.frontdoorLockFile);
+  writeFrontDoorState(fs12, paths.frontdoorStateFile, { protocol: FRONT_DOOR_PROTOCOL, supervisorPid: ports.ownPid, port: http2.port, connectPort: connect3.port, directPort: direct.port, ...sticky() });
+  fs12.removeRecursive(paths.frontdoorLockFile);
   ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: front door on 127.0.0.1:${String(http2.port)}, CONNECT surface on 127.0.0.1:${String(connect3.port)}`);
   let idleSince;
   let ticks = 0;
@@ -2599,15 +2611,15 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
       return FRONTDOOR_SUPERVISOR_STILL_RUNNING;
     }
     ticks += 1;
-    pruneDeadFrontDoorSessions(fs10, paths.frontdoorSessionsDir, ports.isRunning);
-    if (listFrontDoorSessions(fs10, paths.frontdoorSessionsDir).length === 0) {
+    pruneDeadFrontDoorSessions(fs12, paths.frontdoorSessionsDir, ports.isRunning);
+    if (listFrontDoorSessions(fs12, paths.frontdoorSessionsDir).length === 0) {
       idleSince ??= ports.now();
       if (ports.now() - idleSince >= idleShutdownMinutes * MS_PER_MINUTE) {
         ports.log(`agent-shim frontdoor supervisor: no sessions for ${String(idleShutdownMinutes)} minute(s); closing the front door and exiting`);
         await direct.close();
         await connect3.close();
         await http2.close();
-        writeFrontDoorState(fs10, paths.frontdoorStateFile, sticky());
+        writeFrontDoorState(fs12, paths.frontdoorStateFile, sticky());
         return 0;
       }
     } else {
@@ -2662,8 +2674,8 @@ function parseConnectTarget(authority) {
 function isInterceptedHost(host, interceptHosts) {
   return interceptHosts.includes(host);
 }
-function servedByPipeline(path23) {
-  return path23?.startsWith(ROUTED_PATH_PREFIX) === true;
+function servedByPipeline(path28) {
+  return path28?.startsWith(ROUTED_PATH_PREFIX) === true;
 }
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
@@ -3197,16 +3209,16 @@ function parseJson(raw, schema) {
   const parsed = schema.safeParse(JSON.parse(raw));
   return parsed.success ? parsed.data : void 0;
 }
-function readHeadroomState(fs10, stateFile) {
+function readHeadroomState(fs12, stateFile) {
   try {
-    return parseJson(fs10.readFileUtf8(stateFile), HeadroomStateSchema);
+    return parseJson(fs12.readFileUtf8(stateFile), HeadroomStateSchema);
   } catch {
     return void 0;
   }
 }
-function writeHeadroomState(fs10, stateFile, state) {
-  fs10.mkdirp(path8.dirname(stateFile));
-  fs10.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
+function writeHeadroomState(fs12, stateFile, state) {
+  fs12.mkdirp(path8.dirname(stateFile));
+  fs12.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
 function headroomAllowlist(providers) {
@@ -3226,14 +3238,14 @@ function headroomUpstreams(providers, frontDoorOrigin2) {
 function hashAllowlist(allowlist) {
   return createHash2("sha256").update(allowlist.join("\n")).digest("hex");
 }
-function readAllProviders(fs10, providersDir) {
+function readAllProviders(fs12, providersDir) {
   const result = [];
-  for (const name of fs10.readdir(providersDir)) {
+  for (const name of fs12.readdir(providersDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs10.readFileUtf8(path8.join(providersDir, name)), ProviderSchema);
+      const parsed = parseJson(fs12.readFileUtf8(path8.join(providersDir, name)), ProviderSchema);
       if (parsed !== void 0) {
         result.push({ name: name.slice(0, -".json".length), provider: parsed });
       }
@@ -3243,22 +3255,22 @@ function readAllProviders(fs10, providersDir) {
   }
   return result;
 }
-function writeSession(fs10, sessionsDir, session) {
-  fs10.mkdirp(sessionsDir);
-  fs10.writeFileUtf8(path8.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeSession(fs12, sessionsDir, session) {
+  fs12.mkdirp(sessionsDir);
+  fs12.writeFileUtf8(path8.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function removeSession(fs10, sessionsDir, pid) {
-  fs10.removeRecursive(path8.join(sessionsDir, `${String(pid)}.json`));
+function removeSession(fs12, sessionsDir, pid) {
+  fs12.removeRecursive(path8.join(sessionsDir, `${String(pid)}.json`));
 }
-function listSessions(fs10, sessionsDir) {
+function listSessions(fs12, sessionsDir) {
   const sessions = [];
-  for (const name of fs10.readdir(sessionsDir)) {
+  for (const name of fs12.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs10.readFileUtf8(path8.join(sessionsDir, name)), HeadroomSessionSchema);
+      const parsed = parseJson(fs12.readFileUtf8(path8.join(sessionsDir, name)), HeadroomSessionSchema);
       if (parsed !== void 0) {
         sessions.push(parsed);
       }
@@ -3268,22 +3280,22 @@ function listSessions(fs10, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
-function sessionsForSupervisor(fs10, sessionsDir, supervisorPid) {
-  return listSessions(fs10, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
+function sessionsForSupervisor(fs12, sessionsDir, supervisorPid) {
+  return listSessions(fs12, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
 }
-function pruneDeadSessions(fs10, sessionsDir, isRunning) {
+function pruneDeadSessions(fs12, sessionsDir, isRunning) {
   const removed = [];
-  for (const session of listSessions(fs10, sessionsDir)) {
+  for (const session of listSessions(fs12, sessionsDir)) {
     if (!isRunning(session.pid)) {
-      removeSession(fs10, sessionsDir, session.pid);
+      removeSession(fs12, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
   return removed;
 }
-function readStartLock(fs10, lockFile) {
+function readStartLock(fs12, lockFile) {
   try {
-    return parseJson(fs10.readFileUtf8(lockFile), HeadroomLockSchema);
+    return parseJson(fs12.readFileUtf8(lockFile), HeadroomLockSchema);
   } catch {
     return void 0;
   }
@@ -3534,12 +3546,12 @@ function isIdentityName(name) {
 function claudeJsonPath(identitiesDir, identity) {
   return path9.join(identitiesDir, identity, CLAUDE_JSON);
 }
-function readAccountMetadata(fs10, identitiesDir, identity) {
+function readAccountMetadata(fs12, identitiesDir, identity) {
   if (!isIdentityName(identity)) {
     throw new Error(`"${identity}" is not a valid identity name.`);
   }
   const file = claudeJsonPath(identitiesDir, identity);
-  const raw = fs10.readFileUtf8(file);
+  const raw = fs12.readFileUtf8(file);
   if (raw === void 0) {
     return void 0;
   }
@@ -3573,8 +3585,8 @@ function readAccountMetadata(fs10, identitiesDir, identity) {
 // src/usage/read.ts
 var SEGMENT_RE = /^(\d{4}-\d{2}-\d{2})\.(\d+)\.jsonl$/;
 var DAY_MS = 864e5;
-function listLogSegments(fs10, logDir) {
-  return fs10.readdir(logDir).flatMap((name) => {
+function listLogSegments(fs12, logDir) {
+  return fs12.readdir(logDir).flatMap((name) => {
     const match = SEGMENT_RE.exec(name);
     const day = match?.[1];
     if (day === void 0) {
@@ -3583,15 +3595,15 @@ function listLogSegments(fs10, logDir) {
     return [{ name, day, endsAt: Date.parse(`${day}T00:00:00.000Z`) + DAY_MS }];
   }).sort((left, right) => left.day.localeCompare(right.day) || left.name.localeCompare(right.name));
 }
-function readUsageLog(fs10, logDir, options = {}) {
+function readUsageLog(fs12, logDir, options = {}) {
   const { sinceMs } = options;
   const records = [];
   let invalidLines = 0;
-  for (const segment of listLogSegments(fs10, logDir)) {
+  for (const segment of listLogSegments(fs12, logDir)) {
     if (sinceMs !== void 0 && segment.endsAt <= sinceMs) {
       continue;
     }
-    const contents = fs10.readFileUtf8(path10.join(logDir, segment.name));
+    const contents = fs12.readFileUtf8(path10.join(logDir, segment.name));
     if (contents === void 0) {
       continue;
     }
@@ -3635,9 +3647,9 @@ function snapshotPath(snapshotsDir, identity) {
   }
   return path10.join(snapshotsDir, `${identity}.json`);
 }
-function readUsageSnapshot(fs10, snapshotsDir, identity) {
+function readUsageSnapshot(fs12, snapshotsDir, identity) {
   const file = snapshotPath(snapshotsDir, identity);
-  const raw = fs10.readFileUtf8(file);
+  const raw = fs12.readFileUtf8(file);
   if (raw === void 0) {
     return void 0;
   }
@@ -3653,8 +3665,8 @@ function readUsageSnapshot(fs10, snapshotsDir, identity) {
   }
   return snapshot.data;
 }
-function listUsageSnapshots(fs10, snapshotsDir) {
-  return fs10.readdir(snapshotsDir).flatMap((name) => {
+function listUsageSnapshots(fs12, snapshotsDir) {
+  return fs12.readdir(snapshotsDir).flatMap((name) => {
     if (!name.endsWith(".json")) {
       return [];
     }
@@ -3662,7 +3674,7 @@ function listUsageSnapshots(fs10, snapshotsDir) {
     if (!isIdentityName(identity)) {
       return [];
     }
-    const snapshot = readUsageSnapshot(fs10, snapshotsDir, identity);
+    const snapshot = readUsageSnapshot(fs12, snapshotsDir, identity);
     return snapshot === void 0 ? [] : [snapshot];
   }).sort((left, right) => left.identity.localeCompare(right.identity));
 }
@@ -3837,9 +3849,9 @@ function compareVersions(a, b) {
 }
 var HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
 async function runSupervisor(initialConfig, ports, options = {}) {
-  const { fs: fs10, paths } = ports;
+  const { fs: fs12, paths } = ports;
   let config = initialConfig;
-  const previousState = readHeadroomState(fs10, paths.headroomStateFile);
+  const previousState = readHeadroomState(fs12, paths.headroomStateFile);
   if (previousState?.supervisorPid !== void 0 && previousState.supervisorPid !== ports.ownPid && ports.isRunning(previousState.supervisorPid)) {
     ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: supervisor ${String(previousState.supervisorPid)} already owns the daemon; exiting`);
     return 0;
@@ -3848,19 +3860,19 @@ async function runSupervisor(initialConfig, ports, options = {}) {
   let lastPort = previousState?.lastPort;
   const sticky = () => lastPort === void 0 ? {} : { lastPort };
   const ownsState = () => {
-    const owner = readHeadroomState(fs10, paths.headroomStateFile)?.supervisorPid;
+    const owner = readHeadroomState(fs12, paths.headroomStateFile)?.supervisorPid;
     return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
   };
   const writeOwnState = (state) => {
     if (!ownsState()) {
       return false;
     }
-    writeHeadroomState(fs10, paths.headroomStateFile, state);
+    writeHeadroomState(fs12, paths.headroomStateFile, state);
     return true;
   };
   const fail = (message) => {
     if (writeOwnState({ lastError: message, ...sticky() })) {
-      fs10.removeRecursive(paths.headroomLockFile);
+      fs12.removeRecursive(paths.headroomLockFile);
     }
     ports.log(`agent-shim headroom supervisor: ${message}`);
     return 1;
@@ -3909,7 +3921,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     const settingsHash = hashSettings(config.settings);
     const allowlist = allowlistOf(ports);
     const allowlistHash = hashAllowlist(allowlist);
-    pruneDeadSessions(fs10, paths.headroomSessionsDir, ports.isRunning);
+    pruneDeadSessions(fs12, paths.headroomSessionsDir, ports.isRunning);
     const ownsNow = ownsState();
     if (!ownsNow && !superseded) {
       ports.log("agent-shim headroom supervisor: another supervisor now owns state.json; serving this daemon's own sessions until they end");
@@ -3961,7 +3973,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           ...sticky()
         });
         if (recorded) {
-          fs10.removeRecursive(paths.headroomLockFile);
+          fs12.removeRecursive(paths.headroomLockFile);
         }
         idleSince = void 0;
         ports.log(`agent-shim headroom supervisor: headroom pid ${String(pid)} ready on 127.0.0.1:${String(port)}`);
@@ -3976,7 +3988,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
       }
     } else {
       if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config.source) {
-        if (sessionsForSupervisor(fs10, paths.headroomSessionsDir, ports.ownPid).length === 0) {
+        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);
           headroomPid = void 0;
@@ -3985,7 +3997,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           continue;
         }
       }
-      const sessions = sessionsForSupervisor(fs10, paths.headroomSessionsDir, ports.ownPid);
+      const sessions = sessionsForSupervisor(fs12, paths.headroomSessionsDir, ports.ownPid);
       if (sessions.length === 0) {
         idleSince ??= ports.now();
         const idleMs = ports.now() - idleSince;
@@ -4007,9 +4019,9 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     await ports.sleep(HEADROOM_POLL_MS);
   }
 }
-function currentHeadroomAllowlist(fs10, paths) {
-  const providers = readAllProviders(fs10, paths.providersDir).map((entry) => entry.provider);
-  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs10, paths.frontdoorStateFile))));
+function currentHeadroomAllowlist(fs12, paths) {
+  const providers = readAllProviders(fs12, paths.providersDir).map((entry) => entry.provider);
+  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs12, paths.frontdoorStateFile))));
 }
 function allowlistOf(ports) {
   return currentHeadroomAllowlist(ports.fs, ports.paths);
@@ -4186,8 +4198,8 @@ function decideConfigProfile(params) {
   }
   return { source: "none" };
 }
-function loadIdentity(identitiesDir, name, fs10) {
-  return loadConfigFile(path12.join(identitiesDir, name, "identity.json"), IdentitySchema, fs10.readConfigFile);
+function loadIdentity(identitiesDir, name, fs12) {
+  return loadConfigFile(path12.join(identitiesDir, name, "identity.json"), IdentitySchema, fs12.readConfigFile);
 }
 
 // src/configProfilesStore.ts
@@ -4529,13 +4541,59 @@ import path15 from "node:path";
 
 // src/credentialCache.ts
 import { z as z7 } from "zod";
+var MS_PER_UNIT = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
 var CachedCredentialSchema = z7.strictObject({
   token: z7.string().min(1),
   fetchedAt: z7.number().int().nonnegative(),
   source: CredentialSourceSchema
 });
+function effectiveStore(cache, platform) {
+  return cache.store ?? (platform === "darwin" ? "keychain" : "file");
+}
+function ttlMs(cache) {
+  if (cache.ttl === void 0) {
+    return void 0;
+  }
+  const multiplier = MS_PER_UNIT[cache.ttl.slice(-1)];
+  if (multiplier === void 0) {
+    throw new Error(`credential cache ttl "${cache.ttl}" has no recognised unit`);
+  }
+  return Number(cache.ttl.slice(0, -1)) * multiplier;
+}
+function isFresh(entry, cache, now) {
+  const limit = ttlMs(cache);
+  if (entry.fetchedAt > now) {
+    return false;
+  }
+  return limit === void 0 || now - entry.fetchedAt < limit;
+}
 
 // src/credential.ts
+var CREDENTIAL_UNAVAILABLE_EXIT = 64;
+var CREDENTIAL_COMMAND_TIMEOUT_MS = 1e4;
+var CREDENTIAL_INTERACTIVE_TIMEOUT_MS = 12e4;
+var GROUP_OTHER_PERMISSION_BITS = 63;
+var PERMISSION_BITS = 511;
+var OCTAL_RADIX = 8;
+function commandArgv(source) {
+  if ("command" in source) {
+    return source.command;
+  }
+  if ("op" in source) {
+    return ["op", "read", source.op];
+  }
+  const account = source.keychain.account;
+  return ["security", "find-generic-password", "-s", source.keychain.service, ...account === void 0 ? [] : ["-a", account], "-w"];
+}
+function isInteractiveSource(source, env) {
+  if ("command" in source || "keychain" in source) {
+    return source.interactive ?? false;
+  }
+  if ("op" in source) {
+    return source.interactive ?? (env.OP_SERVICE_ACCOUNT_TOKEN ?? "") === "";
+  }
+  return false;
+}
 function summariseSource(source) {
   if ("env" in source) {
     return { kind: "env", variable: source.env };
@@ -4583,6 +4641,9 @@ function formatSourceSummary(summary) {
       return summary;
   }
 }
+function describeSource(source) {
+  return formatSourceSummary(summariseSource(source));
+}
 function formatCredentialSummary(summary) {
   const cache = summary.cache === void 0 ? "" : `, cached ${summary.cache.ttl === void 0 ? "with no expiry" : `for ${summary.cache.ttl}`}${summary.cache.store === void 0 ? "" : ` in the ${summary.cache.store} store`}`;
   return `${summary.target} from ${summary.sources.map(formatSourceSummary).join(", then ")}${cache}`;
@@ -4590,6 +4651,88 @@ function formatCredentialSummary(summary) {
 function describeCredential(credential) {
   return formatCredentialSummary(summariseCredential(credential));
 }
+function trySource(source, params) {
+  const none = (reason, warn = false) => ({ ok: false, reason, warn });
+  if ("env" in source) {
+    const value = params.env[source.env];
+    return value === void 0 || value === "" ? none("is unset or empty") : { ok: true, token: value };
+  }
+  if ("literal" in source) {
+    return { ok: true, token: source.literal };
+  }
+  if ("file" in source) {
+    const read = params.port.readSecretFile(source.file);
+    if (!read.found) {
+      return none("does not exist");
+    }
+    if (read.mode !== void 0 && (read.mode & GROUP_OTHER_PERMISSION_BITS) !== 0) {
+      return none(
+        `is readable or writable by group or others (mode ${(read.mode & PERMISSION_BITS).toString(OCTAL_RADIX)}); run \`chmod 600 ${source.file}\``,
+        true
+      );
+    }
+    const token2 = read.content.trim();
+    return token2 === "" ? none("is empty") : { ok: true, token: token2 };
+  }
+  const argv = commandArgv(source);
+  const interactive = isInteractiveSource(source, params.env);
+  if (interactive && !params.port.personPresent()) {
+    return none("needs a person to approve it, but there is no terminal or desktop session");
+  }
+  const timeoutMs = source.timeoutMs ?? (interactive ? CREDENTIAL_INTERACTIVE_TIMEOUT_MS : CREDENTIAL_COMMAND_TIMEOUT_MS);
+  const result = params.port.runCommand(argv, { timeoutMs, interactive });
+  if (result.timedOut) {
+    return none(`timed out after ${String(timeoutMs)}ms`);
+  }
+  if (result.status !== 0) {
+    const stderr = result.stderr.trim();
+    const outcome = result.status === null ? "could not be run or was killed by a signal" : `exited with status ${String(result.status)}`;
+    return none(`${outcome}${stderr === "" ? "" : `: ${stderr}`}`);
+  }
+  const token = result.stdout.trim();
+  return token === "" ? none("printed no token") : { ok: true, token };
+}
+function warmCommandFor(subject) {
+  const [kind, name] = subject.split(" ");
+  return kind === "provider" ? `agent-shim credential warm --provider ${name ?? ""}` : `agent-shim credential warm ${name ?? ""}`;
+}
+function resolveCredential(params) {
+  const target = params.credential.target ?? "bearer";
+  const cacheBlock = params.credential.cache;
+  const cache = cacheBlock === void 0 ? void 0 : params.port.cache;
+  const store = cacheBlock === void 0 || cache === void 0 ? void 0 : effectiveStore(cacheBlock, cache.platform);
+  if (cacheBlock !== void 0 && cache !== void 0 && store !== void 0 && params.refresh !== true) {
+    const entry = cache.port.read(store, params.subject);
+    if (entry !== void 0 && isFresh(entry, cacheBlock, cache.now())) {
+      return { ok: true, credential: { target, token: entry.token, source: entry.source, warnings: [], cachedAt: entry.fetchedAt } };
+    }
+  }
+  const attempts = [];
+  const warnings = [];
+  for (const source of params.credential.sources) {
+    const outcome = trySource(source, params);
+    if (outcome.ok) {
+      if (cache !== void 0 && store !== void 0) {
+        cache.port.write(store, params.subject, { token: outcome.token, fetchedAt: cache.now(), source });
+      }
+      return { ok: true, credential: { target, token: outcome.token, source, warnings } };
+    }
+    const line = `${describeSource(source)} ${outcome.reason}`;
+    attempts.push(line);
+    if (outcome.warn) {
+      warnings.push(`agent-shim: ${params.subject}: skipped ${line}`);
+    }
+  }
+  const hint = cacheBlock === void 0 ? "" : `; fill the cache from a terminal with \`${warmCommandFor(params.subject)}\``;
+  return { ok: false, message: `agent-shim: ${params.subject} has no usable credential: ${attempts.join("; ")}${hint}` };
+}
+function credentialVariables(target, token) {
+  return {
+    ANTHROPIC_AUTH_TOKEN: target === "bearer" ? token : void 0,
+    ANTHROPIC_API_KEY: target === "apiKey" ? token : void 0,
+    CLAUDE_CODE_OAUTH_TOKEN: target === "oauthToken" ? token : void 0
+  };
+}
 
 // src/providersStore.ts
 var ProviderNotFoundError = class extends CliError {
@@ -4695,6 +4838,11 @@ function readProvider(paths, name) {
   const raw = JSON.parse(fs6.readFileSync(filePath, "utf8"));
   return parseProviderFile(filePath, raw);
 }
+function loadProvider(providersDir, name, port) {
+  const filePath = path15.join(providersDir, `${name}.json`);
+  const raw = port.readConfigFile(filePath);
+  return raw === void 0 ? void 0 : parseProviderFile(filePath, raw);
+}
 function listProviders(paths) {
   const names = listProviderNames(
     (dir) => fs6.readdirSync(dir),
@@ -4827,6 +4975,30 @@ function cascadeProviderName(cascade) {
   }
   return name;
 }
+function resolveProvider(params) {
+  const cliName = params.cliProvider !== void 0 && params.cliProvider !== "" ? params.cliProvider : void 0;
+  const name = cliName ?? (params.cascade === void 0 ? void 0 : cascadeProviderName(params.cascade));
+  if (name === void 0) {
+    return void 0;
+  }
+  const definition = loadProvider(params.paths.providersDir, name, params.port);
+  if (definition === void 0) {
+    const known = listProviderNames(params.port.readdir, params.paths.providersDir);
+    return {
+      ok: false,
+      status: 1,
+      message: `agent-shim: no provider named "${name}". ` + (known.length > 0 ? `Known providers: ${known.join(", ")}.` : "No providers are defined yet; run `agent-shim provider add`.")
+    };
+  }
+  if (params.credentials === void 0) {
+    return { ok: false, status: 1, message: `agent-shim: provider ${name} needs its credential resolved, but this launcher has no credential port wired` };
+  }
+  const resolution = resolveCredential({ credential: definition.credential, env: params.env, port: params.credentials, subject: `provider ${name}` });
+  if (!resolution.ok) {
+    return { ok: false, status: CREDENTIAL_UNAVAILABLE_EXIT, message: resolution.message };
+  }
+  return { ok: true, provider: { name, definition, credential: resolution.credential }, warnings: resolution.credential.warnings };
+}
 
 // src/directoryRulesStore.ts
 var DirectoryRuleNotFoundError = class extends CliError {
@@ -4919,7 +5091,7 @@ function removeDirectoryRule(paths, rulePath) {
 }
 
 // src/checkReport.ts
-import os3 from "node:os";
+import os4 from "node:os";
 
 // src/launcher/cascade.ts
 import path17 from "node:path";
@@ -5015,6 +5187,7 @@ var MS_PER_SECOND2 = 1e3;
 var SECONDS_PER_MINUTE = 60;
 var MINUTES_PER_HOUR = 60;
 var HOURS_PER_DAY = 24;
+var WARNING_STATUSES = /* @__PURE__ */ new Set(["allowed_warning", "rejected"]);
 function formatAge(ms) {
   const minutes = Math.floor(ms / (MS_PER_SECOND2 * SECONDS_PER_MINUTE));
   if (minutes < MINUTES_PER_HOUR) {
@@ -5035,8 +5208,30 @@ function effectiveWindow(window, nowMs) {
     ...window.status === void 0 ? {} : { status: window.status }
   };
 }
+function quotaWarnings(snapshot, provider, nowMs) {
+  const rateLimit = snapshot?.providers[provider]?.rateLimit;
+  const unified = rateLimit?.unified;
+  if (snapshot === void 0 || rateLimit === void 0 || unified === void 0) {
+    return [];
+  }
+  const age = formatAge(nowMs - Date.parse(rateLimit.observedAt));
+  const windows = [
+    { name: "five-hour", window: unified.fiveHour },
+    { name: "seven-day", window: unified.sevenDay }
+  ];
+  return windows.flatMap(({ name, window }) => {
+    const effective = window === void 0 ? void 0 : effectiveWindow(window, nowMs);
+    if (window === void 0 || effective?.status === void 0 || !WARNING_STATUSES.has(effective.status)) {
+      return [];
+    }
+    const reset = window.resetsAt === void 0 ? "" : `, resets ${window.resetsAt}`;
+    const verdict = effective.status === "rejected" ? "exhausted" : "nearly used";
+    return [`agent-shim: identity ${snapshot.identity}: the ${name} quota is ${verdict}${reset} (last seen ${age} ago)`];
+  });
+}
 
 // src/usage/poolPick.ts
+import path18 from "node:path";
 import { z as z9 } from "zod";
 
 // src/usage/plan.ts
@@ -5289,14 +5484,14 @@ var PicksFileSchema = z9.strictObject({
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function loadPoolMembers(fs10, paths, identities, nowMs) {
+function loadPoolMembers(fs12, paths, identities, nowMs) {
   const windowStartMs = nowMs - FIVE_HOUR_WINDOW_MS;
-  const log = readUsageLog(fs10, paths.usageLogDir, { sinceMs: windowStartMs });
+  const log = readUsageLog(fs12, paths.usageLogDir, { sinceMs: windowStartMs });
   return identities.map((identity) => {
     const records = log.records.filter((record) => record.identity === identity && record.provider === ANTHROPIC_PROVIDER && Date.parse(record.at) >= windowStartMs);
     try {
-      const snapshot = readUsageSnapshot(fs10, paths.usageSnapshotsDir, identity);
-      const account = readAccountMetadata(fs10, paths.identitiesDir, identity) ?? snapshot?.account;
+      const snapshot = readUsageSnapshot(fs12, paths.usageSnapshotsDir, identity);
+      const account = readAccountMetadata(fs12, paths.identitiesDir, identity) ?? snapshot?.account;
       return { identity, records, ...snapshot === void 0 ? {} : { snapshot }, ...account === void 0 ? {} : { account } };
     } catch (error) {
       if (error instanceof UsageSnapshotError || error instanceof AccountMetadataError) {
@@ -5314,9 +5509,9 @@ function rankPoolFromStore(params) {
     ...params.sticky === void 0 ? {} : { sticky: params.sticky }
   });
 }
-function readPicksFile(fs10, file) {
+function readPicksFile(fs12, file) {
   const empty = { schemaVersion: SCHEMA_VERSION, picks: {} };
-  const raw = fs10.readFileUtf8(file);
+  const raw = fs12.readFileUtf8(file);
   if (raw === void 0) {
     return { file: empty };
   }
@@ -5329,17 +5524,72 @@ function readPicksFile(fs10, file) {
   const result = PicksFileSchema.safeParse(parsed);
   return result.success ? { file: result.data } : { file: empty, problem: `${file} is not a picks file this agent-shim can read` };
 }
-function readStickyPick(fs10, picksFile, directory) {
-  const read = readPicksFile(fs10, picksFile);
+function readStickyPick(fs12, picksFile, directory) {
+  const read = readPicksFile(fs12, picksFile);
   const entry = read.file.picks[directory];
   return { ...entry === void 0 ? {} : { sticky: entry }, ...read.problem === void 0 ? {} : { problem: read.problem } };
 }
+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(path18.dirname(picksFile));
+  fs12.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
+`);
+}
 
 // src/launcher/pool.ts
-function splitMembers(pool, paths, fs10) {
-  const exists = (name) => loadIdentity(paths.identitiesDir, name, fs10) !== void 0;
+var RESUME_FLAGS = /* @__PURE__ */ new Set(["--continue", "-c", "--resume", "-r"]);
+var TERMINATOR = "--";
+var REASONS_LOGGED = 3;
+function splitMembers(pool, paths, fs12) {
+  const exists = (name) => loadIdentity(paths.identitiesDir, name, fs12) !== void 0;
   return { present: pool.identities.filter(exists), missing: pool.identities.filter((name) => !exists(name)) };
 }
+function isResuming(passthrough) {
+  const end = passthrough.indexOf(TERMINATOR);
+  return (end === -1 ? passthrough : passthrough.slice(0, end)).some((token) => RESUME_FLAGS.has(token));
+}
+function resolvePoolLaunch(params) {
+  const { poolName, log } = params;
+  const pool = params.pools?.[poolName];
+  if (pool === void 0) {
+    return { ok: false, message: `agent-shim: no pool named "${poolName}" (selected via ${params.selectedVia}). Run \`agent-shim pool add ${poolName} --identity <name>...\` first.` };
+  }
+  const { present: identities, missing } = splitMembers(pool, params.paths, params.fs);
+  for (const name of missing) {
+    log.warn(`agent-shim: pool "${poolName}" names identity "${name}", which does not exist; skipping it`);
+  }
+  if (identities.length === 0) {
+    return { ok: false, message: `agent-shim: no member of pool "${poolName}" is an existing identity.` };
+  }
+  const resuming = isResuming(params.passthrough);
+  const stickyRead = readStickyPick(params.usageFs, params.paths.usagePicksFile, params.cwd);
+  if (stickyRead.problem !== void 0) {
+    log.warn(`agent-shim: ${stickyRead.problem}; ignoring the last-pick record`);
+  }
+  for (; ; ) {
+    const nowMs = params.now();
+    const ranking = rankPoolFromStore({ fs: params.usageFs, paths: params.paths, identities, nowMs, resuming, ...stickyRead.sticky === void 0 ? {} : { sticky: stickyRead.sticky } });
+    const { pick, earliestReturn } = ranking;
+    if (pick !== void 0) {
+      recordStickyPick(params.usageFs, params.paths.usagePicksFile, params.cwd, pick.identity, nowMs);
+      return { ok: true, identity: pick.identity, explanation: `pool ${poolName}: ${pick.reasons.slice(0, REASONS_LOGGED).join("; ")}` };
+    }
+    if (earliestReturn === void 0) {
+      return { ok: false, message: `agent-shim: no member of pool "${poolName}" can be picked.` };
+    }
+    const until = new Date(earliestReturn.atMs).toISOString();
+    if (!params.wait) {
+      return {
+        ok: false,
+        message: `agent-shim: every member of pool "${poolName}" is refused right now; the earliest, ${earliestReturn.identity}, returns at ${until} (in ${formatAge(earliestReturn.atMs - nowMs)}). Pass --wait to sleep until then.`
+      };
+    }
+    log.info(`agent-shim: every member of pool "${poolName}" is refused; waiting until ${until} for ${earliestReturn.identity}`);
+    params.sleep(Math.max(earliestReturn.atMs - nowMs, 0));
+  }
+}
 
 // src/poolPickReport.ts
 function candidateView(candidate) {
@@ -5379,14 +5629,15 @@ function collectPoolPick(params) {
 import { spawn, spawnSync } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 import fs7 from "node:fs";
-import path19 from "node:path";
+import os3 from "node:os";
+import path20 from "node:path";
 import { isSea } from "node:sea";
 
 // src/versionDiscovery.ts
 import os2 from "node:os";
-import path18 from "node:path";
+import path19 from "node:path";
 function defaultVersionsDir() {
-  return path18.join(os2.homedir(), ".local", "share", "claude", "versions");
+  return path19.join(os2.homedir(), ".local", "share", "claude", "versions");
 }
 var NUMERIC_DOTTED_VERSION_RE = /^\d+(?:\.\d+)*$/;
 function isNumericDottedVersion(name) {
@@ -5428,14 +5679,14 @@ function discoverClaudeBinary(options) {
   const highestVersion = pickHighestVersion(entries);
   if (highestVersion !== void 0) {
     return {
-      path: path18.join(versionsDir, highestVersion),
+      path: path19.join(versionsDir, highestVersion),
       source: "versions-dir",
       version: highestVersion
     };
   }
-  const ownInstallDirs = new Set(options.ownInstallDirs.map((dir) => path18.resolve(dir)));
+  const ownInstallDirs = new Set(options.ownInstallDirs.map((dir) => path19.resolve(dir)));
   for (const dir of options.pathDirs) {
-    if (ownInstallDirs.has(path18.resolve(dir))) {
+    if (ownInstallDirs.has(path19.resolve(dir))) {
       continue;
     }
     const found = options.findExecutableInDir(dir, "claude");
@@ -5480,7 +5731,7 @@ function isErrorWithCode(error, code) {
 }
 var OWNER_ONLY_DIR_MODE = 448;
 var OWNER_ONLY_FILE_MODE = 384;
-var PERMISSION_BITS = 511;
+var PERMISSION_BITS2 = 511;
 var realFarmFs = {
   lstat(filePath) {
     let stat;
@@ -5546,7 +5797,7 @@ var realFarmFs = {
   appendFilePrivate(filePath, contents) {
     const descriptor = fs7.openSync(filePath, "a", OWNER_ONLY_FILE_MODE);
     try {
-      if ((fs7.fstatSync(descriptor).mode & PERMISSION_BITS) !== OWNER_ONLY_FILE_MODE) {
+      if ((fs7.fstatSync(descriptor).mode & PERMISSION_BITS2) !== OWNER_ONLY_FILE_MODE) {
         fs7.fchmodSync(descriptor, OWNER_ONLY_FILE_MODE);
       }
       const bytes = Buffer.from(contents, "utf8");
@@ -5580,6 +5831,10 @@ var realFarmFs = {
     }
   }
 };
+var INT32_BYTE_LENGTH = 4;
+function realSleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(INT32_BYTE_LENGTH)), 0, 0, ms);
+}
 function realIsProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -5601,6 +5856,51 @@ var realRunPort = {
     return { status: result.status, stdout: result.stdout, stderr: result.stderr };
   }
 };
+function expandHome2(filePath) {
+  return filePath.startsWith("~/") ? path20.join(os3.homedir(), filePath.slice(1)) : filePath;
+}
+var MACOS_GUI_SESSION_MANAGER = "Aqua";
+function hasDesktopSession() {
+  if (process.platform === "darwin") {
+    const result = spawnSync("launchctl", ["managername"], { encoding: "utf8" });
+    return result.status === 0 && result.stdout.trim() === MACOS_GUI_SESSION_MANAGER;
+  }
+  if (process.platform === "win32") {
+    return false;
+  }
+  return (process.env.DISPLAY ?? "") !== "" || (process.env.WAYLAND_DISPLAY ?? "") !== "";
+}
+var realCredentialPort = {
+  readSecretFile(filePath) {
+    const resolved = expandHome2(filePath);
+    let content;
+    let stat;
+    try {
+      stat = fs7.statSync(resolved);
+      content = fs7.readFileSync(resolved, "utf8");
+    } catch (error) {
+      if (isEnoent3(error)) {
+        return { found: false };
+      }
+      throw error;
+    }
+    return { found: true, content, mode: process.platform === "win32" ? void 0 : stat.mode };
+  },
+  runCommand(argv, options) {
+    const [command, ...args] = argv;
+    const result = spawnSync(command, args, {
+      encoding: "utf8",
+      timeout: options.timeoutMs,
+      stdio: options.interactive ? ["inherit", "pipe", "inherit"] : ["ignore", "pipe", "pipe"]
+    });
+    if (result.error !== void 0) {
+      const timedOut = isErrorWithCode(result.error, "ETIMEDOUT");
+      return { status: result.status, stdout: "", stderr: timedOut ? "" : result.error.message, timedOut };
+    }
+    return { status: result.status, stdout: result.stdout, stderr: options.interactive ? "" : result.stderr, timedOut: false };
+  },
+  personPresent: () => process.stdin.isTTY || hasDesktopSession()
+};
 function resolveGitBranch(run, cwd) {
   const result = run.run("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"]);
   if (result.status !== 0) {
@@ -5615,6 +5915,62 @@ function resolveGitBranch(run, cwd) {
   }
   return { branch: name, branchDetached: false };
 }
+function resolveGitRoot(run, cwd) {
+  const result = run.run("git", ["-C", cwd, "rev-parse", "--show-toplevel"]);
+  if (result.status !== 0) {
+    return void 0;
+  }
+  const root = result.stdout.trim();
+  return root === "" ? void 0 : root;
+}
+function detachedDaemonSpawnOptions(logFd, env) {
+  return { detached: true, stdio: ["ignore", logFd, logFd], env };
+}
+function spawnDaemonThrough(executable) {
+  return (paths, subcommand, logPath) => spawnDetachedDaemon({ command: executable, args: [subcommand] }, paths, subcommand, logPath);
+}
+function spawnDetachedDaemon(invocation, paths, subcommand, logPath) {
+  fs7.mkdirSync(path20.dirname(logPath), { recursive: true });
+  const logFd = fs7.openSync(logPath, "a");
+  try {
+    const child = spawn(invocation.command, invocation.args, detachedDaemonSpawnOptions(logFd, { ...process.env, AGENT_SHIM_HOME: paths.root }));
+    child.unref();
+    if (child.pid === void 0) {
+      throw new Error(`spawning ${subcommand} returned no pid`);
+    }
+    return child.pid;
+  } finally {
+    fs7.closeSync(logFd);
+  }
+}
+function spawnHeadroomSupervisor(paths, spawnDaemon) {
+  return spawnDaemon(paths, "__headroom-supervisor", paths.headroomLogPath);
+}
+function realHeadroomPort(paths, options) {
+  return {
+    ensure: () => {
+      const up = ensureHeadroom({
+        paths,
+        launcherPid: process.pid,
+        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,
+          spawnSupervisor: (layout) => spawnHeadroomSupervisor(layout, options.spawnDaemon)
+        }
+      });
+      return {
+        port: up.port,
+        projectId: resolveGitRoot(realRunPort, options.cwd) ?? options.cwd
+      };
+    },
+    release: () => {
+      removeSession(realFarmFs, paths.headroomSessionsDir, process.pid);
+    }
+  };
+}
 var realProcPort = {
   env: process.env,
   argv: process.argv.slice(2),
@@ -5632,7 +5988,7 @@ function listVersionsDir(dir) {
     throw error;
   }
   return entries.filter((entry) => entry.isFile()).map((entry) => {
-    const fullPath = path19.join(dir, entry.name);
+    const fullPath = path20.join(dir, entry.name);
     const stat = fs7.statSync(fullPath);
     return {
       name: entry.name,
@@ -5647,7 +6003,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 = path19.join(dir, name);
+  const candidate = path20.join(dir, name);
   if (env.platform === "win32") {
     const extensions = windowsPathExtensions(env.pathext);
     const alreadyHasRecognisedExtension = extensions.some((ext) => candidate.toLowerCase().endsWith(ext.toLowerCase()));
@@ -5696,13 +6052,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 : path19.resolve(env.cwd, env.argv1);
-  const candidateDir = path19.dirname(candidate);
-  const candidateDirOnPath = env.pathDirs.some((dir) => path19.resolve(dir) === candidateDir);
+  const candidate = env.argv1 === void 0 ? env.execPath : path20.resolve(env.cwd, env.argv1);
+  const candidateDir = path20.dirname(candidate);
+  const candidateDirOnPath = env.pathDirs.some((dir) => path20.resolve(dir) === candidateDir);
   if (candidateDirOnPath) {
     return candidate;
   }
-  const viaPath = searchPathForExecutable(env.pathDirs, path19.basename(candidate), env.findExecutableInDir);
+  const viaPath = searchPathForExecutable(env.pathDirs, path20.basename(candidate), env.findExecutableInDir);
   return viaPath ?? candidate;
 }
 function realOwnExecutablePath() {
@@ -5710,21 +6066,21 @@ function realOwnExecutablePath() {
     argv1: process.argv[1],
     execPath: process.execPath,
     cwd: process.cwd(),
-    pathDirs: (process.env.PATH ?? "").split(path19.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(path20.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir
   });
 }
 function realResolveClaudeBinary(ownInstallDirs) {
   return () => discoverClaudeBinary({
     listVersionsDir,
-    pathDirs: (process.env.PATH ?? "").split(path19.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(path20.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir,
     ownInstallDirs: [...ownInstallDirs]
   });
 }
 
 // src/checkReport.ts
-import path20 from "node:path";
+import path21 from "node:path";
 import { z as z10 } from "zod";
 
 // src/cli/bool.ts
@@ -6046,7 +6402,7 @@ function loadCheckProvider(paths, name) {
 }
 function collectCheckReport(params) {
   const { paths, cwd } = params;
-  const home = os3.homedir();
+  const home = os4.homedir();
   const claudeHome = resolveClaudeHome();
   const read = cosmiconfigReader();
   const classification = loadClassification(paths);
@@ -6091,10 +6447,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 : path20.join(paths.identitiesDir, identityDecision.name);
+  const farmRoot = identityDecision.name === void 0 ? void 0 : path21.join(paths.identitiesDir, identityDecision.name);
   const settingsFiles = {
-    "settings.json": realFsPort.readFileUtf8(path20.join(claudeHome, "settings.json")),
-    "settings.local.json": realFsPort.readFileUtf8(path20.join(claudeHome, "settings.local.json"))
+    "settings.json": realFsPort.readFileUtf8(path21.join(claudeHome, "settings.json")),
+    "settings.local.json": realFsPort.readFileUtf8(path21.join(claudeHome, "settings.local.json"))
   };
   const report = runCheck({
     cwd,
@@ -6124,7 +6480,7 @@ function collectCheckReport(params) {
 
 // src/claudeShim.ts
 import fs8 from "node:fs";
-import path21 from "node:path";
+import path22 from "node:path";
 import { z as z11 } from "zod";
 var ClaudeShimStateSchema = z11.strictObject({
   targetPath: z11.string().min(1),
@@ -6135,29 +6491,29 @@ function commandFilename(ownExecutablePath, commandName) {
   return ownExecutablePath.toLowerCase().endsWith(".exe") ? `${commandName}.exe` : commandName;
 }
 function resolveOwnInstallDirs(paths, ownExecutablePath) {
-  const dirs = [path21.dirname(ownExecutablePath)];
+  const dirs = [path22.dirname(ownExecutablePath)];
   const state = readJson(paths.claudeShimFile, ClaudeShimStateSchema);
   if (state !== void 0) {
-    dirs.push(path21.dirname(state.targetPath));
+    dirs.push(path22.dirname(state.targetPath));
   }
   return dirs;
 }
 var nodeLinkFs = { link: fs8.linkSync, copyFile: fs8.copyFileSync, chmod: fs8.chmodSync };
 function findPathShadow(params) {
-  const resolvedTargetDir = path21.resolve(params.targetDir);
+  const resolvedTargetDir = path22.resolve(params.targetDir);
   for (const dir of params.pathDirs) {
     const found = params.findExecutableInDir(dir, params.targetFilename);
     if (found === void 0) {
       continue;
     }
-    return path21.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
+    return path22.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
   }
-  return params.pathDirs.some((dir) => path21.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
+  return params.pathDirs.some((dir) => path22.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
 }
 
 // src/doctorReport.ts
 import fs9 from "node:fs";
-import path22 from "node:path";
+import path23 from "node:path";
 function refinePathShadow(status, ownExecutablePath, realpath) {
   if (status.status !== "shadowed") {
     return status;
@@ -6181,7 +6537,7 @@ function validateJson(schema, input) {
   return { ok: true, data: result.data };
 }
 function pushPathResolution(push, resolution) {
-  const ownDir = path22.dirname(resolution.ownExecutablePath);
+  const ownDir = path23.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");
@@ -6249,14 +6605,14 @@ function pushProvider(push, entry) {
 }
 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 && path22.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
+  if (legacyVariables.length === 0 && path23.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 (path22.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
+  if (path23.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
     push(
       "legacy-name",
       "warn",
@@ -6564,18 +6920,18 @@ function collectDoctorReport(params) {
   const { paths } = params;
   const identityNames = fs9.existsSync(paths.identitiesDir) ? fs9.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isIdentityDirectoryName(entry.name)).map((entry) => entry.name).sort() : [];
   const identities = identityNames.map((name) => {
-    const farmRoot = path22.join(paths.identitiesDir, name);
-    const identityPath = path22.join(farmRoot, "identity.json");
+    const farmRoot = path23.join(paths.identitiesDir, name);
+    const identityPath = path23.join(farmRoot, "identity.json");
     return { name, path: identityPath, raw: realFsPort.readFileUtf8(identityPath), farmRoot };
   });
   const profileNames = fs9.existsSync(paths.configProfilesDir) ? fs9.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 = path22.join(paths.configProfilesDir, `${name}.json`);
+    const profilePath = path23.join(paths.configProfilesDir, `${name}.json`);
     return { name, path: profilePath, raw: realFsPort.readFileUtf8(profilePath) };
   });
   const providerNames = fs9.existsSync(paths.providersDir) ? fs9.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 = path22.join(paths.providersDir, `${name}.json`);
+    const providerPath = path23.join(paths.providersDir, `${name}.json`);
     return { name, path: providerPath, raw: realFsPort.readFileUtf8(providerPath) };
   });
   const ownExecutablePath = realOwnExecutablePath();
@@ -6587,12 +6943,12 @@ 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(path22.delimiter).filter((dir) => dir !== "");
+  const pathDirs = (params.env.PATH ?? "").split(path23.delimiter).filter((dir) => dir !== "");
   const claudeShimShadow = shimState === void 0 ? void 0 : refinePathShadow(
     findPathShadow({
       pathDirs,
-      targetDir: path22.dirname(shimState.targetPath),
-      targetFilename: path22.basename(shimState.targetPath),
+      targetDir: path23.dirname(shimState.targetPath),
+      targetFilename: path23.basename(shimState.targetPath),
       findExecutableInDir
     }),
     shimState.targetPath,
@@ -6615,7 +6971,7 @@ function collectDoctorReport(params) {
       agentShim: refinePathShadow(
         findPathShadow({
           pathDirs,
-          targetDir: path22.dirname(ownExecutablePath),
+          targetDir: path23.dirname(ownExecutablePath),
           targetFilename: commandFilename(ownExecutablePath, "agent-shim"),
           findExecutableInDir
         }),
@@ -6633,6 +6989,975 @@ function collectDoctorReport(params) {
   });
   return report;
 }
+
+// src/launcher.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import path25 from "node:path";
+
+// src/launcher/argv.ts
+var ConflictingIdentityError = class extends UsageError {
+  constructor(positional, flag) {
+    super(`The launch names two identities: "@${positional}" and "--identity ${flag}". Pass only one.`);
+    this.positional = positional;
+    this.flag = flag;
+    this.name = "ConflictingIdentityError";
+  }
+  positional;
+  flag;
+};
+var VALUED_FLAGS = ["--identity", "--config-profile", "--provider", "--category", "--share", "--hide"];
+var BOOLEAN_FLAGS = [
+  { flag: "--headroom", key: "headroom" },
+  { flag: "--track-usage", key: "trackUsage" },
+  { flag: "--skip-permissions", key: "skipPermissions" },
+  { flag: "--remote-control", key: "remoteControl" },
+  { flag: "--wait", key: "wait" }
+];
+var LAUNCHER_FLAG_NAMES = [
+  ...VALUED_FLAGS,
+  "--no-provider",
+  ...BOOLEAN_FLAGS.flatMap(({ flag }) => [flag, `--no-${flag.slice(2)}`])
+];
+var TERMINATOR2 = "--";
+function matchValuedFlag(token) {
+  for (const flag of VALUED_FLAGS) {
+    if (token === flag) {
+      return { flag };
+    }
+    if (token.startsWith(`${flag}=`)) {
+      return { flag, inlineValue: token.slice(flag.length + 1) };
+    }
+  }
+  return void 0;
+}
+function matchBooleanFlag(token) {
+  for (const { flag, key } of BOOLEAN_FLAGS) {
+    if (token === flag) {
+      return { key, value: true };
+    }
+    if (token === `--no-${flag.slice(2)}`) {
+      return { key, value: false };
+    }
+  }
+  return void 0;
+}
+function parseLauncherArgv(argv) {
+  const first = argv[0];
+  const positionalIdentity = first !== void 0 && first.startsWith("@") && first.length > 1 ? first.slice(1) : void 0;
+  const remaining = positionalIdentity === void 0 ? argv : argv.slice(1);
+  let flagIdentity;
+  let configProfile;
+  let provider;
+  const booleans = {};
+  const categoryFlags = [];
+  const shareFlags = [];
+  const hideFlags = [];
+  const rest = [];
+  for (let index = 0; index < remaining.length; index += 1) {
+    const token = remaining[index];
+    if (token === void 0) {
+      continue;
+    }
+    if (token === TERMINATOR2) {
+      rest.push(...remaining.slice(index));
+      break;
+    }
+    if (token === "--no-provider") {
+      provider = false;
+      continue;
+    }
+    const booleanFlag = matchBooleanFlag(token);
+    if (booleanFlag !== void 0) {
+      booleans[booleanFlag.key] = booleanFlag.value;
+      continue;
+    }
+    const matched = matchValuedFlag(token);
+    if (matched === void 0) {
+      rest.push(token);
+      continue;
+    }
+    let value;
+    if (matched.inlineValue !== void 0) {
+      value = matched.inlineValue;
+    } else {
+      const next = remaining[index + 1];
+      if (next === void 0 || next === TERMINATOR2) {
+        rest.push(token);
+        continue;
+      }
+      value = next;
+      index += 1;
+    }
+    switch (matched.flag) {
+      case "--identity":
+        flagIdentity = value;
+        break;
+      case "--config-profile":
+        configProfile = value;
+        break;
+      case "--provider":
+        provider = value;
+        break;
+      case "--category":
+        categoryFlags.push(value);
+        break;
+      case "--share":
+        shareFlags.push(value);
+        break;
+      case "--hide":
+        hideFlags.push(value);
+        break;
+      default:
+        matched.flag;
+    }
+  }
+  if (positionalIdentity !== void 0 && flagIdentity !== void 0 && positionalIdentity !== flagIdentity) {
+    throw new ConflictingIdentityError(positionalIdentity, flagIdentity);
+  }
+  const identity = flagIdentity ?? positionalIdentity;
+  return {
+    ...identity === void 0 ? {} : { identity },
+    ...configProfile === void 0 ? {} : { configProfile },
+    ...provider === void 0 ? {} : { provider },
+    ...booleans,
+    categoryFlags,
+    shareFlags,
+    hideFlags,
+    rest
+  };
+}
+
+// src/cli/pairs.ts
+function splitCommas(input) {
+  if (input === "") {
+    return [];
+  }
+  return input.split(",");
+}
+function parsePair(input) {
+  const eqIndex = input.indexOf("=");
+  if (eqIndex === -1) {
+    throw new Error(`Expected "<key>=<value>", got "${input}" (no "=" found)`);
+  }
+  const key = input.slice(0, eqIndex);
+  const value = input.slice(eqIndex + 1);
+  if (key === "") {
+    throw new Error(`Expected a non-empty key before "=" in "${input}"`);
+  }
+  return { key, value };
+}
+function parseBool(input) {
+  const parsed = parseBoolWord(input);
+  if (parsed === void 0) {
+    throw new Error(`Expected "true", "false", "1" or "0", got "${input}"`);
+  }
+  return parsed;
+}
+function parseBoolPairList(input) {
+  const result = {};
+  for (const piece of splitCommas(input)) {
+    const { key, value } = parsePair(piece);
+    result[key] = parseBool(value);
+  }
+  return result;
+}
+
+// src/launcher/cliOverride.ts
+var InvalidCliCategoryError = class extends CliError {
+  constructor(categoryName) {
+    super(`"${categoryName}" is not a category this launch may toggle (runtime, history, knowledge, settings).`);
+    this.categoryName = categoryName;
+    this.name = "InvalidCliCategoryError";
+  }
+  categoryName;
+};
+var InvalidCliEntryKeyError = class extends CliError {
+  constructor(key) {
+    super(`"${key}" is not a valid entries key \u2014 it must start with "<category>/", e.g. "knowledge/skills/commit".`);
+    this.key = key;
+    this.name = "InvalidCliEntryKeyError";
+  }
+  key;
+};
+function toCategoryMap(pairs) {
+  const expanded = expandAllCategoryKey(pairs);
+  const result = {};
+  for (const [key, value] of Object.entries(expanded)) {
+    if (!isOverridableCategory(key)) {
+      throw new InvalidCliCategoryError(key);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function toEntries(pairs) {
+  for (const key of Object.keys(pairs)) {
+    if (!ENTRY_KEY_RE.test(key)) {
+      throw new InvalidCliEntryKeyError(key);
+    }
+  }
+  return pairs;
+}
+function parseOverride(source, raw, parse) {
+  try {
+    return parse(raw);
+  } catch (error) {
+    if (error instanceof Error && !(error instanceof CliError)) {
+      throw new UsageError(`Invalid ${source} value "${raw}": ${error.message}.`);
+    }
+    throw error;
+  }
+}
+function buildCliOverride(params) {
+  let categoryPairs = {};
+  if (params.env.AGENT_SHIM_CATEGORY_OVERRIDE !== void 0 && params.env.AGENT_SHIM_CATEGORY_OVERRIDE !== "") {
+    categoryPairs = parseOverride("AGENT_SHIM_CATEGORY_OVERRIDE", params.env.AGENT_SHIM_CATEGORY_OVERRIDE, parseBoolPairList);
+  }
+  for (const flagValue of params.categoryFlags) {
+    const pair = parseOverride("--category", flagValue, (raw) => {
+      const { key, value } = parsePair(raw);
+      return { key, value: parseBool(value) };
+    });
+    categoryPairs[pair.key] = pair.value;
+  }
+  let entryPairs = {};
+  if (params.env.AGENT_SHIM_ENTRY_OVERRIDE !== void 0 && params.env.AGENT_SHIM_ENTRY_OVERRIDE !== "") {
+    entryPairs = parseOverride("AGENT_SHIM_ENTRY_OVERRIDE", params.env.AGENT_SHIM_ENTRY_OVERRIDE, parseBoolPairList);
+  }
+  for (const entryPath of params.shareFlags) {
+    entryPairs[entryPath] = true;
+  }
+  for (const entryPath of params.hideFlags) {
+    entryPairs[entryPath] = false;
+  }
+  const hasCategories = Object.keys(categoryPairs).length > 0;
+  const hasEntries = Object.keys(entryPairs).length > 0;
+  const hasProvider = params.providerFlag !== void 0 && params.providerFlag !== "";
+  if (!hasCategories && !hasEntries && !hasProvider) {
+    return void 0;
+  }
+  return {
+    ...hasCategories ? { categories: toCategoryMap(categoryPairs) } : {},
+    ...hasEntries ? { entries: toEntries(entryPairs) } : {},
+    ...hasProvider ? { launch: { provider: params.providerFlag } } : {}
+  };
+}
+
+// src/launcher/flags.ts
+import path24 from "node:path";
+
+// src/headroom/headers.ts
+function mergeAnthropicCustomHeaders(existing, additions) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const block of existing) {
+    if (block === void 0) {
+      continue;
+    }
+    for (const line of block.split("\n")) {
+      const entry = parseCustomHeaderLine(line);
+      if (entry === void 0) {
+        continue;
+      }
+      merged.set(entry.name, entry.value);
+    }
+  }
+  for (const entry of additions) {
+    merged.set(entry.name, entry.value);
+  }
+  return [...merged].map(([name, value]) => `${name}: ${value}`).join("\n");
+}
+function parseCustomHeaderLine(line) {
+  const trimmed = line.trim();
+  if (trimmed === "") {
+    return void 0;
+  }
+  const colon = trimmed.indexOf(":");
+  if (colon <= 0) {
+    return void 0;
+  }
+  return { name: trimmed.slice(0, colon).trim(), value: trimmed.slice(colon + 1).trim() };
+}
+
+// src/launcher/flags.ts
+function resolveLaunchFlags(params) {
+  return {
+    skipPermissions: params.flags?.skipPermissions ?? parseEnvBool("AGENT_SHIM_SKIP_PERMISSIONS", params.env.AGENT_SHIM_SKIP_PERMISSIONS) ?? params.cascade?.skipPermissions ?? false,
+    remoteControl: params.flags?.remoteControl ?? parseEnvBool("AGENT_SHIM_REMOTE_CONTROL", params.env.AGENT_SHIM_REMOTE_CONTROL) ?? params.cascade?.remoteControl ?? false,
+    headroom: params.flags?.headroom ?? parseEnvBool("AGENT_SHIM_HEADROOM", params.env.AGENT_SHIM_HEADROOM) ?? params.cascade?.headroom ?? false,
+    trackUsage: params.flags?.trackUsage ?? parseEnvBool("AGENT_SHIM_TRACK_USAGE", params.env.AGENT_SHIM_TRACK_USAGE) ?? params.cascade?.trackUsage ?? params.trackUsageDefault ?? false
+  };
+}
+function buildFlagArgs(flags) {
+  const args = [];
+  if (flags.skipPermissions) {
+    args.push("--dangerously-skip-permissions");
+  }
+  if (flags.remoteControl) {
+    args.push("--remote-control=");
+  }
+  return args;
+}
+function buildArgv(params) {
+  return [...params.toolFlags, ...params.extraFlags, ...params.passthrough];
+}
+var LOOPBACK_HOSTS = ["127.0.0.1", "localhost", "::1"];
+function isLoopbackUrl(baseUrl) {
+  const host = new URL(baseUrl).hostname.replace(/^\[|\]$/g, "");
+  return LOOPBACK_HOSTS.some((loopback) => loopback === host);
+}
+function withLoopbackHosts(existing) {
+  const listed = (existing ?? "").split(",").map((entry) => entry.trim()).filter((entry) => entry !== "");
+  return [...listed, ...LOOPBACK_HOSTS.filter((host) => !listed.includes(host))].join(",");
+}
+function buildEnv(params) {
+  const env = { ...params.baseEnv };
+  const parentCustomHeaders = params.baseEnv.ANTHROPIC_CUSTOM_HEADERS;
+  let providerCustomHeaders;
+  if (!params.configDirEscapeHatch && params.resolvedIdentityName !== void 0) {
+    env.CLAUDE_CONFIG_DIR = path24.join(params.identitiesDir, params.resolvedIdentityName);
+  }
+  if (params.provider !== void 0) {
+    const providerEnv = params.provider.definition.env ?? {};
+    providerCustomHeaders = providerEnv.ANTHROPIC_CUSTOM_HEADERS;
+    env.ANTHROPIC_BASE_URL = params.provider.baseUrl;
+    if (isLoopbackUrl(params.provider.baseUrl)) {
+      env.NO_PROXY = withLoopbackHosts(params.baseEnv.NO_PROXY);
+      env.no_proxy = withLoopbackHosts(params.baseEnv.no_proxy);
+    }
+    env.AGENT_SHIM_PROVIDER = params.provider.definition.displayName;
+    for (const [key, value] of Object.entries(providerEnv)) {
+      env[key] = value;
+    }
+  }
+  const credential = params.provider?.credential ?? params.identityCredential;
+  if (credential !== void 0) {
+    for (const [variable, value] of Object.entries(credentialVariables(credential.target, credential.token))) {
+      env[variable] = value;
+    }
+  }
+  if (params.headroom !== void 0) {
+    env.HEADROOM_PROXY_URL = `http://127.0.0.1:${String(params.headroom.port)}`;
+  }
+  if (params.frontdoor !== void 0) {
+    env.ANTHROPIC_CUSTOM_HEADERS = mergeAnthropicCustomHeaders(
+      [
+        ...parentCustomHeaders === void 0 ? [] : [parentCustomHeaders],
+        ...providerCustomHeaders === void 0 ? [] : [providerCustomHeaders]
+      ],
+      [
+        ...params.resolvedIdentityName === void 0 ? [] : [{ name: IDENTITY_HEADER, value: params.resolvedIdentityName }],
+        { name: SESSION_HEADER, value: params.sessionId },
+        { name: AUTH_HEADER, value: params.frontdoor.sessionToken },
+        ...params.headroom === void 0 ? [] : [
+          { name: HEADROOM_FLAG_HEADER, value: "1" },
+          { name: PROJECT_ID_HEADER, value: params.headroom.projectId }
+        ]
+      ]
+    );
+    env.NODE_EXTRA_CA_CERTS = params.frontdoor.trustBundlePath;
+    if (params.provider === void 0) {
+      env.HTTPS_PROXY = connectProxyUrl(params.frontdoor.connectPort, params.frontdoor.sessionToken);
+    }
+  }
+  return env;
+}
+
+// src/launcher/extraFlags.ts
+function splitExtraFlags(value) {
+  if (value === void 0) {
+    return [];
+  }
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return [];
+  }
+  return trimmed.split(/\s+/);
+}
+
+// src/launcher.ts
+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` };
+  }
+  const resolution = resolveCredential({ credential, env, port, subject: `identity ${identity}` });
+  return resolution.ok ? resolution : { ok: false, status: CREDENTIAL_UNAVAILABLE_EXIT, message: resolution.message };
+}
+function pickFromPool(decided, params, parsedArgv) {
+  const { paths, fs: fs12, proc, log } = params;
+  if (decided.pool === void 0) {
+    return { identityDecision: decided };
+  }
+  const farmRuntime = params.farm;
+  if (farmRuntime === void 0) {
+    log.error(`agent-shim: pool "${decided.pool}" was selected, but this launcher has no farm wired to read usage and pick a member with.`);
+    return proc.exit(1);
+  }
+  const resolution = resolvePoolLaunch({
+    poolName: decided.pool,
+    selectedVia: decided.source,
+    pools: params.pools,
+    paths,
+    fs: fs12,
+    usageFs: farmRuntime.fs,
+    cwd: farmRuntime.cwd,
+    now: farmRuntime.now,
+    sleep: farmRuntime.lock.sleep,
+    passthrough: parsedArgv.rest,
+    wait: parsedArgv.wait === true,
+    log
+  });
+  if (!resolution.ok) {
+    log.error(resolution.message);
+    return proc.exit(1);
+  }
+  return { identityDecision: { ...decided, name: resolution.identity }, poolExplanation: resolution.explanation };
+}
+function prepareLaunch(params) {
+  const { paths, fs: fs12, proc, log } = params;
+  const { env, argv } = proc;
+  const parsedArgv = parseLauncherArgv(argv);
+  const cliOverride = buildCliOverride({
+    env,
+    categoryFlags: parsedArgv.categoryFlags,
+    shareFlags: parsedArgv.shareFlags,
+    hideFlags: parsedArgv.hideFlags
+  });
+  const configDirEscapeHatchApplies = env.CLAUDE_CONFIG_DIR !== void 0 && env.CLAUDE_CONFIG_DIR !== "";
+  const decidedIdentity = decideIdentity({
+    env,
+    argv0Identity: parsedArgv.identity,
+    directoryPinnedIdentity: params.directoryPinnedIdentity,
+    readActiveIdentityFile: () => {
+      const raw = fs12.readFileUtf8(paths.activeIdentityFile);
+      if (raw === void 0) {
+        return void 0;
+      }
+      const trimmed = raw.trim();
+      return trimmed === "" ? void 0 : trimmed;
+    }
+  });
+  const { identityDecision, poolExplanation } = pickFromPool(decidedIdentity, params, parsedArgv);
+  const farmIdentity = configDirEscapeHatchApplies ? void 0 : identityDecision.name;
+  const farm = farmIdentity === void 0 ? void 0 : params.farm;
+  if (farm !== void 0 && farmIdentity !== void 0) {
+    let recovery;
+    try {
+      recovery = recoverFarm({
+        fs: farm.fs,
+        identitiesDir: paths.identitiesDir,
+        identity: farmIdentity,
+        now: farm.now,
+        lock: farm.lock,
+        classification: farm.classification
+      });
+    } catch (error) {
+      if (error instanceof IdentityLockBusyError) {
+        log.error(error.message);
+        proc.exit(1);
+      }
+      throw error;
+    }
+    for (const diagnostic of recoveryDiagnostics(recovery, farmIdentity)) {
+      log.warn(`agent-shim: ${diagnostic.code}: ${diagnostic.message}`);
+    }
+  }
+  let loadedIdentity;
+  if (identityDecision.name !== void 0) {
+    loadedIdentity = loadIdentity(paths.identitiesDir, identityDecision.name, fs12);
+    if (loadedIdentity === void 0) {
+      log.error(
+        `agent-shim: no identity named "${identityDecision.name}" (selected via ${identityDecision.source}). Run \`agent-shim identity add ${identityDecision.name}\` first.`
+      );
+      proc.exit(1);
+    }
+  }
+  const configProfileDecision = decideConfigProfile({
+    env,
+    cliFlagConfigProfile: params.cliFlagConfigProfile ?? parsedArgv.configProfile,
+    directoryRuleConfigProfile: params.directoryRuleConfigProfile,
+    identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
+    globalDefaultConfigProfile: params.globalDefaultConfigProfile
+  });
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(path25.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.`
+    );
+    proc.exit(1);
+  }
+  const farmContext = farm !== void 0 && farmIdentity !== void 0 ? { farm, identity: farmIdentity, cascade: farm.loadCascade(configProfileDecision.name, cliOverride) } : void 0;
+  const provider = parsedArgv.provider === false ? void 0 : resolveProvider({
+    paths,
+    port: fs12,
+    env,
+    ...params.credentials === void 0 ? {} : { credentials: params.credentials },
+    ...parsedArgv.provider === void 0 ? {} : { cliProvider: parsedArgv.provider },
+    ...farmContext === void 0 ? {} : { cascade: farmContext.cascade }
+  });
+  if (provider !== void 0 && !provider.ok) {
+    log.error(provider.message);
+    proc.exit(provider.status);
+  }
+  const resolvedProvider = provider?.ok === true ? provider.provider : void 0;
+  for (const warning of provider?.ok === true ? provider.warnings : []) {
+    log.warn(warning);
+  }
+  if (farm !== void 0 && farmIdentity !== void 0) {
+    try {
+      const snapshot = readUsageSnapshot(farm.fs, paths.usageSnapshotsDir, farmIdentity);
+      for (const warning of quotaWarnings(snapshot, resolvedProvider?.name ?? ANTHROPIC_PROVIDER, farm.now())) {
+        log.warn(warning);
+      }
+    } catch (error) {
+      if (!(error instanceof UsageSnapshotError)) {
+        throw error;
+      }
+      log.warn(`agent-shim: ${error.message}`);
+    }
+  }
+  const identityCredentialBlock = loadedIdentity?.config.credential;
+  const identityResolution = resolvedProvider === void 0 && farmIdentity !== void 0 && identityCredentialBlock !== void 0 ? resolveIdentityCredential(farmIdentity, identityCredentialBlock, env, params.credentials) : void 0;
+  if (identityResolution !== void 0 && !identityResolution.ok) {
+    log.error(identityResolution.message);
+    proc.exit(identityResolution.status);
+  }
+  const identityCredential = identityResolution?.ok === true ? identityResolution.credential : void 0;
+  for (const warning of identityCredential?.warnings ?? []) {
+    log.warn(warning);
+  }
+  const guardResult = evaluateAmbientCredentialGuard({
+    env,
+    allowAmbientCredential: loadedIdentity?.config.allowAmbientCredential ?? false,
+    allowAmbientCredentialOverride: parseEnvBool("AGENT_SHIM_ALLOW_AMBIENT_CREDENTIAL", env.AGENT_SHIM_ALLOW_AMBIENT_CREDENTIAL) === true,
+    identityName: identityDecision.name,
+    providerSelected: resolvedProvider !== void 0,
+    ...identityCredential === void 0 ? {} : { injectedCredential: { variable: CREDENTIAL_TARGET_VARS[identityCredential.target], token: identityCredential.token } }
+  });
+  if (!guardResult.ok) {
+    log.error(guardResult.message);
+    proc.exit(1);
+  }
+  log.info(
+    `agent-shim: identity ${identityDecision.name ?? "(none)"} (${identityDecision.source}${poolExplanation === void 0 ? "" : `, ${poolExplanation}`}), config profile ${configProfileDecision.name ?? "(none)"} (${configProfileDecision.source})` + (resolvedProvider === void 0 ? "" : `, provider ${resolvedProvider.name} (credential ${resolvedProvider.credential.target} from ${describeSource(resolvedProvider.credential.source)})`) + (identityCredential === void 0 ? "" : `, identity credential ${identityCredential.target} from ${describeSource(identityCredential.source)}`)
+  );
+  let cascadeLaunch;
+  if (farmContext !== void 0) {
+    const { farm: resyncFarmRuntime, identity: resyncIdentity, cascade } = farmContext;
+    let result;
+    try {
+      result = resyncFarm({
+        fs: resyncFarmRuntime.fs,
+        identitiesDir: paths.identitiesDir,
+        identity: resyncIdentity,
+        ...configProfileDecision.name === void 0 ? {} : { configProfile: configProfileDecision.name },
+        claudeHome: resyncFarmRuntime.claudeHome,
+        home: resyncFarmRuntime.home,
+        cwd: resyncFarmRuntime.cwd,
+        env,
+        ...resyncFarmRuntime.branch === void 0 ? {} : { branch: resyncFarmRuntime.branch },
+        ...resyncFarmRuntime.branchDetached === void 0 ? {} : { branchDetached: resyncFarmRuntime.branchDetached },
+        cascade,
+        classification: resyncFarmRuntime.classification,
+        now: resyncFarmRuntime.now,
+        uniqueSuffix: resyncFarmRuntime.uniqueSuffix,
+        lock: resyncFarmRuntime.lock
+      });
+    } catch (error) {
+      if (error instanceof IdentityLockBusyError) {
+        log.error(error.message);
+        proc.exit(1);
+      }
+      throw error;
+    }
+    for (const diagnostic of result.diagnostics) {
+      if (diagnostic.severity === "error") {
+        log.error(`agent-shim: ${diagnostic.code}: ${diagnostic.message}`);
+      } else if (diagnostic.severity === "warning") {
+        log.warn(`agent-shim: ${diagnostic.code}: ${diagnostic.message}`);
+      }
+    }
+    log.info(
+      result.noOp ? `agent-shim: farm at ${result.farmRoot} already matches the resolved cascade` : `agent-shim: farm at ${result.farmRoot} resynced (${String(result.manifest.links.length)} link(s), ${String(result.manifest.materialised.length)} built director(ies)${result.adopted.length === 0 ? "" : `, ${String(result.adopted.length)} adopted into ${resyncFarmRuntime.claudeHome}`})`
+    );
+    cascadeLaunch = result.resolved.flattened.launch;
+  } else if (params.farm !== void 0) {
+    cascadeLaunch = flattenLayers(assembleCascade(params.farm.loadCascade(configProfileDecision.name, cliOverride)).layers, { home: params.farm.home }).launch;
+  }
+  const discovered = params.resolveClaudeBinary();
+  const resolvedFlags = resolveLaunchFlags({
+    env,
+    // A pool pick reads the usage the front door records, so a pool launch records its own unless something says otherwise.
+    ...poolExplanation === void 0 ? {} : { trackUsageDefault: true },
+    ...cascadeLaunch === void 0 ? {} : { cascade: cascadeLaunch },
+    flags: {
+      ...parsedArgv.skipPermissions === void 0 ? {} : { skipPermissions: parsedArgv.skipPermissions },
+      ...parsedArgv.remoteControl === void 0 ? {} : { remoteControl: parsedArgv.remoteControl },
+      ...parsedArgv.headroom === void 0 ? {} : { headroom: parsedArgv.headroom },
+      ...parsedArgv.trackUsage === void 0 ? {} : { trackUsage: parsedArgv.trackUsage }
+    }
+  });
+  const frontDoorPort = params.frontdoor;
+  const frontDoorEngaged = resolvedProvider !== void 0 || resolvedFlags.headroom || resolvedFlags.trackUsage;
+  if (frontDoorEngaged && frontDoorPort === void 0) {
+    log.error("agent-shim: this launch routes through the front-door daemon, but this launcher has no front-door port wired; refusing to launch without it.");
+    proc.exit(1);
+  }
+  const frontDoor = frontDoorEngaged && frontDoorPort !== void 0 ? frontDoorPort.ensure(env.NODE_EXTRA_CA_CERTS) : void 0;
+  if (frontDoor?.trustWarning !== void 0) {
+    log.warn(frontDoor.trustWarning);
+  }
+  let routedProvider;
+  if (resolvedProvider !== void 0 && frontDoor !== void 0) {
+    routedProvider = { ...resolvedProvider, baseUrl: providerBaseUrl(frontDoor.port, resolvedProvider.name) };
+  }
+  let headroom;
+  const headroomPort = params.headroom;
+  if (resolvedFlags.headroom && headroomPort !== void 0) {
+    headroom = headroomPort.ensure();
+    const via = resolvedProvider === void 0 ? `OAuth via the door's CONNECT surface on 127.0.0.1:${String(frontDoor?.connectPort ?? 0)}` : `provider ${resolvedProvider.name}`;
+    log.info(`agent-shim: routing through the front door on 127.0.0.1:${String(frontDoor?.port ?? 0)} with headroom on 127.0.0.1:${String(headroom.port)} (${via}, project ${headroom.projectId})`);
+  } else if (resolvedFlags.headroom) {
+    log.error("agent-shim: headroom routing was requested but this launcher has no headroom port wired; refusing to launch without it.");
+    proc.exit(1);
+  } else if (frontDoor !== void 0) {
+    log.info(`agent-shim: routing through the front door on 127.0.0.1:${String(frontDoor.port)}${resolvedProvider === void 0 ? ` (OAuth via the door's CONNECT surface on 127.0.0.1:${String(frontDoor.connectPort)}, usage recorded)` : ` (provider ${resolvedProvider.name})`}`);
+  }
+  const frontDoorRelease = frontDoor === void 0 ? void 0 : frontDoorPort?.release;
+  const finalArgv = buildArgv({
+    toolFlags: buildFlagArgs(resolvedFlags),
+    extraFlags: splitExtraFlags(env.CLAUDE_EXTRA_FLAGS),
+    passthrough: parsedArgv.rest
+  });
+  const finalEnv = buildEnv({
+    baseEnv: env,
+    configDirEscapeHatch: configDirEscapeHatchApplies,
+    resolvedIdentityName: identityDecision.name,
+    identitiesDir: paths.identitiesDir,
+    ...routedProvider === void 0 ? {} : { provider: routedProvider },
+    ...identityCredential === void 0 ? {} : { identityCredential },
+    ...frontDoor === void 0 ? {} : { frontdoor: frontDoor },
+    ...headroom === void 0 ? {} : { headroom },
+    sessionId: randomUUID4()
+  });
+  const releases = [...headroom === void 0 || headroomPort === void 0 ? [] : [headroomPort.release], ...frontDoorRelease === void 0 ? [] : [frontDoorRelease]];
+  const release = () => {
+    for (const registered of releases) {
+      registered();
+    }
+  };
+  return { bin: discovered.path, args: finalArgv, env: finalEnv, release };
+}
+
+// src/launchWiring.ts
+import os5 from "node:os";
+import { randomUUID as randomUUID5 } from "node:crypto";
+
+// src/realCredentialCache.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import fs10 from "node:fs";
+import path26 from "node:path";
+var KEYCHAIN_CACHE_SERVICE = "agent-shim-credential-cache";
+var CACHE_DIR_MODE = 448;
+var CACHE_FILE_MODE = 384;
+function cacheFileNameFor(owner) {
+  return `${owner.replace(/[^A-Za-z0-9._-]/g, "_")}.json`;
+}
+function parseEntry(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  const parsed = CachedCredentialSchema.safeParse(json);
+  return parsed.success ? parsed.data : void 0;
+}
+function requireKeychain() {
+  if (process.platform !== "darwin") {
+    throw new Error("the keychain credential store needs macOS; use --credential-cache-store file");
+  }
+}
+function security(args, stdin) {
+  const result = spawnSync2("security", args, { encoding: "utf8", ...stdin === void 0 ? {} : { input: stdin }, stdio: ["pipe", "pipe", "ignore"] });
+  return { status: result.status, stdout: result.stdout };
+}
+function createRealCredentialCache(root) {
+  const dir = path26.join(root, "credential-cache");
+  const filePath = (owner) => path26.join(dir, cacheFileNameFor(owner));
+  return {
+    read(store, owner) {
+      if (store === "file") {
+        try {
+          return parseEntry(fs10.readFileSync(filePath(owner), "utf8"));
+        } catch {
+          return void 0;
+        }
+      }
+      requireKeychain();
+      const result = security(["find-generic-password", "-s", KEYCHAIN_CACHE_SERVICE, "-a", owner, "-w"]);
+      return result.status === 0 ? parseEntry(Buffer.from(result.stdout.trim(), "base64").toString("utf8")) : void 0;
+    },
+    write(store, owner, entry) {
+      const serialised = JSON.stringify(entry);
+      if (store === "file") {
+        fs10.mkdirSync(dir, { recursive: true, mode: CACHE_DIR_MODE });
+        fs10.chmodSync(dir, CACHE_DIR_MODE);
+        const target = filePath(owner);
+        const temp = `${target}.${String(process.pid)}.tmp`;
+        fs10.writeFileSync(temp, serialised, { mode: CACHE_FILE_MODE });
+        fs10.renameSync(temp, target);
+        return;
+      }
+      requireKeychain();
+      const encoded = Buffer.from(serialised, "utf8").toString("base64");
+      const result = security(["-i"], `add-generic-password -U -s ${KEYCHAIN_CACHE_SERVICE} -a ${JSON.stringify(owner)} -w ${encoded}
+`);
+      if (result.status !== 0) {
+        throw new Error(`could not write the keychain credential cache for ${owner}`);
+      }
+    },
+    remove(store, owner) {
+      if (store === "file") {
+        fs10.rmSync(filePath(owner), { force: true });
+        return;
+      }
+      requireKeychain();
+      security(["delete-generic-password", "-s", KEYCHAIN_CACHE_SERVICE, "-a", owner]);
+    }
+  };
+}
+function realCredentialCacheEnv(paths) {
+  return { port: createRealCredentialCache(paths.root), platform: process.platform, now: () => Date.now() };
+}
+
+// src/frontdoor/realFrontDoorPort.ts
+import fs11 from "node:fs";
+
+// src/frontdoor/probe.ts
+import { Worker } from "node:worker_threads";
+var PROBE_TIMEOUT_MS = 2e3;
+var PROBE_WAIT_MARGIN_MS = 1e3;
+var REASON_BYTES = 1024;
+var HEADER_SLOTS = 2;
+var INT32_BYTES = 4;
+var VERDICT_PENDING = 0;
+var VERDICT_OK = 1;
+var VERDICT_FAILED = 2;
+var PROBE_SOURCE = `
+const { workerData } = require("node:worker_threads");
+const https = require("node:https");
+const { port, ca, timeoutMs, shared, ok, failed, headerSlots } = workerData;
+const header = new Int32Array(shared, 0, headerSlots);
+const reason = new Uint8Array(shared, headerSlots * 4);
+let done = false;
+const finish = (verdict, message) => {
+  if (done) return;
+  done = true;
+  const bytes = Buffer.from(String(message), "utf8").subarray(0, reason.length);
+  reason.set(bytes);
+  Atomics.store(header, 1, bytes.length);
+  Atomics.store(header, 0, verdict);
+  Atomics.notify(header, 0);
+};
+const request = https.get({ host: "127.0.0.1", port, path: "/healthz", ca: [ca], agent: false }, (response) => {
+  let body = "";
+  response.setEncoding("utf8");
+  response.on("data", (chunk) => { body += chunk; });
+  response.on("end", () => {
+    if (response.statusCode === 200 && body === "ok") finish(ok, "");
+    else finish(failed, "the listener answered its health probe with HTTP " + String(response.statusCode));
+  });
+  response.on("error", (error) => finish(failed, error.message));
+});
+// A hard deadline over the whole exchange, handshake included: a listener that accepts the connection and then says nothing must still fail the probe.
+setTimeout(() => { request.destroy(new Error("no answer within " + String(timeoutMs) + "ms")); }, timeoutMs);
+request.on("error", (error) => finish(failed, (error.code ? error.code + ": " : "") + error.message));
+`;
+function probeFrontDoorSync(port, caPem) {
+  const shared = new SharedArrayBuffer(HEADER_SLOTS * INT32_BYTES + REASON_BYTES);
+  const header = new Int32Array(shared, 0, HEADER_SLOTS);
+  const worker = new Worker(PROBE_SOURCE, {
+    eval: true,
+    workerData: { port, ca: caPem, timeoutMs: PROBE_TIMEOUT_MS, shared, ok: VERDICT_OK, failed: VERDICT_FAILED, headerSlots: HEADER_SLOTS }
+  });
+  worker.unref();
+  try {
+    const waited = Atomics.wait(header, 0, VERDICT_PENDING, PROBE_TIMEOUT_MS + PROBE_WAIT_MARGIN_MS);
+    const verdict = Atomics.load(header, 0);
+    if (waited === "timed-out" || verdict === VERDICT_PENDING) {
+      return { ok: false, reason: `the probe did not finish within ${String(PROBE_TIMEOUT_MS + PROBE_WAIT_MARGIN_MS)}ms` };
+    }
+    if (verdict === VERDICT_OK) {
+      return { ok: true };
+    }
+    const length = Atomics.load(header, 1);
+    return { ok: false, reason: Buffer.from(new Uint8Array(shared, HEADER_SLOTS * INT32_BYTES, length)).toString("utf8") };
+  } finally {
+    void worker.terminate();
+  }
+}
+
+// src/frontdoor/trust.ts
+import { createHash as createHash5 } from "node:crypto";
+import path27 from "node:path";
+var BUNDLE_NAME_HEX_DIGITS = 16;
+function resolveTrustBundle(params) {
+  const { caCertFile, bundlesDir, inherited, fs: fs12 } = params;
+  if (inherited === void 0 || inherited === "" || path27.resolve(inherited) === path27.resolve(caCertFile)) {
+    return { path: caCertFile };
+  }
+  const caPem = fs12.readFileUtf8(caCertFile);
+  let inheritedPem;
+  try {
+    inheritedPem = fs12.readFileUtf8(inherited);
+  } catch (error) {
+    return {
+      path: caCertFile,
+      warning: `agent-shim: NODE_EXTRA_CA_CERTS names ${inherited}, which could not be read (${error instanceof Error ? error.message : String(error)}); the child trusts agent-shim's front-door CA on top of the system store, and nothing from that file`
+    };
+  }
+  if (inheritedPem.includes(caPem.trim())) {
+    return { path: inherited };
+  }
+  const combined = `${inheritedPem.trimEnd()}
+${caPem}`;
+  const bundle = path27.join(bundlesDir, `${createHash5("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  if (!fs12.exists(bundle)) {
+    fs12.mkdirp(bundlesDir);
+    fs12.writeFileAtomic(bundle, combined);
+  }
+  return { path: bundle };
+}
+
+// src/frontdoor/realFrontDoorPort.ts
+var realTrustBundleFs = {
+  readFileUtf8: (file) => fs11.readFileSync(file, "utf8"),
+  exists: (file) => fs11.existsSync(file),
+  mkdirp: (dir) => {
+    fs11.mkdirSync(dir, { recursive: true });
+  },
+  writeFileAtomic: (file, contents) => {
+    realFarmFs.writeFilePrivate(file, contents);
+  }
+};
+function realFrontDoorPort(paths, spawnDaemon) {
+  return {
+    ensure: (inheritedExtraCaCerts) => {
+      const up = ensureFrontDoor({
+        paths,
+        launcherPid: process.pid,
+        ports: {
+          fs: realFarmFs,
+          isRunning: realIsProcessRunning,
+          now: () => Date.now(),
+          sleep: realSleepSync,
+          spawnSupervisor: (layout) => spawnDaemon(layout, "__frontdoor-supervisor", layout.frontdoorLogPath),
+          stopSupervisor: (pid) => {
+            process.kill(pid, "SIGTERM");
+          },
+          // Read fresh for each probe: a replacement supervisor may have regenerated an unparseable CA, and the probe must trust exactly what the serving door's leaf chains to.
+          verifyListener: (port) => probeFrontDoorSync(port, fs11.readFileSync(paths.frontdoorCaCertFile, "utf8"))
+        }
+      });
+      const trust = resolveTrustBundle({ caCertFile: paths.frontdoorCaCertFile, bundlesDir: paths.frontdoorCaBundlesDir, inherited: inheritedExtraCaCerts, fs: realTrustBundleFs });
+      return {
+        port: up.port,
+        connectPort: up.connectPort,
+        trustBundlePath: trust.path,
+        ...trust.warning === void 0 ? {} : { trustWarning: trust.warning },
+        sessionToken: up.token
+      };
+    },
+    release: () => {
+      removeFrontDoorSession(realFarmFs, paths.frontdoorSessionsDir, process.pid);
+    }
+  };
+}
+
+// src/launchWiring.ts
+function buildFarmRuntime(paths, cwd) {
+  const home = os5.homedir();
+  const read = cosmiconfigReader();
+  const classification = loadClassification(paths);
+  const loaded = loadCascadeInput({ paths, home, cwd, read });
+  const selections = readDirectorySelections(loaded);
+  const git = resolveGitBranch(realRunPort, cwd);
+  return {
+    runtime: {
+      fs: realFarmFs,
+      claudeHome: resolveClaudeHome(),
+      home,
+      cwd,
+      ...git.branch === void 0 ? {} : { branch: git.branch },
+      ...git.branchDetached === void 0 ? {} : { branchDetached: git.branchDetached },
+      classification,
+      loadCascade: (baseConfigProfile, cliOverride) => loadCascadeInput({
+        paths,
+        home,
+        cwd,
+        read,
+        ...baseConfigProfile === void 0 ? {} : { baseConfigProfile },
+        ...cliOverride === void 0 ? {} : { cliOverride }
+      }).input,
+      now: () => Date.now(),
+      uniqueSuffix: `${String(process.pid)}.${randomUUID5()}`,
+      // Zombie-aware on purpose: a previous launcher that crashed out of a resync without releasing the lock may sit unreaped, still answering signal 0 as alive, and must read as a dead holder so this launch takes the lock over instead of timing out.
+      lock: { pid: process.pid, isRunning: realIsProcessRunning, sleep: realSleepSync }
+    },
+    ...selections.identity === void 0 ? {} : { directoryIdentity: selections.identity },
+    ...selections.configProfile === void 0 ? {} : { directoryConfigProfile: selections.configProfile },
+    ...loaded.globalConfig?.defaultConfigProfile === void 0 ? {} : { globalDefaultConfigProfile: loaded.globalConfig.defaultConfigProfile },
+    ...loaded.globalConfig?.pools === void 0 ? {} : { pools: loaded.globalConfig.pools }
+  };
+}
+function realPrepareLaunchParams(paths, options) {
+  const { farm } = options;
+  return {
+    paths,
+    fs: realFsPort,
+    proc: options.proc,
+    log: options.log,
+    resolveClaudeBinary: realResolveClaudeBinary(resolveOwnInstallDirs(paths, realOwnExecutablePath())),
+    farm: farm.runtime,
+    headroom: realHeadroomPort(paths, { spawnDaemon: options.spawnDaemon, cwd: farm.runtime.cwd }),
+    frontdoor: realFrontDoorPort(paths, options.spawnDaemon),
+    credentials: { ...realCredentialPort, cache: realCredentialCacheEnv(paths) },
+    ...farm.directoryIdentity === void 0 ? {} : { directoryPinnedIdentity: farm.directoryIdentity },
+    ...farm.directoryConfigProfile === void 0 ? {} : { directoryRuleConfigProfile: farm.directoryConfigProfile },
+    ...farm.globalDefaultConfigProfile === void 0 ? {} : { globalDefaultConfigProfile: farm.globalDefaultConfigProfile },
+    ...farm.pools === void 0 ? {} : { pools: farm.pools },
+    ...options.allowMissingConfigProfile === void 0 ? {} : { allowMissingConfigProfile: options.allowMissingConfigProfile }
+  };
+}
+var LaunchRefusedError = class extends CliError {
+  exitCode;
+  constructor(message, exitCode) {
+    super(message);
+    this.name = "LaunchRefusedError";
+    this.exitCode = exitCode;
+  }
+};
+function prepareClaudeLaunch(options) {
+  const paths = options.paths ?? resolveLayoutPaths();
+  const refusals = [];
+  const log = {
+    info: () => void 0,
+    warn: () => void 0,
+    error: (message) => {
+      refusals.push(message);
+    }
+  };
+  const proc = {
+    env: options.env,
+    argv: options.argv,
+    exit: (code) => {
+      throw new LaunchRefusedError(refusals.join("\n") || `the launch was refused (exit ${String(code)})`, code);
+    }
+  };
+  const spawnDaemon = options.agentShim === void 0 ? () => {
+    throw new LaunchRefusedError("this launch routes through the front door or headroom, which need `agentShim`, the path of the agent-shim executable, to start their daemons", 1);
+  } : spawnDaemonThrough(options.agentShim);
+  return prepareLaunch(realPrepareLaunchParams(paths, { proc, log, spawnDaemon, farm: buildFarmRuntime(paths, options.cwd) }));
+}
 export {
   AMBIENT_CREDENTIAL_VARS,
   CONNECT_INTERCEPT_HOST,
@@ -6664,6 +7989,7 @@ export {
   InvalidCategoryNameError,
   InvalidIdentityNameError,
   InvalidProviderNameError,
+  LaunchRefusedError,
   LegacyProviderFileError,
   PoolNameSchema,
   PoolNotFoundError,
@@ -6714,6 +8040,8 @@ export {
   listUsageSnapshots,
   mintLeaf,
   parseConnectTarget,
+  prepareClaudeLaunch,
+  prepareLaunch,
   profileExists,
   providerExists,
   readActiveIdentity,