claude-use 7.13.2 → 8.0.0

package/dist/index.cjs

@@ -413,7 +413,7 @@ var HeadroomGlobalConfigSchema = HeadroomGlobalConfigObjectSchema.superRefine((c
     context.addIssue({ code: "custom", path: ["readMaturation"], message: "readMaturation needs rolloutChannel beta or dev" });
   }
 });
-var HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@ecd1c351fcfed97499721e86852e148436ff2ee6";
+var HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@53525f479f2f48e8ef6b08cf729601feab7d2382";
 var HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES = 15;
 var FrontDoorGlobalConfigSchema = import_zod.z.strictObject({
   /** How long the front door may sit with no registered sessions before it closes and exits. Defaults to FRONTDOOR_DEFAULT_IDLE_SHUTDOWN_MINUTES. */
@@ -2650,7 +2650,7 @@ function providerBaseUrl(port, provider) {
 // src/frontdoor/state.ts
 var import_node_path7 = __toESM(require("node:path"), 1);
 var import_zod3 = require("zod");
-var FRONT_DOOR_PROTOCOL = 1;
+var FRONT_DOOR_PROTOCOL = 2;
 var FrontDoorSessionSchema = import_zod3.z.strictObject({ pid: import_zod3.z.number().int().positive(), startedAt: import_zod3.z.number(), token: import_zod3.z.string().min(1) });
 var FrontDoorStateSchema = import_zod3.z.strictObject({
   /**
@@ -2875,8 +2875,8 @@ function parseConnectTarget(authority) {
 function isInterceptedHost(host, interceptHosts) {
   return interceptHosts.includes(host);
 }
-function servedByPipeline(path28) {
-  return path28?.startsWith(ROUTED_PATH_PREFIX) === true;
+function servedByPipeline(path29) {
+  return path29?.startsWith(ROUTED_PATH_PREFIX) === true;
 }
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
@@ -3209,13 +3209,63 @@ function realConnectCertStore(paths) {
 }
 
 // src/frontdoor/connectEffects.ts
+var dns = __toESM(require("node:dns"), 1);
 var http = __toESM(require("node:http"), 1);
 var https = __toESM(require("node:https"), 1);
 var net2 = __toESM(require("node:net"), 1);
 var tls = __toESM(require("node:tls"), 1);
+var UPSTREAM_LOCAL_PORT_START = 47900;
+var UPSTREAM_LOCAL_PORT_END = 47919;
+var nextUpstreamLocalPort = UPSTREAM_LOCAL_PORT_START;
+function upstreamLocalPort() {
+  const port = nextUpstreamLocalPort;
+  nextUpstreamLocalPort = nextUpstreamLocalPort === UPSTREAM_LOCAL_PORT_END ? UPSTREAM_LOCAL_PORT_START : nextUpstreamLocalPort + 1;
+  return port;
+}
+var realAddressLookup = (host, _options, callback) => {
+  if (net2.isIP(host) !== 0) {
+    callback(null, [{ address: host, family: net2.isIP(host) }]);
+    return;
+  }
+  dns.resolve4(host, (error, addresses) => {
+    const first = addresses[0];
+    if (error !== null || first === void 0) {
+      callback(error ?? new Error(`no A record for ${host}`), [{ address: "", family: 4 }]);
+      return;
+    }
+    callback(null, [{ address: first, family: 4 }]);
+  });
+};
+var HTTP_PORT = 80;
+function exemptDial(options, defaultPort) {
+  const host = typeof options.host === "string" ? options.host : "";
+  const port = typeof options.port === "number" ? options.port : defaultPort;
+  return net2.connect(net2.isIP(host) === 0 ? { host, port, localPort: upstreamLocalPort(), lookup: realAddressLookup } : { host, port });
+}
+function requestServername(options, fallback) {
+  return "servername" in options && typeof options.servername === "string" && options.servername !== "" ? options.servername : fallback;
+}
+var ExemptHttpAgent = class extends http.Agent {
+  createConnection(options) {
+    return exemptDial(options, HTTP_PORT);
+  }
+};
+var ExemptTlsAgent = class extends https.Agent {
+  createConnection(options) {
+    const host = typeof options.host === "string" ? options.host : "";
+    const tlsOptions = { socket: exemptDial(options, HTTPS_PORT), servername: requestServername(options, host) };
+    if ("ca" in options && Array.isArray(options.ca)) {
+      tlsOptions.ca = options.ca;
+    }
+    if ("rejectUnauthorized" in options && typeof options.rejectUnauthorized === "boolean") {
+      tlsOptions.rejectUnauthorized = options.rejectUnauthorized;
+    }
+    return tls.connect(tlsOptions);
+  }
+};
 function realConnectEffects() {
-  const plainAgent = new http.Agent({ keepAlive: true });
-  const tlsAgent = new https.Agent({ keepAlive: true });
+  const plainAgent = new ExemptHttpAgent();
+  const tlsAgent = new ExemptTlsAgent();
   const listenOnce = async (port, onSocket) => await new Promise((resolve, reject) => {
     const accepted = /* @__PURE__ */ new Set();
     const server = net2.createServer((socket) => {
@@ -3301,11 +3351,23 @@ function realConnectEffects() {
       };
     },
     connectTlsUpstream: async (host, port, clientAlpn) => await new Promise((resolve, reject) => {
-      const socket = tls.connect({ host, port, servername: host, ...clientAlpn === void 0 ? {} : { ALPNProtocols: [clientAlpn] } });
-      socket.once("secureConnect", () => {
-        resolve(socket);
-      });
-      socket.once("error", reject);
+      const dial = (localPort) => {
+        const raw = net2.connect({ host, port, localPort, lookup: realAddressLookup });
+        return tls.connect({ socket: raw, servername: host, ...clientAlpn === void 0 ? {} : { ALPNProtocols: [clientAlpn] } });
+      };
+      const settle = (candidate) => {
+        candidate.once("secureConnect", () => {
+          resolve(candidate);
+        });
+        candidate.once("error", (error) => {
+          if ("code" in error && error.code === "EADDRINUSE") {
+            settle(dial(upstreamLocalPort()));
+            return;
+          }
+          reject(error);
+        });
+      };
+      settle(dial(upstreamLocalPort()));
     }),
     connectTcp: async (host, port) => await new Promise((resolve, reject) => {
       const socket = net2.connect({ host, port });
@@ -3319,6 +3381,7 @@ function realConnectEffects() {
       const options = {
         host: target.host,
         port: target.port,
+        lookup: realAddressLookup,
         method: request3.method,
         path: request3.url,
         headers,
@@ -3379,17 +3442,16 @@ var import_node_crypto5 = require("node:crypto");
 var import_node_path8 = __toESM(require("node:path"), 1);
 var import_zod4 = require("zod");
 var HEADROOM_ANTHROPIC_UPSTREAM = "https://api.anthropic.com";
+var HEADROOM_STATE_SCHEMA_VERSION = 2;
 var HeadroomStateSchema = import_zod4.z.strictObject({
   /** The supervisor process owning the daemon. Alive means someone is keeping headroom running. */
   supervisorPid: import_zod4.z.number().int().positive().optional(),
   /** The headroom proxy process itself. Absent while the supervisor is between restarts. */
   headroomPid: import_zod4.z.number().int().positive().optional(),
-  /** The loopback port the proxy listens on. Absent until the proxy has passed its readiness check, so "port is set" is itself the ready signal a launcher polls for. */
-  port: import_zod4.z.number().int().positive().optional(),
   /**
-   * The sticky port preference: the address the daemon last served on, kept across crashes, restarts, and idle shutdowns so the next start reuses it. Distinct from `port` on purpose: `port` is the ready signal (absent whenever nothing is serving), while `lastPort` survives every shutdown, because the front door (which routes sessions through this daemon) reads it live and follows a restart to whichever address it lands on.
+   * The unix socket the proxy serves on, inside the owner-only socket directory. Absent until the proxy has passed its readiness check, so "socketPath is set" is itself the ready signal a launcher polls for. The front door reads it on every hop, so a restart (which keeps the generation's path) is followed without anything being relaunched.
    */
-  lastPort: import_zod4.z.number().int().positive().optional(),
+  socketPath: import_zod4.z.string().min(1).optional(),
   /** The `headroom --version` output of the running install. */
   version: import_zod4.z.string().optional(),
   /** Hash of the allowlist the running proxy was started with, so a provider-file change is detected as drift. */
@@ -3896,10 +3958,10 @@ function ensureHeadroom(params) {
   for (; ; ) {
     const state = readHeadroomState(ports.fs, paths.headroomStateFile);
     if (state?.supervisorPid !== void 0 && ports.isRunning(state.supervisorPid)) {
-      const daemonUp = state.port !== void 0 && state.headroomPid !== void 0 && ports.isRunning(state.headroomPid);
-      if (daemonUp && state.port !== void 0) {
+      const daemonUp = state.socketPath !== void 0 && state.headroomPid !== void 0 && ports.isRunning(state.headroomPid);
+      if (daemonUp && state.socketPath !== void 0) {
         writeSession(ports.fs, paths.headroomSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), supervisorPid: state.supervisorPid });
-        return { port: state.port };
+        return { socketPath: state.socketPath };
       }
       if (state.lastError !== void 0) {
         throw new HeadroomStartError(
@@ -3963,6 +4025,71 @@ function hashSettings(settings) {
   return (0, import_node_crypto7.createHash)("sha256").update(JSON.stringify([...settingsArgs(settings), JSON.stringify(settingsEnv(settings))])).digest("hex");
 }
 
+// src/headroom/socket.ts
+var import_node_path11 = __toESM(require("node:path"), 1);
+var GROUP_OR_OTHER_BITS = 63;
+var OCTAL_RADIX = 8;
+var MODE_DIGITS = 4;
+var HEADROOM_SOCKET_SUFFIX = ".sock";
+var HEADROOM_SOCKET_NAME = /^(\d+)\.sock$/;
+var UNIX_SOCKET_PATH_MAX_BYTES = 103;
+var PLATFORMS_WITHOUT_UNIX_SOCKETS = ["win32"];
+function headroomSocketPath(paths, supervisorPid) {
+  return import_node_path11.default.join(paths.headroomSocketDir, `${String(supervisorPid)}${HEADROOM_SOCKET_SUFFIX}`);
+}
+function platformRefusal(platform) {
+  return PLATFORMS_WITHOUT_UNIX_SOCKETS.includes(platform) ? `headroom routing needs a unix domain socket, which headroom cannot serve on ${platform}; agent-shim never falls back to a TCP port for this hop` : void 0;
+}
+function ownerOnlyRefusal(label, target, stat, expected, uid) {
+  if (stat === void 0) {
+    return `the headroom ${label} ${target} does not exist`;
+  }
+  if (stat.kind === "symlink") {
+    return `the headroom ${label} ${target} is a symlink; it must be the real ${expected === "dir" ? "directory" : "socket"}`;
+  }
+  if (stat.kind !== expected) {
+    return `the headroom ${label} ${target} is not a ${expected === "dir" ? "directory" : "socket"}`;
+  }
+  if (stat.uid !== uid) {
+    return `the headroom ${label} ${target} is owned by uid ${String(stat.uid)}, not by this user (uid ${String(uid)})`;
+  }
+  if ((stat.mode & GROUP_OR_OTHER_BITS) !== 0) {
+    return `the headroom ${label} ${target} has mode ${stat.mode.toString(OCTAL_RADIX).padStart(MODE_DIGITS, "0")}, which lets other users reach it; it must be accessible to its owner only`;
+  }
+  return void 0;
+}
+function prepareHeadroomSocket(fs12, ports, paths, supervisorPid) {
+  const unsupported = platformRefusal(ports.platform);
+  if (unsupported !== void 0) {
+    return { refused: unsupported };
+  }
+  const socketPath = headroomSocketPath(paths, supervisorPid);
+  const length = Buffer.byteLength(socketPath, "utf8");
+  if (length > UNIX_SOCKET_PATH_MAX_BYTES) {
+    return {
+      refused: `the headroom socket path ${socketPath} is ${String(length)} bytes, longer than the ${String(UNIX_SOCKET_PATH_MAX_BYTES)} a unix socket path can hold; set AGENT_SHIM_HOME to a shorter directory`
+    };
+  }
+  if (ports.lstat(paths.headroomSocketDir)?.kind === "symlink") {
+    return { refused: `the headroom socket directory ${paths.headroomSocketDir} is a symlink; it must be the real directory` };
+  }
+  fs12.mkdirPrivate(paths.headroomSocketDir);
+  const refusal = ownerOnlyRefusal("socket directory", paths.headroomSocketDir, ports.lstat(paths.headroomSocketDir), "dir", ports.currentUid());
+  return refusal === void 0 ? { socketPath } : { refused: refusal };
+}
+function pruneStaleHeadroomSockets(fs12, paths, isRunning) {
+  const removed = [];
+  for (const name of fs12.readdir(paths.headroomSocketDir)) {
+    const pid = HEADROOM_SOCKET_NAME.exec(name)?.[1];
+    if (pid === void 0 || isRunning(Number.parseInt(pid, 10))) {
+      continue;
+    }
+    fs12.removeRecursive(import_node_path11.default.join(paths.headroomSocketDir, name));
+    removed.push(name);
+  }
+  return removed;
+}
+
 // src/headroom/source.ts
 var import_zod6 = require("zod");
 var GIT_SPEC_RE = /git\+[^@\s]+(?:@([^\s#]+))?/;
@@ -4058,8 +4185,6 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     return 0;
   }
   let installedSource = previousState?.installedSource;
-  let lastPort = previousState?.lastPort;
-  const sticky = () => lastPort === void 0 ? {} : { lastPort };
   const ownsState = () => {
     const owner = readHeadroomState(fs12, paths.headroomStateFile)?.supervisorPid;
     return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
@@ -4072,7 +4197,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     return true;
   };
   const fail = (message) => {
-    if (writeOwnState({ lastError: message, ...sticky() })) {
+    if (writeOwnState({ lastError: message })) {
       fs12.removeRecursive(paths.headroomLockFile);
     }
     ports.log(`agent-shim headroom supervisor: ${message}`);
@@ -4095,11 +4220,17 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     installedSource = config.source;
     return true;
   };
+  const socket = prepareHeadroomSocket(fs12, ports.socketTrust, paths, ports.ownPid);
+  if (socket.refused !== void 0) {
+    return fail(socket.refused);
+  }
+  const { socketPath } = socket;
+  pruneStaleHeadroomSockets(fs12, paths, ports.isRunning);
   if (!ensureInstalled()) {
     return fail(`could not install headroom from ${config.source}: install failed (is uv installed and on PATH?)`);
   }
   const version = ports.headroomVersion() ?? "unknown";
-  writeOwnState({ supervisorPid: ports.ownPid, version, installedSource, ...sticky() });
+  writeOwnState({ supervisorPid: ports.ownPid, version, installedSource });
   ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${allowlistOf(ports).join(", ")}]`);
   const orphanPid = previousState?.headroomPid;
   if (orphanPid !== void 0 && ports.isRunning(orphanPid)) {
@@ -4125,7 +4256,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     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");
+      ports.log("agent-shim headroom supervisor: another supervisor now owns the state file; serving this daemon's own sessions until they end");
     }
     superseded = !ownsNow;
     const crashed = headroomPid !== void 0 && !ports.isRunning(headroomPid);
@@ -4138,8 +4269,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
         writeOwnState({
           supervisorPid: ports.ownPid,
           version,
-          installedSource,
-          ...sticky()
+          installedSource
         });
       }
       if (consecutiveFailures >= HEADROOM_START_RETRY_BUDGET) {
@@ -4148,41 +4278,32 @@ async function runSupervisor(initialConfig, ports, options = {}) {
       if (installedSource !== config.source && !ensureInstalled()) {
         return fail(`could not install headroom from ${config.source}: install failed (is uv installed and on PATH?)`);
       }
-      const previousSticky = lastPort;
-      const port = lastPort !== void 0 && await ports.isPortFree(lastPort) ? lastPort : await ports.freePort();
-      const pid = ports.spawnHeadroom(port, allowlist, config.settings);
-      const ready = await waitUntilReady(ports, port);
+      const pid = ports.spawnHeadroom(socketPath, allowlist, config.settings);
+      const ready = await waitUntilReady(ports, socketPath);
       if (ready) {
         consecutiveFailures = 0;
         headroomPid = pid;
         runningHash = allowlistHash;
         runningSettingsHash = settingsHash;
-        lastPort = port;
-        if (previousSticky !== void 0 && port !== previousSticky) {
-          ports.log(
-            `agent-shim headroom supervisor: sticky port ${String(previousSticky)} was occupied; moving to ${String(port)} (sessions launched against the old port are stale until they relaunch)`
-          );
-        }
         const recorded = writeOwnState({
           supervisorPid: ports.ownPid,
           headroomPid: pid,
-          port,
+          socketPath,
           version,
           allowlistHash,
           settingsHash,
-          installedSource: config.source,
-          ...sticky()
+          installedSource: config.source
         });
         if (recorded) {
           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)}`);
+        ports.log(`agent-shim headroom supervisor: headroom pid ${String(pid)} ready on unix socket ${socketPath}`);
       } else {
         ports.stopProcess(pid);
         consecutiveFailures += 1;
         ports.log(
-          `agent-shim headroom supervisor: headroom did not become ready on port ${String(port)} (attempt ${String(consecutiveFailures)} of ${String(HEADROOM_START_RETRY_BUDGET)})`
+          `agent-shim headroom supervisor: headroom did not become ready on unix socket ${socketPath} (attempt ${String(consecutiveFailures)} of ${String(HEADROOM_START_RETRY_BUDGET)})`
         );
         await ports.sleep(backoffForAttempt(consecutiveFailures));
         continue;
@@ -4207,10 +4328,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
             `agent-shim headroom supervisor: no sessions for ${String(config.idleShutdownMinutes)} minute(s); stopping headroom and exiting`
           );
           ports.stopProcess(headroomPid);
-          writeOwnState({
-            version,
-            ...sticky()
-          });
+          writeOwnState({ version });
           return 0;
         }
       } else {
@@ -4227,10 +4345,10 @@ function currentHeadroomAllowlist(fs12, paths) {
 function allowlistOf(ports) {
   return currentHeadroomAllowlist(ports.fs, ports.paths);
 }
-async function waitUntilReady(ports, port) {
+async function waitUntilReady(ports, socketPath) {
   const deadline = ports.now() + HEADROOM_READY_TIMEOUT_MS;
   for (; ; ) {
-    if (await ports.ready(port)) {
+    if (await ports.ready(socketPath)) {
       return true;
     }
     if (ports.now() >= deadline) {
@@ -4290,14 +4408,14 @@ function evaluateAmbientCredentialGuard(params) {
 // src/paths.ts
 var import_node_fs2 = __toESM(require("node:fs"), 1);
 var import_node_os = __toESM(require("node:os"), 1);
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_path12 = __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_path11.default.join(home, HOME_DIRNAME);
-  const legacy = import_node_path11.default.join(home, LEGACY_HOME_DIRNAME);
+  const current = import_node_path12.default.join(home, HOME_DIRNAME);
+  const legacy = import_node_path12.default.join(home, LEGACY_HOME_DIRNAME);
   return !isDirectory(current) && isDirectory(legacy) ? legacy : current;
 }
 function isExistingDirectory(candidate) {
@@ -4308,38 +4426,39 @@ function resolveClaudeHome() {
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  return import_node_path11.default.join(import_node_os.default.homedir(), ".claude");
+  return import_node_path12.default.join(import_node_os.default.homedir(), ".claude");
 }
 function buildLayoutPaths(root) {
   return {
     root,
-    identitiesDir: import_node_path11.default.join(root, "identities"),
-    configProfilesDir: import_node_path11.default.join(root, "config-profiles"),
-    providersDir: import_node_path11.default.join(root, "providers"),
-    directoryRulesFile: import_node_path11.default.join(root, "directory-rules.json"),
-    activeIdentityFile: import_node_path11.default.join(root, "active-identity"),
-    globalConfigFile: import_node_path11.default.join(root, "config.json"),
-    categoriesLocalFile: import_node_path11.default.join(root, "categories.local.json"),
-    claudeShimFile: import_node_path11.default.join(root, "claude-shim.json"),
-    headroomDir: import_node_path11.default.join(root, "headroom"),
-    headroomStateFile: import_node_path11.default.join(root, "headroom", "state.json"),
-    headroomLockFile: import_node_path11.default.join(root, "headroom", "start.lock"),
-    headroomSessionsDir: import_node_path11.default.join(root, "headroom", "sessions"),
-    logsDir: import_node_path11.default.join(root, "logs"),
-    headroomLogPath: import_node_path11.default.join(root, "logs", "headroom.log"),
-    frontdoorDir: import_node_path11.default.join(root, "frontdoor"),
-    frontdoorCaDir: import_node_path11.default.join(root, "frontdoor", "ca"),
-    frontdoorCaCertFile: import_node_path11.default.join(root, "frontdoor", "ca", "ca.pem"),
-    frontdoorCaKeyFile: import_node_path11.default.join(root, "frontdoor", "ca", "ca.key"),
-    frontdoorCaBundlesDir: import_node_path11.default.join(root, "frontdoor", "ca", "bundles"),
-    frontdoorStateFile: import_node_path11.default.join(root, "frontdoor", "state.json"),
-    frontdoorLockFile: import_node_path11.default.join(root, "frontdoor", "start.lock"),
-    frontdoorSessionsDir: import_node_path11.default.join(root, "frontdoor", "sessions"),
-    frontdoorLogPath: import_node_path11.default.join(root, "logs", "frontdoor.log"),
-    usageDir: import_node_path11.default.join(root, "usage"),
-    usageLogDir: import_node_path11.default.join(root, "usage", "log"),
-    usageSnapshotsDir: import_node_path11.default.join(root, "usage", "snapshots"),
-    usagePicksFile: import_node_path11.default.join(root, "usage", "picks.json")
+    identitiesDir: import_node_path12.default.join(root, "identities"),
+    configProfilesDir: import_node_path12.default.join(root, "config-profiles"),
+    providersDir: import_node_path12.default.join(root, "providers"),
+    directoryRulesFile: import_node_path12.default.join(root, "directory-rules.json"),
+    activeIdentityFile: import_node_path12.default.join(root, "active-identity"),
+    globalConfigFile: import_node_path12.default.join(root, "config.json"),
+    categoriesLocalFile: import_node_path12.default.join(root, "categories.local.json"),
+    claudeShimFile: import_node_path12.default.join(root, "claude-shim.json"),
+    headroomDir: import_node_path12.default.join(root, "headroom"),
+    headroomStateFile: import_node_path12.default.join(root, "headroom", `state.v${String(HEADROOM_STATE_SCHEMA_VERSION)}.json`),
+    headroomSocketDir: import_node_path12.default.join(root, "headroom", "run"),
+    headroomLockFile: import_node_path12.default.join(root, "headroom", "start.lock"),
+    headroomSessionsDir: import_node_path12.default.join(root, "headroom", "sessions"),
+    logsDir: import_node_path12.default.join(root, "logs"),
+    headroomLogPath: import_node_path12.default.join(root, "logs", "headroom.log"),
+    frontdoorDir: import_node_path12.default.join(root, "frontdoor"),
+    frontdoorCaDir: import_node_path12.default.join(root, "frontdoor", "ca"),
+    frontdoorCaCertFile: import_node_path12.default.join(root, "frontdoor", "ca", "ca.pem"),
+    frontdoorCaKeyFile: import_node_path12.default.join(root, "frontdoor", "ca", "ca.key"),
+    frontdoorCaBundlesDir: import_node_path12.default.join(root, "frontdoor", "ca", "bundles"),
+    frontdoorStateFile: import_node_path12.default.join(root, "frontdoor", "state.json"),
+    frontdoorLockFile: import_node_path12.default.join(root, "frontdoor", "start.lock"),
+    frontdoorSessionsDir: import_node_path12.default.join(root, "frontdoor", "sessions"),
+    frontdoorLogPath: import_node_path12.default.join(root, "logs", "frontdoor.log"),
+    usageDir: import_node_path12.default.join(root, "usage"),
+    usageLogDir: import_node_path12.default.join(root, "usage", "log"),
+    usageSnapshotsDir: import_node_path12.default.join(root, "usage", "snapshots"),
+    usagePicksFile: import_node_path12.default.join(root, "usage", "picks.json")
   };
 }
 function resolveLayoutPaths() {
@@ -4348,10 +4467,10 @@ function resolveLayoutPaths() {
 
 // src/identityStore.ts
 var import_node_fs4 = __toESM(require("node:fs"), 1);
-var import_node_path14 = __toESM(require("node:path"), 1);
+var import_node_path15 = __toESM(require("node:path"), 1);
 
 // src/launcher/identity.ts
-var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 function poolNameOf(selector) {
   return selector.startsWith(POOL_SELECTOR_PREFIX) ? selector.slice(POOL_SELECTOR_PREFIX.length) : void 0;
 }
@@ -4400,12 +4519,12 @@ function decideConfigProfile(params) {
   return { source: "none" };
 }
 function loadIdentity(identitiesDir, name, fs12) {
-  return loadConfigFile(import_node_path12.default.join(identitiesDir, name, "identity.json"), IdentitySchema, fs12.readConfigFile);
+  return loadConfigFile(import_node_path13.default.join(identitiesDir, name, "identity.json"), IdentitySchema, fs12.readConfigFile);
 }
 
 // src/configProfilesStore.ts
 var import_node_fs3 = __toESM(require("node:fs"), 1);
-var import_node_path13 = __toESM(require("node:path"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
 var ProfileNotFoundError = class extends CliError {
   constructor(profileName) {
     super(`No configuration profile named "${profileName}". Run \`agent-shim profile add ${profileName}\` first.`);
@@ -4431,7 +4550,7 @@ var InvalidCategoryNameError = class extends CliError {
   categoryName;
 };
 function profileJsonPath(paths, name) {
-  return import_node_path13.default.join(paths.configProfilesDir, `${name}.json`);
+  return import_node_path14.default.join(paths.configProfilesDir, `${name}.json`);
 }
 function profileExists(paths, name) {
   return import_node_fs3.default.existsSync(profileJsonPath(paths, name));
@@ -4619,7 +4738,7 @@ var InvalidIdentityNameError = class extends CliError {
   attemptedName;
 };
 function identityJsonPath(paths, name) {
-  return import_node_path14.default.join(paths.identitiesDir, name, "identity.json");
+  return import_node_path15.default.join(paths.identitiesDir, name, "identity.json");
 }
 function identityExists(paths, name) {
   return import_node_fs4.default.existsSync(identityJsonPath(paths, name));
@@ -4720,7 +4839,7 @@ function setIdentityCredential(paths, identityName, change) {
   });
 }
 function belongsToIdentity(entry, name) {
-  return entry === name || entry === import_node_path14.default.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
+  return entry === name || entry === import_node_path15.default.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
 }
 function removeIdentity(paths, name) {
   if (!identityExists(paths, name)) {
@@ -4728,7 +4847,7 @@ function removeIdentity(paths, name) {
   }
   for (const entry of import_node_fs4.default.readdirSync(paths.identitiesDir)) {
     if (belongsToIdentity(entry, name)) {
-      import_node_fs4.default.rmSync(import_node_path14.default.join(paths.identitiesDir, entry), { recursive: true, force: true });
+      import_node_fs4.default.rmSync(import_node_path15.default.join(paths.identitiesDir, entry), { recursive: true, force: true });
     }
   }
   if (readActiveIdentity(paths) === name) {
@@ -4738,7 +4857,7 @@ function removeIdentity(paths, name) {
 
 // src/providersStore.ts
 var import_node_fs5 = __toESM(require("node:fs"), 1);
-var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_path16 = __toESM(require("node:path"), 1);
 
 // src/credentialCache.ts
 var import_zod7 = require("zod");
@@ -4775,7 +4894,7 @@ 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;
+var OCTAL_RADIX2 = 8;
 function commandArgv(source) {
   if ("command" in source) {
     return source.command;
@@ -4868,7 +4987,7 @@ function trySource(source, params) {
     }
     if (read.mode !== void 0 && (read.mode & GROUP_OTHER_PERMISSION_BITS) !== 0) {
       return none(
-        `is readable or writable by group or others (mode ${(read.mode & PERMISSION_BITS).toString(OCTAL_RADIX)}); run \`chmod 600 ${source.file}\``,
+        `is readable or writable by group or others (mode ${(read.mode & PERMISSION_BITS).toString(OCTAL_RADIX2)}); run \`chmod 600 ${source.file}\``,
         true
       );
     }
@@ -4964,7 +5083,7 @@ var InvalidProviderNameError = class extends CliError {
 };
 var PROVIDER_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._@-]*$/;
 function providerJsonPath(paths, name) {
-  return import_node_path15.default.join(paths.providersDir, `${name}.json`);
+  return import_node_path16.default.join(paths.providersDir, `${name}.json`);
 }
 function providerExists(paths, name) {
   return import_node_fs5.default.existsSync(providerJsonPath(paths, name));
@@ -5040,7 +5159,7 @@ function readProvider(paths, name) {
   return parseProviderFile(filePath, raw);
 }
 function loadProvider(providersDir, name, port) {
-  const filePath = import_node_path15.default.join(providersDir, `${name}.json`);
+  const filePath = import_node_path16.default.join(providersDir, `${name}.json`);
   const raw = port.readConfigFile(filePath);
   return raw === void 0 ? void 0 : parseProviderFile(filePath, raw);
 }
@@ -5295,21 +5414,21 @@ function removeDirectoryRule(paths, rulePath) {
 var import_node_os4 = __toESM(require("node:os"), 1);
 
 // src/launcher/cascade.ts
-var import_node_path17 = __toESM(require("node:path"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 
 // src/pathNorm.ts
-var import_node_path16 = __toESM(require("node:path"), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
 function expandTilde(value, home) {
   if (value === "~") {
     return home;
   }
   if (value.startsWith("~/")) {
-    return import_node_path16.default.join(home, value.slice(2));
+    return import_node_path17.default.join(home, value.slice(2));
   }
   return value;
 }
 function normaliseRulePath(rulePath, home) {
-  return import_node_path16.default.resolve(expandTilde(rulePath, home));
+  return import_node_path17.default.resolve(expandTilde(rulePath, home));
 }
 
 // src/launcher/cascade.ts
@@ -5319,7 +5438,7 @@ function loadCascadeInput(params) {
   const globalConfig = loadConfigFile(params.paths.globalConfigFile, GlobalConfigSchema, params.read);
   const directoryRules = loadConfigFile(params.paths.directoryRulesFile, DirectoryRulesSchema, params.read);
   const loadProfile = (name) => {
-    const filepath = import_node_path17.default.join(params.paths.configProfilesDir, `${name}.json`);
+    const filepath = import_node_path18.default.join(params.paths.configProfilesDir, `${name}.json`);
     const loaded = loadConfigFile(filepath, ConfigProfileSchema, params.read);
     if (loaded === void 0) {
       return void 0;
@@ -5334,8 +5453,8 @@ function loadCascadeInput(params) {
   });
   const levels = [];
   for (const dir of dirs) {
-    const portable = loadConfigFile(import_node_path17.default.join(dir, PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path17.default.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read);
-    const portableLocal = loadConfigFile(import_node_path17.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path17.default.join(dir, LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read);
+    const portable = loadConfigFile(import_node_path18.default.join(dir, PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path18.default.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read);
+    const portableLocal = loadConfigFile(import_node_path18.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path18.default.join(dir, LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read);
     const rules = (directoryRules?.config.rules ?? []).map((rule, index) => ({ rule, index })).filter(({ rule }) => normaliseRulePath(rule.path, params.home) === dir).map(({ rule, index }) => {
       const entryOrder = directoryRules?.ruleEntryOrders[index];
       return {
@@ -5432,7 +5551,7 @@ function quotaWarnings(snapshot, provider, nowMs) {
 }
 
 // src/usage/poolPick.ts
-var import_node_path18 = __toESM(require("node:path"), 1);
+var import_node_path19 = __toESM(require("node:path"), 1);
 var import_zod9 = require("zod");
 
 // src/usage/plan.ts
@@ -5734,7 +5853,7 @@ function recordStickyPick(fs12, picksFile, directory, identity, nowMs) {
   const current = readPicksFile(fs12, picksFile).file.picks;
   const kept = Object.entries(current).filter(([, entry]) => nowMs - Date.parse(entry.at) <= USAGE_RETENTION_MS);
   const next = { schemaVersion: SCHEMA_VERSION, picks: { ...Object.fromEntries(kept), [directory]: { identity, at: new Date(nowMs).toISOString() } } };
-  fs12.mkdirPrivate(import_node_path18.default.dirname(picksFile));
+  fs12.mkdirPrivate(import_node_path19.default.dirname(picksFile));
   fs12.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
 `);
 }
@@ -5831,14 +5950,14 @@ var import_node_child_process = require("node:child_process");
 var import_node_crypto8 = require("node:crypto");
 var import_node_fs6 = __toESM(require("node:fs"), 1);
 var import_node_os3 = __toESM(require("node:os"), 1);
-var import_node_path20 = __toESM(require("node:path"), 1);
+var import_node_path21 = __toESM(require("node:path"), 1);
 var import_node_sea = require("node:sea");
 
 // src/versionDiscovery.ts
 var import_node_os2 = __toESM(require("node:os"), 1);
-var import_node_path19 = __toESM(require("node:path"), 1);
+var import_node_path20 = __toESM(require("node:path"), 1);
 function defaultVersionsDir() {
-  return import_node_path19.default.join(import_node_os2.default.homedir(), ".local", "share", "claude", "versions");
+  return import_node_path20.default.join(import_node_os2.default.homedir(), ".local", "share", "claude", "versions");
 }
 var NUMERIC_DOTTED_VERSION_RE = /^\d+(?:\.\d+)*$/;
 function isNumericDottedVersion(name) {
@@ -5880,14 +5999,14 @@ function discoverClaudeBinary(options) {
   const highestVersion = pickHighestVersion(entries);
   if (highestVersion !== void 0) {
     return {
-      path: import_node_path19.default.join(versionsDir, highestVersion),
+      path: import_node_path20.default.join(versionsDir, highestVersion),
       source: "versions-dir",
       version: highestVersion
     };
   }
-  const ownInstallDirs = new Set(options.ownInstallDirs.map((dir) => import_node_path19.default.resolve(dir)));
+  const ownInstallDirs = new Set(options.ownInstallDirs.map((dir) => import_node_path20.default.resolve(dir)));
   for (const dir of options.pathDirs) {
-    if (ownInstallDirs.has(import_node_path19.default.resolve(dir))) {
+    if (ownInstallDirs.has(import_node_path20.default.resolve(dir))) {
       continue;
     }
     const found = options.findExecutableInDir(dir, "claude");
@@ -6058,7 +6177,7 @@ var realRunPort = {
   }
 };
 function expandHome2(filePath) {
-  return filePath.startsWith("~/") ? import_node_path20.default.join(import_node_os3.default.homedir(), filePath.slice(1)) : filePath;
+  return filePath.startsWith("~/") ? import_node_path21.default.join(import_node_os3.default.homedir(), filePath.slice(1)) : filePath;
 }
 var MACOS_GUI_SESSION_MANAGER = "Aqua";
 function hasDesktopSession() {
@@ -6131,7 +6250,7 @@ function spawnDaemonThrough(executable) {
   return (paths, subcommand, logPath) => spawnDetachedDaemon({ command: executable, args: [subcommand] }, paths, subcommand, logPath);
 }
 function spawnDetachedDaemon(invocation, paths, subcommand, logPath) {
-  import_node_fs6.default.mkdirSync(import_node_path20.default.dirname(logPath), { recursive: true });
+  import_node_fs6.default.mkdirSync(import_node_path21.default.dirname(logPath), { recursive: true });
   const logFd = import_node_fs6.default.openSync(logPath, "a");
   try {
     const child = (0, import_node_child_process.spawn)(invocation.command, invocation.args, detachedDaemonSpawnOptions(logFd, { ...process.env, AGENT_SHIM_HOME: paths.root }));
@@ -6147,6 +6266,29 @@ function spawnDetachedDaemon(invocation, paths, subcommand, logPath) {
 function spawnHeadroomSupervisor(paths, spawnDaemon) {
   return spawnDaemon(paths, "__headroom-supervisor", paths.headroomLogPath);
 }
+var SOCKET_PERMISSION_BITS = 511;
+var realHeadroomSocketTrust = {
+  platform: process.platform,
+  currentUid: () => {
+    if (process.getuid === void 0) {
+      throw new Error(`no POSIX user id on ${process.platform}`);
+    }
+    return process.getuid();
+  },
+  lstat: (target) => {
+    let stat;
+    try {
+      stat = import_node_fs6.default.lstatSync(target);
+    } catch (error) {
+      if (isEnoent3(error)) {
+        return void 0;
+      }
+      throw error;
+    }
+    const kind = stat.isSymbolicLink() ? "symlink" : stat.isDirectory() ? "dir" : stat.isSocket() ? "socket" : "other";
+    return { kind, uid: stat.uid, mode: stat.mode & SOCKET_PERMISSION_BITS };
+  }
+};
 function realHeadroomPort(paths, options) {
   return {
     ensure: () => {
@@ -6163,7 +6305,7 @@ function realHeadroomPort(paths, options) {
         }
       });
       return {
-        port: up.port,
+        socketPath: up.socketPath,
         projectId: resolveGitRoot(realRunPort, options.cwd) ?? options.cwd
       };
     },
@@ -6189,7 +6331,7 @@ function listVersionsDir(dir) {
     throw error;
   }
   return entries.filter((entry) => entry.isFile()).map((entry) => {
-    const fullPath = import_node_path20.default.join(dir, entry.name);
+    const fullPath = import_node_path21.default.join(dir, entry.name);
     const stat = import_node_fs6.default.statSync(fullPath);
     return {
       name: entry.name,
@@ -6204,7 +6346,7 @@ function windowsPathExtensions(pathext) {
   return (pathext ?? WINDOWS_DEFAULT_PATHEXT).split(";").map((ext) => ext.trim()).filter((ext) => ext.length > 0);
 }
 function resolveExecutableCandidate(dir, name, env) {
-  const candidate = import_node_path20.default.join(dir, name);
+  const candidate = import_node_path21.default.join(dir, name);
   if (env.platform === "win32") {
     const extensions = windowsPathExtensions(env.pathext);
     const alreadyHasRecognisedExtension = extensions.some((ext) => candidate.toLowerCase().endsWith(ext.toLowerCase()));
@@ -6253,13 +6395,13 @@ function resolveOwnExecutablePath(env) {
   if (env.argv1 !== void 0 && !env.argv1.includes("/") && !env.argv1.includes("\\")) {
     return searchPathForExecutable(env.pathDirs, env.argv1, env.findExecutableInDir) ?? env.execPath;
   }
-  const candidate = env.argv1 === void 0 ? env.execPath : import_node_path20.default.resolve(env.cwd, env.argv1);
-  const candidateDir = import_node_path20.default.dirname(candidate);
-  const candidateDirOnPath = env.pathDirs.some((dir) => import_node_path20.default.resolve(dir) === candidateDir);
+  const candidate = env.argv1 === void 0 ? env.execPath : import_node_path21.default.resolve(env.cwd, env.argv1);
+  const candidateDir = import_node_path21.default.dirname(candidate);
+  const candidateDirOnPath = env.pathDirs.some((dir) => import_node_path21.default.resolve(dir) === candidateDir);
   if (candidateDirOnPath) {
     return candidate;
   }
-  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path20.default.basename(candidate), env.findExecutableInDir);
+  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path21.default.basename(candidate), env.findExecutableInDir);
   return viaPath ?? candidate;
 }
 function realOwnExecutablePath() {
@@ -6267,21 +6409,21 @@ function realOwnExecutablePath() {
     argv1: process.argv[1],
     execPath: process.execPath,
     cwd: process.cwd(),
-    pathDirs: (process.env.PATH ?? "").split(import_node_path20.default.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(import_node_path21.default.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir
   });
 }
 function realResolveClaudeBinary(ownInstallDirs) {
   return () => discoverClaudeBinary({
     listVersionsDir,
-    pathDirs: (process.env.PATH ?? "").split(import_node_path20.default.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(import_node_path21.default.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir,
     ownInstallDirs: [...ownInstallDirs]
   });
 }
 
 // src/checkReport.ts
-var import_node_path21 = __toESM(require("node:path"), 1);
+var import_node_path22 = __toESM(require("node:path"), 1);
 var import_zod10 = require("zod");
 
 // src/cli/bool.ts
@@ -6649,10 +6791,10 @@ function collectCheckReport(params) {
   }).input;
   const providerName = cascadeProviderName(cascade);
   const provider = providerName === void 0 ? void 0 : loadCheckProvider(paths, providerName);
-  const farmRoot = identityDecision.name === void 0 ? void 0 : import_node_path21.default.join(paths.identitiesDir, identityDecision.name);
+  const farmRoot = identityDecision.name === void 0 ? void 0 : import_node_path22.default.join(paths.identitiesDir, identityDecision.name);
   const settingsFiles = {
-    "settings.json": realFsPort.readFileUtf8(import_node_path21.default.join(claudeHome, "settings.json")),
-    "settings.local.json": realFsPort.readFileUtf8(import_node_path21.default.join(claudeHome, "settings.local.json"))
+    "settings.json": realFsPort.readFileUtf8(import_node_path22.default.join(claudeHome, "settings.json")),
+    "settings.local.json": realFsPort.readFileUtf8(import_node_path22.default.join(claudeHome, "settings.local.json"))
   };
   const report = runCheck({
     cwd,
@@ -6682,7 +6824,7 @@ function collectCheckReport(params) {
 
 // src/claudeShim.ts
 var import_node_fs7 = __toESM(require("node:fs"), 1);
-var import_node_path22 = __toESM(require("node:path"), 1);
+var import_node_path23 = __toESM(require("node:path"), 1);
 var import_zod11 = require("zod");
 var ClaudeShimStateSchema = import_zod11.z.strictObject({
   targetPath: import_zod11.z.string().min(1),
@@ -6693,29 +6835,29 @@ function commandFilename(ownExecutablePath, commandName) {
   return ownExecutablePath.toLowerCase().endsWith(".exe") ? `${commandName}.exe` : commandName;
 }
 function resolveOwnInstallDirs(paths, ownExecutablePath) {
-  const dirs = [import_node_path22.default.dirname(ownExecutablePath)];
+  const dirs = [import_node_path23.default.dirname(ownExecutablePath)];
   const state = readJson(paths.claudeShimFile, ClaudeShimStateSchema);
   if (state !== void 0) {
-    dirs.push(import_node_path22.default.dirname(state.targetPath));
+    dirs.push(import_node_path23.default.dirname(state.targetPath));
   }
   return dirs;
 }
 var nodeLinkFs = { link: import_node_fs7.default.linkSync, copyFile: import_node_fs7.default.copyFileSync, chmod: import_node_fs7.default.chmodSync };
 function findPathShadow(params) {
-  const resolvedTargetDir = import_node_path22.default.resolve(params.targetDir);
+  const resolvedTargetDir = import_node_path23.default.resolve(params.targetDir);
   for (const dir of params.pathDirs) {
     const found = params.findExecutableInDir(dir, params.targetFilename);
     if (found === void 0) {
       continue;
     }
-    return import_node_path22.default.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
+    return import_node_path23.default.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
   }
-  return params.pathDirs.some((dir) => import_node_path22.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
+  return params.pathDirs.some((dir) => import_node_path23.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
 }
 
 // src/doctorReport.ts
 var import_node_fs8 = __toESM(require("node:fs"), 1);
-var import_node_path23 = __toESM(require("node:path"), 1);
+var import_node_path24 = __toESM(require("node:path"), 1);
 function refinePathShadow(status, ownExecutablePath, realpath) {
   if (status.status !== "shadowed") {
     return status;
@@ -6739,7 +6881,7 @@ function validateJson(schema, input) {
   return { ok: true, data: result.data };
 }
 function pushPathResolution(push, resolution) {
-  const ownDir = import_node_path23.default.dirname(resolution.ownExecutablePath);
+  const ownDir = import_node_path24.default.dirname(resolution.ownExecutablePath);
   switch (resolution.agentShim.status) {
     case "ok":
       push("path-resolution", "pass", `\`agent-shim\` on PATH resolves to this running executable, ${resolution.ownExecutablePath}.`, "agent-shim");
@@ -6807,14 +6949,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 && import_node_path23.default.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
+  if (legacyVariables.length === 0 && import_node_path24.default.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
     push("legacy-name", "pass", "Nothing here still uses the former `claude-use` name.");
     return;
   }
   for (const name of legacyVariables) {
     push("legacy-name", "warn", `${name} is the former name of ${name.replace(LEGACY_ENV_PREFIX, ENV_PREFIX)}. Rename it; the old name still works but is only a fallback.`, name);
   }
-  if (import_node_path23.default.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
+  if (import_node_path24.default.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
     push(
       "legacy-name",
       "warn",
@@ -7004,7 +7146,7 @@ function runDoctor(params) {
           "warn",
           `Headroom state names supervisor pid ${String(state.supervisorPid)}, which is not running; the next launch through headroom will start a replacement.`
         );
-      } else if (state.headroomPid === void 0 || state.port === void 0) {
+      } else if (state.headroomPid === void 0 || state.socketPath === void 0) {
         push(
           "headroom",
           "warn",
@@ -7020,7 +7162,7 @@ function runDoctor(params) {
         push(
           "headroom",
           "pass",
-          `Headroom daemon is up on 127.0.0.1:${String(state.port)} (supervisor ${String(state.supervisorPid)}, daemon ${String(state.headroomPid)}).`
+          `Headroom daemon is up on unix socket ${state.socketPath} (supervisor ${String(state.supervisorPid)}, daemon ${String(state.headroomPid)}).`
         );
       }
       if (state.lastError !== void 0 && supervisorAlive) {
@@ -7122,18 +7264,18 @@ function collectDoctorReport(params) {
   const { paths } = params;
   const identityNames = import_node_fs8.default.existsSync(paths.identitiesDir) ? import_node_fs8.default.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isIdentityDirectoryName(entry.name)).map((entry) => entry.name).sort() : [];
   const identities = identityNames.map((name) => {
-    const farmRoot = import_node_path23.default.join(paths.identitiesDir, name);
-    const identityPath = import_node_path23.default.join(farmRoot, "identity.json");
+    const farmRoot = import_node_path24.default.join(paths.identitiesDir, name);
+    const identityPath = import_node_path24.default.join(farmRoot, "identity.json");
     return { name, path: identityPath, raw: realFsPort.readFileUtf8(identityPath), farmRoot };
   });
   const profileNames = import_node_fs8.default.existsSync(paths.configProfilesDir) ? import_node_fs8.default.readdirSync(paths.configProfilesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
   const configProfiles = profileNames.map((name) => {
-    const profilePath = import_node_path23.default.join(paths.configProfilesDir, `${name}.json`);
+    const profilePath = import_node_path24.default.join(paths.configProfilesDir, `${name}.json`);
     return { name, path: profilePath, raw: realFsPort.readFileUtf8(profilePath) };
   });
   const providerNames = import_node_fs8.default.existsSync(paths.providersDir) ? import_node_fs8.default.readdirSync(paths.providersDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
   const providers = providerNames.map((name) => {
-    const providerPath = import_node_path23.default.join(paths.providersDir, `${name}.json`);
+    const providerPath = import_node_path24.default.join(paths.providersDir, `${name}.json`);
     return { name, path: providerPath, raw: realFsPort.readFileUtf8(providerPath) };
   });
   const ownExecutablePath = realOwnExecutablePath();
@@ -7145,12 +7287,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(import_node_path23.default.delimiter).filter((dir) => dir !== "");
+  const pathDirs = (params.env.PATH ?? "").split(import_node_path24.default.delimiter).filter((dir) => dir !== "");
   const claudeShimShadow = shimState === void 0 ? void 0 : refinePathShadow(
     findPathShadow({
       pathDirs,
-      targetDir: import_node_path23.default.dirname(shimState.targetPath),
-      targetFilename: import_node_path23.default.basename(shimState.targetPath),
+      targetDir: import_node_path24.default.dirname(shimState.targetPath),
+      targetFilename: import_node_path24.default.basename(shimState.targetPath),
       findExecutableInDir
     }),
     shimState.targetPath,
@@ -7173,7 +7315,7 @@ function collectDoctorReport(params) {
       agentShim: refinePathShadow(
         findPathShadow({
           pathDirs,
-          targetDir: import_node_path23.default.dirname(ownExecutablePath),
+          targetDir: import_node_path24.default.dirname(ownExecutablePath),
           targetFilename: commandFilename(ownExecutablePath, "agent-shim"),
           findExecutableInDir
         }),
@@ -7194,7 +7336,7 @@ function collectDoctorReport(params) {
 
 // src/launcher.ts
 var import_node_crypto9 = require("node:crypto");
-var import_node_path25 = __toESM(require("node:path"), 1);
+var import_node_path26 = __toESM(require("node:path"), 1);
 
 // src/launcher/argv.ts
 var ConflictingIdentityError = class extends UsageError {
@@ -7446,7 +7588,7 @@ function buildCliOverride(params) {
 }
 
 // src/launcher/flags.ts
-var import_node_path24 = __toESM(require("node:path"), 1);
+var import_node_path25 = __toESM(require("node:path"), 1);
 
 // src/headroom/headers.ts
 function mergeAnthropicCustomHeaders(existing, additions) {
@@ -7516,7 +7658,7 @@ function buildEnv(params) {
   const parentCustomHeaders = params.baseEnv.ANTHROPIC_CUSTOM_HEADERS;
   let providerCustomHeaders;
   if (!params.configDirEscapeHatch && params.resolvedIdentityName !== void 0) {
-    env.CLAUDE_CONFIG_DIR = import_node_path24.default.join(params.identitiesDir, params.resolvedIdentityName);
+    env.CLAUDE_CONFIG_DIR = import_node_path25.default.join(params.identitiesDir, params.resolvedIdentityName);
   }
   if (params.provider !== void 0) {
     const providerEnv = params.provider.definition.env ?? {};
@@ -7537,9 +7679,6 @@ function buildEnv(params) {
       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(
       [
@@ -7680,7 +7819,7 @@ function prepareLaunch(params) {
     identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
     globalDefaultConfigProfile: params.globalDefaultConfigProfile
   });
-  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path25.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path26.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
     log.error(
       `agent-shim: no configuration profile named "${configProfileDecision.name}" (selected via ${configProfileDecision.source}). Run \`agent-shim profile add ${configProfileDecision.name}\` first.`
     );
@@ -7816,7 +7955,7 @@ function prepareLaunch(params) {
   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})`);
+    log.info(`agent-shim: routing through the front door on 127.0.0.1:${String(frontDoor?.port ?? 0)} with headroom on unix socket ${headroom.socketPath} (${via}, project ${headroom.projectId})`);
   } else if (resolvedFlags.headroom) {
     log.error("agent-shim: headroom routing was requested but this launcher has no headroom port wired; refusing to launch without it.");
     proc.exit(1);
@@ -7856,7 +7995,7 @@ var import_node_crypto11 = require("node:crypto");
 // src/realCredentialCache.ts
 var import_node_child_process2 = require("node:child_process");
 var import_node_fs9 = __toESM(require("node:fs"), 1);
-var import_node_path26 = __toESM(require("node:path"), 1);
+var import_node_path27 = __toESM(require("node:path"), 1);
 var KEYCHAIN_CACHE_SERVICE = "agent-shim-credential-cache";
 var CACHE_DIR_MODE = 448;
 var CACHE_FILE_MODE = 384;
@@ -7883,8 +8022,8 @@ function security(args, stdin) {
   return { status: result.status, stdout: result.stdout };
 }
 function createRealCredentialCache(root) {
-  const dir = import_node_path26.default.join(root, "credential-cache");
-  const filePath = (owner) => import_node_path26.default.join(dir, cacheFileNameFor(owner));
+  const dir = import_node_path27.default.join(root, "credential-cache");
+  const filePath = (owner) => import_node_path27.default.join(dir, cacheFileNameFor(owner));
   return {
     read(store, owner) {
       if (store === "file") {
@@ -8000,11 +8139,11 @@ function probeFrontDoorSync(port, caPem) {
 
 // src/frontdoor/trust.ts
 var import_node_crypto10 = require("node:crypto");
-var import_node_path27 = __toESM(require("node:path"), 1);
+var import_node_path28 = __toESM(require("node:path"), 1);
 var BUNDLE_NAME_HEX_DIGITS = 16;
 function resolveTrustBundle(params) {
   const { caCertFile, bundlesDir, inherited, fs: fs12 } = params;
-  if (inherited === void 0 || inherited === "" || import_node_path27.default.resolve(inherited) === import_node_path27.default.resolve(caCertFile)) {
+  if (inherited === void 0 || inherited === "" || import_node_path28.default.resolve(inherited) === import_node_path28.default.resolve(caCertFile)) {
     return { path: caCertFile };
   }
   const caPem = fs12.readFileUtf8(caCertFile);
@@ -8022,7 +8161,7 @@ function resolveTrustBundle(params) {
   }
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
-  const bundle = import_node_path27.default.join(bundlesDir, `${(0, import_node_crypto10.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  const bundle = import_node_path28.default.join(bundlesDir, `${(0, import_node_crypto10.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
   if (!fs12.exists(bundle)) {
     fs12.mkdirp(bundlesDir);
     fs12.writeFileAtomic(bundle, combined);