claude-use 11.45.0 → 11.47.0

package/dist/index.cjs

@@ -293,8 +293,6 @@ var init_schema = __esm({
       delay: import_zod.z.string().regex(DURATION_RE, "must be a duration such as 5s or 500ms").optional(),
       /** Whether the launcher waits for a key press after its own output before it starts claude. Takes the place of `delay` when both are set. Applies only when a terminal is watching. */
       pause: import_zod.z.boolean().optional(),
-      /** Whether a provider session routes provider-qualified model names (`z/glm-5.3`, `auto`) through the `models` block to the provider that serves them, instead of sending every request to the launch provider. */
-      routeByName: import_zod.z.boolean().optional(),
       /** Whether the launcher's report, for a launch that picks from a pool, lists every member the pick ranked with why each stands where it does, and not only the member it picked. */
       explain: import_zod.z.boolean().optional()
     });
@@ -1473,9 +1471,6 @@ function flattenLayers(layers, options) {
       if (layer.launch.explain !== void 0) {
         launch.explain = layer.launch.explain;
       }
-      if (layer.launch.routeByName !== void 0) {
-        launch.routeByName = layer.launch.routeByName;
-      }
     }
     if (layer.models !== void 0) {
       models = mergeModels(models, layer.models);
@@ -2930,7 +2925,7 @@ var init_capability = __esm({
 });
 
 // src/frontdoor/route.ts
-var IDENTITY_HEADER, SESSION_HEADER, PROVIDER_HEADER, HEADROOM_FLAG_HEADER, ROUTE_BY_NAME_HEADER, PROJECT_ID_HEADER, AUTH_HEADER;
+var IDENTITY_HEADER, SESSION_HEADER, PROVIDER_HEADER, HEADROOM_FLAG_HEADER, PROJECT_ID_HEADER, AUTH_HEADER;
 var init_route = __esm({
   "src/frontdoor/route.ts"() {
     "use strict";
@@ -2938,7 +2933,6 @@ var init_route = __esm({
     SESSION_HEADER = "x-agent-shim-session";
     PROVIDER_HEADER = "x-agent-shim-provider";
     HEADROOM_FLAG_HEADER = "x-agent-shim-headroom";
-    ROUTE_BY_NAME_HEADER = "x-agent-shim-route-by-name";
     PROJECT_ID_HEADER = "x-headroom-project-id";
     AUTH_HEADER = "x-agent-shim-auth";
   }
@@ -3078,7 +3072,7 @@ var init_state = __esm({
     import_node_path8 = __toESM(require("node:path"), 1);
     import_zod3 = require("zod");
     init_schema();
-    FRONT_DOOR_PROTOCOL = 4;
+    FRONT_DOOR_PROTOCOL = 5;
     FrontDoorSessionSchema = import_zod3.z.strictObject({ pid: import_zod3.z.number().int().positive(), startedAt: import_zod3.z.number(), token: import_zod3.z.string().min(1), supervisorPid: import_zod3.z.number().int().positive().optional(), sessionId: import_zod3.z.string().min(1).optional(), models: ModelsConfigSchema.optional() });
     FrontDoorStateSchema = import_zod3.z.strictObject({
       /**
@@ -3151,7 +3145,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.45.0",
+      version: "11.47.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>",
@@ -6455,9 +6449,6 @@ function applyProfileChange(paths, name, change) {
   if (change.launchExplain !== void 0) {
     launchPatch.explain = change.launchExplain;
   }
-  if (change.launchRouteByName !== void 0) {
-    launchPatch.routeByName = change.launchRouteByName;
-  }
   if (Object.keys(launchPatch).length > 0) {
     setProfileLaunchFlags(paths, name, launchPatch);
     touched = true;
@@ -6527,6 +6518,7 @@ function buildLayoutPaths(root) {
     identitiesDir: import_node_path23.default.join(root, "identities"),
     configProfilesDir: import_node_path23.default.join(root, "config-profiles"),
     providersDir: import_node_path23.default.join(root, "providers"),
+    providerAliasesFile: import_node_path23.default.join(root, "provider-aliases.json"),
     directoryRulesFile: import_node_path23.default.join(root, "directory-rules.json"),
     activeIdentityFile: import_node_path23.default.join(root, "active-identity"),
     globalConfigFile: import_node_path23.default.join(root, "config.json"),
@@ -6743,6 +6735,50 @@ var init_realCredentialCache = __esm({
   }
 });
 
+// src/providerAliases.ts
+function parseAliases(file, raw) {
+  const parsed = ProviderAliasesSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new ConfigValidationError(file, parsed.error.issues);
+  }
+  return parsed.data;
+}
+function readProviderAliases(paths) {
+  return readJson(paths.providerAliasesFile, ProviderAliasesSchema) ?? {};
+}
+function loadProviderAliases(file, port) {
+  const raw = port.readConfigFile(file);
+  return raw === void 0 ? {} : parseAliases(file, raw);
+}
+function canonicalProviderName(name, defined, aliases) {
+  if (defined(name)) {
+    return name;
+  }
+  return aliases()[name] ?? name;
+}
+function aliasFindings(aliases, providerNames) {
+  return Object.entries(aliases).map(([alias, target]) => {
+    if (!providerNames.has(target)) {
+      return { level: "fail", alias, message: `${alias} is recorded as a former name of ${target}, which is not a provider. Run \`agent-shim provider unalias ${alias}\`.` };
+    }
+    if (providerNames.has(alias)) {
+      return { level: "warn", alias, message: `${alias} is both a provider and a recorded former name of ${target}; the provider wins. Run \`agent-shim provider unalias ${alias}\`.` };
+    }
+    return { level: "pass", alias, message: `${alias} is a former name of ${target}, still honoured for sessions launched under it. Run \`agent-shim provider unalias ${alias}\` once none is running.` };
+  });
+}
+var import_zod15, ProviderAliasesSchema;
+var init_providerAliases = __esm({
+  "src/providerAliases.ts"() {
+    "use strict";
+    import_zod15 = require("zod");
+    init_cliError();
+    init_load();
+    init_store();
+    ProviderAliasesSchema = import_zod15.z.record(import_zod15.z.string().min(1), import_zod15.z.string().min(1));
+  }
+});
+
 // src/credential.ts
 function commandArgv(source) {
   if ("command" in source) {
@@ -7147,6 +7183,11 @@ var init_families = __esm({
 });
 
 // src/providersStore.ts
+function requireValidProviderName(name) {
+  if (!PROVIDER_NAME_RE.test(name)) {
+    throw new InvalidProviderNameError(name);
+  }
+}
 function providerJsonPath(paths, name) {
   return import_node_path25.default.join(paths.providersDir, `${name}.json`);
 }
@@ -7267,9 +7308,7 @@ function addProvider(paths, name, input) {
   if (providerExists(paths, name)) {
     throw new ProviderAlreadyExistsError(name);
   }
-  if (!PROVIDER_NAME_RE.test(name)) {
-    throw new InvalidProviderNameError(name);
-  }
+  requireValidProviderName(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.");
@@ -7400,10 +7439,11 @@ function cascadeProviderName(cascade) {
 }
 function selectProvider(params) {
   const cliName = params.cliProvider !== void 0 && params.cliProvider !== "" ? params.cliProvider : void 0;
-  const name = cliName ?? (params.cascade === void 0 ? void 0 : cascadeProviderName(params.cascade));
-  if (name === void 0) {
+  const named = cliName ?? (params.cascade === void 0 ? void 0 : cascadeProviderName(params.cascade));
+  if (named === void 0) {
     return void 0;
   }
+  const name = canonicalProviderName(named, (candidate) => loadProvider(params.paths.providersDir, candidate, params.port) !== void 0, () => loadProviderAliases(params.paths.providerAliasesFile, params.port));
   const definition = loadProvider(params.paths.providersDir, name, params.port);
   if (definition === void 0) {
     const known = listProviderNames(params.port.readdir, params.paths.providersDir);
@@ -7503,6 +7543,7 @@ var init_providersStore = __esm({
     init_unrecognisedKeys();
     init_schema();
     init_cliError();
+    init_providerAliases();
     init_credential();
     init_walk();
     init_families();
@@ -7790,21 +7831,21 @@ function findPathShadow(params) {
   }
   return params.pathDirs.some((dir) => import_node_path28.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
 }
-var import_node_fs7, import_node_path28, import_zod19, ClaudeShimStateSchema, nodeLinkFs;
+var import_node_fs7, import_node_path28, import_zod20, ClaudeShimStateSchema, nodeLinkFs;
 var init_claudeShim = __esm({
   "src/claudeShim.ts"() {
     "use strict";
     import_node_fs7 = __toESM(require("node:fs"), 1);
     import_node_path28 = __toESM(require("node:path"), 1);
-    import_zod19 = require("zod");
+    import_zod20 = require("zod");
     init_commandDeps();
     init_store();
     init_realPorts();
     init_cliError();
-    ClaudeShimStateSchema = import_zod19.z.strictObject({
-      targetPath: import_zod19.z.string().min(1),
-      method: import_zod19.z.enum(["hardlink", "copy"]),
-      installedAtMs: import_zod19.z.number()
+    ClaudeShimStateSchema = import_zod20.z.strictObject({
+      targetPath: import_zod20.z.string().min(1),
+      method: import_zod20.z.enum(["hardlink", "copy"]),
+      installedAtMs: import_zod20.z.number()
     });
     nodeLinkFs = { link: import_node_fs7.default.linkSync, copyFile: import_node_fs7.default.copyFileSync, chmod: import_node_fs7.default.chmodSync };
   }
@@ -7900,62 +7941,62 @@ var init_signatures = __esm({
 });
 
 // src/codex/anthropic.ts
-var import_zod23, TextBlockSchema, Base64ImageSourceSchema, UrlImageSourceSchema, ImageBlockSchema, ToolUseBlockSchema, ToolResultContentBlockSchema, ToolResultBlockSchema, OtherBlockSchema, ContentBlockSchema, MessageSchema, ToolSchema, ToolChoiceSchema, SystemSchema, MessagesRequestSchema, CountTokensRequestSchema;
+var import_zod24, TextBlockSchema, Base64ImageSourceSchema, UrlImageSourceSchema, ImageBlockSchema, ToolUseBlockSchema, ToolResultContentBlockSchema, ToolResultBlockSchema, OtherBlockSchema, ContentBlockSchema, MessageSchema, ToolSchema, ToolChoiceSchema, SystemSchema, MessagesRequestSchema, CountTokensRequestSchema;
 var init_anthropic = __esm({
   "src/codex/anthropic.ts"() {
     "use strict";
-    import_zod23 = require("zod");
-    TextBlockSchema = import_zod23.z.looseObject({ type: import_zod23.z.literal("text"), text: import_zod23.z.string() });
-    Base64ImageSourceSchema = import_zod23.z.looseObject({ type: import_zod23.z.literal("base64"), media_type: import_zod23.z.string().min(1), data: import_zod23.z.string() });
-    UrlImageSourceSchema = import_zod23.z.looseObject({ type: import_zod23.z.literal("url"), url: import_zod23.z.string().min(1) });
-    ImageBlockSchema = import_zod23.z.looseObject({
-      type: import_zod23.z.literal("image"),
-      source: import_zod23.z.union([Base64ImageSourceSchema, UrlImageSourceSchema])
+    import_zod24 = require("zod");
+    TextBlockSchema = import_zod24.z.looseObject({ type: import_zod24.z.literal("text"), text: import_zod24.z.string() });
+    Base64ImageSourceSchema = import_zod24.z.looseObject({ type: import_zod24.z.literal("base64"), media_type: import_zod24.z.string().min(1), data: import_zod24.z.string() });
+    UrlImageSourceSchema = import_zod24.z.looseObject({ type: import_zod24.z.literal("url"), url: import_zod24.z.string().min(1) });
+    ImageBlockSchema = import_zod24.z.looseObject({
+      type: import_zod24.z.literal("image"),
+      source: import_zod24.z.union([Base64ImageSourceSchema, UrlImageSourceSchema])
     });
-    ToolUseBlockSchema = import_zod23.z.looseObject({
-      type: import_zod23.z.literal("tool_use"),
-      id: import_zod23.z.string().min(1),
-      name: import_zod23.z.string().min(1),
-      input: import_zod23.z.unknown()
+    ToolUseBlockSchema = import_zod24.z.looseObject({
+      type: import_zod24.z.literal("tool_use"),
+      id: import_zod24.z.string().min(1),
+      name: import_zod24.z.string().min(1),
+      input: import_zod24.z.unknown()
     });
-    ToolResultContentBlockSchema = import_zod23.z.union([TextBlockSchema, import_zod23.z.looseObject({ type: import_zod23.z.string() })]);
-    ToolResultBlockSchema = import_zod23.z.looseObject({
-      type: import_zod23.z.literal("tool_result"),
-      tool_use_id: import_zod23.z.string().min(1),
-      content: import_zod23.z.union([import_zod23.z.string(), import_zod23.z.array(ToolResultContentBlockSchema)]).optional()
+    ToolResultContentBlockSchema = import_zod24.z.union([TextBlockSchema, import_zod24.z.looseObject({ type: import_zod24.z.string() })]);
+    ToolResultBlockSchema = import_zod24.z.looseObject({
+      type: import_zod24.z.literal("tool_result"),
+      tool_use_id: import_zod24.z.string().min(1),
+      content: import_zod24.z.union([import_zod24.z.string(), import_zod24.z.array(ToolResultContentBlockSchema)]).optional()
     });
-    OtherBlockSchema = import_zod23.z.looseObject({ type: import_zod23.z.string() });
-    ContentBlockSchema = import_zod23.z.union([TextBlockSchema, ImageBlockSchema, ToolUseBlockSchema, ToolResultBlockSchema, OtherBlockSchema]);
-    MessageSchema = import_zod23.z.looseObject({
-      role: import_zod23.z.enum(["user", "assistant", "system"]),
-      content: import_zod23.z.union([import_zod23.z.string(), import_zod23.z.array(ContentBlockSchema)])
+    OtherBlockSchema = import_zod24.z.looseObject({ type: import_zod24.z.string() });
+    ContentBlockSchema = import_zod24.z.union([TextBlockSchema, ImageBlockSchema, ToolUseBlockSchema, ToolResultBlockSchema, OtherBlockSchema]);
+    MessageSchema = import_zod24.z.looseObject({
+      role: import_zod24.z.enum(["user", "assistant", "system"]),
+      content: import_zod24.z.union([import_zod24.z.string(), import_zod24.z.array(ContentBlockSchema)])
     });
-    ToolSchema = import_zod23.z.looseObject({
-      name: import_zod23.z.string().min(1),
-      description: import_zod23.z.string().optional(),
-      input_schema: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown()).optional()
+    ToolSchema = import_zod24.z.looseObject({
+      name: import_zod24.z.string().min(1),
+      description: import_zod24.z.string().optional(),
+      input_schema: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.unknown()).optional()
     });
-    ToolChoiceSchema = import_zod23.z.union([
-      import_zod23.z.looseObject({ type: import_zod23.z.enum(["auto", "none", "any"]) }),
-      import_zod23.z.looseObject({ type: import_zod23.z.literal("tool"), name: import_zod23.z.string().min(1) })
+    ToolChoiceSchema = import_zod24.z.union([
+      import_zod24.z.looseObject({ type: import_zod24.z.enum(["auto", "none", "any"]) }),
+      import_zod24.z.looseObject({ type: import_zod24.z.literal("tool"), name: import_zod24.z.string().min(1) })
     ]);
-    SystemSchema = import_zod23.z.union([import_zod23.z.string(), import_zod23.z.array(import_zod23.z.union([TextBlockSchema, OtherBlockSchema]))]);
-    MessagesRequestSchema = import_zod23.z.looseObject({
-      model: import_zod23.z.string().optional(),
+    SystemSchema = import_zod24.z.union([import_zod24.z.string(), import_zod24.z.array(import_zod24.z.union([TextBlockSchema, OtherBlockSchema]))]);
+    MessagesRequestSchema = import_zod24.z.looseObject({
+      model: import_zod24.z.string().optional(),
       system: SystemSchema.optional(),
-      messages: import_zod23.z.array(MessageSchema),
-      tools: import_zod23.z.array(ToolSchema).optional(),
+      messages: import_zod24.z.array(MessageSchema),
+      tools: import_zod24.z.array(ToolSchema).optional(),
       tool_choice: ToolChoiceSchema.optional(),
-      stream: import_zod23.z.boolean().optional(),
+      stream: import_zod24.z.boolean().optional(),
       /** `user_id` is stable for one Claude Code session and differs between sessions, which is what makes it the right key for both the backend's prompt cache and its session header. */
-      metadata: import_zod23.z.looseObject({ user_id: import_zod23.z.string().optional() }).optional(),
+      metadata: import_zod24.z.looseObject({ user_id: import_zod24.z.string().optional() }).optional(),
       /** Claude Code's effort setting. Any string is accepted; the translator honours only the levels the backend understands. */
-      output_config: import_zod23.z.looseObject({ effort: import_zod23.z.string().optional() }).optional()
+      output_config: import_zod24.z.looseObject({ effort: import_zod24.z.string().optional() }).optional()
     });
-    CountTokensRequestSchema = import_zod23.z.looseObject({
-      system: import_zod23.z.unknown().optional(),
-      messages: import_zod23.z.unknown().optional(),
-      tools: import_zod23.z.unknown().optional()
+    CountTokensRequestSchema = import_zod24.z.looseObject({
+      system: import_zod24.z.unknown().optional(),
+      messages: import_zod24.z.unknown().optional(),
+      tools: import_zod24.z.unknown().optional()
     });
   }
 });
@@ -8057,13 +8098,13 @@ function filterCatalogue(models, catalogue) {
   const excluded = catalogue.exclude === void 0 ? void 0 : (0, import_picomatch4.default)(catalogue.exclude, { dot: true });
   return models.filter((model) => included?.(model.id) !== false && excluded?.(model.id) !== true);
 }
-var import_node_path30, import_picomatch4, import_zod24, DEFAULT_CANDIDATE_URLS, MS_PER_SECOND5, SECONDS_PER_HOUR2, HOURS_PER_DAY5, MS_PER_HOUR4, HOURS_BETWEEN_RETRIES, CATALOGUE_MAX_AGE_MS, CATALOGUE_RETRY_MS, CATALOGUE_REQUEST_SECONDS, CATALOGUE_REQUEST_TIMEOUT_MS, CATALOGUE_REFRESH_TIMEOUT_MS, CatalogueModelSchema, CatalogueCacheSchema;
+var import_node_path30, import_picomatch4, import_zod25, DEFAULT_CANDIDATE_URLS, MS_PER_SECOND5, SECONDS_PER_HOUR2, HOURS_PER_DAY5, MS_PER_HOUR4, HOURS_BETWEEN_RETRIES, CATALOGUE_MAX_AGE_MS, CATALOGUE_RETRY_MS, CATALOGUE_REQUEST_SECONDS, CATALOGUE_REQUEST_TIMEOUT_MS, CATALOGUE_REFRESH_TIMEOUT_MS, CatalogueModelSchema, CatalogueCacheSchema;
 var init_providerCatalogue = __esm({
   "src/providerCatalogue.ts"() {
     "use strict";
     import_node_path30 = __toESM(require("node:path"), 1);
     import_picomatch4 = __toESM(require("picomatch"), 1);
-    import_zod24 = require("zod");
+    import_zod25 = require("zod");
     DEFAULT_CANDIDATE_URLS = 2;
     MS_PER_SECOND5 = 1e3;
     SECONDS_PER_HOUR2 = 3600;
@@ -8075,8 +8116,8 @@ var init_providerCatalogue = __esm({
     CATALOGUE_REQUEST_SECONDS = 10;
     CATALOGUE_REQUEST_TIMEOUT_MS = CATALOGUE_REQUEST_SECONDS * MS_PER_SECOND5;
     CATALOGUE_REFRESH_TIMEOUT_MS = DEFAULT_CANDIDATE_URLS * CATALOGUE_REQUEST_TIMEOUT_MS;
-    CatalogueModelSchema = import_zod24.z.strictObject({ id: import_zod24.z.string().min(1), name: import_zod24.z.string().min(1).optional() });
-    CatalogueCacheSchema = import_zod24.z.strictObject({ fetchedAt: import_zod24.z.number(), url: import_zod24.z.string().min(1), models: import_zod24.z.array(CatalogueModelSchema) });
+    CatalogueModelSchema = import_zod25.z.strictObject({ id: import_zod25.z.string().min(1), name: import_zod25.z.string().min(1).optional() });
+    CatalogueCacheSchema = import_zod25.z.strictObject({ fetchedAt: import_zod25.z.number(), url: import_zod25.z.string().min(1), models: import_zod25.z.array(CatalogueModelSchema) });
   }
 });
 
@@ -8162,7 +8203,7 @@ function providerModelRows(provider, catalogue = []) {
   const taken = new Set(named.map((row) => labelOf(row.model)));
   return [...named, ...catalogueRows(provider, catalogue).filter((row) => !taken.has(labelOf(row.model)))];
 }
-function routedModelRows(models, providers, bare = true) {
+function routedModelRows(models, providers) {
   const hidden = new Set(models.hide ?? []);
   const shown = models.show === void 0 ? void 0 : new Set(models.show);
   const visible = (model) => shown === void 0 ? !hidden.has(model) : shown.has(model);
@@ -8170,17 +8211,17 @@ function routedModelRows(models, providers, bare = true) {
   const concreteByRef = new Map(concrete.map((row) => [row.model, row]));
   const families = buildFamilies([...concrete.map((row) => row.model), ...accountRefsOf(models)], models);
   const handlingOf = (refs) => refs.map((ref) => concreteByRef.get(ref)?.behavesAs).find((behavesAs) => behavesAs !== void 0) ?? TIER_BEHAVES_AS.sonnet;
-  const virtual = bare ? Object.entries(models.virtual ?? {}).flatMap(([name, definition]) => {
+  const virtual = Object.entries(models.virtual ?? {}).flatMap(([name, definition]) => {
     if (!visible(name)) {
       return [];
     }
     const targets = expandFamilyMembers(safeExpand(name, models), families);
     return [{ model: name, label: name, description: `Virtual (${definition.mode})`, behavesAs: handlingOf(targets) }];
-  }) : [];
-  const familyRows = bare ? sharedFamilies(families).flatMap((family) => {
+  });
+  const familyRows = sharedFamilies(families).flatMap((family) => {
     const member = `${FAMILY_PREFIX}${family.key}`;
     return visible(member) ? [{ model: member, label: family.key, description: `Family (${familyMode(family.settings)}): ${family.refs.join(", ")}`, behavesAs: handlingOf(family.refs) }] : [];
-  }) : [];
+  });
   return [...virtual, ...familyRows, ...concrete.filter((row) => visible(row.model))];
 }
 function safeExpand(name, models) {
@@ -8660,8 +8701,7 @@ var init_argv = __esm({
       { flag: "--remote-control", key: "remoteControl" },
       { flag: "--wait", key: "wait" },
       { flag: "--pause", key: "pause" },
-      { flag: "--explain", key: "explain" },
-      { flag: "--route-by-name", key: "routeByName" }
+      { flag: "--explain", key: "explain" }
     ];
     LAUNCHER_FLAG_NAMES = [
       ...VALUED_FLAGS,
@@ -8851,7 +8891,6 @@ function resolveLaunchFlags(params) {
     trackUsage: params.flags?.trackUsage ?? parseEnvBool("AGENT_SHIM_TRACK_USAGE", params.env.AGENT_SHIM_TRACK_USAGE) ?? params.cascade?.trackUsage ?? true,
     pause: params.flags?.pause ?? parseEnvBool("AGENT_SHIM_PAUSE", params.env.AGENT_SHIM_PAUSE) ?? params.cascade?.pause ?? false,
     explain: params.flags?.explain ?? parseEnvBool("AGENT_SHIM_EXPLAIN", params.env.AGENT_SHIM_EXPLAIN) ?? params.cascade?.explain ?? false,
-    routeByName: params.flags?.routeByName ?? parseEnvBool("AGENT_SHIM_ROUTE_BY_NAME", params.env.AGENT_SHIM_ROUTE_BY_NAME) ?? params.cascade?.routeByName ?? false,
     delayMs: resolveDelayMs(params)
   };
 }
@@ -8900,12 +8939,10 @@ function buildEnv(params) {
       env[key] = value;
     }
   }
-  if (params.routeByName) {
-    for (const tier of CLAUDE_TIERS) {
-      const ref = params.tierModels?.[tier];
-      if (ref !== void 0) {
-        env[`ANTHROPIC_DEFAULT_${tier.toUpperCase()}_MODEL`] = ref;
-      }
+  for (const tier of CLAUDE_TIERS) {
+    const ref = params.tierModels?.[tier];
+    if (ref !== void 0) {
+      env[`ANTHROPIC_DEFAULT_${tier.toUpperCase()}_MODEL`] = ref;
     }
   }
   if (params.provider !== void 0) {
@@ -8928,7 +8965,6 @@ function buildEnv(params) {
         { name: SESSION_HEADER, value: params.sessionId },
         { name: AUTH_HEADER, value: params.frontdoor.sessionToken },
         ...params.provider === void 0 ? [] : [{ name: PROVIDER_HEADER, value: params.provider.name }],
-        ...params.routeByName ? [{ name: ROUTE_BY_NAME_HEADER, value: "1" }] : [],
         ...params.headroom === void 0 ? [] : [
           { name: HEADROOM_FLAG_HEADER, value: "1" },
           { name: PROJECT_ID_HEADER, value: params.headroom.projectId }
@@ -9707,7 +9743,6 @@ function decideLaunch(params, readOnly) {
       ...parsedArgv.trackUsage === void 0 ? {} : { trackUsage: parsedArgv.trackUsage },
       ...parsedArgv.pause === void 0 ? {} : { pause: parsedArgv.pause },
       ...parsedArgv.explain === void 0 ? {} : { explain: parsedArgv.explain },
-      ...parsedArgv.routeByName === void 0 ? {} : { routeByName: parsedArgv.routeByName },
       ...parsedArgv.delay === void 0 ? {} : { delay: parsedArgv.delay }
     }
   });
@@ -9717,7 +9752,6 @@ function decideLaunch(params, readOnly) {
     notes.push(`${loginlessProvider.identity} has no stored login, so Remote Control is off; provider ${loginlessProvider.provider} runs without it`);
   }
   const flags = loginlessProvider === void 0 ? requestedFlags : { ...requestedFlags, remoteControl: false };
-  const routesByName = flags.routeByName || selectedProvider !== void 0 && isRouterProvider(selectedProvider.definition);
   const globalModels = loadConfigFile(paths.globalConfigFile, GlobalConfigSchema, params.fs.readConfigFile)?.config.models;
   const models = launchCascade !== void 0 && params.farm !== void 0 ? cascadeModels : globalModels;
   const listedProviders = listProviderNames(fs13.readdir, paths.providersDir).flatMap((name) => {
@@ -9728,7 +9762,7 @@ function decideLaunch(params, readOnly) {
       return [];
     }
   });
-  const pickerSettings = modelPickerSettingsFromRows(routedModelRows(models ?? {}, listedProviders, routesByName), selectedProvider !== void 0);
+  const pickerSettings = modelPickerSettingsFromRows(routedModelRows(models ?? {}, listedProviders), selectedProvider !== void 0);
   const callerSettings = hasSettingsArgument(parsedArgv.rest);
   if (pickerSettings !== void 0 && callerSettings) {
     notes.push("--settings was passed, so /model keeps Claude Code's own model names");
@@ -9832,8 +9866,8 @@ function prepareLaunch(params) {
   if (decided.pinnedVersion !== void 0) {
     rows.push(pinnedVersionRow(decided.pinnedVersion.version, decided.pinnedVersion.source));
   }
-  const routesByName = resolvedFlags.routeByName || resolvedProvider !== void 0 && isRouterProvider(resolvedProvider.definition);
-  if (routesByName) {
+  const namesResolved = decided.models !== void 0;
+  if (namesResolved) {
     const check = resolveRoutedProviderCredentials({ paths, port: params.fs, env, ...params.credentials === void 0 ? {} : { credentials: params.credentials }, models: decided.models, targets: () => targetRefs(paths) });
     if (!check.ok) {
       log.error(check.message);
@@ -9874,7 +9908,6 @@ function prepareLaunch(params) {
     ...headroom === void 0 ? {} : { headroom },
     sessionId,
     remoteControl: resolvedFlags.remoteControl,
-    routeByName: routesByName,
     ...decided.models?.tiers === void 0 ? {} : { tierModels: decided.models.tiers }
   });
   const releases = [...headroom === void 0 || headroomPort === void 0 ? [] : [headroomPort.release], ...frontDoorRelease === void 0 ? [] : [frontDoorRelease]];
@@ -9902,8 +9935,7 @@ function resolveLaunch(params) {
     ...frontDoor ? { frontdoor: { port: 0, connectPort: 0, trustBundlePath: "", sessionToken: "" } } : {},
     ...decided.flags.headroom ? { headroom: { socketPath: "", projectId: "" } } : {},
     sessionId: "",
-    remoteControl: decided.flags.remoteControl,
-    routeByName: decided.flags.routeByName
+    remoteControl: decided.flags.remoteControl
   });
   const credentialNames = decided.identityCredentialBlock === void 0 ? [] : Object.keys(credentialVariables(decided.identityCredentialBlock.target ?? "bearer", ""));
   const environment = [.../* @__PURE__ */ new Set([...Object.keys(built).filter((name) => built[name] !== env[name]), ...credentialNames])].sort();
@@ -9915,7 +9947,7 @@ function resolveLaunch(params) {
     bin: decided.bin,
     args: decided.args,
     ...credential === void 0 ? {} : { credential },
-    routing: { frontDoor, headroom: decided.flags.headroom, routeByName: decided.flags.routeByName },
+    routing: { frontDoor, headroom: decided.flags.headroom },
     environment
   };
 }
@@ -10448,11 +10480,11 @@ var init_identityClaude = __esm({
 });
 
 // src/usage/providerQuota.ts
-var import_zod31, MS_PER_SECOND9, SECONDS_PER_HOUR3, HOURS_PER_DAY6, 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, ANTIGRAVITY_HOST, ANTIGRAVITY_QUOTA_URL, ANTIGRAVITY_USER_URL, FIVE_HOURS2, DAYS_PER_WEEK2, FIVE_HOURS_MS, WEEK_MS, AntigravityBucketSchema, AntigravitySummarySchema, GoogleTokenInfoSchema, AntigravityUserSchema;
+var import_zod32, MS_PER_SECOND9, SECONDS_PER_HOUR3, HOURS_PER_DAY6, 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, ANTIGRAVITY_HOST, ANTIGRAVITY_QUOTA_URL, ANTIGRAVITY_USER_URL, FIVE_HOURS2, DAYS_PER_WEEK2, FIVE_HOURS_MS, WEEK_MS, AntigravityBucketSchema, AntigravitySummarySchema, GoogleTokenInfoSchema, AntigravityUserSchema;
 var init_providerQuota = __esm({
   "src/usage/providerQuota.ts"() {
     "use strict";
-    import_zod31 = require("zod");
+    import_zod32 = require("zod");
     init_cloudUpstream();
     init_schema2();
     MS_PER_SECOND9 = 1e3;
@@ -10467,35 +10499,35 @@ var init_providerQuota = __esm({
       [ZAI_UNIT_HOURS, SECONDS_PER_HOUR3 * MS_PER_SECOND9],
       [ZAI_UNIT_MONTHS, DAYS_PER_MONTH * HOURS_PER_DAY6 * SECONDS_PER_HOUR3 * MS_PER_SECOND9]
     ]);
-    ZaiLimitSchema = import_zod31.z.object({
-      type: import_zod31.z.string(),
-      unit: import_zod31.z.number().int(),
-      number: import_zod31.z.number().int().positive(),
-      percentage: import_zod31.z.number().nonnegative(),
-      nextResetTime: import_zod31.z.number().positive().optional(),
-      usage: import_zod31.z.number().nonnegative().optional(),
-      currentValue: import_zod31.z.number().nonnegative().optional(),
-      remaining: import_zod31.z.number().nonnegative().optional()
+    ZaiLimitSchema = import_zod32.z.object({
+      type: import_zod32.z.string(),
+      unit: import_zod32.z.number().int(),
+      number: import_zod32.z.number().int().positive(),
+      percentage: import_zod32.z.number().nonnegative(),
+      nextResetTime: import_zod32.z.number().positive().optional(),
+      usage: import_zod32.z.number().nonnegative().optional(),
+      currentValue: import_zod32.z.number().nonnegative().optional(),
+      remaining: import_zod32.z.number().nonnegative().optional()
     });
-    ZaiResponseSchema = import_zod31.z.object({
-      success: import_zod31.z.boolean(),
-      msg: import_zod31.z.string().optional(),
-      data: import_zod31.z.object({ level: import_zod31.z.string().optional(), limits: import_zod31.z.array(ZaiLimitSchema) })
+    ZaiResponseSchema = import_zod32.z.object({
+      success: import_zod32.z.boolean(),
+      msg: import_zod32.z.string().optional(),
+      data: import_zod32.z.object({ level: import_zod32.z.string().optional(), limits: import_zod32.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_DAY6 * SECONDS_PER_HOUR3 * MS_PER_SECOND9;
-    OpenRouterKeySchema = import_zod31.z.object({
-      data: import_zod31.z.object({
-        limit: import_zod31.z.number().nonnegative().nullable(),
-        limit_remaining: import_zod31.z.number().nullable(),
-        limit_reset: import_zod31.z.string().nullable(),
-        is_free_tier: import_zod31.z.boolean().optional(),
-        free_model_daily_requests: import_zod31.z.object({ used: import_zod31.z.number().nonnegative(), limit: import_zod31.z.number().nonnegative(), remaining: import_zod31.z.number() }).optional()
+    OpenRouterKeySchema = import_zod32.z.object({
+      data: import_zod32.z.object({
+        limit: import_zod32.z.number().nonnegative().nullable(),
+        limit_remaining: import_zod32.z.number().nullable(),
+        limit_reset: import_zod32.z.string().nullable(),
+        is_free_tier: import_zod32.z.boolean().optional(),
+        free_model_daily_requests: import_zod32.z.object({ used: import_zod32.z.number().nonnegative(), limit: import_zod32.z.number().nonnegative(), remaining: import_zod32.z.number() }).optional()
       })
     });
-    OpenRouterCreditsSchema = import_zod31.z.object({ data: import_zod31.z.object({ total_credits: import_zod31.z.number().nonnegative(), total_usage: import_zod31.z.number().nonnegative() }) });
+    OpenRouterCreditsSchema = import_zod32.z.object({ data: import_zod32.z.object({ total_credits: import_zod32.z.number().nonnegative(), total_usage: import_zod32.z.number().nonnegative() }) });
     ANTIGRAVITY_HOST = "daily-cloudcode-pa.googleapis.com";
     ANTIGRAVITY_QUOTA_URL = `https://${ANTIGRAVITY_HOST}/v1internal:retrieveUserQuotaSummary`;
     ANTIGRAVITY_USER_URL = `https://${ANTIGRAVITY_HOST}/v1internal:loadCodeAssist`;
@@ -10503,21 +10535,21 @@ var init_providerQuota = __esm({
     DAYS_PER_WEEK2 = 7;
     FIVE_HOURS_MS = FIVE_HOURS2 * SECONDS_PER_HOUR3 * MS_PER_SECOND9;
     WEEK_MS = DAYS_PER_WEEK2 * HOURS_PER_DAY6 * SECONDS_PER_HOUR3 * MS_PER_SECOND9;
-    AntigravityBucketSchema = import_zod31.z.object({
-      bucketId: import_zod31.z.string(),
-      remainingFraction: import_zod31.z.number().optional(),
-      resetTime: import_zod31.z.string().optional()
+    AntigravityBucketSchema = import_zod32.z.object({
+      bucketId: import_zod32.z.string(),
+      remainingFraction: import_zod32.z.number().optional(),
+      resetTime: import_zod32.z.string().optional()
     });
-    AntigravitySummarySchema = import_zod31.z.object({ groups: import_zod31.z.array(import_zod31.z.object({ buckets: import_zod31.z.array(AntigravityBucketSchema) })) });
-    GoogleTokenInfoSchema = import_zod31.z.object({
-      email: import_zod31.z.string().optional(),
-      sub: import_zod31.z.string().optional()
+    AntigravitySummarySchema = import_zod32.z.object({ groups: import_zod32.z.array(import_zod32.z.object({ buckets: import_zod32.z.array(AntigravityBucketSchema) })) });
+    GoogleTokenInfoSchema = import_zod32.z.object({
+      email: import_zod32.z.string().optional(),
+      sub: import_zod32.z.string().optional()
     });
-    AntigravityUserSchema = import_zod31.z.object({
+    AntigravityUserSchema = import_zod32.z.object({
       /** The code-assist tier context, which defaults to the free tier for every account. */
-      currentTier: import_zod31.z.object({ name: import_zod31.z.string().optional(), id: import_zod31.z.string().optional() }).optional(),
+      currentTier: import_zod32.z.object({ name: import_zod32.z.string().optional(), id: import_zod32.z.string().optional() }).optional(),
       /** The account's paid subscription; absent when the account has none. */
-      paidTier: import_zod31.z.object({ name: import_zod31.z.string().optional(), id: import_zod31.z.string().optional() }).optional()
+      paidTier: import_zod32.z.object({ name: import_zod32.z.string().optional(), id: import_zod32.z.string().optional() }).optional()
     });
   }
 });
@@ -14818,7 +14850,7 @@ init_providersStore();
 init_signIn();
 init_realPorts();
 var import_node_path27 = __toESM(require("node:path"), 1);
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 init_envBool();
 init_load();
 init_schema();
@@ -14898,9 +14930,9 @@ function lookupKeychainService(run, farmRoot) {
   }
   return { checked: true, found: true, serviceName, note: `Keychain service name for this identity: "${serviceName}".` };
 }
-var SettingsSecretsShapeSchema = import_zod15.z.looseObject({
-  env: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.unknown()).optional(),
-  hooks: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.array(import_zod15.z.unknown())).optional()
+var SettingsSecretsShapeSchema = import_zod16.z.looseObject({
+  env: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()).optional(),
+  hooks: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.array(import_zod16.z.unknown())).optional()
 });
 function hookCommandCountOf(group) {
   if (typeof group !== "object" || group === null) {
@@ -15193,7 +15225,7 @@ function collectCheckReport(params) {
 }
 
 // src/checkReportSchema.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 init_schema();
 init_claudeVersion();
 init_identity();
@@ -15257,124 +15289,124 @@ var DIAGNOSTIC_CODES = [
 var DIAGNOSTIC_SEVERITIES = ["error", "warning", "info"];
 
 // src/usage/pickReportSchema.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 init_plan2();
-var PoolPickCandidateViewSchema = import_zod16.z.strictObject({
-  identity: import_zod16.z.string(),
+var PoolPickCandidateViewSchema = import_zod17.z.strictObject({
+  identity: import_zod17.z.string(),
   /** In pick order: `scored` has usable quota data, `unknown` has none, `pay-per-use` bills by use, `ineligible` is refused right now. */
-  class: import_zod16.z.enum(["scored", "unknown", "pay-per-use", "ineligible"]),
+  class: import_zod17.z.enum(["scored", "unknown", "pay-per-use", "ineligible"]),
   /** Plan-size-weighted remaining quota per hour until its reset; present for `scored` only. */
-  score: import_zod16.z.number().optional(),
+  score: import_zod17.z.number().optional(),
   /** Which window's reset divides the score: the seven-day window, or the five-hour one when the member reports no seven-day utilisation or its measured-ratio five-hour term outranks the weekly one; present with `score`. */
-  scoreWindow: import_zod16.z.enum(["sevenDay", "fiveHour"]).optional(),
+  scoreWindow: import_zod17.z.enum(["sevenDay", "fiveHour"]).optional(),
   /** False when the five-hour window would run dry, at the observed pace, before it resets. */
-  feasible: import_zod16.z.boolean(),
+  feasible: import_zod17.z.boolean(),
   /** When an `ineligible` member can be used again, as an ISO instant. */
-  blockedUntil: import_zod16.z.iso.datetime().optional(),
+  blockedUntil: import_zod17.z.iso.datetime().optional(),
   plan: PlanClassSchema,
   /** The facts behind the class and score, in the order they matter. */
-  reasons: import_zod16.z.array(import_zod16.z.string())
+  reasons: import_zod17.z.array(import_zod17.z.string())
 });
-var PoolPickReportSchema = import_zod16.z.strictObject({
-  pool: import_zod16.z.string(),
-  directory: import_zod16.z.string(),
+var PoolPickReportSchema = import_zod17.z.strictObject({
+  pool: import_zod17.z.string(),
+  directory: import_zod17.z.string(),
   /** The member a launch would run as, absent when every member is refused. */
-  pick: import_zod16.z.string().optional(),
-  candidates: import_zod16.z.array(PoolPickCandidateViewSchema),
+  pick: import_zod17.z.string().optional(),
+  candidates: import_zod17.z.array(PoolPickCandidateViewSchema),
   /** Identity members anywhere in the pool's graph that do not exist; a launch skips them. */
-  missing: import_zod16.z.array(import_zod16.z.string()),
+  missing: import_zod17.z.array(import_zod17.z.string()),
   /** When nothing can be picked, the soonest any member returns. */
-  earliestReturn: import_zod16.z.strictObject({ identity: import_zod16.z.string(), at: import_zod16.z.iso.datetime() }).optional(),
+  earliestReturn: import_zod17.z.strictObject({ identity: import_zod17.z.string(), at: import_zod17.z.iso.datetime() }).optional(),
   /** The member a resumed conversation started on but moved off, and why, when the ranking could not keep it. */
-  movedOff: import_zod16.z.strictObject({ identity: import_zod16.z.string(), reason: import_zod16.z.string() }).optional(),
+  movedOff: import_zod17.z.strictObject({ identity: import_zod17.z.string(), reason: import_zod17.z.string() }).optional(),
   /** Why the last-pick record could not be read, when that is the case. */
-  stickyProblem: import_zod16.z.string().optional()
+  stickyProblem: import_zod17.z.string().optional()
 });
 
 // src/checkReportSchema.ts
 var CHECK_CREDENTIAL_APPLIES = ["provider", "identity", "stored-login"];
-var CheckLayerViewSchema = import_zod17.z.strictObject({
-  id: import_zod17.z.int(),
-  kind: import_zod17.z.enum(LAYER_KINDS),
-  source: import_zod17.z.string()
+var CheckLayerViewSchema = import_zod18.z.strictObject({
+  id: import_zod18.z.int(),
+  kind: import_zod18.z.enum(LAYER_KINDS),
+  source: import_zod18.z.string()
 });
-var CheckEntryViewSchema = import_zod17.z.strictObject({
-  path: import_zod17.z.string(),
-  shared: import_zod17.z.boolean(),
-  via: import_zod17.z.enum(DECISION_VIAS),
+var CheckEntryViewSchema = import_zod18.z.strictObject({
+  path: import_zod18.z.string(),
+  shared: import_zod18.z.boolean(),
+  via: import_zod18.z.enum(DECISION_VIAS),
   /** The entry's real category, or null when nothing classifies it. */
-  category: import_zod17.z.enum(CATEGORY_NAMES).nullable(),
-  rule: import_zod17.z.strictObject({ key: import_zod17.z.string(), layer: import_zod17.z.int() }).optional(),
+  category: import_zod18.z.enum(CATEGORY_NAMES).nullable(),
+  rule: import_zod18.z.strictObject({ key: import_zod18.z.string(), layer: import_zod18.z.int() }).optional(),
   /** Rules that matched but whose `when` condition failed, each with the conditions that failed. */
-  eliminated: import_zod17.z.readonly(import_zod17.z.array(import_zod17.z.strictObject({ key: import_zod17.z.string(), failed: import_zod17.z.readonly(import_zod17.z.array(import_zod17.z.string())) }))).optional()
+  eliminated: import_zod18.z.readonly(import_zod18.z.array(import_zod18.z.strictObject({ key: import_zod18.z.string(), failed: import_zod18.z.readonly(import_zod18.z.array(import_zod18.z.string())) }))).optional()
 });
-var CheckDiagnosticSchema = import_zod17.z.strictObject({
-  code: import_zod17.z.enum(DIAGNOSTIC_CODES),
-  severity: import_zod17.z.enum(DIAGNOSTIC_SEVERITIES),
-  message: import_zod17.z.string(),
-  subject: import_zod17.z.string().optional(),
-  layer: import_zod17.z.int().optional()
+var CheckDiagnosticSchema = import_zod18.z.strictObject({
+  code: import_zod18.z.enum(DIAGNOSTIC_CODES),
+  severity: import_zod18.z.enum(DIAGNOSTIC_SEVERITIES),
+  message: import_zod18.z.string(),
+  subject: import_zod18.z.string().optional(),
+  layer: import_zod18.z.int().optional()
 });
-var CheckAmbientCredentialSchema = import_zod17.z.union([import_zod17.z.strictObject({ ok: import_zod17.z.literal(true) }), import_zod17.z.strictObject({ ok: import_zod17.z.literal(false), variable: import_zod17.z.string(), message: import_zod17.z.string() })]);
-var CheckKeychainSchema = import_zod17.z.strictObject({
-  checked: import_zod17.z.literal(true),
-  found: import_zod17.z.boolean(),
-  serviceName: import_zod17.z.string().optional(),
-  note: import_zod17.z.string()
+var CheckAmbientCredentialSchema = import_zod18.z.union([import_zod18.z.strictObject({ ok: import_zod18.z.literal(true) }), import_zod18.z.strictObject({ ok: import_zod18.z.literal(false), variable: import_zod18.z.string(), message: import_zod18.z.string() })]);
+var CheckKeychainSchema = import_zod18.z.strictObject({
+  checked: import_zod18.z.literal(true),
+  found: import_zod18.z.boolean(),
+  serviceName: import_zod18.z.string().optional(),
+  note: import_zod18.z.string()
 });
-var CheckSettingsExposureSchema = import_zod17.z.strictObject({
-  file: import_zod17.z.string(),
-  envKeyNames: import_zod17.z.readonly(import_zod17.z.array(import_zod17.z.string())),
-  hookEventNames: import_zod17.z.readonly(import_zod17.z.array(import_zod17.z.string())),
-  hookCommandCount: import_zod17.z.int().nonnegative()
+var CheckSettingsExposureSchema = import_zod18.z.strictObject({
+  file: import_zod18.z.string(),
+  envKeyNames: import_zod18.z.readonly(import_zod18.z.array(import_zod18.z.string())),
+  hookEventNames: import_zod18.z.readonly(import_zod18.z.array(import_zod18.z.string())),
+  hookCommandCount: import_zod18.z.int().nonnegative()
 });
-var CredentialSourceSummarySchema = import_zod17.z.union([
-  import_zod17.z.strictObject({ kind: import_zod17.z.literal("env"), variable: import_zod17.z.string() }),
-  import_zod17.z.strictObject({ kind: import_zod17.z.literal("file"), path: import_zod17.z.string() }),
-  import_zod17.z.strictObject({ kind: import_zod17.z.literal("command"), program: import_zod17.z.string() }),
-  import_zod17.z.strictObject({ kind: import_zod17.z.literal("op"), reference: import_zod17.z.string() }),
-  import_zod17.z.strictObject({ kind: import_zod17.z.literal("keychain"), service: import_zod17.z.string(), account: import_zod17.z.string().optional() }),
-  import_zod17.z.strictObject({ kind: import_zod17.z.literal("literal") })
+var CredentialSourceSummarySchema = import_zod18.z.union([
+  import_zod18.z.strictObject({ kind: import_zod18.z.literal("env"), variable: import_zod18.z.string() }),
+  import_zod18.z.strictObject({ kind: import_zod18.z.literal("file"), path: import_zod18.z.string() }),
+  import_zod18.z.strictObject({ kind: import_zod18.z.literal("command"), program: import_zod18.z.string() }),
+  import_zod18.z.strictObject({ kind: import_zod18.z.literal("op"), reference: import_zod18.z.string() }),
+  import_zod18.z.strictObject({ kind: import_zod18.z.literal("keychain"), service: import_zod18.z.string(), account: import_zod18.z.string().optional() }),
+  import_zod18.z.strictObject({ kind: import_zod18.z.literal("literal") })
 ]);
-var CredentialSummarySchema = import_zod17.z.strictObject({
-  target: import_zod17.z.enum(CREDENTIAL_TARGETS),
-  sources: import_zod17.z.readonly(import_zod17.z.array(CredentialSourceSummarySchema)),
+var CredentialSummarySchema = import_zod18.z.strictObject({
+  target: import_zod18.z.enum(CREDENTIAL_TARGETS),
+  sources: import_zod18.z.readonly(import_zod18.z.array(CredentialSourceSummarySchema)),
   cache: CredentialCacheSchema.optional()
 });
-var CachedCredentialStateSchema = import_zod17.z.union([
-  import_zod17.z.strictObject({ store: import_zod17.z.enum(CREDENTIAL_CACHE_STORES), status: import_zod17.z.literal("empty") }),
-  import_zod17.z.strictObject({ store: import_zod17.z.enum(CREDENTIAL_CACHE_STORES), status: import_zod17.z.literal("unreadable"), reason: import_zod17.z.string() }),
-  import_zod17.z.strictObject({ store: import_zod17.z.enum(CREDENTIAL_CACHE_STORES), status: import_zod17.z.enum(["fresh", "expired"]), ageMs: import_zod17.z.number(), expiresInMs: import_zod17.z.number().optional() })
+var CachedCredentialStateSchema = import_zod18.z.union([
+  import_zod18.z.strictObject({ store: import_zod18.z.enum(CREDENTIAL_CACHE_STORES), status: import_zod18.z.literal("empty") }),
+  import_zod18.z.strictObject({ store: import_zod18.z.enum(CREDENTIAL_CACHE_STORES), status: import_zod18.z.literal("unreadable"), reason: import_zod18.z.string() }),
+  import_zod18.z.strictObject({ store: import_zod18.z.enum(CREDENTIAL_CACHE_STORES), status: import_zod18.z.enum(["fresh", "expired"]), ageMs: import_zod18.z.number(), expiresInMs: import_zod18.z.number().optional() })
 ]);
-var CheckCredentialProviderSchema = import_zod17.z.union([
-  import_zod17.z.strictObject({ name: import_zod17.z.string(), credential: CredentialSummarySchema.optional(), cached: CachedCredentialStateSchema.optional() }),
-  import_zod17.z.strictObject({ name: import_zod17.z.string(), problem: import_zod17.z.string() })
+var CheckCredentialProviderSchema = import_zod18.z.union([
+  import_zod18.z.strictObject({ name: import_zod18.z.string(), credential: CredentialSummarySchema.optional(), cached: CachedCredentialStateSchema.optional() }),
+  import_zod18.z.strictObject({ name: import_zod18.z.string(), problem: import_zod18.z.string() })
 ]);
-var CheckCredentialSchema = import_zod17.z.strictObject({
-  applies: import_zod17.z.enum(CHECK_CREDENTIAL_APPLIES),
+var CheckCredentialSchema = import_zod18.z.strictObject({
+  applies: import_zod18.z.enum(CHECK_CREDENTIAL_APPLIES),
   provider: CheckCredentialProviderSchema.optional(),
   identity: CredentialSummarySchema.optional(),
   identityCached: CachedCredentialStateSchema.optional()
 });
-var CheckClaudeVersionSchema = import_zod17.z.strictObject({
-  pinned: import_zod17.z.strictObject({ version: import_zod17.z.string(), source: import_zod17.z.enum(CLAUDE_VERSION_SOURCES), installed: import_zod17.z.boolean() }).optional(),
-  highestInstalled: import_zod17.z.string().optional(),
-  installed: import_zod17.z.readonly(import_zod17.z.array(import_zod17.z.string()))
+var CheckClaudeVersionSchema = import_zod18.z.strictObject({
+  pinned: import_zod18.z.strictObject({ version: import_zod18.z.string(), source: import_zod18.z.enum(CLAUDE_VERSION_SOURCES), installed: import_zod18.z.boolean() }).optional(),
+  highestInstalled: import_zod18.z.string().optional(),
+  installed: import_zod18.z.readonly(import_zod18.z.array(import_zod18.z.string()))
 });
-var CheckReportJsonSchema = import_zod17.z.strictObject({
-  identity: import_zod17.z.strictObject({ name: import_zod17.z.string().nullable(), source: import_zod17.z.enum(IDENTITY_DECISION_SOURCES) }),
+var CheckReportJsonSchema = import_zod18.z.strictObject({
+  identity: import_zod18.z.strictObject({ name: import_zod18.z.string().nullable(), source: import_zod18.z.enum(IDENTITY_DECISION_SOURCES) }),
   /** The pool ranking, when the launch named a pool instead of an identity. */
   pool: PoolPickReportSchema.optional(),
-  configProfile: import_zod17.z.strictObject({ name: import_zod17.z.string().nullable(), source: import_zod17.z.enum(CONFIG_PROFILE_DECISION_SOURCES) }),
-  layers: import_zod17.z.readonly(import_zod17.z.array(CheckLayerViewSchema)),
-  entries: import_zod17.z.readonly(import_zod17.z.array(CheckEntryViewSchema)),
-  projectEncodingAmbiguities: import_zod17.z.readonly(
-    import_zod17.z.array(import_zod17.z.strictObject({ fragment: import_zod17.z.string(), encoded: import_zod17.z.string(), reason: import_zod17.z.enum(ENCODING_AMBIGUITY_REASONS), detail: import_zod17.z.string() }))
+  configProfile: import_zod18.z.strictObject({ name: import_zod18.z.string().nullable(), source: import_zod18.z.enum(CONFIG_PROFILE_DECISION_SOURCES) }),
+  layers: import_zod18.z.readonly(import_zod18.z.array(CheckLayerViewSchema)),
+  entries: import_zod18.z.readonly(import_zod18.z.array(CheckEntryViewSchema)),
+  projectEncodingAmbiguities: import_zod18.z.readonly(
+    import_zod18.z.array(import_zod18.z.strictObject({ fragment: import_zod18.z.string(), encoded: import_zod18.z.string(), reason: import_zod18.z.enum(ENCODING_AMBIGUITY_REASONS), detail: import_zod18.z.string() }))
   ),
-  diagnostics: import_zod17.z.readonly(import_zod17.z.array(CheckDiagnosticSchema)),
+  diagnostics: import_zod18.z.readonly(import_zod18.z.array(CheckDiagnosticSchema)),
   ambientCredential: CheckAmbientCredentialSchema,
   keychain: CheckKeychainSchema.optional(),
-  settingsExposure: import_zod17.z.readonly(import_zod17.z.array(CheckSettingsExposureSchema)),
+  settingsExposure: import_zod18.z.readonly(import_zod18.z.array(CheckSettingsExposureSchema)),
   credential: CheckCredentialSchema,
   claudeVersion: CheckClaudeVersionSchema.optional()
 });
@@ -15434,28 +15466,28 @@ function collectResets(snapshots, nowMs) {
 }
 
 // src/usage/resetsSchema.ts
-var import_zod18 = require("zod");
-var ResetRowSchema = import_zod18.z.strictObject({
-  identity: import_zod18.z.string(),
-  provider: import_zod18.z.string(),
+var import_zod19 = require("zod");
+var ResetRowSchema = import_zod19.z.strictObject({
+  identity: import_zod19.z.string(),
+  provider: import_zod19.z.string(),
   /** What the window is: `5h`, `7d` or `extra usage` for an Anthropic account, or the provider's own measure and period (`tokens 5h`). */
-  window: import_zod18.z.string(),
+  window: import_zod19.z.string(),
   /** When the state the window comes from was observed, as an ISO instant. */
-  observedAt: import_zod18.z.iso.datetime(),
+  observedAt: import_zod19.z.iso.datetime(),
   /** When the window resets, as an ISO instant; absent when the upstream reported none. */
-  resetsAt: import_zod18.z.iso.datetime().optional(),
+  resetsAt: import_zod19.z.iso.datetime().optional(),
   /** True when the reset time has passed, so the recorded observation describes a window that no longer exists and its utilisation reads as 0. */
-  reset: import_zod18.z.boolean(),
+  reset: import_zod19.z.boolean(),
   /** The fraction used, as `effectiveWindow` reads it at the report's own clock. */
-  utilization: import_zod18.z.number().optional(),
+  utilization: import_zod19.z.number().optional(),
   /** The window's own status, for a window that has not reset yet. */
-  status: import_zod18.z.string().optional()
+  status: import_zod19.z.string().optional()
 });
-var ResetScheduleSchema = import_zod18.z.strictObject({ resets: import_zod18.z.readonly(import_zod18.z.array(ResetRowSchema)) });
+var ResetScheduleSchema = import_zod19.z.strictObject({ resets: import_zod19.z.readonly(import_zod19.z.array(ResetRowSchema)) });
 
 // src/frontdoor/controlSchemas.ts
 var import_node_path32 = __toESM(require("node:path"), 1);
-var import_zod25 = require("zod");
+var import_zod26 = require("zod");
 
 // src/doctorReport.ts
 init_claudeShim();
@@ -15635,24 +15667,24 @@ var import_node_path31 = __toESM(require("node:path"), 1);
 init_signIn();
 
 // src/codex/siwcStore.ts
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 
 // src/codex/auth.ts
-var import_zod20 = require("zod");
-var AuthFileSchema = import_zod20.z.looseObject({
-  tokens: import_zod20.z.looseObject({
-    access_token: import_zod20.z.string().optional(),
-    refresh_token: import_zod20.z.string().optional(),
-    id_token: import_zod20.z.string().optional(),
-    account_id: import_zod20.z.string().optional()
+var import_zod21 = require("zod");
+var AuthFileSchema = import_zod21.z.looseObject({
+  tokens: import_zod21.z.looseObject({
+    access_token: import_zod21.z.string().optional(),
+    refresh_token: import_zod21.z.string().optional(),
+    id_token: import_zod21.z.string().optional(),
+    account_id: import_zod21.z.string().optional()
   }).nullish(),
-  last_refresh: import_zod20.z.string().optional()
+  last_refresh: import_zod21.z.string().optional()
 });
-var TokenGrantSchema = import_zod20.z.looseObject({
-  access_token: import_zod20.z.string().min(1).optional(),
-  refresh_token: import_zod20.z.string().min(1).optional(),
-  id_token: import_zod20.z.string().min(1).optional(),
-  account_id: import_zod20.z.string().min(1).optional()
+var TokenGrantSchema = import_zod21.z.looseObject({
+  access_token: import_zod21.z.string().min(1).optional(),
+  refresh_token: import_zod21.z.string().min(1).optional(),
+  id_token: import_zod21.z.string().min(1).optional(),
+  account_id: import_zod21.z.string().min(1).optional()
 });
 var CodexAuthError = class extends Error {
   constructor(message) {
@@ -15662,41 +15694,41 @@ var CodexAuthError = class extends Error {
 };
 
 // src/codex/siwc.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 var SIWC_RESOURCE = "https://api.openai.com/v1";
 var SIWC_RESPONSES_URL = `${SIWC_RESOURCE}/responses`;
 var SIWC_PLAN_SCOPE = "chatgpt.tokens.use.direct";
-var TokenResponseSchema = import_zod21.z.looseObject({
-  access_token: import_zod21.z.string().min(1),
-  refresh_token: import_zod21.z.string().min(1).optional(),
-  id_token: import_zod21.z.string().min(1).optional(),
-  expires_in: import_zod21.z.number().positive(),
-  scope: import_zod21.z.string().optional()
+var TokenResponseSchema = import_zod22.z.looseObject({
+  access_token: import_zod22.z.string().min(1),
+  refresh_token: import_zod22.z.string().min(1).optional(),
+  id_token: import_zod22.z.string().min(1).optional(),
+  expires_in: import_zod22.z.number().positive(),
+  scope: import_zod22.z.string().optional()
 });
-var JwtHeaderSchema = import_zod21.z.looseObject({ alg: import_zod21.z.string(), kid: import_zod21.z.string().optional() });
-var IdTokenClaimsSchema = import_zod21.z.looseObject({
-  iss: import_zod21.z.string(),
-  sub: import_zod21.z.string().min(1),
-  aud: import_zod21.z.union([import_zod21.z.string(), import_zod21.z.array(import_zod21.z.string())]),
-  exp: import_zod21.z.number(),
-  nonce: import_zod21.z.string().optional(),
-  email: import_zod21.z.string().optional()
+var JwtHeaderSchema = import_zod22.z.looseObject({ alg: import_zod22.z.string(), kid: import_zod22.z.string().optional() });
+var IdTokenClaimsSchema = import_zod22.z.looseObject({
+  iss: import_zod22.z.string(),
+  sub: import_zod22.z.string().min(1),
+  aud: import_zod22.z.union([import_zod22.z.string(), import_zod22.z.array(import_zod22.z.string())]),
+  exp: import_zod22.z.number(),
+  nonce: import_zod22.z.string().optional(),
+  email: import_zod22.z.string().optional()
 });
-var JwksSchema = import_zod21.z.object({ keys: import_zod21.z.array(import_zod21.z.looseObject({ kid: import_zod21.z.string().optional(), kty: import_zod21.z.string() })) });
+var JwksSchema = import_zod22.z.object({ keys: import_zod22.z.array(import_zod22.z.looseObject({ kid: import_zod22.z.string().optional(), kty: import_zod22.z.string() })) });
 
 // src/codex/siwcStore.ts
-var SiwcGrantSchema = import_zod22.z.strictObject({
-  clientId: import_zod22.z.string().min(1),
-  sub: import_zod22.z.string().min(1),
-  email: import_zod22.z.string().optional(),
-  idToken: import_zod22.z.string().min(1),
-  accessToken: import_zod22.z.string().min(1),
-  refreshToken: import_zod22.z.string().min(1),
-  scopes: import_zod22.z.array(import_zod22.z.string()).readonly(),
+var SiwcGrantSchema = import_zod23.z.strictObject({
+  clientId: import_zod23.z.string().min(1),
+  sub: import_zod23.z.string().min(1),
+  email: import_zod23.z.string().optional(),
+  idToken: import_zod23.z.string().min(1),
+  accessToken: import_zod23.z.string().min(1),
+  refreshToken: import_zod23.z.string().min(1),
+  scopes: import_zod23.z.array(import_zod23.z.string()).readonly(),
   /** When the access token stops working, in milliseconds since the epoch. */
-  expiresAt: import_zod22.z.number()
+  expiresAt: import_zod23.z.number()
 });
-var SiwcFileSchema = import_zod22.z.strictObject({ registeredClientId: import_zod22.z.string().min(1).optional(), grant: SiwcGrantSchema.optional() });
+var SiwcFileSchema = import_zod23.z.strictObject({ registeredClientId: import_zod23.z.string().min(1).optional(), grant: SiwcGrantSchema.optional() });
 function parseSiwcFile(raw, filePath) {
   let json;
   try {
@@ -15978,6 +16010,7 @@ function realFrontDoorListenerProbes(paths) {
 // src/doctorReport.ts
 init_supervisorProcesses();
 init_legacy();
+init_providerAliases();
 init_providersStore();
 init_guard();
 init_identity();
@@ -16306,6 +16339,10 @@ function runDoctor(params) {
   for (const entry of params.providers) {
     pushProvider(push, entry, params.credentialCache, params.chatgptSignIn);
   }
+  const providerNames = new Set(params.providers.map((entry) => entry.name));
+  for (const finding of aliasFindings(params.providerAliases ?? {}, providerNames)) {
+    push("provider", finding.level, finding.message, finding.alias);
+  }
   if (params.platform !== "darwin" || params.run === void 0) {
     push("keychain", "pass", "Skipped (not macOS).");
   } else {
@@ -16595,6 +16632,7 @@ function collectDoctorReport(params) {
     identities,
     configProfiles,
     providers,
+    providerAliases: readProviderAliases(paths),
     directoryRules: { path: paths.directoryRulesFile, raw: realFsPort.readFileUtf8(paths.directoryRulesFile) },
     globalConfig: { path: paths.globalConfigFile, raw: realFsPort.readFileUtf8(paths.globalConfigFile) },
     models: parsedModelsOf(paths),
@@ -16650,90 +16688,90 @@ function collectDoctorReport(params) {
 // src/frontdoor/controlSchemas.ts
 init_schema2();
 init_state();
-var UsageListOutputSchema = import_zod25.z.strictObject({ snapshots: import_zod25.z.readonly(import_zod25.z.array(UsageSnapshotSchema)) });
-var UsageWindowsInputSchema = import_zod25.z.strictObject({
-  identity: import_zod25.z.string().min(1),
-  provider: import_zod25.z.string().min(1).optional()
+var UsageListOutputSchema = import_zod26.z.strictObject({ snapshots: import_zod26.z.readonly(import_zod26.z.array(UsageSnapshotSchema)) });
+var UsageWindowsInputSchema = import_zod26.z.strictObject({
+  identity: import_zod26.z.string().min(1),
+  provider: import_zod26.z.string().min(1).optional()
 });
-var EffectiveWindowSchema = import_zod25.z.strictObject({
+var EffectiveWindowSchema = import_zod26.z.strictObject({
   /** True when the window's reset time has passed, so the recorded observation describes a window that no longer exists. */
-  reset: import_zod25.z.boolean(),
+  reset: import_zod26.z.boolean(),
   /** The fraction used: 0 for a reset window, otherwise what was last observed, absent when none was reported. */
-  utilization: import_zod25.z.number().optional(),
+  utilization: import_zod26.z.number().optional(),
   /** The reset instant, for a window that has not reset yet and reported one. */
-  resetsAtMs: import_zod25.z.number().optional(),
+  resetsAtMs: import_zod26.z.number().optional(),
   /** The window's own status, for a window that has not reset yet. */
-  status: import_zod25.z.string().optional()
+  status: import_zod26.z.string().optional()
 });
-var UsageWindowsOutputSchema = import_zod25.z.strictObject({
-  identity: import_zod25.z.string(),
-  provider: import_zod25.z.string(),
+var UsageWindowsOutputSchema = import_zod26.z.strictObject({
+  identity: import_zod26.z.string(),
+  provider: import_zod26.z.string(),
   /** When the rate-limit state the windows come from was observed. */
-  observedAt: import_zod25.z.iso.datetime().optional(),
+  observedAt: import_zod26.z.iso.datetime().optional(),
   fiveHour: EffectiveWindowSchema.optional(),
   sevenDay: EffectiveWindowSchema.optional()
 });
-var UsageLiveOutputSchema = import_zod25.z.strictObject({
+var UsageLiveOutputSchema = import_zod26.z.strictObject({
   /** The freshest observation the door holds, never narrowed by the read's session filter because it is the door's single latest statement of the account's quota; absent while no rate_limit_event has been filed at all. */
   latest: RcLiveRateLimitSchema.optional(),
   /** One observation per session whose stream has filed a rate_limit_event this door generation. */
-  sessions: import_zod25.z.readonly(import_zod25.z.array(RcLiveRateLimitSchema))
+  sessions: import_zod26.z.readonly(import_zod26.z.array(RcLiveRateLimitSchema))
 });
-var FrontDoorSessionStatusSchema = import_zod25.z.strictObject({
-  pid: import_zod25.z.int().positive(),
-  startedAt: import_zod25.z.number(),
-  alive: import_zod25.z.boolean()
+var FrontDoorSessionStatusSchema = import_zod26.z.strictObject({
+  pid: import_zod26.z.int().positive(),
+  startedAt: import_zod26.z.number(),
+  alive: import_zod26.z.boolean()
 });
-var HeadroomSocketTargetSchema = import_zod25.z.union([import_zod25.z.strictObject({ socketPath: import_zod25.z.string() }), import_zod25.z.strictObject({ refused: import_zod25.z.string() })]);
-var FrontDoorStatusOutputSchema = import_zod25.z.strictObject({
+var HeadroomSocketTargetSchema = import_zod26.z.union([import_zod26.z.strictObject({ socketPath: import_zod26.z.string() }), import_zod26.z.strictObject({ refused: import_zod26.z.string() })]);
+var FrontDoorStatusOutputSchema = import_zod26.z.strictObject({
   state: FrontDoorStateSchema,
-  supervisorAlive: import_zod25.z.boolean(),
-  sessions: import_zod25.z.readonly(import_zod25.z.array(FrontDoorSessionStatusSchema)),
+  supervisorAlive: import_zod26.z.boolean(),
+  sessions: import_zod26.z.readonly(import_zod26.z.array(FrontDoorSessionStatusSchema)),
   headroomSocket: HeadroomSocketTargetSchema.optional(),
-  logPath: import_zod25.z.string(),
-  logExists: import_zod25.z.boolean()
+  logPath: import_zod26.z.string(),
+  logExists: import_zod26.z.boolean()
 });
-var FrontDoorSessionsOutputSchema = import_zod25.z.strictObject({ sessions: import_zod25.z.readonly(import_zod25.z.array(FrontDoorSessionStatusSchema)) });
-var CheckRunInputSchema = import_zod25.z.strictObject({
-  path: import_zod25.z.string().min(1),
-  identity: import_zod25.z.string().min(1).optional()
+var FrontDoorSessionsOutputSchema = import_zod26.z.strictObject({ sessions: import_zod26.z.readonly(import_zod26.z.array(FrontDoorSessionStatusSchema)) });
+var CheckRunInputSchema = import_zod26.z.strictObject({
+  path: import_zod26.z.string().min(1),
+  identity: import_zod26.z.string().min(1).optional()
 }).refine((input) => import_node_path32.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
-var PoolPickInputSchema = import_zod25.z.strictObject({
-  pool: import_zod25.z.string().min(1),
-  path: import_zod25.z.string().min(1)
+var PoolPickInputSchema = import_zod26.z.strictObject({
+  pool: import_zod26.z.string().min(1),
+  path: import_zod26.z.string().min(1)
 }).refine((input) => import_node_path32.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
-var DoctorFindingSchema = import_zod25.z.strictObject({
-  section: import_zod25.z.enum(DOCTOR_SECTIONS),
-  subject: import_zod25.z.string().optional(),
-  severity: import_zod25.z.enum(DOCTOR_SEVERITIES),
-  message: import_zod25.z.string()
+var DoctorFindingSchema = import_zod26.z.strictObject({
+  section: import_zod26.z.enum(DOCTOR_SECTIONS),
+  subject: import_zod26.z.string().optional(),
+  severity: import_zod26.z.enum(DOCTOR_SEVERITIES),
+  message: import_zod26.z.string()
 });
-var DoctorRunOutputSchema = import_zod25.z.strictObject({
+var DoctorRunOutputSchema = import_zod26.z.strictObject({
   /** False exactly when any finding is a `fail`; a `warn` never fails the report on its own. */
-  ok: import_zod25.z.boolean(),
-  findings: import_zod25.z.readonly(import_zod25.z.array(DoctorFindingSchema))
+  ok: import_zod26.z.boolean(),
+  findings: import_zod26.z.readonly(import_zod26.z.array(DoctorFindingSchema))
 });
-var FrontDoorRestartOutputSchema = import_zod25.z.strictObject({
-  action: import_zod25.z.literal("restarting"),
-  previousPid: import_zod25.z.int().positive()
+var FrontDoorRestartOutputSchema = import_zod26.z.strictObject({
+  action: import_zod26.z.literal("restarting"),
+  previousPid: import_zod26.z.int().positive()
 });
-var UpdateCheckOutputSchema = import_zod25.z.strictObject({
-  current: import_zod25.z.string(),
-  latest: import_zod25.z.string(),
-  action: import_zod25.z.enum(["current", "available", "updated"])
+var UpdateCheckOutputSchema = import_zod26.z.strictObject({
+  current: import_zod26.z.string(),
+  latest: import_zod26.z.string(),
+  action: import_zod26.z.enum(["current", "available", "updated"])
 });
-var CodexSignInSchema = import_zod25.z.discriminatedUnion("state", [
-  import_zod25.z.strictObject({ state: import_zod25.z.literal("none") }),
-  import_zod25.z.strictObject({ state: import_zod25.z.literal("signed-in"), email: import_zod25.z.string().optional(), planScope: import_zod25.z.boolean(), accessTokenExpiresAt: import_zod25.z.number() }),
-  import_zod25.z.strictObject({ state: import_zod25.z.literal("unreadable"), message: import_zod25.z.string() })
+var CodexSignInSchema = import_zod26.z.discriminatedUnion("state", [
+  import_zod26.z.strictObject({ state: import_zod26.z.literal("none") }),
+  import_zod26.z.strictObject({ state: import_zod26.z.literal("signed-in"), email: import_zod26.z.string().optional(), planScope: import_zod26.z.boolean(), accessTokenExpiresAt: import_zod26.z.number() }),
+  import_zod26.z.strictObject({ state: import_zod26.z.literal("unreadable"), message: import_zod26.z.string() })
 ]);
-var CodexStatusOutputSchema = import_zod25.z.strictObject({
+var CodexStatusOutputSchema = import_zod26.z.strictObject({
   signIn: CodexSignInSchema,
-  codexProviders: import_zod25.z.readonly(import_zod25.z.array(import_zod25.z.string()))
+  codexProviders: import_zod26.z.readonly(import_zod26.z.array(import_zod26.z.string()))
 });
-var CodexLogoutOutputSchema = import_zod25.z.strictObject({
-  hadGrant: import_zod25.z.boolean(),
-  revoked: import_zod25.z.boolean()
+var CodexLogoutOutputSchema = import_zod26.z.strictObject({
+  hadGrant: import_zod26.z.boolean(),
+  revoked: import_zod26.z.boolean()
 });
 
 // src/frontdoor/codexApi.ts
@@ -16890,144 +16928,143 @@ init_identity();
 init_providersStore();
 
 // src/frontdoor/configSchemas.ts
-var import_zod26 = require("zod");
+var import_zod27 = require("zod");
 init_schema();
-var RemovalConfirmationSchema = import_zod26.z.boolean();
-var CredentialWriteSchema = (targets) => import_zod26.z.strictObject({
-  sources: import_zod26.z.array(RemoteCredentialSourceSchema).min(1).optional(),
-  target: import_zod26.z.enum(targets).optional(),
-  cache: import_zod26.z.union([import_zod26.z.literal(false), CredentialCacheSchema]).optional()
+var RemovalConfirmationSchema = import_zod27.z.boolean();
+var CredentialWriteSchema = (targets) => import_zod27.z.strictObject({
+  sources: import_zod27.z.array(RemoteCredentialSourceSchema).min(1).optional(),
+  target: import_zod27.z.enum(targets).optional(),
+  cache: import_zod27.z.union([import_zod27.z.literal(false), CredentialCacheSchema]).optional()
 });
-var CredentialSummarySchema2 = import_zod26.z.strictObject({
-  target: import_zod26.z.enum(CREDENTIAL_TARGETS),
-  sources: import_zod26.z.readonly(import_zod26.z.array(
-    import_zod26.z.discriminatedUnion("kind", [
-      import_zod26.z.strictObject({ kind: import_zod26.z.literal("env"), variable: import_zod26.z.string() }),
-      import_zod26.z.strictObject({ kind: import_zod26.z.literal("file"), path: import_zod26.z.string() }),
-      import_zod26.z.strictObject({ kind: import_zod26.z.literal("command"), program: import_zod26.z.string() }),
-      import_zod26.z.strictObject({ kind: import_zod26.z.literal("op"), reference: import_zod26.z.string() }),
-      import_zod26.z.strictObject({ kind: import_zod26.z.literal("keychain"), service: import_zod26.z.string(), account: import_zod26.z.string().optional() }),
-      import_zod26.z.strictObject({ kind: import_zod26.z.literal("literal") })
+var CredentialSummarySchema2 = import_zod27.z.strictObject({
+  target: import_zod27.z.enum(CREDENTIAL_TARGETS),
+  sources: import_zod27.z.readonly(import_zod27.z.array(
+    import_zod27.z.discriminatedUnion("kind", [
+      import_zod27.z.strictObject({ kind: import_zod27.z.literal("env"), variable: import_zod27.z.string() }),
+      import_zod27.z.strictObject({ kind: import_zod27.z.literal("file"), path: import_zod27.z.string() }),
+      import_zod27.z.strictObject({ kind: import_zod27.z.literal("command"), program: import_zod27.z.string() }),
+      import_zod27.z.strictObject({ kind: import_zod27.z.literal("op"), reference: import_zod27.z.string() }),
+      import_zod27.z.strictObject({ kind: import_zod27.z.literal("keychain"), service: import_zod27.z.string(), account: import_zod27.z.string().optional() }),
+      import_zod27.z.strictObject({ kind: import_zod27.z.literal("literal") })
     ])
   )),
   cache: CredentialCacheSchema.optional()
 });
-var mutationOutput = (kind, action) => import_zod26.z.strictObject({ action: import_zod26.z.literal(action), kind: import_zod26.z.literal(kind), name: import_zod26.z.string() });
-var storedMutationOutput = (kind, action, value) => import_zod26.z.strictObject({ action: import_zod26.z.literal(action), kind: import_zod26.z.literal(kind), name: import_zod26.z.string(), value });
-var IdentityValueSchema = import_zod26.z.strictObject({
-  name: import_zod26.z.string(),
-  defaultConfigProfile: import_zod26.z.string().optional(),
-  allowAmbientCredential: import_zod26.z.boolean(),
+var mutationOutput = (kind, action) => import_zod27.z.strictObject({ action: import_zod27.z.literal(action), kind: import_zod27.z.literal(kind), name: import_zod27.z.string() });
+var storedMutationOutput = (kind, action, value) => import_zod27.z.strictObject({ action: import_zod27.z.literal(action), kind: import_zod27.z.literal(kind), name: import_zod27.z.string(), value });
+var IdentityValueSchema = import_zod27.z.strictObject({
+  name: import_zod27.z.string(),
+  defaultConfigProfile: import_zod27.z.string().optional(),
+  allowAmbientCredential: import_zod27.z.boolean(),
   credential: CredentialSummarySchema2.optional(),
-  anchors: import_zod26.z.array(AnchorSchema).optional()
+  anchors: import_zod27.z.array(AnchorSchema).optional()
 });
 var ProfileValueSchema = ConfigProfileSchema.omit({ $schema: true });
-var ProviderValueSchema = import_zod26.z.strictObject({
-  name: import_zod26.z.string(),
-  kind: import_zod26.z.enum(PROVIDER_KINDS),
-  displayName: import_zod26.z.string(),
-  baseUrl: import_zod26.z.string().optional(),
+var ProviderValueSchema = import_zod27.z.strictObject({
+  name: import_zod27.z.string(),
+  kind: import_zod27.z.enum(PROVIDER_KINDS),
+  displayName: import_zod27.z.string(),
+  baseUrl: import_zod27.z.string().optional(),
   codex: CodexProviderConfigSchema.optional(),
   credential: CredentialSummarySchema2.optional(),
-  env: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.string()).optional()
+  env: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.string()).optional()
 });
-var ConfigNameInputSchema = import_zod26.z.strictObject({ name: import_zod26.z.string().min(1) });
+var ConfigNameInputSchema = import_zod27.z.strictObject({ name: import_zod27.z.string().min(1) });
 var ConfigIdentityAddOutputSchema = storedMutationOutput("identity", "created", IdentityValueSchema);
-var ConfigIdentitySetInputSchema = import_zod26.z.strictObject({
-  name: import_zod26.z.string().min(1),
-  defaultConfigProfile: import_zod26.z.union([import_zod26.z.string().min(1), import_zod26.z.literal(false)]).optional(),
-  allowAmbientCredential: import_zod26.z.boolean().optional(),
-  credential: import_zod26.z.union([import_zod26.z.literal(false), CredentialWriteSchema(CREDENTIAL_TARGETS)]).optional(),
+var ConfigIdentitySetInputSchema = import_zod27.z.strictObject({
+  name: import_zod27.z.string().min(1),
+  defaultConfigProfile: import_zod27.z.union([import_zod27.z.string().min(1), import_zod27.z.literal(false)]).optional(),
+  allowAmbientCredential: import_zod27.z.boolean().optional(),
+  credential: import_zod27.z.union([import_zod27.z.literal(false), CredentialWriteSchema(CREDENTIAL_TARGETS)]).optional(),
   /** `false` removes the anchors; a list replaces them. */
-  anchors: import_zod26.z.union([import_zod26.z.literal(false), import_zod26.z.array(AnchorSchema).min(1)]).optional()
+  anchors: import_zod27.z.union([import_zod27.z.literal(false), import_zod27.z.array(AnchorSchema).min(1)]).optional()
 });
 var ConfigIdentitySetOutputSchema = storedMutationOutput("identity", "updated", IdentityValueSchema);
-var ConfigIdentityRemoveInputSchema = import_zod26.z.strictObject({ name: import_zod26.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigIdentityRemoveInputSchema = import_zod27.z.strictObject({ name: import_zod27.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigIdentityRemoveOutputSchema = mutationOutput("identity", "removed");
 var ConfigIdentityUseOutputSchema = mutationOutput("identity", "selected");
-var ConfigProfileAddInputSchema = import_zod26.z.strictObject({
-  name: import_zod26.z.string().min(1),
-  extends: import_zod26.z.array(import_zod26.z.string().min(1)).optional(),
-  description: import_zod26.z.string().optional()
+var ConfigProfileAddInputSchema = import_zod27.z.strictObject({
+  name: import_zod27.z.string().min(1),
+  extends: import_zod27.z.array(import_zod27.z.string().min(1)).optional(),
+  description: import_zod27.z.string().optional()
 });
 var ConfigProfileAddOutputSchema = storedMutationOutput("profile", "created", ProfileValueSchema);
-var ConfigProfileSetInputSchema = import_zod26.z.strictObject({
-  name: import_zod26.z.string().min(1),
-  category: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.boolean()).optional(),
-  entry: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.boolean()).optional(),
-  extends: import_zod26.z.union([import_zod26.z.array(import_zod26.z.string().min(1)), import_zod26.z.literal(false)]).optional(),
-  description: import_zod26.z.union([import_zod26.z.string(), import_zod26.z.literal(false)]).optional(),
-  launch: import_zod26.z.strictObject({
-    skipPermissions: import_zod26.z.boolean().optional(),
-    remoteControl: import_zod26.z.boolean().optional(),
-    headroom: import_zod26.z.boolean().optional(),
-    trackUsage: import_zod26.z.boolean().optional(),
-    provider: import_zod26.z.union([import_zod26.z.string().min(1), import_zod26.z.literal(false)]).optional(),
-    claudeVersion: import_zod26.z.union([import_zod26.z.string().min(1), import_zod26.z.literal(false)]).optional(),
-    delay: import_zod26.z.union([import_zod26.z.string().regex(DURATION_RE), import_zod26.z.literal(false)]).optional(),
-    pause: import_zod26.z.boolean().optional(),
-    explain: import_zod26.z.boolean().optional(),
-    routeByName: import_zod26.z.boolean().optional()
+var ConfigProfileSetInputSchema = import_zod27.z.strictObject({
+  name: import_zod27.z.string().min(1),
+  category: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.boolean()).optional(),
+  entry: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.boolean()).optional(),
+  extends: import_zod27.z.union([import_zod27.z.array(import_zod27.z.string().min(1)), import_zod27.z.literal(false)]).optional(),
+  description: import_zod27.z.union([import_zod27.z.string(), import_zod27.z.literal(false)]).optional(),
+  launch: import_zod27.z.strictObject({
+    skipPermissions: import_zod27.z.boolean().optional(),
+    remoteControl: import_zod27.z.boolean().optional(),
+    headroom: import_zod27.z.boolean().optional(),
+    trackUsage: import_zod27.z.boolean().optional(),
+    provider: import_zod27.z.union([import_zod27.z.string().min(1), import_zod27.z.literal(false)]).optional(),
+    claudeVersion: import_zod27.z.union([import_zod27.z.string().min(1), import_zod27.z.literal(false)]).optional(),
+    delay: import_zod27.z.union([import_zod27.z.string().regex(DURATION_RE), import_zod27.z.literal(false)]).optional(),
+    pause: import_zod27.z.boolean().optional(),
+    explain: import_zod27.z.boolean().optional()
   }).optional()
 });
 var ConfigProfileSetOutputSchema = storedMutationOutput("profile", "updated", ProfileValueSchema);
-var ConfigProfileRemoveInputSchema = import_zod26.z.strictObject({ name: import_zod26.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProfileRemoveInputSchema = import_zod27.z.strictObject({ name: import_zod27.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigProfileRemoveOutputSchema = mutationOutput("profile", "removed");
 var ConfigProfileUseOutputSchema = mutationOutput("profile", "selected");
-var PoolMembersInputSchema = import_zod26.z.array(import_zod26.z.string().min(1)).min(1);
-var ConfigPoolAddInputSchema = import_zod26.z.strictObject({
-  name: import_zod26.z.string().min(1),
+var PoolMembersInputSchema = import_zod27.z.array(import_zod27.z.string().min(1)).min(1);
+var ConfigPoolAddInputSchema = import_zod27.z.strictObject({
+  name: import_zod27.z.string().min(1),
   identities: PoolMembersInputSchema,
-  preference: import_zod26.z.enum(POOL_PREFERENCES).optional(),
-  resumeOnLimit: import_zod26.z.boolean().optional(),
-  compactBeforeLimit: import_zod26.z.boolean().optional(),
+  preference: import_zod27.z.enum(POOL_PREFERENCES).optional(),
+  resumeOnLimit: import_zod27.z.boolean().optional(),
+  compactBeforeLimit: import_zod27.z.boolean().optional(),
   compactAtUtilisation: CompactAtUtilisationSchema.optional()
 });
 var ConfigPoolAddOutputSchema = storedMutationOutput("pool", "created", PoolSchema);
-var ConfigPoolSetInputSchema = import_zod26.z.strictObject({
-  name: import_zod26.z.string().min(1),
+var ConfigPoolSetInputSchema = import_zod27.z.strictObject({
+  name: import_zod27.z.string().min(1),
   identities: PoolMembersInputSchema.optional(),
-  preference: import_zod26.z.union([import_zod26.z.enum(POOL_PREFERENCES), import_zod26.z.literal(false)]).optional(),
-  resumeOnLimit: import_zod26.z.boolean().optional(),
-  compactBeforeLimit: import_zod26.z.boolean().optional(),
-  compactAtUtilisation: import_zod26.z.union([CompactAtUtilisationSchema, import_zod26.z.literal(false)]).optional()
+  preference: import_zod27.z.union([import_zod27.z.enum(POOL_PREFERENCES), import_zod27.z.literal(false)]).optional(),
+  resumeOnLimit: import_zod27.z.boolean().optional(),
+  compactBeforeLimit: import_zod27.z.boolean().optional(),
+  compactAtUtilisation: import_zod27.z.union([CompactAtUtilisationSchema, import_zod27.z.literal(false)]).optional()
 });
 var ConfigPoolSetOutputSchema = storedMutationOutput("pool", "updated", PoolSchema);
-var ConfigPoolRemoveInputSchema = import_zod26.z.strictObject({ name: import_zod26.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigPoolRemoveInputSchema = import_zod27.z.strictObject({ name: import_zod27.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigPoolRemoveOutputSchema = mutationOutput("pool", "removed");
 var ConfigPoolUseOutputSchema = mutationOutput("pool", "selected");
-var ConfigProviderAddInputSchema = import_zod26.z.strictObject({
-  name: import_zod26.z.string().min(1),
-  kind: import_zod26.z.enum(PROVIDER_KINDS).optional(),
-  displayName: import_zod26.z.string().min(1),
-  baseUrl: import_zod26.z.string().min(1).optional(),
+var ConfigProviderAddInputSchema = import_zod27.z.strictObject({
+  name: import_zod27.z.string().min(1),
+  kind: import_zod27.z.enum(PROVIDER_KINDS).optional(),
+  displayName: import_zod27.z.string().min(1),
+  baseUrl: import_zod27.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_zod26.z.strictObject({
-  name: import_zod26.z.string().min(1),
-  displayName: import_zod26.z.string().min(1).optional(),
-  baseUrl: import_zod26.z.string().min(1).optional(),
+var ConfigProviderSetInputSchema = import_zod27.z.strictObject({
+  name: import_zod27.z.string().min(1),
+  displayName: import_zod27.z.string().min(1).optional(),
+  baseUrl: import_zod27.z.string().min(1).optional(),
   credential: CredentialWriteSchema(PROVIDER_CREDENTIAL_TARGETS).optional(),
   codex: CodexProviderConfigSchema.optional()
 });
 var ConfigProviderSetOutputSchema = storedMutationOutput("provider", "updated", ProviderValueSchema);
-var ConfigProviderRemoveInputSchema = import_zod26.z.strictObject({ name: import_zod26.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProviderRemoveInputSchema = import_zod27.z.strictObject({ name: import_zod27.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigProviderRemoveOutputSchema = mutationOutput("provider", "removed");
-var ConfigRuleAddInputSchema = import_zod26.z.strictObject({
-  path: import_zod26.z.string().min(1),
-  configProfile: import_zod26.z.string().min(1).optional(),
-  identity: import_zod26.z.string().min(1).optional()
+var ConfigRuleAddInputSchema = import_zod27.z.strictObject({
+  path: import_zod27.z.string().min(1),
+  configProfile: import_zod27.z.string().min(1).optional(),
+  identity: import_zod27.z.string().min(1).optional()
 });
 var ConfigRuleAddOutputSchema = storedMutationOutput("rule", "created", DirectoryRuleSchema);
-var ConfigRuleSetInputSchema = import_zod26.z.strictObject({
-  path: import_zod26.z.string().min(1),
-  configProfile: import_zod26.z.union([import_zod26.z.string().min(1), import_zod26.z.literal(false)]).optional(),
-  identity: import_zod26.z.union([import_zod26.z.string().min(1), import_zod26.z.literal(false)]).optional()
+var ConfigRuleSetInputSchema = import_zod27.z.strictObject({
+  path: import_zod27.z.string().min(1),
+  configProfile: import_zod27.z.union([import_zod27.z.string().min(1), import_zod27.z.literal(false)]).optional(),
+  identity: import_zod27.z.union([import_zod27.z.string().min(1), import_zod27.z.literal(false)]).optional()
 });
 var ConfigRuleSetOutputSchema = storedMutationOutput("rule", "updated", DirectoryRuleSchema);
-var ConfigRuleRemoveInputSchema = import_zod26.z.strictObject({ path: import_zod26.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigRuleRemoveInputSchema = import_zod27.z.strictObject({ path: import_zod27.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigRuleRemoveOutputSchema = mutationOutput("rule", "removed");
 
 // src/frontdoor/configApi.ts
@@ -17179,8 +17216,7 @@ function createConfigApiRouter(deps) {
               ...launch?.claudeVersion === void 0 ? {} : { launchClaudeVersion: launch.claudeVersion },
               ...launch?.delay === void 0 ? {} : { launchDelay: launch.delay },
               ...launch?.pause === void 0 ? {} : { launchPause: launch.pause },
-              ...launch?.explain === void 0 ? {} : { launchExplain: launch.explain },
-              ...launch?.routeByName === void 0 ? {} : { launchRouteByName: launch.routeByName }
+              ...launch?.explain === void 0 ? {} : { launchExplain: launch.explain }
             });
             return { action: "updated", kind: "profile", name: input.name, value: profileValue(input.name, paths) };
           })
@@ -17339,43 +17375,43 @@ var import_openapi4 = require("@orpc/openapi");
 var import_server3 = require("@orpc/server");
 
 // src/frontdoor/eventSchemas.ts
-var import_zod27 = require("zod");
+var import_zod28 = 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_zod27.z.strictObject({
-  source: import_zod27.z.string().min(1),
+var DoorEventSchema = import_zod28.z.strictObject({
+  source: import_zod28.z.string().min(1),
   /** A positive integer because the backbone's counters start at one and only ever increase. */
-  sequence: import_zod27.z.number().int().positive(),
-  payload: import_zod27.z.unknown()
+  sequence: import_zod28.z.number().int().positive(),
+  payload: import_zod28.z.unknown()
 });
-var DoorEventSourceQuerySchema = import_zod27.z.strictObject({
-  sources: import_zod27.z.array(import_zod27.z.string().min(1)).min(1).optional()
+var DoorEventSourceQuerySchema = import_zod28.z.strictObject({
+  sources: import_zod28.z.array(import_zod28.z.string().min(1)).min(1).optional()
 });
-var LaunchLifecycleEventSchema = import_zod27.z.strictObject({
-  kind: import_zod27.z.enum(["registered", "pruned", "ended"]),
-  pid: import_zod27.z.number().int().positive(),
-  startedAt: import_zod27.z.number(),
-  observedAt: import_zod27.z.number()
+var LaunchLifecycleEventSchema = import_zod28.z.strictObject({
+  kind: import_zod28.z.enum(["registered", "pruned", "ended"]),
+  pid: import_zod28.z.number().int().positive(),
+  startedAt: import_zod28.z.number(),
+  observedAt: import_zod28.z.number()
 });
-var DoorHealthEventSchema = import_zod27.z.discriminatedUnion("kind", [
-  import_zod27.z.strictObject({ kind: import_zod27.z.literal("generation"), pid: import_zod27.z.number().int().positive(), providerPort: import_zod27.z.number().int().positive(), connectPort: import_zod27.z.number().int().positive(), directPort: import_zod27.z.number().int().positive(), observedAt: import_zod27.z.number() }),
-  import_zod27.z.strictObject({ kind: import_zod27.z.literal("listenerFailed"), pid: import_zod27.z.number().int().positive(), listener: import_zod27.z.enum(["provider", "connect", "direct"]), message: import_zod27.z.string(), observedAt: import_zod27.z.number() }),
-  import_zod27.z.strictObject({ kind: import_zod27.z.literal("binaryTurnover"), pid: import_zod27.z.number().int().positive(), observedAt: import_zod27.z.number() }),
-  import_zod27.z.strictObject({ kind: import_zod27.z.literal("idleShutdown"), pid: import_zod27.z.number().int().positive(), observedAt: import_zod27.z.number() }),
-  import_zod27.z.strictObject({ kind: import_zod27.z.literal("superseded"), pid: import_zod27.z.number().int().positive(), ownerPid: import_zod27.z.number().int().positive(), observedAt: import_zod27.z.number() }),
-  import_zod27.z.strictObject({ kind: import_zod27.z.literal("drained"), pid: import_zod27.z.number().int().positive(), observedAt: import_zod27.z.number() })
+var DoorHealthEventSchema = import_zod28.z.discriminatedUnion("kind", [
+  import_zod28.z.strictObject({ kind: import_zod28.z.literal("generation"), pid: import_zod28.z.number().int().positive(), providerPort: import_zod28.z.number().int().positive(), connectPort: import_zod28.z.number().int().positive(), directPort: import_zod28.z.number().int().positive(), observedAt: import_zod28.z.number() }),
+  import_zod28.z.strictObject({ kind: import_zod28.z.literal("listenerFailed"), pid: import_zod28.z.number().int().positive(), listener: import_zod28.z.enum(["provider", "connect", "direct"]), message: import_zod28.z.string(), observedAt: import_zod28.z.number() }),
+  import_zod28.z.strictObject({ kind: import_zod28.z.literal("binaryTurnover"), pid: import_zod28.z.number().int().positive(), observedAt: import_zod28.z.number() }),
+  import_zod28.z.strictObject({ kind: import_zod28.z.literal("idleShutdown"), pid: import_zod28.z.number().int().positive(), observedAt: import_zod28.z.number() }),
+  import_zod28.z.strictObject({ kind: import_zod28.z.literal("superseded"), pid: import_zod28.z.number().int().positive(), ownerPid: import_zod28.z.number().int().positive(), observedAt: import_zod28.z.number() }),
+  import_zod28.z.strictObject({ kind: import_zod28.z.literal("drained"), pid: import_zod28.z.number().int().positive(), observedAt: import_zod28.z.number() })
 ]);
-var QuotaExpiringEventSchema = import_zod27.z.strictObject({
-  identity: import_zod27.z.string().min(1),
-  provider: import_zod27.z.string().min(1),
-  window: import_zod27.z.enum(["fiveHour", "sevenDay"]),
+var QuotaExpiringEventSchema = import_zod28.z.strictObject({
+  identity: import_zod28.z.string().min(1),
+  provider: import_zod28.z.string().min(1),
+  window: import_zod28.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_zod27.z.number().min(0).max(1),
-  resetsAt: import_zod27.z.iso.datetime(),
-  observedAt: import_zod27.z.number()
+  utilization: import_zod28.z.number().min(0).max(1),
+  resetsAt: import_zod28.z.iso.datetime(),
+  observedAt: import_zod28.z.number()
 });
 
 // src/frontdoor/eventsApi.ts
@@ -17459,56 +17495,55 @@ init_cliError();
 
 // src/frontdoor/launchSchemas.ts
 var import_node_path33 = __toESM(require("node:path"), 1);
-var import_zod28 = require("zod");
+var import_zod29 = require("zod");
 init_claudeVersion();
 init_identity();
-var LaunchResolveInputSchema = import_zod28.z.strictObject({
-  path: import_zod28.z.string().min(1),
+var LaunchResolveInputSchema = import_zod29.z.strictObject({
+  path: import_zod29.z.string().min(1),
   /** `@name`, launch flags, then the arguments for `claude`; empty for a bare launch. */
-  argv: import_zod28.z.readonly(import_zod28.z.array(import_zod28.z.string())).optional(),
+  argv: import_zod29.z.readonly(import_zod29.z.array(import_zod29.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_zod28.z.record(import_zod28.z.string(), import_zod28.z.string()).optional()
+  env: import_zod29.z.record(import_zod29.z.string(), import_zod29.z.string()).optional()
 }).refine((input) => import_node_path33.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_zod28.z.strictObject({
-  name: import_zod28.z.string(),
-  reasons: import_zod28.z.readonly(import_zod28.z.array(import_zod28.z.string())),
-  movedOff: import_zod28.z.strictObject({ identity: import_zod28.z.string(), reason: import_zod28.z.string() }).optional()
+var LaunchPoolDecisionSchema = import_zod29.z.strictObject({
+  name: import_zod29.z.string(),
+  reasons: import_zod29.z.readonly(import_zod29.z.array(import_zod29.z.string())),
+  movedOff: import_zod29.z.strictObject({ identity: import_zod29.z.string(), reason: import_zod29.z.string() }).optional()
 });
-var LaunchDecisionSchema = import_zod28.z.strictObject({
-  identity: import_zod28.z.string().optional(),
-  identitySource: import_zod28.z.enum(IDENTITY_DECISION_SOURCES),
+var LaunchDecisionSchema = import_zod29.z.strictObject({
+  identity: import_zod29.z.string().optional(),
+  identitySource: import_zod29.z.enum(IDENTITY_DECISION_SOURCES),
   pool: LaunchPoolDecisionSchema.optional(),
-  configDirEscapeHatch: import_zod28.z.boolean(),
-  configDir: import_zod28.z.string().optional(),
-  configProfile: import_zod28.z.string().optional(),
-  configProfileSource: import_zod28.z.enum(CONFIG_PROFILE_DECISION_SOURCES),
-  provider: import_zod28.z.string().optional()
+  configDirEscapeHatch: import_zod29.z.boolean(),
+  configDir: import_zod29.z.string().optional(),
+  configProfile: import_zod29.z.string().optional(),
+  configProfileSource: import_zod29.z.enum(CONFIG_PROFILE_DECISION_SOURCES),
+  provider: import_zod29.z.string().optional()
 });
-var LaunchFlagsSchema = import_zod28.z.strictObject({
-  skipPermissions: import_zod28.z.boolean(),
-  remoteControl: import_zod28.z.boolean(),
-  headroom: import_zod28.z.boolean(),
-  trackUsage: import_zod28.z.boolean(),
-  pause: import_zod28.z.boolean(),
-  explain: import_zod28.z.boolean(),
-  routeByName: import_zod28.z.boolean(),
+var LaunchFlagsSchema = import_zod29.z.strictObject({
+  skipPermissions: import_zod29.z.boolean(),
+  remoteControl: import_zod29.z.boolean(),
+  headroom: import_zod29.z.boolean(),
+  trackUsage: import_zod29.z.boolean(),
+  pause: import_zod29.z.boolean(),
+  explain: import_zod29.z.boolean(),
   /** How long the launch waits after its own output before it starts claude, in milliseconds. */
-  delayMs: import_zod28.z.number()
+  delayMs: import_zod29.z.number()
 });
-var LaunchResolveOutputSchema = import_zod28.z.strictObject({
+var LaunchResolveOutputSchema = import_zod29.z.strictObject({
   decision: LaunchDecisionSchema,
   flags: LaunchFlagsSchema,
-  claudeVersion: import_zod28.z.strictObject({ version: import_zod28.z.string(), source: import_zod28.z.enum(CLAUDE_VERSION_SOURCES) }).optional(),
+  claudeVersion: import_zod29.z.strictObject({ version: import_zod29.z.string(), source: import_zod29.z.enum(CLAUDE_VERSION_SOURCES) }).optional(),
   /** The real `claude` binary the launch would spawn, on the door's host. */
-  bin: import_zod28.z.string(),
+  bin: import_zod29.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_zod28.z.readonly(import_zod28.z.array(import_zod28.z.string())),
+  args: import_zod29.z.readonly(import_zod29.z.array(import_zod29.z.string())),
   /** The credential the launch would authenticate with, by target and source kinds. Absent when none applies. */
-  credential: import_zod28.z.strictObject({ subject: import_zod28.z.enum(["provider", "identity"]), name: import_zod28.z.string(), summary: CredentialSummarySchema }).optional(),
-  routing: import_zod28.z.strictObject({ frontDoor: import_zod28.z.boolean(), headroom: import_zod28.z.boolean(), routeByName: import_zod28.z.boolean() }),
+  credential: import_zod29.z.strictObject({ subject: import_zod29.z.enum(["provider", "identity"]), name: import_zod29.z.string(), summary: CredentialSummarySchema }).optional(),
+  routing: import_zod29.z.strictObject({ frontDoor: import_zod29.z.boolean(), headroom: import_zod29.z.boolean() }),
   /** The names of the environment variables the launch would set or unset, sorted. Values are not reported. */
-  environment: import_zod28.z.readonly(import_zod28.z.array(import_zod28.z.string())),
-  warnings: import_zod28.z.readonly(import_zod28.z.array(import_zod28.z.string()))
+  environment: import_zod29.z.readonly(import_zod29.z.array(import_zod29.z.string())),
+  warnings: import_zod29.z.readonly(import_zod29.z.array(import_zod29.z.string()))
 });
 
 // src/frontdoor/launchApi.ts
@@ -17544,22 +17579,22 @@ function createLaunchApiRouter(deps) {
 // src/frontdoor/agentTreesApi.ts
 var import_client6 = require("@orpc/client");
 var import_openapi7 = require("@orpc/openapi");
-var import_zod29 = require("zod");
+var import_zod30 = require("zod");
 init_cliError();
-var AgentTreesListInputSchema = import_zod29.z.strictObject({
+var AgentTreesListInputSchema = import_zod30.z.strictObject({
   /** Only this identity's sessions. */
-  identity: import_zod29.z.string().optional(),
+  identity: import_zod30.z.string().optional(),
   /** Include sessions that spawned no agent and ran no workflow. */
-  all: import_zod29.z.boolean().optional()
+  all: import_zod30.z.boolean().optional()
 });
-var AgentTreesListOutputSchema = import_zod29.z.array(SessionSummarySchema);
-var AgentTreesShowInputSchema = import_zod29.z.strictObject({
+var AgentTreesListOutputSchema = import_zod30.z.array(SessionSummarySchema);
+var AgentTreesShowInputSchema = import_zod30.z.strictObject({
   /** A session id, or an unambiguous prefix of one. */
-  session: import_zod29.z.string().min(1),
+  session: import_zod30.z.string().min(1),
   /** Look only in this identity. */
-  identity: import_zod29.z.string().optional()
+  identity: import_zod30.z.string().optional()
 });
-var AgentTreesShowOutputSchema = import_zod29.z.strictObject({ identities: import_zod29.z.array(import_zod29.z.string()), ...MergedAgentTreeSchema.shape });
+var AgentTreesShowOutputSchema = import_zod30.z.strictObject({ identities: import_zod30.z.array(import_zod30.z.string()), ...MergedAgentTreeSchema.shape });
 function asBadRequest(error) {
   if (error instanceof CliError) {
     throw new import_client6.ORPCError("BAD_REQUEST", { message: error.message });
@@ -19742,7 +19777,7 @@ init_poolPick();
 
 // src/agents/read.ts
 var import_node_path35 = __toESM(require("node:path"), 1);
-var import_zod30 = require("zod");
+var import_zod31 = require("zod");
 var PROJECTS_DIR = "projects";
 var TASKS_DIR = "tasks";
 var SUBAGENTS_DIR = "subagents";
@@ -19861,14 +19896,14 @@ function parseJson2(text) {
     return void 0;
   }
 }
-var TaskFileSchema = import_zod30.z.object({ ...TaskItemSchema.omit({ taskList: true }).shape, blocks: import_zod30.z.array(import_zod30.z.string()).default([]), blockedBy: import_zod30.z.array(import_zod30.z.string()).default([]) });
-var WorkflowRunFileSchema = import_zod30.z.object({
-  runId: import_zod30.z.string(),
-  workflowName: import_zod30.z.string().optional(),
-  status: import_zod30.z.string().optional(),
-  startTime: import_zod30.z.number().optional(),
-  phases: import_zod30.z.array(import_zod30.z.object({ title: import_zod30.z.string() })).default([]),
-  summary: import_zod30.z.string().optional()
+var TaskFileSchema = import_zod31.z.object({ ...TaskItemSchema.omit({ taskList: true }).shape, blocks: import_zod31.z.array(import_zod31.z.string()).default([]), blockedBy: import_zod31.z.array(import_zod31.z.string()).default([]) });
+var WorkflowRunFileSchema = import_zod31.z.object({
+  runId: import_zod31.z.string(),
+  workflowName: import_zod31.z.string().optional(),
+  status: import_zod31.z.string().optional(),
+  startTime: import_zod31.z.number().optional(),
+  phases: import_zod31.z.array(import_zod31.z.object({ title: import_zod31.z.string() })).default([]),
+  summary: import_zod31.z.string().optional()
 });
 function summariseSession(fs13, configDir, ref) {
   const sessionRelative = import_node_path35.default.join(PROJECTS_DIR, ref.project, ref.entry);