agent-shim 11.50.2 → 11.51.0

package/dist/index.mjs

@@ -121,58 +121,72 @@ import { z } from "zod";
 function distinctList(member) {
   return z.array(member).refine((items) => new Set(items).size === items.length, "must not repeat a segment");
 }
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeStatuslineSettings(base, over) {
+  if (!isPlainObject(base) || !isPlainObject(over)) {
+    return over === void 0 ? base : over;
+  }
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(over)) {
+    merged[key] = key in base ? mergeStatuslineSettings(base[key], value) : value;
+  }
+  return merged;
+}
 function resolveStatusline(settings) {
-  const resolved = {
-    header: settings?.header ?? STATUSLINE_DEFAULTS.header,
-    bars: settings?.bars ?? STATUSLINE_DEFAULTS.bars,
-    warnAt: settings?.warnAt ?? STATUSLINE_DEFAULTS.warnAt,
-    criticalAt: settings?.criticalAt ?? STATUSLINE_DEFAULTS.criticalAt,
-    fiveHourLabel: settings?.fiveHourLabel ?? STATUSLINE_DEFAULTS.fiveHourLabel,
-    sevenDayLabel: settings?.sevenDayLabel ?? STATUSLINE_DEFAULTS.sevenDayLabel,
-    barWidth: settings?.barWidth ?? STATUSLINE_DEFAULTS.barWidth
-  };
-  if (resolved.warnAt >= resolved.criticalAt) {
-    throw new RangeError(`statusline warnAt (${String(resolved.warnAt)}) must be below criticalAt (${String(resolved.criticalAt)})`);
+  const resolved = ResolvedStatuslineSchema.parse(mergeStatuslineSettings(STATUSLINE_DEFAULTS, settings));
+  if (resolved.bands.warnAt >= resolved.bands.criticalAt) {
+    throw new RangeError(`statusline bands.warnAt (${String(resolved.bands.warnAt)}) must be below bands.criticalAt (${String(resolved.bands.criticalAt)})`);
   }
   return resolved;
 }
-var STATUSLINE_HEADER_SEGMENTS, STATUSLINE_BAR_GROUPS, MAX_PERCENT, MAX_STATUSLINE_LABEL_CHARS, MAX_BAR_CELLS, LABEL_RE2, wholePercent, StatuslineSchema, StatuslineChangeSchema, STATUSLINE_DEFAULTS, STATUSLINE_ENV;
+var STATUSLINE_HEADER_SEGMENTS, STATUSLINE_ROWS, MAX_PERCENT, MAX_STATUSLINE_LABEL_CHARS, MAX_BAR_CELLS, LABEL_RE2, labelText, wholePercent, SHAPES, StatuslineSchema, ResolvedStatuslineSchema, STATUSLINE_DEFAULTS, STATUSLINE_ENV;
 var init_statusline = __esm({
   "src/config/statusline.ts"() {
     "use strict";
     STATUSLINE_HEADER_SEGMENTS = ["model", "provider", "route", "account", "identity", "headroom"];
-    STATUSLINE_BAR_GROUPS = ["context", "quota"];
+    STATUSLINE_ROWS = ["context", "quota"];
     MAX_PERCENT = 100;
     MAX_STATUSLINE_LABEL_CHARS = 12;
     MAX_BAR_CELLS = 40;
     LABEL_RE2 = /^[^\p{C}\p{Z}]+(?: [^\p{C}\p{Z}]+)*$/u;
+    labelText = z.string().max(MAX_STATUSLINE_LABEL_CHARS).regex(LABEL_RE2, "must be visible text without control characters");
     wholePercent = z.number().int().min(1).max(MAX_PERCENT);
+    SHAPES = {
+      layout: {
+        header: distinctList(z.enum(STATUSLINE_HEADER_SEGMENTS)).describe("The header segments to draw, in drawing order; a segment left out is hidden, and an empty list hides the header."),
+        rows: distinctList(z.enum(STATUSLINE_ROWS)).describe("The rows to draw below the header, in drawing order; a row left out is hidden, and an empty list hides every row.")
+      },
+      bands: {
+        warnAt: wholePercent.describe("The whole percentage of use at which a bar turns yellow; it must be below criticalAt."),
+        criticalAt: wholePercent.describe("The whole percentage of use at which a bar turns red.")
+      },
+      labels: {
+        fiveHour: labelText.describe("The name of the five-hour subscription window."),
+        sevenDay: labelText.describe("The name of the weekly subscription window.")
+      },
+      bar: {
+        width: z.number().int().min(1).max(MAX_BAR_CELLS).describe("A bar's width in cells before the line's spare width is shared out among the bars.")
+      }
+    };
     StatuslineSchema = z.strictObject({
-      header: distinctList(z.enum(STATUSLINE_HEADER_SEGMENTS)).optional(),
-      bars: distinctList(z.enum(STATUSLINE_BAR_GROUPS)).optional(),
-      warnAt: wholePercent.optional(),
-      criticalAt: wholePercent.optional(),
-      fiveHourLabel: z.string().max(MAX_STATUSLINE_LABEL_CHARS).regex(LABEL_RE2, "must be visible text without control characters").optional(),
-      sevenDayLabel: z.string().max(MAX_STATUSLINE_LABEL_CHARS).regex(LABEL_RE2, "must be visible text without control characters").optional(),
-      barWidth: z.number().int().min(1).max(MAX_BAR_CELLS).optional()
+      layout: z.strictObject(SHAPES.layout).partial().optional(),
+      bands: z.strictObject(SHAPES.bands).partial().optional(),
+      labels: z.strictObject(SHAPES.labels).partial().optional(),
+      bar: z.strictObject(SHAPES.bar).partial().optional()
     });
-    StatuslineChangeSchema = z.strictObject({
-      header: z.union([StatuslineSchema.shape.header.unwrap(), z.literal(false)]).optional(),
-      bars: z.union([StatuslineSchema.shape.bars.unwrap(), z.literal(false)]).optional(),
-      warnAt: z.union([StatuslineSchema.shape.warnAt.unwrap(), z.literal(false)]).optional(),
-      criticalAt: z.union([StatuslineSchema.shape.criticalAt.unwrap(), z.literal(false)]).optional(),
-      fiveHourLabel: z.union([StatuslineSchema.shape.fiveHourLabel.unwrap(), z.literal(false)]).optional(),
-      sevenDayLabel: z.union([StatuslineSchema.shape.sevenDayLabel.unwrap(), z.literal(false)]).optional(),
-      barWidth: z.union([StatuslineSchema.shape.barWidth.unwrap(), z.literal(false)]).optional()
+    ResolvedStatuslineSchema = z.strictObject({
+      layout: z.strictObject(SHAPES.layout),
+      bands: z.strictObject(SHAPES.bands),
+      labels: z.strictObject(SHAPES.labels),
+      bar: z.strictObject(SHAPES.bar)
     });
     STATUSLINE_DEFAULTS = {
-      header: STATUSLINE_HEADER_SEGMENTS,
-      bars: STATUSLINE_BAR_GROUPS,
-      warnAt: 70,
-      criticalAt: 90,
-      fiveHourLabel: "5h",
-      sevenDayLabel: "Wk",
-      barWidth: 10
+      layout: { header: [...STATUSLINE_HEADER_SEGMENTS], rows: [...STATUSLINE_ROWS] },
+      bands: { warnAt: 70, criticalAt: 90 },
+      labels: { fiveHour: "5h", sevenDay: "Wk" },
+      bar: { width: 10 }
     };
     STATUSLINE_ENV = "AGENT_SHIM_STATUSLINE";
   }
@@ -1570,7 +1584,7 @@ function flattenLayers(layers, options) {
         launch.proxyBypass = layer.launch.proxyBypass;
       }
       if (layer.launch.statusline !== void 0) {
-        launch.statusline = { ...launch.statusline, ...layer.launch.statusline };
+        launch.statusline = StatuslineSchema.parse(mergeStatuslineSettings(launch.statusline, layer.launch.statusline));
       }
     }
     if (layer.models !== void 0) {
@@ -1751,6 +1765,7 @@ var init_flatten = __esm({
   "src/resolve/flatten.ts"() {
     "use strict";
     init_schema();
+    init_statusline();
     init_conditions();
     init_match();
   }
@@ -4235,7 +4250,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "agent-shim",
-      version: "11.50.2",
+      version: "11.51.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>",
@@ -7393,6 +7408,111 @@ var init_poolPick = __esm({
   }
 });
 
+// src/statusline/keys.ts
+import { z as z15 } from "zod";
+function valueAt(source, path43) {
+  let current = source;
+  for (const part of path43) {
+    if (!isPlainObject(current)) {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function keyOf(path43, leaf) {
+  const common = { path: path43.join("."), description: leaf.description ?? "", defaultValue: valueAt(STATUSLINE_DEFAULTS, path43) };
+  if (leaf instanceof z15.ZodNumber) {
+    return { ...common, kind: "integer", choices: [] };
+  }
+  if (leaf instanceof z15.ZodString) {
+    return { ...common, kind: "text", choices: [] };
+  }
+  if (leaf instanceof z15.ZodEnum) {
+    return { ...common, kind: "choice", choices: Object.values(leaf.enum).map(String) };
+  }
+  if (leaf instanceof z15.ZodArray && leaf.element instanceof z15.ZodEnum) {
+    return { ...common, kind: "list", choices: Object.values(leaf.element.enum).map(String) };
+  }
+  throw new TypeError(`statusline setting ${path43.join(".")} has a kind the key listing does not describe`);
+}
+function walk(shape, prefix) {
+  return Object.entries(shape).flatMap(([name, schema]) => schema instanceof z15.ZodObject ? walk(schema.shape, [...prefix, name]) : [keyOf([...prefix, name], schema)]);
+}
+function statuslineKeys() {
+  return walk(ResolvedStatuslineSchema.shape, []);
+}
+var init_keys = __esm({
+  "src/statusline/keys.ts"() {
+    "use strict";
+    init_statusline();
+  }
+});
+
+// src/statusline/change.ts
+function keyNamed(path43) {
+  const found = statuslineKeys().find((key) => key.path === path43);
+  if (found === void 0) {
+    throw new UsageError(`"${path43}" is not a statusline setting; \`agent-shim statusline keys\` lists them.`);
+  }
+  return found;
+}
+function setAt(target, path43, value) {
+  const [head, ...rest] = path43;
+  if (head === void 0) {
+    return;
+  }
+  if (rest.length === 0) {
+    target[head] = value;
+    return;
+  }
+  const child = target[head];
+  const next = isPlainObject(child) ? child : {};
+  target[head] = next;
+  setAt(next, rest, value);
+}
+function removeAt(target, path43) {
+  const [head, ...rest] = path43;
+  if (head === void 0) {
+    return;
+  }
+  const child = target[head];
+  if (rest.length === 0) {
+    Reflect.deleteProperty(target, head);
+    return;
+  }
+  if (isPlainObject(child)) {
+    removeAt(child, rest);
+    if (Object.keys(child).length === 0) {
+      Reflect.deleteProperty(target, head);
+    }
+  }
+}
+function applyStatuslineChange(existing, change) {
+  const draft = structuredClone(existing ?? {});
+  for (const [path43, value] of Object.entries(change.set ?? {})) {
+    keyNamed(path43);
+    setAt(draft, path43.split("."), value);
+  }
+  for (const path43 of change.unset ?? []) {
+    keyNamed(path43);
+    removeAt(draft, path43.split("."));
+  }
+  const result = StatuslineSchema.safeParse(draft);
+  if (!result.success) {
+    throw new UsageError(`statusline: ${result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}.`);
+  }
+  return Object.keys(result.data).length === 0 ? void 0 : result.data;
+}
+var init_change = __esm({
+  "src/statusline/change.ts"() {
+    "use strict";
+    init_cliError();
+    init_statusline();
+    init_keys();
+  }
+});
+
 // src/configProfilesStore.ts
 import fs4 from "node:fs";
 import path22 from "node:path";
@@ -7494,17 +7614,6 @@ function removeProfile(paths, name) {
   requireProfileExists(paths, name);
   fs4.rmSync(profileJsonPath(paths, name));
 }
-function withStatuslineChange(existing, change) {
-  const merged = new Map(Object.entries({ ...existing }));
-  for (const [key, value] of Object.entries(change)) {
-    if (value === false) {
-      merged.delete(key);
-    } else {
-      merged.set(key, value);
-    }
-  }
-  return merged.size === 0 ? void 0 : StatuslineSchema.parse(Object.fromEntries(merged));
-}
 function applyProfileChange(paths, name, change) {
   let touched = false;
   if (change.category !== void 0) {
@@ -7554,7 +7663,7 @@ function applyProfileChange(paths, name, change) {
     launchPatch.explain = change.launchExplain;
   }
   if (change.launchStatusline !== void 0) {
-    launchPatch.statusline = withStatuslineChange(readProfile(paths, name)?.launch?.statusline, change.launchStatusline);
+    launchPatch.statusline = applyStatuslineChange(readProfile(paths, name)?.launch?.statusline, change.launchStatusline);
   }
   if (Object.keys(launchPatch).length > 0) {
     setProfileLaunchFlags(paths, name, launchPatch);
@@ -7569,7 +7678,7 @@ var init_configProfilesStore = __esm({
     init_store();
     init_schema();
     init_cliError();
-    init_statusline();
+    init_change();
     init_load();
     ProfileNotFoundError = class extends CliError {
       constructor(profileName) {
@@ -7681,7 +7790,7 @@ var init_paths = __esm({
 });
 
 // src/credentialCache.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 function effectiveStore(cache, platform) {
   return cache.store ?? (platform === "darwin" ? "keychain" : "file");
 }
@@ -7748,9 +7857,9 @@ var init_credentialCache = __esm({
     init_schema();
     init_preflight();
     MS_PER_UNIT = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
-    CachedCredentialSchema = z15.strictObject({
-      token: z15.string().min(1),
-      fetchedAt: z15.number().int().nonnegative(),
+    CachedCredentialSchema = z16.strictObject({
+      token: z16.string().min(1),
+      fetchedAt: z16.number().int().nonnegative(),
       source: CredentialSourceSchema
     });
   }
@@ -7842,7 +7951,7 @@ var init_realCredentialCache = __esm({
 });
 
 // src/providerAliases.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 function parseAliases(file, raw) {
   const parsed = ProviderAliasesSchema.safeParse(raw);
   if (!parsed.success) {
@@ -7881,7 +7990,7 @@ var init_providerAliases = __esm({
     init_cliError();
     init_load();
     init_store();
-    ProviderAliasesSchema = z16.record(z16.string().min(1), z16.string().min(1));
+    ProviderAliasesSchema = z17.record(z17.string().min(1), z17.string().min(1));
   }
 });
 
@@ -8898,7 +9007,7 @@ var init_commandDeps = __esm({
 // src/claudeShim.ts
 import fs8 from "node:fs";
 import path28 from "node:path";
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 function commandFilename(ownExecutablePath, commandName) {
   return ownExecutablePath.toLowerCase().endsWith(".exe") ? `${commandName}.exe` : commandName;
 }
@@ -8948,10 +9057,10 @@ var init_claudeShim = __esm({
     init_store();
     init_realPorts();
     init_cliError();
-    ClaudeShimStateSchema = z21.strictObject({
-      targetPath: z21.string().min(1),
-      method: z21.enum(["hardlink", "copy"]),
-      installedAtMs: z21.number()
+    ClaudeShimStateSchema = z22.strictObject({
+      targetPath: z22.string().min(1),
+      method: z22.enum(["hardlink", "copy"]),
+      installedAtMs: z22.number()
     });
     nodeLinkFs = { link: fs8.linkSync, copyFile: fs8.copyFileSync, chmod: fs8.chmodSync };
   }
@@ -8970,14 +9079,14 @@ function memberKindOf(ref, models) {
 function expandMembers(name, models) {
   const virtual = models?.virtual ?? {};
   const expanded = [];
-  const walk = (current, chain) => {
+  const walk2 = (current, chain) => {
     const nested = virtual[current];
     if (nested !== void 0) {
       if (chain.includes(current)) {
         throw new Error(`virtual model cycle: ${[...chain, current].join(" -> ")}`);
       }
       for (const member of nested.members) {
-        walk(member, [...chain, current]);
+        walk2(member, [...chain, current]);
       }
       return;
     }
@@ -8990,7 +9099,7 @@ function expandMembers(name, models) {
     throw new VirtualModelNotFoundError(name);
   }
   for (const member of top.members) {
-    walk(member, [name]);
+    walk2(member, [name]);
   }
   return expanded;
 }
@@ -9047,62 +9156,62 @@ var init_signatures = __esm({
 });
 
 // src/codex/anthropic.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var 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";
-    TextBlockSchema = z25.looseObject({ type: z25.literal("text"), text: z25.string() });
-    Base64ImageSourceSchema = z25.looseObject({ type: z25.literal("base64"), media_type: z25.string().min(1), data: z25.string() });
-    UrlImageSourceSchema = z25.looseObject({ type: z25.literal("url"), url: z25.string().min(1) });
-    ImageBlockSchema = z25.looseObject({
-      type: z25.literal("image"),
-      source: z25.union([Base64ImageSourceSchema, UrlImageSourceSchema])
+    TextBlockSchema = z26.looseObject({ type: z26.literal("text"), text: z26.string() });
+    Base64ImageSourceSchema = z26.looseObject({ type: z26.literal("base64"), media_type: z26.string().min(1), data: z26.string() });
+    UrlImageSourceSchema = z26.looseObject({ type: z26.literal("url"), url: z26.string().min(1) });
+    ImageBlockSchema = z26.looseObject({
+      type: z26.literal("image"),
+      source: z26.union([Base64ImageSourceSchema, UrlImageSourceSchema])
     });
-    ToolUseBlockSchema = z25.looseObject({
-      type: z25.literal("tool_use"),
-      id: z25.string().min(1),
-      name: z25.string().min(1),
-      input: z25.unknown()
+    ToolUseBlockSchema = z26.looseObject({
+      type: z26.literal("tool_use"),
+      id: z26.string().min(1),
+      name: z26.string().min(1),
+      input: z26.unknown()
     });
-    ToolResultContentBlockSchema = z25.union([TextBlockSchema, z25.looseObject({ type: z25.string() })]);
-    ToolResultBlockSchema = z25.looseObject({
-      type: z25.literal("tool_result"),
-      tool_use_id: z25.string().min(1),
-      content: z25.union([z25.string(), z25.array(ToolResultContentBlockSchema)]).optional()
+    ToolResultContentBlockSchema = z26.union([TextBlockSchema, z26.looseObject({ type: z26.string() })]);
+    ToolResultBlockSchema = z26.looseObject({
+      type: z26.literal("tool_result"),
+      tool_use_id: z26.string().min(1),
+      content: z26.union([z26.string(), z26.array(ToolResultContentBlockSchema)]).optional()
     });
-    OtherBlockSchema = z25.looseObject({ type: z25.string() });
-    ContentBlockSchema = z25.union([TextBlockSchema, ImageBlockSchema, ToolUseBlockSchema, ToolResultBlockSchema, OtherBlockSchema]);
-    MessageSchema = z25.looseObject({
-      role: z25.enum(["user", "assistant", "system"]),
-      content: z25.union([z25.string(), z25.array(ContentBlockSchema)])
+    OtherBlockSchema = z26.looseObject({ type: z26.string() });
+    ContentBlockSchema = z26.union([TextBlockSchema, ImageBlockSchema, ToolUseBlockSchema, ToolResultBlockSchema, OtherBlockSchema]);
+    MessageSchema = z26.looseObject({
+      role: z26.enum(["user", "assistant", "system"]),
+      content: z26.union([z26.string(), z26.array(ContentBlockSchema)])
     });
-    ToolSchema = z25.looseObject({
-      name: z25.string().min(1),
-      description: z25.string().optional(),
-      input_schema: z25.record(z25.string(), z25.unknown()).optional()
+    ToolSchema = z26.looseObject({
+      name: z26.string().min(1),
+      description: z26.string().optional(),
+      input_schema: z26.record(z26.string(), z26.unknown()).optional()
     });
-    ToolChoiceSchema = z25.union([
-      z25.looseObject({ type: z25.enum(["auto", "none", "any"]) }),
-      z25.looseObject({ type: z25.literal("tool"), name: z25.string().min(1) })
+    ToolChoiceSchema = z26.union([
+      z26.looseObject({ type: z26.enum(["auto", "none", "any"]) }),
+      z26.looseObject({ type: z26.literal("tool"), name: z26.string().min(1) })
     ]);
-    SystemSchema = z25.union([z25.string(), z25.array(z25.union([TextBlockSchema, OtherBlockSchema]))]);
-    MessagesRequestSchema = z25.looseObject({
-      model: z25.string().optional(),
+    SystemSchema = z26.union([z26.string(), z26.array(z26.union([TextBlockSchema, OtherBlockSchema]))]);
+    MessagesRequestSchema = z26.looseObject({
+      model: z26.string().optional(),
       system: SystemSchema.optional(),
-      messages: z25.array(MessageSchema),
-      tools: z25.array(ToolSchema).optional(),
+      messages: z26.array(MessageSchema),
+      tools: z26.array(ToolSchema).optional(),
       tool_choice: ToolChoiceSchema.optional(),
-      stream: z25.boolean().optional(),
+      stream: z26.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: z25.looseObject({ user_id: z25.string().optional() }).optional(),
+      metadata: z26.looseObject({ user_id: z26.string().optional() }).optional(),
       /** Claude Code's effort setting. Any string is accepted; the translator honours only the levels the backend understands. */
-      output_config: z25.looseObject({ effort: z25.string().optional() }).optional()
+      output_config: z26.looseObject({ effort: z26.string().optional() }).optional()
     });
-    CountTokensRequestSchema = z25.looseObject({
-      system: z25.unknown().optional(),
-      messages: z25.unknown().optional(),
-      tools: z25.unknown().optional()
+    CountTokensRequestSchema = z26.looseObject({
+      system: z26.unknown().optional(),
+      messages: z26.unknown().optional(),
+      tools: z26.unknown().optional()
     });
   }
 });
@@ -9187,7 +9296,7 @@ var init_translate2 = __esm({
 // src/providerCatalogue.ts
 import path30 from "node:path";
 import picomatch4 from "picomatch";
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 function catalogueCachePath(paths, name) {
   return path30.join(paths.catalogueDir, `${name}.json`);
 }
@@ -9222,8 +9331,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 = z26.strictObject({ id: z26.string().min(1), name: z26.string().min(1).optional() });
-    CatalogueCacheSchema = z26.strictObject({ fetchedAt: z26.number(), url: z26.string().min(1), models: z26.array(CatalogueModelSchema) });
+    CatalogueModelSchema = z27.strictObject({ id: z27.string().min(1), name: z27.string().min(1).optional() });
+    CatalogueCacheSchema = z27.strictObject({ fetchedAt: z27.number(), url: z27.string().min(1), models: z27.array(CatalogueModelSchema) });
   }
 });
 
@@ -11583,7 +11692,7 @@ function isAnthropicUsageStale(member, nowMs) {
 function poolIdentityNames(pools, poolName) {
   const seenPools = /* @__PURE__ */ new Set();
   const identities = /* @__PURE__ */ new Set();
-  const walk = (name) => {
+  const walk2 = (name) => {
     const pool = pools[name];
     if (pool === void 0 || seenPools.has(name)) {
       return;
@@ -11595,11 +11704,11 @@ function poolIdentityNames(pools, poolName) {
       if (nested === void 0) {
         identities.add(member);
       } else {
-        walk(nested);
+        walk2(nested);
       }
     }
   };
-  walk(poolName);
+  walk2(poolName);
   return [...identities];
 }
 function describeError(error) {
@@ -11718,7 +11827,7 @@ var init_identityClaude = __esm({
 });
 
 // src/usage/providerQuota.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 var 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"() {
@@ -11737,35 +11846,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 = z33.object({
-      type: z33.string(),
-      unit: z33.number().int(),
-      number: z33.number().int().positive(),
-      percentage: z33.number().nonnegative(),
-      nextResetTime: z33.number().positive().optional(),
-      usage: z33.number().nonnegative().optional(),
-      currentValue: z33.number().nonnegative().optional(),
-      remaining: z33.number().nonnegative().optional()
+    ZaiLimitSchema = z34.object({
+      type: z34.string(),
+      unit: z34.number().int(),
+      number: z34.number().int().positive(),
+      percentage: z34.number().nonnegative(),
+      nextResetTime: z34.number().positive().optional(),
+      usage: z34.number().nonnegative().optional(),
+      currentValue: z34.number().nonnegative().optional(),
+      remaining: z34.number().nonnegative().optional()
     });
-    ZaiResponseSchema = z33.object({
-      success: z33.boolean(),
-      msg: z33.string().optional(),
-      data: z33.object({ level: z33.string().optional(), limits: z33.array(ZaiLimitSchema) })
+    ZaiResponseSchema = z34.object({
+      success: z34.boolean(),
+      msg: z34.string().optional(),
+      data: z34.object({ level: z34.string().optional(), limits: z34.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 = z33.object({
-      data: z33.object({
-        limit: z33.number().nonnegative().nullable(),
-        limit_remaining: z33.number().nullable(),
-        limit_reset: z33.string().nullable(),
-        is_free_tier: z33.boolean().optional(),
-        free_model_daily_requests: z33.object({ used: z33.number().nonnegative(), limit: z33.number().nonnegative(), remaining: z33.number() }).optional()
+    OpenRouterKeySchema = z34.object({
+      data: z34.object({
+        limit: z34.number().nonnegative().nullable(),
+        limit_remaining: z34.number().nullable(),
+        limit_reset: z34.string().nullable(),
+        is_free_tier: z34.boolean().optional(),
+        free_model_daily_requests: z34.object({ used: z34.number().nonnegative(), limit: z34.number().nonnegative(), remaining: z34.number() }).optional()
       })
     });
-    OpenRouterCreditsSchema = z33.object({ data: z33.object({ total_credits: z33.number().nonnegative(), total_usage: z33.number().nonnegative() }) });
+    OpenRouterCreditsSchema = z34.object({ data: z34.object({ total_credits: z34.number().nonnegative(), total_usage: z34.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`;
@@ -11773,21 +11882,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 = z33.object({
-      bucketId: z33.string(),
-      remainingFraction: z33.number().optional(),
-      resetTime: z33.string().optional()
+    AntigravityBucketSchema = z34.object({
+      bucketId: z34.string(),
+      remainingFraction: z34.number().optional(),
+      resetTime: z34.string().optional()
     });
-    AntigravitySummarySchema = z33.object({ groups: z33.array(z33.object({ buckets: z33.array(AntigravityBucketSchema) })) });
-    GoogleTokenInfoSchema = z33.object({
-      email: z33.string().optional(),
-      sub: z33.string().optional()
+    AntigravitySummarySchema = z34.object({ groups: z34.array(z34.object({ buckets: z34.array(AntigravityBucketSchema) })) });
+    GoogleTokenInfoSchema = z34.object({
+      email: z34.string().optional(),
+      sub: z34.string().optional()
     });
-    AntigravityUserSchema = z33.object({
+    AntigravityUserSchema = z34.object({
       /** The code-assist tier context, which defaults to the free tier for every account. */
-      currentTier: z33.object({ name: z33.string().optional(), id: z33.string().optional() }).optional(),
+      currentTier: z34.object({ name: z34.string().optional(), id: z34.string().optional() }).optional(),
       /** The account's paid subscription; absent when the account has none. */
-      paidTier: z33.object({ name: z33.string().optional(), id: z33.string().optional() }).optional()
+      paidTier: z34.object({ name: z34.string().optional(), id: z34.string().optional() }).optional()
     });
   }
 });
@@ -14686,7 +14795,7 @@ function writePools(paths, pools) {
   applyPatch(paths.globalConfigFile, GlobalConfigSchema, { pools }, { defaults: {} });
 }
 function poolCycleOf(pools, name) {
-  const walk = (current, path43) => {
+  const walk2 = (current, path43) => {
     for (const entry of pools[current]?.identities ?? []) {
       const nested = poolNameOf(poolMemberIdentity(entry));
       if (nested === void 0) {
@@ -14698,14 +14807,14 @@ function poolCycleOf(pools, name) {
       if (path43.includes(nested)) {
         continue;
       }
-      const found = walk(nested, [...path43, nested]);
+      const found = walk2(nested, [...path43, nested]);
       if (found !== void 0) {
         return found;
       }
     }
     return void 0;
   };
-  return walk(name, [name]);
+  return walk2(name, [name]);
 }
 function validateMembers(pools, name, members) {
   for (const entry of members) {
@@ -14834,7 +14943,7 @@ init_providersStore();
 init_projects();
 init_pipeline();
 import path27 from "node:path";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var HISTORY_PROJECTS_KEY_PREFIX = "history/projects/";
 function projectFragmentOf(rawKey) {
   return rawKey.startsWith(HISTORY_PROJECTS_KEY_PREFIX) ? rawKey.slice(HISTORY_PROJECTS_KEY_PREFIX.length) : void 0;
@@ -14903,9 +15012,9 @@ function lookupKeychainService(run, farmRoot) {
   }
   return { checked: true, found: true, serviceName, note: `Keychain service name for this identity: "${serviceName}".` };
 }
-var SettingsSecretsShapeSchema = z17.looseObject({
-  env: z17.record(z17.string(), z17.unknown()).optional(),
-  hooks: z17.record(z17.string(), z17.array(z17.unknown())).optional()
+var SettingsSecretsShapeSchema = z18.looseObject({
+  env: z18.record(z18.string(), z18.unknown()).optional(),
+  hooks: z18.record(z18.string(), z18.array(z18.unknown())).optional()
 });
 function hookCommandCountOf(group) {
   if (typeof group !== "object" || group === null) {
@@ -15202,7 +15311,7 @@ init_schema();
 init_claudeVersion();
 init_identity();
 init_projects();
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/resolve/types.ts
 var LAYER_KINDS = [
@@ -15263,123 +15372,123 @@ var DIAGNOSTIC_SEVERITIES = ["error", "warning", "info"];
 
 // src/usage/pickReportSchema.ts
 init_plan2();
-import { z as z18 } from "zod";
-var PoolPickCandidateViewSchema = z18.strictObject({
-  identity: z18.string(),
+import { z as z19 } from "zod";
+var PoolPickCandidateViewSchema = z19.strictObject({
+  identity: z19.string(),
   /** In pick order: `scored` has usable quota data, `unknown` has none, `pay-per-use` bills by use, `ineligible` is refused right now. */
-  class: z18.enum(["scored", "unknown", "pay-per-use", "ineligible"]),
+  class: z19.enum(["scored", "unknown", "pay-per-use", "ineligible"]),
   /** Plan-size-weighted remaining quota per hour until its reset; present for `scored` only. */
-  score: z18.number().optional(),
+  score: z19.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: z18.enum(["sevenDay", "fiveHour"]).optional(),
+  scoreWindow: z19.enum(["sevenDay", "fiveHour"]).optional(),
   /** False when the five-hour window would run dry, at the observed pace, before it resets. */
-  feasible: z18.boolean(),
+  feasible: z19.boolean(),
   /** When an `ineligible` member can be used again, as an ISO instant. */
-  blockedUntil: z18.iso.datetime().optional(),
+  blockedUntil: z19.iso.datetime().optional(),
   plan: PlanClassSchema,
   /** The facts behind the class and score, in the order they matter. */
-  reasons: z18.array(z18.string())
+  reasons: z19.array(z19.string())
 });
-var PoolPickReportSchema = z18.strictObject({
-  pool: z18.string(),
-  directory: z18.string(),
+var PoolPickReportSchema = z19.strictObject({
+  pool: z19.string(),
+  directory: z19.string(),
   /** The member a launch would run as, absent when every member is refused. */
-  pick: z18.string().optional(),
-  candidates: z18.array(PoolPickCandidateViewSchema),
+  pick: z19.string().optional(),
+  candidates: z19.array(PoolPickCandidateViewSchema),
   /** Identity members anywhere in the pool's graph that do not exist; a launch skips them. */
-  missing: z18.array(z18.string()),
+  missing: z19.array(z19.string()),
   /** When nothing can be picked, the soonest any member returns. */
-  earliestReturn: z18.strictObject({ identity: z18.string(), at: z18.iso.datetime() }).optional(),
+  earliestReturn: z19.strictObject({ identity: z19.string(), at: z19.iso.datetime() }).optional(),
   /** The member a resumed conversation started on but moved off, and why, when the ranking could not keep it. */
-  movedOff: z18.strictObject({ identity: z18.string(), reason: z18.string() }).optional(),
+  movedOff: z19.strictObject({ identity: z19.string(), reason: z19.string() }).optional(),
   /** Why the last-pick record could not be read, when that is the case. */
-  stickyProblem: z18.string().optional()
+  stickyProblem: z19.string().optional()
 });
 
 // src/checkReportSchema.ts
 var CHECK_CREDENTIAL_APPLIES = ["provider", "identity", "stored-login"];
-var CheckLayerViewSchema = z19.strictObject({
-  id: z19.int(),
-  kind: z19.enum(LAYER_KINDS),
-  source: z19.string()
+var CheckLayerViewSchema = z20.strictObject({
+  id: z20.int(),
+  kind: z20.enum(LAYER_KINDS),
+  source: z20.string()
 });
-var CheckEntryViewSchema = z19.strictObject({
-  path: z19.string(),
-  shared: z19.boolean(),
-  via: z19.enum(DECISION_VIAS),
+var CheckEntryViewSchema = z20.strictObject({
+  path: z20.string(),
+  shared: z20.boolean(),
+  via: z20.enum(DECISION_VIAS),
   /** The entry's real category, or null when nothing classifies it. */
-  category: z19.enum(CATEGORY_NAMES).nullable(),
-  rule: z19.strictObject({ key: z19.string(), layer: z19.int() }).optional(),
+  category: z20.enum(CATEGORY_NAMES).nullable(),
+  rule: z20.strictObject({ key: z20.string(), layer: z20.int() }).optional(),
   /** Rules that matched but whose `when` condition failed, each with the conditions that failed. */
-  eliminated: z19.readonly(z19.array(z19.strictObject({ key: z19.string(), failed: z19.readonly(z19.array(z19.string())) }))).optional()
+  eliminated: z20.readonly(z20.array(z20.strictObject({ key: z20.string(), failed: z20.readonly(z20.array(z20.string())) }))).optional()
 });
-var CheckDiagnosticSchema = z19.strictObject({
-  code: z19.enum(DIAGNOSTIC_CODES),
-  severity: z19.enum(DIAGNOSTIC_SEVERITIES),
-  message: z19.string(),
-  subject: z19.string().optional(),
-  layer: z19.int().optional()
+var CheckDiagnosticSchema = z20.strictObject({
+  code: z20.enum(DIAGNOSTIC_CODES),
+  severity: z20.enum(DIAGNOSTIC_SEVERITIES),
+  message: z20.string(),
+  subject: z20.string().optional(),
+  layer: z20.int().optional()
 });
-var CheckAmbientCredentialSchema = z19.union([z19.strictObject({ ok: z19.literal(true) }), z19.strictObject({ ok: z19.literal(false), variable: z19.string(), message: z19.string() })]);
-var CheckKeychainSchema = z19.strictObject({
-  checked: z19.literal(true),
-  found: z19.boolean(),
-  serviceName: z19.string().optional(),
-  note: z19.string()
+var CheckAmbientCredentialSchema = z20.union([z20.strictObject({ ok: z20.literal(true) }), z20.strictObject({ ok: z20.literal(false), variable: z20.string(), message: z20.string() })]);
+var CheckKeychainSchema = z20.strictObject({
+  checked: z20.literal(true),
+  found: z20.boolean(),
+  serviceName: z20.string().optional(),
+  note: z20.string()
 });
-var CheckSettingsExposureSchema = z19.strictObject({
-  file: z19.string(),
-  envKeyNames: z19.readonly(z19.array(z19.string())),
-  hookEventNames: z19.readonly(z19.array(z19.string())),
-  hookCommandCount: z19.int().nonnegative()
+var CheckSettingsExposureSchema = z20.strictObject({
+  file: z20.string(),
+  envKeyNames: z20.readonly(z20.array(z20.string())),
+  hookEventNames: z20.readonly(z20.array(z20.string())),
+  hookCommandCount: z20.int().nonnegative()
 });
-var CredentialSourceSummarySchema = z19.union([
-  z19.strictObject({ kind: z19.literal("env"), variable: z19.string() }),
-  z19.strictObject({ kind: z19.literal("file"), path: z19.string() }),
-  z19.strictObject({ kind: z19.literal("command"), program: z19.string() }),
-  z19.strictObject({ kind: z19.literal("op"), reference: z19.string() }),
-  z19.strictObject({ kind: z19.literal("keychain"), service: z19.string(), account: z19.string().optional() }),
-  z19.strictObject({ kind: z19.literal("literal") })
+var CredentialSourceSummarySchema = z20.union([
+  z20.strictObject({ kind: z20.literal("env"), variable: z20.string() }),
+  z20.strictObject({ kind: z20.literal("file"), path: z20.string() }),
+  z20.strictObject({ kind: z20.literal("command"), program: z20.string() }),
+  z20.strictObject({ kind: z20.literal("op"), reference: z20.string() }),
+  z20.strictObject({ kind: z20.literal("keychain"), service: z20.string(), account: z20.string().optional() }),
+  z20.strictObject({ kind: z20.literal("literal") })
 ]);
-var CredentialSummarySchema = z19.strictObject({
-  target: z19.enum(CREDENTIAL_TARGETS),
-  sources: z19.readonly(z19.array(CredentialSourceSummarySchema)),
+var CredentialSummarySchema = z20.strictObject({
+  target: z20.enum(CREDENTIAL_TARGETS),
+  sources: z20.readonly(z20.array(CredentialSourceSummarySchema)),
   cache: CredentialCacheSchema.optional()
 });
-var CachedCredentialStateSchema = z19.union([
-  z19.strictObject({ store: z19.enum(CREDENTIAL_CACHE_STORES), status: z19.literal("empty") }),
-  z19.strictObject({ store: z19.enum(CREDENTIAL_CACHE_STORES), status: z19.literal("unreadable"), reason: z19.string() }),
-  z19.strictObject({ store: z19.enum(CREDENTIAL_CACHE_STORES), status: z19.enum(["fresh", "expired"]), ageMs: z19.number(), expiresInMs: z19.number().optional() })
+var CachedCredentialStateSchema = z20.union([
+  z20.strictObject({ store: z20.enum(CREDENTIAL_CACHE_STORES), status: z20.literal("empty") }),
+  z20.strictObject({ store: z20.enum(CREDENTIAL_CACHE_STORES), status: z20.literal("unreadable"), reason: z20.string() }),
+  z20.strictObject({ store: z20.enum(CREDENTIAL_CACHE_STORES), status: z20.enum(["fresh", "expired"]), ageMs: z20.number(), expiresInMs: z20.number().optional() })
 ]);
-var CheckCredentialProviderSchema = z19.union([
-  z19.strictObject({ name: z19.string(), credential: CredentialSummarySchema.optional(), cached: CachedCredentialStateSchema.optional() }),
-  z19.strictObject({ name: z19.string(), problem: z19.string() })
+var CheckCredentialProviderSchema = z20.union([
+  z20.strictObject({ name: z20.string(), credential: CredentialSummarySchema.optional(), cached: CachedCredentialStateSchema.optional() }),
+  z20.strictObject({ name: z20.string(), problem: z20.string() })
 ]);
-var CheckCredentialSchema = z19.strictObject({
-  applies: z19.enum(CHECK_CREDENTIAL_APPLIES),
+var CheckCredentialSchema = z20.strictObject({
+  applies: z20.enum(CHECK_CREDENTIAL_APPLIES),
   provider: CheckCredentialProviderSchema.optional(),
   identity: CredentialSummarySchema.optional(),
   identityCached: CachedCredentialStateSchema.optional()
 });
-var CheckClaudeVersionSchema = z19.strictObject({
-  pinned: z19.strictObject({ version: z19.string(), source: z19.enum(CLAUDE_VERSION_SOURCES), installed: z19.boolean() }).optional(),
-  highestInstalled: z19.string().optional(),
-  installed: z19.readonly(z19.array(z19.string()))
+var CheckClaudeVersionSchema = z20.strictObject({
+  pinned: z20.strictObject({ version: z20.string(), source: z20.enum(CLAUDE_VERSION_SOURCES), installed: z20.boolean() }).optional(),
+  highestInstalled: z20.string().optional(),
+  installed: z20.readonly(z20.array(z20.string()))
 });
-var CheckReportJsonSchema = z19.strictObject({
-  identity: z19.strictObject({ name: z19.string().nullable(), source: z19.enum(IDENTITY_DECISION_SOURCES) }),
+var CheckReportJsonSchema = z20.strictObject({
+  identity: z20.strictObject({ name: z20.string().nullable(), source: z20.enum(IDENTITY_DECISION_SOURCES) }),
   /** The pool ranking, when the launch named a pool instead of an identity. */
   pool: PoolPickReportSchema.optional(),
-  configProfile: z19.strictObject({ name: z19.string().nullable(), source: z19.enum(CONFIG_PROFILE_DECISION_SOURCES) }),
-  layers: z19.readonly(z19.array(CheckLayerViewSchema)),
-  entries: z19.readonly(z19.array(CheckEntryViewSchema)),
-  projectEncodingAmbiguities: z19.readonly(
-    z19.array(z19.strictObject({ fragment: z19.string(), encoded: z19.string(), reason: z19.enum(ENCODING_AMBIGUITY_REASONS), detail: z19.string() }))
+  configProfile: z20.strictObject({ name: z20.string().nullable(), source: z20.enum(CONFIG_PROFILE_DECISION_SOURCES) }),
+  layers: z20.readonly(z20.array(CheckLayerViewSchema)),
+  entries: z20.readonly(z20.array(CheckEntryViewSchema)),
+  projectEncodingAmbiguities: z20.readonly(
+    z20.array(z20.strictObject({ fragment: z20.string(), encoded: z20.string(), reason: z20.enum(ENCODING_AMBIGUITY_REASONS), detail: z20.string() }))
   ),
-  diagnostics: z19.readonly(z19.array(CheckDiagnosticSchema)),
+  diagnostics: z20.readonly(z20.array(CheckDiagnosticSchema)),
   ambientCredential: CheckAmbientCredentialSchema,
   keychain: CheckKeychainSchema.optional(),
-  settingsExposure: z19.readonly(z19.array(CheckSettingsExposureSchema)),
+  settingsExposure: z20.readonly(z20.array(CheckSettingsExposureSchema)),
   credential: CheckCredentialSchema,
   claudeVersion: CheckClaudeVersionSchema.optional()
 });
@@ -15439,28 +15548,28 @@ function collectResets(snapshots, nowMs) {
 }
 
 // src/usage/resetsSchema.ts
-import { z as z20 } from "zod";
-var ResetRowSchema = z20.strictObject({
-  identity: z20.string(),
-  provider: z20.string(),
+import { z as z21 } from "zod";
+var ResetRowSchema = z21.strictObject({
+  identity: z21.string(),
+  provider: z21.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: z20.string(),
+  window: z21.string(),
   /** When the state the window comes from was observed, as an ISO instant. */
-  observedAt: z20.iso.datetime(),
+  observedAt: z21.iso.datetime(),
   /** When the window resets, as an ISO instant; absent when the upstream reported none. */
-  resetsAt: z20.iso.datetime().optional(),
+  resetsAt: z21.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: z20.boolean(),
+  reset: z21.boolean(),
   /** The fraction used, as `effectiveWindow` reads it at the report's own clock. */
-  utilization: z20.number().optional(),
+  utilization: z21.number().optional(),
   /** The window's own status, for a window that has not reset yet. */
-  status: z20.string().optional()
+  status: z21.string().optional()
 });
-var ResetScheduleSchema = z20.strictObject({ resets: z20.readonly(z20.array(ResetRowSchema)) });
+var ResetScheduleSchema = z21.strictObject({ resets: z21.readonly(z21.array(ResetRowSchema)) });
 
 // src/frontdoor/controlSchemas.ts
 import path32 from "node:path";
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 
 // src/doctorReport.ts
 init_claudeShim();
@@ -15640,24 +15749,24 @@ import path31 from "node:path";
 init_signIn();
 
 // src/codex/siwcStore.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // src/codex/auth.ts
-import { z as z22 } from "zod";
-var AuthFileSchema = z22.looseObject({
-  tokens: z22.looseObject({
-    access_token: z22.string().optional(),
-    refresh_token: z22.string().optional(),
-    id_token: z22.string().optional(),
-    account_id: z22.string().optional()
+import { z as z23 } from "zod";
+var AuthFileSchema = z23.looseObject({
+  tokens: z23.looseObject({
+    access_token: z23.string().optional(),
+    refresh_token: z23.string().optional(),
+    id_token: z23.string().optional(),
+    account_id: z23.string().optional()
   }).nullish(),
-  last_refresh: z22.string().optional()
+  last_refresh: z23.string().optional()
 });
-var TokenGrantSchema = z22.looseObject({
-  access_token: z22.string().min(1).optional(),
-  refresh_token: z22.string().min(1).optional(),
-  id_token: z22.string().min(1).optional(),
-  account_id: z22.string().min(1).optional()
+var TokenGrantSchema = z23.looseObject({
+  access_token: z23.string().min(1).optional(),
+  refresh_token: z23.string().min(1).optional(),
+  id_token: z23.string().min(1).optional(),
+  account_id: z23.string().min(1).optional()
 });
 var CodexAuthError = class extends Error {
   constructor(message) {
@@ -15667,41 +15776,41 @@ var CodexAuthError = class extends Error {
 };
 
 // src/codex/siwc.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "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 = z23.looseObject({
-  access_token: z23.string().min(1),
-  refresh_token: z23.string().min(1).optional(),
-  id_token: z23.string().min(1).optional(),
-  expires_in: z23.number().positive(),
-  scope: z23.string().optional()
+var TokenResponseSchema = z24.looseObject({
+  access_token: z24.string().min(1),
+  refresh_token: z24.string().min(1).optional(),
+  id_token: z24.string().min(1).optional(),
+  expires_in: z24.number().positive(),
+  scope: z24.string().optional()
 });
-var JwtHeaderSchema = z23.looseObject({ alg: z23.string(), kid: z23.string().optional() });
-var IdTokenClaimsSchema = z23.looseObject({
-  iss: z23.string(),
-  sub: z23.string().min(1),
-  aud: z23.union([z23.string(), z23.array(z23.string())]),
-  exp: z23.number(),
-  nonce: z23.string().optional(),
-  email: z23.string().optional()
+var JwtHeaderSchema = z24.looseObject({ alg: z24.string(), kid: z24.string().optional() });
+var IdTokenClaimsSchema = z24.looseObject({
+  iss: z24.string(),
+  sub: z24.string().min(1),
+  aud: z24.union([z24.string(), z24.array(z24.string())]),
+  exp: z24.number(),
+  nonce: z24.string().optional(),
+  email: z24.string().optional()
 });
-var JwksSchema = z23.object({ keys: z23.array(z23.looseObject({ kid: z23.string().optional(), kty: z23.string() })) });
+var JwksSchema = z24.object({ keys: z24.array(z24.looseObject({ kid: z24.string().optional(), kty: z24.string() })) });
 
 // src/codex/siwcStore.ts
-var SiwcGrantSchema = z24.strictObject({
-  clientId: z24.string().min(1),
-  sub: z24.string().min(1),
-  email: z24.string().optional(),
-  idToken: z24.string().min(1),
-  accessToken: z24.string().min(1),
-  refreshToken: z24.string().min(1),
-  scopes: z24.array(z24.string()).readonly(),
+var SiwcGrantSchema = z25.strictObject({
+  clientId: z25.string().min(1),
+  sub: z25.string().min(1),
+  email: z25.string().optional(),
+  idToken: z25.string().min(1),
+  accessToken: z25.string().min(1),
+  refreshToken: z25.string().min(1),
+  scopes: z25.array(z25.string()).readonly(),
   /** When the access token stops working, in milliseconds since the epoch. */
-  expiresAt: z24.number()
+  expiresAt: z25.number()
 });
-var SiwcFileSchema = z24.strictObject({ registeredClientId: z24.string().min(1).optional(), grant: SiwcGrantSchema.optional() });
+var SiwcFileSchema = z25.strictObject({ registeredClientId: z25.string().min(1).optional(), grant: SiwcGrantSchema.optional() });
 function parseSiwcFile(raw, filePath) {
   let json;
   try {
@@ -16665,92 +16774,92 @@ function collectDoctorReport(params) {
 // src/frontdoor/controlSchemas.ts
 init_schema2();
 init_state();
-var UsageListOutputSchema = z27.strictObject({ snapshots: z27.readonly(z27.array(UsageSnapshotSchema)) });
-var UsageWindowsInputSchema = z27.strictObject({
-  identity: z27.string().min(1),
-  provider: z27.string().min(1).optional()
+var UsageListOutputSchema = z28.strictObject({ snapshots: z28.readonly(z28.array(UsageSnapshotSchema)) });
+var UsageWindowsInputSchema = z28.strictObject({
+  identity: z28.string().min(1),
+  provider: z28.string().min(1).optional()
 });
-var EffectiveWindowSchema = z27.strictObject({
+var EffectiveWindowSchema = z28.strictObject({
   /** True when the window's reset time has passed, so the recorded observation describes a window that no longer exists. */
-  reset: z27.boolean(),
+  reset: z28.boolean(),
   /** The fraction used: 0 for a reset window, otherwise what was last observed, absent when none was reported. */
-  utilization: z27.number().optional(),
+  utilization: z28.number().optional(),
   /** The reset instant, for a window that has not reset yet and reported one. */
-  resetsAtMs: z27.number().optional(),
+  resetsAtMs: z28.number().optional(),
   /** The window's own status, for a window that has not reset yet. */
-  status: z27.string().optional()
+  status: z28.string().optional()
 });
-var UsageWindowsOutputSchema = z27.strictObject({
-  identity: z27.string(),
-  provider: z27.string(),
+var UsageWindowsOutputSchema = z28.strictObject({
+  identity: z28.string(),
+  provider: z28.string(),
   /** When the rate-limit state the windows come from was observed. */
-  observedAt: z27.iso.datetime().optional(),
+  observedAt: z28.iso.datetime().optional(),
   fiveHour: EffectiveWindowSchema.optional(),
   sevenDay: EffectiveWindowSchema.optional()
 });
-var UsageLiveOutputSchema = z27.strictObject({
+var UsageLiveOutputSchema = z28.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: z27.readonly(z27.array(RcLiveRateLimitSchema))
+  sessions: z28.readonly(z28.array(RcLiveRateLimitSchema))
 });
-var FrontDoorSessionStatusSchema = z27.strictObject({
-  pid: z27.int().positive(),
-  startedAt: z27.number(),
-  alive: z27.boolean()
+var FrontDoorSessionStatusSchema = z28.strictObject({
+  pid: z28.int().positive(),
+  startedAt: z28.number(),
+  alive: z28.boolean()
 });
-var HeadroomSocketTargetSchema = z27.union([z27.strictObject({ socketPath: z27.string() }), z27.strictObject({ refused: z27.string() })]);
-var FrontDoorStatusOutputSchema = z27.strictObject({
+var HeadroomSocketTargetSchema = z28.union([z28.strictObject({ socketPath: z28.string() }), z28.strictObject({ refused: z28.string() })]);
+var FrontDoorStatusOutputSchema = z28.strictObject({
   state: FrontDoorStateSchema,
-  supervisorAlive: z27.boolean(),
+  supervisorAlive: z28.boolean(),
   /** The pids of earlier doors that released their addresses and are finishing the connections they carried: running, but not serving anything new. */
-  draining: z27.readonly(z27.array(z27.number().int().positive())),
-  sessions: z27.readonly(z27.array(FrontDoorSessionStatusSchema)),
+  draining: z28.readonly(z28.array(z28.number().int().positive())),
+  sessions: z28.readonly(z28.array(FrontDoorSessionStatusSchema)),
   headroomSocket: HeadroomSocketTargetSchema.optional(),
-  logPath: z27.string(),
-  logExists: z27.boolean()
+  logPath: z28.string(),
+  logExists: z28.boolean()
 });
-var FrontDoorSessionsOutputSchema = z27.strictObject({ sessions: z27.readonly(z27.array(FrontDoorSessionStatusSchema)) });
-var CheckRunInputSchema = z27.strictObject({
-  path: z27.string().min(1),
-  identity: z27.string().min(1).optional()
+var FrontDoorSessionsOutputSchema = z28.strictObject({ sessions: z28.readonly(z28.array(FrontDoorSessionStatusSchema)) });
+var CheckRunInputSchema = z28.strictObject({
+  path: z28.string().min(1),
+  identity: z28.string().min(1).optional()
 }).refine((input) => path32.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
-var PoolPickInputSchema = z27.strictObject({
-  pool: z27.string().min(1),
-  path: z27.string().min(1)
+var PoolPickInputSchema = z28.strictObject({
+  pool: z28.string().min(1),
+  path: z28.string().min(1)
 }).refine((input) => path32.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
-var DoctorFindingSchema = z27.strictObject({
-  section: z27.enum(DOCTOR_SECTIONS),
-  subject: z27.string().optional(),
-  severity: z27.enum(DOCTOR_SEVERITIES),
-  message: z27.string()
+var DoctorFindingSchema = z28.strictObject({
+  section: z28.enum(DOCTOR_SECTIONS),
+  subject: z28.string().optional(),
+  severity: z28.enum(DOCTOR_SEVERITIES),
+  message: z28.string()
 });
-var DoctorRunOutputSchema = z27.strictObject({
+var DoctorRunOutputSchema = z28.strictObject({
   /** False exactly when any finding is a `fail`; a `warn` never fails the report on its own. */
-  ok: z27.boolean(),
-  findings: z27.readonly(z27.array(DoctorFindingSchema))
+  ok: z28.boolean(),
+  findings: z28.readonly(z28.array(DoctorFindingSchema))
 });
-var FrontDoorRestartOutputSchema = z27.strictObject({
-  action: z27.literal("restarting"),
-  previousPid: z27.int().positive()
+var FrontDoorRestartOutputSchema = z28.strictObject({
+  action: z28.literal("restarting"),
+  previousPid: z28.int().positive()
 });
-var UpdateCheckOutputSchema = z27.strictObject({
-  current: z27.string(),
-  latest: z27.string(),
-  action: z27.enum(["current", "available", "updated"])
+var UpdateCheckOutputSchema = z28.strictObject({
+  current: z28.string(),
+  latest: z28.string(),
+  action: z28.enum(["current", "available", "updated"])
 });
-var CodexSignInSchema = z27.discriminatedUnion("state", [
-  z27.strictObject({ state: z27.literal("none") }),
-  z27.strictObject({ state: z27.literal("signed-in"), email: z27.string().optional(), planScope: z27.boolean(), accessTokenExpiresAt: z27.number() }),
-  z27.strictObject({ state: z27.literal("unreadable"), message: z27.string() })
+var CodexSignInSchema = z28.discriminatedUnion("state", [
+  z28.strictObject({ state: z28.literal("none") }),
+  z28.strictObject({ state: z28.literal("signed-in"), email: z28.string().optional(), planScope: z28.boolean(), accessTokenExpiresAt: z28.number() }),
+  z28.strictObject({ state: z28.literal("unreadable"), message: z28.string() })
 ]);
-var CodexStatusOutputSchema = z27.strictObject({
+var CodexStatusOutputSchema = z28.strictObject({
   signIn: CodexSignInSchema,
-  codexProviders: z27.readonly(z27.array(z27.string()))
+  codexProviders: z28.readonly(z28.array(z28.string()))
 });
-var CodexLogoutOutputSchema = z27.strictObject({
-  hadGrant: z27.boolean(),
-  revoked: z27.boolean()
+var CodexLogoutOutputSchema = z28.strictObject({
+  hadGrant: z28.boolean(),
+  revoked: z28.boolean()
 });
 
 // src/frontdoor/codexApi.ts
@@ -16909,145 +17018,147 @@ init_providersStore();
 
 // src/frontdoor/configSchemas.ts
 init_schema();
-init_statusline();
-import { z as z28 } from "zod";
-var RemovalConfirmationSchema = z28.boolean();
-var CredentialWriteSchema = (targets) => z28.strictObject({
-  sources: z28.array(RemoteCredentialSourceSchema).min(1).optional(),
-  target: z28.enum(targets).optional(),
-  cache: z28.union([z28.literal(false), CredentialCacheSchema]).optional()
+import { z as z29 } from "zod";
+var RemovalConfirmationSchema = z29.boolean();
+var CredentialWriteSchema = (targets) => z29.strictObject({
+  sources: z29.array(RemoteCredentialSourceSchema).min(1).optional(),
+  target: z29.enum(targets).optional(),
+  cache: z29.union([z29.literal(false), CredentialCacheSchema]).optional()
 });
-var CredentialSummarySchema2 = z28.strictObject({
-  target: z28.enum(CREDENTIAL_TARGETS),
-  sources: z28.readonly(z28.array(
-    z28.discriminatedUnion("kind", [
-      z28.strictObject({ kind: z28.literal("env"), variable: z28.string() }),
-      z28.strictObject({ kind: z28.literal("file"), path: z28.string() }),
-      z28.strictObject({ kind: z28.literal("command"), program: z28.string() }),
-      z28.strictObject({ kind: z28.literal("op"), reference: z28.string() }),
-      z28.strictObject({ kind: z28.literal("keychain"), service: z28.string(), account: z28.string().optional() }),
-      z28.strictObject({ kind: z28.literal("literal") })
+var CredentialSummarySchema2 = z29.strictObject({
+  target: z29.enum(CREDENTIAL_TARGETS),
+  sources: z29.readonly(z29.array(
+    z29.discriminatedUnion("kind", [
+      z29.strictObject({ kind: z29.literal("env"), variable: z29.string() }),
+      z29.strictObject({ kind: z29.literal("file"), path: z29.string() }),
+      z29.strictObject({ kind: z29.literal("command"), program: z29.string() }),
+      z29.strictObject({ kind: z29.literal("op"), reference: z29.string() }),
+      z29.strictObject({ kind: z29.literal("keychain"), service: z29.string(), account: z29.string().optional() }),
+      z29.strictObject({ kind: z29.literal("literal") })
     ])
   )),
   cache: CredentialCacheSchema.optional()
 });
-var mutationOutput = (kind, action) => z28.strictObject({ action: z28.literal(action), kind: z28.literal(kind), name: z28.string() });
-var storedMutationOutput = (kind, action, value) => z28.strictObject({ action: z28.literal(action), kind: z28.literal(kind), name: z28.string(), value });
-var IdentityValueSchema = z28.strictObject({
-  name: z28.string(),
-  defaultConfigProfile: z28.string().optional(),
-  allowAmbientCredential: z28.boolean(),
+var mutationOutput = (kind, action) => z29.strictObject({ action: z29.literal(action), kind: z29.literal(kind), name: z29.string() });
+var storedMutationOutput = (kind, action, value) => z29.strictObject({ action: z29.literal(action), kind: z29.literal(kind), name: z29.string(), value });
+var IdentityValueSchema = z29.strictObject({
+  name: z29.string(),
+  defaultConfigProfile: z29.string().optional(),
+  allowAmbientCredential: z29.boolean(),
   credential: CredentialSummarySchema2.optional(),
-  anchors: z28.array(AnchorSchema).optional()
+  anchors: z29.array(AnchorSchema).optional()
 });
 var ProfileValueSchema = ConfigProfileSchema.omit({ $schema: true });
-var ProviderValueSchema = z28.strictObject({
-  name: z28.string(),
-  kind: z28.enum(PROVIDER_KINDS),
-  displayName: z28.string(),
-  baseUrl: z28.string().optional(),
+var ProviderValueSchema = z29.strictObject({
+  name: z29.string(),
+  kind: z29.enum(PROVIDER_KINDS),
+  displayName: z29.string(),
+  baseUrl: z29.string().optional(),
   codex: CodexProviderConfigSchema.optional(),
   credential: CredentialSummarySchema2.optional(),
-  env: z28.record(z28.string(), z28.string()).optional()
+  env: z29.record(z29.string(), z29.string()).optional()
 });
-var ConfigNameInputSchema = z28.strictObject({ name: z28.string().min(1) });
+var ConfigNameInputSchema = z29.strictObject({ name: z29.string().min(1) });
 var ConfigIdentityAddOutputSchema = storedMutationOutput("identity", "created", IdentityValueSchema);
-var ConfigIdentitySetInputSchema = z28.strictObject({
-  name: z28.string().min(1),
-  defaultConfigProfile: z28.union([z28.string().min(1), z28.literal(false)]).optional(),
-  allowAmbientCredential: z28.boolean().optional(),
-  credential: z28.union([z28.literal(false), CredentialWriteSchema(CREDENTIAL_TARGETS)]).optional(),
+var ConfigIdentitySetInputSchema = z29.strictObject({
+  name: z29.string().min(1),
+  defaultConfigProfile: z29.union([z29.string().min(1), z29.literal(false)]).optional(),
+  allowAmbientCredential: z29.boolean().optional(),
+  credential: z29.union([z29.literal(false), CredentialWriteSchema(CREDENTIAL_TARGETS)]).optional(),
   /** `false` removes the anchors; a list replaces them. */
-  anchors: z28.union([z28.literal(false), z28.array(AnchorSchema).min(1)]).optional()
+  anchors: z29.union([z29.literal(false), z29.array(AnchorSchema).min(1)]).optional()
 });
 var ConfigIdentitySetOutputSchema = storedMutationOutput("identity", "updated", IdentityValueSchema);
-var ConfigIdentityRemoveInputSchema = z28.strictObject({ name: z28.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigIdentityRemoveInputSchema = z29.strictObject({ name: z29.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigIdentityRemoveOutputSchema = mutationOutput("identity", "removed");
 var ConfigIdentityUseOutputSchema = mutationOutput("identity", "selected");
-var ConfigProfileAddInputSchema = z28.strictObject({
-  name: z28.string().min(1),
-  extends: z28.array(z28.string().min(1)).optional(),
-  description: z28.string().optional()
+var ConfigProfileAddInputSchema = z29.strictObject({
+  name: z29.string().min(1),
+  extends: z29.array(z29.string().min(1)).optional(),
+  description: z29.string().optional()
 });
 var ConfigProfileAddOutputSchema = storedMutationOutput("profile", "created", ProfileValueSchema);
-var ConfigProfileSetInputSchema = z28.strictObject({
-  name: z28.string().min(1),
-  category: z28.record(z28.string(), z28.boolean()).optional(),
-  entry: z28.record(z28.string(), z28.boolean()).optional(),
-  extends: z28.union([z28.array(z28.string().min(1)), z28.literal(false)]).optional(),
-  description: z28.union([z28.string(), z28.literal(false)]).optional(),
-  launch: z28.strictObject({
-    skipPermissions: z28.boolean().optional(),
-    remoteControl: z28.boolean().optional(),
-    headroom: z28.boolean().optional(),
-    trackUsage: z28.boolean().optional(),
-    provider: z28.union([z28.string().min(1), z28.literal(false)]).optional(),
-    claudeVersion: z28.union([z28.string().min(1), z28.literal(false)]).optional(),
-    delay: z28.union([z28.string().regex(DURATION_RE), z28.literal(false)]).optional(),
-    pause: z28.boolean().optional(),
-    explain: z28.boolean().optional(),
-    proxyBypass: z28.union([z28.array(z28.string().min(1)), z28.literal(false)]).optional(),
-    statusline: StatuslineChangeSchema.optional()
+var ConfigProfileSetInputSchema = z29.strictObject({
+  name: z29.string().min(1),
+  category: z29.record(z29.string(), z29.boolean()).optional(),
+  entry: z29.record(z29.string(), z29.boolean()).optional(),
+  extends: z29.union([z29.array(z29.string().min(1)), z29.literal(false)]).optional(),
+  description: z29.union([z29.string(), z29.literal(false)]).optional(),
+  launch: z29.strictObject({
+    skipPermissions: z29.boolean().optional(),
+    remoteControl: z29.boolean().optional(),
+    headroom: z29.boolean().optional(),
+    trackUsage: z29.boolean().optional(),
+    provider: z29.union([z29.string().min(1), z29.literal(false)]).optional(),
+    claudeVersion: z29.union([z29.string().min(1), z29.literal(false)]).optional(),
+    delay: z29.union([z29.string().regex(DURATION_RE), z29.literal(false)]).optional(),
+    pause: z29.boolean().optional(),
+    explain: z29.boolean().optional(),
+    proxyBypass: z29.union([z29.array(z29.string().min(1)), z29.literal(false)]).optional(),
+    statusline: z29.strictObject({
+      set: z29.record(z29.string(), z29.unknown()).optional(),
+      unset: z29.array(z29.string()).optional()
+    }).optional()
   }).optional()
 });
 var ConfigProfileSetOutputSchema = storedMutationOutput("profile", "updated", ProfileValueSchema);
-var ConfigProfileRemoveInputSchema = z28.strictObject({ name: z28.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProfileRemoveInputSchema = z29.strictObject({ name: z29.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigProfileRemoveOutputSchema = mutationOutput("profile", "removed");
 var ConfigProfileUseOutputSchema = mutationOutput("profile", "selected");
-var PoolMembersInputSchema = z28.array(z28.string().min(1)).min(1);
-var ConfigPoolAddInputSchema = z28.strictObject({
-  name: z28.string().min(1),
+var PoolMembersInputSchema = z29.array(z29.string().min(1)).min(1);
+var ConfigPoolAddInputSchema = z29.strictObject({
+  name: z29.string().min(1),
   identities: PoolMembersInputSchema,
-  preference: z28.enum(POOL_PREFERENCES).optional(),
-  resumeOnLimit: z28.boolean().optional(),
-  compactBeforeLimit: z28.boolean().optional(),
+  preference: z29.enum(POOL_PREFERENCES).optional(),
+  resumeOnLimit: z29.boolean().optional(),
+  compactBeforeLimit: z29.boolean().optional(),
   compactAtUtilisation: CompactAtUtilisationSchema.optional()
 });
 var ConfigPoolAddOutputSchema = storedMutationOutput("pool", "created", PoolSchema);
-var ConfigPoolSetInputSchema = z28.strictObject({
-  name: z28.string().min(1),
+var ConfigPoolSetInputSchema = z29.strictObject({
+  name: z29.string().min(1),
   identities: PoolMembersInputSchema.optional(),
-  preference: z28.union([z28.enum(POOL_PREFERENCES), z28.literal(false)]).optional(),
-  resumeOnLimit: z28.boolean().optional(),
-  compactBeforeLimit: z28.boolean().optional(),
-  compactAtUtilisation: z28.union([CompactAtUtilisationSchema, z28.literal(false)]).optional()
+  preference: z29.union([z29.enum(POOL_PREFERENCES), z29.literal(false)]).optional(),
+  resumeOnLimit: z29.boolean().optional(),
+  compactBeforeLimit: z29.boolean().optional(),
+  compactAtUtilisation: z29.union([CompactAtUtilisationSchema, z29.literal(false)]).optional()
 });
 var ConfigPoolSetOutputSchema = storedMutationOutput("pool", "updated", PoolSchema);
-var ConfigPoolRemoveInputSchema = z28.strictObject({ name: z28.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigPoolRemoveInputSchema = z29.strictObject({ name: z29.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigPoolRemoveOutputSchema = mutationOutput("pool", "removed");
 var ConfigPoolUseOutputSchema = mutationOutput("pool", "selected");
-var ConfigProviderAddInputSchema = z28.strictObject({
-  name: z28.string().min(1),
-  kind: z28.enum(PROVIDER_KINDS).optional(),
-  displayName: z28.string().min(1),
-  baseUrl: z28.string().min(1).optional(),
+var ConfigProviderAddInputSchema = z29.strictObject({
+  name: z29.string().min(1),
+  kind: z29.enum(PROVIDER_KINDS).optional(),
+  displayName: z29.string().min(1),
+  baseUrl: z29.string().min(1).optional(),
   credential: CredentialWriteSchema(PROVIDER_CREDENTIAL_TARGETS).required({ sources: true }),
   codex: CodexProviderConfigSchema.optional()
 });
 var ConfigProviderAddOutputSchema = storedMutationOutput("provider", "created", ProviderValueSchema);
-var ConfigProviderSetInputSchema = z28.strictObject({
-  name: z28.string().min(1),
-  displayName: z28.string().min(1).optional(),
-  baseUrl: z28.string().min(1).optional(),
+var ConfigProviderSetInputSchema = z29.strictObject({
+  name: z29.string().min(1),
+  displayName: z29.string().min(1).optional(),
+  baseUrl: z29.string().min(1).optional(),
   credential: CredentialWriteSchema(PROVIDER_CREDENTIAL_TARGETS).optional(),
   codex: CodexProviderConfigSchema.optional()
 });
 var ConfigProviderSetOutputSchema = storedMutationOutput("provider", "updated", ProviderValueSchema);
-var ConfigProviderRemoveInputSchema = z28.strictObject({ name: z28.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProviderRemoveInputSchema = z29.strictObject({ name: z29.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigProviderRemoveOutputSchema = mutationOutput("provider", "removed");
-var ConfigRuleAddInputSchema = z28.strictObject({
-  path: z28.string().min(1),
-  configProfile: z28.string().min(1).optional(),
-  identity: z28.string().min(1).optional()
+var ConfigRuleAddInputSchema = z29.strictObject({
+  path: z29.string().min(1),
+  configProfile: z29.string().min(1).optional(),
+  identity: z29.string().min(1).optional()
 });
 var ConfigRuleAddOutputSchema = storedMutationOutput("rule", "created", DirectoryRuleSchema);
-var ConfigRuleSetInputSchema = z28.strictObject({
-  path: z28.string().min(1),
-  configProfile: z28.union([z28.string().min(1), z28.literal(false)]).optional(),
-  identity: z28.union([z28.string().min(1), z28.literal(false)]).optional()
+var ConfigRuleSetInputSchema = z29.strictObject({
+  path: z29.string().min(1),
+  configProfile: z29.union([z29.string().min(1), z29.literal(false)]).optional(),
+  identity: z29.union([z29.string().min(1), z29.literal(false)]).optional()
 });
 var ConfigRuleSetOutputSchema = storedMutationOutput("rule", "updated", DirectoryRuleSchema);
-var ConfigRuleRemoveInputSchema = z28.strictObject({ path: z28.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigRuleRemoveInputSchema = z29.strictObject({ path: z29.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigRuleRemoveOutputSchema = mutationOutput("rule", "removed");
 
 // src/frontdoor/configApi.ts
@@ -17360,43 +17471,43 @@ import { openapi as openapi4 } from "@orpc/openapi";
 import { eventIterator as eventIterator2, withEventMeta as withEventMeta2 } from "@orpc/server";
 
 // src/frontdoor/eventSchemas.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "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 = z29.strictObject({
-  source: z29.string().min(1),
+var DoorEventSchema = z30.strictObject({
+  source: z30.string().min(1),
   /** A positive integer because the backbone's counters start at one and only ever increase. */
-  sequence: z29.number().int().positive(),
-  payload: z29.unknown()
+  sequence: z30.number().int().positive(),
+  payload: z30.unknown()
 });
-var DoorEventSourceQuerySchema = z29.strictObject({
-  sources: z29.array(z29.string().min(1)).min(1).optional()
+var DoorEventSourceQuerySchema = z30.strictObject({
+  sources: z30.array(z30.string().min(1)).min(1).optional()
 });
-var LaunchLifecycleEventSchema = z29.strictObject({
-  kind: z29.enum(["registered", "pruned", "ended"]),
-  pid: z29.number().int().positive(),
-  startedAt: z29.number(),
-  observedAt: z29.number()
+var LaunchLifecycleEventSchema = z30.strictObject({
+  kind: z30.enum(["registered", "pruned", "ended"]),
+  pid: z30.number().int().positive(),
+  startedAt: z30.number(),
+  observedAt: z30.number()
 });
-var DoorHealthEventSchema = z29.discriminatedUnion("kind", [
-  z29.strictObject({ kind: z29.literal("generation"), pid: z29.number().int().positive(), providerPort: z29.number().int().positive(), connectPort: z29.number().int().positive(), directPort: z29.number().int().positive(), observedAt: z29.number() }),
-  z29.strictObject({ kind: z29.literal("listenerFailed"), pid: z29.number().int().positive(), listener: z29.enum(["provider", "connect", "direct"]), message: z29.string(), observedAt: z29.number() }),
-  z29.strictObject({ kind: z29.literal("binaryTurnover"), pid: z29.number().int().positive(), observedAt: z29.number() }),
-  z29.strictObject({ kind: z29.literal("idleShutdown"), pid: z29.number().int().positive(), observedAt: z29.number() }),
-  z29.strictObject({ kind: z29.literal("superseded"), pid: z29.number().int().positive(), ownerPid: z29.number().int().positive(), observedAt: z29.number() }),
-  z29.strictObject({ kind: z29.literal("drained"), pid: z29.number().int().positive(), observedAt: z29.number() })
+var DoorHealthEventSchema = z30.discriminatedUnion("kind", [
+  z30.strictObject({ kind: z30.literal("generation"), pid: z30.number().int().positive(), providerPort: z30.number().int().positive(), connectPort: z30.number().int().positive(), directPort: z30.number().int().positive(), observedAt: z30.number() }),
+  z30.strictObject({ kind: z30.literal("listenerFailed"), pid: z30.number().int().positive(), listener: z30.enum(["provider", "connect", "direct"]), message: z30.string(), observedAt: z30.number() }),
+  z30.strictObject({ kind: z30.literal("binaryTurnover"), pid: z30.number().int().positive(), observedAt: z30.number() }),
+  z30.strictObject({ kind: z30.literal("idleShutdown"), pid: z30.number().int().positive(), observedAt: z30.number() }),
+  z30.strictObject({ kind: z30.literal("superseded"), pid: z30.number().int().positive(), ownerPid: z30.number().int().positive(), observedAt: z30.number() }),
+  z30.strictObject({ kind: z30.literal("drained"), pid: z30.number().int().positive(), observedAt: z30.number() })
 ]);
-var QuotaExpiringEventSchema = z29.strictObject({
-  identity: z29.string().min(1),
-  provider: z29.string().min(1),
-  window: z29.enum(["fiveHour", "sevenDay"]),
+var QuotaExpiringEventSchema = z30.strictObject({
+  identity: z30.string().min(1),
+  provider: z30.string().min(1),
+  window: z30.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: z29.number().min(0).max(1),
-  resetsAt: z29.iso.datetime(),
-  observedAt: z29.number()
+  utilization: z30.number().min(0).max(1),
+  resetsAt: z30.iso.datetime(),
+  observedAt: z30.number()
 });
 
 // src/frontdoor/eventsApi.ts
@@ -17480,60 +17591,60 @@ import { openapi as openapi6 } from "@orpc/openapi";
 
 // src/frontdoor/launchSchemas.ts
 import path33 from "node:path";
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 init_statusline();
 init_claudeVersion();
 init_identity();
-var LaunchResolveInputSchema = z30.strictObject({
-  path: z30.string().min(1),
+var LaunchResolveInputSchema = z31.strictObject({
+  path: z31.string().min(1),
   /** `@name`, launch flags, then the arguments for `claude`; empty for a bare launch. */
-  argv: z30.readonly(z30.array(z30.string())).optional(),
+  argv: z31.readonly(z31.array(z31.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: z30.record(z30.string(), z30.string()).optional()
+  env: z31.record(z31.string(), z31.string()).optional()
 }).refine((input) => path33.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
-var LaunchPoolDecisionSchema = z30.strictObject({
-  name: z30.string(),
-  reasons: z30.readonly(z30.array(z30.string())),
-  movedOff: z30.strictObject({ identity: z30.string(), reason: z30.string() }).optional()
+var LaunchPoolDecisionSchema = z31.strictObject({
+  name: z31.string(),
+  reasons: z31.readonly(z31.array(z31.string())),
+  movedOff: z31.strictObject({ identity: z31.string(), reason: z31.string() }).optional()
 });
-var LaunchDecisionSchema = z30.strictObject({
-  identity: z30.string().optional(),
-  identitySource: z30.enum(IDENTITY_DECISION_SOURCES),
+var LaunchDecisionSchema = z31.strictObject({
+  identity: z31.string().optional(),
+  identitySource: z31.enum(IDENTITY_DECISION_SOURCES),
   pool: LaunchPoolDecisionSchema.optional(),
-  configDirEscapeHatch: z30.boolean(),
-  configDir: z30.string().optional(),
-  configProfile: z30.string().optional(),
-  configProfileSource: z30.enum(CONFIG_PROFILE_DECISION_SOURCES),
-  provider: z30.string().optional()
+  configDirEscapeHatch: z31.boolean(),
+  configDir: z31.string().optional(),
+  configProfile: z31.string().optional(),
+  configProfileSource: z31.enum(CONFIG_PROFILE_DECISION_SOURCES),
+  provider: z31.string().optional()
 });
-var LaunchFlagsSchema = z30.strictObject({
-  skipPermissions: z30.boolean(),
-  remoteControl: z30.boolean(),
-  headroom: z30.boolean(),
-  trackUsage: z30.boolean(),
-  pause: z30.boolean(),
-  explain: z30.boolean(),
+var LaunchFlagsSchema = z31.strictObject({
+  skipPermissions: z31.boolean(),
+  remoteControl: z31.boolean(),
+  headroom: z31.boolean(),
+  trackUsage: z31.boolean(),
+  pause: z31.boolean(),
+  explain: z31.boolean(),
   /** How long the launch waits after its own output before it starts claude, in milliseconds. */
-  delayMs: z30.number(),
+  delayMs: z31.number(),
   /** The hosts the launch keeps off the front door by adding them to the child's `NO_PROXY`. */
-  proxyBypass: z30.array(z30.string()).readonly(),
+  proxyBypass: z31.array(z31.string()).readonly(),
   /** How the session's built-in statusline looks, when the launch configures any of it. */
   statusline: StatuslineSchema.optional()
 });
-var LaunchResolveOutputSchema = z30.strictObject({
+var LaunchResolveOutputSchema = z31.strictObject({
   decision: LaunchDecisionSchema,
   flags: LaunchFlagsSchema,
-  claudeVersion: z30.strictObject({ version: z30.string(), source: z30.enum(CLAUDE_VERSION_SOURCES) }).optional(),
+  claudeVersion: z31.strictObject({ version: z31.string(), source: z31.enum(CLAUDE_VERSION_SOURCES) }).optional(),
   /** The real `claude` binary the launch would spawn, on the door's host. */
-  bin: z30.string(),
+  bin: z31.string(),
   /** The arguments the launch would pass it: the tool's own flags, then `CLAUDE_EXTRA_FLAGS`, then the caller's own. */
-  args: z30.readonly(z30.array(z30.string())),
+  args: z31.readonly(z31.array(z31.string())),
   /** The credential the launch would authenticate with, by target and source kinds. Absent when none applies. */
-  credential: z30.strictObject({ subject: z30.enum(["provider", "identity"]), name: z30.string(), summary: CredentialSummarySchema }).optional(),
-  routing: z30.strictObject({ frontDoor: z30.boolean(), headroom: z30.boolean() }),
+  credential: z31.strictObject({ subject: z31.enum(["provider", "identity"]), name: z31.string(), summary: CredentialSummarySchema }).optional(),
+  routing: z31.strictObject({ frontDoor: z31.boolean(), headroom: z31.boolean() }),
   /** The names of the environment variables the launch would set or unset, sorted. Values are not reported. */
-  environment: z30.readonly(z30.array(z30.string())),
-  warnings: z30.readonly(z30.array(z30.string()))
+  environment: z31.readonly(z31.array(z31.string())),
+  warnings: z31.readonly(z31.array(z31.string()))
 });
 
 // src/frontdoor/launchApi.ts
@@ -17569,22 +17680,22 @@ function createLaunchApiRouter(deps) {
 // src/frontdoor/agentTreesApi.ts
 import { ORPCError as ORPCError6 } from "@orpc/client";
 import { openapi as openapi7 } from "@orpc/openapi";
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 init_cliError();
-var AgentTreesListInputSchema = z31.strictObject({
+var AgentTreesListInputSchema = z32.strictObject({
   /** Only this identity's sessions. */
-  identity: z31.string().optional(),
+  identity: z32.string().optional(),
   /** Include sessions that spawned no agent and ran no workflow. */
-  all: z31.boolean().optional()
+  all: z32.boolean().optional()
 });
-var AgentTreesListOutputSchema = z31.array(SessionSummarySchema);
-var AgentTreesShowInputSchema = z31.strictObject({
+var AgentTreesListOutputSchema = z32.array(SessionSummarySchema);
+var AgentTreesShowInputSchema = z32.strictObject({
   /** A session id, or an unambiguous prefix of one. */
-  session: z31.string().min(1),
+  session: z32.string().min(1),
   /** Look only in this identity. */
-  identity: z31.string().optional()
+  identity: z32.string().optional()
 });
-var AgentTreesShowOutputSchema = z31.strictObject({ identities: z31.array(z31.string()), ...MergedAgentTreeSchema.shape });
+var AgentTreesShowOutputSchema = z32.strictObject({ identities: z32.array(z32.string()), ...MergedAgentTreeSchema.shape });
 function asBadRequest(error) {
   if (error instanceof CliError) {
     throw new ORPCError6("BAD_REQUEST", { message: error.message });
@@ -19777,7 +19888,7 @@ init_poolPick();
 
 // src/agents/read.ts
 import path35 from "node:path";
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var PROJECTS_DIR = "projects";
 var TASKS_DIR = "tasks";
 var SUBAGENTS_DIR = "subagents";
@@ -19896,14 +20007,14 @@ function parseJson2(text) {
     return void 0;
   }
 }
-var TaskFileSchema = z32.object({ ...TaskItemSchema.omit({ taskList: true }).shape, blocks: z32.array(z32.string()).default([]), blockedBy: z32.array(z32.string()).default([]) });
-var WorkflowRunFileSchema = z32.object({
-  runId: z32.string(),
-  workflowName: z32.string().optional(),
-  status: z32.string().optional(),
-  startTime: z32.number().optional(),
-  phases: z32.array(z32.object({ title: z32.string() })).default([]),
-  summary: z32.string().optional()
+var TaskFileSchema = z33.object({ ...TaskItemSchema.omit({ taskList: true }).shape, blocks: z33.array(z33.string()).default([]), blockedBy: z33.array(z33.string()).default([]) });
+var WorkflowRunFileSchema = z33.object({
+  runId: z33.string(),
+  workflowName: z33.string().optional(),
+  status: z33.string().optional(),
+  startTime: z33.number().optional(),
+  phases: z33.array(z33.object({ title: z33.string() })).default([]),
+  summary: z33.string().optional()
 });
 function summariseSession(fs14, configDir, ref) {
   const sessionRelative = path35.join(PROJECTS_DIR, ref.project, ref.entry);