agent-shim 7.7.0 → 7.8.0

package/dist/index.mjs

@@ -243,6 +243,11 @@ var SHIPPED_CATEGORY_DEFAULTS = Object.freeze({
   settings: true
 });
 
+// src/config/store.ts
+import fs from "node:fs";
+import path2 from "node:path";
+import { randomUUID } from "node:crypto";
+
 // src/config/load.ts
 import { cosmiconfigSync } from "cosmiconfig";
 
@@ -261,6 +266,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 fs.readFileSync(filePath, "utf8");
+    } catch (error) {
+      if (isEnoent(error)) {
+        return void 0;
+      }
+      throw error;
+    }
+  },
+  writeFileUtf8(filePath, contents) {
+    fs.writeFileSync(filePath, contents, "utf8");
+  },
+  renameSync(from, to) {
+    fs.renameSync(from, to);
+  },
+  mkdirSync(dirPath) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  },
+  unlinkSync(filePath) {
+    try {
+      fs.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 = path2.dirname(filePath);
+  storeFs.mkdirSync(dir);
+  const tempPath = path2.join(dir, `.${path2.basename(filePath)}.${String(process.pid)}.${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) {
@@ -852,7 +949,7 @@ function dedupeDiagnostics(diagnostics) {
 }
 
 // src/resolve/plan.ts
-import path2 from "node:path";
+import path3 from "node:path";
 function parentOf(rel) {
   const index = rel.lastIndexOf("/");
   return index === -1 ? "" : rel.slice(0, index);
@@ -902,7 +999,7 @@ function planFarm(params) {
     }
     return value;
   };
-  const linkTarget = (rel) => path2.join(params.facts.claudeHome, rel);
+  const linkTarget = (rel) => path3.join(params.facts.claudeHome, rel);
   const visit = (rel) => {
     const fact = params.facts.entries.get(rel);
     const decision = params.decisions.get(rel);
@@ -1126,7 +1223,7 @@ function resolveDecisions(input) {
 }
 
 // src/launcher/farm.ts
-import path4 from "node:path";
+import path5 from "node:path";
 import { z as z2 } from "zod";
 
 // src/resolve/reconcile.ts
@@ -1225,8 +1322,8 @@ var LEGACY_HOME_DIRNAME = ".claude-use";
 var LEGACY_FARM_MANIFEST_FILENAME = ".claude-use-farm.json";
 
 // src/launcher/lock.ts
-import { randomUUID } from "node:crypto";
-import path3 from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import path4 from "node:path";
 var DEFAULT_STALE_AFTER_MS = 12e4;
 var DEFAULT_RETRY_DELAY_MS = 50;
 var DEFAULT_MAX_ATTEMPTS = 200;
@@ -1245,7 +1342,7 @@ var IdentityLockBusyError = class extends CliError {
   holderPid;
 };
 function identityLockPath(dir, identity) {
-  return path3.join(dir, `.${identity}.lock`);
+  return path4.join(dir, `.${identity}.lock`);
 }
 function parseLockRecord(raw) {
   if (raw === void 0) {
@@ -1274,7 +1371,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 = randomUUID();
+  const token = randomUUID2();
   if (params.fs.lstat(params.dir) === void 0) {
     params.fs.mkdirp(params.dir);
   }
@@ -1323,8 +1420,8 @@ var FarmManifestSchema = z2.strictObject({
   materialised: z2.array(z2.string()),
   links: z2.array(z2.strictObject({ rel: z2.string(), target: z2.string() }))
 });
-function readFarmManifest(fs3, farmRoot) {
-  const raw = fs3.readFileUtf8(path4.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs3.readFileUtf8(path4.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
+function readFarmManifest(fs7, farmRoot) {
+  const raw = fs7.readFileUtf8(path5.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs7.readFileUtf8(path5.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
   if (raw === void 0) {
     return void 0;
   }
@@ -1340,7 +1437,7 @@ function readFarmManifest(fs3, farmRoot) {
 function buildEntryFacts(params) {
   const entries = /* @__PURE__ */ new Map();
   const visit = (rel) => {
-    const absolute = path4.join(params.claudeHome, rel);
+    const absolute = path5.join(params.claudeHome, rel);
     const stat = params.fs.lstat(absolute);
     if (stat === void 0) {
       return void 0;
@@ -1382,9 +1479,9 @@ function buildEntryFacts(params) {
     entries
   };
 }
-function listSubtree(fs3, root, rel) {
-  const absolute = path4.join(root, rel);
-  const stat = fs3.lstat(absolute);
+function listSubtree(fs7, root, rel) {
+  const absolute = path5.join(root, rel);
+  const stat = fs7.lstat(absolute);
   if (stat === void 0) {
     return [];
   }
@@ -1392,10 +1489,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) {
@@ -1409,25 +1506,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(path4.join(farmRoot, name))?.kind === "dir").sort();
+  return [...fs7.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs7.lstat(path5.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 = path4.join(claudeHome, entry.rel);
-    const stat = fs3.lstat(absolute);
+    const absolute = path5.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;
     }
@@ -1451,21 +1548,21 @@ function carryOver(params) {
     if (accounted.has(name)) {
       continue;
     }
-    const stat = params.fs.lstat(path4.join(params.previousRoot, name));
+    const stat = params.fs.lstat(path5.join(params.previousRoot, name));
     if (stat === void 0 || stat.kind === "symlink") {
       continue;
     }
-    if (params.fs.lstat(path4.join(params.farmRoot, name)) !== void 0) {
+    if (params.fs.lstat(path5.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(path4.join(params.previousRoot, name));
+        params.fs.removeRecursive(path5.join(params.previousRoot, name));
         autoResolved.push(name);
         continue;
       }
       collided.push(name);
       continue;
     }
-    params.fs.rename(path4.join(params.previousRoot, name), path4.join(params.farmRoot, name));
+    params.fs.rename(path5.join(params.previousRoot, name), path5.join(params.farmRoot, name));
     carried.push(name);
   }
   return { carried, autoResolved, collided };
@@ -1473,9 +1570,9 @@ function carryOver(params) {
 function buildScratchTree(params) {
   params.fs.mkdirp(params.scratchRoot);
   for (const entry of params.plan.entries) {
-    const absolute = path4.join(params.scratchRoot, entry.rel);
+    const absolute = path5.join(params.scratchRoot, entry.rel);
     if (entry.kind === "link") {
-      params.fs.mkdirp(path4.dirname(absolute));
+      params.fs.mkdirp(path5.dirname(absolute));
       params.fs.symlink(entry.target, absolute);
       continue;
     }
@@ -1484,14 +1581,14 @@ function buildScratchTree(params) {
     }
   }
   params.fs.writeFileUtf8(
-    path4.join(params.scratchRoot, FARM_MANIFEST_FILENAME),
+    path5.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(path4.dirname(params.farmRoot));
+    params.fs.mkdirp(path5.dirname(params.farmRoot));
     params.fs.rename(params.scratchRoot, params.farmRoot);
     return { carried: [], autoResolved: [], collided: [] };
   }
@@ -1515,14 +1612,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(path4.join(params.identitiesDir, name));
+    params.fs.removeRecursive(path5.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(path4.join(params.identitiesDir, first), params.farmRoot);
+    params.fs.rename(path5.join(params.identitiesDir, first), params.farmRoot);
     restoredFrom = first;
     previous = previous.slice(1);
   }
@@ -1530,7 +1627,7 @@ function recoverInterruptedSwap(params) {
   const autoResolved = [];
   const retained = [];
   for (const name of previous) {
-    const previousRoot = path4.join(params.identitiesDir, name);
+    const previousRoot = path5.join(params.identitiesDir, name);
     const result = carryOver({
       fs: params.fs,
       previousRoot,
@@ -1555,7 +1652,7 @@ function recoverInterruptedSwap(params) {
   };
 }
 function recoverFarm(params) {
-  const farmRoot = path4.join(params.identitiesDir, params.identity);
+  const farmRoot = path5.join(params.identitiesDir, params.identity);
   const lock = acquireIdentityLock({
     identity: params.identity,
     dir: params.identitiesDir,
@@ -1614,16 +1711,16 @@ function executeReconciliation(params) {
       });
       continue;
     }
-    const from = path4.join(params.farmRoot, action.rel);
-    const canonical = path4.join(params.claudeHome, action.rel);
+    const from = path5.join(params.farmRoot, action.rel);
+    const canonical = path5.join(params.claudeHome, action.rel);
     if (action.kind === "adopt") {
-      params.fs.mkdirp(path4.dirname(canonical));
+      params.fs.mkdirp(path5.dirname(canonical));
       params.fs.copyRecursive(from, canonical);
       adopted.push(action.rel);
       continue;
     }
     const preserved = `${canonical}.farm-conflict-${String(params.nowMs)}`;
-    params.fs.mkdirp(path4.dirname(canonical));
+    params.fs.mkdirp(path5.dirname(canonical));
     params.fs.copyRecursive(from, preserved);
     conflicts.push(action.rel);
   }
@@ -1648,7 +1745,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 = path4.join(params.identitiesDir, params.identity);
+  const farmRoot = path5.join(params.identitiesDir, params.identity);
   const lock = acquireIdentityLock({
     identity: params.identity,
     dir: params.identitiesDir,
@@ -1727,8 +1824,8 @@ function resyncFarm(params) {
         diagnostics
       };
     }
-    const scratchRoot = path4.join(params.identitiesDir, `.${params.identity}.scratch.${params.uniqueSuffix}`);
-    const previousRoot = path4.join(params.identitiesDir, `.${params.identity}.previous.${params.uniqueSuffix}`);
+    const scratchRoot = path5.join(params.identitiesDir, `.${params.identity}.scratch.${params.uniqueSuffix}`);
+    const previousRoot = path5.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) {
@@ -1786,7 +1883,7 @@ function recoveryDiagnostics(recovery, identity) {
 
 // src/frontdoor/connect.ts
 import { X509Certificate as X509Certificate2, createPrivateKey as createPrivateKey2 } from "node:crypto";
-import * as fs from "node:fs";
+import * as fs2 from "node:fs";
 
 // src/frontdoor/x509.ts
 import { createHash, createPrivateKey, generateKeyPairSync, randomBytes, sign, X509Certificate } from "node:crypto";
@@ -2132,7 +2229,7 @@ function capabilityFromProxyAuthorization(value) {
 var AUTH_HEADER = "x-agent-shim-auth";
 
 // src/frontdoor/state.ts
-import path5 from "node:path";
+import path6 from "node:path";
 import { z as z3 } from "zod";
 var FRONT_DOOR_PROTOCOL = 1;
 var FrontDoorSessionSchema = z3.strictObject({ pid: z3.number().int().positive(), startedAt: z3.number(), token: z3.string().min(1) });
@@ -2166,10 +2263,10 @@ var FrontDoorStateSchema = z3.strictObject({
   /** The last fatal error, kept across shutdowns so `frontdoor status` can explain a front door that is not running. */
   lastError: z3.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;
   }
@@ -2183,28 +2280,28 @@ function readFrontDoorState(fs3, stateFile) {
     return void 0;
   }
 }
-function writeFrontDoorState(fs3, stateFile, state) {
-  fs3.mkdirp(path5.dirname(stateFile));
-  fs3.writeFileUtf8(stateFile, `${JSON.stringify(state, null, 2)}
+function writeFrontDoorState(fs7, stateFile, state) {
+  fs7.mkdirp(path6.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(path5.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeFrontDoorSession(fs7, sessionsDir, session) {
+  fs7.mkdirPrivate(sessionsDir);
+  fs7.writeFilePrivate(path6.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(path5.join(sessionsDir, name)) ?? ""));
+      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs7.readFileUtf8(path6.join(sessionsDir, name)) ?? ""));
       if (parsed.success) {
         sessions.push({ pid: parsed.data.pid, startedAt: parsed.data.startedAt });
       }
@@ -2214,14 +2311,14 @@ function listFrontDoorSessions(fs3, sessionsDir) {
   }
   return sessions.sort((a, b) => a.pid - b.pid);
 }
-function removeFrontDoorSession(fs3, sessionsDir, pid) {
-  fs3.removeRecursive(path5.join(sessionsDir, `${String(pid)}.json`));
+function removeFrontDoorSession(fs7, sessionsDir, pid) {
+  fs7.removeRecursive(path6.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);
     }
   }
@@ -2233,8 +2330,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;
@@ -2244,12 +2341,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 {
@@ -2286,8 +2383,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;
@@ -2296,15 +2393,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 {
@@ -2359,8 +2456,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",
@@ -2658,15 +2755,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;
@@ -2679,10 +2776,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);
     }
   };
 }
@@ -2851,11 +2948,11 @@ function realConnectEffects() {
 }
 
 // src/frontdoor/ensure.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // src/headroom/state.ts
 import { createHash as createHash2 } from "node:crypto";
-import path6 from "node:path";
+import path7 from "node:path";
 import { z as z4 } from "zod";
 var HEADROOM_ANTHROPIC_UPSTREAM = "https://api.anthropic.com";
 var HeadroomStateSchema = z4.strictObject({
@@ -2889,16 +2986,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(path6.dirname(stateFile));
-  fs3.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
+function writeHeadroomState(fs7, stateFile, state) {
+  fs7.mkdirp(path7.dirname(stateFile));
+  fs7.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
 function headroomAllowlist(providers) {
@@ -2918,14 +3015,14 @@ function headroomUpstreams(providers, frontDoorOrigin2) {
 function hashAllowlist(allowlist) {
   return createHash2("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(path6.join(providersDir, name)), ProviderSchema);
+      const parsed = parseJson(fs7.readFileUtf8(path7.join(providersDir, name)), ProviderSchema);
       if (parsed !== void 0) {
         result.push({ name: name.slice(0, -".json".length), provider: parsed });
       }
@@ -2935,22 +3032,22 @@ function readAllProviders(fs3, providersDir) {
   }
   return result;
 }
-function writeSession(fs3, sessionsDir, session) {
-  fs3.mkdirp(sessionsDir);
-  fs3.writeFileUtf8(path6.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeSession(fs7, sessionsDir, session) {
+  fs7.mkdirp(sessionsDir);
+  fs7.writeFileUtf8(path7.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function removeSession(fs3, sessionsDir, pid) {
-  fs3.removeRecursive(path6.join(sessionsDir, `${String(pid)}.json`));
+function removeSession(fs7, sessionsDir, pid) {
+  fs7.removeRecursive(path7.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(path6.join(sessionsDir, name)), HeadroomSessionSchema);
+      const parsed = parseJson(fs7.readFileUtf8(path7.join(sessionsDir, name)), HeadroomSessionSchema);
       if (parsed !== void 0) {
         sessions.push(parsed);
       }
@@ -2960,22 +3057,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;
   }
@@ -3015,7 +3112,7 @@ function ensureFrontDoor(params) {
           continue;
         }
         if (verdict.ok) {
-          const token = randomUUID2();
+          const token = randomUUID3();
           writeFrontDoorSession(ports.fs, paths.frontdoorSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), token });
           return { port: state.port, connectPort: state.connectPort, token };
         }
@@ -3055,7 +3152,7 @@ function ensureFrontDoor(params) {
 }
 
 // src/usage/read.ts
-import path7 from "node:path";
+import path8 from "node:path";
 
 // src/usage/schema.ts
 import { z as z5 } from "zod";
@@ -3222,11 +3319,11 @@ function snapshotPath(snapshotsDir, identity) {
   if (!isIdentityName(identity)) {
     throw new Error(`"${identity}" is not a valid identity name.`);
   }
-  return path7.join(snapshotsDir, `${identity}.json`);
+  return path8.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;
   }
@@ -3242,8 +3339,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 [];
     }
@@ -3251,7 +3348,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));
 }
@@ -3418,9 +3515,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;
@@ -3429,19 +3526,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;
@@ -3490,7 +3587,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");
@@ -3542,7 +3639,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)}`);
@@ -3557,7 +3654,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;
@@ -3566,7 +3663,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;
@@ -3588,9 +3685,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);
@@ -3656,63 +3753,735 @@ function evaluateAmbientCredentialGuard(params) {
 }
 
 // src/paths.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import os from "node:os";
-import path8 from "node:path";
+import path9 from "node:path";
 function resolveAgentShimHome(env = process.env, home = os.homedir(), isDirectory = isExistingDirectory) {
   const fromEnv = env.AGENT_SHIM_HOME;
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  const current = path8.join(home, HOME_DIRNAME);
-  const legacy = path8.join(home, LEGACY_HOME_DIRNAME);
+  const current = path9.join(home, HOME_DIRNAME);
+  const legacy = path9.join(home, LEGACY_HOME_DIRNAME);
   return !isDirectory(current) && isDirectory(legacy) ? legacy : current;
 }
 function isExistingDirectory(candidate) {
-  return fs2.statSync(candidate, { throwIfNoEntry: false })?.isDirectory() ?? false;
+  return fs3.statSync(candidate, { throwIfNoEntry: false })?.isDirectory() ?? false;
 }
 function resolveClaudeHome() {
   const fromEnv = process.env.AGENT_SHIM_CLAUDE_HOME;
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  return path8.join(os.homedir(), ".claude");
+  return path9.join(os.homedir(), ".claude");
 }
 function buildLayoutPaths(root) {
   return {
     root,
-    identitiesDir: path8.join(root, "identities"),
-    configProfilesDir: path8.join(root, "config-profiles"),
-    providersDir: path8.join(root, "providers"),
-    directoryRulesFile: path8.join(root, "directory-rules.json"),
-    activeIdentityFile: path8.join(root, "active-identity"),
-    globalConfigFile: path8.join(root, "config.json"),
-    categoriesLocalFile: path8.join(root, "categories.local.json"),
-    claudeShimFile: path8.join(root, "claude-shim.json"),
-    headroomDir: path8.join(root, "headroom"),
-    headroomStateFile: path8.join(root, "headroom", "state.json"),
-    headroomLockFile: path8.join(root, "headroom", "start.lock"),
-    headroomSessionsDir: path8.join(root, "headroom", "sessions"),
-    logsDir: path8.join(root, "logs"),
-    headroomLogPath: path8.join(root, "logs", "headroom.log"),
-    frontdoorDir: path8.join(root, "frontdoor"),
-    frontdoorCaDir: path8.join(root, "frontdoor", "ca"),
-    frontdoorCaCertFile: path8.join(root, "frontdoor", "ca", "ca.pem"),
-    frontdoorCaKeyFile: path8.join(root, "frontdoor", "ca", "ca.key"),
-    frontdoorCaBundlesDir: path8.join(root, "frontdoor", "ca", "bundles"),
-    frontdoorStateFile: path8.join(root, "frontdoor", "state.json"),
-    frontdoorLockFile: path8.join(root, "frontdoor", "start.lock"),
-    frontdoorSessionsDir: path8.join(root, "frontdoor", "sessions"),
-    frontdoorLogPath: path8.join(root, "logs", "frontdoor.log"),
-    usageDir: path8.join(root, "usage"),
-    usageLogDir: path8.join(root, "usage", "log"),
-    usageSnapshotsDir: path8.join(root, "usage", "snapshots"),
-    usagePicksFile: path8.join(root, "usage", "picks.json")
+    identitiesDir: path9.join(root, "identities"),
+    configProfilesDir: path9.join(root, "config-profiles"),
+    providersDir: path9.join(root, "providers"),
+    directoryRulesFile: path9.join(root, "directory-rules.json"),
+    activeIdentityFile: path9.join(root, "active-identity"),
+    globalConfigFile: path9.join(root, "config.json"),
+    categoriesLocalFile: path9.join(root, "categories.local.json"),
+    claudeShimFile: path9.join(root, "claude-shim.json"),
+    headroomDir: path9.join(root, "headroom"),
+    headroomStateFile: path9.join(root, "headroom", "state.json"),
+    headroomLockFile: path9.join(root, "headroom", "start.lock"),
+    headroomSessionsDir: path9.join(root, "headroom", "sessions"),
+    logsDir: path9.join(root, "logs"),
+    headroomLogPath: path9.join(root, "logs", "headroom.log"),
+    frontdoorDir: path9.join(root, "frontdoor"),
+    frontdoorCaDir: path9.join(root, "frontdoor", "ca"),
+    frontdoorCaCertFile: path9.join(root, "frontdoor", "ca", "ca.pem"),
+    frontdoorCaKeyFile: path9.join(root, "frontdoor", "ca", "ca.key"),
+    frontdoorCaBundlesDir: path9.join(root, "frontdoor", "ca", "bundles"),
+    frontdoorStateFile: path9.join(root, "frontdoor", "state.json"),
+    frontdoorLockFile: path9.join(root, "frontdoor", "start.lock"),
+    frontdoorSessionsDir: path9.join(root, "frontdoor", "sessions"),
+    frontdoorLogPath: path9.join(root, "logs", "frontdoor.log"),
+    usageDir: path9.join(root, "usage"),
+    usageLogDir: path9.join(root, "usage", "log"),
+    usageSnapshotsDir: path9.join(root, "usage", "snapshots"),
+    usagePicksFile: path9.join(root, "usage", "picks.json")
   };
 }
 function resolveLayoutPaths() {
   return buildLayoutPaths(resolveAgentShimHome());
 }
+
+// src/identityStore.ts
+import fs5 from "node:fs";
+import path11 from "node:path";
+
+// src/launcher/identity.ts
+function poolNameOf(selector) {
+  return selector.startsWith(POOL_SELECTOR_PREFIX) ? selector.slice(POOL_SELECTOR_PREFIX.length) : void 0;
+}
+
+// src/configProfilesStore.ts
+import fs4 from "node:fs";
+import path10 from "node:path";
+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 path10.join(paths.configProfilesDir, `${name}.json`);
+}
+function profileExists(paths, name) {
+  return fs4.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 (!fs4.existsSync(paths.configProfilesDir)) {
+    return [];
+  }
+  const names = fs4.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);
+  fs4.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 path11.join(paths.identitiesDir, name, "identity.json");
+}
+function identityExists(paths, name) {
+  return fs5.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 (!fs5.existsSync(paths.activeIdentityFile)) {
+    return void 0;
+  }
+  const raw = fs5.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 (!fs5.existsSync(paths.identitiesDir)) {
+    return [];
+  }
+  const active = readActiveIdentity(paths);
+  const names = fs5.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 === path11.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 fs5.readdirSync(paths.identitiesDir)) {
+    if (belongsToIdentity(entry, name)) {
+      fs5.rmSync(path11.join(paths.identitiesDir, entry), { recursive: true, force: true });
+    }
+  }
+  if (readActiveIdentity(paths) === name) {
+    fs5.rmSync(paths.activeIdentityFile);
+  }
+}
+
+// src/providersStore.ts
+import fs6 from "node:fs";
+import path12 from "node:path";
+
+// src/credentialCache.ts
+import { z as z7 } from "zod";
+var CachedCredentialSchema = z7.strictObject({
+  token: z7.string().min(1),
+  fetchedAt: z7.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 path12.join(paths.providersDir, `${name}.json`);
+}
+function providerExists(paths, name) {
+  return fs6.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 (!fs6.existsSync(filePath)) {
+    return void 0;
+  }
+  const raw = JSON.parse(fs6.readFileSync(filePath, "utf8"));
+  return parseProviderFile(filePath, raw);
+}
+function listProviders(paths) {
+  const names = listProviderNames(
+    (dir) => fs6.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);
+  }
+  fs6.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 });
+}
 export {
   AMBIENT_CREDENTIAL_VARS,
   CONNECT_INTERCEPT_HOST,
@@ -3726,6 +4495,9 @@ export {
   CredentialCacheSchema,
   CredentialSchema,
   CredentialSourceSchema,
+  DirectoryRuleAlreadyExistsError,
+  DirectoryRuleMissingTargetError,
+  DirectoryRuleNotFoundError,
   DirectoryRuleSchema,
   DirectoryRulesSchema,
   EXIT_FAILURE,
@@ -3735,20 +4507,38 @@ export {
   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,
@@ -3757,16 +4547,37 @@ export {
   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,
@@ -3776,7 +4587,20 @@ export {
   runFrontDoorSupervisor,
   runSupervisor,
   servedByPipeline,
+  setAllowAmbientCredential,
+  setDefaultConfigProfile,
+  setGlobalDefaultProfile,
+  setIdentityCredential,
+  setPool,
+  setProfileCategories,
+  setProfileEntries,
+  setProfileLaunchFlags,
+  setProfileMetadata,
   snapshotPath,
   startConnectServer,
-  topLevelNames
+  topLevelNames,
+  updateDirectoryRule,
+  updateProvider,
+  useIdentity,
+  writeDirectoryRules
 };