agent-shim 7.6.1 → 7.8.0

package/dist/index.cjs

@@ -42,6 +42,9 @@ __export(index_exports, {
   CredentialCacheSchema: () => CredentialCacheSchema,
   CredentialSchema: () => CredentialSchema,
   CredentialSourceSchema: () => CredentialSourceSchema,
+  DirectoryRuleAlreadyExistsError: () => DirectoryRuleAlreadyExistsError,
+  DirectoryRuleMissingTargetError: () => DirectoryRuleMissingTargetError,
+  DirectoryRuleNotFoundError: () => DirectoryRuleNotFoundError,
   DirectoryRuleSchema: () => DirectoryRuleSchema,
   DirectoryRulesSchema: () => DirectoryRulesSchema,
   EXIT_FAILURE: () => EXIT_FAILURE,
@@ -51,20 +54,38 @@ __export(index_exports, {
   FrontDoorStartError: () => FrontDoorStartError,
   GlobalConfigSchema: () => GlobalConfigSchema,
   HeadroomStartError: () => HeadroomStartError,
+  IdentityAlreadyExistsError: () => IdentityAlreadyExistsError,
+  IdentityNotFoundError: () => IdentityNotFoundError,
   IdentitySchema: () => IdentitySchema,
+  InvalidCategoryNameError: () => InvalidCategoryNameError,
+  InvalidIdentityNameError: () => InvalidIdentityNameError,
+  InvalidProviderNameError: () => InvalidProviderNameError,
+  LegacyProviderFileError: () => LegacyProviderFileError,
   PoolNameSchema: () => PoolNameSchema,
+  PoolNotFoundError: () => PoolNotFoundError,
   PoolSchema: () => PoolSchema,
   PortableConfigSchema: () => PortableConfigSchema,
+  ProfileAlreadyExistsError: () => ProfileAlreadyExistsError,
+  ProfileNotFoundError: () => ProfileNotFoundError,
+  ProviderAlreadyExistsError: () => ProviderAlreadyExistsError,
+  ProviderKindMismatchError: () => ProviderKindMismatchError,
+  ProviderNotFoundError: () => ProviderNotFoundError,
   ProviderSchema: () => ProviderSchema,
   ROUTED_PATH_PREFIX: () => ROUTED_PATH_PREFIX,
   UsageError: () => UsageError,
   UsageSnapshotError: () => UsageSnapshotError,
   UsageSnapshotSchema: () => UsageSnapshotSchema,
   WhenSchema: () => WhenSchema,
+  addDirectoryRule: () => addDirectoryRule,
+  addIdentity: () => addIdentity,
+  addPool: () => addPool,
+  addProvider: () => addProvider,
   buildEntryFacts: () => buildEntryFacts,
   buildLayoutPaths: () => buildLayoutPaths,
   carryOver: () => carryOver,
   createLeafCache: () => createLeafCache,
+  createProfile: () => createProfile,
+  describeProviderEndpoint: () => describeProviderEndpoint,
   detectAmbientCredential: () => detectAmbientCredential,
   ensureCa: () => ensureCa,
   ensureFrontDoor: () => ensureFrontDoor,
@@ -73,16 +94,37 @@ __export(index_exports, {
   formatAmbientCredentialGuardMessage: () => formatAmbientCredentialGuardMessage,
   forwardableHeaders: () => forwardableHeaders,
   generateCa: () => generateCa,
+  identityExists: () => identityExists,
+  isIdentityDirectoryName: () => isIdentityDirectoryName,
   isInterceptedHost: () => isInterceptedHost,
+  listDirectoryRules: () => listDirectoryRules,
+  listIdentities: () => listIdentities,
+  listProfiles: () => listProfiles,
+  listProviders: () => listProviders,
   listUsageSnapshots: () => listUsageSnapshots,
   mintLeaf: () => mintLeaf,
   parseConnectTarget: () => parseConnectTarget,
+  profileExists: () => profileExists,
+  providerExists: () => providerExists,
+  readActiveIdentity: () => readActiveIdentity,
+  readDirectoryRules: () => readDirectoryRules,
   readFarmManifest: () => readFarmManifest,
+  readGlobalConfig: () => readGlobalConfig,
+  readIdentity: () => readIdentity,
+  readPools: () => readPools,
+  readProfile: () => readProfile,
+  readProvider: () => readProvider,
   readUsageSnapshot: () => readUsageSnapshot,
   realConnectCertStore: () => realConnectCertStore,
   realConnectEffects: () => realConnectEffects,
   recoverFarm: () => recoverFarm,
   recoveryDiagnostics: () => recoveryDiagnostics,
+  removeDirectoryRule: () => removeDirectoryRule,
+  removeIdentity: () => removeIdentity,
+  removePool: () => removePool,
+  removeProfile: () => removeProfile,
+  removeProvider: () => removeProvider,
+  requirePool: () => requirePool,
   resolveAgentShimHome: () => resolveAgentShimHome,
   resolveClaudeHome: () => resolveClaudeHome,
   resolveDecisions: () => resolveDecisions,
@@ -92,9 +134,22 @@ __export(index_exports, {
   runFrontDoorSupervisor: () => runFrontDoorSupervisor,
   runSupervisor: () => runSupervisor,
   servedByPipeline: () => servedByPipeline,
+  setAllowAmbientCredential: () => setAllowAmbientCredential,
+  setDefaultConfigProfile: () => setDefaultConfigProfile,
+  setGlobalDefaultProfile: () => setGlobalDefaultProfile,
+  setIdentityCredential: () => setIdentityCredential,
+  setPool: () => setPool,
+  setProfileCategories: () => setProfileCategories,
+  setProfileEntries: () => setProfileEntries,
+  setProfileLaunchFlags: () => setProfileLaunchFlags,
+  setProfileMetadata: () => setProfileMetadata,
   snapshotPath: () => snapshotPath,
   startConnectServer: () => startConnectServer,
-  topLevelNames: () => topLevelNames
+  topLevelNames: () => topLevelNames,
+  updateDirectoryRule: () => updateDirectoryRule,
+  updateProvider: () => updateProvider,
+  useIdentity: () => useIdentity,
+  writeDirectoryRules: () => writeDirectoryRules
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -343,6 +398,11 @@ var SHIPPED_CATEGORY_DEFAULTS = Object.freeze({
   settings: true
 });
 
+// src/config/store.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_crypto = require("node:crypto");
+
 // src/config/load.ts
 var import_cosmiconfig = require("cosmiconfig");
 
@@ -361,6 +421,98 @@ var UsageError = class extends CliError {
   }
 };
 
+// src/config/load.ts
+var ConfigValidationError = class extends CliError {
+  constructor(filepath, issues) {
+    const detail = issues.map((issue) => `  ${issue.path.join(".") || "(root)"}: ${issue.message}`).join("\n");
+    super(`Invalid configuration in ${filepath}:
+${detail}`);
+    this.filepath = filepath;
+    this.issues = issues;
+    this.name = "ConfigValidationError";
+  }
+  filepath;
+  issues;
+};
+
+// src/config/store.ts
+function isEnoent(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+var nodeStoreFs = {
+  readFileUtf8(filePath) {
+    try {
+      return import_node_fs.default.readFileSync(filePath, "utf8");
+    } catch (error) {
+      if (isEnoent(error)) {
+        return void 0;
+      }
+      throw error;
+    }
+  },
+  writeFileUtf8(filePath, contents) {
+    import_node_fs.default.writeFileSync(filePath, contents, "utf8");
+  },
+  renameSync(from, to) {
+    import_node_fs.default.renameSync(from, to);
+  },
+  mkdirSync(dirPath) {
+    import_node_fs.default.mkdirSync(dirPath, { recursive: true });
+  },
+  unlinkSync(filePath) {
+    try {
+      import_node_fs.default.unlinkSync(filePath);
+    } catch (error) {
+      if (!isEnoent(error)) {
+        throw error;
+      }
+    }
+  }
+};
+function readJson(filePath, schema, storeFs = nodeStoreFs) {
+  const raw = storeFs.readFileUtf8(filePath);
+  if (raw === void 0) {
+    return void 0;
+  }
+  const parsed = JSON.parse(raw);
+  const result = schema.safeParse(parsed);
+  if (!result.success) {
+    throw new ConfigValidationError(filePath, result.error.issues);
+  }
+  return result.data;
+}
+function writeTextAtomic(filePath, contents, storeFs = nodeStoreFs) {
+  const dir = import_node_path2.default.dirname(filePath);
+  storeFs.mkdirSync(dir);
+  const tempPath = import_node_path2.default.join(dir, `.${import_node_path2.default.basename(filePath)}.${String(process.pid)}.${(0, import_node_crypto.randomUUID)()}.tmp`);
+  storeFs.writeFileUtf8(tempPath, contents);
+  try {
+    storeFs.renameSync(tempPath, filePath);
+  } catch (error) {
+    storeFs.unlinkSync(tempPath);
+    throw error;
+  }
+}
+function writeJsonAtomic(filePath, data, storeFs = nodeStoreFs) {
+  writeTextAtomic(filePath, `${JSON.stringify(data, null, 2)}
+`, storeFs);
+}
+function applyPatch(filePath, schema, patch, options = {}) {
+  const storeFs = options.storeFs ?? nodeStoreFs;
+  const existing = readJson(filePath, schema, storeFs) ?? options.defaults;
+  if (existing === void 0) {
+    throw new Error(`Cannot patch ${filePath}: it does not exist yet and no defaults were provided.`);
+  }
+  const merged = { ...existing, ...patch };
+  const result = schema.safeParse(merged);
+  if (!result.success) {
+    throw new ConfigValidationError(filePath, result.error.issues);
+  }
+  const validated = result.data;
+  writeJsonAtomic(filePath, validated, storeFs);
+  return validated;
+}
+
 // src/config/classify.ts
 var GLOB_METACHARACTERS = /[*?[\]{}!()]/;
 function isExactPattern(pattern) {
@@ -952,7 +1104,7 @@ function dedupeDiagnostics(diagnostics) {
 }
 
 // src/resolve/plan.ts
-var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
 function parentOf(rel) {
   const index = rel.lastIndexOf("/");
   return index === -1 ? "" : rel.slice(0, index);
@@ -1002,7 +1154,7 @@ function planFarm(params) {
     }
     return value;
   };
-  const linkTarget = (rel) => import_node_path2.default.join(params.facts.claudeHome, rel);
+  const linkTarget = (rel) => import_node_path3.default.join(params.facts.claudeHome, rel);
   const visit = (rel) => {
     const fact = params.facts.entries.get(rel);
     const decision = params.decisions.get(rel);
@@ -1226,7 +1378,7 @@ function resolveDecisions(input) {
 }
 
 // src/launcher/farm.ts
-var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
 var import_zod2 = require("zod");
 
 // src/resolve/reconcile.ts
@@ -1325,8 +1477,8 @@ var LEGACY_HOME_DIRNAME = ".claude-use";
 var LEGACY_FARM_MANIFEST_FILENAME = ".claude-use-farm.json";
 
 // src/launcher/lock.ts
-var import_node_crypto = require("node:crypto");
-var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_crypto2 = require("node:crypto");
+var import_node_path4 = __toESM(require("node:path"), 1);
 var DEFAULT_STALE_AFTER_MS = 12e4;
 var DEFAULT_RETRY_DELAY_MS = 50;
 var DEFAULT_MAX_ATTEMPTS = 200;
@@ -1345,7 +1497,7 @@ var IdentityLockBusyError = class extends CliError {
   holderPid;
 };
 function identityLockPath(dir, identity) {
-  return import_node_path3.default.join(dir, `.${identity}.lock`);
+  return import_node_path4.default.join(dir, `.${identity}.lock`);
 }
 function parseLockRecord(raw) {
   if (raw === void 0) {
@@ -1374,7 +1526,7 @@ function acquireIdentityLock(params) {
   const staleAfterMs = params.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
   const retryDelayMs = params.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
   const maxAttempts = params.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-  const token = (0, import_node_crypto.randomUUID)();
+  const token = (0, import_node_crypto2.randomUUID)();
   if (params.fs.lstat(params.dir) === void 0) {
     params.fs.mkdirp(params.dir);
   }
@@ -1423,8 +1575,8 @@ var FarmManifestSchema = import_zod2.z.strictObject({
   materialised: import_zod2.z.array(import_zod2.z.string()),
   links: import_zod2.z.array(import_zod2.z.strictObject({ rel: import_zod2.z.string(), target: import_zod2.z.string() }))
 });
-function readFarmManifest(fs3, farmRoot) {
-  const raw = fs3.readFileUtf8(import_node_path4.default.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs3.readFileUtf8(import_node_path4.default.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
+function readFarmManifest(fs7, farmRoot) {
+  const raw = fs7.readFileUtf8(import_node_path5.default.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs7.readFileUtf8(import_node_path5.default.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
   if (raw === void 0) {
     return void 0;
   }
@@ -1440,7 +1592,7 @@ function readFarmManifest(fs3, farmRoot) {
 function buildEntryFacts(params) {
   const entries = /* @__PURE__ */ new Map();
   const visit = (rel) => {
-    const absolute = import_node_path4.default.join(params.claudeHome, rel);
+    const absolute = import_node_path5.default.join(params.claudeHome, rel);
     const stat = params.fs.lstat(absolute);
     if (stat === void 0) {
       return void 0;
@@ -1482,9 +1634,9 @@ function buildEntryFacts(params) {
     entries
   };
 }
-function listSubtree(fs3, root, rel) {
-  const absolute = import_node_path4.default.join(root, rel);
-  const stat = fs3.lstat(absolute);
+function listSubtree(fs7, root, rel) {
+  const absolute = import_node_path5.default.join(root, rel);
+  const stat = fs7.lstat(absolute);
   if (stat === void 0) {
     return [];
   }
@@ -1492,10 +1644,10 @@ function listSubtree(fs3, root, rel) {
     return [{ rel, kind: "symlink" }];
   }
   if (stat.kind === "dir") {
-    const children = [...fs3.readdir(absolute)].sort().flatMap((name) => listSubtree(fs3, root, `${rel}/${name}`));
+    const children = [...fs7.readdir(absolute)].sort().flatMap((name) => listSubtree(fs7, root, `${rel}/${name}`));
     return [{ rel, kind: "dir" }, ...children];
   }
-  const contentHash = fs3.hashFile(absolute);
+  const contentHash = fs7.hashFile(absolute);
   return [{ rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } }];
 }
 function topLevelScopeRoots(roots) {
@@ -1509,25 +1661,25 @@ function topLevelScopeRoots(roots) {
   }
   return kept;
 }
-function reconciliationScope(fs3, farmRoot, manifest) {
+function reconciliationScope(fs7, farmRoot, manifest) {
   if (manifest !== void 0) {
     return topLevelScopeRoots(manifest.materialised);
   }
-  return [...fs3.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs3.lstat(import_node_path4.default.join(farmRoot, name))?.kind === "dir").sort();
+  return [...fs7.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs7.lstat(import_node_path5.default.join(farmRoot, name))?.kind === "dir").sort();
 }
-function collectFarmListing(fs3, farmRoot, scopeRoots) {
-  return scopeRoots.flatMap((root) => listSubtree(fs3, farmRoot, root));
+function collectFarmListing(fs7, farmRoot, scopeRoots) {
+  return scopeRoots.flatMap((root) => listSubtree(fs7, farmRoot, root));
 }
-function collectCanonicalCounterparts(fs3, claudeHome, farmListing) {
+function collectCanonicalCounterparts(fs7, claudeHome, farmListing) {
   const out = [];
   for (const entry of farmListing) {
-    const absolute = import_node_path4.default.join(claudeHome, entry.rel);
-    const stat = fs3.lstat(absolute);
+    const absolute = import_node_path5.default.join(claudeHome, entry.rel);
+    const stat = fs7.lstat(absolute);
     if (stat === void 0) {
       continue;
     }
     if (stat.kind === "file") {
-      const contentHash = fs3.hashFile(absolute);
+      const contentHash = fs7.hashFile(absolute);
       out.push({ rel: entry.rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } });
       continue;
     }
@@ -1551,21 +1703,21 @@ function carryOver(params) {
     if (accounted.has(name)) {
       continue;
     }
-    const stat = params.fs.lstat(import_node_path4.default.join(params.previousRoot, name));
+    const stat = params.fs.lstat(import_node_path5.default.join(params.previousRoot, name));
     if (stat === void 0 || stat.kind === "symlink") {
       continue;
     }
-    if (params.fs.lstat(import_node_path4.default.join(params.farmRoot, name)) !== void 0) {
+    if (params.fs.lstat(import_node_path5.default.join(params.farmRoot, name)) !== void 0) {
       const category = params.classification === void 0 ? void 0 : classifyEntries([name], params.classification).classification.get(name);
       if (category === "runtime") {
-        params.fs.removeRecursive(import_node_path4.default.join(params.previousRoot, name));
+        params.fs.removeRecursive(import_node_path5.default.join(params.previousRoot, name));
         autoResolved.push(name);
         continue;
       }
       collided.push(name);
       continue;
     }
-    params.fs.rename(import_node_path4.default.join(params.previousRoot, name), import_node_path4.default.join(params.farmRoot, name));
+    params.fs.rename(import_node_path5.default.join(params.previousRoot, name), import_node_path5.default.join(params.farmRoot, name));
     carried.push(name);
   }
   return { carried, autoResolved, collided };
@@ -1573,9 +1725,9 @@ function carryOver(params) {
 function buildScratchTree(params) {
   params.fs.mkdirp(params.scratchRoot);
   for (const entry of params.plan.entries) {
-    const absolute = import_node_path4.default.join(params.scratchRoot, entry.rel);
+    const absolute = import_node_path5.default.join(params.scratchRoot, entry.rel);
     if (entry.kind === "link") {
-      params.fs.mkdirp(import_node_path4.default.dirname(absolute));
+      params.fs.mkdirp(import_node_path5.default.dirname(absolute));
       params.fs.symlink(entry.target, absolute);
       continue;
     }
@@ -1584,14 +1736,14 @@ function buildScratchTree(params) {
     }
   }
   params.fs.writeFileUtf8(
-    import_node_path4.default.join(params.scratchRoot, FARM_MANIFEST_FILENAME),
+    import_node_path5.default.join(params.scratchRoot, FARM_MANIFEST_FILENAME),
     `${JSON.stringify(params.manifest, null, 2)}
 `
   );
 }
 function swapIn(params) {
   if (params.fs.lstat(params.farmRoot) === void 0) {
-    params.fs.mkdirp(import_node_path4.default.dirname(params.farmRoot));
+    params.fs.mkdirp(import_node_path5.default.dirname(params.farmRoot));
     params.fs.rename(params.scratchRoot, params.farmRoot);
     return { carried: [], autoResolved: [], collided: [] };
   }
@@ -1615,14 +1767,14 @@ function recoverInterruptedSwap(params) {
   const names = [...params.fs.readdir(params.identitiesDir)].sort();
   const removedScratch = [];
   for (const name of names.filter((candidate) => candidate.startsWith(scratchPrefix))) {
-    params.fs.removeRecursive(import_node_path4.default.join(params.identitiesDir, name));
+    params.fs.removeRecursive(import_node_path5.default.join(params.identitiesDir, name));
     removedScratch.push(name);
   }
   let previous = names.filter((candidate) => candidate.startsWith(previousPrefix));
   let restoredFrom;
   const first = previous[0];
   if (first !== void 0 && params.fs.lstat(params.farmRoot) === void 0) {
-    params.fs.rename(import_node_path4.default.join(params.identitiesDir, first), params.farmRoot);
+    params.fs.rename(import_node_path5.default.join(params.identitiesDir, first), params.farmRoot);
     restoredFrom = first;
     previous = previous.slice(1);
   }
@@ -1630,7 +1782,7 @@ function recoverInterruptedSwap(params) {
   const autoResolved = [];
   const retained = [];
   for (const name of previous) {
-    const previousRoot = import_node_path4.default.join(params.identitiesDir, name);
+    const previousRoot = import_node_path5.default.join(params.identitiesDir, name);
     const result = carryOver({
       fs: params.fs,
       previousRoot,
@@ -1655,7 +1807,7 @@ function recoverInterruptedSwap(params) {
   };
 }
 function recoverFarm(params) {
-  const farmRoot = import_node_path4.default.join(params.identitiesDir, params.identity);
+  const farmRoot = import_node_path5.default.join(params.identitiesDir, params.identity);
   const lock = acquireIdentityLock({
     identity: params.identity,
     dir: params.identitiesDir,
@@ -1714,16 +1866,16 @@ function executeReconciliation(params) {
       });
       continue;
     }
-    const from = import_node_path4.default.join(params.farmRoot, action.rel);
-    const canonical = import_node_path4.default.join(params.claudeHome, action.rel);
+    const from = import_node_path5.default.join(params.farmRoot, action.rel);
+    const canonical = import_node_path5.default.join(params.claudeHome, action.rel);
     if (action.kind === "adopt") {
-      params.fs.mkdirp(import_node_path4.default.dirname(canonical));
+      params.fs.mkdirp(import_node_path5.default.dirname(canonical));
       params.fs.copyRecursive(from, canonical);
       adopted.push(action.rel);
       continue;
     }
     const preserved = `${canonical}.farm-conflict-${String(params.nowMs)}`;
-    params.fs.mkdirp(import_node_path4.default.dirname(canonical));
+    params.fs.mkdirp(import_node_path5.default.dirname(canonical));
     params.fs.copyRecursive(from, preserved);
     conflicts.push(action.rel);
   }
@@ -1748,7 +1900,7 @@ function farmAlreadyMatches(existing, next) {
   return existing.identity === next.identity && existing.claudeHome === next.claudeHome && sameStrings(existing.materialised, next.materialised) && sameLinks(existing.links, next.links);
 }
 function resyncFarm(params) {
-  const farmRoot = import_node_path4.default.join(params.identitiesDir, params.identity);
+  const farmRoot = import_node_path5.default.join(params.identitiesDir, params.identity);
   const lock = acquireIdentityLock({
     identity: params.identity,
     dir: params.identitiesDir,
@@ -1827,8 +1979,8 @@ function resyncFarm(params) {
         diagnostics
       };
     }
-    const scratchRoot = import_node_path4.default.join(params.identitiesDir, `.${params.identity}.scratch.${params.uniqueSuffix}`);
-    const previousRoot = import_node_path4.default.join(params.identitiesDir, `.${params.identity}.previous.${params.uniqueSuffix}`);
+    const scratchRoot = import_node_path5.default.join(params.identitiesDir, `.${params.identity}.scratch.${params.uniqueSuffix}`);
+    const previousRoot = import_node_path5.default.join(params.identitiesDir, `.${params.identity}.previous.${params.uniqueSuffix}`);
     buildScratchTree({ fs: params.fs, scratchRoot, plan: resolved.farm, manifest });
     const swap = swapIn({ fs: params.fs, farmRoot, scratchRoot, previousRoot, classification: params.classification });
     if (swap.retainedPrevious !== void 0) {
@@ -1885,11 +2037,11 @@ function recoveryDiagnostics(recovery, identity) {
 }
 
 // src/frontdoor/connect.ts
-var import_node_crypto3 = require("node:crypto");
-var fs = __toESM(require("node:fs"), 1);
+var import_node_crypto4 = require("node:crypto");
+var fs2 = __toESM(require("node:fs"), 1);
 
 // src/frontdoor/x509.ts
-var import_node_crypto2 = require("node:crypto");
+var import_node_crypto3 = require("node:crypto");
 var import_node_net = __toESM(require("node:net"), 1);
 var TAG_BOOLEAN = 1;
 var TAG_INTEGER = 2;
@@ -2041,7 +2193,7 @@ function ipBytes(address) {
   return bytes;
 }
 function keyIdentifier(publicKey) {
-  return (0, import_node_crypto2.createHash)("sha1").update(publicKey.export({ type: "pkcs1", format: "der" })).digest();
+  return (0, import_node_crypto3.createHash)("sha1").update(publicKey.export({ type: "pkcs1", format: "der" })).digest();
 }
 function readElement(buffer, offset) {
   const tag = buffer[offset];
@@ -2087,7 +2239,7 @@ ${body.join("\n")}
 `;
 }
 function randomSerial() {
-  const bytes = (0, import_node_crypto2.randomBytes)(SERIAL_NUMBER_BYTES);
+  const bytes = (0, import_node_crypto3.randomBytes)(SERIAL_NUMBER_BYTES);
   bytes[0] = (bytes[0] ?? 0) & BASE_128_PAYLOAD_MASK | HIGH_BIT >> 1;
   return bytes;
 }
@@ -2102,7 +2254,7 @@ function assemble(spec) {
     spec.subjectPublicKey.export({ type: "spki", format: "der" }),
     tlv(TAG_EXTENSIONS, sequence(...spec.extensions))
   );
-  const signature = (0, import_node_crypto2.sign)("sha256", tbs, spec.signingKey);
+  const signature = (0, import_node_crypto3.sign)("sha256", tbs, spec.signingKey);
   return sequence(tbs, SIGNATURE_ALGORITHM, wholeBitString(signature));
 }
 function subjectKeyIdentifierExtension(publicKey) {
@@ -2112,7 +2264,7 @@ function basicConstraintsExtension(isCa) {
   return extension(OID_BASIC_CONSTRAINTS, true, sequence(...isCa ? [boolean(true)] : []));
 }
 function rsaKeyPair() {
-  return (0, import_node_crypto2.generateKeyPairSync)("rsa", { modulusLength: RSA_MODULUS_BITS });
+  return (0, import_node_crypto3.generateKeyPairSync)("rsa", { modulusLength: RSA_MODULUS_BITS });
 }
 function keyPem(privateKey) {
   return privateKey.export({ type: "pkcs8", format: "pem" });
@@ -2136,8 +2288,8 @@ function issueLeafCertificate(ca, names, notBefore, notAfter) {
   if (commonName === void 0) {
     throw new Error("a leaf certificate needs at least one name");
   }
-  const caCertificate = new import_node_crypto2.X509Certificate(ca.certPem);
-  const caPrivateKey = (0, import_node_crypto2.createPrivateKey)(ca.keyPem);
+  const caCertificate = new import_node_crypto3.X509Certificate(ca.certPem);
+  const caPrivateKey = (0, import_node_crypto3.createPrivateKey)(ca.keyPem);
   const { publicKey, privateKey } = rsaKeyPair();
   const generalNames = names.map((name) => import_node_net.default.isIP(name) === 0 ? tlv(TAG_GENERAL_NAME_DNS, Buffer.from(name, "ascii")) : tlv(TAG_GENERAL_NAME_IP, ipBytes(name)));
   const der = assemble({
@@ -2160,7 +2312,7 @@ function issueLeafCertificate(ca, names, notBefore, notAfter) {
 }
 
 // src/frontdoor/tap.ts
-function pumpTapSession(secure, openUpstream, tap) {
+function pumpTapSession(secure, openUpstream, tap, prefix = Buffer.alloc(0)) {
   let upstream;
   let ended = false;
   const end = () => {
@@ -2192,6 +2344,9 @@ function pumpTapSession(secure, openUpstream, tap) {
       upstream.destroy();
       return;
     }
+    if (prefix.length > 0) {
+      upstream.write(prefix);
+    }
     if (tap !== void 0) {
       secure.on("data", (chunk) => {
         tap.onChunk("client-to-server", chunk);
@@ -2225,8 +2380,11 @@ function capabilityFromProxyAuthorization(value) {
   return password === "" ? void 0 : password;
 }
 
+// src/frontdoor/route.ts
+var AUTH_HEADER = "x-agent-shim-auth";
+
 // src/frontdoor/state.ts
-var import_node_path5 = __toESM(require("node:path"), 1);
+var import_node_path6 = __toESM(require("node:path"), 1);
 var import_zod3 = require("zod");
 var FRONT_DOOR_PROTOCOL = 1;
 var FrontDoorSessionSchema = import_zod3.z.strictObject({ pid: import_zod3.z.number().int().positive(), startedAt: import_zod3.z.number(), token: import_zod3.z.string().min(1) });
@@ -2260,10 +2418,10 @@ var FrontDoorStateSchema = import_zod3.z.strictObject({
   /** The last fatal error, kept across shutdowns so `frontdoor status` can explain a front door that is not running. */
   lastError: import_zod3.z.string().optional()
 });
-function readFrontDoorState(fs3, stateFile) {
+function readFrontDoorState(fs7, stateFile) {
   let raw;
   try {
-    raw = fs3.readFileUtf8(stateFile);
+    raw = fs7.readFileUtf8(stateFile);
   } catch {
     return void 0;
   }
@@ -2277,28 +2435,28 @@ function readFrontDoorState(fs3, stateFile) {
     return void 0;
   }
 }
-function writeFrontDoorState(fs3, stateFile, state) {
-  fs3.mkdirp(import_node_path5.default.dirname(stateFile));
-  fs3.writeFileUtf8(stateFile, `${JSON.stringify(state, null, 2)}
+function writeFrontDoorState(fs7, stateFile, state) {
+  fs7.mkdirp(import_node_path6.default.dirname(stateFile));
+  fs7.writeFileUtf8(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
 function frontDoorOrigin(state) {
   const port = state?.directPort ?? state?.lastDirectPort;
   return port === void 0 ? void 0 : `http://127.0.0.1:${String(port)}`;
 }
-function writeFrontDoorSession(fs3, sessionsDir, session) {
-  fs3.mkdirPrivate(sessionsDir);
-  fs3.writeFilePrivate(import_node_path5.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeFrontDoorSession(fs7, sessionsDir, session) {
+  fs7.mkdirPrivate(sessionsDir);
+  fs7.writeFilePrivate(import_node_path6.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function listFrontDoorSessions(fs3, sessionsDir) {
+function listFrontDoorSessions(fs7, sessionsDir) {
   const sessions = [];
-  for (const name of fs3.readdir(sessionsDir)) {
+  for (const name of fs7.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs3.readFileUtf8(import_node_path5.default.join(sessionsDir, name)) ?? ""));
+      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs7.readFileUtf8(import_node_path6.default.join(sessionsDir, name)) ?? ""));
       if (parsed.success) {
         sessions.push({ pid: parsed.data.pid, startedAt: parsed.data.startedAt });
       }
@@ -2308,14 +2466,14 @@ function listFrontDoorSessions(fs3, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
-function removeFrontDoorSession(fs3, sessionsDir, pid) {
-  fs3.removeRecursive(import_node_path5.default.join(sessionsDir, `${String(pid)}.json`));
+function removeFrontDoorSession(fs7, sessionsDir, pid) {
+  fs7.removeRecursive(import_node_path6.default.join(sessionsDir, `${String(pid)}.json`));
 }
-function pruneDeadFrontDoorSessions(fs3, sessionsDir, isRunning) {
+function pruneDeadFrontDoorSessions(fs7, sessionsDir, isRunning) {
   const removed = [];
-  for (const session of listFrontDoorSessions(fs3, sessionsDir)) {
+  for (const session of listFrontDoorSessions(fs7, sessionsDir)) {
     if (!isRunning(session.pid)) {
-      removeFrontDoorSession(fs3, sessionsDir, session.pid);
+      removeFrontDoorSession(fs7, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
@@ -2327,8 +2485,8 @@ var FRONTDOOR_SUPERVISOR_STILL_RUNNING = -1;
 var FRONTDOOR_POLL_MS = 1e3;
 var MS_PER_MINUTE = 6e4;
 async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {}) {
-  const { fs: fs3, paths } = ports;
-  const previous = readFrontDoorState(fs3, paths.frontdoorStateFile);
+  const { fs: fs7, paths } = ports;
+  const previous = readFrontDoorState(fs7, paths.frontdoorStateFile);
   let lastPort = previous?.lastPort;
   let lastConnectPort = previous?.lastConnectPort;
   let lastDirectPort = previous?.lastDirectPort;
@@ -2338,12 +2496,12 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     ...lastDirectPort === void 0 ? {} : { lastDirectPort }
   });
   const fail = (message) => {
-    writeFrontDoorState(fs3, paths.frontdoorStateFile, { lastError: message, ...sticky() });
-    fs3.removeRecursive(paths.frontdoorLockFile);
+    writeFrontDoorState(fs7, paths.frontdoorStateFile, { lastError: message, ...sticky() });
+    fs7.removeRecursive(paths.frontdoorLockFile);
     ports.log(`agent-shim frontdoor supervisor: ${message}`);
     return 1;
   };
-  writeFrontDoorState(fs3, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
+  writeFrontDoorState(fs7, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
   const previousSticky = lastPort;
   let http2;
   try {
@@ -2380,8 +2538,8 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     ports.log(`agent-shim frontdoor supervisor: sticky direct port ${String(previousStickyDirect)} was occupied; moving to ${String(direct.port)} (headroom must be restarted to admit the new address)`);
   }
   lastDirectPort = direct.port;
-  writeFrontDoorState(fs3, paths.frontdoorStateFile, { protocol: FRONT_DOOR_PROTOCOL, supervisorPid: ports.ownPid, port: http2.port, connectPort: connect3.port, directPort: direct.port, ...sticky() });
-  fs3.removeRecursive(paths.frontdoorLockFile);
+  writeFrontDoorState(fs7, paths.frontdoorStateFile, { protocol: FRONT_DOOR_PROTOCOL, supervisorPid: ports.ownPid, port: http2.port, connectPort: connect3.port, directPort: direct.port, ...sticky() });
+  fs7.removeRecursive(paths.frontdoorLockFile);
   ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: front door on 127.0.0.1:${String(http2.port)}, CONNECT surface on 127.0.0.1:${String(connect3.port)}`);
   let idleSince;
   let ticks = 0;
@@ -2390,15 +2548,15 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
       return FRONTDOOR_SUPERVISOR_STILL_RUNNING;
     }
     ticks += 1;
-    pruneDeadFrontDoorSessions(fs3, paths.frontdoorSessionsDir, ports.isRunning);
-    if (listFrontDoorSessions(fs3, paths.frontdoorSessionsDir).length === 0) {
+    pruneDeadFrontDoorSessions(fs7, paths.frontdoorSessionsDir, ports.isRunning);
+    if (listFrontDoorSessions(fs7, paths.frontdoorSessionsDir).length === 0) {
       idleSince ??= ports.now();
       if (ports.now() - idleSince >= idleShutdownMinutes * MS_PER_MINUTE) {
         ports.log(`agent-shim frontdoor supervisor: no sessions for ${String(idleShutdownMinutes)} minute(s); closing the front door and exiting`);
         await direct.close();
         await connect3.close();
         await http2.close();
-        writeFrontDoorState(fs3, paths.frontdoorStateFile, sticky());
+        writeFrontDoorState(fs7, paths.frontdoorStateFile, sticky());
         return 0;
       }
     } else {
@@ -2453,8 +2611,8 @@ function parseConnectTarget(authority) {
 function isInterceptedHost(host, interceptHosts) {
   return interceptHosts.includes(host);
 }
-function servedByPipeline(path9) {
-  return path9?.startsWith(ROUTED_PATH_PREFIX) === true;
+function servedByPipeline(path13) {
+  return path13?.startsWith(ROUTED_PATH_PREFIX) === true;
 }
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
@@ -2513,8 +2671,8 @@ function ensureCa(store, generate) {
 }
 function caParses(ca) {
   try {
-    new import_node_crypto3.X509Certificate(ca.certPem);
-    (0, import_node_crypto3.createPrivateKey)(ca.keyPem);
+    new import_node_crypto4.X509Certificate(ca.certPem);
+    (0, import_node_crypto4.createPrivateKey)(ca.keyPem);
     return true;
   } catch {
     return false;
@@ -2522,7 +2680,19 @@ function caParses(ca) {
 }
 var TAP_ALPN_PROTOCOLS = ["h2", "http/1.1"];
 async function startConnectServer(config, effects, preferredPort) {
-  const onUpgrade = config.capture === void 0 ? void 0 : (request3) => config.capture?.upgrade(request3);
+  const tunnelTokens = /* @__PURE__ */ new WeakMap();
+  const onUpgrade = (host) => (request3, socket, head) => {
+    config.capture?.upgrade(request3);
+    if (head.length > 0) {
+      socket.pause();
+      socket.unshift(head);
+    }
+    const headText = `${request3.method ?? "GET"} ${request3.url ?? "/"} HTTP/1.1\r
+${request3.rawHeaders.reduce((accumulated, value, index) => index % 2 === 0 ? `${accumulated}${value}: ` : `${accumulated}${value}\r
+`, "")}\r
+`;
+    pumpTapSession(socket, async (clientAlpn) => await effects.connectTlsUpstream(host, HTTPS_PORT, clientAlpn), void 0, Buffer.from(headText, "utf8"));
+  };
   const sessions = config.interceptHosts.map((host) => {
     if (config.tapHosts.includes(host)) {
       const tlsAcceptor2 = effects.createTlsAcceptor(
@@ -2536,13 +2706,18 @@ async function startConnectServer(config, effects, preferredPort) {
     }
     const handler = (request3, response) => {
       if (host === config.routedHost && servedByPipeline(request3.url)) {
+        const tunnelToken = tunnelTokens.get(request3.socket);
+        if (tunnelToken !== void 0 && request3.headers[AUTH_HEADER] === void 0) {
+          request3.headers[AUTH_HEADER] = tunnelToken;
+        }
         config.serveRouted(request3, response);
         return;
       }
       effects.forwardHttp(config.upstreamFor(host), request3, response, config.capture?.observePassthrough(request3));
     };
-    const httpSession = effects.createHttpSession(handler, onUpgrade);
-    const tlsAcceptor = effects.createTlsAcceptor(config.leafFor(host), (secure) => {
+    const httpSession = effects.createHttpSession(handler, onUpgrade(host));
+    const tlsAcceptor = effects.createTlsAcceptor(config.leafFor(host), (secure, context) => {
+      tunnelTokens.set(secure, context);
       httpSession.serve(secure);
     });
     return { host, httpSession, tlsAcceptor };
@@ -2683,6 +2858,7 @@ function routeConnect(socket, head, context) {
   const credential = proxyAuthorizationOf(head);
   const capability = credential === void 0 ? void 0 : capabilityFromProxyAuthorization(credential);
   if (capability === void 0 || !config.isLiveCapability(capability)) {
+    console.error(`[upg-dbg] refused CONNECT to ${head.split("\r\n", 1)[0]?.split(" ")[1] ?? "?"} (credential ${credential === void 0 ? "absent" : "present but dead"})`);
     refuse(socket, REFUSAL.proxyAuthenticationRequired, [`Proxy-Authenticate: Basic realm="${CONNECT_PROXY_REALM}"`]);
     return;
   }
@@ -2702,7 +2878,7 @@ function routeConnect(socket, head, context) {
   config.capture?.connect(target, session !== void 0);
   socket.write(CONNECT_ESTABLISHED);
   if (session !== void 0) {
-    session.tlsAcceptor.accept(socket);
+    session.tlsAcceptor.accept(socket, capability);
     return;
   }
   void blindTunnel(socket, target, effects);
@@ -2734,15 +2910,15 @@ async function blindTunnel(socket, target, effects) {
     socket.destroy();
   });
 }
-function isEnoent(error) {
+function isEnoent2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function realConnectCertStore(paths) {
   const read = (file) => {
     try {
-      return fs.readFileSync(file, "utf8");
+      return fs2.readFileSync(file, "utf8");
     } catch (error) {
-      if (isEnoent(error)) {
+      if (isEnoent2(error)) {
         return void 0;
       }
       throw error;
@@ -2755,10 +2931,10 @@ function realConnectCertStore(paths) {
       return certPem === void 0 || keyPem2 === void 0 ? void 0 : { certPem, keyPem: keyPem2 };
     },
     writeCa: (ca) => {
-      fs.mkdirSync(paths.frontdoorCaDir, { recursive: true });
-      fs.writeFileSync(paths.frontdoorCaCertFile, ca.certPem, "utf8");
-      fs.writeFileSync(paths.frontdoorCaKeyFile, ca.keyPem, { encoding: "utf8", mode: CA_KEY_FILE_MODE });
-      fs.chmodSync(paths.frontdoorCaKeyFile, CA_KEY_FILE_MODE);
+      fs2.mkdirSync(paths.frontdoorCaDir, { recursive: true });
+      fs2.writeFileSync(paths.frontdoorCaCertFile, ca.certPem, "utf8");
+      fs2.writeFileSync(paths.frontdoorCaKeyFile, ca.keyPem, { encoding: "utf8", mode: CA_KEY_FILE_MODE });
+      fs2.chmodSync(paths.frontdoorCaKeyFile, CA_KEY_FILE_MODE);
     }
   };
 }
@@ -2814,10 +2990,11 @@ function realConnectEffects() {
       return await listenOnce(0, onSocket);
     },
     createTlsAcceptor: (leaf, onSecure, alpnProtocols) => {
+      let pendingContext = "";
       const server = tls.createServer(
         { key: leaf.keyPem, cert: leaf.certPem, ...alpnProtocols === void 0 ? {} : { ALPNProtocols: [...alpnProtocols] } },
         (secure) => {
-          onSecure(secure);
+          onSecure(secure, pendingContext);
         }
       );
       server.on("clientError", (_error, socket) => {
@@ -2825,7 +3002,8 @@ function realConnectEffects() {
       });
       return {
         // tls.Server is a net.Server whose connection listener wraps the raw socket in the TLS handshake, and emitting the event by hand is what runs that listener on a socket this process already owns (the CONNECT half of the connection) rather than one the server accepted itself.
-        accept: (socket) => {
+        accept: (socket, context) => {
+          pendingContext = context;
           server.emit("connection", socket);
         },
         close: () => {
@@ -2839,9 +3017,8 @@ function realConnectEffects() {
         socket.destroy();
       });
       if (onUpgrade !== void 0) {
-        server.on("upgrade", (request3, socket) => {
-          onUpgrade(request3);
-          socket.destroy();
+        server.on("upgrade", (request3, socket, head) => {
+          onUpgrade(request3, socket, head);
         });
       }
       return {
@@ -2926,11 +3103,11 @@ function realConnectEffects() {
 }
 
 // src/frontdoor/ensure.ts
-var import_node_crypto5 = require("node:crypto");
+var import_node_crypto6 = require("node:crypto");
 
 // src/headroom/state.ts
-var import_node_crypto4 = require("node:crypto");
-var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_crypto5 = require("node:crypto");
+var import_node_path7 = __toESM(require("node:path"), 1);
 var import_zod4 = require("zod");
 var HEADROOM_ANTHROPIC_UPSTREAM = "https://api.anthropic.com";
 var HeadroomStateSchema = import_zod4.z.strictObject({
@@ -2964,16 +3141,16 @@ function parseJson(raw, schema) {
   const parsed = schema.safeParse(JSON.parse(raw));
   return parsed.success ? parsed.data : void 0;
 }
-function readHeadroomState(fs3, stateFile) {
+function readHeadroomState(fs7, stateFile) {
   try {
-    return parseJson(fs3.readFileUtf8(stateFile), HeadroomStateSchema);
+    return parseJson(fs7.readFileUtf8(stateFile), HeadroomStateSchema);
   } catch {
     return void 0;
   }
 }
-function writeHeadroomState(fs3, stateFile, state) {
-  fs3.mkdirp(import_node_path6.default.dirname(stateFile));
-  fs3.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
+function writeHeadroomState(fs7, stateFile, state) {
+  fs7.mkdirp(import_node_path7.default.dirname(stateFile));
+  fs7.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
 function headroomAllowlist(providers) {
@@ -2991,16 +3168,16 @@ function headroomUpstreams(providers, frontDoorOrigin2) {
   return upstreams;
 }
 function hashAllowlist(allowlist) {
-  return (0, import_node_crypto4.createHash)("sha256").update(allowlist.join("\n")).digest("hex");
+  return (0, import_node_crypto5.createHash)("sha256").update(allowlist.join("\n")).digest("hex");
 }
-function readAllProviders(fs3, providersDir) {
+function readAllProviders(fs7, providersDir) {
   const result = [];
-  for (const name of fs3.readdir(providersDir)) {
+  for (const name of fs7.readdir(providersDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs3.readFileUtf8(import_node_path6.default.join(providersDir, name)), ProviderSchema);
+      const parsed = parseJson(fs7.readFileUtf8(import_node_path7.default.join(providersDir, name)), ProviderSchema);
       if (parsed !== void 0) {
         result.push({ name: name.slice(0, -".json".length), provider: parsed });
       }
@@ -3010,22 +3187,22 @@ function readAllProviders(fs3, providersDir) {
   }
   return result;
 }
-function writeSession(fs3, sessionsDir, session) {
-  fs3.mkdirp(sessionsDir);
-  fs3.writeFileUtf8(import_node_path6.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeSession(fs7, sessionsDir, session) {
+  fs7.mkdirp(sessionsDir);
+  fs7.writeFileUtf8(import_node_path7.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function removeSession(fs3, sessionsDir, pid) {
-  fs3.removeRecursive(import_node_path6.default.join(sessionsDir, `${String(pid)}.json`));
+function removeSession(fs7, sessionsDir, pid) {
+  fs7.removeRecursive(import_node_path7.default.join(sessionsDir, `${String(pid)}.json`));
 }
-function listSessions(fs3, sessionsDir) {
+function listSessions(fs7, sessionsDir) {
   const sessions = [];
-  for (const name of fs3.readdir(sessionsDir)) {
+  for (const name of fs7.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs3.readFileUtf8(import_node_path6.default.join(sessionsDir, name)), HeadroomSessionSchema);
+      const parsed = parseJson(fs7.readFileUtf8(import_node_path7.default.join(sessionsDir, name)), HeadroomSessionSchema);
       if (parsed !== void 0) {
         sessions.push(parsed);
       }
@@ -3035,22 +3212,22 @@ function listSessions(fs3, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
-function sessionsForSupervisor(fs3, sessionsDir, supervisorPid) {
-  return listSessions(fs3, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
+function sessionsForSupervisor(fs7, sessionsDir, supervisorPid) {
+  return listSessions(fs7, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
 }
-function pruneDeadSessions(fs3, sessionsDir, isRunning) {
+function pruneDeadSessions(fs7, sessionsDir, isRunning) {
   const removed = [];
-  for (const session of listSessions(fs3, sessionsDir)) {
+  for (const session of listSessions(fs7, sessionsDir)) {
     if (!isRunning(session.pid)) {
-      removeSession(fs3, sessionsDir, session.pid);
+      removeSession(fs7, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
   return removed;
 }
-function readStartLock(fs3, lockFile) {
+function readStartLock(fs7, lockFile) {
   try {
-    return parseJson(fs3.readFileUtf8(lockFile), HeadroomLockSchema);
+    return parseJson(fs7.readFileUtf8(lockFile), HeadroomLockSchema);
   } catch {
     return void 0;
   }
@@ -3090,7 +3267,7 @@ function ensureFrontDoor(params) {
           continue;
         }
         if (verdict.ok) {
-          const token = (0, import_node_crypto5.randomUUID)();
+          const token = (0, import_node_crypto6.randomUUID)();
           writeFrontDoorSession(ports.fs, paths.frontdoorSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), token });
           return { port: state.port, connectPort: state.connectPort, token };
         }
@@ -3130,7 +3307,7 @@ function ensureFrontDoor(params) {
 }
 
 // src/usage/read.ts
-var import_node_path7 = __toESM(require("node:path"), 1);
+var import_node_path8 = __toESM(require("node:path"), 1);
 
 // src/usage/schema.ts
 var import_zod5 = require("zod");
@@ -3297,11 +3474,11 @@ function snapshotPath(snapshotsDir, identity) {
   if (!isIdentityName(identity)) {
     throw new Error(`"${identity}" is not a valid identity name.`);
   }
-  return import_node_path7.default.join(snapshotsDir, `${identity}.json`);
+  return import_node_path8.default.join(snapshotsDir, `${identity}.json`);
 }
-function readUsageSnapshot(fs3, snapshotsDir, identity) {
+function readUsageSnapshot(fs7, snapshotsDir, identity) {
   const file = snapshotPath(snapshotsDir, identity);
-  const raw = fs3.readFileUtf8(file);
+  const raw = fs7.readFileUtf8(file);
   if (raw === void 0) {
     return void 0;
   }
@@ -3317,8 +3494,8 @@ function readUsageSnapshot(fs3, snapshotsDir, identity) {
   }
   return snapshot.data;
 }
-function listUsageSnapshots(fs3, snapshotsDir) {
-  return fs3.readdir(snapshotsDir).flatMap((name) => {
+function listUsageSnapshots(fs7, snapshotsDir) {
+  return fs7.readdir(snapshotsDir).flatMap((name) => {
     if (!name.endsWith(".json")) {
       return [];
     }
@@ -3326,7 +3503,7 @@ function listUsageSnapshots(fs3, snapshotsDir) {
     if (!isIdentityName(identity)) {
       return [];
     }
-    const snapshot = readUsageSnapshot(fs3, snapshotsDir, identity);
+    const snapshot = readUsageSnapshot(fs7, snapshotsDir, identity);
     return snapshot === void 0 ? [] : [snapshot];
   }).sort((left, right) => left.identity.localeCompare(right.identity));
 }
@@ -3386,7 +3563,7 @@ function ensureHeadroom(params) {
 }
 
 // src/headroom/settings.ts
-var import_node_crypto6 = require("node:crypto");
+var import_node_crypto7 = require("node:crypto");
 function settingsOf(config) {
   return {
     ...config.mode === void 0 ? {} : { mode: config.mode },
@@ -3411,7 +3588,7 @@ function settingsEnv(settings) {
   return settings.rolloutChannel === void 0 ? {} : { HEADROOM_ROLLOUT_CHANNEL: settings.rolloutChannel };
 }
 function hashSettings(settings) {
-  return (0, import_node_crypto6.createHash)("sha256").update(JSON.stringify([...settingsArgs(settings), JSON.stringify(settingsEnv(settings))])).digest("hex");
+  return (0, import_node_crypto7.createHash)("sha256").update(JSON.stringify([...settingsArgs(settings), JSON.stringify(settingsEnv(settings))])).digest("hex");
 }
 
 // src/headroom/source.ts
@@ -3493,9 +3670,9 @@ function compareVersions(a, b) {
 }
 var HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
 async function runSupervisor(initialConfig, ports, options = {}) {
-  const { fs: fs3, paths } = ports;
+  const { fs: fs7, paths } = ports;
   let config = initialConfig;
-  const previousState = readHeadroomState(fs3, paths.headroomStateFile);
+  const previousState = readHeadroomState(fs7, 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;
@@ -3504,19 +3681,19 @@ async function runSupervisor(initialConfig, ports, options = {}) {
   let lastPort = previousState?.lastPort;
   const sticky = () => lastPort === void 0 ? {} : { lastPort };
   const ownsState = () => {
-    const owner = readHeadroomState(fs3, paths.headroomStateFile)?.supervisorPid;
+    const owner = readHeadroomState(fs7, paths.headroomStateFile)?.supervisorPid;
     return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
   };
   const writeOwnState = (state) => {
     if (!ownsState()) {
       return false;
     }
-    writeHeadroomState(fs3, paths.headroomStateFile, state);
+    writeHeadroomState(fs7, paths.headroomStateFile, state);
     return true;
   };
   const fail = (message) => {
     if (writeOwnState({ lastError: message, ...sticky() })) {
-      fs3.removeRecursive(paths.headroomLockFile);
+      fs7.removeRecursive(paths.headroomLockFile);
     }
     ports.log(`agent-shim headroom supervisor: ${message}`);
     return 1;
@@ -3565,7 +3742,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     const settingsHash = hashSettings(config.settings);
     const allowlist = allowlistOf(ports);
     const allowlistHash = hashAllowlist(allowlist);
-    pruneDeadSessions(fs3, paths.headroomSessionsDir, ports.isRunning);
+    pruneDeadSessions(fs7, paths.headroomSessionsDir, ports.isRunning);
     const ownsNow = ownsState();
     if (!ownsNow && !superseded) {
       ports.log("agent-shim headroom supervisor: another supervisor now owns state.json; serving this daemon's own sessions until they end");
@@ -3617,7 +3794,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           ...sticky()
         });
         if (recorded) {
-          fs3.removeRecursive(paths.headroomLockFile);
+          fs7.removeRecursive(paths.headroomLockFile);
         }
         idleSince = void 0;
         ports.log(`agent-shim headroom supervisor: headroom pid ${String(pid)} ready on 127.0.0.1:${String(port)}`);
@@ -3632,7 +3809,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
       }
     } else {
       if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config.source) {
-        if (sessionsForSupervisor(fs3, paths.headroomSessionsDir, ports.ownPid).length === 0) {
+        if (sessionsForSupervisor(fs7, 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;
@@ -3641,7 +3818,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           continue;
         }
       }
-      const sessions = sessionsForSupervisor(fs3, paths.headroomSessionsDir, ports.ownPid);
+      const sessions = sessionsForSupervisor(fs7, paths.headroomSessionsDir, ports.ownPid);
       if (sessions.length === 0) {
         idleSince ??= ports.now();
         const idleMs = ports.now() - idleSince;
@@ -3663,9 +3840,9 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     await ports.sleep(HEADROOM_POLL_MS);
   }
 }
-function currentHeadroomAllowlist(fs3, paths) {
-  const providers = readAllProviders(fs3, paths.providersDir).map((entry) => entry.provider);
-  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs3, paths.frontdoorStateFile))));
+function currentHeadroomAllowlist(fs7, paths) {
+  const providers = readAllProviders(fs7, paths.providersDir).map((entry) => entry.provider);
+  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs7, paths.frontdoorStateFile))));
 }
 function allowlistOf(ports) {
   return currentHeadroomAllowlist(ports.fs, ports.paths);
@@ -3731,63 +3908,735 @@ function evaluateAmbientCredentialGuard(params) {
 }
 
 // src/paths.ts
-var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_fs2 = __toESM(require("node:fs"), 1);
 var import_node_os = __toESM(require("node:os"), 1);
-var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_path9 = __toESM(require("node:path"), 1);
 function resolveAgentShimHome(env = process.env, home = import_node_os.default.homedir(), isDirectory = isExistingDirectory) {
   const fromEnv = env.AGENT_SHIM_HOME;
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  const current = import_node_path8.default.join(home, HOME_DIRNAME);
-  const legacy = import_node_path8.default.join(home, LEGACY_HOME_DIRNAME);
+  const current = import_node_path9.default.join(home, HOME_DIRNAME);
+  const legacy = import_node_path9.default.join(home, LEGACY_HOME_DIRNAME);
   return !isDirectory(current) && isDirectory(legacy) ? legacy : current;
 }
 function isExistingDirectory(candidate) {
-  return import_node_fs.default.statSync(candidate, { throwIfNoEntry: false })?.isDirectory() ?? false;
+  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_path8.default.join(import_node_os.default.homedir(), ".claude");
+  return import_node_path9.default.join(import_node_os.default.homedir(), ".claude");
 }
 function buildLayoutPaths(root) {
   return {
     root,
-    identitiesDir: import_node_path8.default.join(root, "identities"),
-    configProfilesDir: import_node_path8.default.join(root, "config-profiles"),
-    providersDir: import_node_path8.default.join(root, "providers"),
-    directoryRulesFile: import_node_path8.default.join(root, "directory-rules.json"),
-    activeIdentityFile: import_node_path8.default.join(root, "active-identity"),
-    globalConfigFile: import_node_path8.default.join(root, "config.json"),
-    categoriesLocalFile: import_node_path8.default.join(root, "categories.local.json"),
-    claudeShimFile: import_node_path8.default.join(root, "claude-shim.json"),
-    headroomDir: import_node_path8.default.join(root, "headroom"),
-    headroomStateFile: import_node_path8.default.join(root, "headroom", "state.json"),
-    headroomLockFile: import_node_path8.default.join(root, "headroom", "start.lock"),
-    headroomSessionsDir: import_node_path8.default.join(root, "headroom", "sessions"),
-    logsDir: import_node_path8.default.join(root, "logs"),
-    headroomLogPath: import_node_path8.default.join(root, "logs", "headroom.log"),
-    frontdoorDir: import_node_path8.default.join(root, "frontdoor"),
-    frontdoorCaDir: import_node_path8.default.join(root, "frontdoor", "ca"),
-    frontdoorCaCertFile: import_node_path8.default.join(root, "frontdoor", "ca", "ca.pem"),
-    frontdoorCaKeyFile: import_node_path8.default.join(root, "frontdoor", "ca", "ca.key"),
-    frontdoorCaBundlesDir: import_node_path8.default.join(root, "frontdoor", "ca", "bundles"),
-    frontdoorStateFile: import_node_path8.default.join(root, "frontdoor", "state.json"),
-    frontdoorLockFile: import_node_path8.default.join(root, "frontdoor", "start.lock"),
-    frontdoorSessionsDir: import_node_path8.default.join(root, "frontdoor", "sessions"),
-    frontdoorLogPath: import_node_path8.default.join(root, "logs", "frontdoor.log"),
-    usageDir: import_node_path8.default.join(root, "usage"),
-    usageLogDir: import_node_path8.default.join(root, "usage", "log"),
-    usageSnapshotsDir: import_node_path8.default.join(root, "usage", "snapshots"),
-    usagePicksFile: import_node_path8.default.join(root, "usage", "picks.json")
+    identitiesDir: import_node_path9.default.join(root, "identities"),
+    configProfilesDir: import_node_path9.default.join(root, "config-profiles"),
+    providersDir: import_node_path9.default.join(root, "providers"),
+    directoryRulesFile: import_node_path9.default.join(root, "directory-rules.json"),
+    activeIdentityFile: import_node_path9.default.join(root, "active-identity"),
+    globalConfigFile: import_node_path9.default.join(root, "config.json"),
+    categoriesLocalFile: import_node_path9.default.join(root, "categories.local.json"),
+    claudeShimFile: import_node_path9.default.join(root, "claude-shim.json"),
+    headroomDir: import_node_path9.default.join(root, "headroom"),
+    headroomStateFile: import_node_path9.default.join(root, "headroom", "state.json"),
+    headroomLockFile: import_node_path9.default.join(root, "headroom", "start.lock"),
+    headroomSessionsDir: import_node_path9.default.join(root, "headroom", "sessions"),
+    logsDir: import_node_path9.default.join(root, "logs"),
+    headroomLogPath: import_node_path9.default.join(root, "logs", "headroom.log"),
+    frontdoorDir: import_node_path9.default.join(root, "frontdoor"),
+    frontdoorCaDir: import_node_path9.default.join(root, "frontdoor", "ca"),
+    frontdoorCaCertFile: import_node_path9.default.join(root, "frontdoor", "ca", "ca.pem"),
+    frontdoorCaKeyFile: import_node_path9.default.join(root, "frontdoor", "ca", "ca.key"),
+    frontdoorCaBundlesDir: import_node_path9.default.join(root, "frontdoor", "ca", "bundles"),
+    frontdoorStateFile: import_node_path9.default.join(root, "frontdoor", "state.json"),
+    frontdoorLockFile: import_node_path9.default.join(root, "frontdoor", "start.lock"),
+    frontdoorSessionsDir: import_node_path9.default.join(root, "frontdoor", "sessions"),
+    frontdoorLogPath: import_node_path9.default.join(root, "logs", "frontdoor.log"),
+    usageDir: import_node_path9.default.join(root, "usage"),
+    usageLogDir: import_node_path9.default.join(root, "usage", "log"),
+    usageSnapshotsDir: import_node_path9.default.join(root, "usage", "snapshots"),
+    usagePicksFile: import_node_path9.default.join(root, "usage", "picks.json")
   };
 }
 function resolveLayoutPaths() {
   return buildLayoutPaths(resolveAgentShimHome());
 }
+
+// src/identityStore.ts
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path11 = __toESM(require("node:path"), 1);
+
+// src/launcher/identity.ts
+function poolNameOf(selector) {
+  return selector.startsWith(POOL_SELECTOR_PREFIX) ? selector.slice(POOL_SELECTOR_PREFIX.length) : void 0;
+}
+
+// src/configProfilesStore.ts
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_path10 = __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.`);
+    this.profileName = profileName;
+    this.name = "ProfileNotFoundError";
+  }
+  profileName;
+};
+var ProfileAlreadyExistsError = class extends CliError {
+  constructor(profileName) {
+    super(`A configuration profile named "${profileName}" already exists.`);
+    this.profileName = profileName;
+    this.name = "ProfileAlreadyExistsError";
+  }
+  profileName;
+};
+var InvalidCategoryNameError = class extends CliError {
+  constructor(categoryName) {
+    super(`"${categoryName}" is not a category a configuration profile may toggle (runtime, history, knowledge, settings).`);
+    this.categoryName = categoryName;
+    this.name = "InvalidCategoryNameError";
+  }
+  categoryName;
+};
+function profileJsonPath(paths, name) {
+  return import_node_path10.default.join(paths.configProfilesDir, `${name}.json`);
+}
+function profileExists(paths, name) {
+  return import_node_fs3.default.existsSync(profileJsonPath(paths, name));
+}
+function requireProfileExists(paths, name) {
+  if (!profileExists(paths, name)) {
+    throw new ProfileNotFoundError(name);
+  }
+}
+function readProfile(paths, name) {
+  return readJson(profileJsonPath(paths, name), ConfigProfileSchema);
+}
+function createProfile(paths, name, extendsList, description) {
+  if (profileExists(paths, name)) {
+    throw new ProfileAlreadyExistsError(name);
+  }
+  const filePath = profileJsonPath(paths, name);
+  const parsed = ConfigProfileSchema.safeParse({
+    ...description === void 0 ? {} : { description },
+    ...extendsList !== void 0 && extendsList.length > 0 ? { extends: [...extendsList] } : {}
+  });
+  if (!parsed.success) {
+    throw new ConfigValidationError(filePath, parsed.error.issues);
+  }
+  writeJsonAtomic(filePath, parsed.data);
+  return parsed.data;
+}
+function listProfiles(paths) {
+  if (!import_node_fs3.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 result = [];
+  for (const name of names) {
+    const profile = readProfile(paths, name);
+    if (profile !== void 0) {
+      result.push({ name, profile });
+    }
+  }
+  return result;
+}
+function globalConfigPath(paths) {
+  return paths.globalConfigFile;
+}
+function readGlobalConfig(paths) {
+  return readJson(globalConfigPath(paths), GlobalConfigSchema);
+}
+function setGlobalDefaultProfile(paths, name) {
+  return applyPatch(
+    globalConfigPath(paths),
+    GlobalConfigSchema,
+    { defaultConfigProfile: name },
+    { defaults: {} }
+  );
+}
+function validateCategoryNames(patch) {
+  for (const key of Object.keys(patch)) {
+    if (!isOverridableCategory(key)) {
+      throw new InvalidCategoryNameError(key);
+    }
+  }
+}
+function setProfileCategories(paths, name, patch) {
+  requireProfileExists(paths, name);
+  const expandedPatch = expandAllCategoryKey(patch);
+  validateCategoryNames(expandedPatch);
+  const existing = readProfile(paths, name) ?? {};
+  const mergedCategories = { ...existing.categories, ...expandedPatch };
+  return applyPatch(profileJsonPath(paths, name), ConfigProfileSchema, { categories: mergedCategories });
+}
+function setProfileEntries(paths, name, patch) {
+  requireProfileExists(paths, name);
+  const existing = readProfile(paths, name) ?? {};
+  const mergedEntries = { ...existing.entries, ...patch };
+  return applyPatch(profileJsonPath(paths, name), ConfigProfileSchema, { entries: mergedEntries });
+}
+function setProfileLaunchFlags(paths, name, patch) {
+  requireProfileExists(paths, name);
+  const existing = readProfile(paths, name) ?? {};
+  const mergedLaunch = { ...existing.launch, ...patch };
+  return applyPatch(profileJsonPath(paths, name), ConfigProfileSchema, {
+    // Read as `unknown` so the check sees the `undefined` a cleared key holds, which LaunchFlags' optional properties hide from the value type.
+    launch: Object.values(mergedLaunch).every((value) => value === void 0) ? void 0 : mergedLaunch
+  });
+}
+function setProfileMetadata(paths, name, patch) {
+  requireProfileExists(paths, name);
+  return applyPatch(profileJsonPath(paths, name), ConfigProfileSchema, {
+    ...patch.extends === void 0 ? {} : { extends: patch.extends.length === 0 ? void 0 : [...patch.extends] },
+    ...patch.description === void 0 ? {} : { description: patch.description === false ? void 0 : patch.description }
+  });
+}
+function removeProfile(paths, name) {
+  requireProfileExists(paths, name);
+  import_node_fs3.default.rmSync(profileJsonPath(paths, name));
+}
+
+// src/poolStore.ts
+var PoolNotFoundError = class extends CliError {
+  constructor(poolName) {
+    super(`No pool named "${poolName}". Run \`agent-shim pool add ${poolName} --identity <name>...\` first.`);
+    this.poolName = poolName;
+    this.name = "PoolNotFoundError";
+  }
+  poolName;
+};
+var PoolAlreadyExistsError = class extends CliError {
+  constructor(poolName) {
+    super(`A pool named "${poolName}" already exists. Use \`agent-shim pool set ${poolName}\` to change its members.`);
+    this.poolName = poolName;
+    this.name = "PoolAlreadyExistsError";
+  }
+  poolName;
+};
+var InvalidPoolNameError = class extends CliError {
+  constructor(attemptedName) {
+    super(`"${attemptedName}" is not a valid pool name: it must start with a letter or number and may then contain letters, numbers, dots, hyphens and underscores.`);
+    this.attemptedName = attemptedName;
+    this.name = "InvalidPoolNameError";
+  }
+  attemptedName;
+};
+function readPools(paths) {
+  return readGlobalConfig(paths)?.pools ?? {};
+}
+function requirePool(paths, name) {
+  const pool = readPools(paths)[name];
+  if (pool === void 0) {
+    throw new PoolNotFoundError(name);
+  }
+  return pool;
+}
+function writePools(paths, pools) {
+  applyPatch(paths.globalConfigFile, GlobalConfigSchema, { pools }, { defaults: {} });
+}
+function addPool(paths, name, identities) {
+  if (!PoolNameSchema.safeParse(name).success) {
+    throw new InvalidPoolNameError(name);
+  }
+  const pools = readPools(paths);
+  if (pools[name] !== void 0) {
+    throw new PoolAlreadyExistsError(name);
+  }
+  const pool = { identities: [...identities] };
+  writePools(paths, { ...pools, [name]: pool });
+  return pool;
+}
+function setPool(paths, name, identities) {
+  requirePool(paths, name);
+  const pool = { identities: [...identities] };
+  writePools(paths, { ...readPools(paths), [name]: pool });
+  return pool;
+}
+function removePool(paths, name) {
+  requirePool(paths, name);
+  const remaining = Object.fromEntries(Object.entries(readPools(paths)).filter(([existing]) => existing !== name));
+  writePools(paths, remaining);
+}
+
+// src/identityStore.ts
+var IdentityNotFoundError = class extends CliError {
+  constructor(name) {
+    super(`No identity named "${name}". Run \`agent-shim identity add ${name}\` first.`);
+    this.name = name;
+    this.name = "IdentityNotFoundError";
+  }
+  name;
+};
+var IdentityAlreadyExistsError = class extends CliError {
+  constructor(identityName) {
+    super(`An identity named "${identityName}" already exists.`);
+    this.identityName = identityName;
+    this.name = "IdentityAlreadyExistsError";
+  }
+  identityName;
+};
+var InvalidIdentityNameError = class extends CliError {
+  constructor(attemptedName) {
+    super(
+      `"${attemptedName}" is not a valid identity name \u2014 identity 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 = "InvalidIdentityNameError";
+  }
+  attemptedName;
+};
+function identityJsonPath(paths, name) {
+  return import_node_path11.default.join(paths.identitiesDir, name, "identity.json");
+}
+function identityExists(paths, name) {
+  return import_node_fs4.default.existsSync(identityJsonPath(paths, name));
+}
+function readIdentity(paths, name) {
+  return readJson(identityJsonPath(paths, name), IdentitySchema);
+}
+function addIdentity(paths, name) {
+  if (identityExists(paths, name)) {
+    throw new IdentityAlreadyExistsError(name);
+  }
+  const parsed = IdentitySchema.safeParse({ name, allowAmbientCredential: false });
+  if (!parsed.success) {
+    throw new InvalidIdentityNameError(name);
+  }
+  writeJsonAtomic(identityJsonPath(paths, name), parsed.data);
+  return parsed.data;
+}
+function useIdentity(paths, name) {
+  const pool = poolNameOf(name);
+  if (pool !== void 0) {
+    requirePool(paths, pool);
+  } else if (!identityExists(paths, name)) {
+    throw new IdentityNotFoundError(name);
+  }
+  writeTextAtomic(paths.activeIdentityFile, `${name}
+`);
+}
+function readActiveIdentity(paths) {
+  if (!import_node_fs4.default.existsSync(paths.activeIdentityFile)) {
+    return void 0;
+  }
+  const raw = import_node_fs4.default.readFileSync(paths.activeIdentityFile, "utf8").trim();
+  return raw === "" ? void 0 : raw;
+}
+function isIdentityDirectoryName(name) {
+  return !name.startsWith(".");
+}
+function readIdentityForListing(paths, name) {
+  try {
+    return readIdentity(paths, name);
+  } catch (error) {
+    if (error instanceof ConfigValidationError || error instanceof SyntaxError) {
+      return { problem: error.message.replace(/\s*\n\s*/g, " ") };
+    }
+    throw error;
+  }
+}
+function listIdentities(paths) {
+  if (!import_node_fs4.default.existsSync(paths.identitiesDir)) {
+    return [];
+  }
+  const active = readActiveIdentity(paths);
+  const names = import_node_fs4.default.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isIdentityDirectoryName(entry.name)).map((entry) => entry.name).sort();
+  const result = [];
+  for (const name of names) {
+    const read = readIdentityForListing(paths, name);
+    if (read === void 0) {
+      continue;
+    }
+    const isActive = name === active;
+    result.push("problem" in read ? { name, isActive, problem: read.problem } : { name, identity: read, isActive });
+  }
+  return result;
+}
+function setDefaultConfigProfile(paths, identityName, profileName) {
+  if (!identityExists(paths, identityName)) {
+    throw new IdentityNotFoundError(identityName);
+  }
+  return applyPatch(identityJsonPath(paths, identityName), IdentitySchema, {
+    defaultConfigProfile: profileName
+  });
+}
+function setAllowAmbientCredential(paths, identityName, allow) {
+  if (!identityExists(paths, identityName)) {
+    throw new IdentityNotFoundError(identityName);
+  }
+  return applyPatch(identityJsonPath(paths, identityName), IdentitySchema, {
+    allowAmbientCredential: allow
+  });
+}
+function setIdentityCredential(paths, identityName, change) {
+  const existing = readIdentity(paths, identityName);
+  if (existing === void 0) {
+    throw new IdentityNotFoundError(identityName);
+  }
+  if (change === false) {
+    return applyPatch(identityJsonPath(paths, identityName), IdentitySchema, { credential: void 0 });
+  }
+  const sources = change.sources ?? existing.credential?.sources;
+  if (sources === void 0) {
+    throw new UsageError(`Identity "${identityName}" has no credential yet: pass --credential to give it one before choosing its target.`);
+  }
+  const target = change.target ?? existing.credential?.target;
+  const cache = change.cache === void 0 ? existing.credential?.cache : change.cache === false ? void 0 : change.cache;
+  return applyPatch(identityJsonPath(paths, identityName), IdentitySchema, {
+    credential: { sources: [...sources], ...target === void 0 ? {} : { target }, ...cache === void 0 ? {} : { cache } }
+  });
+}
+function belongsToIdentity(entry, name) {
+  return entry === name || entry === import_node_path11.default.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
+}
+function removeIdentity(paths, name) {
+  if (!identityExists(paths, name)) {
+    throw new IdentityNotFoundError(name);
+  }
+  for (const entry of import_node_fs4.default.readdirSync(paths.identitiesDir)) {
+    if (belongsToIdentity(entry, name)) {
+      import_node_fs4.default.rmSync(import_node_path11.default.join(paths.identitiesDir, entry), { recursive: true, force: true });
+    }
+  }
+  if (readActiveIdentity(paths) === name) {
+    import_node_fs4.default.rmSync(paths.activeIdentityFile);
+  }
+}
+
+// src/providersStore.ts
+var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_path12 = __toESM(require("node:path"), 1);
+
+// src/credentialCache.ts
+var import_zod7 = require("zod");
+var CachedCredentialSchema = import_zod7.z.strictObject({
+  token: import_zod7.z.string().min(1),
+  fetchedAt: import_zod7.z.number().int().nonnegative(),
+  source: CredentialSourceSchema
+});
+
+// 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;
+};
+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_path12.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 isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function legacyProviderConversion(raw) {
+  if (!isRecord(raw) || "credential" in raw) {
+    return void 0;
+  }
+  const env = isRecord(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 {
+    fields,
+    replacement: {
+      ...rest,
+      credential: { sources, ...raw.authScheme === "apiKey" ? { target: "apiKey" } : {} },
+      ...remainingEnv === void 0 || Object.keys(remainingEnv).length === 0 ? {} : { env: remainingEnv }
+    }
+  };
+}
+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;
+};
+function parseProviderFile(filePath, raw) {
+  const conversion = legacyProviderConversion(raw);
+  if (conversion !== void 0) {
+    throw new LegacyProviderFileError(filePath, conversion);
+  }
+  const parsed = ProviderSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new ConfigValidationError(filePath, parsed.error.issues);
+  }
+  return parsed.data;
+}
+function readProvider(paths, name) {
+  const filePath = providerJsonPath(paths, name);
+  if (!import_node_fs5.default.existsSync(filePath)) {
+    return void 0;
+  }
+  const raw = JSON.parse(import_node_fs5.default.readFileSync(filePath, "utf8"));
+  return parseProviderFile(filePath, raw);
+}
+function listProviders(paths) {
+  const names = listProviderNames(
+    (dir) => import_node_fs5.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 result;
+}
+function listProviderNames(readdir, providersDir) {
+  let entries;
+  try {
+    entries = readdir(providersDir);
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => entry.endsWith(".json")).map((entry) => entry.slice(0, -".json".length)).sort();
+}
+function describeProviderEndpoint(provider) {
+  return isCodexProvider(provider) ? "codex translation daemon" : provider.baseUrl;
+}
+var ProviderKindMismatchError = class extends UsageError {
+  constructor(message) {
+    super(message);
+    this.name = "ProviderKindMismatchError";
+  }
+};
+function isEmptyCodexConfig(config) {
+  return config === void 0 || config.defaultModel === void 0 && config.effort === void 0 && (config.models === void 0 || Object.keys(config.models).length === 0);
+}
+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).");
+  }
+  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 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 removeProvider(paths, name) {
+  if (!providerExists(paths, name)) {
+    throw new ProviderNotFoundError(name);
+  }
+  import_node_fs5.default.rmSync(providerJsonPath(paths, name));
+}
+
+// src/directoryRulesStore.ts
+var DirectoryRuleNotFoundError = class extends CliError {
+  constructor(rulePath) {
+    super(`No directory rule found for path "${rulePath}".`);
+    this.rulePath = rulePath;
+    this.name = "DirectoryRuleNotFoundError";
+  }
+  rulePath;
+};
+var DirectoryRuleMissingTargetError = class extends CliError {
+  constructor() {
+    super("A directory rule must set at least one of --config-profile or --identity.");
+    this.name = "DirectoryRuleMissingTargetError";
+  }
+};
+var DirectoryRuleAlreadyExistsError = class extends CliError {
+  constructor(rulePath) {
+    super(`A directory rule for path "${rulePath}" already exists. Use \`agent-shim rule set\` to change it.`);
+    this.rulePath = rulePath;
+    this.name = "DirectoryRuleAlreadyExistsError";
+  }
+  rulePath;
+};
+function readDirectoryRules(paths) {
+  return readJson(paths.directoryRulesFile, DirectoryRulesSchema) ?? { rules: [] };
+}
+function writeDirectoryRules(paths, rules) {
+  const parsed = DirectoryRulesSchema.safeParse(rules);
+  if (!parsed.success) {
+    throw new ConfigValidationError(paths.directoryRulesFile, parsed.error.issues);
+  }
+  writeJsonAtomic(paths.directoryRulesFile, parsed.data);
+}
+function listDirectoryRules(paths) {
+  return readDirectoryRules(paths).rules;
+}
+function addDirectoryRule(paths, rulePath, options) {
+  if (options.configProfile === void 0 && options.identity === void 0) {
+    throw new DirectoryRuleMissingTargetError();
+  }
+  const current = readDirectoryRules(paths);
+  if (current.rules.some((rule) => rule.path === rulePath)) {
+    throw new DirectoryRuleAlreadyExistsError(rulePath);
+  }
+  const created = buildNewRule(rulePath, options);
+  writeDirectoryRules(paths, { ...current, rules: [...current.rules, created] });
+  return created;
+}
+function ruleHasEffect(rule) {
+  return rule.configProfile !== void 0 || rule.identity !== void 0 || rule.categories !== void 0 || rule.entries !== void 0 || rule.launch !== void 0;
+}
+function updateDirectoryRule(paths, rulePath, options) {
+  const current = readDirectoryRules(paths);
+  const index = current.rules.findIndex((rule) => rule.path === rulePath);
+  const existing = index === -1 ? void 0 : current.rules[index];
+  if (existing === void 0) {
+    throw new DirectoryRuleNotFoundError(rulePath);
+  }
+  const { configProfile, identity, ...rest } = existing;
+  const nextConfigProfile = options.configProfile === void 0 ? configProfile : options.configProfile === false ? void 0 : options.configProfile;
+  const nextIdentity = options.identity === void 0 ? identity : options.identity === false ? void 0 : options.identity;
+  const updated = {
+    ...rest,
+    ...nextConfigProfile === void 0 ? {} : { configProfile: nextConfigProfile },
+    ...nextIdentity === void 0 ? {} : { identity: nextIdentity }
+  };
+  if (!ruleHasEffect(updated)) {
+    throw new DirectoryRuleMissingTargetError();
+  }
+  const nextRules = [...current.rules];
+  nextRules[index] = updated;
+  writeDirectoryRules(paths, { ...current, rules: nextRules });
+  return updated;
+}
+function buildNewRule(rulePath, options) {
+  return {
+    path: rulePath,
+    ...options.configProfile !== void 0 ? { configProfile: options.configProfile } : {},
+    ...options.identity !== void 0 ? { identity: options.identity } : {}
+  };
+}
+function removeDirectoryRule(paths, rulePath) {
+  const current = readDirectoryRules(paths);
+  const nextRules = current.rules.filter((rule) => rule.path !== rulePath);
+  if (nextRules.length === current.rules.length) {
+    throw new DirectoryRuleNotFoundError(rulePath);
+  }
+  writeDirectoryRules(paths, { ...current, rules: nextRules });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AMBIENT_CREDENTIAL_VARS,
@@ -3802,6 +4651,9 @@ function resolveLayoutPaths() {
   CredentialCacheSchema,
   CredentialSchema,
   CredentialSourceSchema,
+  DirectoryRuleAlreadyExistsError,
+  DirectoryRuleMissingTargetError,
+  DirectoryRuleNotFoundError,
   DirectoryRuleSchema,
   DirectoryRulesSchema,
   EXIT_FAILURE,
@@ -3811,20 +4663,38 @@ function resolveLayoutPaths() {
   FrontDoorStartError,
   GlobalConfigSchema,
   HeadroomStartError,
+  IdentityAlreadyExistsError,
+  IdentityNotFoundError,
   IdentitySchema,
+  InvalidCategoryNameError,
+  InvalidIdentityNameError,
+  InvalidProviderNameError,
+  LegacyProviderFileError,
   PoolNameSchema,
+  PoolNotFoundError,
   PoolSchema,
   PortableConfigSchema,
+  ProfileAlreadyExistsError,
+  ProfileNotFoundError,
+  ProviderAlreadyExistsError,
+  ProviderKindMismatchError,
+  ProviderNotFoundError,
   ProviderSchema,
   ROUTED_PATH_PREFIX,
   UsageError,
   UsageSnapshotError,
   UsageSnapshotSchema,
   WhenSchema,
+  addDirectoryRule,
+  addIdentity,
+  addPool,
+  addProvider,
   buildEntryFacts,
   buildLayoutPaths,
   carryOver,
   createLeafCache,
+  createProfile,
+  describeProviderEndpoint,
   detectAmbientCredential,
   ensureCa,
   ensureFrontDoor,
@@ -3833,16 +4703,37 @@ function resolveLayoutPaths() {
   formatAmbientCredentialGuardMessage,
   forwardableHeaders,
   generateCa,
+  identityExists,
+  isIdentityDirectoryName,
   isInterceptedHost,
+  listDirectoryRules,
+  listIdentities,
+  listProfiles,
+  listProviders,
   listUsageSnapshots,
   mintLeaf,
   parseConnectTarget,
+  profileExists,
+  providerExists,
+  readActiveIdentity,
+  readDirectoryRules,
   readFarmManifest,
+  readGlobalConfig,
+  readIdentity,
+  readPools,
+  readProfile,
+  readProvider,
   readUsageSnapshot,
   realConnectCertStore,
   realConnectEffects,
   recoverFarm,
   recoveryDiagnostics,
+  removeDirectoryRule,
+  removeIdentity,
+  removePool,
+  removeProfile,
+  removeProvider,
+  requirePool,
   resolveAgentShimHome,
   resolveClaudeHome,
   resolveDecisions,
@@ -3852,7 +4743,20 @@ function resolveLayoutPaths() {
   runFrontDoorSupervisor,
   runSupervisor,
   servedByPipeline,
+  setAllowAmbientCredential,
+  setDefaultConfigProfile,
+  setGlobalDefaultProfile,
+  setIdentityCredential,
+  setPool,
+  setProfileCategories,
+  setProfileEntries,
+  setProfileLaunchFlags,
+  setProfileMetadata,
   snapshotPath,
   startConnectServer,
-  topLevelNames
+  topLevelNames,
+  updateDirectoryRule,
+  updateProvider,
+  useIdentity,
+  writeDirectoryRules
 });