claude-use 9.6.0 → 9.7.0

package/dist/index.cjs

@@ -228,7 +228,7 @@ function isCodexProvider(provider) {
 function poolMemberIdentity(member) {
   return typeof member === "string" ? member : member.identity;
 }
-var import_node_path2, import_zod, import_trilean, CATEGORY_NAMES, OVERRIDABLE_CATEGORIES, CategoryMapSchema, DURATION_RE, DurationSchema, WhenConditionObjectSchema, WhenSchema, EntryValueSchema, ENTRY_KEY_RE, EntriesSchema, LaunchSchema, CREDENTIAL_TARGETS, PROVIDER_CREDENTIAL_TARGETS, CREDENTIAL_TARGET_VARS, ArgvSchema, CommandSourceOptions, CredentialSourceSchema, CREDENTIAL_CACHE_STORES, CredentialCacheSchema, CredentialSchema, ProviderCredentialSchema, RESERVED_PROVIDER_ENV_KEYS, ProviderEnvSchema, CODEX_EFFORTS, CODEX_LOGINS, CODEX_DEFAULT_TIER_MODELS, CodexProviderConfigSchema, ProviderRouteSchema, HttpProviderSchema, CodexProviderSchema, ProviderSchema, ConfigProfileSchema, POOL_SELECTOR_PREFIX, POOL_NAME_PATTERN, IDENTITY_NAME_PATTERN, PoolNameSchema, SELECTOR_RE, IdentitySelectorSchema, PoolMemberSchema, POOL_PREFERENCES, PoolPreferenceSchema, PoolSchema, DirectoryRuleSchema, DirectoryRulesSchema, PortableConfigSchema, HEADROOM_MODES, HEADROOM_CCR_MODES, HEADROOM_ROLLOUT_CHANNELS, INTERCEPT_CHANNELS, READ_MATURATION_CHANNELS, HeadroomGlobalConfigObjectSchema, HeadroomGlobalConfigSchema, HEADROOM_DEFAULT_SOURCE, HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES, FrontDoorGlobalConfigSchema, UPDATE_MODES, UpdateGlobalConfigSchema, GlobalConfigSchema, IdentitySchema, CategoryClassificationSchema, CategoryClassificationOverlaySchema, SHIPPED_CATEGORY_DEFAULTS;
+var import_node_path2, import_zod, import_trilean, CATEGORY_NAMES, OVERRIDABLE_CATEGORIES, CategoryMapSchema, DURATION_RE, DurationSchema, WhenConditionObjectSchema, WhenSchema, EntryValueSchema, ENTRY_KEY_RE, EntriesSchema, LaunchSchema, CREDENTIAL_TARGETS, PROVIDER_CREDENTIAL_TARGETS, CREDENTIAL_TARGET_VARS, ArgvSchema, CommandSourceOptions, EnvCredentialSourceSchema, FileCredentialSourceSchema, CommandCredentialSourceSchema, OpCredentialSourceSchema, KeychainCredentialSourceSchema, LiteralCredentialSourceSchema, CredentialSourceSchema, RemoteCredentialSourceSchema, CREDENTIAL_CACHE_STORES, CredentialCacheSchema, CredentialSchema, ProviderCredentialSchema, RESERVED_PROVIDER_ENV_KEYS, ProviderEnvSchema, PROVIDER_KINDS, CODEX_EFFORTS, CODEX_LOGINS, CODEX_DEFAULT_TIER_MODELS, CodexProviderConfigSchema, ProviderRouteSchema, HttpProviderSchema, CodexProviderSchema, ProviderSchema, ConfigProfileSchema, POOL_SELECTOR_PREFIX, POOL_NAME_PATTERN, IDENTITY_NAME_PATTERN, PoolNameSchema, SELECTOR_RE, IdentitySelectorSchema, PoolMemberSchema, POOL_PREFERENCES, PoolPreferenceSchema, PoolSchema, DirectoryRuleSchema, DirectoryRulesSchema, PortableConfigSchema, HEADROOM_MODES, HEADROOM_CCR_MODES, HEADROOM_ROLLOUT_CHANNELS, INTERCEPT_CHANNELS, READ_MATURATION_CHANNELS, HeadroomGlobalConfigObjectSchema, HeadroomGlobalConfigSchema, HEADROOM_DEFAULT_SOURCE, HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES, FrontDoorGlobalConfigSchema, UPDATE_MODES, UpdateGlobalConfigSchema, GlobalConfigSchema, IdentitySchema, CategoryClassificationSchema, CategoryClassificationOverlaySchema, SHIPPED_CATEGORY_DEFAULTS;
 var init_schema = __esm({
   "src/config/schema.ts"() {
     "use strict";
@@ -284,20 +284,33 @@ var init_schema = __esm({
       /** How long the command may run before it is killed and counted as failed. Defaults to `CREDENTIAL_COMMAND_TIMEOUT_MS`, or `CREDENTIAL_INTERACTIVE_TIMEOUT_MS` for an interactive source. */
       timeoutMs: import_zod.z.int().positive().optional()
     };
+    EnvCredentialSourceSchema = import_zod.z.strictObject({ env: import_zod.z.string().min(1) });
+    FileCredentialSourceSchema = import_zod.z.strictObject({
+      file: import_zod.z.string().min(1).refine((filePath) => filePath.startsWith("~/") || import_node_path2.default.isAbsolute(filePath), {
+        message: "a credential file must be an absolute or ~-rooted path, since a launch can start in any directory"
+      })
+    });
+    CommandCredentialSourceSchema = import_zod.z.strictObject({ command: ArgvSchema, ...CommandSourceOptions });
+    OpCredentialSourceSchema = import_zod.z.strictObject({ op: import_zod.z.string().startsWith("op://"), ...CommandSourceOptions });
+    KeychainCredentialSourceSchema = import_zod.z.strictObject({
+      keychain: import_zod.z.strictObject({ service: import_zod.z.string().min(1), account: import_zod.z.string().min(1).optional() }),
+      ...CommandSourceOptions
+    });
+    LiteralCredentialSourceSchema = import_zod.z.strictObject({ literal: import_zod.z.string().min(1) });
     CredentialSourceSchema = import_zod.z.union([
-      import_zod.z.strictObject({ env: import_zod.z.string().min(1) }),
-      import_zod.z.strictObject({
-        file: import_zod.z.string().min(1).refine((filePath) => filePath.startsWith("~/") || import_node_path2.default.isAbsolute(filePath), {
-          message: "a credential file must be an absolute or ~-rooted path, since a launch can start in any directory"
-        })
-      }),
-      import_zod.z.strictObject({ command: ArgvSchema, ...CommandSourceOptions }),
-      import_zod.z.strictObject({ op: import_zod.z.string().startsWith("op://"), ...CommandSourceOptions }),
-      import_zod.z.strictObject({
-        keychain: import_zod.z.strictObject({ service: import_zod.z.string().min(1), account: import_zod.z.string().min(1).optional() }),
-        ...CommandSourceOptions
-      }),
-      import_zod.z.strictObject({ literal: import_zod.z.string().min(1) })
+      EnvCredentialSourceSchema,
+      FileCredentialSourceSchema,
+      CommandCredentialSourceSchema,
+      OpCredentialSourceSchema,
+      KeychainCredentialSourceSchema,
+      LiteralCredentialSourceSchema
+    ]);
+    RemoteCredentialSourceSchema = import_zod.z.union([
+      EnvCredentialSourceSchema,
+      FileCredentialSourceSchema,
+      OpCredentialSourceSchema,
+      KeychainCredentialSourceSchema,
+      LiteralCredentialSourceSchema
     ]);
     CREDENTIAL_CACHE_STORES = ["keychain", "file"];
     CredentialCacheSchema = import_zod.z.strictObject({
@@ -314,6 +327,7 @@ var init_schema = __esm({
     ProviderEnvSchema = import_zod.z.record(import_zod.z.string().min(1), import_zod.z.string()).refine((env) => !Object.keys(env).some((key) => RESERVED_PROVIDER_ENV_KEYS.includes(key)), {
       message: `env may not set ${RESERVED_PROVIDER_ENV_KEYS.join(", ")}: the credential block's target sets one and agent-shim removes the others`
     });
+    PROVIDER_KINDS = ["http", "codex"];
     CODEX_EFFORTS = ["none", "low", "medium", "high"];
     CODEX_LOGINS = ["codex-cli", "chatgpt-sign-in"];
     CODEX_DEFAULT_TIER_MODELS = Object.freeze({
@@ -2649,7 +2663,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "9.6.0",
+      version: "9.7.0",
       description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
       license: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -3052,8 +3066,8 @@ function verifyHeadroomSocket(socketPath, ports) {
   }
   const uid = ports.currentUid();
   const directory = import_node_path12.default.dirname(socketPath);
-  const refusal = ownerOnlyRefusal("socket directory", directory, ports.lstat(directory), "dir", uid) ?? ownerOnlyRefusal("socket", socketPath, ports.lstat(socketPath), "socket", uid);
-  return refusal === void 0 ? { socketPath } : { refused: refusal };
+  const refusal2 = ownerOnlyRefusal("socket directory", directory, ports.lstat(directory), "dir", uid) ?? ownerOnlyRefusal("socket", socketPath, ports.lstat(socketPath), "socket", uid);
+  return refusal2 === void 0 ? { socketPath } : { refused: refusal2 };
 }
 function prepareHeadroomSocket(fs12, ports, paths, supervisorPid) {
   const unsupported = platformRefusal(ports.platform);
@@ -3071,8 +3085,8 @@ function prepareHeadroomSocket(fs12, ports, paths, supervisorPid) {
     return { refused: `the headroom socket directory ${paths.headroomSocketDir} is a symlink; it must be the real directory` };
   }
   fs12.mkdirPrivate(paths.headroomSocketDir);
-  const refusal = ownerOnlyRefusal("socket directory", paths.headroomSocketDir, ports.lstat(paths.headroomSocketDir), "dir", ports.currentUid());
-  return refusal === void 0 ? { socketPath } : { refused: refusal };
+  const refusal2 = ownerOnlyRefusal("socket directory", paths.headroomSocketDir, ports.lstat(paths.headroomSocketDir), "dir", ports.currentUid());
+  return refusal2 === void 0 ? { socketPath } : { refused: refusal2 };
 }
 function pruneStaleHeadroomSockets(fs12, paths, isRunning) {
   const removed = [];
@@ -4586,14 +4600,14 @@ function capacityOf(plan) {
   return plan.kind === "subscription" ? plan.capacity : 1;
 }
 function assessRefusedNested(member, nested, nowMs) {
-  const refusal = nested.earliestReturn === void 0 ? { reason: `no member of pool "${nested.pool}" can be picked` } : { reason: `every member of pool "${nested.pool}" is refused; ${nested.earliestReturn.identity} returns at ${new Date(nested.earliestReturn.atMs).toISOString()} (in ${formatAge(nested.earliestReturn.atMs - nowMs)})`, blockedUntilMs: nested.earliestReturn.atMs };
+  const refusal2 = nested.earliestReturn === void 0 ? { reason: `no member of pool "${nested.pool}" can be picked` } : { reason: `every member of pool "${nested.pool}" is refused; ${nested.earliestReturn.identity} returns at ${new Date(nested.earliestReturn.atMs).toISOString()} (in ${formatAge(nested.earliestReturn.atMs - nowMs)})`, blockedUntilMs: nested.earliestReturn.atMs };
   return {
     candidate: {
       identity: member.identity,
       class: "ineligible",
-      ...refusal.blockedUntilMs === void 0 ? {} : { blockedUntilMs: refusal.blockedUntilMs },
+      ...refusal2.blockedUntilMs === void 0 ? {} : { blockedUntilMs: refusal2.blockedUntilMs },
       plan: planOf(member.account),
-      reasons: [refusal.reason]
+      reasons: [refusal2.reason]
     }
   };
 }
@@ -4684,7 +4698,7 @@ function rankPool(input) {
   const assessments = members.map((member) => ({ member, ...assess(member, nowMs) }));
   const demands = assessments.flatMap(({ candidate, burn }) => burn === void 0 ? [] : [burn * capacityOf(candidate.plan)]);
   const sharedDemand = demands.length === 0 ? void 0 : Math.max(...demands);
-  const guarded = assessments.map((assessment) => {
+  const guarded2 = assessments.map((assessment) => {
     const { candidate } = assessment;
     if (candidate.class === "ineligible" || assessment.member.policy === void 0) {
       return assessment;
@@ -4699,7 +4713,7 @@ function rankPool(input) {
     }
     return { ...assessment, candidate: { ...candidate, class: "ineligible", reasons: [`skipped by policy (${verdict.checked.join(", ")}: did not hold)`, ...candidate.reasons] } };
   });
-  const candidates = guarded.map((assessment) => {
+  const candidates = guarded2.map((assessment) => {
     const { candidate, fiveHour, burn } = assessment;
     const pace = burn ?? (sharedDemand === void 0 ? void 0 : sharedDemand / capacityOf(candidate.plan));
     const { sevenDay, sevenDayBurn } = assessment;
@@ -7697,11 +7711,11 @@ var init_anthropicUsageRefresh = __esm({
 });
 
 // src/usage/providerQuota.ts
-var import_zod22, MS_PER_SECOND7, SECONDS_PER_HOUR, HOURS_PER_DAY3, DAYS_PER_MONTH, ZAI_HOST, ZAI_QUOTA_URL, ZAI_UNIT_HOURS, ZAI_UNIT_MONTHS, ZAI_UNIT_MS, ZaiLimitSchema, ZaiResponseSchema, OPENROUTER_HOST, OPENROUTER_KEY_URL, OPENROUTER_CREDITS_URL, MS_PER_DAY3, OpenRouterKeySchema, OpenRouterCreditsSchema;
+var import_zod23, MS_PER_SECOND7, SECONDS_PER_HOUR, HOURS_PER_DAY3, DAYS_PER_MONTH, ZAI_HOST, ZAI_QUOTA_URL, ZAI_UNIT_HOURS, ZAI_UNIT_MONTHS, ZAI_UNIT_MS, ZaiLimitSchema, ZaiResponseSchema, OPENROUTER_HOST, OPENROUTER_KEY_URL, OPENROUTER_CREDITS_URL, MS_PER_DAY3, OpenRouterKeySchema, OpenRouterCreditsSchema;
 var init_providerQuota = __esm({
   "src/usage/providerQuota.ts"() {
     "use strict";
-    import_zod22 = require("zod");
+    import_zod23 = require("zod");
     init_schema2();
     MS_PER_SECOND7 = 1e3;
     SECONDS_PER_HOUR = 3600;
@@ -7715,35 +7729,35 @@ var init_providerQuota = __esm({
       [ZAI_UNIT_HOURS, SECONDS_PER_HOUR * MS_PER_SECOND7],
       [ZAI_UNIT_MONTHS, DAYS_PER_MONTH * HOURS_PER_DAY3 * SECONDS_PER_HOUR * MS_PER_SECOND7]
     ]);
-    ZaiLimitSchema = import_zod22.z.object({
-      type: import_zod22.z.string(),
-      unit: import_zod22.z.number().int(),
-      number: import_zod22.z.number().int().positive(),
-      percentage: import_zod22.z.number().nonnegative(),
-      nextResetTime: import_zod22.z.number().positive().optional(),
-      usage: import_zod22.z.number().nonnegative().optional(),
-      currentValue: import_zod22.z.number().nonnegative().optional(),
-      remaining: import_zod22.z.number().nonnegative().optional()
+    ZaiLimitSchema = import_zod23.z.object({
+      type: import_zod23.z.string(),
+      unit: import_zod23.z.number().int(),
+      number: import_zod23.z.number().int().positive(),
+      percentage: import_zod23.z.number().nonnegative(),
+      nextResetTime: import_zod23.z.number().positive().optional(),
+      usage: import_zod23.z.number().nonnegative().optional(),
+      currentValue: import_zod23.z.number().nonnegative().optional(),
+      remaining: import_zod23.z.number().nonnegative().optional()
     });
-    ZaiResponseSchema = import_zod22.z.object({
-      success: import_zod22.z.boolean(),
-      msg: import_zod22.z.string().optional(),
-      data: import_zod22.z.object({ level: import_zod22.z.string().optional(), limits: import_zod22.z.array(ZaiLimitSchema) })
+    ZaiResponseSchema = import_zod23.z.object({
+      success: import_zod23.z.boolean(),
+      msg: import_zod23.z.string().optional(),
+      data: import_zod23.z.object({ level: import_zod23.z.string().optional(), limits: import_zod23.z.array(ZaiLimitSchema) })
     });
     OPENROUTER_HOST = "openrouter.ai";
     OPENROUTER_KEY_URL = `https://${OPENROUTER_HOST}/api/v1/key`;
     OPENROUTER_CREDITS_URL = `https://${OPENROUTER_HOST}/api/v1/credits`;
     MS_PER_DAY3 = HOURS_PER_DAY3 * SECONDS_PER_HOUR * MS_PER_SECOND7;
-    OpenRouterKeySchema = import_zod22.z.object({
-      data: import_zod22.z.object({
-        limit: import_zod22.z.number().nonnegative().nullable(),
-        limit_remaining: import_zod22.z.number().nullable(),
-        limit_reset: import_zod22.z.string().nullable(),
-        is_free_tier: import_zod22.z.boolean().optional(),
-        free_model_daily_requests: import_zod22.z.object({ used: import_zod22.z.number().nonnegative(), limit: import_zod22.z.number().nonnegative(), remaining: import_zod22.z.number() }).optional()
+    OpenRouterKeySchema = import_zod23.z.object({
+      data: import_zod23.z.object({
+        limit: import_zod23.z.number().nonnegative().nullable(),
+        limit_remaining: import_zod23.z.number().nullable(),
+        limit_reset: import_zod23.z.string().nullable(),
+        is_free_tier: import_zod23.z.boolean().optional(),
+        free_model_daily_requests: import_zod23.z.object({ used: import_zod23.z.number().nonnegative(), limit: import_zod23.z.number().nonnegative(), remaining: import_zod23.z.number() }).optional()
       })
     });
-    OpenRouterCreditsSchema = import_zod22.z.object({ data: import_zod22.z.object({ total_credits: import_zod22.z.number().nonnegative(), total_usage: import_zod22.z.number().nonnegative() }) });
+    OpenRouterCreditsSchema = import_zod23.z.object({ data: import_zod23.z.object({ total_credits: import_zod23.z.number().nonnegative(), total_usage: import_zod23.z.number().nonnegative() }) });
   }
 });
 
@@ -7878,10 +7892,44 @@ __export(index_exports, {
   CodexLogoutOutputSchema: () => CodexLogoutOutputSchema,
   CodexSignInSchema: () => CodexSignInSchema,
   CodexStatusOutputSchema: () => CodexStatusOutputSchema,
+  ConfigIdentityAddOutputSchema: () => ConfigIdentityAddOutputSchema,
+  ConfigIdentityRemoveInputSchema: () => ConfigIdentityRemoveInputSchema,
+  ConfigIdentityRemoveOutputSchema: () => ConfigIdentityRemoveOutputSchema,
+  ConfigIdentitySetInputSchema: () => ConfigIdentitySetInputSchema,
+  ConfigIdentitySetOutputSchema: () => ConfigIdentitySetOutputSchema,
+  ConfigIdentityUseOutputSchema: () => ConfigIdentityUseOutputSchema,
+  ConfigNameInputSchema: () => ConfigNameInputSchema,
+  ConfigPoolAddInputSchema: () => ConfigPoolAddInputSchema,
+  ConfigPoolAddOutputSchema: () => ConfigPoolAddOutputSchema,
+  ConfigPoolRemoveInputSchema: () => ConfigPoolRemoveInputSchema,
+  ConfigPoolRemoveOutputSchema: () => ConfigPoolRemoveOutputSchema,
+  ConfigPoolSetInputSchema: () => ConfigPoolSetInputSchema,
+  ConfigPoolSetOutputSchema: () => ConfigPoolSetOutputSchema,
+  ConfigPoolUseOutputSchema: () => ConfigPoolUseOutputSchema,
+  ConfigProfileAddInputSchema: () => ConfigProfileAddInputSchema,
+  ConfigProfileAddOutputSchema: () => ConfigProfileAddOutputSchema,
+  ConfigProfileRemoveInputSchema: () => ConfigProfileRemoveInputSchema,
+  ConfigProfileRemoveOutputSchema: () => ConfigProfileRemoveOutputSchema,
   ConfigProfileSchema: () => ConfigProfileSchema,
+  ConfigProfileSetInputSchema: () => ConfigProfileSetInputSchema,
+  ConfigProfileSetOutputSchema: () => ConfigProfileSetOutputSchema,
+  ConfigProfileUseOutputSchema: () => ConfigProfileUseOutputSchema,
+  ConfigProviderAddInputSchema: () => ConfigProviderAddInputSchema,
+  ConfigProviderAddOutputSchema: () => ConfigProviderAddOutputSchema,
+  ConfigProviderRemoveInputSchema: () => ConfigProviderRemoveInputSchema,
+  ConfigProviderRemoveOutputSchema: () => ConfigProviderRemoveOutputSchema,
+  ConfigProviderSetInputSchema: () => ConfigProviderSetInputSchema,
+  ConfigProviderSetOutputSchema: () => ConfigProviderSetOutputSchema,
+  ConfigRuleAddInputSchema: () => ConfigRuleAddInputSchema,
+  ConfigRuleAddOutputSchema: () => ConfigRuleAddOutputSchema,
+  ConfigRuleRemoveInputSchema: () => ConfigRuleRemoveInputSchema,
+  ConfigRuleRemoveOutputSchema: () => ConfigRuleRemoveOutputSchema,
+  ConfigRuleSetInputSchema: () => ConfigRuleSetInputSchema,
+  ConfigRuleSetOutputSchema: () => ConfigRuleSetOutputSchema,
   CredentialCacheSchema: () => CredentialCacheSchema,
   CredentialSchema: () => CredentialSchema,
   CredentialSourceSchema: () => CredentialSourceSchema,
+  CredentialSummarySchema: () => CredentialSummarySchema2,
   DOOR_EVENT_BUFFER_EVENTS: () => DOOR_EVENT_BUFFER_EVENTS,
   DOOR_EVENT_SOURCE_RC: () => DOOR_EVENT_SOURCE_RC,
   DOOR_HEALTH_EVENT_SOURCE: () => DOOR_HEALTH_EVENT_SOURCE,
@@ -8012,6 +8060,7 @@ __export(index_exports, {
   collectFrontDoorStatus: () => collectFrontDoorStatus,
   collectPoolPick: () => collectPoolPick,
   createCodexApiRouter: () => createCodexApiRouter,
+  createConfigApiRouter: () => createConfigApiRouter,
   createControlApiRouter: () => createControlApiRouter,
   createDoorApiNodeHandler: () => createDoorApiNodeHandler,
   createDoorApiRouter: () => createDoorApiRouter,
@@ -9030,6 +9079,7 @@ var HTTP_STATUS = {
   forbidden: 403,
   notFound: 404,
   methodNotAllowed: 405,
+  conflict: 409,
   payloadTooLarge: 413,
   tooManyRequests: 429,
   /** Not sent to anyone: the client is gone. Recorded for a response abandoned because the client disconnected, following the convention nginx uses for the same case. */
@@ -11155,9 +11205,9 @@ function doorApiNodeHandlerOf(router, expectedToken) {
       if (request4.method === "GET" && request4.url === `${RC_ORPC_PATH_PREFIX}${RC_OPENAPI_DOC_PATH}`) {
         const token = doorApiBearer(request4.headers);
         if (token === void 0 || !isLiveCapability(token, [expectedToken])) {
-          const refusal = new import_client.ORPCError("UNAUTHORIZED", { message: "the front door's OpenAPI document demands this generation's control token as a Bearer credential" });
+          const refusal2 = new import_client.ORPCError("UNAUTHORIZED", { message: "the front door's OpenAPI document demands this generation's control token as a Bearer credential" });
           response.writeHead(HTTP_STATUS.unauthorized, { "content-type": "application/json" });
-          response.end(JSON.stringify(refusal.toJSON()));
+          response.end(JSON.stringify(refusal2.toJSON()));
           return { matched: true };
         }
         try {
@@ -11165,9 +11215,9 @@ function doorApiNodeHandlerOf(router, expectedToken) {
           response.writeHead(HTTP_STATUS.ok, { "content-type": "application/json" });
           response.end(JSON.stringify(doc));
         } catch (error) {
-          const refusal = new import_client.ORPCError("INTERNAL_SERVER_ERROR", { message: `the OpenAPI document could not be generated from the door's own router: ${error instanceof Error ? error.message : String(error)}` });
+          const refusal2 = new import_client.ORPCError("INTERNAL_SERVER_ERROR", { message: `the OpenAPI document could not be generated from the door's own router: ${error instanceof Error ? error.message : String(error)}` });
           response.writeHead(HTTP_STATUS.internalServerError, { "content-type": "application/json" });
-          response.end(JSON.stringify(refusal.toJSON()));
+          response.end(JSON.stringify(refusal2.toJSON()));
         }
         return { matched: true };
       }
@@ -11216,8 +11266,8 @@ init_cliError();
 init_realPorts();
 
 // src/frontdoor/controlApi.ts
-var import_client5 = require("@orpc/client");
-var import_openapi6 = require("@orpc/openapi");
+var import_client6 = require("@orpc/client");
+var import_openapi7 = require("@orpc/openapi");
 
 // src/checkReport.ts
 var import_node_os5 = __toESM(require("node:os"), 1);
@@ -11401,6 +11451,48 @@ function removeProfile(paths, name) {
   requireProfileExists(paths, name);
   import_node_fs3.default.rmSync(profileJsonPath(paths, name));
 }
+function applyProfileChange(paths, name, change) {
+  let touched = false;
+  if (change.category !== void 0) {
+    setProfileCategories(paths, name, change.category);
+    touched = true;
+  }
+  if (change.entry !== void 0) {
+    setProfileEntries(paths, name, change.entry);
+    touched = true;
+  }
+  if (change.extends !== void 0 || change.description !== void 0) {
+    setProfileMetadata(paths, name, {
+      ...change.extends === void 0 ? {} : { extends: change.extends === false ? [] : change.extends },
+      ...change.description === void 0 ? {} : { description: change.description }
+    });
+    touched = true;
+  }
+  const launchPatch = {};
+  if (change.launchSkipPermissions !== void 0) {
+    launchPatch.skipPermissions = change.launchSkipPermissions;
+  }
+  if (change.launchRemoteControl !== void 0) {
+    launchPatch.remoteControl = change.launchRemoteControl;
+  }
+  if (change.launchHeadroom !== void 0) {
+    launchPatch.headroom = change.launchHeadroom;
+  }
+  if (change.launchTrackUsage !== void 0) {
+    launchPatch.trackUsage = change.launchTrackUsage;
+  }
+  if (change.launchProvider !== void 0) {
+    launchPatch.provider = change.launchProvider === false ? void 0 : change.launchProvider;
+  }
+  if (change.launchClaudeVersion !== void 0) {
+    launchPatch.claudeVersion = change.launchClaudeVersion === false ? void 0 : change.launchClaudeVersion;
+  }
+  if (Object.keys(launchPatch).length > 0) {
+    setProfileLaunchFlags(paths, name, launchPatch);
+    touched = true;
+  }
+  return touched;
+}
 
 // src/poolStore.ts
 init_store();
@@ -12174,6 +12266,14 @@ var InvalidIdentityNameError = class extends CliError {
 function identityJsonPath(paths, name) {
   return import_node_path27.default.join(paths.identitiesDir, name, "identity.json");
 }
+function requireIdentityNames(paths, names) {
+  const existing = new Set(listIdentities(paths).map((entry) => entry.name));
+  for (const name of names) {
+    if (poolNameOf(name) === void 0 && !existing.has(name)) {
+      throw new IdentityNotFoundError(name);
+    }
+  }
+}
 function identityExists(paths, name) {
   return import_node_fs8.default.existsSync(identityJsonPath(paths, name));
 }
@@ -13066,47 +13166,608 @@ function createCodexApiRouter(deps) {
   };
 }
 
-// src/frontdoor/eventsApi.ts
+// src/frontdoor/configApi.ts
 var import_client2 = require("@orpc/client");
 var import_openapi3 = require("@orpc/openapi");
+init_cliError();
+init_schema();
+init_credential();
+
+// src/credentialCacheChange.ts
+init_cliError();
+init_schema();
+function mergeCredentialCache(request4, existing) {
+  if (request4.enabled === false) {
+    return false;
+  }
+  if (request4.ttl === void 0 && request4.store === void 0 && request4.enabled !== true) {
+    return void 0;
+  }
+  const parsed = CredentialCacheSchema.safeParse({
+    ...existing,
+    ...request4.ttl === void 0 ? {} : { ttl: request4.ttl },
+    ...request4.store === void 0 ? {} : { store: request4.store }
+  });
+  if (!parsed.success) {
+    throw new UsageError(parsed.error.issues.map((issue) => issue.message).join("; "));
+  }
+  return parsed.data;
+}
+
+// src/directoryRulesStore.ts
+init_store();
+init_load();
+init_schema();
+init_cliError();
+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 });
+}
+function requireRuleSelector(paths, selector) {
+  if (selector.startsWith(POOL_SELECTOR_PREFIX)) {
+    const poolName = selector.slice(POOL_SELECTOR_PREFIX.length);
+    if (readPools(paths)[poolName] === void 0) {
+      throw new PoolNotFoundError(poolName);
+    }
+  } else if (readIdentity(paths, selector) === void 0) {
+    throw new IdentityNotFoundError(selector);
+  }
+}
+
+// src/frontdoor/configApi.ts
+init_identity();
+init_providersStore();
+
+// src/frontdoor/configSchemas.ts
+var import_zod20 = require("zod");
+init_schema();
+var RemovalConfirmationSchema = import_zod20.z.boolean();
+var CredentialWriteSchema = (targets) => import_zod20.z.strictObject({
+  sources: import_zod20.z.array(RemoteCredentialSourceSchema).min(1).optional(),
+  target: import_zod20.z.enum(targets).optional(),
+  cache: import_zod20.z.union([import_zod20.z.literal(false), CredentialCacheSchema]).optional()
+});
+var CredentialSummarySchema2 = import_zod20.z.strictObject({
+  target: import_zod20.z.enum(CREDENTIAL_TARGETS),
+  sources: import_zod20.z.readonly(import_zod20.z.array(
+    import_zod20.z.discriminatedUnion("kind", [
+      import_zod20.z.strictObject({ kind: import_zod20.z.literal("env"), variable: import_zod20.z.string() }),
+      import_zod20.z.strictObject({ kind: import_zod20.z.literal("file"), path: import_zod20.z.string() }),
+      import_zod20.z.strictObject({ kind: import_zod20.z.literal("command"), program: import_zod20.z.string() }),
+      import_zod20.z.strictObject({ kind: import_zod20.z.literal("op"), reference: import_zod20.z.string() }),
+      import_zod20.z.strictObject({ kind: import_zod20.z.literal("keychain"), service: import_zod20.z.string(), account: import_zod20.z.string().optional() }),
+      import_zod20.z.strictObject({ kind: import_zod20.z.literal("literal") })
+    ])
+  )),
+  cache: CredentialCacheSchema.optional()
+});
+var mutationOutput = (kind, action) => import_zod20.z.strictObject({ action: import_zod20.z.literal(action), kind: import_zod20.z.literal(kind), name: import_zod20.z.string() });
+var storedMutationOutput = (kind, action, value) => import_zod20.z.strictObject({ action: import_zod20.z.literal(action), kind: import_zod20.z.literal(kind), name: import_zod20.z.string(), value });
+var IdentityValueSchema = import_zod20.z.strictObject({
+  name: import_zod20.z.string(),
+  defaultConfigProfile: import_zod20.z.string().optional(),
+  allowAmbientCredential: import_zod20.z.boolean(),
+  credential: CredentialSummarySchema2.optional()
+});
+var ProfileValueSchema = ConfigProfileSchema.omit({ $schema: true });
+var ProviderValueSchema = import_zod20.z.strictObject({
+  name: import_zod20.z.string(),
+  kind: import_zod20.z.enum(PROVIDER_KINDS),
+  displayName: import_zod20.z.string(),
+  baseUrl: import_zod20.z.string().optional(),
+  codex: CodexProviderConfigSchema.optional(),
+  credential: CredentialSummarySchema2,
+  env: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.string()).optional()
+});
+var ConfigNameInputSchema = import_zod20.z.strictObject({ name: import_zod20.z.string().min(1) });
+var ConfigIdentityAddOutputSchema = storedMutationOutput("identity", "created", IdentityValueSchema);
+var ConfigIdentitySetInputSchema = import_zod20.z.strictObject({
+  name: import_zod20.z.string().min(1),
+  defaultConfigProfile: import_zod20.z.union([import_zod20.z.string().min(1), import_zod20.z.literal(false)]).optional(),
+  allowAmbientCredential: import_zod20.z.boolean().optional(),
+  credential: import_zod20.z.union([import_zod20.z.literal(false), CredentialWriteSchema(CREDENTIAL_TARGETS)]).optional()
+});
+var ConfigIdentitySetOutputSchema = storedMutationOutput("identity", "updated", IdentityValueSchema);
+var ConfigIdentityRemoveInputSchema = import_zod20.z.strictObject({ name: import_zod20.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigIdentityRemoveOutputSchema = mutationOutput("identity", "removed");
+var ConfigIdentityUseOutputSchema = mutationOutput("identity", "selected");
+var ConfigProfileAddInputSchema = import_zod20.z.strictObject({
+  name: import_zod20.z.string().min(1),
+  extends: import_zod20.z.array(import_zod20.z.string().min(1)).optional(),
+  description: import_zod20.z.string().optional()
+});
+var ConfigProfileAddOutputSchema = storedMutationOutput("profile", "created", ProfileValueSchema);
+var ConfigProfileSetInputSchema = import_zod20.z.strictObject({
+  name: import_zod20.z.string().min(1),
+  category: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.boolean()).optional(),
+  entry: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.boolean()).optional(),
+  extends: import_zod20.z.union([import_zod20.z.array(import_zod20.z.string().min(1)), import_zod20.z.literal(false)]).optional(),
+  description: import_zod20.z.union([import_zod20.z.string(), import_zod20.z.literal(false)]).optional(),
+  launch: import_zod20.z.strictObject({
+    skipPermissions: import_zod20.z.boolean().optional(),
+    remoteControl: import_zod20.z.boolean().optional(),
+    headroom: import_zod20.z.boolean().optional(),
+    trackUsage: import_zod20.z.boolean().optional(),
+    provider: import_zod20.z.union([import_zod20.z.string().min(1), import_zod20.z.literal(false)]).optional(),
+    claudeVersion: import_zod20.z.union([import_zod20.z.string().min(1), import_zod20.z.literal(false)]).optional()
+  }).optional()
+});
+var ConfigProfileSetOutputSchema = storedMutationOutput("profile", "updated", ProfileValueSchema);
+var ConfigProfileRemoveInputSchema = import_zod20.z.strictObject({ name: import_zod20.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProfileRemoveOutputSchema = mutationOutput("profile", "removed");
+var ConfigProfileUseOutputSchema = mutationOutput("profile", "selected");
+var PoolMembersInputSchema = import_zod20.z.array(import_zod20.z.string().min(1)).min(1);
+var ConfigPoolAddInputSchema = import_zod20.z.strictObject({
+  name: import_zod20.z.string().min(1),
+  identities: PoolMembersInputSchema,
+  preference: import_zod20.z.enum(POOL_PREFERENCES).optional()
+});
+var ConfigPoolAddOutputSchema = storedMutationOutput("pool", "created", PoolSchema);
+var ConfigPoolSetInputSchema = import_zod20.z.strictObject({
+  name: import_zod20.z.string().min(1),
+  identities: PoolMembersInputSchema.optional(),
+  preference: import_zod20.z.union([import_zod20.z.enum(POOL_PREFERENCES), import_zod20.z.literal(false)]).optional()
+});
+var ConfigPoolSetOutputSchema = storedMutationOutput("pool", "updated", PoolSchema);
+var ConfigPoolRemoveInputSchema = import_zod20.z.strictObject({ name: import_zod20.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigPoolRemoveOutputSchema = mutationOutput("pool", "removed");
+var ConfigPoolUseOutputSchema = mutationOutput("pool", "selected");
+var ConfigProviderAddInputSchema = import_zod20.z.strictObject({
+  name: import_zod20.z.string().min(1),
+  kind: import_zod20.z.enum(PROVIDER_KINDS).optional(),
+  displayName: import_zod20.z.string().min(1),
+  baseUrl: import_zod20.z.string().min(1).optional(),
+  credential: CredentialWriteSchema(PROVIDER_CREDENTIAL_TARGETS).required({ sources: true }),
+  codex: CodexProviderConfigSchema.optional()
+});
+var ConfigProviderAddOutputSchema = storedMutationOutput("provider", "created", ProviderValueSchema);
+var ConfigProviderSetInputSchema = import_zod20.z.strictObject({
+  name: import_zod20.z.string().min(1),
+  displayName: import_zod20.z.string().min(1).optional(),
+  baseUrl: import_zod20.z.string().min(1).optional(),
+  credential: CredentialWriteSchema(PROVIDER_CREDENTIAL_TARGETS).optional(),
+  codex: CodexProviderConfigSchema.optional()
+});
+var ConfigProviderSetOutputSchema = storedMutationOutput("provider", "updated", ProviderValueSchema);
+var ConfigProviderRemoveInputSchema = import_zod20.z.strictObject({ name: import_zod20.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProviderRemoveOutputSchema = mutationOutput("provider", "removed");
+var ConfigRuleAddInputSchema = import_zod20.z.strictObject({
+  path: import_zod20.z.string().min(1),
+  configProfile: import_zod20.z.string().min(1).optional(),
+  identity: import_zod20.z.string().min(1).optional()
+});
+var ConfigRuleAddOutputSchema = storedMutationOutput("rule", "created", DirectoryRuleSchema);
+var ConfigRuleSetInputSchema = import_zod20.z.strictObject({
+  path: import_zod20.z.string().min(1),
+  configProfile: import_zod20.z.union([import_zod20.z.string().min(1), import_zod20.z.literal(false)]).optional(),
+  identity: import_zod20.z.union([import_zod20.z.string().min(1), import_zod20.z.literal(false)]).optional()
+});
+var ConfigRuleSetOutputSchema = storedMutationOutput("rule", "updated", DirectoryRuleSchema);
+var ConfigRuleRemoveInputSchema = import_zod20.z.strictObject({ path: import_zod20.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigRuleRemoveOutputSchema = mutationOutput("rule", "removed");
+
+// src/frontdoor/configApi.ts
+var CONFIG_API_TAG = "config";
+function refusal(error) {
+  if (error instanceof IdentityNotFoundError || error instanceof ProfileNotFoundError || error instanceof PoolNotFoundError || error instanceof ProviderNotFoundError || error instanceof DirectoryRuleNotFoundError) {
+    throw new import_client2.ORPCError("NOT_FOUND", { message: error.message });
+  }
+  if (error instanceof IdentityAlreadyExistsError || error instanceof ProfileAlreadyExistsError || error instanceof PoolAlreadyExistsError || error instanceof ProviderAlreadyExistsError || error instanceof DirectoryRuleAlreadyExistsError) {
+    throw new import_client2.ORPCError("CONFLICT", { message: error.message });
+  }
+  if (error instanceof CliError) {
+    throw new import_client2.ORPCError("BAD_REQUEST", { message: error.message });
+  }
+  throw error;
+}
+function guarded(write) {
+  try {
+    return write();
+  } catch (error) {
+    return refusal(error);
+  }
+}
+function requireConfirmation(confirm, what) {
+  if (!confirm) {
+    throw new import_client2.ORPCError("BAD_REQUEST", { message: `removing ${what} needs confirm: true, the API's form of the CLI's --yes` });
+  }
+}
+function requireChange(given, fields) {
+  if (!given) {
+    throw new import_client2.ORPCError("BAD_REQUEST", { message: `Nothing to change: pass ${fields}.` });
+  }
+}
+function identityValue(name, paths) {
+  const identity = readIdentity(paths, name);
+  if (identity === void 0) {
+    throw new IdentityNotFoundError(name);
+  }
+  return {
+    name: identity.name,
+    ...identity.defaultConfigProfile === void 0 ? {} : { defaultConfigProfile: identity.defaultConfigProfile },
+    allowAmbientCredential: identity.allowAmbientCredential,
+    ...identity.credential === void 0 ? {} : { credential: summariseCredential(identity.credential) }
+  };
+}
+function providerValue(name, provider) {
+  return {
+    name,
+    kind: provider.kind ?? "http",
+    displayName: provider.displayName,
+    ...isCodexProvider(provider) ? provider.codex === void 0 ? {} : { codex: provider.codex } : { baseUrl: provider.baseUrl },
+    credential: summariseCredential(provider.credential),
+    ...provider.env === void 0 ? {} : { env: provider.env }
+  };
+}
+function profileValue(name, paths) {
+  const profile = { ...readProfile(paths, name) };
+  delete profile.$schema;
+  return profile;
+}
+function createConfigApiRouter(deps) {
+  const authed = doorApiAuth(deps.expectedToken);
+  const { paths } = deps;
+  const route = (path36, summary) => authed.meta((0, import_openapi3.openapi)({ method: "POST", path: path36, summary, tags: [CONFIG_API_TAG] }));
+  return {
+    config: {
+      identity: {
+        add: route("/rest/config/identity/add", "Create an identity").input(ConfigNameInputSchema).output(ConfigIdentityAddOutputSchema).handler(
+          ({ input }) => guarded(() => {
+            addIdentity(paths, input.name);
+            return { action: "created", kind: "identity", name: input.name, value: identityValue(input.name, paths) };
+          })
+        ),
+        set: route("/rest/config/identity/set", "Update an identity's default profile, ambient-credential setting or credential").input(ConfigIdentitySetInputSchema).output(ConfigIdentitySetOutputSchema).handler(
+          ({ input }) => guarded(() => {
+            requireChange(input.defaultConfigProfile !== void 0 || input.allowAmbientCredential !== void 0 || input.credential !== void 0, "defaultConfigProfile, allowAmbientCredential or credential");
+            if (!identityExists(paths, input.name)) {
+              throw new IdentityNotFoundError(input.name);
+            }
+            if (typeof input.defaultConfigProfile === "string") {
+              requireProfileExists(paths, input.defaultConfigProfile);
+            }
+            if (input.defaultConfigProfile !== void 0) {
+              setDefaultConfigProfile(paths, input.name, input.defaultConfigProfile === false ? void 0 : input.defaultConfigProfile);
+            }
+            if (input.allowAmbientCredential !== void 0) {
+              setAllowAmbientCredential(paths, input.name, input.allowAmbientCredential);
+            }
+            if (input.credential === false) {
+              setIdentityCredential(paths, input.name, false);
+            } else if (input.credential !== void 0) {
+              const { sources, target, cache } = input.credential;
+              const merged = cache === void 0 ? void 0 : mergeCredentialCache(cache === false ? { enabled: false } : { ...cache, enabled: true }, readIdentity(paths, input.name)?.credential?.cache);
+              const change = {
+                ...sources === void 0 ? {} : { sources },
+                ...target === void 0 ? {} : { target },
+                ...merged === void 0 ? {} : { cache: merged }
+              };
+              setIdentityCredential(paths, input.name, change);
+            }
+            return { action: "updated", kind: "identity", name: input.name, value: identityValue(input.name, paths) };
+          })
+        ),
+        remove: route("/rest/config/identity/remove", "Delete an identity and its directory").input(ConfigIdentityRemoveInputSchema).output(ConfigIdentityRemoveOutputSchema).handler(({ input }) => {
+          requireConfirmation(input.confirm, `identity "${input.name}" and its directory`);
+          return guarded(() => {
+            removeIdentity(paths, input.name);
+            return { action: "removed", kind: "identity", name: input.name };
+          });
+        }),
+        use: route("/rest/config/identity/use", "Select the active identity").input(ConfigNameInputSchema).output(ConfigIdentityUseOutputSchema).handler(
+          ({ input }) => guarded(() => {
+            if (poolNameOf(input.name) === void 0 && !identityExists(paths, input.name)) {
+              throw new IdentityNotFoundError(input.name);
+            }
+            useIdentity(paths, input.name);
+            return { action: "selected", kind: "identity", name: input.name };
+          })
+        )
+      },
+      profile: {
+        add: route("/rest/config/profile/add", "Create a configuration profile").input(ConfigProfileAddInputSchema).output(ConfigProfileAddOutputSchema).handler(
+          ({ input }) => guarded(() => {
+            createProfile(paths, input.name, input.extends, input.description);
+            return { action: "created", kind: "profile", name: input.name, value: profileValue(input.name, paths) };
+          })
+        ),
+        set: route("/rest/config/profile/set", "Update a configuration profile's categories, entries, extends list, description or launch settings").input(ConfigProfileSetInputSchema).output(ConfigProfileSetOutputSchema).handler(
+          ({ input }) => guarded(() => {
+            const { launch } = input;
+            requireChange(
+              input.category !== void 0 || input.entry !== void 0 || input.extends !== void 0 || input.description !== void 0 || launch !== void 0,
+              "category, entry, extends, description or launch"
+            );
+            requireProfileExists(paths, input.name);
+            applyProfileChange(paths, input.name, {
+              ...input.category === void 0 ? {} : { category: input.category },
+              ...input.entry === void 0 ? {} : { entry: input.entry },
+              ...input.extends === void 0 ? {} : { extends: input.extends },
+              ...input.description === void 0 ? {} : { description: input.description },
+              ...launch?.skipPermissions === void 0 ? {} : { launchSkipPermissions: launch.skipPermissions },
+              ...launch?.remoteControl === void 0 ? {} : { launchRemoteControl: launch.remoteControl },
+              ...launch?.headroom === void 0 ? {} : { launchHeadroom: launch.headroom },
+              ...launch?.trackUsage === void 0 ? {} : { launchTrackUsage: launch.trackUsage },
+              ...launch?.provider === void 0 ? {} : { launchProvider: launch.provider },
+              ...launch?.claudeVersion === void 0 ? {} : { launchClaudeVersion: launch.claudeVersion }
+            });
+            return { action: "updated", kind: "profile", name: input.name, value: profileValue(input.name, paths) };
+          })
+        ),
+        remove: route("/rest/config/profile/remove", "Delete a configuration profile").input(ConfigProfileRemoveInputSchema).output(ConfigProfileRemoveOutputSchema).handler(({ input }) => {
+          requireConfirmation(input.confirm, `configuration profile "${input.name}"`);
+          return guarded(() => {
+            removeProfile(paths, input.name);
+            return { action: "removed", kind: "profile", name: input.name };
+          });
+        }),
+        use: route("/rest/config/profile/use", "Make a configuration profile the global default").input(ConfigNameInputSchema).output(ConfigProfileUseOutputSchema).handler(
+          ({ input }) => guarded(() => {
+            requireProfileExists(paths, input.name);
+            setGlobalDefaultProfile(paths, input.name);
+            return { action: "selected", kind: "profile", name: input.name };
+          })
+        )
+      },
+      pool: {
+        add: route("/rest/config/pool/add", "Define a pool").input(ConfigPoolAddInputSchema).output(ConfigPoolAddOutputSchema).handler(
+          ({ input }) => guarded(() => {
+            requireIdentityNames(paths, input.identities);
+            const created = addPool(paths, input.name, input.identities, input.preference);
+            return { action: "created", kind: "pool", name: input.name, value: created };
+          })
+        ),
+        set: route("/rest/config/pool/set", "Replace a pool's members, its preference or both").input(ConfigPoolSetInputSchema).output(ConfigPoolSetOutputSchema).handler(
+          ({ input }) => guarded(() => {
+            requireChange(input.identities !== void 0 || input.preference !== void 0, "identities or preference");
+            const existing = requirePool(paths, input.name);
+            if (input.identities !== void 0) {
+              requireIdentityNames(paths, input.identities);
+            }
+            const members = input.identities ?? existing.identities;
+            const preference = input.preference === void 0 ? existing.preference : input.preference === false ? void 0 : input.preference;
+            return { action: "updated", kind: "pool", name: input.name, value: setPool(paths, input.name, members, preference) };
+          })
+        ),
+        remove: route("/rest/config/pool/remove", "Delete a pool").input(ConfigPoolRemoveInputSchema).output(ConfigPoolRemoveOutputSchema).handler(({ input }) => {
+          requireConfirmation(input.confirm, `pool "${input.name}"`);
+          return guarded(() => {
+            removePool(paths, input.name);
+            return { action: "removed", kind: "pool", name: input.name };
+          });
+        }),
+        use: route("/rest/config/pool/use", "Make launches with no other selection pick a member of a pool").input(ConfigNameInputSchema).output(ConfigPoolUseOutputSchema).handler(
+          ({ input }) => guarded(() => {
+            if (readPools(paths)[input.name] === void 0) {
+              throw new PoolNotFoundError(input.name);
+            }
+            useIdentity(paths, `pool:${input.name}`);
+            return { action: "selected", kind: "pool", name: input.name };
+          })
+        )
+      },
+      provider: {
+        add: route("/rest/config/provider/add", "Create an API provider definition").input(ConfigProviderAddInputSchema).output(ConfigProviderAddOutputSchema).handler(
+          ({ input }) => guarded(() => {
+            const created = addProvider(paths, input.name, {
+              ...input.kind === void 0 ? {} : { kind: input.kind },
+              displayName: input.displayName,
+              ...input.baseUrl === void 0 ? {} : { baseUrl: input.baseUrl },
+              sources: input.credential.sources,
+              ...input.credential.target === void 0 ? {} : { target: input.credential.target },
+              ...input.codex === void 0 ? {} : { codex: input.codex }
+            });
+            const cache = input.credential.cache;
+            const stored = cache === void 0 || cache === false ? created : updateProvider(paths, input.name, { cache });
+            return { action: "created", kind: "provider", name: input.name, value: providerValue(input.name, stored) };
+          })
+        ),
+        set: route("/rest/config/provider/set", "Update an API provider definition").input(ConfigProviderSetInputSchema).output(ConfigProviderSetOutputSchema).handler(
+          ({ input }) => guarded(() => {
+            requireChange(input.displayName !== void 0 || input.baseUrl !== void 0 || input.credential !== void 0 || input.codex !== void 0, "displayName, baseUrl, credential or codex");
+            const existing = readProvider(paths, input.name);
+            if (existing === void 0) {
+              throw new ProviderNotFoundError(input.name);
+            }
+            const credential = input.credential;
+            if (input.baseUrl !== void 0 && !isCodexProvider(existing) && input.baseUrl !== existing.baseUrl && credential?.sources === void 0) {
+              throw new import_client2.ORPCError("BAD_REQUEST", { message: `Changing the base URL of provider "${input.name}" requires a credential block in the same call: the stored credential is not sent to a different endpoint.` });
+            }
+            const cache = credential?.cache === void 0 ? void 0 : mergeCredentialCache(credential.cache === false ? { enabled: false } : { ...credential.cache, enabled: true }, existing.credential.cache);
+            const updated = updateProvider(paths, input.name, {
+              ...input.displayName === void 0 ? {} : { displayName: input.displayName },
+              ...input.baseUrl === void 0 ? {} : { baseUrl: input.baseUrl },
+              ...credential?.sources === void 0 ? {} : { sources: credential.sources },
+              ...credential?.target === void 0 ? {} : { target: credential.target },
+              ...cache === void 0 ? {} : { cache },
+              ...input.codex === void 0 ? {} : { codex: input.codex }
+            });
+            return { action: "updated", kind: "provider", name: input.name, value: providerValue(input.name, updated) };
+          })
+        ),
+        remove: route("/rest/config/provider/remove", "Delete an API provider definition").input(ConfigProviderRemoveInputSchema).output(ConfigProviderRemoveOutputSchema).handler(({ input }) => {
+          requireConfirmation(input.confirm, `provider "${input.name}"`);
+          return guarded(() => {
+            if (!providerExists(paths, input.name)) {
+              throw new ProviderNotFoundError(input.name);
+            }
+            removeProvider(paths, input.name);
+            return { action: "removed", kind: "provider", name: input.name };
+          });
+        })
+      },
+      rule: {
+        add: route("/rest/config/rule/add", "Add a directory rule for a path").input(ConfigRuleAddInputSchema).output(ConfigRuleAddOutputSchema).handler(
+          ({ input }) => guarded(() => {
+            if (input.identity !== void 0) {
+              requireRuleSelector(paths, input.identity);
+            }
+            if (input.configProfile !== void 0) {
+              requireProfileExists(paths, input.configProfile);
+            }
+            const created = addDirectoryRule(paths, input.path, {
+              ...input.configProfile === void 0 ? {} : { configProfile: input.configProfile },
+              ...input.identity === void 0 ? {} : { identity: input.identity }
+            });
+            return { action: "created", kind: "rule", name: input.path, value: created };
+          })
+        ),
+        set: route("/rest/config/rule/set", "Update the directory rule for a path").input(ConfigRuleSetInputSchema).output(ConfigRuleSetOutputSchema).handler(
+          ({ input }) => guarded(() => {
+            requireChange(input.configProfile !== void 0 || input.identity !== void 0, "configProfile or identity");
+            if (typeof input.identity === "string") {
+              requireRuleSelector(paths, input.identity);
+            }
+            if (typeof input.configProfile === "string") {
+              requireProfileExists(paths, input.configProfile);
+            }
+            const updated = updateDirectoryRule(paths, input.path, {
+              ...input.configProfile === void 0 ? {} : { configProfile: input.configProfile },
+              ...input.identity === void 0 ? {} : { identity: input.identity }
+            });
+            return { action: "updated", kind: "rule", name: input.path, value: updated };
+          })
+        ),
+        remove: route("/rest/config/rule/remove", "Remove the directory rule for a path").input(ConfigRuleRemoveInputSchema).output(ConfigRuleRemoveOutputSchema).handler(({ input }) => {
+          requireConfirmation(input.confirm, `the directory rule for "${input.path}"`);
+          return guarded(() => {
+            if (!listDirectoryRules(paths).some((entry) => entry.path === input.path)) {
+              throw new DirectoryRuleNotFoundError(input.path);
+            }
+            removeDirectoryRule(paths, input.path);
+            return { action: "removed", kind: "rule", name: input.path };
+          });
+        })
+      }
+    }
+  };
+}
+
+// src/frontdoor/eventsApi.ts
+var import_client3 = require("@orpc/client");
+var import_openapi4 = require("@orpc/openapi");
 var import_server3 = require("@orpc/server");
 
 // src/frontdoor/eventSchemas.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 var DOOR_EVENT_SOURCE_RC = "rc";
 var LAUNCH_EVENT_SOURCE = "launch";
 var USAGE_EVENT_SOURCE = "usage";
 var DOOR_HEALTH_EVENT_SOURCE = "door";
 var QUOTA_EXPIRING_EVENT_SOURCE = "quota-expiring";
-var DoorEventSchema = import_zod20.z.strictObject({
-  source: import_zod20.z.string().min(1),
+var DoorEventSchema = import_zod21.z.strictObject({
+  source: import_zod21.z.string().min(1),
   /** A positive integer because the backbone's counters start at one and only ever increase. */
-  sequence: import_zod20.z.number().int().positive(),
-  payload: import_zod20.z.unknown()
-});
-var DoorEventSourceQuerySchema = import_zod20.z.strictObject({
-  sources: import_zod20.z.array(import_zod20.z.string().min(1)).min(1).optional()
-});
-var LaunchLifecycleEventSchema = import_zod20.z.strictObject({
-  kind: import_zod20.z.enum(["registered", "pruned", "ended"]),
-  pid: import_zod20.z.number().int().positive(),
-  startedAt: import_zod20.z.number(),
-  observedAt: import_zod20.z.number()
-});
-var DoorHealthEventSchema = import_zod20.z.discriminatedUnion("kind", [
-  import_zod20.z.strictObject({ kind: import_zod20.z.literal("generation"), pid: import_zod20.z.number().int().positive(), providerPort: import_zod20.z.number().int().positive(), connectPort: import_zod20.z.number().int().positive(), directPort: import_zod20.z.number().int().positive(), observedAt: import_zod20.z.number() }),
-  import_zod20.z.strictObject({ kind: import_zod20.z.literal("listenerFailed"), pid: import_zod20.z.number().int().positive(), listener: import_zod20.z.enum(["provider", "connect", "direct"]), message: import_zod20.z.string(), observedAt: import_zod20.z.number() }),
-  import_zod20.z.strictObject({ kind: import_zod20.z.literal("binaryTurnover"), pid: import_zod20.z.number().int().positive(), observedAt: import_zod20.z.number() }),
-  import_zod20.z.strictObject({ kind: import_zod20.z.literal("idleShutdown"), pid: import_zod20.z.number().int().positive(), observedAt: import_zod20.z.number() })
+  sequence: import_zod21.z.number().int().positive(),
+  payload: import_zod21.z.unknown()
+});
+var DoorEventSourceQuerySchema = import_zod21.z.strictObject({
+  sources: import_zod21.z.array(import_zod21.z.string().min(1)).min(1).optional()
+});
+var LaunchLifecycleEventSchema = import_zod21.z.strictObject({
+  kind: import_zod21.z.enum(["registered", "pruned", "ended"]),
+  pid: import_zod21.z.number().int().positive(),
+  startedAt: import_zod21.z.number(),
+  observedAt: import_zod21.z.number()
+});
+var DoorHealthEventSchema = import_zod21.z.discriminatedUnion("kind", [
+  import_zod21.z.strictObject({ kind: import_zod21.z.literal("generation"), pid: import_zod21.z.number().int().positive(), providerPort: import_zod21.z.number().int().positive(), connectPort: import_zod21.z.number().int().positive(), directPort: import_zod21.z.number().int().positive(), observedAt: import_zod21.z.number() }),
+  import_zod21.z.strictObject({ kind: import_zod21.z.literal("listenerFailed"), pid: import_zod21.z.number().int().positive(), listener: import_zod21.z.enum(["provider", "connect", "direct"]), message: import_zod21.z.string(), observedAt: import_zod21.z.number() }),
+  import_zod21.z.strictObject({ kind: import_zod21.z.literal("binaryTurnover"), pid: import_zod21.z.number().int().positive(), observedAt: import_zod21.z.number() }),
+  import_zod21.z.strictObject({ kind: import_zod21.z.literal("idleShutdown"), pid: import_zod21.z.number().int().positive(), observedAt: import_zod21.z.number() })
 ]);
-var QuotaExpiringEventSchema = import_zod20.z.strictObject({
-  identity: import_zod20.z.string().min(1),
-  provider: import_zod20.z.string().min(1),
-  window: import_zod20.z.enum(["fiveHour", "sevenDay"]),
+var QuotaExpiringEventSchema = import_zod21.z.strictObject({
+  identity: import_zod21.z.string().min(1),
+  provider: import_zod21.z.string().min(1),
+  window: import_zod21.z.enum(["fiveHour", "sevenDay"]),
   /** The fraction of the window already used when it was seen expiring, always below one because a fully used window has nothing left to spend. */
-  utilization: import_zod20.z.number().min(0).max(1),
-  resetsAt: import_zod20.z.iso.datetime(),
-  observedAt: import_zod20.z.number()
+  utilization: import_zod21.z.number().min(0).max(1),
+  resetsAt: import_zod21.z.iso.datetime(),
+  observedAt: import_zod21.z.number()
 });
 
 // src/frontdoor/eventsApi.ts
@@ -13115,12 +13776,12 @@ function createEventsApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   return {
     events: {
-      subscribe: authed.meta((0, import_openapi3.openapi)({ method: "GET", path: "/rest/events", summary: "Stream the door's every event source (SSE)", tags: [EVENTS_API_TAG] })).input(DoorEventSourceQuerySchema).output((0, import_server3.eventIterator)(DoorEventSchema)).handler(async function* ({ input, signal }) {
+      subscribe: authed.meta((0, import_openapi4.openapi)({ method: "GET", path: "/rest/events", summary: "Stream the door's every event source (SSE)", tags: [EVENTS_API_TAG] })).input(DoorEventSourceQuerySchema).output((0, import_server3.eventIterator)(DoorEventSchema)).handler(async function* ({ input, signal }) {
         if (input.sources !== void 0) {
           const live = deps.events.sources();
           const unknown = input.sources.filter((source) => !live.includes(source));
           if (unknown.length > 0) {
-            throw new import_client2.ORPCError("NOT_FOUND", { message: `the door publishes no event source named ${unknown.map((source) => `"${source}"`).join(", ")}; the live sources are ${live.map((source) => `"${source}"`).join(", ")}` });
+            throw new import_client3.ORPCError("NOT_FOUND", { message: `the door publishes no event source named ${unknown.map((source) => `"${source}"`).join(", ")}; the live sources are ${live.map((source) => `"${source}"`).join(", ")}` });
           }
         }
         const stream = deps.events.stream(input.sources);
@@ -13148,8 +13809,8 @@ function createEventsApiRouter(deps) {
 }
 
 // src/frontdoor/lifecycleApi.ts
-var import_client3 = require("@orpc/client");
-var import_openapi4 = require("@orpc/openapi");
+var import_client4 = require("@orpc/client");
+var import_openapi5 = require("@orpc/openapi");
 init_update();
 var FRONTDOOR_API_TAG = "frontdoor";
 var UPDATE_API_TAG = "update";
@@ -13157,24 +13818,24 @@ function createLifecycleApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   return {
     frontdoor: {
-      restart: authed.meta((0, import_openapi4.openapi)({ method: "POST", path: "/rest/frontdoor/restart", summary: "Replace the serving front door in place", description: "Answers with the pid of the door being replaced, then replaces it. The replacement is a new generation with its own control token: the caller reopens its client from the state root once the door's supervisor pid differs from the one returned.", tags: [FRONTDOOR_API_TAG] })).output(FrontDoorRestartOutputSchema).handler(({ context }) => {
+      restart: authed.meta((0, import_openapi5.openapi)({ method: "POST", path: "/rest/frontdoor/restart", summary: "Replace the serving front door in place", description: "Answers with the pid of the door being replaced, then replaces it. The replacement is a new generation with its own control token: the caller reopens its client from the state root once the door's supervisor pid differs from the one returned.", tags: [FRONTDOOR_API_TAG] })).output(FrontDoorRestartOutputSchema).handler(({ context }) => {
         context.afterResponse(deps.restartDoor);
         return { action: "restarting", previousPid: deps.doorPid };
       })
     },
     update: {
-      check: authed.meta((0, import_openapi4.openapi)({ method: "GET", path: "/rest/update/check", summary: "Check whether a newer release exists", tags: [UPDATE_API_TAG] })).output(UpdateCheckOutputSchema).handler(async () => {
+      check: authed.meta((0, import_openapi5.openapi)({ method: "GET", path: "/rest/update/check", summary: "Check whether a newer release exists", tags: [UPDATE_API_TAG] })).output(UpdateCheckOutputSchema).handler(async () => {
         try {
           return await deps.checkForUpdate();
         } catch (error) {
           if (error instanceof UpdateChannelError) {
-            throw new import_client3.ORPCError("PRECONDITION_FAILED", { message: error.message });
+            throw new import_client4.ORPCError("PRECONDITION_FAILED", { message: error.message });
           }
           if (error instanceof UpdateConflictError) {
-            throw new import_client3.ORPCError("CONFLICT", { message: error.message });
+            throw new import_client4.ORPCError("CONFLICT", { message: error.message });
           }
           if (error instanceof UpdateDownloadError) {
-            throw new import_client3.ORPCError("BAD_GATEWAY", { message: error.message });
+            throw new import_client4.ORPCError("BAD_GATEWAY", { message: error.message });
           }
           throw error;
         }
@@ -13184,57 +13845,57 @@ function createLifecycleApiRouter(deps) {
 }
 
 // src/frontdoor/launchApi.ts
-var import_client4 = require("@orpc/client");
-var import_openapi5 = require("@orpc/openapi");
+var import_client5 = require("@orpc/client");
+var import_openapi6 = require("@orpc/openapi");
 init_cliError();
 
 // src/frontdoor/launchSchemas.ts
 var import_node_path30 = __toESM(require("node:path"), 1);
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 init_claudeVersion();
 init_identity();
-var LaunchResolveInputSchema = import_zod21.z.strictObject({
-  path: import_zod21.z.string().min(1),
+var LaunchResolveInputSchema = import_zod22.z.strictObject({
+  path: import_zod22.z.string().min(1),
   /** `@name`, launch flags, then the arguments for `claude`; empty for a bare launch. */
-  argv: import_zod21.z.readonly(import_zod21.z.array(import_zod21.z.string())).optional(),
+  argv: import_zod22.z.readonly(import_zod22.z.array(import_zod22.z.string())).optional(),
   /** The launch's inherited environment. Absent means an empty one: the door's own environment is never a substitute for the caller's, so a caller that wants `AGENT_SHIM_*` switches or a `CLAUDE_CONFIG_DIR` considered names them here. Values are read, never reported. */
-  env: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.string()).optional()
+  env: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).optional()
 }).refine((input) => import_node_path30.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
-var LaunchPoolDecisionSchema = import_zod21.z.strictObject({
-  name: import_zod21.z.string(),
-  reasons: import_zod21.z.readonly(import_zod21.z.array(import_zod21.z.string())),
-  movedOff: import_zod21.z.strictObject({ identity: import_zod21.z.string(), reason: import_zod21.z.string() }).optional()
-});
-var LaunchDecisionSchema = import_zod21.z.strictObject({
-  identity: import_zod21.z.string().optional(),
-  identitySource: import_zod21.z.enum(IDENTITY_DECISION_SOURCES),
+var LaunchPoolDecisionSchema = import_zod22.z.strictObject({
+  name: import_zod22.z.string(),
+  reasons: import_zod22.z.readonly(import_zod22.z.array(import_zod22.z.string())),
+  movedOff: import_zod22.z.strictObject({ identity: import_zod22.z.string(), reason: import_zod22.z.string() }).optional()
+});
+var LaunchDecisionSchema = import_zod22.z.strictObject({
+  identity: import_zod22.z.string().optional(),
+  identitySource: import_zod22.z.enum(IDENTITY_DECISION_SOURCES),
   pool: LaunchPoolDecisionSchema.optional(),
-  configDirEscapeHatch: import_zod21.z.boolean(),
-  configDir: import_zod21.z.string().optional(),
-  configProfile: import_zod21.z.string().optional(),
-  configProfileSource: import_zod21.z.enum(CONFIG_PROFILE_DECISION_SOURCES),
-  provider: import_zod21.z.string().optional()
-});
-var LaunchFlagsSchema = import_zod21.z.strictObject({
-  skipPermissions: import_zod21.z.boolean(),
-  remoteControl: import_zod21.z.boolean(),
-  headroom: import_zod21.z.boolean(),
-  trackUsage: import_zod21.z.boolean()
-});
-var LaunchResolveOutputSchema = import_zod21.z.strictObject({
+  configDirEscapeHatch: import_zod22.z.boolean(),
+  configDir: import_zod22.z.string().optional(),
+  configProfile: import_zod22.z.string().optional(),
+  configProfileSource: import_zod22.z.enum(CONFIG_PROFILE_DECISION_SOURCES),
+  provider: import_zod22.z.string().optional()
+});
+var LaunchFlagsSchema = import_zod22.z.strictObject({
+  skipPermissions: import_zod22.z.boolean(),
+  remoteControl: import_zod22.z.boolean(),
+  headroom: import_zod22.z.boolean(),
+  trackUsage: import_zod22.z.boolean()
+});
+var LaunchResolveOutputSchema = import_zod22.z.strictObject({
   decision: LaunchDecisionSchema,
   flags: LaunchFlagsSchema,
-  claudeVersion: import_zod21.z.strictObject({ version: import_zod21.z.string(), source: import_zod21.z.enum(CLAUDE_VERSION_SOURCES) }).optional(),
+  claudeVersion: import_zod22.z.strictObject({ version: import_zod22.z.string(), source: import_zod22.z.enum(CLAUDE_VERSION_SOURCES) }).optional(),
   /** The real `claude` binary the launch would spawn, on the door's host. */
-  bin: import_zod21.z.string(),
+  bin: import_zod22.z.string(),
   /** The arguments the launch would pass it: the tool's own flags, then `CLAUDE_EXTRA_FLAGS`, then the caller's own. */
-  args: import_zod21.z.readonly(import_zod21.z.array(import_zod21.z.string())),
+  args: import_zod22.z.readonly(import_zod22.z.array(import_zod22.z.string())),
   /** The credential the launch would authenticate with, by target and source kinds. Absent when none applies. */
-  credential: import_zod21.z.strictObject({ subject: import_zod21.z.enum(["provider", "identity"]), name: import_zod21.z.string(), summary: CredentialSummarySchema }).optional(),
-  routing: import_zod21.z.strictObject({ frontDoor: import_zod21.z.boolean(), headroom: import_zod21.z.boolean() }),
+  credential: import_zod22.z.strictObject({ subject: import_zod22.z.enum(["provider", "identity"]), name: import_zod22.z.string(), summary: CredentialSummarySchema }).optional(),
+  routing: import_zod22.z.strictObject({ frontDoor: import_zod22.z.boolean(), headroom: import_zod22.z.boolean() }),
   /** The names of the environment variables the launch would set or unset, sorted. Values are not reported. */
-  environment: import_zod21.z.readonly(import_zod21.z.array(import_zod21.z.string())),
-  warnings: import_zod21.z.readonly(import_zod21.z.array(import_zod21.z.string()))
+  environment: import_zod22.z.readonly(import_zod22.z.array(import_zod22.z.string())),
+  warnings: import_zod22.z.readonly(import_zod22.z.array(import_zod22.z.string()))
 });
 
 // src/frontdoor/launchApi.ts
@@ -13243,13 +13904,13 @@ function createLaunchApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   return {
     launch: {
-      resolve: authed.meta((0, import_openapi5.openapi)({ method: "POST", path: "/rest/launch/resolve", summary: "Resolve what a launch from one directory would do, without performing it", tags: [LAUNCH_API_TAG] })).input(LaunchResolveInputSchema).output(LaunchResolveOutputSchema).handler(({ input }) => {
+      resolve: authed.meta((0, import_openapi6.openapi)({ method: "POST", path: "/rest/launch/resolve", summary: "Resolve what a launch from one directory would do, without performing it", tags: [LAUNCH_API_TAG] })).input(LaunchResolveInputSchema).output(LaunchResolveOutputSchema).handler(({ input }) => {
         try {
           const { resolution, warnings } = deps.resolveLaunch({ path: input.path, argv: input.argv ?? [], env: input.env ?? {} });
           return { ...resolution, warnings };
         } catch (error) {
           if (error instanceof CliError) {
-            throw new import_client4.ORPCError("BAD_REQUEST", { message: error.message });
+            throw new import_client5.ORPCError("BAD_REQUEST", { message: error.message });
           }
           throw error;
         }
@@ -13268,11 +13929,11 @@ function createControlApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   return {
     usage: {
-      list: authed.meta((0, import_openapi6.openapi)({ method: "GET", path: "/rest/usage/snapshots", summary: "List every identity's usage snapshot", tags: [USAGE_API_TAG] })).output(UsageListOutputSchema).handler(() => ({ snapshots: deps.usageSnapshots() })),
-      effectiveWindow: authed.meta((0, import_openapi6.openapi)({ method: "GET", path: "/rest/usage/windows", summary: "Read one identity's effective quota windows", tags: [USAGE_API_TAG] })).input(UsageWindowsInputSchema).output(UsageWindowsOutputSchema).handler(({ input }) => {
+      list: authed.meta((0, import_openapi7.openapi)({ method: "GET", path: "/rest/usage/snapshots", summary: "List every identity's usage snapshot", tags: [USAGE_API_TAG] })).output(UsageListOutputSchema).handler(() => ({ snapshots: deps.usageSnapshots() })),
+      effectiveWindow: authed.meta((0, import_openapi7.openapi)({ method: "GET", path: "/rest/usage/windows", summary: "Read one identity's effective quota windows", tags: [USAGE_API_TAG] })).input(UsageWindowsInputSchema).output(UsageWindowsOutputSchema).handler(({ input }) => {
         const snapshot = deps.usageSnapshotOf(input.identity);
         if (snapshot === void 0) {
-          throw new import_client5.ORPCError("NOT_FOUND", { message: `identity ${input.identity} has no usage snapshot yet, so no quota window has been observed for it` });
+          throw new import_client6.ORPCError("NOT_FOUND", { message: `identity ${input.identity} has no usage snapshot yet, so no quota window has been observed for it` });
         }
         const provider = input.provider ?? ANTHROPIC_PROVIDER;
         const rateLimit = snapshot.providers[provider]?.rateLimit;
@@ -13286,34 +13947,34 @@ function createControlApiRouter(deps) {
           ...unified?.sevenDay === void 0 ? {} : { sevenDay: effectiveWindow(unified.sevenDay, now) }
         };
       }),
-      live: authed.meta((0, import_openapi6.openapi)({ method: "GET", path: "/rest/usage/live", summary: "Read the live rate-limit observations the event backbone files", tags: [USAGE_API_TAG] })).input(RcSessionQuerySchema).output(UsageLiveOutputSchema).handler(({ input }) => {
+      live: authed.meta((0, import_openapi7.openapi)({ method: "GET", path: "/rest/usage/live", summary: "Read the live rate-limit observations the event backbone files", tags: [USAGE_API_TAG] })).input(RcSessionQuerySchema).output(UsageLiveOutputSchema).handler(({ input }) => {
         const sessions = deps.liveRateLimits(input.session);
         if (input.session !== void 0 && sessions.length === 0) {
           if (deps.list().some((session) => session.id === input.session)) {
-            throw new import_client5.ORPCError("NOT_FOUND", { message: `session ${input.session} has filed no rate_limit_event on its stream yet: the worker emits one only once a turn has completed, so retry after this session's next turn` });
+            throw new import_client6.ORPCError("NOT_FOUND", { message: `session ${input.session} has filed no rate_limit_event on its stream yet: the worker emits one only once a turn has completed, so retry after this session's next turn` });
           }
-          throw new import_client5.ORPCError("NOT_FOUND", { message: rcSessionNotObservedMessage(input.session) });
+          throw new import_client6.ORPCError("NOT_FOUND", { message: rcSessionNotObservedMessage(input.session) });
         }
         return { latest: deps.latestRateLimit(), sessions };
       })
     },
     frontdoor: {
-      status: authed.meta((0, import_openapi6.openapi)({ method: "GET", path: "/rest/frontdoor/status", summary: "Read the front door's status", tags: [FRONTDOOR_API_TAG2] })).output(FrontDoorStatusOutputSchema).handler(() => deps.frontDoorStatus()),
-      sessions: authed.meta((0, import_openapi6.openapi)({ method: "GET", path: "/rest/frontdoor/sessions", summary: "Read the front door's session registry", tags: [FRONTDOOR_API_TAG2] })).output(FrontDoorSessionsOutputSchema).handler(() => ({ sessions: deps.frontDoorStatus().sessions }))
+      status: authed.meta((0, import_openapi7.openapi)({ method: "GET", path: "/rest/frontdoor/status", summary: "Read the front door's status", tags: [FRONTDOOR_API_TAG2] })).output(FrontDoorStatusOutputSchema).handler(() => deps.frontDoorStatus()),
+      sessions: authed.meta((0, import_openapi7.openapi)({ method: "GET", path: "/rest/frontdoor/sessions", summary: "Read the front door's session registry", tags: [FRONTDOOR_API_TAG2] })).output(FrontDoorSessionsOutputSchema).handler(() => ({ sessions: deps.frontDoorStatus().sessions }))
     },
     check: {
       // The report's own JSON shape is the contract (the same one `check --json` prints and `checkReportSchema.ts` defines), so the procedure returns exactly that conversion.
-      run: authed.meta((0, import_openapi6.openapi)({ method: "GET", path: "/rest/check", summary: "Run the check report for one directory", tags: [CHECK_API_TAG] })).input(CheckRunInputSchema).output(CheckReportJsonSchema).handler(({ input }) => checkReportToJson(deps.checkReport(input.path, input.identity)))
+      run: authed.meta((0, import_openapi7.openapi)({ method: "GET", path: "/rest/check", summary: "Run the check report for one directory", tags: [CHECK_API_TAG] })).input(CheckRunInputSchema).output(CheckReportJsonSchema).handler(({ input }) => checkReportToJson(deps.checkReport(input.path, input.identity)))
     },
     doctor: {
-      run: authed.meta((0, import_openapi6.openapi)({ method: "GET", path: "/rest/doctor", summary: "Run the doctor report", tags: [DOCTOR_API_TAG] })).output(DoctorRunOutputSchema).handler(() => deps.doctorReport())
+      run: authed.meta((0, import_openapi7.openapi)({ method: "GET", path: "/rest/doctor", summary: "Run the doctor report", tags: [DOCTOR_API_TAG] })).output(DoctorRunOutputSchema).handler(() => deps.doctorReport())
     },
     pool: {
-      pick: authed.meta((0, import_openapi6.openapi)({ method: "GET", path: "/rest/pool/pick", summary: "Rank one pool exactly as a launch from a directory would right now", tags: [POOL_API_TAG] })).input(PoolPickInputSchema).output(PoolPickReportSchema).handler(({ input }) => {
+      pick: authed.meta((0, import_openapi7.openapi)({ method: "GET", path: "/rest/pool/pick", summary: "Rank one pool exactly as a launch from a directory would right now", tags: [POOL_API_TAG] })).input(PoolPickInputSchema).output(PoolPickReportSchema).handler(({ input }) => {
         const report = deps.poolPick(input.pool, input.path);
         if (report === void 0) {
           const live = deps.poolNames();
-          throw new import_client5.ORPCError("NOT_FOUND", {
+          throw new import_client6.ORPCError("NOT_FOUND", {
             message: live.length === 0 ? `no pools are configured, so none is named ${input.pool}` : `no pool is named ${input.pool}; the live pools are ${live.map((name) => `"${name}"`).join(", ")}`
           });
         }
@@ -13325,13 +13986,13 @@ function createControlApiRouter(deps) {
 function createDoorApiRouter(deps) {
   const control = createControlApiRouter(deps);
   const lifecycle = createLifecycleApiRouter(deps);
-  return { ...createRcApiRouter(deps), ...control, ...lifecycle, ...createCodexApiRouter(deps), ...createLaunchApiRouter(deps), ...createEventsApiRouter(deps), frontdoor: { ...control.frontdoor, ...lifecycle.frontdoor } };
+  return { ...createRcApiRouter(deps), ...control, ...lifecycle, ...createConfigApiRouter(deps), ...createCodexApiRouter(deps), ...createLaunchApiRouter(deps), ...createEventsApiRouter(deps), frontdoor: { ...control.frontdoor, ...lifecycle.frontdoor } };
 }
 function createDoorApiNodeHandler(deps) {
   return doorApiNodeHandlerOf(createDoorApiRouter(deps), deps.expectedToken);
 }
 function frontDoorApiClient(port, ca, token) {
-  return (0, import_client5.createORPCClient)(frontDoorApiLink(port, ca, token));
+  return (0, import_client6.createORPCClient)(frontDoorApiLink(port, ca, token));
 }
 
 // src/frontdoor/doorClient.ts
@@ -14137,9 +14798,9 @@ async function serveRcCompatSessions(ctx, pathname, compatPath) {
   const slash = rest.indexOf("/");
   const address = slash === -1 ? rest : rest.slice(0, slash);
   const compatTail = slash === -1 ? "" : rest.slice(slash + 1);
-  const refusal = ctx.credentialRefusal(request4.headers);
-  if (refusal !== void 0) {
-    await ctx.unauthorized(response, refusal);
+  const refusal2 = ctx.credentialRefusal(request4.headers);
+  if (refusal2 !== void 0) {
+    await ctx.unauthorized(response, refusal2);
     return;
   }
   const session = ctx.sessions.get(address) ?? ctx.sessions.get(`cse_${address}`);
@@ -14217,9 +14878,9 @@ function conversationRow(conversation) {
 }
 async function serveRcConversations(ctx, pathname, method) {
   const { request: request4, response, conversations } = ctx;
-  const refusal = ctx.credentialRefusal(request4.headers);
-  if (refusal !== void 0) {
-    await ctx.unauthorized(response, refusal);
+  const refusal2 = ctx.credentialRefusal(request4.headers);
+  if (refusal2 !== void 0) {
+    await ctx.unauthorized(response, refusal2);
     return;
   }
   if (pathname === RC_CONVERSATIONS_PATH_PREFIX) {
@@ -14543,9 +15204,9 @@ async function fetchThroughWebProxy(url, deps) {
   try {
     let redirects = 0;
     for (; ; ) {
-      const refusal = await checkTarget(current, deps);
-      if (refusal !== void 0) {
-        return refusal;
+      const refusal2 = await checkTarget(current, deps);
+      if (refusal2 !== void 0) {
+        return refusal2;
       }
       let hop;
       try {
@@ -14915,8 +15576,8 @@ data: ${JSON.stringify(envelope)}
     "doubled-scheme-word": "the self-hosted Remote Control surface reads one Bearer scheme word, and this call's Authorization header carried it twice: a persisted session record holds the whole header value with the scheme word included, so prefixing Bearer onto it presents a different credential",
     unrecognised: "the self-hosted Remote Control surface did not recognise the presented credential"
   };
-  const unauthorized = async (response, refusal) => {
-    await answerJson2(response, HTTP_STATUS.unauthorized, { type: "error", error: { type: "authentication_error", message: refusalMessages[refusal] } });
+  const unauthorized = async (response, refusal2) => {
+    await answerJson2(response, HTTP_STATUS.unauthorized, { type: "error", error: { type: "authentication_error", message: refusalMessages[refusal2] } });
   };
   const serveSessionPath = async (session, tail, request4, response) => {
     const method = request4.method.toUpperCase();
@@ -14927,9 +15588,9 @@ data: ${JSON.stringify(envelope)}
     session.lastTrafficAt = deps.now();
     if (tail === "") {
       if (method === "PATCH" || method === "PUT") {
-        const refusal = credentialRefusal(request4.headers);
-        if (refusal !== void 0) {
-          await unauthorized(response, refusal);
+        const refusal2 = credentialRefusal(request4.headers);
+        if (refusal2 !== void 0) {
+          await unauthorized(response, refusal2);
           return;
         }
         const body = parseJsonObject5(await readBody2(request4.body, CONTROL_BODY_CAP_BYTES));
@@ -14952,9 +15613,9 @@ data: ${JSON.stringify(envelope)}
       return;
     }
     if (tail === "bridge" && method === "POST") {
-      const refusal = credentialRefusal(request4.headers);
-      if (refusal !== void 0) {
-        await unauthorized(response, refusal);
+      const refusal2 = credentialRefusal(request4.headers);
+      if (refusal2 !== void 0) {
+        await unauthorized(response, refusal2);
         return;
       }
       const workerJwt = mintWorkerJwt(deps.randomToken, deps.now());
@@ -14964,9 +15625,9 @@ data: ${JSON.stringify(envelope)}
       return;
     }
     if (tail === "archive" && method === "POST") {
-      const refusal = credentialRefusal(request4.headers);
-      if (refusal !== void 0) {
-        await unauthorized(response, refusal);
+      const refusal2 = credentialRefusal(request4.headers);
+      if (refusal2 !== void 0) {
+        await unauthorized(response, refusal2);
         return;
       }
       retireSession(session);
@@ -14977,9 +15638,9 @@ data: ${JSON.stringify(envelope)}
     if (tail === "worker" || tail.startsWith("worker/")) {
       const workerTail = tail === "worker" ? "" : tail.slice("worker/".length);
       const webProxy = workerTail === "web-fetch" || workerTail === "web-search";
-      const refusal = webProxy ? workerOrCredentialRefusal(request4.headers, session) : workerRefusal(request4.headers, session);
-      if (refusal !== void 0) {
-        await unauthorized(response, refusal);
+      const refusal2 = webProxy ? workerOrCredentialRefusal(request4.headers, session) : workerRefusal(request4.headers, session);
+      if (refusal2 !== void 0) {
+        await unauthorized(response, refusal2);
         return;
       }
       if (workerTail === "" && method === "GET") {
@@ -15392,102 +16053,6 @@ init_paths();
 init_cliError();
 init_schema();
 init_providersStore();
-
-// src/directoryRulesStore.ts
-init_store();
-init_load();
-init_schema();
-init_cliError();
-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 });
-}
-
-// src/index.ts
 init_launcher();
 init_spawn();
 init_launchWiring();
@@ -15602,10 +16167,44 @@ init_ownCli();
   CodexLogoutOutputSchema,
   CodexSignInSchema,
   CodexStatusOutputSchema,
+  ConfigIdentityAddOutputSchema,
+  ConfigIdentityRemoveInputSchema,
+  ConfigIdentityRemoveOutputSchema,
+  ConfigIdentitySetInputSchema,
+  ConfigIdentitySetOutputSchema,
+  ConfigIdentityUseOutputSchema,
+  ConfigNameInputSchema,
+  ConfigPoolAddInputSchema,
+  ConfigPoolAddOutputSchema,
+  ConfigPoolRemoveInputSchema,
+  ConfigPoolRemoveOutputSchema,
+  ConfigPoolSetInputSchema,
+  ConfigPoolSetOutputSchema,
+  ConfigPoolUseOutputSchema,
+  ConfigProfileAddInputSchema,
+  ConfigProfileAddOutputSchema,
+  ConfigProfileRemoveInputSchema,
+  ConfigProfileRemoveOutputSchema,
   ConfigProfileSchema,
+  ConfigProfileSetInputSchema,
+  ConfigProfileSetOutputSchema,
+  ConfigProfileUseOutputSchema,
+  ConfigProviderAddInputSchema,
+  ConfigProviderAddOutputSchema,
+  ConfigProviderRemoveInputSchema,
+  ConfigProviderRemoveOutputSchema,
+  ConfigProviderSetInputSchema,
+  ConfigProviderSetOutputSchema,
+  ConfigRuleAddInputSchema,
+  ConfigRuleAddOutputSchema,
+  ConfigRuleRemoveInputSchema,
+  ConfigRuleRemoveOutputSchema,
+  ConfigRuleSetInputSchema,
+  ConfigRuleSetOutputSchema,
   CredentialCacheSchema,
   CredentialSchema,
   CredentialSourceSchema,
+  CredentialSummarySchema,
   DOOR_EVENT_BUFFER_EVENTS,
   DOOR_EVENT_SOURCE_RC,
   DOOR_HEALTH_EVENT_SOURCE,
@@ -15736,6 +16335,7 @@ init_ownCli();
   collectFrontDoorStatus,
   collectPoolPick,
   createCodexApiRouter,
+  createConfigApiRouter,
   createControlApiRouter,
   createDoorApiNodeHandler,
   createDoorApiRouter,