agent-shim 7.3.0 → 7.5.0

package/dist/index.cjs

@@ -32,14 +32,37 @@ var index_exports = {};
 __export(index_exports, {
   AMBIENT_CREDENTIAL_VARS: () => AMBIENT_CREDENTIAL_VARS,
   CONNECT_INTERCEPT_HOST: () => CONNECT_INTERCEPT_HOST,
+  CONNECT_INTERCEPT_HOSTS: () => CONNECT_INTERCEPT_HOSTS,
   CONNECT_LIMITS: () => CONNECT_LIMITS,
+  CategoryClassificationOverlaySchema: () => CategoryClassificationOverlaySchema,
+  CategoryClassificationSchema: () => CategoryClassificationSchema,
+  CategoryMapSchema: () => CategoryMapSchema,
+  CliError: () => CliError,
+  ConfigProfileSchema: () => ConfigProfileSchema,
+  CredentialCacheSchema: () => CredentialCacheSchema,
+  CredentialSchema: () => CredentialSchema,
+  CredentialSourceSchema: () => CredentialSourceSchema,
+  DirectoryRuleSchema: () => DirectoryRuleSchema,
+  DirectoryRulesSchema: () => DirectoryRulesSchema,
+  EXIT_FAILURE: () => EXIT_FAILURE,
+  EXIT_USAGE: () => EXIT_USAGE,
+  EntryValueSchema: () => EntryValueSchema,
   FARM_MANIFEST_FILENAME: () => FARM_MANIFEST_FILENAME,
   FrontDoorStartError: () => FrontDoorStartError,
+  GlobalConfigSchema: () => GlobalConfigSchema,
   HeadroomStartError: () => HeadroomStartError,
+  IdentitySchema: () => IdentitySchema,
+  PoolNameSchema: () => PoolNameSchema,
+  PoolSchema: () => PoolSchema,
+  PortableConfigSchema: () => PortableConfigSchema,
+  ProviderSchema: () => ProviderSchema,
   ROUTED_PATH_PREFIX: () => ROUTED_PATH_PREFIX,
+  UsageError: () => UsageError,
   UsageSnapshotError: () => UsageSnapshotError,
   UsageSnapshotSchema: () => UsageSnapshotSchema,
+  WhenSchema: () => WhenSchema,
   buildEntryFacts: () => buildEntryFacts,
+  buildLayoutPaths: () => buildLayoutPaths,
   carryOver: () => carryOver,
   createLeafCache: () => createLeafCache,
   detectAmbientCredential: () => detectAmbientCredential,
@@ -60,7 +83,10 @@ __export(index_exports, {
   realConnectEffects: () => realConnectEffects,
   recoverFarm: () => recoverFarm,
   recoveryDiagnostics: () => recoveryDiagnostics,
+  resolveAgentShimHome: () => resolveAgentShimHome,
+  resolveClaudeHome: () => resolveClaudeHome,
   resolveDecisions: () => resolveDecisions,
+  resolveLayoutPaths: () => resolveLayoutPaths,
   resolveSupervisorConfig: () => resolveSupervisorConfig,
   resyncFarm: () => resyncFarm,
   runFrontDoorSupervisor: () => runFrontDoorSupervisor,
@@ -322,10 +348,18 @@ var import_cosmiconfig = require("cosmiconfig");
 
 // src/cliError.ts
 var EXIT_FAILURE = 1;
+var EXIT_USAGE = 2;
 var CliError = class extends Error {
   /** The process exit status this failure maps to. `EXIT_FAILURE` unless a subclass says otherwise. */
   exitCode = EXIT_FAILURE;
 };
+var UsageError = class extends CliError {
+  exitCode = EXIT_USAGE;
+  constructor(message) {
+    super(message);
+    this.name = "UsageError";
+  }
+};
 
 // src/config/classify.ts
 var GLOB_METACHARACTERS = /[*?[\]{}!()]/;
@@ -1286,6 +1320,8 @@ function planReconciliation(params) {
 }
 
 // src/legacy.ts
+var HOME_DIRNAME = ".agent-shim";
+var LEGACY_HOME_DIRNAME = ".claude-use";
 var LEGACY_FARM_MANIFEST_FILENAME = ".claude-use-farm.json";
 
 // src/launcher/lock.ts
@@ -1387,8 +1423,8 @@ var FarmManifestSchema = import_zod2.z.strictObject({
   materialised: import_zod2.z.array(import_zod2.z.string()),
   links: import_zod2.z.array(import_zod2.z.strictObject({ rel: import_zod2.z.string(), target: import_zod2.z.string() }))
 });
-function readFarmManifest(fs2, farmRoot) {
-  const raw = fs2.readFileUtf8(import_node_path4.default.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs2.readFileUtf8(import_node_path4.default.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
+function readFarmManifest(fs3, farmRoot) {
+  const raw = fs3.readFileUtf8(import_node_path4.default.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs3.readFileUtf8(import_node_path4.default.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
   if (raw === void 0) {
     return void 0;
   }
@@ -1446,9 +1482,9 @@ function buildEntryFacts(params) {
     entries
   };
 }
-function listSubtree(fs2, root, rel) {
+function listSubtree(fs3, root, rel) {
   const absolute = import_node_path4.default.join(root, rel);
-  const stat = fs2.lstat(absolute);
+  const stat = fs3.lstat(absolute);
   if (stat === void 0) {
     return [];
   }
@@ -1456,10 +1492,10 @@ function listSubtree(fs2, root, rel) {
     return [{ rel, kind: "symlink" }];
   }
   if (stat.kind === "dir") {
-    const children = [...fs2.readdir(absolute)].sort().flatMap((name) => listSubtree(fs2, root, `${rel}/${name}`));
+    const children = [...fs3.readdir(absolute)].sort().flatMap((name) => listSubtree(fs3, root, `${rel}/${name}`));
     return [{ rel, kind: "dir" }, ...children];
   }
-  const contentHash = fs2.hashFile(absolute);
+  const contentHash = fs3.hashFile(absolute);
   return [{ rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } }];
 }
 function topLevelScopeRoots(roots) {
@@ -1473,25 +1509,25 @@ function topLevelScopeRoots(roots) {
   }
   return kept;
 }
-function reconciliationScope(fs2, farmRoot, manifest) {
+function reconciliationScope(fs3, farmRoot, manifest) {
   if (manifest !== void 0) {
     return topLevelScopeRoots(manifest.materialised);
   }
-  return [...fs2.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs2.lstat(import_node_path4.default.join(farmRoot, name))?.kind === "dir").sort();
+  return [...fs3.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs3.lstat(import_node_path4.default.join(farmRoot, name))?.kind === "dir").sort();
 }
-function collectFarmListing(fs2, farmRoot, scopeRoots) {
-  return scopeRoots.flatMap((root) => listSubtree(fs2, farmRoot, root));
+function collectFarmListing(fs3, farmRoot, scopeRoots) {
+  return scopeRoots.flatMap((root) => listSubtree(fs3, farmRoot, root));
 }
-function collectCanonicalCounterparts(fs2, claudeHome, farmListing) {
+function collectCanonicalCounterparts(fs3, claudeHome, farmListing) {
   const out = [];
   for (const entry of farmListing) {
     const absolute = import_node_path4.default.join(claudeHome, entry.rel);
-    const stat = fs2.lstat(absolute);
+    const stat = fs3.lstat(absolute);
     if (stat === void 0) {
       continue;
     }
     if (stat.kind === "file") {
-      const contentHash = fs2.hashFile(absolute);
+      const contentHash = fs3.hashFile(absolute);
       out.push({ rel: entry.rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } });
       continue;
     }
@@ -2175,10 +2211,10 @@ var FrontDoorStateSchema = import_zod3.z.strictObject({
   /** The last fatal error, kept across shutdowns so `frontdoor status` can explain a front door that is not running. */
   lastError: import_zod3.z.string().optional()
 });
-function readFrontDoorState(fs2, stateFile) {
+function readFrontDoorState(fs3, stateFile) {
   let raw;
   try {
-    raw = fs2.readFileUtf8(stateFile);
+    raw = fs3.readFileUtf8(stateFile);
   } catch {
     return void 0;
   }
@@ -2192,28 +2228,28 @@ function readFrontDoorState(fs2, stateFile) {
     return void 0;
   }
 }
-function writeFrontDoorState(fs2, stateFile, state) {
-  fs2.mkdirp(import_node_path5.default.dirname(stateFile));
-  fs2.writeFileUtf8(stateFile, `${JSON.stringify(state, null, 2)}
+function writeFrontDoorState(fs3, stateFile, state) {
+  fs3.mkdirp(import_node_path5.default.dirname(stateFile));
+  fs3.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(fs2, sessionsDir, session) {
-  fs2.mkdirPrivate(sessionsDir);
-  fs2.writeFilePrivate(import_node_path5.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeFrontDoorSession(fs3, sessionsDir, session) {
+  fs3.mkdirPrivate(sessionsDir);
+  fs3.writeFilePrivate(import_node_path5.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function listFrontDoorSessions(fs2, sessionsDir) {
+function listFrontDoorSessions(fs3, sessionsDir) {
   const sessions = [];
-  for (const name of fs2.readdir(sessionsDir)) {
+  for (const name of fs3.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs2.readFileUtf8(import_node_path5.default.join(sessionsDir, name)) ?? ""));
+      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs3.readFileUtf8(import_node_path5.default.join(sessionsDir, name)) ?? ""));
       if (parsed.success) {
         sessions.push({ pid: parsed.data.pid, startedAt: parsed.data.startedAt });
       }
@@ -2223,14 +2259,14 @@ function listFrontDoorSessions(fs2, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
-function removeFrontDoorSession(fs2, sessionsDir, pid) {
-  fs2.removeRecursive(import_node_path5.default.join(sessionsDir, `${String(pid)}.json`));
+function removeFrontDoorSession(fs3, sessionsDir, pid) {
+  fs3.removeRecursive(import_node_path5.default.join(sessionsDir, `${String(pid)}.json`));
 }
-function pruneDeadFrontDoorSessions(fs2, sessionsDir, isRunning) {
+function pruneDeadFrontDoorSessions(fs3, sessionsDir, isRunning) {
   const removed = [];
-  for (const session of listFrontDoorSessions(fs2, sessionsDir)) {
+  for (const session of listFrontDoorSessions(fs3, sessionsDir)) {
     if (!isRunning(session.pid)) {
-      removeFrontDoorSession(fs2, sessionsDir, session.pid);
+      removeFrontDoorSession(fs3, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
@@ -2242,8 +2278,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: fs2, paths } = ports;
-  const previous = readFrontDoorState(fs2, paths.frontdoorStateFile);
+  const { fs: fs3, paths } = ports;
+  const previous = readFrontDoorState(fs3, paths.frontdoorStateFile);
   let lastPort = previous?.lastPort;
   let lastConnectPort = previous?.lastConnectPort;
   let lastDirectPort = previous?.lastDirectPort;
@@ -2253,12 +2289,12 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     ...lastDirectPort === void 0 ? {} : { lastDirectPort }
   });
   const fail = (message) => {
-    writeFrontDoorState(fs2, paths.frontdoorStateFile, { lastError: message, ...sticky() });
-    fs2.removeRecursive(paths.frontdoorLockFile);
+    writeFrontDoorState(fs3, paths.frontdoorStateFile, { lastError: message, ...sticky() });
+    fs3.removeRecursive(paths.frontdoorLockFile);
     ports.log(`agent-shim frontdoor supervisor: ${message}`);
     return 1;
   };
-  writeFrontDoorState(fs2, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
+  writeFrontDoorState(fs3, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
   const previousSticky = lastPort;
   let http2;
   try {
@@ -2295,8 +2331,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(fs2, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, port: http2.port, connectPort: connect2.port, directPort: direct.port, ...sticky() });
-  fs2.removeRecursive(paths.frontdoorLockFile);
+  writeFrontDoorState(fs3, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, port: http2.port, connectPort: connect2.port, directPort: direct.port, ...sticky() });
+  fs3.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(connect2.port)}`);
   let idleSince;
   let ticks = 0;
@@ -2305,15 +2341,15 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
       return FRONTDOOR_SUPERVISOR_STILL_RUNNING;
     }
     ticks += 1;
-    pruneDeadFrontDoorSessions(fs2, paths.frontdoorSessionsDir, ports.isRunning);
-    if (listFrontDoorSessions(fs2, paths.frontdoorSessionsDir).length === 0) {
+    pruneDeadFrontDoorSessions(fs3, paths.frontdoorSessionsDir, ports.isRunning);
+    if (listFrontDoorSessions(fs3, 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 connect2.close();
         await http2.close();
-        writeFrontDoorState(fs2, paths.frontdoorStateFile, sticky());
+        writeFrontDoorState(fs3, paths.frontdoorStateFile, sticky());
         return 0;
       }
     } else {
@@ -2325,6 +2361,7 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
 
 // src/frontdoor/connect.ts
 var CONNECT_INTERCEPT_HOST = "api.anthropic.com";
+var CONNECT_INTERCEPT_HOSTS = [CONNECT_INTERCEPT_HOST, "platform.claude.com"];
 var ROUTED_PATH_PREFIX = "/v1/";
 var HTTPS_PORT = 443;
 var MAX_PORT = 65535;
@@ -2364,11 +2401,11 @@ function parseConnectTarget(authority) {
   }
   return { host, port };
 }
-function isInterceptedHost(host, interceptHost) {
-  return host === interceptHost;
+function isInterceptedHost(host, interceptHosts) {
+  return interceptHosts.includes(host);
 }
-function servedByPipeline(path8) {
-  return path8?.startsWith(ROUTED_PATH_PREFIX) === true;
+function servedByPipeline(path9) {
+  return path9?.startsWith(ROUTED_PATH_PREFIX) === true;
 }
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
@@ -2435,28 +2472,34 @@ function caParses(ca) {
   }
 }
 async function startConnectServer(config, effects, preferredPort) {
-  const handler = (request3, response) => {
-    if (servedByPipeline(request3.url)) {
-      config.serveRouted(request3, response);
-      return;
-    }
-    effects.forwardHttp(config.upstream, request3, response, config.capture?.observePassthrough(request3));
-  };
-  const httpSession = effects.createHttpSession(handler, config.capture === void 0 ? void 0 : (request3) => config.capture?.upgrade(request3));
-  const tlsAcceptor = effects.createTlsAcceptor(config.leafFor(config.interceptHost), (secure) => {
-    httpSession.serve(secure);
+  const onUpgrade = config.capture === void 0 ? void 0 : (request3) => config.capture?.upgrade(request3);
+  const sessions = config.interceptHosts.map((host) => {
+    const handler = (request3, response) => {
+      if (host === config.routedHost && servedByPipeline(request3.url)) {
+        config.serveRouted(request3, response);
+        return;
+      }
+      effects.forwardHttp(config.upstreamFor(host), request3, response, config.capture?.observePassthrough(request3));
+    };
+    const httpSession = effects.createHttpSession(handler, onUpgrade);
+    const tlsAcceptor = effects.createTlsAcceptor(config.leafFor(host), (secure) => {
+      httpSession.serve(secure);
+    });
+    return { host, httpSession, tlsAcceptor };
   });
   const ledger = createConnectionLedger(config.limits, config.isLiveCapability);
   const listener = await effects.listenLoopback(preferredPort, (socket) => {
-    handleConnect(socket, { config, effects, tlsAcceptor, ledger });
+    handleConnect(socket, { config, effects, sessions, ledger });
   });
   return {
     port: listener.port,
     close: async () => {
       ledger.close();
       await listener.close();
-      tlsAcceptor.close();
-      httpSession.close();
+      for (const { httpSession, tlsAcceptor } of sessions) {
+        tlsAcceptor.close();
+        httpSession.close();
+      }
     }
   };
 }
@@ -2576,7 +2619,7 @@ function proxyAuthorizationOf(head) {
   return values.length === 1 ? value : void 0;
 }
 function routeConnect(socket, head, context) {
-  const { config, effects, tlsAcceptor, ledger } = context;
+  const { config, effects, sessions, ledger } = context;
   const credential = proxyAuthorizationOf(head);
   const capability = credential === void 0 ? void 0 : capabilityFromProxyAuthorization(credential);
   if (capability === void 0 || !config.isLiveCapability(capability)) {
@@ -2595,10 +2638,11 @@ function routeConnect(socket, head, context) {
     refuse(socket, REFUSAL.serviceUnavailable);
     return;
   }
-  config.capture?.connect(target, isInterceptedHost(target.host, config.interceptHost));
+  const session = sessions.find((entry) => entry.host === target.host);
+  config.capture?.connect(target, session !== void 0);
   socket.write(CONNECT_ESTABLISHED);
-  if (isInterceptedHost(target.host, config.interceptHost)) {
-    tlsAcceptor.accept(socket);
+  if (session !== void 0) {
+    session.tlsAcceptor.accept(socket);
     return;
   }
   void blindTunnel(socket, target, effects);
@@ -2844,16 +2888,16 @@ function parseJson(raw, schema) {
   const parsed = schema.safeParse(JSON.parse(raw));
   return parsed.success ? parsed.data : void 0;
 }
-function readHeadroomState(fs2, stateFile) {
+function readHeadroomState(fs3, stateFile) {
   try {
-    return parseJson(fs2.readFileUtf8(stateFile), HeadroomStateSchema);
+    return parseJson(fs3.readFileUtf8(stateFile), HeadroomStateSchema);
   } catch {
     return void 0;
   }
 }
-function writeHeadroomState(fs2, stateFile, state) {
-  fs2.mkdirp(import_node_path6.default.dirname(stateFile));
-  fs2.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
+function writeHeadroomState(fs3, stateFile, state) {
+  fs3.mkdirp(import_node_path6.default.dirname(stateFile));
+  fs3.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
 function headroomAllowlist(providers) {
@@ -2873,14 +2917,14 @@ function headroomUpstreams(providers, frontDoorOrigin2) {
 function hashAllowlist(allowlist) {
   return (0, import_node_crypto4.createHash)("sha256").update(allowlist.join("\n")).digest("hex");
 }
-function readAllProviders(fs2, providersDir) {
+function readAllProviders(fs3, providersDir) {
   const result = [];
-  for (const name of fs2.readdir(providersDir)) {
+  for (const name of fs3.readdir(providersDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs2.readFileUtf8(import_node_path6.default.join(providersDir, name)), ProviderSchema);
+      const parsed = parseJson(fs3.readFileUtf8(import_node_path6.default.join(providersDir, name)), ProviderSchema);
       if (parsed !== void 0) {
         result.push({ name: name.slice(0, -".json".length), provider: parsed });
       }
@@ -2890,22 +2934,22 @@ function readAllProviders(fs2, providersDir) {
   }
   return result;
 }
-function writeSession(fs2, sessionsDir, session) {
-  fs2.mkdirp(sessionsDir);
-  fs2.writeFileUtf8(import_node_path6.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeSession(fs3, sessionsDir, session) {
+  fs3.mkdirp(sessionsDir);
+  fs3.writeFileUtf8(import_node_path6.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function removeSession(fs2, sessionsDir, pid) {
-  fs2.removeRecursive(import_node_path6.default.join(sessionsDir, `${String(pid)}.json`));
+function removeSession(fs3, sessionsDir, pid) {
+  fs3.removeRecursive(import_node_path6.default.join(sessionsDir, `${String(pid)}.json`));
 }
-function listSessions(fs2, sessionsDir) {
+function listSessions(fs3, sessionsDir) {
   const sessions = [];
-  for (const name of fs2.readdir(sessionsDir)) {
+  for (const name of fs3.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs2.readFileUtf8(import_node_path6.default.join(sessionsDir, name)), HeadroomSessionSchema);
+      const parsed = parseJson(fs3.readFileUtf8(import_node_path6.default.join(sessionsDir, name)), HeadroomSessionSchema);
       if (parsed !== void 0) {
         sessions.push(parsed);
       }
@@ -2915,22 +2959,22 @@ function listSessions(fs2, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
-function sessionsForSupervisor(fs2, sessionsDir, supervisorPid) {
-  return listSessions(fs2, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
+function sessionsForSupervisor(fs3, sessionsDir, supervisorPid) {
+  return listSessions(fs3, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
 }
-function pruneDeadSessions(fs2, sessionsDir, isRunning) {
+function pruneDeadSessions(fs3, sessionsDir, isRunning) {
   const removed = [];
-  for (const session of listSessions(fs2, sessionsDir)) {
+  for (const session of listSessions(fs3, sessionsDir)) {
     if (!isRunning(session.pid)) {
-      removeSession(fs2, sessionsDir, session.pid);
+      removeSession(fs3, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
   return removed;
 }
-function readStartLock(fs2, lockFile) {
+function readStartLock(fs3, lockFile) {
   try {
-    return parseJson(fs2.readFileUtf8(lockFile), HeadroomLockSchema);
+    return parseJson(fs3.readFileUtf8(lockFile), HeadroomLockSchema);
   } catch {
     return void 0;
   }
@@ -3167,9 +3211,9 @@ function snapshotPath(snapshotsDir, identity) {
   }
   return import_node_path7.default.join(snapshotsDir, `${identity}.json`);
 }
-function readUsageSnapshot(fs2, snapshotsDir, identity) {
+function readUsageSnapshot(fs3, snapshotsDir, identity) {
   const file = snapshotPath(snapshotsDir, identity);
-  const raw = fs2.readFileUtf8(file);
+  const raw = fs3.readFileUtf8(file);
   if (raw === void 0) {
     return void 0;
   }
@@ -3185,8 +3229,8 @@ function readUsageSnapshot(fs2, snapshotsDir, identity) {
   }
   return snapshot.data;
 }
-function listUsageSnapshots(fs2, snapshotsDir) {
-  return fs2.readdir(snapshotsDir).flatMap((name) => {
+function listUsageSnapshots(fs3, snapshotsDir) {
+  return fs3.readdir(snapshotsDir).flatMap((name) => {
     if (!name.endsWith(".json")) {
       return [];
     }
@@ -3194,7 +3238,7 @@ function listUsageSnapshots(fs2, snapshotsDir) {
     if (!isIdentityName(identity)) {
       return [];
     }
-    const snapshot = readUsageSnapshot(fs2, snapshotsDir, identity);
+    const snapshot = readUsageSnapshot(fs3, snapshotsDir, identity);
     return snapshot === void 0 ? [] : [snapshot];
   }).sort((left, right) => left.identity.localeCompare(right.identity));
 }
@@ -3361,9 +3405,9 @@ function compareVersions(a, b) {
 }
 var HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
 async function runSupervisor(initialConfig, ports, options = {}) {
-  const { fs: fs2, paths } = ports;
+  const { fs: fs3, paths } = ports;
   let config = initialConfig;
-  const previousState = readHeadroomState(fs2, paths.headroomStateFile);
+  const previousState = readHeadroomState(fs3, 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;
@@ -3372,19 +3416,19 @@ async function runSupervisor(initialConfig, ports, options = {}) {
   let lastPort = previousState?.lastPort;
   const sticky = () => lastPort === void 0 ? {} : { lastPort };
   const ownsState = () => {
-    const owner = readHeadroomState(fs2, paths.headroomStateFile)?.supervisorPid;
+    const owner = readHeadroomState(fs3, paths.headroomStateFile)?.supervisorPid;
     return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
   };
   const writeOwnState = (state) => {
     if (!ownsState()) {
       return false;
     }
-    writeHeadroomState(fs2, paths.headroomStateFile, state);
+    writeHeadroomState(fs3, paths.headroomStateFile, state);
     return true;
   };
   const fail = (message) => {
     if (writeOwnState({ lastError: message, ...sticky() })) {
-      fs2.removeRecursive(paths.headroomLockFile);
+      fs3.removeRecursive(paths.headroomLockFile);
     }
     ports.log(`agent-shim headroom supervisor: ${message}`);
     return 1;
@@ -3433,7 +3477,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     const settingsHash = hashSettings(config.settings);
     const allowlist = allowlistOf(ports);
     const allowlistHash = hashAllowlist(allowlist);
-    pruneDeadSessions(fs2, paths.headroomSessionsDir, ports.isRunning);
+    pruneDeadSessions(fs3, 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");
@@ -3485,7 +3529,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           ...sticky()
         });
         if (recorded) {
-          fs2.removeRecursive(paths.headroomLockFile);
+          fs3.removeRecursive(paths.headroomLockFile);
         }
         idleSince = void 0;
         ports.log(`agent-shim headroom supervisor: headroom pid ${String(pid)} ready on 127.0.0.1:${String(port)}`);
@@ -3500,7 +3544,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
       }
     } else {
       if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config.source) {
-        if (sessionsForSupervisor(fs2, paths.headroomSessionsDir, ports.ownPid).length === 0) {
+        if (sessionsForSupervisor(fs3, 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;
@@ -3509,7 +3553,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           continue;
         }
       }
-      const sessions = sessionsForSupervisor(fs2, paths.headroomSessionsDir, ports.ownPid);
+      const sessions = sessionsForSupervisor(fs3, paths.headroomSessionsDir, ports.ownPid);
       if (sessions.length === 0) {
         idleSince ??= ports.now();
         const idleMs = ports.now() - idleSince;
@@ -3531,9 +3575,9 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     await ports.sleep(HEADROOM_POLL_MS);
   }
 }
-function currentHeadroomAllowlist(fs2, paths) {
-  const providers = readAllProviders(fs2, paths.providersDir).map((entry) => entry.provider);
-  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs2, paths.frontdoorStateFile))));
+function currentHeadroomAllowlist(fs3, paths) {
+  const providers = readAllProviders(fs3, paths.providersDir).map((entry) => entry.provider);
+  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs3, paths.frontdoorStateFile))));
 }
 function allowlistOf(ports) {
   return currentHeadroomAllowlist(ports.fs, ports.paths);
@@ -3597,18 +3641,100 @@ function evaluateAmbientCredentialGuard(params) {
     message: formatAmbientCredentialGuardMessage(detected.variable, params.identityName)
   };
 }
+
+// src/paths.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path8 = __toESM(require("node:path"), 1);
+function resolveAgentShimHome(env = process.env, home = import_node_os.default.homedir(), isDirectory = isExistingDirectory) {
+  const fromEnv = env.AGENT_SHIM_HOME;
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    return fromEnv;
+  }
+  const current = import_node_path8.default.join(home, HOME_DIRNAME);
+  const legacy = import_node_path8.default.join(home, LEGACY_HOME_DIRNAME);
+  return !isDirectory(current) && isDirectory(legacy) ? legacy : current;
+}
+function isExistingDirectory(candidate) {
+  return import_node_fs.default.statSync(candidate, { throwIfNoEntry: false })?.isDirectory() ?? false;
+}
+function resolveClaudeHome() {
+  const fromEnv = process.env.AGENT_SHIM_CLAUDE_HOME;
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    return fromEnv;
+  }
+  return import_node_path8.default.join(import_node_os.default.homedir(), ".claude");
+}
+function buildLayoutPaths(root) {
+  return {
+    root,
+    identitiesDir: import_node_path8.default.join(root, "identities"),
+    configProfilesDir: import_node_path8.default.join(root, "config-profiles"),
+    providersDir: import_node_path8.default.join(root, "providers"),
+    directoryRulesFile: import_node_path8.default.join(root, "directory-rules.json"),
+    activeIdentityFile: import_node_path8.default.join(root, "active-identity"),
+    globalConfigFile: import_node_path8.default.join(root, "config.json"),
+    categoriesLocalFile: import_node_path8.default.join(root, "categories.local.json"),
+    claudeShimFile: import_node_path8.default.join(root, "claude-shim.json"),
+    headroomDir: import_node_path8.default.join(root, "headroom"),
+    headroomStateFile: import_node_path8.default.join(root, "headroom", "state.json"),
+    headroomLockFile: import_node_path8.default.join(root, "headroom", "start.lock"),
+    headroomSessionsDir: import_node_path8.default.join(root, "headroom", "sessions"),
+    logsDir: import_node_path8.default.join(root, "logs"),
+    headroomLogPath: import_node_path8.default.join(root, "logs", "headroom.log"),
+    frontdoorDir: import_node_path8.default.join(root, "frontdoor"),
+    frontdoorCaDir: import_node_path8.default.join(root, "frontdoor", "ca"),
+    frontdoorCaCertFile: import_node_path8.default.join(root, "frontdoor", "ca", "ca.pem"),
+    frontdoorCaKeyFile: import_node_path8.default.join(root, "frontdoor", "ca", "ca.key"),
+    frontdoorCaBundlesDir: import_node_path8.default.join(root, "frontdoor", "ca", "bundles"),
+    frontdoorStateFile: import_node_path8.default.join(root, "frontdoor", "state.json"),
+    frontdoorLockFile: import_node_path8.default.join(root, "frontdoor", "start.lock"),
+    frontdoorSessionsDir: import_node_path8.default.join(root, "frontdoor", "sessions"),
+    frontdoorLogPath: import_node_path8.default.join(root, "logs", "frontdoor.log"),
+    usageDir: import_node_path8.default.join(root, "usage"),
+    usageLogDir: import_node_path8.default.join(root, "usage", "log"),
+    usageSnapshotsDir: import_node_path8.default.join(root, "usage", "snapshots"),
+    usagePicksFile: import_node_path8.default.join(root, "usage", "picks.json")
+  };
+}
+function resolveLayoutPaths() {
+  return buildLayoutPaths(resolveAgentShimHome());
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AMBIENT_CREDENTIAL_VARS,
   CONNECT_INTERCEPT_HOST,
+  CONNECT_INTERCEPT_HOSTS,
   CONNECT_LIMITS,
+  CategoryClassificationOverlaySchema,
+  CategoryClassificationSchema,
+  CategoryMapSchema,
+  CliError,
+  ConfigProfileSchema,
+  CredentialCacheSchema,
+  CredentialSchema,
+  CredentialSourceSchema,
+  DirectoryRuleSchema,
+  DirectoryRulesSchema,
+  EXIT_FAILURE,
+  EXIT_USAGE,
+  EntryValueSchema,
   FARM_MANIFEST_FILENAME,
   FrontDoorStartError,
+  GlobalConfigSchema,
   HeadroomStartError,
+  IdentitySchema,
+  PoolNameSchema,
+  PoolSchema,
+  PortableConfigSchema,
+  ProviderSchema,
   ROUTED_PATH_PREFIX,
+  UsageError,
   UsageSnapshotError,
   UsageSnapshotSchema,
+  WhenSchema,
   buildEntryFacts,
+  buildLayoutPaths,
   carryOver,
   createLeafCache,
   detectAmbientCredential,
@@ -3629,7 +3755,10 @@ function evaluateAmbientCredentialGuard(params) {
   realConnectEffects,
   recoverFarm,
   recoveryDiagnostics,
+  resolveAgentShimHome,
+  resolveClaudeHome,
   resolveDecisions,
+  resolveLayoutPaths,
   resolveSupervisorConfig,
   resyncFarm,
   runFrontDoorSupervisor,