claude-use 7.13.2 → 8.0.0

package/dist/index.mjs

@@ -247,7 +247,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 = 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. */
@@ -2484,7 +2484,7 @@ function providerBaseUrl(port, provider) {
 // src/frontdoor/state.ts
 import path7 from "node:path";
 import { z as z3 } from "zod";
-var FRONT_DOOR_PROTOCOL = 1;
+var FRONT_DOOR_PROTOCOL = 2;
 var FrontDoorSessionSchema = z3.strictObject({ pid: z3.number().int().positive(), startedAt: z3.number(), token: z3.string().min(1) });
 var FrontDoorStateSchema = z3.strictObject({
   /**
@@ -2709,8 +2709,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",
@@ -3043,13 +3043,63 @@ function realConnectCertStore(paths) {
 }
 
 // src/frontdoor/connectEffects.ts
+import * as dns from "node:dns";
 import * as http from "node:http";
 import * as https from "node:https";
 import * as net2 from "node:net";
 import * as tls from "node:tls";
+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) => {
@@ -3135,11 +3185,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 });
@@ -3153,6 +3215,7 @@ function realConnectEffects() {
       const options = {
         host: target.host,
         port: target.port,
+        lookup: realAddressLookup,
         method: request3.method,
         path: request3.url,
         headers,
@@ -3213,17 +3276,16 @@ import { createHash as createHash2 } from "node:crypto";
 import path8 from "node:path";
 import { z as z4 } from "zod";
 var HEADROOM_ANTHROPIC_UPSTREAM = "https://api.anthropic.com";
+var HEADROOM_STATE_SCHEMA_VERSION = 2;
 var HeadroomStateSchema = z4.strictObject({
   /** The supervisor process owning the daemon. Alive means someone is keeping headroom running. */
   supervisorPid: z4.number().int().positive().optional(),
   /** The headroom proxy process itself. Absent while the supervisor is between restarts. */
   headroomPid: z4.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: z4.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: z4.number().int().positive().optional(),
+  socketPath: z4.string().min(1).optional(),
   /** The `headroom --version` output of the running install. */
   version: z4.string().optional(),
   /** Hash of the allowlist the running proxy was started with, so a provider-file change is detected as drift. */
@@ -3730,10 +3792,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(
@@ -3797,6 +3859,71 @@ function hashSettings(settings) {
   return createHash3("sha256").update(JSON.stringify([...settingsArgs(settings), JSON.stringify(settingsEnv(settings))])).digest("hex");
 }
 
+// src/headroom/socket.ts
+import path11 from "node:path";
+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 path11.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(path11.join(paths.headroomSocketDir, name));
+    removed.push(name);
+  }
+  return removed;
+}
+
 // src/headroom/source.ts
 import { z as z6 } from "zod";
 var GIT_SPEC_RE = /git\+[^@\s]+(?:@([^\s#]+))?/;
@@ -3892,8 +4019,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);
@@ -3906,7 +4031,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}`);
@@ -3929,11 +4054,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)) {
@@ -3959,7 +4090,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);
@@ -3972,8 +4103,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
         writeOwnState({
           supervisorPid: ports.ownPid,
           version,
-          installedSource,
-          ...sticky()
+          installedSource
         });
       }
       if (consecutiveFailures >= HEADROOM_START_RETRY_BUDGET) {
@@ -3982,41 +4112,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;
@@ -4041,10 +4162,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 {
@@ -4061,10 +4179,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) {
@@ -4124,14 +4242,14 @@ function evaluateAmbientCredentialGuard(params) {
 // src/paths.ts
 import fs3 from "node:fs";
 import os from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 function resolveAgentShimHome(env = process.env, home = os.homedir(), isDirectory = isExistingDirectory) {
   const fromEnv = env.AGENT_SHIM_HOME;
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  const current = path11.join(home, HOME_DIRNAME);
-  const legacy = path11.join(home, LEGACY_HOME_DIRNAME);
+  const current = path12.join(home, HOME_DIRNAME);
+  const legacy = path12.join(home, LEGACY_HOME_DIRNAME);
   return !isDirectory(current) && isDirectory(legacy) ? legacy : current;
 }
 function isExistingDirectory(candidate) {
@@ -4142,38 +4260,39 @@ function resolveClaudeHome() {
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  return path11.join(os.homedir(), ".claude");
+  return path12.join(os.homedir(), ".claude");
 }
 function buildLayoutPaths(root) {
   return {
     root,
-    identitiesDir: path11.join(root, "identities"),
-    configProfilesDir: path11.join(root, "config-profiles"),
-    providersDir: path11.join(root, "providers"),
-    directoryRulesFile: path11.join(root, "directory-rules.json"),
-    activeIdentityFile: path11.join(root, "active-identity"),
-    globalConfigFile: path11.join(root, "config.json"),
-    categoriesLocalFile: path11.join(root, "categories.local.json"),
-    claudeShimFile: path11.join(root, "claude-shim.json"),
-    headroomDir: path11.join(root, "headroom"),
-    headroomStateFile: path11.join(root, "headroom", "state.json"),
-    headroomLockFile: path11.join(root, "headroom", "start.lock"),
-    headroomSessionsDir: path11.join(root, "headroom", "sessions"),
-    logsDir: path11.join(root, "logs"),
-    headroomLogPath: path11.join(root, "logs", "headroom.log"),
-    frontdoorDir: path11.join(root, "frontdoor"),
-    frontdoorCaDir: path11.join(root, "frontdoor", "ca"),
-    frontdoorCaCertFile: path11.join(root, "frontdoor", "ca", "ca.pem"),
-    frontdoorCaKeyFile: path11.join(root, "frontdoor", "ca", "ca.key"),
-    frontdoorCaBundlesDir: path11.join(root, "frontdoor", "ca", "bundles"),
-    frontdoorStateFile: path11.join(root, "frontdoor", "state.json"),
-    frontdoorLockFile: path11.join(root, "frontdoor", "start.lock"),
-    frontdoorSessionsDir: path11.join(root, "frontdoor", "sessions"),
-    frontdoorLogPath: path11.join(root, "logs", "frontdoor.log"),
-    usageDir: path11.join(root, "usage"),
-    usageLogDir: path11.join(root, "usage", "log"),
-    usageSnapshotsDir: path11.join(root, "usage", "snapshots"),
-    usagePicksFile: path11.join(root, "usage", "picks.json")
+    identitiesDir: path12.join(root, "identities"),
+    configProfilesDir: path12.join(root, "config-profiles"),
+    providersDir: path12.join(root, "providers"),
+    directoryRulesFile: path12.join(root, "directory-rules.json"),
+    activeIdentityFile: path12.join(root, "active-identity"),
+    globalConfigFile: path12.join(root, "config.json"),
+    categoriesLocalFile: path12.join(root, "categories.local.json"),
+    claudeShimFile: path12.join(root, "claude-shim.json"),
+    headroomDir: path12.join(root, "headroom"),
+    headroomStateFile: path12.join(root, "headroom", `state.v${String(HEADROOM_STATE_SCHEMA_VERSION)}.json`),
+    headroomSocketDir: path12.join(root, "headroom", "run"),
+    headroomLockFile: path12.join(root, "headroom", "start.lock"),
+    headroomSessionsDir: path12.join(root, "headroom", "sessions"),
+    logsDir: path12.join(root, "logs"),
+    headroomLogPath: path12.join(root, "logs", "headroom.log"),
+    frontdoorDir: path12.join(root, "frontdoor"),
+    frontdoorCaDir: path12.join(root, "frontdoor", "ca"),
+    frontdoorCaCertFile: path12.join(root, "frontdoor", "ca", "ca.pem"),
+    frontdoorCaKeyFile: path12.join(root, "frontdoor", "ca", "ca.key"),
+    frontdoorCaBundlesDir: path12.join(root, "frontdoor", "ca", "bundles"),
+    frontdoorStateFile: path12.join(root, "frontdoor", "state.json"),
+    frontdoorLockFile: path12.join(root, "frontdoor", "start.lock"),
+    frontdoorSessionsDir: path12.join(root, "frontdoor", "sessions"),
+    frontdoorLogPath: path12.join(root, "logs", "frontdoor.log"),
+    usageDir: path12.join(root, "usage"),
+    usageLogDir: path12.join(root, "usage", "log"),
+    usageSnapshotsDir: path12.join(root, "usage", "snapshots"),
+    usagePicksFile: path12.join(root, "usage", "picks.json")
   };
 }
 function resolveLayoutPaths() {
@@ -4182,10 +4301,10 @@ function resolveLayoutPaths() {
 
 // src/identityStore.ts
 import fs5 from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 
 // src/launcher/identity.ts
-import path12 from "node:path";
+import path13 from "node:path";
 function poolNameOf(selector) {
   return selector.startsWith(POOL_SELECTOR_PREFIX) ? selector.slice(POOL_SELECTOR_PREFIX.length) : void 0;
 }
@@ -4234,12 +4353,12 @@ function decideConfigProfile(params) {
   return { source: "none" };
 }
 function loadIdentity(identitiesDir, name, fs12) {
-  return loadConfigFile(path12.join(identitiesDir, name, "identity.json"), IdentitySchema, fs12.readConfigFile);
+  return loadConfigFile(path13.join(identitiesDir, name, "identity.json"), IdentitySchema, fs12.readConfigFile);
 }
 
 // src/configProfilesStore.ts
 import fs4 from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 var ProfileNotFoundError = class extends CliError {
   constructor(profileName) {
     super(`No configuration profile named "${profileName}". Run \`agent-shim profile add ${profileName}\` first.`);
@@ -4265,7 +4384,7 @@ var InvalidCategoryNameError = class extends CliError {
   categoryName;
 };
 function profileJsonPath(paths, name) {
-  return path13.join(paths.configProfilesDir, `${name}.json`);
+  return path14.join(paths.configProfilesDir, `${name}.json`);
 }
 function profileExists(paths, name) {
   return fs4.existsSync(profileJsonPath(paths, name));
@@ -4453,7 +4572,7 @@ var InvalidIdentityNameError = class extends CliError {
   attemptedName;
 };
 function identityJsonPath(paths, name) {
-  return path14.join(paths.identitiesDir, name, "identity.json");
+  return path15.join(paths.identitiesDir, name, "identity.json");
 }
 function identityExists(paths, name) {
   return fs5.existsSync(identityJsonPath(paths, name));
@@ -4554,7 +4673,7 @@ function setIdentityCredential(paths, identityName, change) {
   });
 }
 function belongsToIdentity(entry, name) {
-  return entry === name || entry === path14.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
+  return entry === name || entry === path15.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
 }
 function removeIdentity(paths, name) {
   if (!identityExists(paths, name)) {
@@ -4562,7 +4681,7 @@ function removeIdentity(paths, name) {
   }
   for (const entry of fs5.readdirSync(paths.identitiesDir)) {
     if (belongsToIdentity(entry, name)) {
-      fs5.rmSync(path14.join(paths.identitiesDir, entry), { recursive: true, force: true });
+      fs5.rmSync(path15.join(paths.identitiesDir, entry), { recursive: true, force: true });
     }
   }
   if (readActiveIdentity(paths) === name) {
@@ -4572,7 +4691,7 @@ function removeIdentity(paths, name) {
 
 // src/providersStore.ts
 import fs6 from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 
 // src/credentialCache.ts
 import { z as z7 } from "zod";
@@ -4609,7 +4728,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;
@@ -4702,7 +4821,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
       );
     }
@@ -4798,7 +4917,7 @@ var InvalidProviderNameError = class extends CliError {
 };
 var PROVIDER_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._@-]*$/;
 function providerJsonPath(paths, name) {
-  return path15.join(paths.providersDir, `${name}.json`);
+  return path16.join(paths.providersDir, `${name}.json`);
 }
 function providerExists(paths, name) {
   return fs6.existsSync(providerJsonPath(paths, name));
@@ -4874,7 +4993,7 @@ function readProvider(paths, name) {
   return parseProviderFile(filePath, raw);
 }
 function loadProvider(providersDir, name, port) {
-  const filePath = path15.join(providersDir, `${name}.json`);
+  const filePath = path16.join(providersDir, `${name}.json`);
   const raw = port.readConfigFile(filePath);
   return raw === void 0 ? void 0 : parseProviderFile(filePath, raw);
 }
@@ -5129,21 +5248,21 @@ function removeDirectoryRule(paths, rulePath) {
 import os4 from "node:os";
 
 // src/launcher/cascade.ts
-import path17 from "node:path";
+import path18 from "node:path";
 
 // src/pathNorm.ts
-import path16 from "node:path";
+import path17 from "node:path";
 function expandTilde(value, home) {
   if (value === "~") {
     return home;
   }
   if (value.startsWith("~/")) {
-    return path16.join(home, value.slice(2));
+    return path17.join(home, value.slice(2));
   }
   return value;
 }
 function normaliseRulePath(rulePath, home) {
-  return path16.resolve(expandTilde(rulePath, home));
+  return path17.resolve(expandTilde(rulePath, home));
 }
 
 // src/launcher/cascade.ts
@@ -5153,7 +5272,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 = path17.join(params.paths.configProfilesDir, `${name}.json`);
+    const filepath = path18.join(params.paths.configProfilesDir, `${name}.json`);
     const loaded = loadConfigFile(filepath, ConfigProfileSchema, params.read);
     if (loaded === void 0) {
       return void 0;
@@ -5168,8 +5287,8 @@ function loadCascadeInput(params) {
   });
   const levels = [];
   for (const dir of dirs) {
-    const portable = loadConfigFile(path17.join(dir, PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(path17.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read);
-    const portableLocal = loadConfigFile(path17.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(path17.join(dir, LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read);
+    const portable = loadConfigFile(path18.join(dir, PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(path18.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read);
+    const portableLocal = loadConfigFile(path18.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(path18.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 {
@@ -5266,7 +5385,7 @@ function quotaWarnings(snapshot, provider, nowMs) {
 }
 
 // src/usage/poolPick.ts
-import path18 from "node:path";
+import path19 from "node:path";
 import { z as z9 } from "zod";
 
 // src/usage/plan.ts
@@ -5568,7 +5687,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(path18.dirname(picksFile));
+  fs12.mkdirPrivate(path19.dirname(picksFile));
   fs12.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
 `);
 }
@@ -5665,14 +5784,14 @@ import { spawn, spawnSync } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 import fs7 from "node:fs";
 import os3 from "node:os";
-import path20 from "node:path";
+import path21 from "node:path";
 import { isSea } from "node:sea";
 
 // src/versionDiscovery.ts
 import os2 from "node:os";
-import path19 from "node:path";
+import path20 from "node:path";
 function defaultVersionsDir() {
-  return path19.join(os2.homedir(), ".local", "share", "claude", "versions");
+  return path20.join(os2.homedir(), ".local", "share", "claude", "versions");
 }
 var NUMERIC_DOTTED_VERSION_RE = /^\d+(?:\.\d+)*$/;
 function isNumericDottedVersion(name) {
@@ -5714,14 +5833,14 @@ function discoverClaudeBinary(options) {
   const highestVersion = pickHighestVersion(entries);
   if (highestVersion !== void 0) {
     return {
-      path: path19.join(versionsDir, highestVersion),
+      path: path20.join(versionsDir, highestVersion),
       source: "versions-dir",
       version: highestVersion
     };
   }
-  const ownInstallDirs = new Set(options.ownInstallDirs.map((dir) => path19.resolve(dir)));
+  const ownInstallDirs = new Set(options.ownInstallDirs.map((dir) => path20.resolve(dir)));
   for (const dir of options.pathDirs) {
-    if (ownInstallDirs.has(path19.resolve(dir))) {
+    if (ownInstallDirs.has(path20.resolve(dir))) {
       continue;
     }
     const found = options.findExecutableInDir(dir, "claude");
@@ -5892,7 +6011,7 @@ var realRunPort = {
   }
 };
 function expandHome2(filePath) {
-  return filePath.startsWith("~/") ? path20.join(os3.homedir(), filePath.slice(1)) : filePath;
+  return filePath.startsWith("~/") ? path21.join(os3.homedir(), filePath.slice(1)) : filePath;
 }
 var MACOS_GUI_SESSION_MANAGER = "Aqua";
 function hasDesktopSession() {
@@ -5965,7 +6084,7 @@ 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 });
+  fs7.mkdirSync(path21.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 }));
@@ -5981,6 +6100,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 = fs7.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: () => {
@@ -5997,7 +6139,7 @@ function realHeadroomPort(paths, options) {
         }
       });
       return {
-        port: up.port,
+        socketPath: up.socketPath,
         projectId: resolveGitRoot(realRunPort, options.cwd) ?? options.cwd
       };
     },
@@ -6023,7 +6165,7 @@ function listVersionsDir(dir) {
     throw error;
   }
   return entries.filter((entry) => entry.isFile()).map((entry) => {
-    const fullPath = path20.join(dir, entry.name);
+    const fullPath = path21.join(dir, entry.name);
     const stat = fs7.statSync(fullPath);
     return {
       name: entry.name,
@@ -6038,7 +6180,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 = path20.join(dir, name);
+  const candidate = path21.join(dir, name);
   if (env.platform === "win32") {
     const extensions = windowsPathExtensions(env.pathext);
     const alreadyHasRecognisedExtension = extensions.some((ext) => candidate.toLowerCase().endsWith(ext.toLowerCase()));
@@ -6087,13 +6229,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 : path20.resolve(env.cwd, env.argv1);
-  const candidateDir = path20.dirname(candidate);
-  const candidateDirOnPath = env.pathDirs.some((dir) => path20.resolve(dir) === candidateDir);
+  const candidate = env.argv1 === void 0 ? env.execPath : path21.resolve(env.cwd, env.argv1);
+  const candidateDir = path21.dirname(candidate);
+  const candidateDirOnPath = env.pathDirs.some((dir) => path21.resolve(dir) === candidateDir);
   if (candidateDirOnPath) {
     return candidate;
   }
-  const viaPath = searchPathForExecutable(env.pathDirs, path20.basename(candidate), env.findExecutableInDir);
+  const viaPath = searchPathForExecutable(env.pathDirs, path21.basename(candidate), env.findExecutableInDir);
   return viaPath ?? candidate;
 }
 function realOwnExecutablePath() {
@@ -6101,21 +6243,21 @@ function realOwnExecutablePath() {
     argv1: process.argv[1],
     execPath: process.execPath,
     cwd: process.cwd(),
-    pathDirs: (process.env.PATH ?? "").split(path20.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(path21.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir
   });
 }
 function realResolveClaudeBinary(ownInstallDirs) {
   return () => discoverClaudeBinary({
     listVersionsDir,
-    pathDirs: (process.env.PATH ?? "").split(path20.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(path21.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir,
     ownInstallDirs: [...ownInstallDirs]
   });
 }
 
 // src/checkReport.ts
-import path21 from "node:path";
+import path22 from "node:path";
 import { z as z10 } from "zod";
 
 // src/cli/bool.ts
@@ -6483,10 +6625,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 : path21.join(paths.identitiesDir, identityDecision.name);
+  const farmRoot = identityDecision.name === void 0 ? void 0 : path22.join(paths.identitiesDir, identityDecision.name);
   const settingsFiles = {
-    "settings.json": realFsPort.readFileUtf8(path21.join(claudeHome, "settings.json")),
-    "settings.local.json": realFsPort.readFileUtf8(path21.join(claudeHome, "settings.local.json"))
+    "settings.json": realFsPort.readFileUtf8(path22.join(claudeHome, "settings.json")),
+    "settings.local.json": realFsPort.readFileUtf8(path22.join(claudeHome, "settings.local.json"))
   };
   const report = runCheck({
     cwd,
@@ -6516,7 +6658,7 @@ function collectCheckReport(params) {
 
 // src/claudeShim.ts
 import fs8 from "node:fs";
-import path22 from "node:path";
+import path23 from "node:path";
 import { z as z11 } from "zod";
 var ClaudeShimStateSchema = z11.strictObject({
   targetPath: z11.string().min(1),
@@ -6527,29 +6669,29 @@ function commandFilename(ownExecutablePath, commandName) {
   return ownExecutablePath.toLowerCase().endsWith(".exe") ? `${commandName}.exe` : commandName;
 }
 function resolveOwnInstallDirs(paths, ownExecutablePath) {
-  const dirs = [path22.dirname(ownExecutablePath)];
+  const dirs = [path23.dirname(ownExecutablePath)];
   const state = readJson(paths.claudeShimFile, ClaudeShimStateSchema);
   if (state !== void 0) {
-    dirs.push(path22.dirname(state.targetPath));
+    dirs.push(path23.dirname(state.targetPath));
   }
   return dirs;
 }
 var nodeLinkFs = { link: fs8.linkSync, copyFile: fs8.copyFileSync, chmod: fs8.chmodSync };
 function findPathShadow(params) {
-  const resolvedTargetDir = path22.resolve(params.targetDir);
+  const resolvedTargetDir = path23.resolve(params.targetDir);
   for (const dir of params.pathDirs) {
     const found = params.findExecutableInDir(dir, params.targetFilename);
     if (found === void 0) {
       continue;
     }
-    return path22.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
+    return path23.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
   }
-  return params.pathDirs.some((dir) => path22.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
+  return params.pathDirs.some((dir) => path23.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
 }
 
 // src/doctorReport.ts
 import fs9 from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 function refinePathShadow(status, ownExecutablePath, realpath) {
   if (status.status !== "shadowed") {
     return status;
@@ -6573,7 +6715,7 @@ function validateJson(schema, input) {
   return { ok: true, data: result.data };
 }
 function pushPathResolution(push, resolution) {
-  const ownDir = path23.dirname(resolution.ownExecutablePath);
+  const ownDir = path24.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");
@@ -6641,14 +6783,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 && path23.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
+  if (legacyVariables.length === 0 && path24.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 (path23.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
+  if (path24.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
     push(
       "legacy-name",
       "warn",
@@ -6838,7 +6980,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",
@@ -6854,7 +6996,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) {
@@ -6956,18 +7098,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 = path23.join(paths.identitiesDir, name);
-    const identityPath = path23.join(farmRoot, "identity.json");
+    const farmRoot = path24.join(paths.identitiesDir, name);
+    const identityPath = path24.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 = path23.join(paths.configProfilesDir, `${name}.json`);
+    const profilePath = path24.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 = path23.join(paths.providersDir, `${name}.json`);
+    const providerPath = path24.join(paths.providersDir, `${name}.json`);
     return { name, path: providerPath, raw: realFsPort.readFileUtf8(providerPath) };
   });
   const ownExecutablePath = realOwnExecutablePath();
@@ -6979,12 +7121,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(path23.delimiter).filter((dir) => dir !== "");
+  const pathDirs = (params.env.PATH ?? "").split(path24.delimiter).filter((dir) => dir !== "");
   const claudeShimShadow = shimState === void 0 ? void 0 : refinePathShadow(
     findPathShadow({
       pathDirs,
-      targetDir: path23.dirname(shimState.targetPath),
-      targetFilename: path23.basename(shimState.targetPath),
+      targetDir: path24.dirname(shimState.targetPath),
+      targetFilename: path24.basename(shimState.targetPath),
       findExecutableInDir
     }),
     shimState.targetPath,
@@ -7007,7 +7149,7 @@ function collectDoctorReport(params) {
       agentShim: refinePathShadow(
         findPathShadow({
           pathDirs,
-          targetDir: path23.dirname(ownExecutablePath),
+          targetDir: path24.dirname(ownExecutablePath),
           targetFilename: commandFilename(ownExecutablePath, "agent-shim"),
           findExecutableInDir
         }),
@@ -7028,7 +7170,7 @@ function collectDoctorReport(params) {
 
 // src/launcher.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import path25 from "node:path";
+import path26 from "node:path";
 
 // src/launcher/argv.ts
 var ConflictingIdentityError = class extends UsageError {
@@ -7280,7 +7422,7 @@ function buildCliOverride(params) {
 }
 
 // src/launcher/flags.ts
-import path24 from "node:path";
+import path25 from "node:path";
 
 // src/headroom/headers.ts
 function mergeAnthropicCustomHeaders(existing, additions) {
@@ -7350,7 +7492,7 @@ function buildEnv(params) {
   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);
+    env.CLAUDE_CONFIG_DIR = path25.join(params.identitiesDir, params.resolvedIdentityName);
   }
   if (params.provider !== void 0) {
     const providerEnv = params.provider.definition.env ?? {};
@@ -7371,9 +7513,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(
       [
@@ -7514,7 +7653,7 @@ function prepareLaunch(params) {
     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) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(path26.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.`
     );
@@ -7650,7 +7789,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);
@@ -7690,7 +7829,7 @@ 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";
+import path27 from "node:path";
 var KEYCHAIN_CACHE_SERVICE = "agent-shim-credential-cache";
 var CACHE_DIR_MODE = 448;
 var CACHE_FILE_MODE = 384;
@@ -7717,8 +7856,8 @@ function security(args, stdin) {
   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));
+  const dir = path27.join(root, "credential-cache");
+  const filePath = (owner) => path27.join(dir, cacheFileNameFor(owner));
   return {
     read(store, owner) {
       if (store === "file") {
@@ -7834,11 +7973,11 @@ function probeFrontDoorSync(port, caPem) {
 
 // src/frontdoor/trust.ts
 import { createHash as createHash5 } from "node:crypto";
-import path27 from "node:path";
+import path28 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)) {
+  if (inherited === void 0 || inherited === "" || path28.resolve(inherited) === path28.resolve(caCertFile)) {
     return { path: caCertFile };
   }
   const caPem = fs12.readFileUtf8(caCertFile);
@@ -7856,7 +7995,7 @@ function resolveTrustBundle(params) {
   }
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
-  const bundle = path27.join(bundlesDir, `${createHash5("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  const bundle = path28.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);