agent-shim 8.40.0 → 8.41.0

package/dist/index.cjs

@@ -279,6 +279,7 @@ __export(index_exports, {
   resolveAgentShimHome: () => resolveAgentShimHome,
   resolveClaudeHome: () => resolveClaudeHome,
   resolveDecisions: () => resolveDecisions,
+  resolveLaunchSelection: () => resolveLaunchSelection,
   resolveLayoutPaths: () => resolveLayoutPaths,
   resolveSupervisorConfig: () => resolveSupervisorConfig,
   resyncFarm: () => resyncFarm,
@@ -5427,7 +5428,7 @@ var import_undici = require("undici");
 // package.json
 var package_default = {
   name: "agent-shim",
-  version: "8.40.0",
+  version: "8.41.0",
   description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   license: "MIT",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -5861,7 +5862,10 @@ function frontDoorRcApiClient(port, ca, token) {
 var import_client3 = require("@orpc/client");
 
 // src/checkReport.ts
-var import_node_os4 = __toESM(require("node:os"), 1);
+var import_node_os5 = __toESM(require("node:os"), 1);
+
+// src/launchSelection.ts
+var import_node_os3 = __toESM(require("node:os"), 1);
 
 // src/launcher/cascade.ts
 var import_node_path11 = __toESM(require("node:path"), 1);
@@ -6033,319 +6037,127 @@ function loadIdentity(identitiesDir, name, fs12) {
   return loadConfigFile(import_node_path12.default.join(identitiesDir, name, "identity.json"), IdentitySchema, fs12.readConfigFile);
 }
 
-// src/paths.ts
-var import_node_fs2 = __toESM(require("node:fs"), 1);
-var import_node_os2 = __toESM(require("node:os"), 1);
-var import_node_path14 = __toESM(require("node:path"), 1);
-
-// src/headroom/state.ts
-var import_node_crypto6 = require("node:crypto");
-var import_node_path13 = __toESM(require("node:path"), 1);
-var import_zod5 = require("zod");
-var HEADROOM_ANTHROPIC_UPSTREAM = "https://api.anthropic.com";
-var HEADROOM_STATE_SCHEMA_VERSION = 2;
-var HeadroomStateSchema = import_zod5.z.strictObject({
-  /** The supervisor process owning the daemon. Alive means someone is keeping headroom running. */
-  supervisorPid: import_zod5.z.number().int().positive().optional(),
-  /** The headroom proxy process itself. Absent while the supervisor is between restarts. */
-  headroomPid: import_zod5.z.number().int().positive().optional(),
-  /**
-   * The unix socket the proxy serves on, inside the owner-only socket directory. Absent until the proxy has passed its readiness check, so "socketPath is set" is itself the ready signal a launcher polls for. The front door reads it on every hop, so a restart (which keeps the generation's path) is followed without anything being relaunched.
-   */
-  socketPath: import_zod5.z.string().min(1).optional(),
-  /** The `headroom --version` output of the running install. */
-  version: import_zod5.z.string().optional(),
-  /** Hash of the allowlist the running proxy was started with, so a provider-file change is detected as drift. */
-  allowlistHash: import_zod5.z.string().optional(),
-  /** Hash of the token-saving settings the running proxy was started with, so a settings change is detected as drift. */
-  settingsHash: import_zod5.z.string().optional(),
-  /** The install spec the running install was last installed from, so a `source` config change is detected as drift. */
-  installedSource: import_zod5.z.string().optional(),
-  /** The last fatal error, kept across shutdowns so `headroom status` can explain a daemon that is not running. */
-  lastError: import_zod5.z.string().optional()
-});
-var HeadroomSessionSchema = import_zod5.z.strictObject({ pid: import_zod5.z.number().int().positive(), startedAt: import_zod5.z.number(), supervisorPid: import_zod5.z.number().int().positive() });
-var HeadroomLockSchema = import_zod5.z.strictObject({ pid: import_zod5.z.number().int().positive(), at: import_zod5.z.number() });
-function parseJson(raw, schema) {
-  if (raw === void 0 || raw.trim() === "") {
-    return void 0;
-  }
-  const parsed = schema.safeParse(JSON.parse(raw));
-  return parsed.success ? parsed.data : void 0;
-}
-function readHeadroomState(fs12, stateFile) {
-  try {
-    return parseJson(fs12.readFileUtf8(stateFile), HeadroomStateSchema);
-  } catch {
-    return void 0;
-  }
-}
-function writeHeadroomState(fs12, stateFile, state) {
-  fs12.mkdirp(import_node_path13.default.dirname(stateFile));
-  fs12.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
-`);
-}
-function headroomAllowlist(providers) {
-  const urls = /* @__PURE__ */ new Set([HEADROOM_ANTHROPIC_UPSTREAM]);
-  for (const provider of providers) {
-    urls.add(provider.baseUrl);
-  }
-  return [...urls].sort();
-}
-function headroomUpstreams(providers, frontDoorOrigin2) {
-  const upstreams = providers.filter((provider) => !isCodexProvider(provider)).map((provider) => ({ baseUrl: provider.baseUrl }));
-  if (providers.length > 0 && frontDoorOrigin2 !== void 0) {
-    upstreams.push({ baseUrl: frontDoorOrigin2 });
-  }
-  return upstreams;
-}
-function hashAllowlist(allowlist) {
-  return (0, import_node_crypto6.createHash)("sha256").update(allowlist.join("\n")).digest("hex");
-}
-function readAllProviders(fs12, providersDir) {
-  const result = [];
-  for (const name of fs12.readdir(providersDir)) {
-    if (!name.endsWith(".json")) {
-      continue;
-    }
-    try {
-      const parsed = parseJson(fs12.readFileUtf8(import_node_path13.default.join(providersDir, name)), ProviderSchema);
-      if (parsed !== void 0) {
-        result.push({ name: name.slice(0, -".json".length), provider: parsed });
-      }
-    } catch {
-      continue;
-    }
-  }
-  return result;
-}
-function writeSession(fs12, sessionsDir, session) {
-  fs12.mkdirp(sessionsDir);
-  fs12.writeFileUtf8(import_node_path13.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
-`);
-}
-function removeSession(fs12, sessionsDir, pid) {
-  fs12.removeRecursive(import_node_path13.default.join(sessionsDir, `${String(pid)}.json`));
-}
-function listSessions(fs12, sessionsDir) {
-  const sessions = [];
-  for (const name of fs12.readdir(sessionsDir)) {
-    if (!name.endsWith(".json")) {
-      continue;
-    }
-    try {
-      const parsed = parseJson(fs12.readFileUtf8(import_node_path13.default.join(sessionsDir, name)), HeadroomSessionSchema);
-      if (parsed !== void 0) {
-        sessions.push(parsed);
-      }
-    } catch {
-      continue;
-    }
-  }
-  return sessions.sort((a, b) => a.pid - b.pid);
-}
-function sessionsForSupervisor(fs12, sessionsDir, supervisorPid) {
-  return listSessions(fs12, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
-}
-function pruneDeadSessions(fs12, sessionsDir, isRunning) {
-  const removed = [];
-  for (const session of listSessions(fs12, sessionsDir)) {
-    if (!isRunning(session.pid)) {
-      removeSession(fs12, sessionsDir, session.pid);
-      removed.push(session.pid);
-    }
-  }
-  return removed;
-}
-function readStartLock(fs12, lockFile) {
-  try {
-    return parseJson(fs12.readFileUtf8(lockFile), HeadroomLockSchema);
-  } catch {
-    return void 0;
-  }
-}
-
-// src/paths.ts
-function resolveAgentShimHome(env = process.env, home = import_node_os2.default.homedir(), isDirectory = isExistingDirectory) {
-  const fromEnv = env.AGENT_SHIM_HOME;
-  if (fromEnv !== void 0 && fromEnv !== "") {
-    return fromEnv;
-  }
-  const current = import_node_path14.default.join(home, HOME_DIRNAME);
-  const legacy = import_node_path14.default.join(home, LEGACY_HOME_DIRNAME);
-  return !isDirectory(current) && isDirectory(legacy) ? legacy : current;
-}
-function isExistingDirectory(candidate) {
-  return import_node_fs2.default.statSync(candidate, { throwIfNoEntry: false })?.isDirectory() ?? false;
-}
-function resolveClaudeHome() {
-  const fromEnv = process.env.AGENT_SHIM_CLAUDE_HOME;
-  if (fromEnv !== void 0 && fromEnv !== "") {
-    return fromEnv;
-  }
-  return import_node_path14.default.join(import_node_os2.default.homedir(), ".claude");
-}
-function buildLayoutPaths(root) {
-  return {
-    root,
-    identitiesDir: import_node_path14.default.join(root, "identities"),
-    configProfilesDir: import_node_path14.default.join(root, "config-profiles"),
-    providersDir: import_node_path14.default.join(root, "providers"),
-    directoryRulesFile: import_node_path14.default.join(root, "directory-rules.json"),
-    activeIdentityFile: import_node_path14.default.join(root, "active-identity"),
-    globalConfigFile: import_node_path14.default.join(root, "config.json"),
-    categoriesLocalFile: import_node_path14.default.join(root, "categories.local.json"),
-    claudeShimFile: import_node_path14.default.join(root, "claude-shim.json"),
-    headroomDir: import_node_path14.default.join(root, "headroom"),
-    headroomStateFile: import_node_path14.default.join(root, "headroom", `state.v${String(HEADROOM_STATE_SCHEMA_VERSION)}.json`),
-    headroomSocketDir: import_node_path14.default.join(root, "headroom", "run"),
-    headroomLockFile: import_node_path14.default.join(root, "headroom", "start.lock"),
-    headroomSessionsDir: import_node_path14.default.join(root, "headroom", "sessions"),
-    logsDir: import_node_path14.default.join(root, "logs"),
-    headroomLogPath: import_node_path14.default.join(root, "logs", "headroom.log"),
-    frontdoorDir: import_node_path14.default.join(root, "frontdoor"),
-    frontdoorCaDir: import_node_path14.default.join(root, "frontdoor", "ca"),
-    frontdoorCaCertFile: import_node_path14.default.join(root, "frontdoor", "ca", "ca.pem"),
-    frontdoorCaKeyFile: import_node_path14.default.join(root, "frontdoor", "ca", "ca.key"),
-    frontdoorCaBundlesDir: import_node_path14.default.join(root, "frontdoor", "ca", "bundles"),
-    chatgptSignInFile: import_node_path14.default.join(root, "codex", "chatgpt-sign-in.json"),
-    frontdoorStateFile: import_node_path14.default.join(root, "frontdoor", "state.json"),
-    frontdoorLockFile: import_node_path14.default.join(root, "frontdoor", "start.lock"),
-    frontdoorControlTokenFile: import_node_path14.default.join(root, "frontdoor", "control-token"),
-    frontdoorSessionsDir: import_node_path14.default.join(root, "frontdoor", "sessions"),
-    frontdoorRcCredentialsDir: import_node_path14.default.join(root, "frontdoor", "rc-credentials"),
-    frontdoorLogPath: import_node_path14.default.join(root, "logs", "frontdoor.log"),
-    usageDir: import_node_path14.default.join(root, "usage"),
-    usageLogDir: import_node_path14.default.join(root, "usage", "log"),
-    usageSnapshotsDir: import_node_path14.default.join(root, "usage", "snapshots"),
-    usagePicksFile: import_node_path14.default.join(root, "usage", "picks.json")
-  };
-}
-function resolveLayoutPaths() {
-  return buildLayoutPaths(resolveAgentShimHome());
-}
-
 // src/usage/poolPick.ts
-var import_node_path17 = __toESM(require("node:path"), 1);
-var import_zod9 = require("zod");
+var import_node_path15 = __toESM(require("node:path"), 1);
+var import_zod8 = require("zod");
 
 // src/usage/account.ts
-var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 
 // src/usage/schema.ts
-var import_zod6 = require("zod");
+var import_zod5 = require("zod");
 var USAGE_SCHEMA_VERSION = 1;
-var VersionSchema = import_zod6.z.literal(USAGE_SCHEMA_VERSION);
-var InstantSchema = import_zod6.z.iso.datetime();
-var TokenCountSchema = import_zod6.z.number().int().nonnegative();
-var TokenUsageSchema = import_zod6.z.strictObject({
+var VersionSchema = import_zod5.z.literal(USAGE_SCHEMA_VERSION);
+var InstantSchema = import_zod5.z.iso.datetime();
+var TokenCountSchema = import_zod5.z.number().int().nonnegative();
+var TokenUsageSchema = import_zod5.z.strictObject({
   inputTokens: TokenCountSchema.optional(),
   outputTokens: TokenCountSchema.optional(),
   cacheCreationInputTokens: TokenCountSchema.optional(),
   cacheReadInputTokens: TokenCountSchema.optional()
 });
 var LIMIT_KINDS = ["rate-limited", "quota-exhausted"];
-var LimitClassificationSchema = import_zod6.z.strictObject({
-  kind: import_zod6.z.enum(LIMIT_KINDS),
+var LimitClassificationSchema = import_zod5.z.strictObject({
+  kind: import_zod5.z.enum(LIMIT_KINDS),
   /** Seconds to wait before retrying, from the response's `retry-after`. */
-  retryAfterSeconds: import_zod6.z.number().nonnegative().optional(),
+  retryAfterSeconds: import_zod5.z.number().nonnegative().optional(),
   /** When the limiting window resets, from the upstream's own reset header. */
   resetAt: InstantSchema.optional(),
   /** The window the upstream named as the binding one (`anthropic-ratelimit-unified-representative-claim`), such as `five_hour` or `seven_day`. */
-  window: import_zod6.z.string().optional(),
+  window: import_zod5.z.string().optional(),
   /** The signals the classification rests on, each `<name>=<value>` from a response header or the error body's `type` or `code`. Never the error message. */
-  evidence: import_zod6.z.array(import_zod6.z.string())
+  evidence: import_zod5.z.array(import_zod5.z.string())
 });
-var UsageRecordSchema = import_zod6.z.strictObject({
+var UsageRecordSchema = import_zod5.z.strictObject({
   schemaVersion: VersionSchema,
   /** When the front door received the request. */
   at: InstantSchema,
   /** The launching identity, when the launch resolved one. */
-  identity: import_zod6.z.string().optional(),
+  identity: import_zod5.z.string().optional(),
   /** `anthropic` for an OAuth session's request to Claude Code's own API, otherwise the provider's name. */
-  provider: import_zod6.z.string(),
+  provider: import_zod5.z.string(),
   /** The launch's session id, generated per launch. */
-  sessionId: import_zod6.z.string().optional(),
+  sessionId: import_zod5.z.string().optional(),
   /** The project the launch ran in (its git repository root), when the launch sent one: headroom launches do. */
-  project: import_zod6.z.string().optional(),
+  project: import_zod5.z.string().optional(),
   /** The front-door route that served the request. */
-  route: import_zod6.z.string(),
-  method: import_zod6.z.string(),
+  route: import_zod5.z.string(),
+  method: import_zod5.z.string(),
   /** The API path as the upstream sees it (`/v1/messages`), without the provider prefix or a query string. */
-  endpoint: import_zod6.z.string(),
+  endpoint: import_zod5.z.string(),
   /** The model the response named. */
-  model: import_zod6.z.string().optional(),
-  status: import_zod6.z.number().int(),
+  model: import_zod5.z.string().optional(),
+  status: import_zod5.z.number().int(),
   /** Milliseconds from the request's arrival to its response head. */
-  latencyMs: import_zod6.z.number().int().nonnegative(),
+  latencyMs: import_zod5.z.number().int().nonnegative(),
   /** Milliseconds from the request's arrival to the end of its response body. */
-  durationMs: import_zod6.z.number().int().nonnegative(),
+  durationMs: import_zod5.z.number().int().nonnegative(),
   /** Whether the client received the whole body. */
-  outcome: import_zod6.z.enum(["completed", "aborted"]),
+  outcome: import_zod5.z.enum(["completed", "aborted"]),
   usage: TokenUsageSchema.optional(),
   /** The response's quota and rate-limit headers, by name (see `isRateLimitHeader`). */
-  rateLimitHeaders: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional(),
+  rateLimitHeaders: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.string()).optional(),
   limit: LimitClassificationSchema.optional(),
   /** The upstream's request id (`request-id`), for matching a record to the provider's own logs. */
-  requestId: import_zod6.z.string().optional()
+  requestId: import_zod5.z.string().optional()
 });
-var QuotaWindowSchema = import_zod6.z.strictObject({
+var QuotaWindowSchema = import_zod5.z.strictObject({
   /** The fraction of the window used, as the upstream reports it (0 to 1). */
-  utilization: import_zod6.z.number().nonnegative().optional(),
+  utilization: import_zod5.z.number().nonnegative().optional(),
   resetsAt: InstantSchema.optional(),
   /** The window's own status (`allowed`, `allowed_warning`, `rejected`). */
-  status: import_zod6.z.string().optional()
+  status: import_zod5.z.string().optional()
 });
-var UnifiedRateLimitSchema = import_zod6.z.strictObject({
+var UnifiedRateLimitSchema = import_zod5.z.strictObject({
   /** The overall status: `allowed`, `allowed_warning` or `rejected`. */
-  status: import_zod6.z.string().optional(),
+  status: import_zod5.z.string().optional(),
   fiveHour: QuotaWindowSchema.optional(),
   sevenDay: QuotaWindowSchema.optional(),
   /** The window that currently binds. */
-  representativeClaim: import_zod6.z.string().optional(),
+  representativeClaim: import_zod5.z.string().optional(),
   /** When the binding window resets. */
   resetAt: InstantSchema.optional(),
   /** Whether usage beyond the plan (extra usage) is available: `allowed` or `rejected`. */
-  overageStatus: import_zod6.z.string().optional()
+  overageStatus: import_zod5.z.string().optional()
 });
-var RateLimitStateSchema = import_zod6.z.strictObject({
+var RateLimitStateSchema = import_zod5.z.strictObject({
   observedAt: InstantSchema,
   /** Every quota and rate-limit header on that response, by name. */
-  headers: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()),
+  headers: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.string()),
   unified: UnifiedRateLimitSchema.optional()
 });
 var LimitEventSchema = LimitClassificationSchema.extend({
   observedAt: InstantSchema,
-  status: import_zod6.z.number().int()
+  status: import_zod5.z.number().int()
 });
-var ProviderQuotaWindowSchema = import_zod6.z.strictObject({
+var ProviderQuotaWindowSchema = import_zod5.z.strictObject({
   /** What the window measures, in the provider's terms (`tokens`, `tool-calls`). */
-  measures: import_zod6.z.string(),
+  measures: import_zod5.z.string(),
   /** The window's length in milliseconds, when the provider's unit is one this project knows; absent for an unrecognised unit, with `period` carrying the raw code. */
-  periodMs: import_zod6.z.number().int().positive().optional(),
+  periodMs: import_zod5.z.number().int().positive().optional(),
   /** The provider's own description of the period when `periodMs` could not be derived, such as `unit 4 x 1`. */
-  period: import_zod6.z.string().optional(),
+  period: import_zod5.z.string().optional(),
   /** The fraction of the window used (0 to 1). */
-  utilization: import_zod6.z.number().nonnegative(),
+  utilization: import_zod5.z.number().nonnegative(),
   resetsAt: InstantSchema.optional(),
   /** Absolute counts, when the provider reports them for this window. */
-  limit: import_zod6.z.number().nonnegative().optional(),
-  used: import_zod6.z.number().nonnegative().optional(),
-  remaining: import_zod6.z.number().nonnegative().optional()
+  limit: import_zod5.z.number().nonnegative().optional(),
+  used: import_zod5.z.number().nonnegative().optional(),
+  remaining: import_zod5.z.number().nonnegative().optional()
 });
-var ProviderQuotaSchema = import_zod6.z.strictObject({
+var ProviderQuotaSchema = import_zod5.z.strictObject({
   observedAt: InstantSchema,
   /** Which usage endpoint produced it (`z.ai`). */
-  source: import_zod6.z.string(),
+  source: import_zod5.z.string(),
   /** The subscription level the endpoint reports, when it does. */
-  level: import_zod6.z.string().optional(),
-  windows: import_zod6.z.array(ProviderQuotaWindowSchema)
+  level: import_zod5.z.string().optional(),
+  windows: import_zod5.z.array(ProviderQuotaWindowSchema)
 });
-var ProviderUsageStateSchema = import_zod6.z.strictObject({
+var ProviderUsageStateSchema = import_zod5.z.strictObject({
   /** When the provider last served a request for the identity through the front door. Absent while the state holds only a rate-limit state fetched from the provider's usage endpoint, for an identity that has made no request. */
   lastRequestAt: InstantSchema.optional(),
-  lastStatus: import_zod6.z.number().int().optional(),
-  lastModel: import_zod6.z.string().optional(),
+  lastStatus: import_zod5.z.number().int().optional(),
+  lastModel: import_zod5.z.string().optional(),
   /** The latest rate-limit state, from the last response that carried any rate-limit header. */
   rateLimit: RateLimitStateSchema.optional(),
   /** The latest classified refusal. It stays after later successes, so a reader compares its `resetAt` (or `observedAt` plus `retryAfterSeconds`) with the current time. */
@@ -6353,31 +6165,31 @@ var ProviderUsageStateSchema = import_zod6.z.strictObject({
   /** The latest quota the provider's usage endpoint reported, for providers whose quota is not visible in response headers. */
   quota: ProviderQuotaSchema.optional()
 });
-var AccountMetadataSchema = import_zod6.z.strictObject({
-  accountUuid: import_zod6.z.string().optional(),
-  emailAddress: import_zod6.z.string().optional(),
-  displayName: import_zod6.z.string().optional(),
-  organizationUuid: import_zod6.z.string().optional(),
-  organizationName: import_zod6.z.string().optional(),
-  organizationType: import_zod6.z.string().optional(),
-  organizationRole: import_zod6.z.string().optional(),
-  workspaceRole: import_zod6.z.string().optional(),
-  billingType: import_zod6.z.string().optional(),
-  seatTier: import_zod6.z.string().optional(),
-  organizationRateLimitTier: import_zod6.z.string().optional(),
-  userRateLimitTier: import_zod6.z.string().optional(),
-  hasExtraUsageEnabled: import_zod6.z.boolean().optional(),
-  subscriptionCreatedAt: import_zod6.z.string().optional(),
-  accountCreatedAt: import_zod6.z.string().optional()
+var AccountMetadataSchema = import_zod5.z.strictObject({
+  accountUuid: import_zod5.z.string().optional(),
+  emailAddress: import_zod5.z.string().optional(),
+  displayName: import_zod5.z.string().optional(),
+  organizationUuid: import_zod5.z.string().optional(),
+  organizationName: import_zod5.z.string().optional(),
+  organizationType: import_zod5.z.string().optional(),
+  organizationRole: import_zod5.z.string().optional(),
+  workspaceRole: import_zod5.z.string().optional(),
+  billingType: import_zod5.z.string().optional(),
+  seatTier: import_zod5.z.string().optional(),
+  organizationRateLimitTier: import_zod5.z.string().optional(),
+  userRateLimitTier: import_zod5.z.string().optional(),
+  hasExtraUsageEnabled: import_zod5.z.boolean().optional(),
+  subscriptionCreatedAt: import_zod5.z.string().optional(),
+  accountCreatedAt: import_zod5.z.string().optional()
 });
-var UsageSnapshotSchema = import_zod6.z.strictObject({
+var UsageSnapshotSchema = import_zod5.z.strictObject({
   schemaVersion: VersionSchema,
-  identity: import_zod6.z.string(),
+  identity: import_zod5.z.string(),
   updatedAt: InstantSchema,
   /** The identity's account metadata as of `updatedAt`. */
   account: AccountMetadataSchema.optional(),
   /** Latest state per provider, keyed by provider name (`anthropic` for OAuth sessions). */
-  providers: import_zod6.z.record(import_zod6.z.string(), ProviderUsageStateSchema)
+  providers: import_zod5.z.record(import_zod5.z.string(), ProviderUsageStateSchema)
 });
 
 // src/usage/account.ts
@@ -6397,7 +6209,7 @@ function isIdentityName(name) {
   return IdentitySchema.shape.name.safeParse(name).success;
 }
 function claudeJsonPath(identitiesDir, identity) {
-  return import_node_path15.default.join(identitiesDir, identity, CLAUDE_JSON);
+  return import_node_path13.default.join(identitiesDir, identity, CLAUDE_JSON);
 }
 function readAccountMetadata(fs12, identitiesDir, identity) {
   if (!isIdentityName(identity)) {
@@ -6436,20 +6248,20 @@ function readAccountMetadata(fs12, identitiesDir, identity) {
 }
 
 // src/usage/plan.ts
-var import_zod7 = require("zod");
-var PlanClassSchema = import_zod7.z.union([
-  import_zod7.z.strictObject({
-    kind: import_zod7.z.literal("subscription"),
+var import_zod6 = require("zod");
+var PlanClassSchema = import_zod6.z.union([
+  import_zod6.z.strictObject({
+    kind: import_zod6.z.literal("subscription"),
     /** The plan's size as a multiple of the smallest subscription tier (Max 5x is 5, Max 20x is 20). */
-    capacity: import_zod7.z.number().positive(),
+    capacity: import_zod6.z.number().positive(),
     /** False when the tier string named no multiplier and no tier this project knows, so `capacity` is the neutral 1 rather than a reading. */
-    recognised: import_zod7.z.boolean(),
+    recognised: import_zod6.z.boolean(),
     /** The tier string the classification rests on, when the account had one. */
-    tier: import_zod7.z.string().optional()
+    tier: import_zod6.z.string().optional()
   }),
-  import_zod7.z.strictObject({
-    kind: import_zod7.z.literal("pay-per-use"),
-    tier: import_zod7.z.string().optional()
+  import_zod6.z.strictObject({
+    kind: import_zod6.z.literal("pay-per-use"),
+    tier: import_zod6.z.string().optional()
   })
 ]);
 var TIER_MULTIPLIER = /(?:^|_)(\d+)x$/;
@@ -6518,17 +6330,17 @@ function parseUnifiedRateLimit(headers) {
 }
 
 // src/usage/scan.ts
-var import_zod8 = require("zod");
-var AnthropicUsageSchema = import_zod8.z.looseObject({
-  input_tokens: import_zod8.z.number().int().nonnegative().nullish(),
-  output_tokens: import_zod8.z.number().int().nonnegative().nullish(),
-  cache_creation_input_tokens: import_zod8.z.number().int().nonnegative().nullish(),
-  cache_read_input_tokens: import_zod8.z.number().int().nonnegative().nullish()
+var import_zod7 = require("zod");
+var AnthropicUsageSchema = import_zod7.z.looseObject({
+  input_tokens: import_zod7.z.number().int().nonnegative().nullish(),
+  output_tokens: import_zod7.z.number().int().nonnegative().nullish(),
+  cache_creation_input_tokens: import_zod7.z.number().int().nonnegative().nullish(),
+  cache_read_input_tokens: import_zod7.z.number().int().nonnegative().nullish()
 });
-var ErrorObjectSchema = import_zod8.z.looseObject({
-  type: import_zod8.z.string().optional(),
-  code: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional(),
-  message: import_zod8.z.string().optional()
+var ErrorObjectSchema = import_zod7.z.looseObject({
+  type: import_zod7.z.string().optional(),
+  code: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional(),
+  message: import_zod7.z.string().optional()
 });
 
 // src/usage/middleware.ts
@@ -6815,7 +6627,7 @@ function rankPool(input) {
 }
 
 // src/usage/read.ts
-var import_node_path16 = __toESM(require("node:path"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
 var SEGMENT_RE = /^(\d{4}-\d{2}-\d{2})\.(\d+)\.jsonl$/;
 var DAY_MS = 864e5;
 function listLogSegments(fs12, logDir) {
@@ -6836,7 +6648,7 @@ function readUsageLog(fs12, logDir, options = {}) {
     if (sinceMs !== void 0 && segment.endsAt <= sinceMs) {
       continue;
     }
-    const contents = fs12.readFileUtf8(import_node_path16.default.join(logDir, segment.name));
+    const contents = fs12.readFileUtf8(import_node_path14.default.join(logDir, segment.name));
     if (contents === void 0) {
       continue;
     }
@@ -6878,7 +6690,7 @@ function snapshotPath(snapshotsDir, identity) {
   if (!isIdentityName(identity)) {
     throw new Error(`"${identity}" is not a valid identity name.`);
   }
-  return import_node_path16.default.join(snapshotsDir, `${identity}.json`);
+  return import_node_path14.default.join(snapshotsDir, `${identity}.json`);
 }
 function readUsageSnapshot(fs12, snapshotsDir, identity) {
   const file = snapshotPath(snapshotsDir, identity);
@@ -6925,10 +6737,10 @@ var PoolGraphError = class extends CliError {
   }
 };
 var SCHEMA_VERSION = 1;
-var PickEntrySchema = import_zod9.z.strictObject({ identity: import_zod9.z.string().min(1), at: import_zod9.z.iso.datetime() });
-var PicksFileSchema = import_zod9.z.strictObject({
-  schemaVersion: import_zod9.z.literal(SCHEMA_VERSION),
-  picks: import_zod9.z.record(import_zod9.z.string().min(1), PickEntrySchema)
+var PickEntrySchema = import_zod8.z.strictObject({ identity: import_zod8.z.string().min(1), at: import_zod8.z.iso.datetime() });
+var PicksFileSchema = import_zod8.z.strictObject({
+  schemaVersion: import_zod8.z.literal(SCHEMA_VERSION),
+  picks: import_zod8.z.record(import_zod8.z.string().min(1), PickEntrySchema)
 });
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -7056,7 +6868,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_path17.default.dirname(picksFile));
+  fs12.mkdirPrivate(import_node_path15.default.dirname(picksFile));
   fs12.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
 `);
 }
@@ -7098,8 +6910,8 @@ function collectPoolPick(params) {
 }
 
 // src/configProfilesStore.ts
-var import_node_fs3 = __toESM(require("node:fs"), 1);
-var import_node_path18 = __toESM(require("node:path"), 1);
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_path16 = __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.`);
@@ -7125,10 +6937,10 @@ var InvalidCategoryNameError = class extends CliError {
   categoryName;
 };
 function profileJsonPath(paths, name) {
-  return import_node_path18.default.join(paths.configProfilesDir, `${name}.json`);
+  return import_node_path16.default.join(paths.configProfilesDir, `${name}.json`);
 }
 function profileExists(paths, name) {
-  return import_node_fs3.default.existsSync(profileJsonPath(paths, name));
+  return import_node_fs2.default.existsSync(profileJsonPath(paths, name));
 }
 function requireProfileExists(paths, name) {
   if (!profileExists(paths, name)) {
@@ -7154,10 +6966,10 @@ function createProfile(paths, name, extendsList, description) {
   return parsed.data;
 }
 function listProfiles(paths) {
-  if (!import_node_fs3.default.existsSync(paths.configProfilesDir)) {
+  if (!import_node_fs2.default.existsSync(paths.configProfilesDir)) {
     return [];
   }
-  const names = import_node_fs3.default.readdirSync(paths.configProfilesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort();
+  const names = import_node_fs2.default.readdirSync(paths.configProfilesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort();
   const result = [];
   for (const name of names) {
     const profile = readProfile(paths, name);
@@ -7220,7 +7032,7 @@ function setProfileMetadata(paths, name, patch) {
 }
 function removeProfile(paths, name) {
   requireProfileExists(paths, name);
-  import_node_fs3.default.rmSync(profileJsonPath(paths, name));
+  import_node_fs2.default.rmSync(profileJsonPath(paths, name));
 }
 
 // src/poolStore.ts
@@ -7322,1450 +7134,1684 @@ function removePool(paths, name) {
   writePools(paths, remaining);
 }
 
-// src/realCredentialCache.ts
+// src/realPorts.ts
 var import_node_child_process = require("node:child_process");
-var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_crypto8 = require("node:crypto");
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_os2 = __toESM(require("node:os"), 1);
 var import_node_path19 = __toESM(require("node:path"), 1);
+var import_node_sea = require("node:sea");
 
-// src/credentialCache.ts
-var import_zod10 = require("zod");
-var MS_PER_UNIT = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
-var CachedCredentialSchema = import_zod10.z.strictObject({
-  token: import_zod10.z.string().min(1),
-  fetchedAt: import_zod10.z.number().int().nonnegative(),
-  source: CredentialSourceSchema
+// src/headroom/state.ts
+var import_node_crypto6 = require("node:crypto");
+var import_node_path17 = __toESM(require("node:path"), 1);
+var import_zod9 = require("zod");
+var HEADROOM_ANTHROPIC_UPSTREAM = "https://api.anthropic.com";
+var HEADROOM_STATE_SCHEMA_VERSION = 2;
+var HeadroomStateSchema = import_zod9.z.strictObject({
+  /** The supervisor process owning the daemon. Alive means someone is keeping headroom running. */
+  supervisorPid: import_zod9.z.number().int().positive().optional(),
+  /** The headroom proxy process itself. Absent while the supervisor is between restarts. */
+  headroomPid: import_zod9.z.number().int().positive().optional(),
+  /**
+   * The unix socket the proxy serves on, inside the owner-only socket directory. Absent until the proxy has passed its readiness check, so "socketPath is set" is itself the ready signal a launcher polls for. The front door reads it on every hop, so a restart (which keeps the generation's path) is followed without anything being relaunched.
+   */
+  socketPath: import_zod9.z.string().min(1).optional(),
+  /** The `headroom --version` output of the running install. */
+  version: import_zod9.z.string().optional(),
+  /** Hash of the allowlist the running proxy was started with, so a provider-file change is detected as drift. */
+  allowlistHash: import_zod9.z.string().optional(),
+  /** Hash of the token-saving settings the running proxy was started with, so a settings change is detected as drift. */
+  settingsHash: import_zod9.z.string().optional(),
+  /** The install spec the running install was last installed from, so a `source` config change is detected as drift. */
+  installedSource: import_zod9.z.string().optional(),
+  /** The last fatal error, kept across shutdowns so `headroom status` can explain a daemon that is not running. */
+  lastError: import_zod9.z.string().optional()
 });
-function effectiveStore(cache, platform) {
-  return cache.store ?? (platform === "darwin" ? "keychain" : "file");
-}
-function ttlMs(cache) {
-  if (cache.ttl === void 0) {
+var HeadroomSessionSchema = import_zod9.z.strictObject({ pid: import_zod9.z.number().int().positive(), startedAt: import_zod9.z.number(), supervisorPid: import_zod9.z.number().int().positive() });
+var HeadroomLockSchema = import_zod9.z.strictObject({ pid: import_zod9.z.number().int().positive(), at: import_zod9.z.number() });
+function parseJson(raw, schema) {
+  if (raw === void 0 || raw.trim() === "") {
     return void 0;
   }
-  const multiplier = MS_PER_UNIT[cache.ttl.slice(-1)];
-  if (multiplier === void 0) {
-    throw new Error(`credential cache ttl "${cache.ttl}" has no recognised unit`);
-  }
-  return Number(cache.ttl.slice(0, -1)) * multiplier;
+  const parsed = schema.safeParse(JSON.parse(raw));
+  return parsed.success ? parsed.data : void 0;
 }
-function isFresh(entry, cache, now) {
-  const limit = ttlMs(cache);
-  if (entry.fetchedAt > now) {
-    return false;
+function readHeadroomState(fs12, stateFile) {
+  try {
+    return parseJson(fs12.readFileUtf8(stateFile), HeadroomStateSchema);
+  } catch {
+    return void 0;
   }
-  return limit === void 0 || now - entry.fetchedAt < limit;
 }
-function cacheAgeMs(entry, now) {
-  return Math.max(0, now - entry.fetchedAt);
+function writeHeadroomState(fs12, stateFile, state) {
+  fs12.mkdirp(import_node_path17.default.dirname(stateFile));
+  fs12.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
+`);
 }
-function describeCachedCredential(params) {
-  const store = effectiveStore(params.cache, params.platform);
-  let entry;
-  try {
-    entry = params.port.read(store, params.owner);
-  } catch (error) {
-    return { store, status: "unreadable", reason: error instanceof Error ? error.message : String(error) };
-  }
-  if (entry === void 0) {
-    return { store, status: "empty" };
+function headroomAllowlist(providers) {
+  const urls = /* @__PURE__ */ new Set([HEADROOM_ANTHROPIC_UPSTREAM]);
+  for (const provider of providers) {
+    urls.add(provider.baseUrl);
   }
-  const limit = ttlMs(params.cache);
-  const ageMs = cacheAgeMs(entry, params.nowMs);
-  return {
-    store,
-    status: isFresh(entry, params.cache, params.nowMs) ? "fresh" : "expired",
-    ageMs,
-    ...limit === void 0 ? {} : { expiresInMs: limit - ageMs }
-  };
+  return [...urls].sort();
 }
-function formatCachedCredentialState(state) {
-  if (state.status === "empty") {
-    return `no cached entry in the ${state.store} store yet`;
-  }
-  if (state.status === "unreadable") {
-    return `the ${state.store} store cannot be read here: ${state.reason}`;
-  }
-  if (state.status === "expired" && (state.expiresInMs === void 0 || state.expiresInMs > 0)) {
-    return "cached with a timestamp in the future, treated as expired";
+function headroomUpstreams(providers, frontDoorOrigin2) {
+  const upstreams = providers.filter((provider) => !isCodexProvider(provider)).map((provider) => ({ baseUrl: provider.baseUrl }));
+  if (providers.length > 0 && frontDoorOrigin2 !== void 0) {
+    upstreams.push({ baseUrl: frontDoorOrigin2 });
   }
-  const age = `cached ${formatAge(state.ageMs)} ago`;
-  if (state.expiresInMs === void 0) {
-    return `${age}, no expiry`;
+  return upstreams;
+}
+function hashAllowlist(allowlist) {
+  return (0, import_node_crypto6.createHash)("sha256").update(allowlist.join("\n")).digest("hex");
+}
+function readAllProviders(fs12, providersDir) {
+  const result = [];
+  for (const name of fs12.readdir(providersDir)) {
+    if (!name.endsWith(".json")) {
+      continue;
+    }
+    try {
+      const parsed = parseJson(fs12.readFileUtf8(import_node_path17.default.join(providersDir, name)), ProviderSchema);
+      if (parsed !== void 0) {
+        result.push({ name: name.slice(0, -".json".length), provider: parsed });
+      }
+    } catch {
+      continue;
+    }
   }
-  return state.status === "fresh" ? `${age}, expires in ${formatAge(state.expiresInMs)}` : `${age}, expired ${formatAge(-state.expiresInMs)} ago`;
+  return result;
 }
-
-// src/realCredentialCache.ts
-var KEYCHAIN_CACHE_SERVICE = "agent-shim-credential-cache";
-var CACHE_DIR_MODE = 448;
-var CACHE_FILE_MODE = 384;
-function cacheFileNameFor(owner) {
-  return `${owner.replace(/[^A-Za-z0-9._-]/g, "_")}.json`;
+function writeSession(fs12, sessionsDir, session) {
+  fs12.mkdirp(sessionsDir);
+  fs12.writeFileUtf8(import_node_path17.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+`);
 }
-function parseEntry(raw) {
-  let json;
+function removeSession(fs12, sessionsDir, pid) {
+  fs12.removeRecursive(import_node_path17.default.join(sessionsDir, `${String(pid)}.json`));
+}
+function listSessions(fs12, sessionsDir) {
+  const sessions = [];
+  for (const name of fs12.readdir(sessionsDir)) {
+    if (!name.endsWith(".json")) {
+      continue;
+    }
+    try {
+      const parsed = parseJson(fs12.readFileUtf8(import_node_path17.default.join(sessionsDir, name)), HeadroomSessionSchema);
+      if (parsed !== void 0) {
+        sessions.push(parsed);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return sessions.sort((a, b) => a.pid - b.pid);
+}
+function sessionsForSupervisor(fs12, sessionsDir, supervisorPid) {
+  return listSessions(fs12, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
+}
+function pruneDeadSessions(fs12, sessionsDir, isRunning) {
+  const removed = [];
+  for (const session of listSessions(fs12, sessionsDir)) {
+    if (!isRunning(session.pid)) {
+      removeSession(fs12, sessionsDir, session.pid);
+      removed.push(session.pid);
+    }
+  }
+  return removed;
+}
+function readStartLock(fs12, lockFile) {
   try {
-    json = JSON.parse(raw);
+    return parseJson(fs12.readFileUtf8(lockFile), HeadroomLockSchema);
   } catch {
     return void 0;
   }
-  const parsed = CachedCredentialSchema.safeParse(json);
-  return parsed.success ? parsed.data : void 0;
 }
-function requireKeychain() {
-  if (process.platform !== "darwin") {
-    throw new Error("the keychain credential store needs macOS; use --credential-cache-store file");
+
+// src/headroom/ensure.ts
+var HEADROOM_START_TIMEOUT_MS = 12e4;
+var HEADROOM_LAUNCHER_POLL_MS = 250;
+var HeadroomStartError = class extends CliError {
+  constructor(message) {
+    super(message);
+    this.name = "HeadroomStartError";
   }
-}
-function security(args, stdin) {
-  const result = (0, import_node_child_process.spawnSync)("security", args, { encoding: "utf8", ...stdin === void 0 ? {} : { input: stdin }, stdio: ["pipe", "pipe", "ignore"] });
-  return { status: result.status, stdout: result.stdout };
-}
-function createRealCredentialCache(root) {
-  const dir = import_node_path19.default.join(root, "credential-cache");
-  const filePath = (owner) => import_node_path19.default.join(dir, cacheFileNameFor(owner));
-  return {
-    read(store, owner) {
-      if (store === "file") {
-        try {
-          return parseEntry(import_node_fs4.default.readFileSync(filePath(owner), "utf8"));
-        } catch {
-          return void 0;
+};
+function ensureHeadroom(params) {
+  const { paths, ports } = params;
+  const deadline = ports.now() + HEADROOM_START_TIMEOUT_MS;
+  let spawnedSupervisor = false;
+  let awaitingAllowlist = false;
+  for (; ; ) {
+    const state = readHeadroomState(ports.fs, paths.headroomStateFile);
+    if (state?.supervisorPid !== void 0 && ports.isRunning(state.supervisorPid)) {
+      const daemonUp = state.socketPath !== void 0 && state.headroomPid !== void 0 && ports.isRunning(state.headroomPid);
+      if (daemonUp && state.socketPath !== void 0) {
+        const required = params.requiredAllowlistHash?.();
+        if (required === void 0 || state.allowlistHash === required) {
+          writeSession(ports.fs, paths.headroomSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), supervisorPid: state.supervisorPid });
+          return { socketPath: state.socketPath };
         }
+        const holders = sessionsForSupervisor(ports.fs, paths.headroomSessionsDir, state.supervisorPid).filter((session) => ports.isRunning(session.pid));
+        if (holders.length > 0) {
+          throw new HeadroomStartError(
+            `the running headroom daemon was started before this launch's front door address and would refuse every request this launch sends through it. It restarts once the launches using it end (pid ${holders.map((session) => String(session.pid)).join(", ")}); end them and launch again, or launch with --no-headroom.`
+          );
+        }
+        awaitingAllowlist = true;
       }
-      requireKeychain();
-      const result = security(["find-generic-password", "-s", KEYCHAIN_CACHE_SERVICE, "-a", owner, "-w"]);
-      return result.status === 0 ? parseEntry(Buffer.from(result.stdout.trim(), "base64").toString("utf8")) : void 0;
-    },
-    write(store, owner, entry) {
-      const serialised = JSON.stringify(entry);
-      if (store === "file") {
-        import_node_fs4.default.mkdirSync(dir, { recursive: true, mode: CACHE_DIR_MODE });
-        import_node_fs4.default.chmodSync(dir, CACHE_DIR_MODE);
-        const target = filePath(owner);
-        const temp = `${target}.${String(process.pid)}.tmp`;
-        import_node_fs4.default.writeFileSync(temp, serialised, { mode: CACHE_FILE_MODE });
-        import_node_fs4.default.renameSync(temp, target);
-        return;
-      }
-      requireKeychain();
-      const encoded = Buffer.from(serialised, "utf8").toString("base64");
-      const result = security(["-i"], `add-generic-password -U -s ${KEYCHAIN_CACHE_SERVICE} -a ${JSON.stringify(owner)} -w ${encoded}
-`);
-      if (result.status !== 0) {
-        throw new Error(`could not write the keychain credential cache for ${owner}`);
+      if (state.lastError !== void 0) {
+        throw new HeadroomStartError(
+          `the headroom daemon reported a fatal error and is not serving: ${state.lastError} (daemon log: ${paths.headroomLogPath})`
+        );
       }
-    },
-    remove(store, owner) {
-      if (store === "file") {
-        import_node_fs4.default.rmSync(filePath(owner), { force: true });
-        return;
+    } else if (!spawnedSupervisor) {
+      ports.fs.mkdirp(paths.headroomDir);
+      const created = ports.fs.writeFileExclusive(
+        paths.headroomLockFile,
+        `${JSON.stringify({ pid: params.launcherPid, at: ports.now() })}
+`
+      );
+      if (created) {
+        ports.spawnSupervisor(paths);
+        spawnedSupervisor = true;
+      } else {
+        const lock = readStartLock(ports.fs, paths.headroomLockFile);
+        if (lock === void 0 || !ports.isRunning(lock.pid)) {
+          ports.fs.removeRecursive(paths.headroomLockFile);
+          continue;
+        }
       }
-      requireKeychain();
-      security(["delete-generic-password", "-s", KEYCHAIN_CACHE_SERVICE, "-a", owner]);
     }
+    if (ports.now() >= deadline) {
+      const lastError = state?.lastError;
+      throw new HeadroomStartError(
+        `the headroom daemon did not become ready within ${String(HEADROOM_START_TIMEOUT_MS)}ms` + (lastError === void 0 ? "" : ` (last error: ${lastError})`) + (awaitingAllowlist ? " (the running daemon's allowlist does not admit this launch's front door, and it did not restart)" : "") + `. Daemon log: ${paths.headroomLogPath}`
+      );
+    }
+    ports.sleep(HEADROOM_LAUNCHER_POLL_MS);
+  }
+}
+
+// src/headroom/settings.ts
+var import_node_crypto7 = require("node:crypto");
+function settingsOf(config) {
+  return {
+    ...config.mode === void 0 ? {} : { mode: config.mode },
+    ...config.targetRatio === void 0 ? {} : { targetRatio: config.targetRatio },
+    ...config.ccr === void 0 ? {} : { ccr: config.ccr },
+    ...config.rolloutChannel === void 0 ? {} : { rolloutChannel: config.rolloutChannel },
+    ...config.interceptToolResults === void 0 ? {} : { interceptToolResults: config.interceptToolResults },
+    ...config.readMaturation === void 0 ? {} : { readMaturation: config.readMaturation }
   };
 }
-function realCredentialCacheEnv(paths) {
-  return { port: createRealCredentialCache(paths.root), platform: process.platform, now: () => Date.now() };
+function settingsArgs(settings) {
+  return [
+    ...settings.mode === void 0 ? [] : ["--mode", settings.mode],
+    ...settings.targetRatio === void 0 ? [] : ["--target-ratio", String(settings.targetRatio)],
+    ...settings.ccr === "lossless" ? ["--lossless"] : [],
+    ...settings.ccr === "none" ? ["--no-ccr"] : [],
+    ...settings.interceptToolResults === true ? ["--intercept-tool-results"] : [],
+    ...settings.readMaturation === true ? ["--read-maturation"] : []
+  ];
+}
+function settingsEnv(settings) {
+  return settings.rolloutChannel === void 0 ? {} : { HEADROOM_ROLLOUT_CHANNEL: settings.rolloutChannel };
+}
+function hashSettings(settings) {
+  return (0, import_node_crypto7.createHash)("sha256").update(JSON.stringify([...settingsArgs(settings), JSON.stringify(settingsEnv(settings))])).digest("hex");
 }
 
-// src/providersStore.ts
-var import_node_fs5 = __toESM(require("node:fs"), 1);
-var import_node_path20 = __toESM(require("node:path"), 1);
-
-// src/credential.ts
-var CREDENTIAL_UNAVAILABLE_EXIT = 64;
-var CREDENTIAL_COMMAND_TIMEOUT_MS = 1e4;
-var CREDENTIAL_INTERACTIVE_TIMEOUT_MS = 12e4;
-var GROUP_OTHER_PERMISSION_BITS = 63;
-var PERMISSION_BITS = 511;
+// src/headroom/socket.ts
+var import_node_path18 = __toESM(require("node:path"), 1);
+var GROUP_OR_OTHER_BITS = 63;
 var OCTAL_RADIX = 8;
-function commandArgv(source) {
-  if ("command" in source) {
-    return source.command;
-  }
-  if ("op" in source) {
-    return ["op", "read", source.op];
-  }
-  const account = source.keychain.account;
-  return ["security", "find-generic-password", "-s", source.keychain.service, ...account === void 0 ? [] : ["-a", account], "-w"];
+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_path18.default.join(paths.headroomSocketDir, `${String(supervisorPid)}${HEADROOM_SOCKET_SUFFIX}`);
 }
-function isInteractiveSource(source, env) {
-  if ("command" in source || "keychain" in source) {
-    return source.interactive ?? false;
-  }
-  if ("op" in source) {
-    return source.interactive ?? (env.OP_SERVICE_ACCOUNT_TOKEN ?? "") === "";
-  }
-  return false;
+function 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 summariseSource(source) {
-  if ("env" in source) {
-    return { kind: "env", variable: source.env };
+function ownerOnlyRefusal(label, target, stat, expected, uid) {
+  if (stat === void 0) {
+    return `the headroom ${label} ${target} does not exist`;
   }
-  if ("file" in source) {
-    return { kind: "file", path: source.file };
+  if (stat.kind === "symlink") {
+    return `the headroom ${label} ${target} is a symlink; it must be the real ${expected === "dir" ? "directory" : "socket"}`;
   }
-  if ("command" in source) {
-    return { kind: "command", program: source.command[0] };
+  if (stat.kind !== expected) {
+    return `the headroom ${label} ${target} is not a ${expected === "dir" ? "directory" : "socket"}`;
   }
-  if ("op" in source) {
-    return { kind: "op", reference: source.op };
+  if (stat.uid !== uid) {
+    return `the headroom ${label} ${target} is owned by uid ${String(stat.uid)}, not by this user (uid ${String(uid)})`;
   }
-  if ("keychain" in source) {
-    return {
-      kind: "keychain",
-      service: source.keychain.service,
-      ...source.keychain.account === void 0 ? {} : { account: source.keychain.account }
-    };
+  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 { kind: "literal" };
-}
-function summariseCredential(credential) {
-  return {
-    target: credential.target ?? "bearer",
-    sources: credential.sources.map(summariseSource),
-    ...credential.cache === void 0 ? {} : { cache: credential.cache }
-  };
+  return void 0;
 }
-function formatSourceSummary(summary) {
-  switch (summary.kind) {
-    case "env":
-      return `env ${summary.variable}`;
-    case "file":
-      return `file ${summary.path}`;
-    case "command":
-      return `command ${summary.program}`;
-    case "op":
-      return `op ${summary.reference}`;
-    case "keychain":
-      return `keychain ${summary.service}${summary.account === void 0 ? "" : ` (account ${summary.account})`}`;
-    case "literal":
-      return "literal (non-secret placeholder)";
-    default:
-      return summary;
+function verifyHeadroomSocket(socketPath, ports) {
+  const unsupported = platformRefusal(ports.platform);
+  if (unsupported !== void 0) {
+    return { refused: unsupported };
   }
+  const uid = ports.currentUid();
+  const directory = import_node_path18.default.dirname(socketPath);
+  const refusal = ownerOnlyRefusal("socket directory", directory, ports.lstat(directory), "dir", uid) ?? ownerOnlyRefusal("socket", socketPath, ports.lstat(socketPath), "socket", uid);
+  return refusal === void 0 ? { socketPath } : { refused: refusal };
 }
-function describeSource(source) {
-  return formatSourceSummary(summariseSource(source));
-}
-function formatCredentialSummary(summary) {
-  const cache = summary.cache === void 0 ? "" : `, cached ${summary.cache.ttl === void 0 ? "with no expiry" : `for ${summary.cache.ttl}`}${summary.cache.store === void 0 ? "" : ` in the ${summary.cache.store} store`}`;
-  return `${summary.target} from ${summary.sources.map(formatSourceSummary).join(", then ")}${cache}`;
-}
-function describeCredential(credential) {
-  return formatCredentialSummary(summariseCredential(credential));
-}
-function trySource(source, params) {
-  const none = (reason, warn = false) => ({ ok: false, reason, warn });
-  if ("env" in source) {
-    const value = params.env[source.env];
-    return value === void 0 || value === "" ? none("is unset or empty") : { ok: true, token: value };
-  }
-  if ("literal" in source) {
-    return { ok: true, token: source.literal };
-  }
-  if ("file" in source) {
-    const read = params.port.readSecretFile(source.file);
-    if (!read.found) {
-      return none("does not exist");
-    }
-    if (read.mode !== void 0 && (read.mode & GROUP_OTHER_PERMISSION_BITS) !== 0) {
-      return none(
-        `is readable or writable by group or others (mode ${(read.mode & PERMISSION_BITS).toString(OCTAL_RADIX)}); run \`chmod 600 ${source.file}\``,
-        true
-      );
-    }
-    const token2 = read.content.trim();
-    return token2 === "" ? none("is empty") : { ok: true, token: token2 };
-  }
-  const argv = commandArgv(source);
-  const interactive = isInteractiveSource(source, params.env);
-  if (interactive && !params.port.personPresent()) {
-    return none("needs a person to approve it, but there is no terminal or desktop session");
+function prepareHeadroomSocket(fs12, ports, paths, supervisorPid) {
+  const unsupported = platformRefusal(ports.platform);
+  if (unsupported !== void 0) {
+    return { refused: unsupported };
   }
-  const timeoutMs = source.timeoutMs ?? (interactive ? CREDENTIAL_INTERACTIVE_TIMEOUT_MS : CREDENTIAL_COMMAND_TIMEOUT_MS);
-  const result = params.port.runCommand(argv, { timeoutMs, interactive });
-  if (result.timedOut) {
-    return none(`timed out after ${String(timeoutMs)}ms`);
+  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 (result.status !== 0) {
-    const stderr = result.stderr.trim();
-    const outcome = result.status === null ? "could not be run or was killed by a signal" : `exited with status ${String(result.status)}`;
-    return none(`${outcome}${stderr === "" ? "" : `: ${stderr}`}`);
+  if (ports.lstat(paths.headroomSocketDir)?.kind === "symlink") {
+    return { refused: `the headroom socket directory ${paths.headroomSocketDir} is a symlink; it must be the real directory` };
   }
-  const token = result.stdout.trim();
-  return token === "" ? none("printed no token") : { ok: true, token };
-}
-function warmCommandFor(subject) {
-  const [kind, name] = subject.split(" ");
-  return kind === "provider" ? `agent-shim credential warm --provider ${name ?? ""}` : `agent-shim credential warm ${name ?? ""}`;
+  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 resolveCredential(params) {
-  const target = params.credential.target ?? "bearer";
-  const cacheBlock = params.credential.cache;
-  const cache = cacheBlock === void 0 ? void 0 : params.port.cache;
-  const store = cacheBlock === void 0 || cache === void 0 ? void 0 : effectiveStore(cacheBlock, cache.platform);
-  if (cacheBlock !== void 0 && cache !== void 0 && store !== void 0 && params.refresh !== true) {
-    const entry = cache.port.read(store, params.subject);
-    if (entry !== void 0 && isFresh(entry, cacheBlock, cache.now())) {
-      return { ok: true, credential: { target, token: entry.token, source: entry.source, warnings: [], cachedAt: entry.fetchedAt } };
+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_path18.default.join(paths.headroomSocketDir, name));
+    removed.push(name);
   }
-  const attempts = [];
-  const warnings = [];
-  for (const source of params.credential.sources) {
-    const outcome = trySource(source, params);
-    if (outcome.ok) {
-      if (cache !== void 0 && store !== void 0) {
-        cache.port.write(store, params.subject, { token: outcome.token, fetchedAt: cache.now(), source });
-      }
-      return { ok: true, credential: { target, token: outcome.token, source, warnings } };
-    }
-    const line = `${describeSource(source)} ${outcome.reason}`;
-    attempts.push(line);
-    if (outcome.warn) {
-      warnings.push(`agent-shim: ${params.subject}: skipped ${line}`);
-    }
+  return removed;
+}
+
+// src/headroom/source.ts
+var import_zod10 = require("zod");
+var GIT_SPEC_RE = /git\+[^@\s]+(?:@([^\s#]+))?/;
+var COMMIT_SHA_RE = /^[0-9a-f]{40}$/i;
+var DirectUrlSchema = import_zod10.z.object({ vcs_info: import_zod10.z.object({ commit_id: import_zod10.z.string() }) });
+function isMovingGitSource(spec) {
+  const match = GIT_SPEC_RE.exec(spec);
+  if (match === null) {
+    return false;
   }
-  const hint = cacheBlock === void 0 ? "" : `; fill the cache from a terminal with \`${warmCommandFor(params.subject)}\``;
-  return { ok: false, message: `agent-shim: ${params.subject} has no usable credential: ${attempts.join("; ")}${hint}` };
+  const ref = match[1];
+  return ref === void 0 || !COMMIT_SHA_RE.test(ref);
 }
-function credentialVariables(target, token) {
+function pinnedGitCommit(spec) {
+  const ref = GIT_SPEC_RE.exec(spec)?.[1];
+  return ref !== void 0 && COMMIT_SHA_RE.test(ref) ? ref.toLowerCase() : void 0;
+}
+
+// src/headroom/supervisor.ts
+function resolveSupervisorConfig(configured) {
   return {
-    ANTHROPIC_AUTH_TOKEN: target === "bearer" ? token : void 0,
-    ANTHROPIC_API_KEY: target === "apiKey" ? token : void 0,
-    CLAUDE_CODE_OAUTH_TOKEN: target === "oauthToken" ? token : void 0
+    source: configured.source ?? HEADROOM_DEFAULT_SOURCE,
+    idleShutdownMinutes: configured.idleShutdownMinutes ?? HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES,
+    settings: settingsOf(configured)
   };
 }
-
-// src/providersStore.ts
-var ProviderNotFoundError = class extends CliError {
-  constructor(name) {
-    super(`No provider named "${name}". Run \`agent-shim provider add ${name}\` first.`);
-    this.name = name;
-    this.name = "ProviderNotFoundError";
+var HEADROOM_BACKOFF_BASE_MS = 500;
+var HEADROOM_BACKOFF_CAP_MS = 3e4;
+var HEADROOM_START_RETRY_BUDGET = 5;
+var HEADROOM_READY_TIMEOUT_MS = 15e3;
+var HEADROOM_POLL_MS = 1e3;
+var MS_PER_MINUTE2 = 6e4;
+function backoffForAttempt(attempt) {
+  return Math.min(HEADROOM_BACKOFF_CAP_MS, HEADROOM_BACKOFF_BASE_MS * 2 ** (attempt - 1));
+}
+function versionSatisfies(version, source) {
+  if (version === void 0) {
+    return false;
   }
-  name;
-};
-var ProviderAlreadyExistsError = class extends CliError {
-  constructor(providerName) {
-    super(`A provider named "${providerName}" already exists.`);
-    this.providerName = providerName;
-    this.name = "ProviderAlreadyExistsError";
+  const specifier = /==|>=|<=|!=|>|<|~=/.exec(source);
+  if (specifier === null) {
+    return true;
   }
-  providerName;
-};
-var InvalidProviderNameError = class extends CliError {
-  constructor(attemptedName) {
-    super(
-      `"${attemptedName}" is not a valid provider name. Provider names must start with a letter or number and may then contain letters, numbers, dots, hyphens, underscores, and at signs.`
-    );
-    this.attemptedName = attemptedName;
-    this.name = "InvalidProviderNameError";
+  const installed = parseVersion(version);
+  const wanted = parseVersion(source.slice(specifier.index + specifier[0].length));
+  if (installed === void 0 || wanted === void 0) {
+    return true;
   }
-  attemptedName;
-};
-var PROVIDER_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._@-]*$/;
-function providerJsonPath(paths, name) {
-  return import_node_path20.default.join(paths.providersDir, `${name}.json`);
-}
-function providerExists(paths, name) {
-  return import_node_fs5.default.existsSync(providerJsonPath(paths, name));
-}
-var LEGACY_PROVIDER_FIELDS = ["tokenEnv", "tokenCommand", "authScheme"];
-var LEGACY_ENV_CREDENTIAL_KEYS = Object.values(CREDENTIAL_TARGET_VARS);
-var LEGACY_LITERAL_PLACEHOLDER = "<the value of env.ANTHROPIC_AUTH_TOKEN>";
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function legacyProviderConversion(raw) {
-  if (!isRecord4(raw) || "credential" in raw) {
-    return void 0;
+  const cmp = compareVersions2(installed, wanted);
+  switch (specifier[0]) {
+    case "==":
+      return cmp === 0;
+    case "!=":
+      return cmp !== 0;
+    case ">=":
+      return cmp >= 0;
+    case "<=":
+      return cmp <= 0;
+    case ">":
+      return cmp > 0;
+    case "<":
+      return cmp < 0;
+    case "~=":
+      return compareVersions2(installed.slice(0, Math.max(0, wanted.length - 1)), wanted.slice(0, Math.max(0, wanted.length - 1))) === 0 && cmp >= 0;
+    default:
+      return true;
   }
-  const env = isRecord4(raw.env) ? raw.env : void 0;
-  const legacyEnvKeys = env === void 0 ? [] : Object.keys(env).filter((key) => LEGACY_ENV_CREDENTIAL_KEYS.includes(key));
-  const fields = [...LEGACY_PROVIDER_FIELDS.filter((field) => field in raw), ...legacyEnvKeys.map((key) => `env.${key}`)];
-  if (fields.length === 0) {
+}
+function parseVersion(input) {
+  const match = /(\d+)(\.\d+)*/.exec(input);
+  if (match === null) {
     return void 0;
   }
-  const sources = [];
-  if (typeof raw.tokenEnv === "string") {
-    sources.push({ env: raw.tokenEnv });
-  }
-  if (Array.isArray(raw.tokenCommand)) {
-    sources.push({ command: raw.tokenCommand });
+  return match[0].split(".").map((part) => Number.parseInt(part, 10));
+}
+function compareVersions2(a, b) {
+  for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+    const left = a[index] ?? 0;
+    const right = b[index] ?? 0;
+    if (left !== right) {
+      return left - right;
+    }
   }
-  if (typeof env?.ANTHROPIC_AUTH_TOKEN === "string" && env.ANTHROPIC_AUTH_TOKEN !== "") {
-    sources.push({ literal: LEGACY_LITERAL_PLACEHOLDER });
+  return 0;
+}
+var HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
+async function runSupervisor(initialConfig, ports, options = {}) {
+  const { fs: fs12, paths } = ports;
+  let config = initialConfig;
+  const previousState = readHeadroomState(fs12, paths.headroomStateFile);
+  if (previousState?.supervisorPid !== void 0 && previousState.supervisorPid !== ports.ownPid && ports.isRunning(previousState.supervisorPid)) {
+    ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: supervisor ${String(previousState.supervisorPid)} already owns the daemon; exiting`);
+    return 0;
   }
-  const remainingEnv = env === void 0 ? void 0 : Object.fromEntries(Object.entries(env).filter(([key]) => !LEGACY_ENV_CREDENTIAL_KEYS.includes(key)));
-  const replacedKeys = [...LEGACY_PROVIDER_FIELDS, "env"];
-  const rest = Object.fromEntries(Object.entries(raw).filter(([key]) => !replacedKeys.includes(key)));
-  return {
-    fields,
-    replacement: {
-      ...rest,
-      credential: { sources, ...raw.authScheme === "apiKey" ? { target: "apiKey" } : {} },
-      ...remainingEnv === void 0 || Object.keys(remainingEnv).length === 0 ? {} : { env: remainingEnv }
+  let installedSource = previousState?.installedSource;
+  const ownsState = () => {
+    const owner = readHeadroomState(fs12, paths.headroomStateFile)?.supervisorPid;
+    return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
+  };
+  const writeOwnState = (state) => {
+    if (!ownsState()) {
+      return false;
     }
+    writeHeadroomState(fs12, paths.headroomStateFile, state);
+    return true;
   };
-}
-var LegacyProviderFileError = class extends CliError {
-  constructor(filePath, conversion) {
-    super(
-      `${filePath} uses ${conversion.fields.join(", ")}, which a credential block replaced. Rewrite it as:
-` + JSON.stringify(conversion.replacement, null, 2)
-    );
-    this.filePath = filePath;
-    this.conversion = conversion;
-    this.name = "LegacyProviderFileError";
+  const fail = (message) => {
+    if (writeOwnState({ lastError: message })) {
+      fs12.removeRecursive(paths.headroomLockFile);
+    }
+    ports.log(`agent-shim headroom supervisor: ${message}`);
+    return 1;
+  };
+  const ensureInstalled = () => {
+    const version2 = ports.headroomVersion();
+    const versionOk = version2 !== void 0 && versionSatisfies(version2, config.source);
+    const pinned = pinnedGitCommit(config.source);
+    const commitOk = pinned === void 0 || ports.installedCommit() === pinned;
+    if (versionOk && commitOk && (installedSource === void 0 || installedSource === config.source)) {
+      installedSource = config.source;
+      return true;
+    }
+    ports.log(`agent-shim headroom supervisor: installing headroom from ${config.source}`);
+    const result = ports.install(config.source);
+    if (!result.ok) {
+      return false;
+    }
+    installedSource = config.source;
+    return true;
+  };
+  const socket = prepareHeadroomSocket(fs12, ports.socketTrust, paths, ports.ownPid);
+  if (socket.refused !== void 0) {
+    return fail(socket.refused);
   }
-  filePath;
-  conversion;
-};
-function parseProviderFile(filePath, raw) {
-  const conversion = legacyProviderConversion(raw);
-  if (conversion !== void 0) {
-    throw new LegacyProviderFileError(filePath, conversion);
+  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 parsed = ProviderSchema.safeParse(raw);
-  if (!parsed.success) {
-    throw new ConfigValidationError(filePath, parsed.error.issues);
+  const version = ports.headroomVersion() ?? "unknown";
+  writeOwnState({ supervisorPid: ports.ownPid, version, installedSource });
+  ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${allowlistOf(ports).join(", ")}]`);
+  const orphanPid = previousState?.headroomPid;
+  if (orphanPid !== void 0 && ports.isRunning(orphanPid)) {
+    ports.log(`agent-shim headroom supervisor: stopping daemon pid ${String(orphanPid)} left behind by the previous supervisor`);
+    ports.stopProcess(orphanPid);
+  }
+  let headroomPid;
+  let runningHash;
+  let runningSettingsHash;
+  let consecutiveFailures = 0;
+  let idleSince;
+  let superseded = false;
+  let ticks = 0;
+  for (; ; ) {
+    if (options.tickLimit !== void 0 && ticks >= options.tickLimit) {
+      return HEADROOM_SUPERVISOR_STILL_RUNNING;
+    }
+    ticks += 1;
+    config = ports.readConfig();
+    const settingsHash = hashSettings(config.settings);
+    const allowlist = allowlistOf(ports);
+    const allowlistHash = hashAllowlist(allowlist);
+    pruneDeadSessions(fs12, paths.headroomSessionsDir, ports.isRunning);
+    const ownsNow = ownsState();
+    if (!ownsNow && !superseded) {
+      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);
+    if (headroomPid === void 0 || crashed) {
+      if (crashed) {
+        ports.log(`agent-shim headroom supervisor: headroom pid ${String(headroomPid)} died`);
+        headroomPid = void 0;
+        runningHash = void 0;
+        runningSettingsHash = void 0;
+        writeOwnState({
+          supervisorPid: ports.ownPid,
+          version,
+          installedSource
+        });
+      }
+      if (consecutiveFailures >= HEADROOM_START_RETRY_BUDGET) {
+        return fail(`headroom failed to become ready ${String(consecutiveFailures)} times in a row; giving up`);
+      }
+      if (installedSource !== config.source && !ensureInstalled()) {
+        return fail(`could not install headroom from ${config.source}: install failed (is uv installed and on PATH?)`);
+      }
+      const pid = ports.spawnHeadroom(socketPath, allowlist, config.settings);
+      const ready = await waitUntilReady(ports, socketPath);
+      if (ready) {
+        consecutiveFailures = 0;
+        headroomPid = pid;
+        runningHash = allowlistHash;
+        runningSettingsHash = settingsHash;
+        const recorded = writeOwnState({
+          supervisorPid: ports.ownPid,
+          headroomPid: pid,
+          socketPath,
+          version,
+          allowlistHash,
+          settingsHash,
+          installedSource: config.source
+        });
+        if (recorded) {
+          fs12.removeRecursive(paths.headroomLockFile);
+        }
+        idleSince = void 0;
+        ports.log(`agent-shim headroom supervisor: headroom pid ${String(pid)} ready on unix socket ${socketPath}`);
+      } else {
+        ports.stopProcess(pid);
+        consecutiveFailures += 1;
+        ports.log(
+          `agent-shim headroom supervisor: headroom did not become ready on unix socket ${socketPath} (attempt ${String(consecutiveFailures)} of ${String(HEADROOM_START_RETRY_BUDGET)})`
+        );
+        await ports.sleep(backoffForAttempt(consecutiveFailures));
+        continue;
+      }
+    } else {
+      if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config.source) {
+        if (sessionsForSupervisor(fs12, paths.headroomSessionsDir, ports.ownPid).length === 0) {
+          ports.log("agent-shim headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
+          ports.stopProcess(headroomPid);
+          headroomPid = void 0;
+          runningHash = void 0;
+          runningSettingsHash = void 0;
+          continue;
+        }
+      }
+      const sessions = sessionsForSupervisor(fs12, paths.headroomSessionsDir, ports.ownPid);
+      if (sessions.length === 0) {
+        idleSince ??= ports.now();
+        const idleMs = ports.now() - idleSince;
+        if (idleMs >= config.idleShutdownMinutes * MS_PER_MINUTE2) {
+          ports.log(
+            `agent-shim headroom supervisor: no sessions for ${String(config.idleShutdownMinutes)} minute(s); stopping headroom and exiting`
+          );
+          ports.stopProcess(headroomPid);
+          writeOwnState({ version });
+          return 0;
+        }
+      } else {
+        idleSince = void 0;
+      }
+    }
+    await ports.sleep(HEADROOM_POLL_MS);
   }
-  return parsed.data;
 }
-function readProvider(paths, name) {
-  const filePath = providerJsonPath(paths, name);
-  if (!import_node_fs5.default.existsSync(filePath)) {
-    return void 0;
+function currentHeadroomAllowlist(fs12, paths) {
+  const providers = readAllProviders(fs12, paths.providersDir).map((entry) => entry.provider);
+  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs12, paths.frontdoorStateFile))));
+}
+function allowlistOf(ports) {
+  return currentHeadroomAllowlist(ports.fs, ports.paths);
+}
+async function waitUntilReady(ports, socketPath) {
+  const deadline = ports.now() + HEADROOM_READY_TIMEOUT_MS;
+  for (; ; ) {
+    if (await ports.ready(socketPath)) {
+      return true;
+    }
+    if (ports.now() >= deadline) {
+      return false;
+    }
+    await ports.sleep(HEADROOM_POLL_MS);
   }
-  const raw = JSON.parse(import_node_fs5.default.readFileSync(filePath, "utf8"));
-  return parseProviderFile(filePath, raw);
 }
-function loadProvider(providersDir, name, port) {
-  const filePath = import_node_path20.default.join(providersDir, `${name}.json`);
-  const raw = port.readConfigFile(filePath);
-  return raw === void 0 ? void 0 : parseProviderFile(filePath, raw);
+
+// src/realPorts.ts
+function isEnoent3(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
-function listProviders(paths) {
-  const names = listProviderNames(
-    (dir) => import_node_fs5.default.readdirSync(dir),
-    paths.providersDir
-  );
-  const result = [];
-  for (const name of names) {
-    let provider;
+var realFsPort = {
+  readFileUtf8(filePath) {
     try {
-      provider = readProvider(paths, name);
+      return import_node_fs3.default.readFileSync(filePath, "utf8");
     } catch (error) {
-      if (!(error instanceof ConfigValidationError || error instanceof LegacyProviderFileError)) {
-        throw error;
+      if (isEnoent3(error)) {
+        return void 0;
       }
-      console.error(`agent-shim: providers/${name}.json is invalid and was skipped: ${error.message}`);
-      continue;
+      throw error;
     }
-    if (provider !== void 0) {
-      result.push({ name, provider });
+  },
+  readConfigFile: cosmiconfigReader(),
+  readdir(dirPath) {
+    try {
+      return import_node_fs3.default.readdirSync(dirPath);
+    } catch (error) {
+      if (isEnoent3(error)) {
+        return [];
+      }
+      throw error;
     }
   }
-  return result;
+};
+function isErrorWithCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
-function listProviderNames(readdir, providersDir) {
-  let entries;
-  try {
-    entries = readdir(providersDir);
-  } catch {
-    return [];
+var OWNER_ONLY_DIR_MODE = 448;
+var OWNER_ONLY_FILE_MODE = 384;
+var PERMISSION_BITS = 511;
+var realFarmFs = {
+  lstat(filePath) {
+    let stat;
+    try {
+      stat = import_node_fs3.default.lstatSync(filePath);
+    } catch (error) {
+      if (isEnoent3(error)) {
+        return void 0;
+      }
+      throw error;
+    }
+    const kind = stat.isSymbolicLink() ? "symlink" : stat.isDirectory() ? "dir" : "file";
+    return { kind, mtimeMs: stat.mtimeMs, sizeBytes: stat.size };
+  },
+  readdir(dirPath) {
+    try {
+      return import_node_fs3.default.readdirSync(dirPath);
+    } catch (error) {
+      if (isEnoent3(error) || isErrorWithCode(error, "ENOTDIR")) {
+        return [];
+      }
+      throw error;
+    }
+  },
+  mkdirp(dirPath) {
+    import_node_fs3.default.mkdirSync(dirPath, { recursive: true });
+  },
+  symlink(target, linkPath) {
+    import_node_fs3.default.symlinkSync(target, linkPath);
+  },
+  rename(from, to) {
+    import_node_fs3.default.renameSync(from, to);
+  },
+  removeRecursive(targetPath) {
+    import_node_fs3.default.rmSync(targetPath, { recursive: true, force: true });
+  },
+  copyRecursive(from, to) {
+    import_node_fs3.default.cpSync(from, to, { recursive: true, force: true, verbatimSymlinks: true });
+  },
+  readFileUtf8(filePath) {
+    try {
+      return import_node_fs3.default.readFileSync(filePath, "utf8");
+    } catch (error) {
+      if (isEnoent3(error)) {
+        return void 0;
+      }
+      throw error;
+    }
+  },
+  writeFileUtf8(filePath, contents) {
+    import_node_fs3.default.writeFileSync(filePath, contents, "utf8");
+  },
+  mkdirPrivate(dirPath) {
+    import_node_fs3.default.mkdirSync(dirPath, { recursive: true, mode: OWNER_ONLY_DIR_MODE });
+    import_node_fs3.default.chmodSync(dirPath, OWNER_ONLY_DIR_MODE);
+  },
+  writeFilePrivate(filePath, contents) {
+    const temp = `${filePath}.${String(process.pid)}.tmp`;
+    import_node_fs3.default.writeFileSync(temp, contents, { encoding: "utf8", mode: OWNER_ONLY_FILE_MODE });
+    import_node_fs3.default.chmodSync(temp, OWNER_ONLY_FILE_MODE);
+    import_node_fs3.default.renameSync(temp, filePath);
+  },
+  appendFilePrivate(filePath, contents) {
+    const descriptor = import_node_fs3.default.openSync(filePath, "a", OWNER_ONLY_FILE_MODE);
+    try {
+      if ((import_node_fs3.default.fstatSync(descriptor).mode & PERMISSION_BITS) !== OWNER_ONLY_FILE_MODE) {
+        import_node_fs3.default.fchmodSync(descriptor, OWNER_ONLY_FILE_MODE);
+      }
+      const bytes = Buffer.from(contents, "utf8");
+      let written = 0;
+      while (written < bytes.length) {
+        written += import_node_fs3.default.writeSync(descriptor, bytes, written, bytes.length - written);
+      }
+    } finally {
+      import_node_fs3.default.closeSync(descriptor);
+    }
+  },
+  writeFileExclusive(filePath, contents) {
+    try {
+      import_node_fs3.default.writeFileSync(filePath, contents, { encoding: "utf8", flag: "wx" });
+      return true;
+    } catch (error) {
+      if (isErrorWithCode(error, "EEXIST")) {
+        return false;
+      }
+      throw error;
+    }
+  },
+  hashFile(filePath) {
+    try {
+      return (0, import_node_crypto8.createHash)("sha256").update(import_node_fs3.default.readFileSync(filePath)).digest("hex");
+    } catch (error) {
+      if (isEnoent3(error) || isErrorWithCode(error, "EISDIR")) {
+        return void 0;
+      }
+      throw error;
+    }
   }
-  return entries.filter((entry) => entry.endsWith(".json")).map((entry) => entry.slice(0, -".json".length)).sort();
+};
+var INT32_BYTE_LENGTH = 4;
+function realSleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(INT32_BYTE_LENGTH)), 0, 0, ms);
 }
-function describeProviderEndpoint(provider) {
-  return isCodexProvider(provider) ? "codex translation daemon" : provider.baseUrl;
+function realIsProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return isErrorWithCode(error, "EPERM");
+  }
 }
-var ProviderKindMismatchError = class extends UsageError {
-  constructor(message) {
-    super(message);
-    this.name = "ProviderKindMismatchError";
+function realIsProcessZombie(pid) {
+  const result = (0, import_node_child_process.spawnSync)("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf8" });
+  return result.status === 0 && result.stdout.trim().startsWith("Z");
+}
+function realIsProcessRunning(pid) {
+  return realIsProcessAlive(pid) && !realIsProcessZombie(pid);
+}
+var realRunPort = {
+  run(command, args) {
+    const result = (0, import_node_child_process.spawnSync)(command, [...args], { encoding: "utf8" });
+    return { status: result.status, stdout: result.stdout, stderr: result.stderr };
   }
 };
-function isEmptyCodexConfig(config) {
-  return config === void 0 || config.defaultModel === void 0 && config.effort === void 0 && config.login === void 0 && (config.models === void 0 || Object.keys(config.models).length === 0);
+function expandHome2(filePath) {
+  return filePath.startsWith("~/") ? import_node_path19.default.join(import_node_os2.default.homedir(), filePath.slice(1)) : filePath;
 }
-function addProvider(paths, name, input) {
-  if (providerExists(paths, name)) {
-    throw new ProviderAlreadyExistsError(name);
-  }
-  if (!PROVIDER_NAME_RE.test(name)) {
-    throw new InvalidProviderNameError(name);
-  }
-  const kind = input.kind ?? "http";
-  if (kind === "codex" && input.baseUrl !== void 0) {
-    throw new ProviderKindMismatchError("A codex provider has no base URL: the launcher points its sessions at the front-door daemon. Drop --base-url.");
-  }
-  if (kind === "http" && input.baseUrl === void 0) {
-    throw new ProviderKindMismatchError("An http provider needs --base-url.");
-  }
-  if (kind === "http" && !isEmptyCodexConfig(input.codex)) {
-    throw new ProviderKindMismatchError("Codex settings apply only to a codex provider (--kind codex).");
+var MACOS_GUI_SESSION_MANAGER = "Aqua";
+function hasDesktopSession() {
+  if (process.platform === "darwin") {
+    const result = (0, import_node_child_process.spawnSync)("launchctl", ["managername"], { encoding: "utf8" });
+    return result.status === 0 && result.stdout.trim() === MACOS_GUI_SESSION_MANAGER;
   }
-  const shared = {
-    displayName: input.displayName,
-    credential: { sources: input.sources, ...input.target === void 0 ? {} : { target: input.target } },
-    ...input.env === void 0 || Object.keys(input.env).length === 0 ? {} : { env: input.env }
-  };
-  const parsed = ProviderSchema.safeParse(
-    kind === "codex" ? { kind, ...shared, ...isEmptyCodexConfig(input.codex) ? {} : { codex: input.codex } } : { ...shared, baseUrl: input.baseUrl }
-  );
-  if (!parsed.success) {
-    throw new ConfigValidationError(providerJsonPath(paths, name), parsed.error.issues);
+  if (process.platform === "win32") {
+    return false;
   }
-  writeJsonAtomic(providerJsonPath(paths, name), parsed.data);
-  return parsed.data;
+  return (process.env.DISPLAY ?? "") !== "" || (process.env.WAYLAND_DISPLAY ?? "") !== "";
 }
-function updateProvider(paths, name, input) {
-  const existing = readProvider(paths, name);
-  if (existing === void 0) {
-    throw new ProviderNotFoundError(name);
-  }
-  const unset = new Set(input.unsetEnv);
-  const env = Object.fromEntries(Object.entries({ ...existing.env, ...input.env }).filter(([key]) => !unset.has(key)));
-  const target = input.target ?? existing.credential.target;
-  const cache = input.cache === void 0 ? existing.credential.cache : input.cache === false ? void 0 : input.cache;
-  if (isCodexProvider(existing) && input.baseUrl !== void 0) {
-    throw new ProviderKindMismatchError(`Provider "${name}" is a codex provider, which has no base URL.`);
-  }
-  if (!isCodexProvider(existing) && !isEmptyCodexConfig(input.codex)) {
-    throw new ProviderKindMismatchError(`Provider "${name}" is an http provider; codex settings apply only to a codex provider.`);
+var realCredentialPort = {
+  readSecretFile(filePath) {
+    const resolved = expandHome2(filePath);
+    let content;
+    let stat;
+    try {
+      stat = import_node_fs3.default.statSync(resolved);
+      content = import_node_fs3.default.readFileSync(resolved, "utf8");
+    } catch (error) {
+      if (isEnoent3(error)) {
+        return { found: false };
+      }
+      throw error;
+    }
+    return { found: true, content, mode: process.platform === "win32" ? void 0 : stat.mode };
+  },
+  runCommand(argv, options) {
+    const [command, ...args] = argv;
+    const result = (0, import_node_child_process.spawnSync)(command, args, {
+      encoding: "utf8",
+      timeout: options.timeoutMs,
+      stdio: options.interactive ? ["inherit", "pipe", "inherit"] : ["ignore", "pipe", "pipe"]
+    });
+    if (result.error !== void 0) {
+      const timedOut = isErrorWithCode(result.error, "ETIMEDOUT");
+      return { status: result.status, stdout: "", stderr: timedOut ? "" : result.error.message, timedOut };
+    }
+    return { status: result.status, stdout: result.stdout, stderr: options.interactive ? "" : result.stderr, timedOut: false };
+  },
+  personPresent: () => process.stdin.isTTY || hasDesktopSession()
+};
+function resolveGitBranch(run, cwd) {
+  const result = run.run("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"]);
+  if (result.status !== 0) {
+    return {};
   }
-  const shared = {
-    ...input.displayName === void 0 ? {} : { displayName: input.displayName },
-    credential: {
-      sources: input.sources ?? existing.credential.sources,
-      ...target === void 0 ? {} : { target },
-      ...cache === void 0 ? {} : { cache }
-    },
-    env: Object.keys(env).length === 0 ? void 0 : env
-  };
-  let candidate;
-  if (isCodexProvider(existing)) {
-    const codex = {
-      ...existing.codex,
-      ...input.codex,
-      ...existing.codex?.models === void 0 && input.codex?.models === void 0 ? {} : { models: { ...existing.codex?.models, ...input.codex?.models } }
-    };
-    candidate = { ...existing, ...shared, codex: isEmptyCodexConfig(codex) ? void 0 : codex };
-  } else {
-    candidate = { ...existing, ...shared, ...input.baseUrl === void 0 ? {} : { baseUrl: input.baseUrl } };
+  const name = result.stdout.trim();
+  if (name === "") {
+    return {};
   }
-  const parsed = ProviderSchema.safeParse(candidate);
-  if (!parsed.success) {
-    throw new ConfigValidationError(providerJsonPath(paths, name), parsed.error.issues);
+  if (name === "HEAD") {
+    return { branchDetached: true };
   }
-  writeJsonAtomic(providerJsonPath(paths, name), parsed.data);
-  return parsed.data;
+  return { branch: name, branchDetached: false };
 }
-function removeProvider(paths, name) {
-  if (!providerExists(paths, name)) {
-    throw new ProviderNotFoundError(name);
+function resolveGitRoot(run, cwd) {
+  const result = run.run("git", ["-C", cwd, "rev-parse", "--show-toplevel"]);
+  if (result.status !== 0) {
+    return void 0;
   }
-  import_node_fs5.default.rmSync(providerJsonPath(paths, name));
+  const root = result.stdout.trim();
+  return root === "" ? void 0 : root;
 }
-function cascadeProviderName(cascade) {
-  let name;
-  for (const layer of assembleCascade(cascade).layers) {
-    if (layer.launch?.provider !== void 0) {
-      name = layer.launch.provider;
+function detachedDaemonSpawnOptions(logFd, env) {
+  return { detached: true, stdio: ["ignore", logFd, logFd], env };
+}
+function spawnDaemonThrough(executable) {
+  return (paths, subcommand, logPath) => spawnDetachedDaemon({ command: executable, args: [subcommand] }, paths, subcommand, logPath);
+}
+function spawnDaemonThroughScript(script) {
+  return (paths, subcommand, logPath) => spawnDetachedDaemon({ command: process.execPath, args: [script, subcommand] }, paths, subcommand, logPath);
+}
+function spawnDetachedDaemon(invocation, paths, subcommand, logPath) {
+  import_node_fs3.default.mkdirSync(import_node_path19.default.dirname(logPath), { recursive: true });
+  const logFd = import_node_fs3.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 }));
+    child.unref();
+    if (child.pid === void 0) {
+      throw new Error(`spawning ${subcommand} returned no pid`);
     }
+    return child.pid;
+  } finally {
+    import_node_fs3.default.closeSync(logFd);
   }
-  return name;
 }
-function resolveProvider(params) {
-  const cliName = params.cliProvider !== void 0 && params.cliProvider !== "" ? params.cliProvider : void 0;
-  const name = cliName ?? (params.cascade === void 0 ? void 0 : cascadeProviderName(params.cascade));
-  if (name === void 0) {
-    return void 0;
-  }
-  const definition = loadProvider(params.paths.providersDir, name, params.port);
-  if (definition === void 0) {
-    const known = listProviderNames(params.port.readdir, params.paths.providersDir);
-    return {
-      ok: false,
-      status: 1,
-      message: `agent-shim: no provider named "${name}". ` + (known.length > 0 ? `Known providers: ${known.join(", ")}.` : "No providers are defined yet; run `agent-shim provider add`.")
-    };
-  }
-  if (params.credentials === void 0) {
-    return { ok: false, status: 1, message: `agent-shim: provider ${name} needs its credential resolved, but this launcher has no credential port wired` };
-  }
-  const resolution = resolveCredential({ credential: definition.credential, env: params.env, port: params.credentials, subject: `provider ${name}` });
-  if (!resolution.ok) {
-    return { ok: false, status: CREDENTIAL_UNAVAILABLE_EXIT, message: resolution.message };
-  }
-  return { ok: true, provider: { name, definition, credential: resolution.credential }, warnings: resolution.credential.warnings };
+function spawnHeadroomSupervisor(paths, spawnDaemon) {
+  return spawnDaemon(paths, "__headroom-supervisor", paths.headroomLogPath);
 }
-
-// src/realPorts.ts
-var import_node_child_process2 = 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_path22 = __toESM(require("node:path"), 1);
-var import_node_sea = require("node:sea");
-
-// src/headroom/ensure.ts
-var HEADROOM_START_TIMEOUT_MS = 12e4;
-var HEADROOM_LAUNCHER_POLL_MS = 250;
-var HeadroomStartError = class extends CliError {
-  constructor(message) {
-    super(message);
-    this.name = "HeadroomStartError";
-  }
-};
-function ensureHeadroom(params) {
-  const { paths, ports } = params;
-  const deadline = ports.now() + HEADROOM_START_TIMEOUT_MS;
-  let spawnedSupervisor = false;
-  let awaitingAllowlist = false;
-  for (; ; ) {
-    const state = readHeadroomState(ports.fs, paths.headroomStateFile);
-    if (state?.supervisorPid !== void 0 && ports.isRunning(state.supervisorPid)) {
-      const daemonUp = state.socketPath !== void 0 && state.headroomPid !== void 0 && ports.isRunning(state.headroomPid);
-      if (daemonUp && state.socketPath !== void 0) {
-        const required = params.requiredAllowlistHash?.();
-        if (required === void 0 || state.allowlistHash === required) {
-          writeSession(ports.fs, paths.headroomSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), supervisorPid: state.supervisorPid });
-          return { socketPath: state.socketPath };
-        }
-        const holders = sessionsForSupervisor(ports.fs, paths.headroomSessionsDir, state.supervisorPid).filter((session) => ports.isRunning(session.pid));
-        if (holders.length > 0) {
-          throw new HeadroomStartError(
-            `the running headroom daemon was started before this launch's front door address and would refuse every request this launch sends through it. It restarts once the launches using it end (pid ${holders.map((session) => String(session.pid)).join(", ")}); end them and launch again, or launch with --no-headroom.`
-          );
-        }
-        awaitingAllowlist = true;
-      }
-      if (state.lastError !== void 0) {
-        throw new HeadroomStartError(
-          `the headroom daemon reported a fatal error and is not serving: ${state.lastError} (daemon log: ${paths.headroomLogPath})`
-        );
-      }
-    } else if (!spawnedSupervisor) {
-      ports.fs.mkdirp(paths.headroomDir);
-      const created = ports.fs.writeFileExclusive(
-        paths.headroomLockFile,
-        `${JSON.stringify({ pid: params.launcherPid, at: ports.now() })}
-`
-      );
-      if (created) {
-        ports.spawnSupervisor(paths);
-        spawnedSupervisor = true;
-      } else {
-        const lock = readStartLock(ports.fs, paths.headroomLockFile);
-        if (lock === void 0 || !ports.isRunning(lock.pid)) {
-          ports.fs.removeRecursive(paths.headroomLockFile);
-          continue;
-        }
-      }
+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}`);
     }
-    if (ports.now() >= deadline) {
-      const lastError = state?.lastError;
-      throw new HeadroomStartError(
-        `the headroom daemon did not become ready within ${String(HEADROOM_START_TIMEOUT_MS)}ms` + (lastError === void 0 ? "" : ` (last error: ${lastError})`) + (awaitingAllowlist ? " (the running daemon's allowlist does not admit this launch's front door, and it did not restart)" : "") + `. Daemon log: ${paths.headroomLogPath}`
-      );
+    return process.getuid();
+  },
+  lstat: (target) => {
+    let stat;
+    try {
+      stat = import_node_fs3.default.lstatSync(target);
+    } catch (error) {
+      if (isEnoent3(error)) {
+        return void 0;
+      }
+      throw error;
     }
-    ports.sleep(HEADROOM_LAUNCHER_POLL_MS);
+    const kind = stat.isSymbolicLink() ? "symlink" : stat.isDirectory() ? "dir" : stat.isSocket() ? "socket" : "other";
+    return { kind, uid: stat.uid, mode: stat.mode & SOCKET_PERMISSION_BITS };
   }
-}
-
-// src/headroom/settings.ts
-var import_node_crypto7 = require("node:crypto");
-function settingsOf(config) {
+};
+function realHeadroomPort(paths, options) {
   return {
-    ...config.mode === void 0 ? {} : { mode: config.mode },
-    ...config.targetRatio === void 0 ? {} : { targetRatio: config.targetRatio },
-    ...config.ccr === void 0 ? {} : { ccr: config.ccr },
-    ...config.rolloutChannel === void 0 ? {} : { rolloutChannel: config.rolloutChannel },
-    ...config.interceptToolResults === void 0 ? {} : { interceptToolResults: config.interceptToolResults },
-    ...config.readMaturation === void 0 ? {} : { readMaturation: config.readMaturation }
+    ensure: ({ routesProvider }) => {
+      const up = ensureHeadroom({
+        paths,
+        launcherPid: process.pid,
+        ...routesProvider ? { requiredAllowlistHash: () => hashAllowlist(currentHeadroomAllowlist(realFarmFs, paths)) } : {},
+        ports: {
+          fs: realFarmFs,
+          // Zombie-aware on purpose: a supervisor that died while still a child of this launcher sits unreaped until the launcher itself exits, and a defunct supervisor answering signal 0 as alive would stretch every launch to the full start timeout.
+          isRunning: realIsProcessRunning,
+          now: () => Date.now(),
+          sleep: realSleepSync,
+          spawnSupervisor: (layout) => spawnHeadroomSupervisor(layout, options.spawnDaemon)
+        }
+      });
+      return {
+        socketPath: up.socketPath,
+        projectId: resolveGitRoot(realRunPort, options.cwd) ?? options.cwd
+      };
+    },
+    release: () => {
+      removeSession(realFarmFs, paths.headroomSessionsDir, process.pid);
+    }
   };
 }
-function settingsArgs(settings) {
-  return [
-    ...settings.mode === void 0 ? [] : ["--mode", settings.mode],
-    ...settings.targetRatio === void 0 ? [] : ["--target-ratio", String(settings.targetRatio)],
-    ...settings.ccr === "lossless" ? ["--lossless"] : [],
-    ...settings.ccr === "none" ? ["--no-ccr"] : [],
-    ...settings.interceptToolResults === true ? ["--intercept-tool-results"] : [],
-    ...settings.readMaturation === true ? ["--read-maturation"] : []
-  ];
+var realProcPort = {
+  env: process.env,
+  argv: process.argv.slice(2),
+  exit: (code) => process.exit(code)
+};
+var EXECUTE_BITS_MASK = 73;
+function listVersionsDir(dir) {
+  let entries;
+  try {
+    entries = import_node_fs3.default.readdirSync(dir, { withFileTypes: true });
+  } catch (error) {
+    if (isEnoent3(error)) {
+      return [];
+    }
+    throw error;
+  }
+  return entries.filter((entry) => entry.isFile()).map((entry) => {
+    const fullPath = import_node_path19.default.join(dir, entry.name);
+    const stat = import_node_fs3.default.statSync(fullPath);
+    return {
+      name: entry.name,
+      isFile: true,
+      isExecutable: (stat.mode & EXECUTE_BITS_MASK) !== 0,
+      sizeBytes: stat.size
+    };
+  });
 }
-function settingsEnv(settings) {
-  return settings.rolloutChannel === void 0 ? {} : { HEADROOM_ROLLOUT_CHANNEL: settings.rolloutChannel };
+var WINDOWS_DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.PS1";
+function windowsPathExtensions(pathext) {
+  return (pathext ?? WINDOWS_DEFAULT_PATHEXT).split(";").map((ext) => ext.trim()).filter((ext) => ext.length > 0);
 }
-function hashSettings(settings) {
-  return (0, import_node_crypto7.createHash)("sha256").update(JSON.stringify([...settingsArgs(settings), JSON.stringify(settingsEnv(settings))])).digest("hex");
+function resolveExecutableCandidate(dir, name, env) {
+  const candidate = import_node_path19.default.join(dir, name);
+  if (env.platform === "win32") {
+    const extensions = windowsPathExtensions(env.pathext);
+    const alreadyHasRecognisedExtension = extensions.some((ext) => candidate.toLowerCase().endsWith(ext.toLowerCase()));
+    if (alreadyHasRecognisedExtension) {
+      return env.statFileMode(candidate) !== void 0 ? candidate : void 0;
+    }
+    for (const ext of extensions) {
+      const withExt = candidate + ext;
+      if (env.statFileMode(withExt) !== void 0) {
+        return withExt;
+      }
+    }
+    return void 0;
+  }
+  const mode = env.statFileMode(candidate);
+  return mode !== void 0 && (mode & EXECUTE_BITS_MASK) !== 0 ? candidate : void 0;
 }
-
-// src/headroom/socket.ts
-var import_node_path21 = __toESM(require("node:path"), 1);
-var GROUP_OR_OTHER_BITS = 63;
-var OCTAL_RADIX2 = 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_path21.default.join(paths.headroomSocketDir, `${String(supervisorPid)}${HEADROOM_SOCKET_SUFFIX}`);
+function realStatFileMode(candidate) {
+  try {
+    const stat = import_node_fs3.default.statSync(candidate);
+    return stat.isFile() ? stat.mode : void 0;
+  } catch (error) {
+    if (isEnoent3(error)) {
+      return void 0;
+    }
+    throw error;
+  }
 }
-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 findExecutableInDir(dir, name) {
+  return resolveExecutableCandidate(dir, name, {
+    platform: process.platform,
+    pathext: process.env.PATHEXT,
+    statFileMode: realStatFileMode
+  });
 }
-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_RADIX2).padStart(MODE_DIGITS, "0")}, which lets other users reach it; it must be accessible to its owner only`;
+function searchPathForExecutable(pathDirs, name, findExecutable) {
+  for (const dir of pathDirs) {
+    const found = findExecutable(dir, name);
+    if (found !== void 0) {
+      return found;
+    }
   }
   return void 0;
 }
-function verifyHeadroomSocket(socketPath, ports) {
-  const unsupported = platformRefusal(ports.platform);
-  if (unsupported !== void 0) {
-    return { refused: unsupported };
+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 uid = ports.currentUid();
-  const directory = import_node_path21.default.dirname(socketPath);
-  const refusal = ownerOnlyRefusal("socket directory", directory, ports.lstat(directory), "dir", uid) ?? ownerOnlyRefusal("socket", socketPath, ports.lstat(socketPath), "socket", uid);
-  return refusal === void 0 ? { socketPath } : { refused: refusal };
-}
-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` };
+  const candidate = env.argv1 === void 0 ? env.execPath : import_node_path19.default.resolve(env.cwd, env.argv1);
+  const candidateDir = import_node_path19.default.dirname(candidate);
+  const candidateDirOnPath = env.pathDirs.some((dir) => import_node_path19.default.resolve(dir) === candidateDir);
+  if (candidateDirOnPath) {
+    return candidate;
   }
-  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 };
+  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path19.default.basename(candidate), env.findExecutableInDir);
+  return viaPath ?? candidate;
 }
-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;
+function realOwnExecutablePath() {
+  return resolveOwnExecutablePath({
+    argv1: process.argv[1],
+    execPath: process.execPath,
+    cwd: process.cwd(),
+    pathDirs: (process.env.PATH ?? "").split(import_node_path19.default.delimiter).filter((dir) => dir !== ""),
+    findExecutableInDir
+  });
+}
+function resolveContentSourcePath(env) {
+  return env.isSea ? env.execPath : env.argv1 ?? env.execPath;
+}
+function realContentSourcePath() {
+  return resolveContentSourcePath({ isSea: (0, import_node_sea.isSea)(), execPath: process.execPath, argv1: process.argv[1] });
+}
+function realResolveClaudeBinary(isOwnBinary) {
+  return (request4) => discoverClaudeBinary({
+    listVersionsDir,
+    pathDirs: (process.env.PATH ?? "").split(import_node_path19.default.delimiter).filter((dir) => dir !== ""),
+    findExecutableInDir,
+    isOwnBinary,
+    ...request4?.version === void 0 ? {} : { version: request4.version }
+  });
+}
+function realInstalledClaudeVersions() {
+  return installedVersions(listVersionsDir(defaultVersionsDir()));
+}
+
+// src/launchSelection.ts
+function selectLaunch(params, loaded) {
+  const { paths, cwd } = params;
+  const selections = readDirectorySelections(loaded);
+  const decidedIdentity = decideIdentity({
+    env: params.env,
+    argv0Identity: params.identity,
+    directoryPinnedIdentity: selections.identity,
+    readActiveIdentityFile: () => {
+      const raw = realFsPort.readFileUtf8(paths.activeIdentityFile);
+      if (raw === void 0) {
+        return void 0;
+      }
+      const trimmed = raw.trim();
+      return trimmed === "" ? void 0 : trimmed;
     }
-    fs12.removeRecursive(import_node_path21.default.join(paths.headroomSocketDir, name));
-    removed.push(name);
+  });
+  let poolPick;
+  if (decidedIdentity.pool !== void 0) {
+    const pools = loaded.globalConfig?.pools ?? {};
+    if (pools[decidedIdentity.pool] === void 0) {
+      throw new PoolNotFoundError(decidedIdentity.pool);
+    }
+    poolPick = collectPoolPick({ paths, fs: realFsPort, usageFs: realFarmFs, poolName: decidedIdentity.pool, pools, directory: cwd, nowMs: Date.now() });
   }
-  return removed;
+  const identity = poolPick?.pick === void 0 ? decidedIdentity : { ...decidedIdentity, name: poolPick.pick };
+  const loadedIdentity = identity.name === void 0 ? void 0 : loadIdentity(paths.identitiesDir, identity.name, realFsPort);
+  const configProfile = decideConfigProfile({
+    env: params.env,
+    ...params.configProfile === void 0 ? {} : { cliFlagConfigProfile: params.configProfile },
+    directoryRuleConfigProfile: selections.configProfile,
+    identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
+    globalDefaultConfigProfile: loaded.globalConfig?.defaultConfigProfile
+  });
+  return {
+    selection: { identity, ...poolPick === void 0 ? {} : { poolPick }, configProfile },
+    ...loadedIdentity === void 0 ? {} : { identityConfig: loadedIdentity.config }
+  };
+}
+function resolveLaunchSelection(params) {
+  const loaded = loadCascadeInput({ paths: params.paths, home: import_node_os3.default.homedir(), cwd: params.cwd, read: cosmiconfigReader() });
+  return selectLaunch(params, loaded).selection;
 }
 
-// src/headroom/source.ts
-var import_zod11 = require("zod");
-var GIT_SPEC_RE = /git\+[^@\s]+(?:@([^\s#]+))?/;
-var COMMIT_SHA_RE = /^[0-9a-f]{40}$/i;
-var DirectUrlSchema = import_zod11.z.object({ vcs_info: import_zod11.z.object({ commit_id: import_zod11.z.string() }) });
-function isMovingGitSource(spec) {
-  const match = GIT_SPEC_RE.exec(spec);
-  if (match === null) {
-    return false;
+// src/paths.ts
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_os4 = __toESM(require("node:os"), 1);
+var import_node_path20 = __toESM(require("node:path"), 1);
+function resolveAgentShimHome(env = process.env, home = import_node_os4.default.homedir(), isDirectory = isExistingDirectory) {
+  const fromEnv = env.AGENT_SHIM_HOME;
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    return fromEnv;
   }
-  const ref = match[1];
-  return ref === void 0 || !COMMIT_SHA_RE.test(ref);
+  const current = import_node_path20.default.join(home, HOME_DIRNAME);
+  const legacy = import_node_path20.default.join(home, LEGACY_HOME_DIRNAME);
+  return !isDirectory(current) && isDirectory(legacy) ? legacy : current;
 }
-function pinnedGitCommit(spec) {
-  const ref = GIT_SPEC_RE.exec(spec)?.[1];
-  return ref !== void 0 && COMMIT_SHA_RE.test(ref) ? ref.toLowerCase() : void 0;
+function isExistingDirectory(candidate) {
+  return import_node_fs4.default.statSync(candidate, { throwIfNoEntry: false })?.isDirectory() ?? false;
 }
-
-// src/headroom/supervisor.ts
-function resolveSupervisorConfig(configured) {
+function resolveClaudeHome() {
+  const fromEnv = process.env.AGENT_SHIM_CLAUDE_HOME;
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    return fromEnv;
+  }
+  return import_node_path20.default.join(import_node_os4.default.homedir(), ".claude");
+}
+function buildLayoutPaths(root) {
   return {
-    source: configured.source ?? HEADROOM_DEFAULT_SOURCE,
-    idleShutdownMinutes: configured.idleShutdownMinutes ?? HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES,
-    settings: settingsOf(configured)
+    root,
+    identitiesDir: import_node_path20.default.join(root, "identities"),
+    configProfilesDir: import_node_path20.default.join(root, "config-profiles"),
+    providersDir: import_node_path20.default.join(root, "providers"),
+    directoryRulesFile: import_node_path20.default.join(root, "directory-rules.json"),
+    activeIdentityFile: import_node_path20.default.join(root, "active-identity"),
+    globalConfigFile: import_node_path20.default.join(root, "config.json"),
+    categoriesLocalFile: import_node_path20.default.join(root, "categories.local.json"),
+    claudeShimFile: import_node_path20.default.join(root, "claude-shim.json"),
+    headroomDir: import_node_path20.default.join(root, "headroom"),
+    headroomStateFile: import_node_path20.default.join(root, "headroom", `state.v${String(HEADROOM_STATE_SCHEMA_VERSION)}.json`),
+    headroomSocketDir: import_node_path20.default.join(root, "headroom", "run"),
+    headroomLockFile: import_node_path20.default.join(root, "headroom", "start.lock"),
+    headroomSessionsDir: import_node_path20.default.join(root, "headroom", "sessions"),
+    logsDir: import_node_path20.default.join(root, "logs"),
+    headroomLogPath: import_node_path20.default.join(root, "logs", "headroom.log"),
+    frontdoorDir: import_node_path20.default.join(root, "frontdoor"),
+    frontdoorCaDir: import_node_path20.default.join(root, "frontdoor", "ca"),
+    frontdoorCaCertFile: import_node_path20.default.join(root, "frontdoor", "ca", "ca.pem"),
+    frontdoorCaKeyFile: import_node_path20.default.join(root, "frontdoor", "ca", "ca.key"),
+    frontdoorCaBundlesDir: import_node_path20.default.join(root, "frontdoor", "ca", "bundles"),
+    chatgptSignInFile: import_node_path20.default.join(root, "codex", "chatgpt-sign-in.json"),
+    frontdoorStateFile: import_node_path20.default.join(root, "frontdoor", "state.json"),
+    frontdoorLockFile: import_node_path20.default.join(root, "frontdoor", "start.lock"),
+    frontdoorControlTokenFile: import_node_path20.default.join(root, "frontdoor", "control-token"),
+    frontdoorSessionsDir: import_node_path20.default.join(root, "frontdoor", "sessions"),
+    frontdoorRcCredentialsDir: import_node_path20.default.join(root, "frontdoor", "rc-credentials"),
+    frontdoorLogPath: import_node_path20.default.join(root, "logs", "frontdoor.log"),
+    usageDir: import_node_path20.default.join(root, "usage"),
+    usageLogDir: import_node_path20.default.join(root, "usage", "log"),
+    usageSnapshotsDir: import_node_path20.default.join(root, "usage", "snapshots"),
+    usagePicksFile: import_node_path20.default.join(root, "usage", "picks.json")
   };
 }
-var HEADROOM_BACKOFF_BASE_MS = 500;
-var HEADROOM_BACKOFF_CAP_MS = 3e4;
-var HEADROOM_START_RETRY_BUDGET = 5;
-var HEADROOM_READY_TIMEOUT_MS = 15e3;
-var HEADROOM_POLL_MS = 1e3;
-var MS_PER_MINUTE2 = 6e4;
-function backoffForAttempt(attempt) {
-  return Math.min(HEADROOM_BACKOFF_CAP_MS, HEADROOM_BACKOFF_BASE_MS * 2 ** (attempt - 1));
+function resolveLayoutPaths() {
+  return buildLayoutPaths(resolveAgentShimHome());
 }
-function versionSatisfies(version, source) {
-  if (version === void 0) {
-    return false;
-  }
-  const specifier = /==|>=|<=|!=|>|<|~=/.exec(source);
-  if (specifier === null) {
-    return true;
-  }
-  const installed = parseVersion(version);
-  const wanted = parseVersion(source.slice(specifier.index + specifier[0].length));
-  if (installed === void 0 || wanted === void 0) {
-    return true;
-  }
-  const cmp = compareVersions2(installed, wanted);
-  switch (specifier[0]) {
-    case "==":
-      return cmp === 0;
-    case "!=":
-      return cmp !== 0;
-    case ">=":
-      return cmp >= 0;
-    case "<=":
-      return cmp <= 0;
-    case ">":
-      return cmp > 0;
-    case "<":
-      return cmp < 0;
-    case "~=":
-      return compareVersions2(installed.slice(0, Math.max(0, wanted.length - 1)), wanted.slice(0, Math.max(0, wanted.length - 1))) === 0 && cmp >= 0;
-    default:
-      return true;
-  }
+
+// src/realCredentialCache.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_path21 = __toESM(require("node:path"), 1);
+
+// src/credentialCache.ts
+var import_zod11 = require("zod");
+var MS_PER_UNIT = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+var CachedCredentialSchema = import_zod11.z.strictObject({
+  token: import_zod11.z.string().min(1),
+  fetchedAt: import_zod11.z.number().int().nonnegative(),
+  source: CredentialSourceSchema
+});
+function effectiveStore(cache, platform) {
+  return cache.store ?? (platform === "darwin" ? "keychain" : "file");
 }
-function parseVersion(input) {
-  const match = /(\d+)(\.\d+)*/.exec(input);
-  if (match === null) {
+function ttlMs(cache) {
+  if (cache.ttl === void 0) {
     return void 0;
   }
-  return match[0].split(".").map((part) => Number.parseInt(part, 10));
+  const multiplier = MS_PER_UNIT[cache.ttl.slice(-1)];
+  if (multiplier === void 0) {
+    throw new Error(`credential cache ttl "${cache.ttl}" has no recognised unit`);
+  }
+  return Number(cache.ttl.slice(0, -1)) * multiplier;
 }
-function compareVersions2(a, b) {
-  for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
-    const left = a[index] ?? 0;
-    const right = b[index] ?? 0;
-    if (left !== right) {
-      return left - right;
-    }
+function isFresh(entry, cache, now) {
+  const limit = ttlMs(cache);
+  if (entry.fetchedAt > now) {
+    return false;
   }
-  return 0;
+  return limit === void 0 || now - entry.fetchedAt < limit;
 }
-var HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
-async function runSupervisor(initialConfig, ports, options = {}) {
-  const { fs: fs12, paths } = ports;
-  let config = initialConfig;
-  const previousState = readHeadroomState(fs12, paths.headroomStateFile);
-  if (previousState?.supervisorPid !== void 0 && previousState.supervisorPid !== ports.ownPid && ports.isRunning(previousState.supervisorPid)) {
-    ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: supervisor ${String(previousState.supervisorPid)} already owns the daemon; exiting`);
-    return 0;
+function cacheAgeMs(entry, now) {
+  return Math.max(0, now - entry.fetchedAt);
+}
+function describeCachedCredential(params) {
+  const store = effectiveStore(params.cache, params.platform);
+  let entry;
+  try {
+    entry = params.port.read(store, params.owner);
+  } catch (error) {
+    return { store, status: "unreadable", reason: error instanceof Error ? error.message : String(error) };
   }
-  let installedSource = previousState?.installedSource;
-  const ownsState = () => {
-    const owner = readHeadroomState(fs12, paths.headroomStateFile)?.supervisorPid;
-    return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
-  };
-  const writeOwnState = (state) => {
-    if (!ownsState()) {
-      return false;
-    }
-    writeHeadroomState(fs12, paths.headroomStateFile, state);
-    return true;
-  };
-  const fail = (message) => {
-    if (writeOwnState({ lastError: message })) {
-      fs12.removeRecursive(paths.headroomLockFile);
-    }
-    ports.log(`agent-shim headroom supervisor: ${message}`);
-    return 1;
-  };
-  const ensureInstalled = () => {
-    const version2 = ports.headroomVersion();
-    const versionOk = version2 !== void 0 && versionSatisfies(version2, config.source);
-    const pinned = pinnedGitCommit(config.source);
-    const commitOk = pinned === void 0 || ports.installedCommit() === pinned;
-    if (versionOk && commitOk && (installedSource === void 0 || installedSource === config.source)) {
-      installedSource = config.source;
-      return true;
-    }
-    ports.log(`agent-shim headroom supervisor: installing headroom from ${config.source}`);
-    const result = ports.install(config.source);
-    if (!result.ok) {
-      return false;
-    }
-    installedSource = config.source;
-    return true;
+  if (entry === void 0) {
+    return { store, status: "empty" };
+  }
+  const limit = ttlMs(params.cache);
+  const ageMs = cacheAgeMs(entry, params.nowMs);
+  return {
+    store,
+    status: isFresh(entry, params.cache, params.nowMs) ? "fresh" : "expired",
+    ageMs,
+    ...limit === void 0 ? {} : { expiresInMs: limit - ageMs }
   };
-  const socket = prepareHeadroomSocket(fs12, ports.socketTrust, paths, ports.ownPid);
-  if (socket.refused !== void 0) {
-    return fail(socket.refused);
+}
+function formatCachedCredentialState(state) {
+  if (state.status === "empty") {
+    return `no cached entry in the ${state.store} store yet`;
   }
-  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?)`);
+  if (state.status === "unreadable") {
+    return `the ${state.store} store cannot be read here: ${state.reason}`;
   }
-  const version = ports.headroomVersion() ?? "unknown";
-  writeOwnState({ supervisorPid: ports.ownPid, version, installedSource });
-  ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${allowlistOf(ports).join(", ")}]`);
-  const orphanPid = previousState?.headroomPid;
-  if (orphanPid !== void 0 && ports.isRunning(orphanPid)) {
-    ports.log(`agent-shim headroom supervisor: stopping daemon pid ${String(orphanPid)} left behind by the previous supervisor`);
-    ports.stopProcess(orphanPid);
+  if (state.status === "expired" && (state.expiresInMs === void 0 || state.expiresInMs > 0)) {
+    return "cached with a timestamp in the future, treated as expired";
   }
-  let headroomPid;
-  let runningHash;
-  let runningSettingsHash;
-  let consecutiveFailures = 0;
-  let idleSince;
-  let superseded = false;
-  let ticks = 0;
-  for (; ; ) {
-    if (options.tickLimit !== void 0 && ticks >= options.tickLimit) {
-      return HEADROOM_SUPERVISOR_STILL_RUNNING;
-    }
-    ticks += 1;
-    config = ports.readConfig();
-    const settingsHash = hashSettings(config.settings);
-    const allowlist = allowlistOf(ports);
-    const allowlistHash = hashAllowlist(allowlist);
-    pruneDeadSessions(fs12, paths.headroomSessionsDir, ports.isRunning);
-    const ownsNow = ownsState();
-    if (!ownsNow && !superseded) {
-      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);
-    if (headroomPid === void 0 || crashed) {
-      if (crashed) {
-        ports.log(`agent-shim headroom supervisor: headroom pid ${String(headroomPid)} died`);
-        headroomPid = void 0;
-        runningHash = void 0;
-        runningSettingsHash = void 0;
-        writeOwnState({
-          supervisorPid: ports.ownPid,
-          version,
-          installedSource
-        });
-      }
-      if (consecutiveFailures >= HEADROOM_START_RETRY_BUDGET) {
-        return fail(`headroom failed to become ready ${String(consecutiveFailures)} times in a row; giving up`);
-      }
-      if (installedSource !== config.source && !ensureInstalled()) {
-        return fail(`could not install headroom from ${config.source}: install failed (is uv installed and on PATH?)`);
-      }
-      const pid = ports.spawnHeadroom(socketPath, allowlist, config.settings);
-      const ready = await waitUntilReady(ports, socketPath);
-      if (ready) {
-        consecutiveFailures = 0;
-        headroomPid = pid;
-        runningHash = allowlistHash;
-        runningSettingsHash = settingsHash;
-        const recorded = writeOwnState({
-          supervisorPid: ports.ownPid,
-          headroomPid: pid,
-          socketPath,
-          version,
-          allowlistHash,
-          settingsHash,
-          installedSource: config.source
-        });
-        if (recorded) {
-          fs12.removeRecursive(paths.headroomLockFile);
-        }
-        idleSince = void 0;
-        ports.log(`agent-shim headroom supervisor: headroom pid ${String(pid)} ready on unix socket ${socketPath}`);
-      } else {
-        ports.stopProcess(pid);
-        consecutiveFailures += 1;
-        ports.log(
-          `agent-shim headroom supervisor: headroom did not become ready on unix socket ${socketPath} (attempt ${String(consecutiveFailures)} of ${String(HEADROOM_START_RETRY_BUDGET)})`
-        );
-        await ports.sleep(backoffForAttempt(consecutiveFailures));
-        continue;
-      }
-    } else {
-      if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config.source) {
-        if (sessionsForSupervisor(fs12, paths.headroomSessionsDir, ports.ownPid).length === 0) {
-          ports.log("agent-shim headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
-          ports.stopProcess(headroomPid);
-          headroomPid = void 0;
-          runningHash = void 0;
-          runningSettingsHash = void 0;
-          continue;
-        }
-      }
-      const sessions = sessionsForSupervisor(fs12, paths.headroomSessionsDir, ports.ownPid);
-      if (sessions.length === 0) {
-        idleSince ??= ports.now();
-        const idleMs = ports.now() - idleSince;
-        if (idleMs >= config.idleShutdownMinutes * MS_PER_MINUTE2) {
-          ports.log(
-            `agent-shim headroom supervisor: no sessions for ${String(config.idleShutdownMinutes)} minute(s); stopping headroom and exiting`
-          );
-          ports.stopProcess(headroomPid);
-          writeOwnState({ version });
-          return 0;
-        }
-      } else {
-        idleSince = void 0;
-      }
-    }
-    await ports.sleep(HEADROOM_POLL_MS);
+  const age = `cached ${formatAge(state.ageMs)} ago`;
+  if (state.expiresInMs === void 0) {
+    return `${age}, no expiry`;
   }
+  return state.status === "fresh" ? `${age}, expires in ${formatAge(state.expiresInMs)}` : `${age}, expired ${formatAge(-state.expiresInMs)} ago`;
 }
-function currentHeadroomAllowlist(fs12, paths) {
-  const providers = readAllProviders(fs12, paths.providersDir).map((entry) => entry.provider);
-  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs12, paths.frontdoorStateFile))));
-}
-function allowlistOf(ports) {
-  return currentHeadroomAllowlist(ports.fs, ports.paths);
+
+// src/realCredentialCache.ts
+var KEYCHAIN_CACHE_SERVICE = "agent-shim-credential-cache";
+var CACHE_DIR_MODE = 448;
+var CACHE_FILE_MODE = 384;
+function cacheFileNameFor(owner) {
+  return `${owner.replace(/[^A-Za-z0-9._-]/g, "_")}.json`;
 }
-async function waitUntilReady(ports, socketPath) {
-  const deadline = ports.now() + HEADROOM_READY_TIMEOUT_MS;
-  for (; ; ) {
-    if (await ports.ready(socketPath)) {
-      return true;
-    }
-    if (ports.now() >= deadline) {
-      return false;
-    }
-    await ports.sleep(HEADROOM_POLL_MS);
+function parseEntry(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return void 0;
   }
+  const parsed = CachedCredentialSchema.safeParse(json);
+  return parsed.success ? parsed.data : void 0;
 }
-
-// src/realPorts.ts
-function isEnoent3(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-var realFsPort = {
-  readFileUtf8(filePath) {
-    try {
-      return import_node_fs6.default.readFileSync(filePath, "utf8");
-    } catch (error) {
-      if (isEnoent3(error)) {
-        return void 0;
-      }
-      throw error;
-    }
-  },
-  readConfigFile: cosmiconfigReader(),
-  readdir(dirPath) {
-    try {
-      return import_node_fs6.default.readdirSync(dirPath);
-    } catch (error) {
-      if (isEnoent3(error)) {
-        return [];
-      }
-      throw error;
-    }
+function requireKeychain() {
+  if (process.platform !== "darwin") {
+    throw new Error("the keychain credential store needs macOS; use --credential-cache-store file");
   }
-};
-function isErrorWithCode(error, code) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
-var OWNER_ONLY_DIR_MODE = 448;
-var OWNER_ONLY_FILE_MODE = 384;
-var PERMISSION_BITS2 = 511;
-var realFarmFs = {
-  lstat(filePath) {
-    let stat;
-    try {
-      stat = import_node_fs6.default.lstatSync(filePath);
-    } catch (error) {
-      if (isEnoent3(error)) {
-        return void 0;
-      }
-      throw error;
-    }
-    const kind = stat.isSymbolicLink() ? "symlink" : stat.isDirectory() ? "dir" : "file";
-    return { kind, mtimeMs: stat.mtimeMs, sizeBytes: stat.size };
-  },
-  readdir(dirPath) {
-    try {
-      return import_node_fs6.default.readdirSync(dirPath);
-    } catch (error) {
-      if (isEnoent3(error) || isErrorWithCode(error, "ENOTDIR")) {
-        return [];
-      }
-      throw error;
-    }
-  },
-  mkdirp(dirPath) {
-    import_node_fs6.default.mkdirSync(dirPath, { recursive: true });
-  },
-  symlink(target, linkPath) {
-    import_node_fs6.default.symlinkSync(target, linkPath);
-  },
-  rename(from, to) {
-    import_node_fs6.default.renameSync(from, to);
-  },
-  removeRecursive(targetPath) {
-    import_node_fs6.default.rmSync(targetPath, { recursive: true, force: true });
-  },
-  copyRecursive(from, to) {
-    import_node_fs6.default.cpSync(from, to, { recursive: true, force: true, verbatimSymlinks: true });
-  },
-  readFileUtf8(filePath) {
-    try {
-      return import_node_fs6.default.readFileSync(filePath, "utf8");
-    } catch (error) {
-      if (isEnoent3(error)) {
-        return void 0;
-      }
-      throw error;
-    }
-  },
-  writeFileUtf8(filePath, contents) {
-    import_node_fs6.default.writeFileSync(filePath, contents, "utf8");
-  },
-  mkdirPrivate(dirPath) {
-    import_node_fs6.default.mkdirSync(dirPath, { recursive: true, mode: OWNER_ONLY_DIR_MODE });
-    import_node_fs6.default.chmodSync(dirPath, OWNER_ONLY_DIR_MODE);
-  },
-  writeFilePrivate(filePath, contents) {
-    const temp = `${filePath}.${String(process.pid)}.tmp`;
-    import_node_fs6.default.writeFileSync(temp, contents, { encoding: "utf8", mode: OWNER_ONLY_FILE_MODE });
-    import_node_fs6.default.chmodSync(temp, OWNER_ONLY_FILE_MODE);
-    import_node_fs6.default.renameSync(temp, filePath);
-  },
-  appendFilePrivate(filePath, contents) {
-    const descriptor = import_node_fs6.default.openSync(filePath, "a", OWNER_ONLY_FILE_MODE);
-    try {
-      if ((import_node_fs6.default.fstatSync(descriptor).mode & PERMISSION_BITS2) !== OWNER_ONLY_FILE_MODE) {
-        import_node_fs6.default.fchmodSync(descriptor, OWNER_ONLY_FILE_MODE);
+function security(args, stdin) {
+  const result = (0, import_node_child_process2.spawnSync)("security", args, { encoding: "utf8", ...stdin === void 0 ? {} : { input: stdin }, stdio: ["pipe", "pipe", "ignore"] });
+  return { status: result.status, stdout: result.stdout };
+}
+function createRealCredentialCache(root) {
+  const dir = import_node_path21.default.join(root, "credential-cache");
+  const filePath = (owner) => import_node_path21.default.join(dir, cacheFileNameFor(owner));
+  return {
+    read(store, owner) {
+      if (store === "file") {
+        try {
+          return parseEntry(import_node_fs5.default.readFileSync(filePath(owner), "utf8"));
+        } catch {
+          return void 0;
+        }
       }
-      const bytes = Buffer.from(contents, "utf8");
-      let written = 0;
-      while (written < bytes.length) {
-        written += import_node_fs6.default.writeSync(descriptor, bytes, written, bytes.length - written);
+      requireKeychain();
+      const result = security(["find-generic-password", "-s", KEYCHAIN_CACHE_SERVICE, "-a", owner, "-w"]);
+      return result.status === 0 ? parseEntry(Buffer.from(result.stdout.trim(), "base64").toString("utf8")) : void 0;
+    },
+    write(store, owner, entry) {
+      const serialised = JSON.stringify(entry);
+      if (store === "file") {
+        import_node_fs5.default.mkdirSync(dir, { recursive: true, mode: CACHE_DIR_MODE });
+        import_node_fs5.default.chmodSync(dir, CACHE_DIR_MODE);
+        const target = filePath(owner);
+        const temp = `${target}.${String(process.pid)}.tmp`;
+        import_node_fs5.default.writeFileSync(temp, serialised, { mode: CACHE_FILE_MODE });
+        import_node_fs5.default.renameSync(temp, target);
+        return;
       }
-    } finally {
-      import_node_fs6.default.closeSync(descriptor);
-    }
-  },
-  writeFileExclusive(filePath, contents) {
-    try {
-      import_node_fs6.default.writeFileSync(filePath, contents, { encoding: "utf8", flag: "wx" });
-      return true;
-    } catch (error) {
-      if (isErrorWithCode(error, "EEXIST")) {
-        return false;
+      requireKeychain();
+      const encoded = Buffer.from(serialised, "utf8").toString("base64");
+      const result = security(["-i"], `add-generic-password -U -s ${KEYCHAIN_CACHE_SERVICE} -a ${JSON.stringify(owner)} -w ${encoded}
+`);
+      if (result.status !== 0) {
+        throw new Error(`could not write the keychain credential cache for ${owner}`);
       }
-      throw error;
-    }
-  },
-  hashFile(filePath) {
-    try {
-      return (0, import_node_crypto8.createHash)("sha256").update(import_node_fs6.default.readFileSync(filePath)).digest("hex");
-    } catch (error) {
-      if (isEnoent3(error) || isErrorWithCode(error, "EISDIR")) {
-        return void 0;
+    },
+    remove(store, owner) {
+      if (store === "file") {
+        import_node_fs5.default.rmSync(filePath(owner), { force: true });
+        return;
       }
-      throw error;
+      requireKeychain();
+      security(["delete-generic-password", "-s", KEYCHAIN_CACHE_SERVICE, "-a", owner]);
     }
+  };
+}
+function realCredentialCacheEnv(paths) {
+  return { port: createRealCredentialCache(paths.root), platform: process.platform, now: () => Date.now() };
+}
+
+// src/providersStore.ts
+var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_path22 = __toESM(require("node:path"), 1);
+
+// src/credential.ts
+var CREDENTIAL_UNAVAILABLE_EXIT = 64;
+var CREDENTIAL_COMMAND_TIMEOUT_MS = 1e4;
+var CREDENTIAL_INTERACTIVE_TIMEOUT_MS = 12e4;
+var GROUP_OTHER_PERMISSION_BITS = 63;
+var PERMISSION_BITS2 = 511;
+var OCTAL_RADIX2 = 8;
+function commandArgv(source) {
+  if ("command" in source) {
+    return source.command;
   }
-};
-var INT32_BYTE_LENGTH = 4;
-function realSleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(INT32_BYTE_LENGTH)), 0, 0, ms);
+  if ("op" in source) {
+    return ["op", "read", source.op];
+  }
+  const account = source.keychain.account;
+  return ["security", "find-generic-password", "-s", source.keychain.service, ...account === void 0 ? [] : ["-a", account], "-w"];
 }
-function realIsProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return isErrorWithCode(error, "EPERM");
+function isInteractiveSource(source, env) {
+  if ("command" in source || "keychain" in source) {
+    return source.interactive ?? false;
+  }
+  if ("op" in source) {
+    return source.interactive ?? (env.OP_SERVICE_ACCOUNT_TOKEN ?? "") === "";
   }
+  return false;
 }
-function realIsProcessZombie(pid) {
-  const result = (0, import_node_child_process2.spawnSync)("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf8" });
-  return result.status === 0 && result.stdout.trim().startsWith("Z");
+function summariseSource(source) {
+  if ("env" in source) {
+    return { kind: "env", variable: source.env };
+  }
+  if ("file" in source) {
+    return { kind: "file", path: source.file };
+  }
+  if ("command" in source) {
+    return { kind: "command", program: source.command[0] };
+  }
+  if ("op" in source) {
+    return { kind: "op", reference: source.op };
+  }
+  if ("keychain" in source) {
+    return {
+      kind: "keychain",
+      service: source.keychain.service,
+      ...source.keychain.account === void 0 ? {} : { account: source.keychain.account }
+    };
+  }
+  return { kind: "literal" };
 }
-function realIsProcessRunning(pid) {
-  return realIsProcessAlive(pid) && !realIsProcessZombie(pid);
+function summariseCredential(credential) {
+  return {
+    target: credential.target ?? "bearer",
+    sources: credential.sources.map(summariseSource),
+    ...credential.cache === void 0 ? {} : { cache: credential.cache }
+  };
 }
-var realRunPort = {
-  run(command, args) {
-    const result = (0, import_node_child_process2.spawnSync)(command, [...args], { encoding: "utf8" });
-    return { status: result.status, stdout: result.stdout, stderr: result.stderr };
+function formatSourceSummary(summary) {
+  switch (summary.kind) {
+    case "env":
+      return `env ${summary.variable}`;
+    case "file":
+      return `file ${summary.path}`;
+    case "command":
+      return `command ${summary.program}`;
+    case "op":
+      return `op ${summary.reference}`;
+    case "keychain":
+      return `keychain ${summary.service}${summary.account === void 0 ? "" : ` (account ${summary.account})`}`;
+    case "literal":
+      return "literal (non-secret placeholder)";
+    default:
+      return summary;
   }
-};
-function expandHome2(filePath) {
-  return filePath.startsWith("~/") ? import_node_path22.default.join(import_node_os3.default.homedir(), filePath.slice(1)) : filePath;
 }
-var MACOS_GUI_SESSION_MANAGER = "Aqua";
-function hasDesktopSession() {
-  if (process.platform === "darwin") {
-    const result = (0, import_node_child_process2.spawnSync)("launchctl", ["managername"], { encoding: "utf8" });
-    return result.status === 0 && result.stdout.trim() === MACOS_GUI_SESSION_MANAGER;
+function describeSource(source) {
+  return formatSourceSummary(summariseSource(source));
+}
+function formatCredentialSummary(summary) {
+  const cache = summary.cache === void 0 ? "" : `, cached ${summary.cache.ttl === void 0 ? "with no expiry" : `for ${summary.cache.ttl}`}${summary.cache.store === void 0 ? "" : ` in the ${summary.cache.store} store`}`;
+  return `${summary.target} from ${summary.sources.map(formatSourceSummary).join(", then ")}${cache}`;
+}
+function describeCredential(credential) {
+  return formatCredentialSummary(summariseCredential(credential));
+}
+function trySource(source, params) {
+  const none = (reason, warn = false) => ({ ok: false, reason, warn });
+  if ("env" in source) {
+    const value = params.env[source.env];
+    return value === void 0 || value === "" ? none("is unset or empty") : { ok: true, token: value };
   }
-  if (process.platform === "win32") {
-    return false;
+  if ("literal" in source) {
+    return { ok: true, token: source.literal };
   }
-  return (process.env.DISPLAY ?? "") !== "" || (process.env.WAYLAND_DISPLAY ?? "") !== "";
-}
-var realCredentialPort = {
-  readSecretFile(filePath) {
-    const resolved = expandHome2(filePath);
-    let content;
-    let stat;
-    try {
-      stat = import_node_fs6.default.statSync(resolved);
-      content = import_node_fs6.default.readFileSync(resolved, "utf8");
-    } catch (error) {
-      if (isEnoent3(error)) {
-        return { found: false };
-      }
-      throw error;
+  if ("file" in source) {
+    const read = params.port.readSecretFile(source.file);
+    if (!read.found) {
+      return none("does not exist");
     }
-    return { found: true, content, mode: process.platform === "win32" ? void 0 : stat.mode };
-  },
-  runCommand(argv, options) {
-    const [command, ...args] = argv;
-    const result = (0, import_node_child_process2.spawnSync)(command, args, {
-      encoding: "utf8",
-      timeout: options.timeoutMs,
-      stdio: options.interactive ? ["inherit", "pipe", "inherit"] : ["ignore", "pipe", "pipe"]
-    });
-    if (result.error !== void 0) {
-      const timedOut = isErrorWithCode(result.error, "ETIMEDOUT");
-      return { status: result.status, stdout: "", stderr: timedOut ? "" : result.error.message, timedOut };
+    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_BITS2).toString(OCTAL_RADIX2)}); run \`chmod 600 ${source.file}\``,
+        true
+      );
     }
-    return { status: result.status, stdout: result.stdout, stderr: options.interactive ? "" : result.stderr, timedOut: false };
-  },
-  personPresent: () => process.stdin.isTTY || hasDesktopSession()
-};
-function resolveGitBranch(run, cwd) {
-  const result = run.run("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"]);
-  if (result.status !== 0) {
-    return {};
+    const token2 = read.content.trim();
+    return token2 === "" ? none("is empty") : { ok: true, token: token2 };
   }
-  const name = result.stdout.trim();
-  if (name === "") {
-    return {};
+  const argv = commandArgv(source);
+  const interactive = isInteractiveSource(source, params.env);
+  if (interactive && !params.port.personPresent()) {
+    return none("needs a person to approve it, but there is no terminal or desktop session");
   }
-  if (name === "HEAD") {
-    return { branchDetached: true };
+  const timeoutMs = source.timeoutMs ?? (interactive ? CREDENTIAL_INTERACTIVE_TIMEOUT_MS : CREDENTIAL_COMMAND_TIMEOUT_MS);
+  const result = params.port.runCommand(argv, { timeoutMs, interactive });
+  if (result.timedOut) {
+    return none(`timed out after ${String(timeoutMs)}ms`);
   }
-  return { branch: name, branchDetached: false };
-}
-function resolveGitRoot(run, cwd) {
-  const result = run.run("git", ["-C", cwd, "rev-parse", "--show-toplevel"]);
   if (result.status !== 0) {
-    return void 0;
+    const stderr = result.stderr.trim();
+    const outcome = result.status === null ? "could not be run or was killed by a signal" : `exited with status ${String(result.status)}`;
+    return none(`${outcome}${stderr === "" ? "" : `: ${stderr}`}`);
   }
-  const root = result.stdout.trim();
-  return root === "" ? void 0 : root;
-}
-function detachedDaemonSpawnOptions(logFd, env) {
-  return { detached: true, stdio: ["ignore", logFd, logFd], env };
-}
-function spawnDaemonThrough(executable) {
-  return (paths, subcommand, logPath) => spawnDetachedDaemon({ command: executable, args: [subcommand] }, paths, subcommand, logPath);
+  const token = result.stdout.trim();
+  return token === "" ? none("printed no token") : { ok: true, token };
 }
-function spawnDaemonThroughScript(script) {
-  return (paths, subcommand, logPath) => spawnDetachedDaemon({ command: process.execPath, args: [script, subcommand] }, paths, subcommand, logPath);
+function warmCommandFor(subject) {
+  const [kind, name] = subject.split(" ");
+  return kind === "provider" ? `agent-shim credential warm --provider ${name ?? ""}` : `agent-shim credential warm ${name ?? ""}`;
 }
-function spawnDetachedDaemon(invocation, paths, subcommand, logPath) {
-  import_node_fs6.default.mkdirSync(import_node_path22.default.dirname(logPath), { recursive: true });
-  const logFd = import_node_fs6.default.openSync(logPath, "a");
-  try {
-    const child = (0, import_node_child_process2.spawn)(invocation.command, invocation.args, detachedDaemonSpawnOptions(logFd, { ...process.env, AGENT_SHIM_HOME: paths.root }));
-    child.unref();
-    if (child.pid === void 0) {
-      throw new Error(`spawning ${subcommand} returned no pid`);
+function resolveCredential(params) {
+  const target = params.credential.target ?? "bearer";
+  const cacheBlock = params.credential.cache;
+  const cache = cacheBlock === void 0 ? void 0 : params.port.cache;
+  const store = cacheBlock === void 0 || cache === void 0 ? void 0 : effectiveStore(cacheBlock, cache.platform);
+  if (cacheBlock !== void 0 && cache !== void 0 && store !== void 0 && params.refresh !== true) {
+    const entry = cache.port.read(store, params.subject);
+    if (entry !== void 0 && isFresh(entry, cacheBlock, cache.now())) {
+      return { ok: true, credential: { target, token: entry.token, source: entry.source, warnings: [], cachedAt: entry.fetchedAt } };
     }
-    return child.pid;
-  } finally {
-    import_node_fs6.default.closeSync(logFd);
   }
-}
-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;
+  const attempts = [];
+  const warnings = [];
+  for (const source of params.credential.sources) {
+    const outcome = trySource(source, params);
+    if (outcome.ok) {
+      if (cache !== void 0 && store !== void 0) {
+        cache.port.write(store, params.subject, { token: outcome.token, fetchedAt: cache.now(), source });
       }
-      throw error;
+      return { ok: true, credential: { target, token: outcome.token, source, warnings } };
     }
-    const kind = stat.isSymbolicLink() ? "symlink" : stat.isDirectory() ? "dir" : stat.isSocket() ? "socket" : "other";
-    return { kind, uid: stat.uid, mode: stat.mode & SOCKET_PERMISSION_BITS };
+    const line = `${describeSource(source)} ${outcome.reason}`;
+    attempts.push(line);
+    if (outcome.warn) {
+      warnings.push(`agent-shim: ${params.subject}: skipped ${line}`);
+    }
+  }
+  const hint = cacheBlock === void 0 ? "" : `; fill the cache from a terminal with \`${warmCommandFor(params.subject)}\``;
+  return { ok: false, message: `agent-shim: ${params.subject} has no usable credential: ${attempts.join("; ")}${hint}` };
+}
+function credentialVariables(target, token) {
+  return {
+    ANTHROPIC_AUTH_TOKEN: target === "bearer" ? token : void 0,
+    ANTHROPIC_API_KEY: target === "apiKey" ? token : void 0,
+    CLAUDE_CODE_OAUTH_TOKEN: target === "oauthToken" ? token : void 0
+  };
+}
+
+// src/providersStore.ts
+var ProviderNotFoundError = class extends CliError {
+  constructor(name) {
+    super(`No provider named "${name}". Run \`agent-shim provider add ${name}\` first.`);
+    this.name = name;
+    this.name = "ProviderNotFoundError";
   }
+  name;
 };
-function realHeadroomPort(paths, options) {
+var ProviderAlreadyExistsError = class extends CliError {
+  constructor(providerName) {
+    super(`A provider named "${providerName}" already exists.`);
+    this.providerName = providerName;
+    this.name = "ProviderAlreadyExistsError";
+  }
+  providerName;
+};
+var InvalidProviderNameError = class extends CliError {
+  constructor(attemptedName) {
+    super(
+      `"${attemptedName}" is not a valid provider name. Provider names must start with a letter or number and may then contain letters, numbers, dots, hyphens, underscores, and at signs.`
+    );
+    this.attemptedName = attemptedName;
+    this.name = "InvalidProviderNameError";
+  }
+  attemptedName;
+};
+var PROVIDER_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._@-]*$/;
+function providerJsonPath(paths, name) {
+  return import_node_path22.default.join(paths.providersDir, `${name}.json`);
+}
+function providerExists(paths, name) {
+  return import_node_fs6.default.existsSync(providerJsonPath(paths, name));
+}
+var LEGACY_PROVIDER_FIELDS = ["tokenEnv", "tokenCommand", "authScheme"];
+var LEGACY_ENV_CREDENTIAL_KEYS = Object.values(CREDENTIAL_TARGET_VARS);
+var LEGACY_LITERAL_PLACEHOLDER = "<the value of env.ANTHROPIC_AUTH_TOKEN>";
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function legacyProviderConversion(raw) {
+  if (!isRecord4(raw) || "credential" in raw) {
+    return void 0;
+  }
+  const env = isRecord4(raw.env) ? raw.env : void 0;
+  const legacyEnvKeys = env === void 0 ? [] : Object.keys(env).filter((key) => LEGACY_ENV_CREDENTIAL_KEYS.includes(key));
+  const fields = [...LEGACY_PROVIDER_FIELDS.filter((field) => field in raw), ...legacyEnvKeys.map((key) => `env.${key}`)];
+  if (fields.length === 0) {
+    return void 0;
+  }
+  const sources = [];
+  if (typeof raw.tokenEnv === "string") {
+    sources.push({ env: raw.tokenEnv });
+  }
+  if (Array.isArray(raw.tokenCommand)) {
+    sources.push({ command: raw.tokenCommand });
+  }
+  if (typeof env?.ANTHROPIC_AUTH_TOKEN === "string" && env.ANTHROPIC_AUTH_TOKEN !== "") {
+    sources.push({ literal: LEGACY_LITERAL_PLACEHOLDER });
+  }
+  const remainingEnv = env === void 0 ? void 0 : Object.fromEntries(Object.entries(env).filter(([key]) => !LEGACY_ENV_CREDENTIAL_KEYS.includes(key)));
+  const replacedKeys = [...LEGACY_PROVIDER_FIELDS, "env"];
+  const rest = Object.fromEntries(Object.entries(raw).filter(([key]) => !replacedKeys.includes(key)));
   return {
-    ensure: ({ routesProvider }) => {
-      const up = ensureHeadroom({
-        paths,
-        launcherPid: process.pid,
-        ...routesProvider ? { requiredAllowlistHash: () => hashAllowlist(currentHeadroomAllowlist(realFarmFs, paths)) } : {},
-        ports: {
-          fs: realFarmFs,
-          // Zombie-aware on purpose: a supervisor that died while still a child of this launcher sits unreaped until the launcher itself exits, and a defunct supervisor answering signal 0 as alive would stretch every launch to the full start timeout.
-          isRunning: realIsProcessRunning,
-          now: () => Date.now(),
-          sleep: realSleepSync,
-          spawnSupervisor: (layout) => spawnHeadroomSupervisor(layout, options.spawnDaemon)
-        }
-      });
-      return {
-        socketPath: up.socketPath,
-        projectId: resolveGitRoot(realRunPort, options.cwd) ?? options.cwd
-      };
-    },
-    release: () => {
-      removeSession(realFarmFs, paths.headroomSessionsDir, process.pid);
+    fields,
+    replacement: {
+      ...rest,
+      credential: { sources, ...raw.authScheme === "apiKey" ? { target: "apiKey" } : {} },
+      ...remainingEnv === void 0 || Object.keys(remainingEnv).length === 0 ? {} : { env: remainingEnv }
     }
   };
 }
-var realProcPort = {
-  env: process.env,
-  argv: process.argv.slice(2),
-  exit: (code) => process.exit(code)
+var LegacyProviderFileError = class extends CliError {
+  constructor(filePath, conversion) {
+    super(
+      `${filePath} uses ${conversion.fields.join(", ")}, which a credential block replaced. Rewrite it as:
+` + JSON.stringify(conversion.replacement, null, 2)
+    );
+    this.filePath = filePath;
+    this.conversion = conversion;
+    this.name = "LegacyProviderFileError";
+  }
+  filePath;
+  conversion;
 };
-var EXECUTE_BITS_MASK = 73;
-function listVersionsDir(dir) {
-  let entries;
-  try {
-    entries = import_node_fs6.default.readdirSync(dir, { withFileTypes: true });
-  } catch (error) {
-    if (isEnoent3(error)) {
-      return [];
-    }
-    throw error;
+function parseProviderFile(filePath, raw) {
+  const conversion = legacyProviderConversion(raw);
+  if (conversion !== void 0) {
+    throw new LegacyProviderFileError(filePath, conversion);
   }
-  return entries.filter((entry) => entry.isFile()).map((entry) => {
-    const fullPath = import_node_path22.default.join(dir, entry.name);
-    const stat = import_node_fs6.default.statSync(fullPath);
-    return {
-      name: entry.name,
-      isFile: true,
-      isExecutable: (stat.mode & EXECUTE_BITS_MASK) !== 0,
-      sizeBytes: stat.size
-    };
-  });
+  const parsed = ProviderSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new ConfigValidationError(filePath, parsed.error.issues);
+  }
+  return parsed.data;
 }
-var WINDOWS_DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.PS1";
-function windowsPathExtensions(pathext) {
-  return (pathext ?? WINDOWS_DEFAULT_PATHEXT).split(";").map((ext) => ext.trim()).filter((ext) => ext.length > 0);
+function readProvider(paths, name) {
+  const filePath = providerJsonPath(paths, name);
+  if (!import_node_fs6.default.existsSync(filePath)) {
+    return void 0;
+  }
+  const raw = JSON.parse(import_node_fs6.default.readFileSync(filePath, "utf8"));
+  return parseProviderFile(filePath, raw);
 }
-function resolveExecutableCandidate(dir, name, env) {
-  const candidate = import_node_path22.default.join(dir, name);
-  if (env.platform === "win32") {
-    const extensions = windowsPathExtensions(env.pathext);
-    const alreadyHasRecognisedExtension = extensions.some((ext) => candidate.toLowerCase().endsWith(ext.toLowerCase()));
-    if (alreadyHasRecognisedExtension) {
-      return env.statFileMode(candidate) !== void 0 ? candidate : void 0;
-    }
-    for (const ext of extensions) {
-      const withExt = candidate + ext;
-      if (env.statFileMode(withExt) !== void 0) {
-        return withExt;
+function loadProvider(providersDir, name, port) {
+  const filePath = import_node_path22.default.join(providersDir, `${name}.json`);
+  const raw = port.readConfigFile(filePath);
+  return raw === void 0 ? void 0 : parseProviderFile(filePath, raw);
+}
+function listProviders(paths) {
+  const names = listProviderNames(
+    (dir) => import_node_fs6.default.readdirSync(dir),
+    paths.providersDir
+  );
+  const result = [];
+  for (const name of names) {
+    let provider;
+    try {
+      provider = readProvider(paths, name);
+    } catch (error) {
+      if (!(error instanceof ConfigValidationError || error instanceof LegacyProviderFileError)) {
+        throw error;
       }
+      console.error(`agent-shim: providers/${name}.json is invalid and was skipped: ${error.message}`);
+      continue;
+    }
+    if (provider !== void 0) {
+      result.push({ name, provider });
     }
-    return void 0;
   }
-  const mode = env.statFileMode(candidate);
-  return mode !== void 0 && (mode & EXECUTE_BITS_MASK) !== 0 ? candidate : void 0;
+  return result;
 }
-function realStatFileMode(candidate) {
+function listProviderNames(readdir, providersDir) {
+  let entries;
   try {
-    const stat = import_node_fs6.default.statSync(candidate);
-    return stat.isFile() ? stat.mode : void 0;
-  } catch (error) {
-    if (isEnoent3(error)) {
-      return void 0;
-    }
-    throw error;
+    entries = readdir(providersDir);
+  } catch {
+    return [];
   }
+  return entries.filter((entry) => entry.endsWith(".json")).map((entry) => entry.slice(0, -".json".length)).sort();
 }
-function findExecutableInDir(dir, name) {
-  return resolveExecutableCandidate(dir, name, {
-    platform: process.platform,
-    pathext: process.env.PATHEXT,
-    statFileMode: realStatFileMode
-  });
+function describeProviderEndpoint(provider) {
+  return isCodexProvider(provider) ? "codex translation daemon" : provider.baseUrl;
 }
-function searchPathForExecutable(pathDirs, name, findExecutable) {
-  for (const dir of pathDirs) {
-    const found = findExecutable(dir, name);
-    if (found !== void 0) {
-      return found;
-    }
+var ProviderKindMismatchError = class extends UsageError {
+  constructor(message) {
+    super(message);
+    this.name = "ProviderKindMismatchError";
   }
-  return void 0;
+};
+function isEmptyCodexConfig(config) {
+  return config === void 0 || config.defaultModel === void 0 && config.effort === void 0 && config.login === void 0 && (config.models === void 0 || Object.keys(config.models).length === 0);
 }
-function resolveOwnExecutablePath(env) {
-  if (env.argv1 !== void 0 && !env.argv1.includes("/") && !env.argv1.includes("\\")) {
-    return searchPathForExecutable(env.pathDirs, env.argv1, env.findExecutableInDir) ?? env.execPath;
+function addProvider(paths, name, input) {
+  if (providerExists(paths, name)) {
+    throw new ProviderAlreadyExistsError(name);
   }
-  const candidate = env.argv1 === void 0 ? env.execPath : import_node_path22.default.resolve(env.cwd, env.argv1);
-  const candidateDir = import_node_path22.default.dirname(candidate);
-  const candidateDirOnPath = env.pathDirs.some((dir) => import_node_path22.default.resolve(dir) === candidateDir);
-  if (candidateDirOnPath) {
-    return candidate;
+  if (!PROVIDER_NAME_RE.test(name)) {
+    throw new InvalidProviderNameError(name);
   }
-  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path22.default.basename(candidate), env.findExecutableInDir);
-  return viaPath ?? candidate;
-}
-function realOwnExecutablePath() {
-  return resolveOwnExecutablePath({
-    argv1: process.argv[1],
-    execPath: process.execPath,
-    cwd: process.cwd(),
-    pathDirs: (process.env.PATH ?? "").split(import_node_path22.default.delimiter).filter((dir) => dir !== ""),
-    findExecutableInDir
-  });
+  const kind = input.kind ?? "http";
+  if (kind === "codex" && input.baseUrl !== void 0) {
+    throw new ProviderKindMismatchError("A codex provider has no base URL: the launcher points its sessions at the front-door daemon. Drop --base-url.");
+  }
+  if (kind === "http" && input.baseUrl === void 0) {
+    throw new ProviderKindMismatchError("An http provider needs --base-url.");
+  }
+  if (kind === "http" && !isEmptyCodexConfig(input.codex)) {
+    throw new ProviderKindMismatchError("Codex settings apply only to a codex provider (--kind codex).");
+  }
+  const shared = {
+    displayName: input.displayName,
+    credential: { sources: input.sources, ...input.target === void 0 ? {} : { target: input.target } },
+    ...input.env === void 0 || Object.keys(input.env).length === 0 ? {} : { env: input.env }
+  };
+  const parsed = ProviderSchema.safeParse(
+    kind === "codex" ? { kind, ...shared, ...isEmptyCodexConfig(input.codex) ? {} : { codex: input.codex } } : { ...shared, baseUrl: input.baseUrl }
+  );
+  if (!parsed.success) {
+    throw new ConfigValidationError(providerJsonPath(paths, name), parsed.error.issues);
+  }
+  writeJsonAtomic(providerJsonPath(paths, name), parsed.data);
+  return parsed.data;
 }
-function resolveContentSourcePath(env) {
-  return env.isSea ? env.execPath : env.argv1 ?? env.execPath;
+function updateProvider(paths, name, input) {
+  const existing = readProvider(paths, name);
+  if (existing === void 0) {
+    throw new ProviderNotFoundError(name);
+  }
+  const unset = new Set(input.unsetEnv);
+  const env = Object.fromEntries(Object.entries({ ...existing.env, ...input.env }).filter(([key]) => !unset.has(key)));
+  const target = input.target ?? existing.credential.target;
+  const cache = input.cache === void 0 ? existing.credential.cache : input.cache === false ? void 0 : input.cache;
+  if (isCodexProvider(existing) && input.baseUrl !== void 0) {
+    throw new ProviderKindMismatchError(`Provider "${name}" is a codex provider, which has no base URL.`);
+  }
+  if (!isCodexProvider(existing) && !isEmptyCodexConfig(input.codex)) {
+    throw new ProviderKindMismatchError(`Provider "${name}" is an http provider; codex settings apply only to a codex provider.`);
+  }
+  const shared = {
+    ...input.displayName === void 0 ? {} : { displayName: input.displayName },
+    credential: {
+      sources: input.sources ?? existing.credential.sources,
+      ...target === void 0 ? {} : { target },
+      ...cache === void 0 ? {} : { cache }
+    },
+    env: Object.keys(env).length === 0 ? void 0 : env
+  };
+  let candidate;
+  if (isCodexProvider(existing)) {
+    const codex = {
+      ...existing.codex,
+      ...input.codex,
+      ...existing.codex?.models === void 0 && input.codex?.models === void 0 ? {} : { models: { ...existing.codex?.models, ...input.codex?.models } }
+    };
+    candidate = { ...existing, ...shared, codex: isEmptyCodexConfig(codex) ? void 0 : codex };
+  } else {
+    candidate = { ...existing, ...shared, ...input.baseUrl === void 0 ? {} : { baseUrl: input.baseUrl } };
+  }
+  const parsed = ProviderSchema.safeParse(candidate);
+  if (!parsed.success) {
+    throw new ConfigValidationError(providerJsonPath(paths, name), parsed.error.issues);
+  }
+  writeJsonAtomic(providerJsonPath(paths, name), parsed.data);
+  return parsed.data;
 }
-function realContentSourcePath() {
-  return resolveContentSourcePath({ isSea: (0, import_node_sea.isSea)(), execPath: process.execPath, argv1: process.argv[1] });
+function removeProvider(paths, name) {
+  if (!providerExists(paths, name)) {
+    throw new ProviderNotFoundError(name);
+  }
+  import_node_fs6.default.rmSync(providerJsonPath(paths, name));
 }
-function realResolveClaudeBinary(isOwnBinary) {
-  return (request4) => discoverClaudeBinary({
-    listVersionsDir,
-    pathDirs: (process.env.PATH ?? "").split(import_node_path22.default.delimiter).filter((dir) => dir !== ""),
-    findExecutableInDir,
-    isOwnBinary,
-    ...request4?.version === void 0 ? {} : { version: request4.version }
-  });
+function cascadeProviderName(cascade) {
+  let name;
+  for (const layer of assembleCascade(cascade).layers) {
+    if (layer.launch?.provider !== void 0) {
+      name = layer.launch.provider;
+    }
+  }
+  return name;
 }
-function realInstalledClaudeVersions() {
-  return installedVersions(listVersionsDir(defaultVersionsDir()));
+function resolveProvider(params) {
+  const cliName = params.cliProvider !== void 0 && params.cliProvider !== "" ? params.cliProvider : void 0;
+  const name = cliName ?? (params.cascade === void 0 ? void 0 : cascadeProviderName(params.cascade));
+  if (name === void 0) {
+    return void 0;
+  }
+  const definition = loadProvider(params.paths.providersDir, name, params.port);
+  if (definition === void 0) {
+    const known = listProviderNames(params.port.readdir, params.paths.providersDir);
+    return {
+      ok: false,
+      status: 1,
+      message: `agent-shim: no provider named "${name}". ` + (known.length > 0 ? `Known providers: ${known.join(", ")}.` : "No providers are defined yet; run `agent-shim provider add`.")
+    };
+  }
+  if (params.credentials === void 0) {
+    return { ok: false, status: 1, message: `agent-shim: provider ${name} needs its credential resolved, but this launcher has no credential port wired` };
+  }
+  const resolution = resolveCredential({ credential: definition.credential, env: params.env, port: params.credentials, subject: `provider ${name}` });
+  if (!resolution.ok) {
+    return { ok: false, status: CREDENTIAL_UNAVAILABLE_EXIT, message: resolution.message };
+  }
+  return { ok: true, provider: { name, definition, credential: resolution.credential }, warnings: resolution.credential.warnings };
 }
 
 // src/checkReport.ts
@@ -9204,42 +9250,14 @@ function loadCheckProvider(paths, name) {
 }
 function collectCheckReport(params) {
   const { paths, cwd } = params;
-  const home = import_node_os4.default.homedir();
+  const home = import_node_os5.default.homedir();
   const claudeHome = resolveClaudeHome();
   const read = cosmiconfigReader();
   const classification = loadClassification(paths);
   const loaded = loadCascadeInput({ paths, home, cwd, read });
-  const selections = readDirectorySelections(loaded);
   const git = resolveGitBranch(realRunPort, cwd);
-  const decidedIdentity = decideIdentity({
-    env: params.env,
-    argv0Identity: params.identity,
-    directoryPinnedIdentity: selections.identity,
-    readActiveIdentityFile: () => {
-      const raw = realFsPort.readFileUtf8(paths.activeIdentityFile);
-      if (raw === void 0) {
-        return void 0;
-      }
-      const trimmed = raw.trim();
-      return trimmed === "" ? void 0 : trimmed;
-    }
-  });
-  let poolPick;
-  if (decidedIdentity.pool !== void 0) {
-    const pools = loaded.globalConfig?.pools ?? {};
-    if (pools[decidedIdentity.pool] === void 0) {
-      throw new PoolNotFoundError(decidedIdentity.pool);
-    }
-    poolPick = collectPoolPick({ paths, fs: realFsPort, usageFs: realFarmFs, poolName: decidedIdentity.pool, pools, directory: cwd, nowMs: Date.now() });
-  }
-  const identityDecision = poolPick?.pick === void 0 ? decidedIdentity : { ...decidedIdentity, name: poolPick.pick };
-  const loadedIdentity = identityDecision.name === void 0 ? void 0 : loadIdentity(paths.identitiesDir, identityDecision.name, realFsPort);
-  const configProfileDecision = decideConfigProfile({
-    env: params.env,
-    directoryRuleConfigProfile: selections.configProfile,
-    identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
-    globalDefaultConfigProfile: loaded.globalConfig?.defaultConfigProfile
-  });
+  const { selection, identityConfig } = selectLaunch({ paths, cwd, env: params.env, ...params.identity === void 0 ? {} : { identity: params.identity } }, loaded);
+  const { identity: identityDecision, poolPick, configProfile: configProfileDecision } = selection;
   const cascade = loadCascadeInput({
     paths,
     home,
@@ -9270,7 +9288,7 @@ function collectCheckReport(params) {
     ...poolPick === void 0 ? {} : { poolPick },
     ...configProfileDecision.name === void 0 ? {} : { configProfileName: configProfileDecision.name },
     configProfileSource: configProfileDecision.source,
-    ...loadedIdentity === void 0 ? {} : { identity: loadedIdentity.config },
+    ...identityConfig === void 0 ? {} : { identity: identityConfig },
     settingsFiles,
     run: realRunPort,
     credentialCache: realCredentialCacheEnv(paths),
@@ -13144,14 +13162,14 @@ function resolvePoolLaunch(params) {
 }
 
 // src/launcher/spawn.ts
-var import_node_os5 = __toESM(require("node:os"), 1);
+var import_node_os6 = __toESM(require("node:os"), 1);
 var SIGNAL_EXIT_CODE_OFFSET = 128;
 function exitCodeFor(result) {
   if (result.status !== null) {
     return result.status;
   }
   if (result.signal !== null) {
-    return SIGNAL_EXIT_CODE_OFFSET + import_node_os5.default.constants.signals[result.signal];
+    return SIGNAL_EXIT_CODE_OFFSET + import_node_os6.default.constants.signals[result.signal];
   }
   return 1;
 }
@@ -13552,7 +13570,7 @@ function runLauncher(params) {
 }
 
 // src/launchWiring.ts
-var import_node_os6 = __toESM(require("node:os"), 1);
+var import_node_os7 = __toESM(require("node:os"), 1);
 var import_node_crypto12 = require("node:crypto");
 
 // src/ownCli.ts
@@ -13717,7 +13735,7 @@ function realFrontDoorPort(paths, spawnDaemon) {
 
 // src/launchWiring.ts
 function buildFarmRuntime(paths, cwd) {
-  const home = import_node_os6.default.homedir();
+  const home = import_node_os7.default.homedir();
   const read = cosmiconfigReader();
   const classification = loadClassification(paths);
   const loaded = loadCascadeInput({ paths, home, cwd, read });
@@ -14054,6 +14072,7 @@ function prepareClaudeLaunch(options) {
   resolveAgentShimHome,
   resolveClaudeHome,
   resolveDecisions,
+  resolveLaunchSelection,
   resolveLayoutPaths,
   resolveSupervisorConfig,
   resyncFarm,