claude-use 11.49.2 → 11.50.1

package/dist/index.mjs

@@ -116,6 +116,68 @@ var init_proxyBypass = __esm({
   }
 });
 
+// src/config/statusline.ts
+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 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)})`);
+  }
+  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 init_statusline = __esm({
+  "src/config/statusline.ts"() {
+    "use strict";
+    STATUSLINE_HEADER_SEGMENTS = ["model", "provider", "route", "account", "identity", "headroom"];
+    STATUSLINE_BAR_GROUPS = ["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;
+    wholePercent = z.number().int().min(1).max(MAX_PERCENT);
+    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()
+    });
+    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()
+    });
+    STATUSLINE_DEFAULTS = {
+      header: STATUSLINE_HEADER_SEGMENTS,
+      bars: STATUSLINE_BAR_GROUPS,
+      warnAt: 70,
+      criticalAt: 90,
+      fiveHourLabel: "5h",
+      sevenDayLabel: "Wk",
+      barWidth: 10
+    };
+    STATUSLINE_ENV = "AGENT_SHIM_STATUSLINE";
+  }
+});
+
 // src/cliError.ts
 var EXIT_FAILURE, EXIT_USAGE, CliError, UsageError;
 var init_cliError = __esm({
@@ -232,7 +294,7 @@ var init_versionDiscovery = __esm({
 
 // src/config/schema.ts
 import path2 from "node:path";
-import { z } from "zod";
+import { z as z2 } from "zod";
 import { PredicateNodeSchema } from "trilean";
 function isOverridableCategory(name) {
   return OVERRIDABLE_CATEGORIES.some((category) => category === name);
@@ -276,55 +338,58 @@ var init_schema = __esm({
   "src/config/schema.ts"() {
     "use strict";
     init_proxyBypass();
+    init_statusline();
     init_versionDiscovery();
     CATEGORY_NAMES = ["secret", "runtime", "history", "knowledge", "settings"];
     OVERRIDABLE_CATEGORIES = ["runtime", "history", "knowledge", "settings"];
-    CategoryMapSchema = z.strictObject({
-      all: z.boolean().optional(),
-      runtime: z.boolean().optional(),
-      history: z.boolean().optional(),
-      knowledge: z.boolean().optional(),
-      settings: z.boolean().optional()
+    CategoryMapSchema = z2.strictObject({
+      all: z2.boolean().optional(),
+      runtime: z2.boolean().optional(),
+      history: z2.boolean().optional(),
+      knowledge: z2.boolean().optional(),
+      settings: z2.boolean().optional()
     }).transform((input) => expandAllCategoryKey(input));
     DURATION_RE = /^(?:0|[1-9][0-9]*)(?:ms|s|m|h|d|w)$/;
-    DurationSchema = z.string().regex(DURATION_RE);
-    WhenConditionObjectSchema = z.strictObject({
+    DurationSchema = z2.string().regex(DURATION_RE);
+    WhenConditionObjectSchema = z2.strictObject({
       newerThan: DurationSchema.optional(),
       olderThan: DurationSchema.optional(),
-      maxSizeBytes: z.int().positive().optional(),
-      branch: z.string().min(1).optional(),
-      env: z.record(z.string().min(1), z.string()).optional()
+      maxSizeBytes: z2.int().positive().optional(),
+      branch: z2.string().min(1).optional(),
+      env: z2.record(z2.string().min(1), z2.string()).optional()
     });
-    WhenSchema = z.union([WhenConditionObjectSchema, PredicateNodeSchema]);
-    EntryValueSchema = z.union([
-      z.boolean(),
-      z.strictObject({ value: z.boolean(), when: WhenSchema })
+    WhenSchema = z2.union([WhenConditionObjectSchema, PredicateNodeSchema]);
+    EntryValueSchema = z2.union([
+      z2.boolean(),
+      z2.strictObject({ value: z2.boolean(), when: WhenSchema })
     ]);
     ENTRY_KEY_RE = /^(?:secret|runtime|history|knowledge|settings)\/(?!\/)\S(?:.*\S)?$/;
-    EntriesSchema = z.record(z.string().regex(ENTRY_KEY_RE), EntryValueSchema);
-    LaunchSchema = z.strictObject({
-      skipPermissions: z.boolean().optional(),
-      remoteControl: z.boolean().optional(),
-      provider: z.string().min(1).optional(),
-      headroom: z.boolean().optional(),
-      trackUsage: z.boolean().optional(),
+    EntriesSchema = z2.record(z2.string().regex(ENTRY_KEY_RE), EntryValueSchema);
+    LaunchSchema = z2.strictObject({
+      skipPermissions: z2.boolean().optional(),
+      remoteControl: z2.boolean().optional(),
+      provider: z2.string().min(1).optional(),
+      headroom: z2.boolean().optional(),
+      trackUsage: z2.boolean().optional(),
       /** The exact Claude Code version to run, as it is named in Claude Code's versions directory (`2.1.220`). A pin that is not installed fails the launch; it never falls back to the highest version. */
-      claudeVersion: z.string().regex(NUMERIC_DOTTED_VERSION_RE, "must be an exact dotted-numeric Claude Code version such as 2.1.220").optional(),
+      claudeVersion: z2.string().regex(NUMERIC_DOTTED_VERSION_RE, "must be an exact dotted-numeric Claude Code version such as 2.1.220").optional(),
       /** How long the launcher waits after its own output before it starts claude, so that output can be read before Claude Code takes over the terminal (`5s`, `500ms`). Applies only when a terminal is watching. */
-      delay: z.string().regex(DURATION_RE, "must be a duration such as 5s or 500ms").optional(),
+      delay: z2.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: z.boolean().optional(),
+      pause: z2.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: z.boolean().optional(),
+      explain: z2.boolean().optional(),
       /** Hosts a launch keeps off the front door by adding them to the child's `NO_PROXY`, so their traffic (an HTTP MCP server, say) goes direct and survives a door restart. Each entry is a host name (a leading `.` or `*.` covers its subdomains), an IPv4 address or a bracketed IPv6 address, with an optional `:port`; a malformed entry fails the load. A deeper layer's list replaces a shallower one's, and an empty list clears it. */
-      proxyBypass: z.array(
-        z.string().superRefine((entry, context) => {
+      proxyBypass: z2.array(
+        z2.string().superRefine((entry, context) => {
           const problem = proxyBypassSyntaxProblem(entry);
           if (problem !== void 0) {
             context.addIssue({ code: "custom", message: `"${entry}" ${problem}` });
           }
         })
-      ).optional()
+      ).optional(),
+      /** How the launched session's built-in statusline looks, exported to it as `AGENT_SHIM_STATUSLINE`. Merged key by key across layers, unlike the flags above, which are single values. */
+      statusline: StatuslineSchema.optional()
     });
     CREDENTIAL_TARGETS = ["bearer", "apiKey", "oauthToken"];
     PROVIDER_CREDENTIAL_TARGETS = ["bearer", "apiKey"];
@@ -333,27 +398,27 @@ var init_schema = __esm({
       apiKey: "ANTHROPIC_API_KEY",
       oauthToken: "CLAUDE_CODE_OAUTH_TOKEN"
     };
-    ArgvSchema = z.tuple([z.string().min(1)], z.string());
+    ArgvSchema = z2.tuple([z2.string().min(1)], z2.string());
     CommandSourceOptions = {
       /** True when running the command needs a person present (a desktop-unlocked secret store's approval prompt), so it is skipped when there is neither a terminal nor a desktop session. Defaults per source kind; see `isInteractiveSource`. */
-      interactive: z.boolean().optional(),
+      interactive: z2.boolean().optional(),
       /** How long the command may run before it is killed and counted as failed. Defaults to `CREDENTIAL_COMMAND_TIMEOUT_MS`, or `CREDENTIAL_INTERACTIVE_TIMEOUT_MS` for an interactive source. */
-      timeoutMs: z.int().positive().optional()
+      timeoutMs: z2.int().positive().optional()
     };
-    EnvCredentialSourceSchema = z.strictObject({ env: z.string().min(1) });
-    FileCredentialSourceSchema = z.strictObject({
-      file: z.string().min(1).refine((filePath) => filePath.startsWith("~/") || path2.isAbsolute(filePath), {
+    EnvCredentialSourceSchema = z2.strictObject({ env: z2.string().min(1) });
+    FileCredentialSourceSchema = z2.strictObject({
+      file: z2.string().min(1).refine((filePath) => filePath.startsWith("~/") || path2.isAbsolute(filePath), {
         message: "a credential file must be an absolute or ~-rooted path, since a launch can start in any directory"
       })
     });
-    CommandCredentialSourceSchema = z.strictObject({ command: ArgvSchema, ...CommandSourceOptions });
-    OpCredentialSourceSchema = z.strictObject({ op: z.string().startsWith("op://"), ...CommandSourceOptions });
-    KeychainCredentialSourceSchema = z.strictObject({
-      keychain: z.strictObject({ service: z.string().min(1), account: z.string().min(1).optional() }),
+    CommandCredentialSourceSchema = z2.strictObject({ command: ArgvSchema, ...CommandSourceOptions });
+    OpCredentialSourceSchema = z2.strictObject({ op: z2.string().startsWith("op://"), ...CommandSourceOptions });
+    KeychainCredentialSourceSchema = z2.strictObject({
+      keychain: z2.strictObject({ service: z2.string().min(1), account: z2.string().min(1).optional() }),
       ...CommandSourceOptions
     });
-    LiteralCredentialSourceSchema = z.strictObject({ literal: z.string().min(1) });
-    CredentialSourceSchema = z.union([
+    LiteralCredentialSourceSchema = z2.strictObject({ literal: z2.string().min(1) });
+    CredentialSourceSchema = z2.union([
       EnvCredentialSourceSchema,
       FileCredentialSourceSchema,
       CommandCredentialSourceSchema,
@@ -361,7 +426,7 @@ var init_schema = __esm({
       KeychainCredentialSourceSchema,
       LiteralCredentialSourceSchema
     ]);
-    RemoteCredentialSourceSchema = z.union([
+    RemoteCredentialSourceSchema = z2.union([
       EnvCredentialSourceSchema,
       FileCredentialSourceSchema,
       OpCredentialSourceSchema,
@@ -369,18 +434,18 @@ var init_schema = __esm({
       LiteralCredentialSourceSchema
     ]);
     CREDENTIAL_CACHE_STORES = ["keychain", "file"];
-    CredentialCacheSchema = z.strictObject({
-      ttl: z.string().regex(/^[1-9]\d*[smhd]$/, { message: "ttl is a whole number followed by s, m, h or d, for example 12h" }).optional(),
-      store: z.enum(CREDENTIAL_CACHE_STORES).optional()
+    CredentialCacheSchema = z2.strictObject({
+      ttl: z2.string().regex(/^[1-9]\d*[smhd]$/, { message: "ttl is a whole number followed by s, m, h or d, for example 12h" }).optional(),
+      store: z2.enum(CREDENTIAL_CACHE_STORES).optional()
     });
-    CredentialSchema = z.strictObject({
-      sources: z.array(CredentialSourceSchema).min(1),
-      target: z.enum(CREDENTIAL_TARGETS).optional(),
+    CredentialSchema = z2.strictObject({
+      sources: z2.array(CredentialSourceSchema).min(1),
+      target: z2.enum(CREDENTIAL_TARGETS).optional(),
       cache: CredentialCacheSchema.optional()
     });
-    ProviderCredentialSchema = CredentialSchema.extend({ target: z.enum(PROVIDER_CREDENTIAL_TARGETS).optional() });
+    ProviderCredentialSchema = CredentialSchema.extend({ target: z2.enum(PROVIDER_CREDENTIAL_TARGETS).optional() });
     RESERVED_PROVIDER_ENV_KEYS = Object.values(CREDENTIAL_TARGET_VARS);
-    ProviderEnvSchema = z.record(z.string().min(1), z.string()).refine((env) => !Object.keys(env).some((key) => RESERVED_PROVIDER_ENV_KEYS.includes(key)), {
+    ProviderEnvSchema = z2.record(z2.string().min(1), z2.string()).refine((env) => !Object.keys(env).some((key) => RESERVED_PROVIDER_ENV_KEYS.includes(key)), {
       message: `env may not set ${RESERVED_PROVIDER_ENV_KEYS.join(", ")}: the credential block's target sets one and agent-shim removes the others`
     });
     PROVIDER_KINDS = ["http", "codex", "antigravity", "router"];
@@ -396,33 +461,33 @@ var init_schema = __esm({
       haiku: ["gemini-3.8-flash-low", "gemini-4-argon-low", "claude-sonnet-5-5-low"]
     });
     ANTIGRAVITY_DEFAULT_EFFORT = "low";
-    AntigravityModelTargetSchema = z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]);
-    AntigravityProviderConfigSchema = z.strictObject({
+    AntigravityModelTargetSchema = z2.union([z2.string().min(1), z2.array(z2.string().min(1)).min(1)]);
+    AntigravityProviderConfigSchema = z2.strictObject({
       /** Operational mode: direct cloud endpoint or local ACP daemon. Defaults to `cloud`. */
-      mode: z.enum(ANTIGRAVITY_MODES).optional(),
+      mode: z2.enum(ANTIGRAVITY_MODES).optional(),
       /** The model a request maps to when no tier matches its model name. */
-      defaultModel: z.string().min(1).optional(),
+      defaultModel: z2.string().min(1).optional(),
       /** Model name mapping. A key naming a tier (`fable`, `opus`, `sonnet`, `haiku`) overrides that tier's shipped model and is matched by substring of the requested name in `CLAUDE_TIERS` order; any other key is an alias, matched against the whole requested name case-insensitively, so `/model <alias>` selects its backend model. An alias outranks every other rule, including the pass-through of backend names. A value is one model or an ordered list of candidates: the request goes to the first whose quota windows are not spent, and when every candidate is spent, to the one whose binding window lifts soonest. */
-      models: z.record(z.string().min(1), AntigravityModelTargetSchema).optional(),
+      models: z2.record(z2.string().min(1), AntigravityModelTargetSchema).optional(),
       /** When every candidate of the tier a request names has no quota left, serve it from the next tier down, and onward through the lower tiers, instead of failing with the quota limit. Applies to a name that selects a tier (`/model fable`), not to an alias or a backend model name. Defaults to false. */
-      degradeDownTiers: z.boolean().optional(),
+      degradeDownTiers: z2.boolean().optional(),
       /** The reasoning effort used when the request's own effort is not one the backend accepts. */
-      effort: z.enum(ANTIGRAVITY_EFFORTS).optional(),
+      effort: z2.enum(ANTIGRAVITY_EFFORTS).optional(),
       /** Cloud-specific settings (for `mode: "cloud"`). */
-      cloud: z.strictObject({
+      cloud: z2.strictObject({
         /** Google Gemini API or custom gateway endpoint. Defaults to `https://generativelanguage.googleapis.com`. */
-        endpoint: z.url().optional(),
+        endpoint: z2.url().optional(),
         /** Google Cloud Project ID (when using Vertex AI). */
-        projectId: z.string().min(1).optional(),
+        projectId: z2.string().min(1).optional(),
         /** Google Cloud location/region (when using Vertex AI). */
-        location: z.string().min(1).optional()
+        location: z2.string().min(1).optional()
       }).optional(),
       /** Local-specific settings (for `mode: "local"`). */
-      local: z.strictObject({
+      local: z2.strictObject({
         /** Command and arguments to spawn the ACP server process. */
-        command: z.array(z.string().min(1)).min(1).optional(),
+        command: z2.array(z2.string().min(1)).min(1).optional(),
         /** Path to an existing Unix domain socket to connect to instead of spawning a process. */
-        socketPath: z.string().min(1).optional()
+        socketPath: z2.string().min(1).optional()
       }).optional()
     });
     CODEX_EFFORTS = ["none", "low", "medium", "high"];
@@ -436,47 +501,47 @@ var init_schema = __esm({
       haiku: "gpt-5.6-luna"
     });
     CODEX_DEFAULT_EFFORT = "low";
-    CodexProviderConfigSchema = z.strictObject({
+    CodexProviderConfigSchema = z2.strictObject({
       /** The codex model a request maps to when no tier matches its model name. */
-      defaultModel: z.string().min(1).optional(),
+      defaultModel: z2.string().min(1).optional(),
       /** Per-tier overrides of the shipped mapping, matched by substring of the requested model name in `CLAUDE_TIERS` order. */
-      models: z.strictObject({
-        fable: z.string().min(1).optional(),
-        opus: z.string().min(1).optional(),
-        sonnet: z.string().min(1).optional(),
-        haiku: z.string().min(1).optional()
+      models: z2.strictObject({
+        fable: z2.string().min(1).optional(),
+        opus: z2.string().min(1).optional(),
+        sonnet: z2.string().min(1).optional(),
+        haiku: z2.string().min(1).optional()
       }).optional(),
       /** The reasoning effort used when the request's own `output_config.effort` is not one the backend accepts. */
-      effort: z.enum(CODEX_EFFORTS).optional(),
+      effort: z2.enum(CODEX_EFFORTS).optional(),
       /** Which login the upstream call is made with; see `CODEX_LOGINS`. */
-      login: z.enum(CODEX_LOGINS).optional()
+      login: z2.enum(CODEX_LOGINS).optional()
     });
-    ProviderRouteSchema = z.strictObject({
+    ProviderRouteSchema = z2.strictObject({
       /** The condition, the same `when` union a configuration cascade entry takes: the object form or a trilean predicate tree over the request facts the door resolves (`request.model` and kin). */
       when: WhenSchema,
       /** The provider a matching request is sent to, by the name a provider file carries. */
-      provider: z.string().min(1),
+      provider: z2.string().min(1),
       /** The model name to rewrite the request to before it reaches the target, for a provider that expects another form (OpenRouter's `anthropic/claude-...` for instance). A route that rewrites reads the whole body, the one copy the rewrite needs. */
-      model: z.string().min(1).optional()
+      model: z2.string().min(1).optional()
     });
-    PickerModelSchema = z.strictObject({
-      model: z.string().min(1),
-      tier: z.enum(CLAUDE_TIERS),
-      label: z.string().min(1).optional(),
-      description: z.string().min(1).optional()
+    PickerModelSchema = z2.strictObject({
+      model: z2.string().min(1),
+      tier: z2.enum(CLAUDE_TIERS),
+      label: z2.string().min(1).optional(),
+      description: z2.string().min(1).optional()
     });
-    PickerModelsSchema = z.array(PickerModelSchema).refine((models) => new Set(models.map((entry) => entry.model)).size === models.length, { message: "pickerModels names a model more than once" });
-    ProviderCatalogueSchema = z.strictObject({
-      tier: z.enum(CLAUDE_TIERS),
-      include: z.array(z.string().min(1)).min(1).optional(),
-      exclude: z.array(z.string().min(1)).min(1).optional(),
-      url: z.url().optional()
+    PickerModelsSchema = z2.array(PickerModelSchema).refine((models) => new Set(models.map((entry) => entry.model)).size === models.length, { message: "pickerModels names a model more than once" });
+    ProviderCatalogueSchema = z2.strictObject({
+      tier: z2.enum(CLAUDE_TIERS),
+      include: z2.array(z2.string().min(1)).min(1).optional(),
+      exclude: z2.array(z2.string().min(1)).min(1).optional(),
+      url: z2.url().optional()
     });
-    HttpProviderSchema = z.strictObject({
-      $schema: z.string().optional(),
-      kind: z.literal("http").optional(),
-      displayName: z.string().min(1),
-      baseUrl: z.url(),
+    HttpProviderSchema = z2.strictObject({
+      $schema: z2.string().optional(),
+      kind: z2.literal("http").optional(),
+      displayName: z2.string().min(1),
+      baseUrl: z2.url(),
       credential: ProviderCredentialSchema,
       env: ProviderEnvSchema.optional(),
       /** Extra models `/model` lists beside the ones the tier settings name. */
@@ -484,95 +549,95 @@ var init_schema = __esm({
       /** The provider's own model catalogue, listed in `/model` when set. */
       catalogue: ProviderCatalogueSchema.optional(),
       /** Per-request routing: when present, each request this provider would serve is matched against the list in order, and the first definite match is sent to that entry's provider instead (itself resolved exactly as a directly dialled request would be). Unmatched requests stay on this provider. */
-      routes: z.array(ProviderRouteSchema).optional()
+      routes: z2.array(ProviderRouteSchema).optional()
     });
-    CodexProviderSchema = z.strictObject({
-      $schema: z.string().optional(),
-      kind: z.literal("codex"),
-      displayName: z.string().min(1),
+    CodexProviderSchema = z2.strictObject({
+      $schema: z2.string().optional(),
+      kind: z2.literal("codex"),
+      displayName: z2.string().min(1),
       credential: ProviderCredentialSchema,
       env: ProviderEnvSchema.optional(),
       /** Extra models `/model` lists beside the ones the tier settings name. */
       pickerModels: PickerModelsSchema.optional(),
       codex: CodexProviderConfigSchema.optional()
     });
-    RouterProviderSchema = z.strictObject({
-      $schema: z.string().optional(),
-      kind: z.literal("router"),
-      displayName: z.string().min(1)
+    RouterProviderSchema = z2.strictObject({
+      $schema: z2.string().optional(),
+      kind: z2.literal("router"),
+      displayName: z2.string().min(1)
     });
-    AntigravityProviderSchema = z.strictObject({
-      $schema: z.string().optional(),
-      kind: z.literal("antigravity"),
-      displayName: z.string().min(1),
+    AntigravityProviderSchema = z2.strictObject({
+      $schema: z2.string().optional(),
+      kind: z2.literal("antigravity"),
+      displayName: z2.string().min(1),
       credential: ProviderCredentialSchema,
       env: ProviderEnvSchema.optional(),
       /** Extra models `/model` lists beside the ones the tier settings name. */
       pickerModels: PickerModelsSchema.optional(),
       antigravity: AntigravityProviderConfigSchema.optional()
     });
-    ProviderSchema = z.discriminatedUnion("kind", [HttpProviderSchema, CodexProviderSchema, AntigravityProviderSchema, RouterProviderSchema]);
+    ProviderSchema = z2.discriminatedUnion("kind", [HttpProviderSchema, CodexProviderSchema, AntigravityProviderSchema, RouterProviderSchema]);
     SELECTION_MODES = ["ordered", "most-allowance", "soonest-reset", "spread", "adaptive", "lowest-latency", "highest-success", "cheapest"];
-    VirtualModelSchema = z.strictObject({
+    VirtualModelSchema = z2.strictObject({
       /** How the virtual model chooses its member for a request. */
-      mode: z.enum(SELECTION_MODES),
+      mode: z2.enum(SELECTION_MODES),
       /** The members to choose among, in preference order where the mode reads order. Each names a target (`z/glm-5.3`), an account model (`acct:work/opus`), another virtual model, or a family (`family:<canonical>`). */
-      members: z.array(z.string().min(1)).min(1)
+      members: z2.array(z2.string().min(1)).min(1)
     });
-    ModelPricesSchema = z.strictObject({
-      input: z.number().positive(),
-      output: z.number().positive()
+    ModelPricesSchema = z2.strictObject({
+      input: z2.number().positive(),
+      output: z2.number().positive()
     });
-    FamilySettingsSchema = z.strictObject({
-      names: z.array(z.string().min(1)).optional(),
-      mode: z.enum(SELECTION_MODES).optional(),
-      context: z.number().int().positive().optional(),
-      vision: z.boolean().optional(),
-      tools: z.boolean().optional(),
-      thinking: z.boolean().optional()
+    FamilySettingsSchema = z2.strictObject({
+      names: z2.array(z2.string().min(1)).optional(),
+      mode: z2.enum(SELECTION_MODES).optional(),
+      context: z2.number().int().positive().optional(),
+      vision: z2.boolean().optional(),
+      tools: z2.boolean().optional(),
+      thinking: z2.boolean().optional()
     });
-    ModelsConfigSchema = z.strictObject({
+    ModelsConfigSchema = z2.strictObject({
       /** Virtual models, by name. */
-      virtual: z.record(z.string().min(1), VirtualModelSchema).optional(),
+      virtual: z2.record(z2.string().min(1), VirtualModelSchema).optional(),
       /** Which model ref each Claude tier (`fable`, `opus`, `sonnet`, `haiku`) points at: a concrete target, an account model, a virtual model, or a family. */
-      tiers: z.strictObject({
-        fable: z.string().min(1).optional(),
-        opus: z.string().min(1).optional(),
-        sonnet: z.string().min(1).optional(),
-        haiku: z.string().min(1).optional()
+      tiers: z2.strictObject({
+        fable: z2.string().min(1).optional(),
+        opus: z2.string().min(1).optional(),
+        sonnet: z2.string().min(1).optional(),
+        haiku: z2.string().min(1).optional()
       }).optional(),
       /** Prices per model ref, for the `cheapest` mode. */
-      prices: z.record(z.string().min(1), ModelPricesSchema).optional(),
+      prices: z2.record(z2.string().min(1), ModelPricesSchema).optional(),
       /** Model refs hidden from the picker and from routing, whatever else names them. */
-      hide: z.array(z.string().min(1)).optional(),
+      hide: z2.array(z2.string().min(1)).optional(),
       /** When set, the only model refs visible; everything else is hidden. */
-      show: z.array(z.string().min(1)).optional(),
+      show: z2.array(z2.string().min(1)).optional(),
       /** Assertions that each group of refs is one model under several names, overriding what the names alone say. */
-      same: z.array(z.array(z.string().min(1)).min(2)).optional(),
+      same: z2.array(z2.array(z2.string().min(1)).min(2)).optional(),
       /** Assertions that each pair of refs is two models however alike their names look. */
-      distinct: z.array(z.tuple([z.string().min(1), z.string().min(1)])).optional(),
+      distinct: z2.array(z2.tuple([z2.string().min(1), z2.string().min(1)])).optional(),
       /** Per-family settings and the names the normaliser cannot know, by family key. */
-      families: z.record(z.string().min(1), FamilySettingsSchema).optional()
+      families: z2.record(z2.string().min(1), FamilySettingsSchema).optional()
     });
-    ModelsLayerSchema = z.strictObject({
-      virtual: z.record(z.string().min(1), z.union([VirtualModelSchema, z.null()])).optional(),
-      tiers: z.strictObject({
-        fable: z.union([z.string().min(1), z.null()]).optional(),
-        opus: z.union([z.string().min(1), z.null()]).optional(),
-        sonnet: z.union([z.string().min(1), z.null()]).optional(),
-        haiku: z.union([z.string().min(1), z.null()]).optional()
+    ModelsLayerSchema = z2.strictObject({
+      virtual: z2.record(z2.string().min(1), z2.union([VirtualModelSchema, z2.null()])).optional(),
+      tiers: z2.strictObject({
+        fable: z2.union([z2.string().min(1), z2.null()]).optional(),
+        opus: z2.union([z2.string().min(1), z2.null()]).optional(),
+        sonnet: z2.union([z2.string().min(1), z2.null()]).optional(),
+        haiku: z2.union([z2.string().min(1), z2.null()]).optional()
       }).optional(),
-      prices: z.record(z.string().min(1), z.union([ModelPricesSchema, z.null()])).optional(),
-      hide: z.array(z.string().min(1)).optional(),
-      show: z.array(z.string().min(1)).optional(),
-      same: z.array(z.array(z.string().min(1)).min(2)).optional(),
-      distinct: z.array(z.tuple([z.string().min(1), z.string().min(1)])).optional(),
-      families: z.record(z.string().min(1), z.union([FamilySettingsSchema, z.null()])).optional()
+      prices: z2.record(z2.string().min(1), z2.union([ModelPricesSchema, z2.null()])).optional(),
+      hide: z2.array(z2.string().min(1)).optional(),
+      show: z2.array(z2.string().min(1)).optional(),
+      same: z2.array(z2.array(z2.string().min(1)).min(2)).optional(),
+      distinct: z2.array(z2.tuple([z2.string().min(1), z2.string().min(1)])).optional(),
+      families: z2.record(z2.string().min(1), z2.union([FamilySettingsSchema, z2.null()])).optional()
     });
-    ConfigProfileSchema = z.strictObject({
-      $schema: z.string().optional(),
-      description: z.string().optional(),
-      extends: z.array(z.string().min(1)).optional(),
+    ConfigProfileSchema = z2.strictObject({
+      $schema: z2.string().optional(),
+      description: z2.string().optional(),
+      extends: z2.array(z2.string().min(1)).optional(),
       categories: CategoryMapSchema.optional(),
       entries: EntriesSchema.optional(),
       launch: LaunchSchema.optional(),
@@ -581,55 +646,55 @@ var init_schema = __esm({
     POOL_SELECTOR_PREFIX = "pool:";
     POOL_NAME_PATTERN = "[A-Za-z0-9][A-Za-z0-9._-]*";
     IDENTITY_NAME_PATTERN = "[A-Za-z0-9][A-Za-z0-9._@-]*";
-    PoolNameSchema = z.string().min(1).regex(new RegExp(`^${POOL_NAME_PATTERN}$`));
+    PoolNameSchema = z2.string().min(1).regex(new RegExp(`^${POOL_NAME_PATTERN}$`));
     SELECTOR_RE = new RegExp(`^(${POOL_SELECTOR_PREFIX}${POOL_NAME_PATTERN}|${IDENTITY_NAME_PATTERN})$`);
-    IdentitySelectorSchema = z.string().min(1).regex(SELECTOR_RE);
-    PoolMemberSchema = z.union([z.string().min(1).regex(SELECTOR_RE), z.strictObject({ identity: z.string().min(1).regex(SELECTOR_RE), when: WhenSchema })]);
+    IdentitySelectorSchema = z2.string().min(1).regex(SELECTOR_RE);
+    PoolMemberSchema = z2.union([z2.string().min(1).regex(SELECTOR_RE), z2.strictObject({ identity: z2.string().min(1).regex(SELECTOR_RE), when: WhenSchema })]);
     POOL_PREFERENCES = ["score", "listed"];
-    PoolPreferenceSchema = z.enum(POOL_PREFERENCES);
+    PoolPreferenceSchema = z2.enum(POOL_PREFERENCES);
     WHOLE_PERCENT_MAX = 100;
-    CompactAtUtilisationSchema = z.number().int().min(1).max(WHOLE_PERCENT_MAX);
-    PoolSchema = z.strictObject({
-      identities: z.array(PoolMemberSchema).min(1).refine((members) => new Set(members.map(poolMemberIdentity)).size === members.length, { message: "pool members must be unique" }),
+    CompactAtUtilisationSchema = z2.number().int().min(1).max(WHOLE_PERCENT_MAX);
+    PoolSchema = z2.strictObject({
+      identities: z2.array(PoolMemberSchema).min(1).refine((members) => new Set(members.map(poolMemberIdentity)).size === members.length, { message: "pool members must be unique" }),
       preference: PoolPreferenceSchema.optional(),
       /** Whether an interactive launch from this pool keeps going when its identity runs out of quota: the launcher moves the session to the next member and resumes the conversation there. Absent means false. */
-      resumeOnLimit: z.boolean().optional(),
+      resumeOnLimit: z2.boolean().optional(),
       /** Whether a supervised session's context is compacted before its identity's quota is spent, so the resume on the next member writes a small context instead of a large one. Needs `resumeOnLimit`. Absent means false. */
-      compactBeforeLimit: z.boolean().optional(),
+      compactBeforeLimit: z2.boolean().optional(),
       /** The share of a quota window, in whole percent, at which sessions are compacted. Absent means the launcher decides from what compacting every session on the member would cost against what its five-hour window has left. Needs `compactBeforeLimit`. */
       compactAtUtilisation: CompactAtUtilisationSchema.optional()
     }).refine((pool) => pool.compactBeforeLimit !== true || pool.resumeOnLimit === true, { message: "compactBeforeLimit needs resumeOnLimit, since a session that is not moved has no cold cache to avoid", path: ["compactBeforeLimit"] }).refine((pool) => pool.compactAtUtilisation === void 0 || pool.compactBeforeLimit === true, { message: "compactAtUtilisation needs compactBeforeLimit", path: ["compactAtUtilisation"] });
     WEEKDAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
-    AnchorSchema = z.strictObject({
-      days: z.array(z.enum(WEEKDAYS)).min(1).refine((days) => new Set(days).size === days.length, "an anchor names each weekday at most once"),
-      time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "a 24-hour time such as 06:00"),
-      timeZone: z.string().refine(isTimeZone, "an IANA time zone such as Europe/London").optional()
+    AnchorSchema = z2.strictObject({
+      days: z2.array(z2.enum(WEEKDAYS)).min(1).refine((days) => new Set(days).size === days.length, "an anchor names each weekday at most once"),
+      time: z2.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "a 24-hour time such as 06:00"),
+      timeZone: z2.string().refine(isTimeZone, "an IANA time zone such as Europe/London").optional()
     });
     JOB_WINDOWS = ["fiveHour", "sevenDay"];
-    JobTriggerSchema = z.union([z.strictObject({ at: z.array(AnchorSchema).min(1) }), z.strictObject({ beforeReset: z.enum(JOB_WINDOWS), lead: z.string().regex(DURATION_RE) })]);
-    JobTargetSchema = z.union([z.strictObject({ identity: IdentitySelectorSchema }), z.strictObject({ pool: PoolNameSchema })]);
-    JobSchema = z.strictObject({
+    JobTriggerSchema = z2.union([z2.strictObject({ at: z2.array(AnchorSchema).min(1) }), z2.strictObject({ beforeReset: z2.enum(JOB_WINDOWS), lead: z2.string().regex(DURATION_RE) })]);
+    JobTargetSchema = z2.union([z2.strictObject({ identity: IdentitySelectorSchema }), z2.strictObject({ pool: PoolNameSchema })]);
+    JobSchema = z2.strictObject({
       target: JobTargetSchema,
       trigger: JobTriggerSchema,
-      prompt: z.string().min(1),
+      prompt: z2.string().min(1),
       /** The absolute directory the run works in. */
-      cwd: z.string().min(1),
-      timeout: z.string().regex(DURATION_RE),
-      model: z.string().min(1).optional(),
-      allowedTools: z.array(z.string().min(1)).min(1).optional()
+      cwd: z2.string().min(1),
+      timeout: z2.string().regex(DURATION_RE),
+      model: z2.string().min(1).optional(),
+      allowedTools: z2.array(z2.string().min(1)).min(1).optional()
     });
     DirectoryRuleSchema = ConfigProfileSchema.omit({ description: true }).extend({
-      path: z.string().min(1),
-      configProfile: z.string().min(1).optional(),
+      path: z2.string().min(1),
+      configProfile: z2.string().min(1).optional(),
       identity: IdentitySelectorSchema.optional(),
       when: WhenSchema.optional()
     });
-    DirectoryRulesSchema = z.strictObject({
-      $schema: z.string().optional(),
-      rules: z.array(DirectoryRuleSchema)
+    DirectoryRulesSchema = z2.strictObject({
+      $schema: z2.string().optional(),
+      rules: z2.array(DirectoryRuleSchema)
     });
     PortableConfigSchema = ConfigProfileSchema.omit({ description: true }).extend({
-      configProfile: z.string().min(1).optional(),
+      configProfile: z2.string().min(1).optional(),
       identity: IdentitySelectorSchema.optional(),
       when: WhenSchema.optional()
     });
@@ -638,23 +703,23 @@ var init_schema = __esm({
     HEADROOM_ROLLOUT_CHANNELS = ["beta", "canary", "dev"];
     INTERCEPT_CHANNELS = ["canary", "dev"];
     READ_MATURATION_CHANNELS = ["beta", "dev"];
-    HeadroomGlobalConfigObjectSchema = z.strictObject({
+    HeadroomGlobalConfigObjectSchema = z2.strictObject({
       /** Install spec handed to `uv tool install`. Defaults to HEADROOM_DEFAULT_SOURCE. */
-      source: z.string().min(1).optional(),
+      source: z2.string().min(1).optional(),
       /** How long the daemon may sit with no registered sessions before the supervisor stops it. Defaults to HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES. */
-      idleShutdownMinutes: z.number().int().positive().optional(),
+      idleShutdownMinutes: z2.number().int().positive().optional(),
       /** Optimisation mode, passed as `--mode`. Unset leaves headroom's own default (`cache`). */
-      mode: z.enum(HEADROOM_MODES).optional(),
+      mode: z2.enum(HEADROOM_MODES).optional(),
       /** Keep-ratio for prose and code compression, passed as `--target-ratio`: lower is more aggressive. Unset lets headroom decide. */
-      targetRatio: z.number().gt(0).max(1).optional(),
+      targetRatio: z2.number().gt(0).max(1).optional(),
       /** How compressed tool output stays recoverable. Unset leaves headroom's own default (`default`). */
-      ccr: z.enum(HEADROOM_CCR_MODES).optional(),
+      ccr: z2.enum(HEADROOM_CCR_MODES).optional(),
       /** Headroom's experimental release channel, exported as `HEADROOM_ROLLOUT_CHANNEL`. Required by `interceptToolResults` and `readMaturation`, which are refused without a channel that unlocks them. */
-      rolloutChannel: z.enum(HEADROOM_ROLLOUT_CHANNELS).optional(),
+      rolloutChannel: z2.enum(HEADROOM_ROLLOUT_CHANNELS).optional(),
       /** Opt in to headroom's tool-result interceptors (`--intercept-tool-results`). Needs `rolloutChannel` canary or dev. */
-      interceptToolResults: z.boolean().optional(),
+      interceptToolResults: z2.boolean().optional(),
       /** Opt in to headroom's experimental read maturation (`--read-maturation`). Needs `rolloutChannel` beta or dev. */
-      readMaturation: z.boolean().optional()
+      readMaturation: z2.boolean().optional()
     });
     HeadroomGlobalConfigSchema = HeadroomGlobalConfigObjectSchema.superRefine((config, context) => {
       if (config.interceptToolResults === true && !INTERCEPT_CHANNELS.includes(config.rolloutChannel ?? "")) {
@@ -666,53 +731,53 @@ var init_schema = __esm({
     });
     HEADROOM_DEFAULT_SOURCE = "headroom-ai[proxy] @ git+https://github.com/ExaDev/headroom@2dfa958e47814533751cdd0c5362d8f352ec5b75";
     HEADROOM_DEFAULT_IDLE_SHUTDOWN_MINUTES = 15;
-    FrontDoorGlobalConfigSchema = z.strictObject({
+    FrontDoorGlobalConfigSchema = z2.strictObject({
       /** How long the front door may sit with no registered sessions before it closes and exits. Defaults to FRONTDOOR_DEFAULT_IDLE_SHUTDOWN_MINUTES. */
-      idleShutdownMinutes: z.number().int().positive().optional()
+      idleShutdownMinutes: z2.number().int().positive().optional()
     });
     UPDATE_MODES = ["off", "notify", "auto"];
-    UpdateGlobalConfigSchema = z.strictObject({
+    UpdateGlobalConfigSchema = z2.strictObject({
       /** What a launch does about a newer release of agent-shim itself; see `UPDATE_MODES`. Absent means `off`. */
-      mode: z.enum(UPDATE_MODES).optional()
+      mode: z2.enum(UPDATE_MODES).optional()
     });
-    GlobalConfigSchema = z.strictObject({
-      $schema: z.string().optional(),
-      defaultConfigProfile: z.string().min(1).optional(),
-      walkUpLimit: z.string().min(1).optional(),
+    GlobalConfigSchema = z2.strictObject({
+      $schema: z2.string().optional(),
+      defaultConfigProfile: z2.string().min(1).optional(),
+      walkUpLimit: z2.string().min(1).optional(),
       categories: CategoryMapSchema.optional(),
       entries: EntriesSchema.optional(),
       launch: LaunchSchema.optional(),
       headroom: HeadroomGlobalConfigSchema.optional(),
       frontdoor: FrontDoorGlobalConfigSchema.optional(),
       update: UpdateGlobalConfigSchema.optional(),
-      pools: z.record(PoolNameSchema, PoolSchema).optional(),
+      pools: z2.record(PoolNameSchema, PoolSchema).optional(),
       models: ModelsConfigSchema.optional(),
-      jobs: z.record(PoolNameSchema, JobSchema).optional()
+      jobs: z2.record(PoolNameSchema, JobSchema).optional()
     });
-    IdentitySchema = z.strictObject({
-      $schema: z.string().optional(),
-      name: z.string().min(1).regex(/^[A-Za-z0-9][A-Za-z0-9._@-]*$/),
-      defaultConfigProfile: z.string().min(1).optional(),
-      allowAmbientCredential: z.boolean().default(false),
+    IdentitySchema = z2.strictObject({
+      $schema: z2.string().optional(),
+      name: z2.string().min(1).regex(/^[A-Za-z0-9][A-Za-z0-9._@-]*$/),
+      defaultConfigProfile: z2.string().min(1).optional(),
+      allowAmbientCredential: z2.boolean().default(false),
       credential: CredentialSchema.optional(),
       /** When this identity's five-hour window should be open: the front door opens one at each anchor if none is. Absent, nothing is opened on a schedule. */
-      anchors: z.array(AnchorSchema).min(1).optional()
+      anchors: z2.array(AnchorSchema).min(1).optional()
     });
-    CategoryClassificationSchema = z.strictObject({
-      $schema: z.string().optional(),
-      secret: z.array(z.string().min(1)),
-      runtime: z.array(z.string().min(1)),
-      history: z.array(z.string().min(1)),
-      knowledge: z.array(z.string().min(1)),
-      settings: z.array(z.string().min(1))
+    CategoryClassificationSchema = z2.strictObject({
+      $schema: z2.string().optional(),
+      secret: z2.array(z2.string().min(1)),
+      runtime: z2.array(z2.string().min(1)),
+      history: z2.array(z2.string().min(1)),
+      knowledge: z2.array(z2.string().min(1)),
+      settings: z2.array(z2.string().min(1))
     });
-    CategoryClassificationOverlaySchema = z.strictObject({
-      $schema: z.string().optional(),
-      secret: z.array(z.string().min(1)).optional(),
-      runtime: z.array(z.string().min(1)).optional(),
-      history: z.array(z.string().min(1)).optional(),
-      knowledge: z.array(z.string().min(1)).optional(),
-      settings: z.array(z.string().min(1)).optional()
+    CategoryClassificationOverlaySchema = z2.strictObject({
+      $schema: z2.string().optional(),
+      secret: z2.array(z2.string().min(1)).optional(),
+      runtime: z2.array(z2.string().min(1)).optional(),
+      history: z2.array(z2.string().min(1)).optional(),
+      knowledge: z2.array(z2.string().min(1)).optional(),
+      settings: z2.array(z2.string().min(1)).optional()
     });
     SHIPPED_CATEGORY_DEFAULTS = Object.freeze({
       secret: false,
@@ -1504,6 +1569,9 @@ function flattenLayers(layers, options) {
       if (layer.launch.proxyBypass !== void 0) {
         launch.proxyBypass = layer.launch.proxyBypass;
       }
+      if (layer.launch.statusline !== void 0) {
+        launch.statusline = { ...launch.statusline, ...layer.launch.statusline };
+      }
     }
     if (layer.models !== void 0) {
       models = mergeModels(models, layer.models);
@@ -2429,7 +2497,7 @@ var init_lock = __esm({
 
 // src/launcher/farm.ts
 import path7 from "node:path";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 function readFarmManifest(fs14, farmRoot) {
   const raw = fs14.readFileUtf8(path7.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs14.readFileUtf8(path7.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
   if (raw === void 0) {
@@ -2901,15 +2969,15 @@ var init_farm = __esm({
     init_legacy();
     init_lock();
     FARM_MANIFEST_FILENAME = ".agent-shim-farm.json";
-    FarmManifestSchema = z2.strictObject({
-      version: z2.literal(1),
-      builtAtMs: z2.number(),
-      identity: z2.string(),
-      configProfile: z2.string().optional(),
-      cwd: z2.string(),
-      claudeHome: z2.string(),
-      materialised: z2.array(z2.string()),
-      links: z2.array(z2.strictObject({ rel: z2.string(), target: z2.string() }))
+    FarmManifestSchema = z3.strictObject({
+      version: z3.literal(1),
+      builtAtMs: z3.number(),
+      identity: z3.string(),
+      configProfile: z3.string().optional(),
+      cwd: z3.string(),
+      claudeHome: z3.string(),
+      materialised: z3.array(z3.string()),
+      links: z3.array(z3.strictObject({ rel: z3.string(), target: z3.string() }))
     });
   }
 });
@@ -3304,7 +3372,7 @@ var init_route = __esm({
 
 // src/frontdoor/state.ts
 import path8 from "node:path";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 function readFrontDoorState(fs14, stateFile) {
   let raw;
   try {
@@ -3447,39 +3515,39 @@ var init_state = __esm({
     "use strict";
     init_schema();
     FRONT_DOOR_PROTOCOL = 5;
-    FrontDoorSessionSchema = z3.strictObject({ pid: z3.number().int().positive(), startedAt: z3.number(), token: z3.string().min(1), supervisorPid: z3.number().int().positive().optional(), sessionId: z3.string().min(1).optional(), models: ModelsConfigSchema.optional() });
-    FrontDoorStateSchema = z3.strictObject({
+    FrontDoorSessionSchema = z4.strictObject({ pid: z4.number().int().positive(), startedAt: z4.number(), token: z4.string().min(1), supervisorPid: z4.number().int().positive().optional(), sessionId: z4.string().min(1).optional(), models: ModelsConfigSchema.optional() });
+    FrontDoorStateSchema = z4.strictObject({
       /**
        * The launcher-to-door wire protocol this supervisor speaks, written once it is serving; absent in state written by a release that predates the field, which `ensureFrontDoor` reads as protocol 0. A launcher replaces a door whose protocol is lower than its own (see `FRONT_DOOR_PROTOCOL`).
        */
-      protocol: z3.number().int().nonnegative().optional(),
+      protocol: z4.number().int().nonnegative().optional(),
       /** The supervisor process serving the front door. Alive means both listeners are up in that process. */
-      supervisorPid: z3.number().int().positive().optional(),
+      supervisorPid: z4.number().int().positive().optional(),
       /** The loopback port the HTTPS provider listener serves on. Absent until the listener has bound and answered its health probe, so "port is set" is itself the ready signal a launcher polls for. */
-      port: z3.number().int().positive().optional(),
+      port: z4.number().int().positive().optional(),
       /**
        * The sticky port preference for the provider listener: kept across crashes, restarts and idle shutdowns so every provider session, whose base URL was frozen at launch, keeps finding the front door at the same address.
        */
-      lastPort: z3.number().int().positive().optional(),
+      lastPort: z4.number().int().positive().optional(),
       /**
        * The loopback port the CONNECT surface listens on. Absent whenever no supervisor is serving it, so "connectPort is set" is the ready signal an OAuth launch polls for alongside `port`.
        */
-      connectPort: z3.number().int().positive().optional(),
+      connectPort: z4.number().int().positive().optional(),
       /**
        * The sticky port preference for the CONNECT surface, the exact analogue of `lastPort` for the second listener: it survives every shutdown, because every OAuth session's environment was frozen at launch with HTTPS_PROXY pointing at this address and a restart that moves strands them.
        */
-      lastConnectPort: z3.number().int().positive().optional(),
+      lastConnectPort: z4.number().int().positive().optional(),
       /**
        * The loopback port the direct listener serves on: the listener a headroom hop tells the daemon to forward routed traffic back to. Sticky like the others, because headroom's allowlist admits its exact origin: the headroom supervisor rewrites the daemon's allowlist file when the origin moves, but a provider launch waits at its gate until it has, so an ephemeral port would hold launches up after every restart.
        */
-      directPort: z3.number().int().positive().optional(),
+      directPort: z4.number().int().positive().optional(),
       /** The sticky port preference for the direct listener, for the reason `directPort` gives. */
-      lastDirectPort: z3.number().int().positive().optional(),
+      lastDirectPort: z4.number().int().positive().optional(),
       /** The last fatal error, kept across shutdowns so `frontdoor status` can explain a front door that is not running. */
-      lastError: z3.string().optional()
+      lastError: z4.string().optional()
     });
     MAX_TCP_PORT = 65535;
-    FrontDoorDirectRecordSchema = z3.strictObject({ directPort: z3.number().int().positive().max(MAX_TCP_PORT) });
+    FrontDoorDirectRecordSchema = z4.strictObject({ directPort: z4.number().int().positive().max(MAX_TCP_PORT) });
     RECORD_TEMPORARY_FILE = /^[1-9]\d*\.json\.([1-9]\d*)\.tmp$/;
   }
 });
@@ -4167,7 +4235,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.49.2",
+      version: "11.50.1",
       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>",
@@ -4367,7 +4435,7 @@ var init_supervisorProcesses = __esm({
 // src/headroom/state.ts
 import { createHash as createHash3 } from "node:crypto";
 import path11 from "node:path";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function parseJson(raw, schema) {
   if (raw === void 0 || raw.trim() === "") {
     return void 0;
@@ -4524,32 +4592,32 @@ var init_state2 = __esm({
   "src/headroom/state.ts"() {
     "use strict";
     init_schema();
-    HeadroomStateSchema = z8.strictObject({
+    HeadroomStateSchema = z9.strictObject({
       /** The supervisor process owning the daemon. Alive means someone is keeping headroom running. */
-      supervisorPid: z8.number().int().positive().optional(),
+      supervisorPid: z9.number().int().positive().optional(),
       /** The headroom proxy process itself, recorded as soon as it is spawned (before it is ready, which `socketPath` signals) so a successor can find a daemon whose supervisor died during its start. Absent while the supervisor is between restarts. */
-      headroomPid: z8.number().int().positive().optional(),
+      headroomPid: z9.number().int().positive().optional(),
       /**
        * The unix socket the proxy serves on, inside the owner-only socket directory. Absent until the proxy has passed its readiness check, so "socketPath is set" is itself the ready signal a launcher polls for. The front door reads it on every hop, so a restart (which keeps the generation's path) is followed without anything being relaunched.
        */
-      socketPath: z8.string().min(1).optional(),
+      socketPath: z9.string().min(1).optional(),
       /** The `headroom --version` output of the running install. */
-      version: z8.string().optional(),
+      version: z9.string().optional(),
       /**
        * Hash of the allowlist the running proxy serves. The supervisor records it in the same tick it writes that allowlist to `LayoutPaths.headroomAllowlistFile`, which the proxy re-reads on its next request, so a provider launch, whose requests come back through its front door's direct origin, waits until this names an allowlist holding that origin. A supervisor from an earlier release records here the hash of the allowlist its daemon was started with instead (see `earlierRelease.ts`).
        */
-      allowlistHash: z8.string().optional(),
+      allowlistHash: z9.string().optional(),
       /** Hash of the token-saving settings the running proxy was started with, so a settings change is detected as drift. */
-      settingsHash: z8.string().optional(),
+      settingsHash: z9.string().optional(),
       /** The install spec the running install was last installed from, so a `source` config change is detected as drift. */
-      installedSource: z8.string().optional(),
+      installedSource: z9.string().optional(),
       /** The install spec the supervisor is installing right now, present only while `uv tool install` runs, so a launcher that finds a live supervisor with no daemon yet keeps waiting for the install instead of counting it against its start bound. Cleared by the write that follows the install, whatever its outcome. */
-      installing: z8.string().optional(),
+      installing: z9.string().optional(),
       /** The last fatal error, kept across shutdowns so `headroom status` can explain a daemon that is not running. */
-      lastError: z8.string().optional()
+      lastError: z9.string().optional()
     });
-    HeadroomSessionSchema = z8.strictObject({ pid: z8.number().int().positive(), startedAt: z8.number(), supervisorPid: z8.number().int().positive() });
-    HeadroomLockSchema = z8.strictObject({ pid: z8.number().int().positive(), at: z8.number() });
+    HeadroomSessionSchema = z9.strictObject({ pid: z9.number().int().positive(), startedAt: z9.number(), supervisorPid: z9.number().int().positive() });
+    HeadroomLockSchema = z9.strictObject({ pid: z9.number().int().positive(), at: z9.number() });
     HEADROOM_ALLOWLIST_FILE_FLAG = "--allowed-base-urls-file";
     ALLOWLIST_LINE_BREAKS = "\\n\\r\\u000b\\u000c\\u001c\\u001d\\u001e\\u0085\\u2028\\u2029";
     ALLOWLIST_WHITESPACE = "\\t\\n\\u000b\\u000c\\r\\u001c-\\u001f \\u0085\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000";
@@ -4950,7 +5018,7 @@ var init_socket = __esm({
 });
 
 // src/headroom/source.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 function isMovingGitSource(spec) {
   const match = GIT_SPEC_RE.exec(spec);
   if (match === null) {
@@ -4969,7 +5037,7 @@ var init_source = __esm({
     "use strict";
     GIT_SPEC_RE = /git\+[^@\s]+(?:@([^\s#]+))?/;
     COMMIT_SHA_RE = /^[0-9a-f]{40}$/i;
-    DirectUrlSchema = z9.object({ vcs_info: z9.object({ commit_id: z9.string() }) });
+    DirectUrlSchema = z10.object({ vcs_info: z10.object({ commit_id: z10.string() }) });
   }
 });
 
@@ -6098,161 +6166,161 @@ var init_identity = __esm({
 });
 
 // src/usage/schema.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var USAGE_SCHEMA_VERSION, VersionSchema, InstantSchema, TokenCountSchema, TokenUsageSchema, LIMIT_KINDS, LimitClassificationSchema, UsageRecordSchema, QuotaWindowSchema, ExtraUsageSpendSchema, UnifiedRateLimitSchema, RateLimitStateSchema, LimitEventSchema, ProviderQuotaWindowSchema, ProviderAccountSchema, ProviderQuotaSchema, ProviderUsageStateSchema, AccountMetadataSchema, UsageSnapshotSchema;
 var init_schema2 = __esm({
   "src/usage/schema.ts"() {
     "use strict";
     USAGE_SCHEMA_VERSION = 1;
-    VersionSchema = z10.literal(USAGE_SCHEMA_VERSION);
-    InstantSchema = z10.iso.datetime();
-    TokenCountSchema = z10.number().int().nonnegative();
-    TokenUsageSchema = z10.strictObject({
+    VersionSchema = z11.literal(USAGE_SCHEMA_VERSION);
+    InstantSchema = z11.iso.datetime();
+    TokenCountSchema = z11.number().int().nonnegative();
+    TokenUsageSchema = z11.strictObject({
       inputTokens: TokenCountSchema.optional(),
       outputTokens: TokenCountSchema.optional(),
       cacheCreationInputTokens: TokenCountSchema.optional(),
       cacheReadInputTokens: TokenCountSchema.optional()
     });
     LIMIT_KINDS = ["rate-limited", "quota-exhausted"];
-    LimitClassificationSchema = z10.strictObject({
-      kind: z10.enum(LIMIT_KINDS),
+    LimitClassificationSchema = z11.strictObject({
+      kind: z11.enum(LIMIT_KINDS),
       /** Seconds to wait before retrying, from the response's `retry-after`. */
-      retryAfterSeconds: z10.number().nonnegative().optional(),
+      retryAfterSeconds: z11.number().nonnegative().optional(),
       /** When the limiting window resets, from the upstream's own reset header. */
       resetAt: InstantSchema.optional(),
       /** The window the upstream named as the binding one (`anthropic-ratelimit-unified-representative-claim`), such as `five_hour` or `seven_day`. */
-      window: z10.string().optional(),
+      window: z11.string().optional(),
       /** The signals the classification rests on, each `<name>=<value>` from a response header or the error body's `type` or `code`. Never the error message. */
-      evidence: z10.array(z10.string())
+      evidence: z11.array(z11.string())
     });
-    UsageRecordSchema = z10.strictObject({
+    UsageRecordSchema = z11.strictObject({
       schemaVersion: VersionSchema,
       /** When the front door received the request. */
       at: InstantSchema,
       /** The launching identity, when the launch resolved one. */
-      identity: z10.string().optional(),
+      identity: z11.string().optional(),
       /** `anthropic` for an OAuth session's request to Claude Code's own API, otherwise the provider's name. */
-      provider: z10.string(),
+      provider: z11.string(),
       /** The launch's session id, generated per launch. */
-      sessionId: z10.string().optional(),
+      sessionId: z11.string().optional(),
       /** The project the launch ran in (its git repository root), when the launch sent one: headroom launches do. */
-      project: z10.string().optional(),
+      project: z11.string().optional(),
       /** Whether the request crossed headroom on its way upstream. Absent on a record written before the door recorded it, and false when the request went direct. */
-      viaHeadroom: z10.boolean().optional(),
+      viaHeadroom: z11.boolean().optional(),
       /** The front-door route that served the request. */
-      route: z10.string(),
-      method: z10.string(),
+      route: z11.string(),
+      method: z11.string(),
       /** The API path as the upstream sees it (`/v1/messages`), without the provider prefix or a query string. */
-      endpoint: z10.string(),
+      endpoint: z11.string(),
       /** The model the response named. */
-      model: z10.string().optional(),
+      model: z11.string().optional(),
       /** The model name the session asked for, when a routing layer chose among alternatives for it (a virtual model's or a tier alias's selection) and served the request under a different name. Absent when the session's own name reached the provider unchanged. */
-      requestedModel: z10.string().optional(),
+      requestedModel: z11.string().optional(),
       /** The distinct providers the choice could have landed on, present only when there was more than one, so a reader can tell a choice that crossed providers from one that stayed inside a single provider's lineup. */
-      candidateProviders: z10.array(z10.string()).optional(),
-      status: z10.number().int(),
+      candidateProviders: z11.array(z11.string()).optional(),
+      status: z11.number().int(),
       /** Milliseconds from the request's arrival to its response head. */
-      latencyMs: z10.number().int().nonnegative(),
+      latencyMs: z11.number().int().nonnegative(),
       /** Milliseconds from the request's arrival to the end of its response body. */
-      durationMs: z10.number().int().nonnegative(),
+      durationMs: z11.number().int().nonnegative(),
       /** Whether the client received the whole body. */
-      outcome: z10.enum(["completed", "aborted"]),
+      outcome: z11.enum(["completed", "aborted"]),
       usage: TokenUsageSchema.optional(),
       /** The response's quota and rate-limit headers, by name (see `isRateLimitHeader`). */
-      rateLimitHeaders: z10.record(z10.string(), z10.string()).optional(),
+      rateLimitHeaders: z11.record(z11.string(), z11.string()).optional(),
       limit: LimitClassificationSchema.optional(),
       /** The upstream's request id (`request-id`), for matching a record to the provider's own logs. */
-      requestId: z10.string().optional()
+      requestId: z11.string().optional()
     });
-    QuotaWindowSchema = z10.strictObject({
+    QuotaWindowSchema = z11.strictObject({
       /** The fraction of the window used, as the upstream reports it (0 to 1). */
-      utilization: z10.number().nonnegative().optional(),
+      utilization: z11.number().nonnegative().optional(),
       resetsAt: InstantSchema.optional(),
       /** The window's own status (`allowed`, `allowed_warning`, `rejected`). */
-      status: z10.string().optional(),
+      status: z11.string().optional(),
       /** The fraction of the window's grace allowance used, while the upstream reports the window in grace (the five-hour window only). Requests are served beyond the window's own full mark while it grows, but refusals have been seen at a small value, so nothing ranks on it. */
-      graceUtilization: z10.number().nonnegative().optional()
+      graceUtilization: z11.number().nonnegative().optional()
     });
-    ExtraUsageSpendSchema = z10.strictObject({
+    ExtraUsageSpendSchema = z11.strictObject({
       /** Spent so far in the allowance's period, in the currency's minor units (pence, cents). */
-      usedMinor: z10.number().nonnegative(),
+      usedMinor: z11.number().nonnegative(),
       /** The allowance's cap in the same units, when it has one. */
-      limitMinor: z10.number().nonnegative().optional(),
+      limitMinor: z11.number().nonnegative().optional(),
       /** The ISO 4217 currency code. */
-      currency: z10.string()
+      currency: z11.string()
     });
-    UnifiedRateLimitSchema = z10.strictObject({
+    UnifiedRateLimitSchema = z11.strictObject({
       /** The overall status: `allowed`, `allowed_warning` or `rejected`. */
-      status: z10.string().optional(),
+      status: z11.string().optional(),
       fiveHour: QuotaWindowSchema.optional(),
       sevenDay: QuotaWindowSchema.optional(),
       /** The weekly window of the models whose usage may continue as extra usage (`7d_oi`), reported by some plans beside the all-models weekly window. */
       sevenDayOverageIncluded: QuotaWindowSchema.optional(),
       /** The window that currently binds. */
-      representativeClaim: z10.string().optional(),
+      representativeClaim: z11.string().optional(),
       /** When the binding window resets. */
       resetAt: InstantSchema.optional(),
       /** Whether usage beyond the plan (extra usage) is available: `allowed` or `rejected`. */
-      overageStatus: z10.string().optional(),
+      overageStatus: z11.string().optional(),
       /** The fraction of the extra-usage allowance used, as the upstream reports it (0 to 1). An account with no plan windows, such as an Enterprise one, is metered by this alone. */
-      overageUtilization: z10.number().nonnegative().optional(),
+      overageUtilization: z11.number().nonnegative().optional(),
       /** When the extra-usage allowance resets. */
       overageResetsAt: InstantSchema.optional(),
       /** Why extra usage is unavailable, as the upstream names it (`out_of_credits`, for one). */
-      overageDisabledReason: z10.string().optional(),
+      overageDisabledReason: z11.string().optional(),
       /** Whether the response was served on extra usage, as the upstream states it. */
-      overageInUse: z10.boolean().optional(),
+      overageInUse: z11.boolean().optional(),
       /** The allowance in money, from the usage endpoint (the response headers state only the fraction). */
       extraUsageSpend: ExtraUsageSpendSchema.optional(),
       /** True when the upstream offers a fallback while a window is rejected: some requests, by model, are still served, though the rest are refused. */
-      fallbackAvailable: z10.boolean().optional()
+      fallbackAvailable: z11.boolean().optional()
     });
-    RateLimitStateSchema = z10.strictObject({
+    RateLimitStateSchema = z11.strictObject({
       observedAt: InstantSchema,
       /** Every quota and rate-limit header on that response, by name. */
-      headers: z10.record(z10.string(), z10.string()),
+      headers: z11.record(z11.string(), z11.string()),
       unified: UnifiedRateLimitSchema.optional(),
       /** When the usage endpoint last answered that it has no plan windows for the account, which a later response replaces. Its answer leaves the recorded `unified` state alone (a response's headers may be the only source of it), so this alone says the question was asked. */
       planWindowsUnavailableAt: InstantSchema.optional()
     });
     LimitEventSchema = LimitClassificationSchema.extend({
       observedAt: InstantSchema,
-      status: z10.number().int()
+      status: z11.number().int()
     });
-    ProviderQuotaWindowSchema = z10.strictObject({
+    ProviderQuotaWindowSchema = z11.strictObject({
       /** What the window measures, in the provider's terms (`tokens`, `tool-calls`). */
-      measures: z10.string(),
+      measures: z11.string(),
       /** The window's length in milliseconds, when the provider's unit is one this project knows; absent for an unrecognised unit, with `period` carrying the raw code. */
-      periodMs: z10.number().int().positive().optional(),
+      periodMs: z11.number().int().positive().optional(),
       /** The provider's own description of the period when `periodMs` could not be derived, such as `unit 4 x 1`. */
-      period: z10.string().optional(),
+      period: z11.string().optional(),
       /** The fraction of the window used (0 to 1). */
-      utilization: z10.number().nonnegative(),
+      utilization: z11.number().nonnegative(),
       resetsAt: InstantSchema.optional(),
       /** Absolute counts, when the provider reports them for this window. */
-      limit: z10.number().nonnegative().optional(),
-      used: z10.number().nonnegative().optional(),
-      remaining: z10.number().nonnegative().optional()
+      limit: z11.number().nonnegative().optional(),
+      used: z11.number().nonnegative().optional(),
+      remaining: z11.number().nonnegative().optional()
     });
-    ProviderAccountSchema = z10.strictObject({
-      email: z10.string().optional(),
-      accountId: z10.string().optional()
+    ProviderAccountSchema = z11.strictObject({
+      email: z11.string().optional(),
+      accountId: z11.string().optional()
     });
-    ProviderQuotaSchema = z10.strictObject({
+    ProviderQuotaSchema = z11.strictObject({
       observedAt: InstantSchema,
       /** Which usage endpoint produced it (`z.ai`). */
-      source: z10.string(),
+      source: z11.string(),
       /** The subscription level the endpoint reports, when it does. */
-      level: z10.string().optional(),
+      level: z11.string().optional(),
       /** The account the provider's credential belongs to, when its endpoint reports it. */
       account: ProviderAccountSchema.optional(),
-      windows: z10.array(ProviderQuotaWindowSchema)
+      windows: z11.array(ProviderQuotaWindowSchema)
     });
-    ProviderUsageStateSchema = z10.strictObject({
+    ProviderUsageStateSchema = z11.strictObject({
       /** When the provider last served a request for the identity through the front door. Absent while the state holds only a rate-limit state fetched from the provider's usage endpoint, for an identity that has made no request. */
       lastRequestAt: InstantSchema.optional(),
-      lastStatus: z10.number().int().optional(),
-      lastModel: z10.string().optional(),
+      lastStatus: z11.number().int().optional(),
+      lastModel: z11.string().optional(),
       /** The latest rate-limit state, from the last response that carried any rate-limit header. */
       rateLimit: RateLimitStateSchema.optional(),
       /** The latest classified refusal. It stays after later successes, so a reader compares its `resetAt` (or `observedAt` plus `retryAfterSeconds`) with the current time. */
@@ -6260,31 +6328,31 @@ var init_schema2 = __esm({
       /** The latest quota the provider's usage endpoint reported, for providers whose quota is not visible in response headers. */
       quota: ProviderQuotaSchema.optional()
     });
-    AccountMetadataSchema = z10.strictObject({
-      accountUuid: z10.string().optional(),
-      emailAddress: z10.string().optional(),
-      displayName: z10.string().optional(),
-      organizationUuid: z10.string().optional(),
-      organizationName: z10.string().optional(),
-      organizationType: z10.string().optional(),
-      organizationRole: z10.string().optional(),
-      workspaceRole: z10.string().optional(),
-      billingType: z10.string().optional(),
-      seatTier: z10.string().optional(),
-      organizationRateLimitTier: z10.string().optional(),
-      userRateLimitTier: z10.string().optional(),
-      hasExtraUsageEnabled: z10.boolean().optional(),
-      subscriptionCreatedAt: z10.string().optional(),
-      accountCreatedAt: z10.string().optional()
+    AccountMetadataSchema = z11.strictObject({
+      accountUuid: z11.string().optional(),
+      emailAddress: z11.string().optional(),
+      displayName: z11.string().optional(),
+      organizationUuid: z11.string().optional(),
+      organizationName: z11.string().optional(),
+      organizationType: z11.string().optional(),
+      organizationRole: z11.string().optional(),
+      workspaceRole: z11.string().optional(),
+      billingType: z11.string().optional(),
+      seatTier: z11.string().optional(),
+      organizationRateLimitTier: z11.string().optional(),
+      userRateLimitTier: z11.string().optional(),
+      hasExtraUsageEnabled: z11.boolean().optional(),
+      subscriptionCreatedAt: z11.string().optional(),
+      accountCreatedAt: z11.string().optional()
     });
-    UsageSnapshotSchema = z10.strictObject({
+    UsageSnapshotSchema = z11.strictObject({
       schemaVersion: VersionSchema,
-      identity: z10.string(),
+      identity: z11.string(),
       updatedAt: InstantSchema,
       /** The identity's account metadata as of `updatedAt`. */
       account: AccountMetadataSchema.optional(),
       /** Latest state per provider, keyed by provider name (`anthropic` for OAuth sessions). */
-      providers: z10.record(z10.string(), ProviderUsageStateSchema)
+      providers: z11.record(z11.string(), ProviderUsageStateSchema)
     });
   }
 });
@@ -6374,7 +6442,7 @@ var init_account = __esm({
 });
 
 // src/usage/plan.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 function planOf(account) {
   const userTier = account?.userRateLimitTier;
   if (userTier !== void 0 && ZERO_TIER.test(userTier)) {
@@ -6398,19 +6466,19 @@ var PlanClassSchema, TIER_MULTIPLIER, ZERO_TIER, BASE_TIER;
 var init_plan2 = __esm({
   "src/usage/plan.ts"() {
     "use strict";
-    PlanClassSchema = z11.union([
-      z11.strictObject({
-        kind: z11.literal("subscription"),
+    PlanClassSchema = z12.union([
+      z12.strictObject({
+        kind: z12.literal("subscription"),
         /** The plan's size as a multiple of the smallest subscription tier (Max 5x is 5, Max 20x is 20). */
-        capacity: z11.number().positive(),
+        capacity: z12.number().positive(),
         /** False when the tier string named no multiplier and no tier this project knows, so `capacity` is the neutral 1 rather than a reading. */
-        recognised: z11.boolean(),
+        recognised: z12.boolean(),
         /** The tier string the classification rests on, when the account had one. */
-        tier: z11.string().optional()
+        tier: z12.string().optional()
       }),
-      z11.strictObject({
-        kind: z11.literal("pay-per-use"),
-        tier: z11.string().optional()
+      z12.strictObject({
+        kind: z12.literal("pay-per-use"),
+        tier: z12.string().optional()
       })
     ]);
     TIER_MULTIPLIER = /(?:^|_)(\d+)x$/;
@@ -6511,21 +6579,21 @@ var init_rateLimit = __esm({
 });
 
 // src/usage/scan.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var AnthropicUsageSchema, ErrorObjectSchema;
 var init_scan = __esm({
   "src/usage/scan.ts"() {
     "use strict";
-    AnthropicUsageSchema = z12.looseObject({
-      input_tokens: z12.number().int().nonnegative().nullish(),
-      output_tokens: z12.number().int().nonnegative().nullish(),
-      cache_creation_input_tokens: z12.number().int().nonnegative().nullish(),
-      cache_read_input_tokens: z12.number().int().nonnegative().nullish()
+    AnthropicUsageSchema = z13.looseObject({
+      input_tokens: z13.number().int().nonnegative().nullish(),
+      output_tokens: z13.number().int().nonnegative().nullish(),
+      cache_creation_input_tokens: z13.number().int().nonnegative().nullish(),
+      cache_read_input_tokens: z13.number().int().nonnegative().nullish()
     });
-    ErrorObjectSchema = z12.looseObject({
-      type: z12.string().optional(),
-      code: z12.union([z12.string(), z12.number()]).optional(),
-      message: z12.string().optional()
+    ErrorObjectSchema = z13.looseObject({
+      type: z13.string().optional(),
+      code: z13.union([z13.string(), z13.number()]).optional(),
+      message: z13.string().optional()
     });
   }
 });
@@ -7165,7 +7233,7 @@ var init_store2 = __esm({
 
 // src/usage/poolPick.ts
 import path21 from "node:path";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -7317,10 +7385,10 @@ var init_poolPick = __esm({
       }
     };
     SCHEMA_VERSION = 1;
-    PickEntrySchema = z13.strictObject({ identity: z13.string().min(1), at: z13.iso.datetime() });
-    PicksFileSchema = z13.strictObject({
-      schemaVersion: z13.literal(SCHEMA_VERSION),
-      picks: z13.record(z13.string().min(1), PickEntrySchema)
+    PickEntrySchema = z14.strictObject({ identity: z14.string().min(1), at: z14.iso.datetime() });
+    PicksFileSchema = z14.strictObject({
+      schemaVersion: z14.literal(SCHEMA_VERSION),
+      picks: z14.record(z14.string().min(1), PickEntrySchema)
     });
   }
 });
@@ -7426,6 +7494,17 @@ 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) {
@@ -7474,6 +7553,9 @@ function applyProfileChange(paths, name, change) {
   if (change.launchExplain !== void 0) {
     launchPatch.explain = change.launchExplain;
   }
+  if (change.launchStatusline !== void 0) {
+    launchPatch.statusline = withStatuslineChange(readProfile(paths, name)?.launch?.statusline, change.launchStatusline);
+  }
   if (Object.keys(launchPatch).length > 0) {
     setProfileLaunchFlags(paths, name, launchPatch);
     touched = true;
@@ -7487,6 +7569,7 @@ var init_configProfilesStore = __esm({
     init_store();
     init_schema();
     init_cliError();
+    init_statusline();
     init_load();
     ProfileNotFoundError = class extends CliError {
       constructor(profileName) {
@@ -7598,7 +7681,7 @@ var init_paths = __esm({
 });
 
 // src/credentialCache.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function effectiveStore(cache, platform) {
   return cache.store ?? (platform === "darwin" ? "keychain" : "file");
 }
@@ -7665,9 +7748,9 @@ var init_credentialCache = __esm({
     init_schema();
     init_preflight();
     MS_PER_UNIT = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
-    CachedCredentialSchema = z14.strictObject({
-      token: z14.string().min(1),
-      fetchedAt: z14.number().int().nonnegative(),
+    CachedCredentialSchema = z15.strictObject({
+      token: z15.string().min(1),
+      fetchedAt: z15.number().int().nonnegative(),
       source: CredentialSourceSchema
     });
   }
@@ -7759,7 +7842,7 @@ var init_realCredentialCache = __esm({
 });
 
 // src/providerAliases.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 function parseAliases(file, raw) {
   const parsed = ProviderAliasesSchema.safeParse(raw);
   if (!parsed.success) {
@@ -7798,7 +7881,7 @@ var init_providerAliases = __esm({
     init_cliError();
     init_load();
     init_store();
-    ProviderAliasesSchema = z15.record(z15.string().min(1), z15.string().min(1));
+    ProviderAliasesSchema = z16.record(z16.string().min(1), z16.string().min(1));
   }
 });
 
@@ -8815,7 +8898,7 @@ var init_commandDeps = __esm({
 // src/claudeShim.ts
 import fs8 from "node:fs";
 import path28 from "node:path";
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 function commandFilename(ownExecutablePath, commandName) {
   return ownExecutablePath.toLowerCase().endsWith(".exe") ? `${commandName}.exe` : commandName;
 }
@@ -8865,10 +8948,10 @@ var init_claudeShim = __esm({
     init_store();
     init_realPorts();
     init_cliError();
-    ClaudeShimStateSchema = z20.strictObject({
-      targetPath: z20.string().min(1),
-      method: z20.enum(["hardlink", "copy"]),
-      installedAtMs: z20.number()
+    ClaudeShimStateSchema = z21.strictObject({
+      targetPath: z21.string().min(1),
+      method: z21.enum(["hardlink", "copy"]),
+      installedAtMs: z21.number()
     });
     nodeLinkFs = { link: fs8.linkSync, copyFile: fs8.copyFileSync, chmod: fs8.chmodSync };
   }
@@ -8964,62 +9047,62 @@ var init_signatures = __esm({
 });
 
 // src/codex/anthropic.ts
-import { z as z24 } from "zod";
+import { z as z25 } 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 = z24.looseObject({ type: z24.literal("text"), text: z24.string() });
-    Base64ImageSourceSchema = z24.looseObject({ type: z24.literal("base64"), media_type: z24.string().min(1), data: z24.string() });
-    UrlImageSourceSchema = z24.looseObject({ type: z24.literal("url"), url: z24.string().min(1) });
-    ImageBlockSchema = z24.looseObject({
-      type: z24.literal("image"),
-      source: z24.union([Base64ImageSourceSchema, UrlImageSourceSchema])
+    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])
     });
-    ToolUseBlockSchema = z24.looseObject({
-      type: z24.literal("tool_use"),
-      id: z24.string().min(1),
-      name: z24.string().min(1),
-      input: z24.unknown()
+    ToolUseBlockSchema = z25.looseObject({
+      type: z25.literal("tool_use"),
+      id: z25.string().min(1),
+      name: z25.string().min(1),
+      input: z25.unknown()
     });
-    ToolResultContentBlockSchema = z24.union([TextBlockSchema, z24.looseObject({ type: z24.string() })]);
-    ToolResultBlockSchema = z24.looseObject({
-      type: z24.literal("tool_result"),
-      tool_use_id: z24.string().min(1),
-      content: z24.union([z24.string(), z24.array(ToolResultContentBlockSchema)]).optional()
+    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()
     });
-    OtherBlockSchema = z24.looseObject({ type: z24.string() });
-    ContentBlockSchema = z24.union([TextBlockSchema, ImageBlockSchema, ToolUseBlockSchema, ToolResultBlockSchema, OtherBlockSchema]);
-    MessageSchema = z24.looseObject({
-      role: z24.enum(["user", "assistant", "system"]),
-      content: z24.union([z24.string(), z24.array(ContentBlockSchema)])
+    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)])
     });
-    ToolSchema = z24.looseObject({
-      name: z24.string().min(1),
-      description: z24.string().optional(),
-      input_schema: z24.record(z24.string(), z24.unknown()).optional()
+    ToolSchema = z25.looseObject({
+      name: z25.string().min(1),
+      description: z25.string().optional(),
+      input_schema: z25.record(z25.string(), z25.unknown()).optional()
     });
-    ToolChoiceSchema = z24.union([
-      z24.looseObject({ type: z24.enum(["auto", "none", "any"]) }),
-      z24.looseObject({ type: z24.literal("tool"), name: z24.string().min(1) })
+    ToolChoiceSchema = z25.union([
+      z25.looseObject({ type: z25.enum(["auto", "none", "any"]) }),
+      z25.looseObject({ type: z25.literal("tool"), name: z25.string().min(1) })
     ]);
-    SystemSchema = z24.union([z24.string(), z24.array(z24.union([TextBlockSchema, OtherBlockSchema]))]);
-    MessagesRequestSchema = z24.looseObject({
-      model: z24.string().optional(),
+    SystemSchema = z25.union([z25.string(), z25.array(z25.union([TextBlockSchema, OtherBlockSchema]))]);
+    MessagesRequestSchema = z25.looseObject({
+      model: z25.string().optional(),
       system: SystemSchema.optional(),
-      messages: z24.array(MessageSchema),
-      tools: z24.array(ToolSchema).optional(),
+      messages: z25.array(MessageSchema),
+      tools: z25.array(ToolSchema).optional(),
       tool_choice: ToolChoiceSchema.optional(),
-      stream: z24.boolean().optional(),
+      stream: z25.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: z24.looseObject({ user_id: z24.string().optional() }).optional(),
+      metadata: z25.looseObject({ user_id: z25.string().optional() }).optional(),
       /** Claude Code's effort setting. Any string is accepted; the translator honours only the levels the backend understands. */
-      output_config: z24.looseObject({ effort: z24.string().optional() }).optional()
+      output_config: z25.looseObject({ effort: z25.string().optional() }).optional()
     });
-    CountTokensRequestSchema = z24.looseObject({
-      system: z24.unknown().optional(),
-      messages: z24.unknown().optional(),
-      tools: z24.unknown().optional()
+    CountTokensRequestSchema = z25.looseObject({
+      system: z25.unknown().optional(),
+      messages: z25.unknown().optional(),
+      tools: z25.unknown().optional()
     });
   }
 });
@@ -9104,7 +9187,7 @@ var init_translate2 = __esm({
 // src/providerCatalogue.ts
 import path30 from "node:path";
 import picomatch4 from "picomatch";
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 function catalogueCachePath(paths, name) {
   return path30.join(paths.catalogueDir, `${name}.json`);
 }
@@ -9139,8 +9222,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 = z25.strictObject({ id: z25.string().min(1), name: z25.string().min(1).optional() });
-    CatalogueCacheSchema = z25.strictObject({ fetchedAt: z25.number(), url: z25.string().min(1), models: z25.array(CatalogueModelSchema) });
+    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) });
   }
 });
 
@@ -9971,9 +10054,40 @@ var init_headers = __esm({
   }
 });
 
+// src/statusline/settings.ts
+function checkedStatusline(settings, source) {
+  try {
+    resolveStatusline(settings);
+  } catch (error) {
+    throw new UsageError(`${source}: ${error instanceof Error ? error.message : String(error)}.`);
+  }
+  return settings;
+}
+function statuslineSettingsFromEnv(raw, source) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new UsageError(`${source}: not valid JSON.`);
+  }
+  const result = StatuslineSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new UsageError(`${source}: ${result.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ")}.`);
+  }
+  return checkedStatusline(result.data, source);
+}
+var init_settings2 = __esm({
+  "src/statusline/settings.ts"() {
+    "use strict";
+    init_cliError();
+    init_statusline();
+  }
+});
+
 // src/launcher/flags.ts
 import path37 from "node:path";
 function resolveLaunchFlags(params) {
+  const statusline = resolveStatuslineSettings(params);
   return {
     skipPermissions: params.flags?.skipPermissions ?? parseEnvBool("AGENT_SHIM_SKIP_PERMISSIONS", params.env.AGENT_SHIM_SKIP_PERMISSIONS) ?? params.cascade?.skipPermissions ?? false,
     remoteControl: params.flags?.remoteControl ?? parseEnvBool("AGENT_SHIM_REMOTE_CONTROL", params.env.AGENT_SHIM_REMOTE_CONTROL) ?? params.cascade?.remoteControl ?? false,
@@ -9982,9 +10096,17 @@ function resolveLaunchFlags(params) {
     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,
     delayMs: resolveDelayMs(params),
-    proxyBypass: resolveProxyBypass(params)
+    proxyBypass: resolveProxyBypass(params),
+    ...statusline === void 0 ? {} : { statusline }
   };
 }
+function resolveStatuslineSettings(params) {
+  const fromEnv = params.env[STATUSLINE_ENV] === "" ? void 0 : params.env[STATUSLINE_ENV];
+  if (fromEnv !== void 0) {
+    return statuslineSettingsFromEnv(fromEnv, STATUSLINE_ENV);
+  }
+  return params.cascade?.statusline === void 0 ? void 0 : checkedStatusline(params.cascade.statusline, "launch.statusline");
+}
 function resolveProxyBypass(params) {
   const fromEnv = params.env.AGENT_SHIM_PROXY_BYPASS === "" ? void 0 : params.env.AGENT_SHIM_PROXY_BYPASS;
   return fromEnv !== void 0 ? checkedProxyBypass(fromEnv.split(",").map((entry) => entry.trim()), "AGENT_SHIM_PROXY_BYPASS") : checkedProxyBypass(params.cascade?.proxyBypass ?? [], "launch.proxyBypass");
@@ -10068,6 +10190,9 @@ function buildEnv(params) {
     env.NO_PROXY = withBypassHosts(env.NO_PROXY, bypassed);
     env.no_proxy = withBypassHosts(env.no_proxy, bypassed);
   }
+  if (params.statusline !== void 0) {
+    env[STATUSLINE_ENV] = JSON.stringify(params.statusline);
+  }
   return env;
 }
 var LOOPBACK_HOSTS, PROVIDER_SESSION_PLACEHOLDER;
@@ -10082,6 +10207,8 @@ var init_flags = __esm({
     init_headers();
     init_capability();
     init_route();
+    init_statusline();
+    init_settings2();
     init_proxyBypass2();
     LOOPBACK_HOSTS = ["127.0.0.1", "localhost", "::1"];
     PROVIDER_SESSION_PLACEHOLDER = "agent-shim-provider-session";
@@ -11003,7 +11130,8 @@ function prepareLaunch(params) {
     sessionId,
     remoteControl: resolvedFlags.remoteControl,
     ...decided.models?.tiers === void 0 ? {} : { tierModels: decided.models.tiers },
-    proxyBypass: resolvedFlags.proxyBypass
+    proxyBypass: resolvedFlags.proxyBypass,
+    ...resolvedFlags.statusline === void 0 ? {} : { statusline: resolvedFlags.statusline }
   });
   const releases = [...headroom === void 0 || headroomPort === void 0 ? [] : [headroomPort.release], ...frontDoorRelease === void 0 ? [] : [frontDoorRelease]];
   const release = () => {
@@ -11031,7 +11159,8 @@ function resolveLaunch(params) {
     ...decided.flags.headroom ? { headroom: { socketPath: "", projectId: "" } } : {},
     sessionId: "",
     remoteControl: decided.flags.remoteControl,
-    proxyBypass: decided.flags.proxyBypass
+    proxyBypass: decided.flags.proxyBypass,
+    ...decided.flags.statusline === void 0 ? {} : { statusline: decided.flags.statusline }
   });
   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();
@@ -11589,7 +11718,7 @@ var init_identityClaude = __esm({
 });
 
 // src/usage/providerQuota.ts
-import { z as z32 } from "zod";
+import { z as z33 } 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"() {
@@ -11608,35 +11737,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 = z32.object({
-      type: z32.string(),
-      unit: z32.number().int(),
-      number: z32.number().int().positive(),
-      percentage: z32.number().nonnegative(),
-      nextResetTime: z32.number().positive().optional(),
-      usage: z32.number().nonnegative().optional(),
-      currentValue: z32.number().nonnegative().optional(),
-      remaining: z32.number().nonnegative().optional()
+    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()
     });
-    ZaiResponseSchema = z32.object({
-      success: z32.boolean(),
-      msg: z32.string().optional(),
-      data: z32.object({ level: z32.string().optional(), limits: z32.array(ZaiLimitSchema) })
+    ZaiResponseSchema = z33.object({
+      success: z33.boolean(),
+      msg: z33.string().optional(),
+      data: z33.object({ level: z33.string().optional(), limits: z33.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 = z32.object({
-      data: z32.object({
-        limit: z32.number().nonnegative().nullable(),
-        limit_remaining: z32.number().nullable(),
-        limit_reset: z32.string().nullable(),
-        is_free_tier: z32.boolean().optional(),
-        free_model_daily_requests: z32.object({ used: z32.number().nonnegative(), limit: z32.number().nonnegative(), remaining: z32.number() }).optional()
+    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()
       })
     });
-    OpenRouterCreditsSchema = z32.object({ data: z32.object({ total_credits: z32.number().nonnegative(), total_usage: z32.number().nonnegative() }) });
+    OpenRouterCreditsSchema = z33.object({ data: z33.object({ total_credits: z33.number().nonnegative(), total_usage: z33.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`;
@@ -11644,21 +11773,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 = z32.object({
-      bucketId: z32.string(),
-      remainingFraction: z32.number().optional(),
-      resetTime: z32.string().optional()
+    AntigravityBucketSchema = z33.object({
+      bucketId: z33.string(),
+      remainingFraction: z33.number().optional(),
+      resetTime: z33.string().optional()
     });
-    AntigravitySummarySchema = z32.object({ groups: z32.array(z32.object({ buckets: z32.array(AntigravityBucketSchema) })) });
-    GoogleTokenInfoSchema = z32.object({
-      email: z32.string().optional(),
-      sub: z32.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()
     });
-    AntigravityUserSchema = z32.object({
+    AntigravityUserSchema = z33.object({
       /** The code-assist tier context, which defaults to the free tier for every account. */
-      currentTier: z32.object({ name: z32.string().optional(), id: z32.string().optional() }).optional(),
+      currentTier: z33.object({ name: z33.string().optional(), id: z33.string().optional() }).optional(),
       /** The account's paid subscription; absent when the account has none. */
-      paidTier: z32.object({ name: z32.string().optional(), id: z32.string().optional() }).optional()
+      paidTier: z33.object({ name: z33.string().optional(), id: z33.string().optional() }).optional()
     });
   }
 });
@@ -11774,130 +11903,130 @@ var HTTP_STATUS = {
 init_connect();
 
 // src/agents/liveTasks.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/agents/schema.ts
-import { z as z4 } from "zod";
-var AgentMetaSchema = z4.looseObject({
-  agentType: z4.string(),
-  isFork: z4.boolean().optional(),
-  description: z4.string().optional(),
-  name: z4.string().optional(),
-  toolUseId: z4.string().optional(),
-  spawnDepth: z4.number().int().nonnegative().optional(),
-  parentAgentId: z4.string().optional(),
-  model: z4.string().optional(),
-  requestShape: z4.string().optional(),
-  requestNonInteractive: z4.boolean().optional(),
-  workflowPhase: z4.string().optional(),
-  taskKind: z4.string().optional(),
-  teamName: z4.string().optional(),
-  worktreePath: z4.string().optional(),
-  worktreeBranch: z4.string().optional(),
-  stoppedByUser: z4.boolean().optional()
+import { z as z5 } from "zod";
+var AgentMetaSchema = z5.looseObject({
+  agentType: z5.string(),
+  isFork: z5.boolean().optional(),
+  description: z5.string().optional(),
+  name: z5.string().optional(),
+  toolUseId: z5.string().optional(),
+  spawnDepth: z5.number().int().nonnegative().optional(),
+  parentAgentId: z5.string().optional(),
+  model: z5.string().optional(),
+  requestShape: z5.string().optional(),
+  requestNonInteractive: z5.boolean().optional(),
+  workflowPhase: z5.string().optional(),
+  taskKind: z5.string().optional(),
+  teamName: z5.string().optional(),
+  worktreePath: z5.string().optional(),
+  worktreeBranch: z5.string().optional(),
+  stoppedByUser: z5.boolean().optional()
 });
-var AgentKindSchema = z4.enum(["subagent", "fork", "workflow-agent", "teammate"]);
+var AgentKindSchema = z5.enum(["subagent", "fork", "workflow-agent", "teammate"]);
 var AgentNodeFields = {
-  id: z4.string(),
+  id: z5.string(),
   kind: AgentKindSchema,
-  agentType: z4.string(),
-  description: z4.string().optional(),
-  name: z4.string().optional(),
-  toolUseId: z4.string().optional(),
-  spawnDepth: z4.number().int().nonnegative().optional(),
-  model: z4.string().optional(),
-  background: z4.boolean().optional(),
-  workflowRunId: z4.string().optional(),
-  workflowPhase: z4.string().optional(),
-  teamName: z4.string().optional(),
-  stoppedByUser: z4.boolean().optional(),
-  transcript: z4.string()
+  agentType: z5.string(),
+  description: z5.string().optional(),
+  name: z5.string().optional(),
+  toolUseId: z5.string().optional(),
+  spawnDepth: z5.number().int().nonnegative().optional(),
+  model: z5.string().optional(),
+  background: z5.boolean().optional(),
+  workflowRunId: z5.string().optional(),
+  workflowPhase: z5.string().optional(),
+  teamName: z5.string().optional(),
+  stoppedByUser: z5.boolean().optional(),
+  transcript: z5.string()
 };
-var AgentNodeSchema = z4.lazy(() => z4.strictObject({ ...AgentNodeFields, children: z4.array(AgentNodeSchema) }));
-var TaskItemSchema = z4.strictObject({
-  id: z4.string(),
-  subject: z4.string(),
-  description: z4.string().optional(),
-  status: z4.string(),
+var AgentNodeSchema = z5.lazy(() => z5.strictObject({ ...AgentNodeFields, children: z5.array(AgentNodeSchema) }));
+var TaskItemSchema = z5.strictObject({
+  id: z5.string(),
+  subject: z5.string(),
+  description: z5.string().optional(),
+  status: z5.string(),
   /** What a spinner shows while the task runs. */
-  activeForm: z4.string().optional(),
+  activeForm: z5.string().optional(),
   /** The teammate or agent name the task is assigned to, as Agent Teams writes it. */
-  owner: z4.string().optional(),
+  owner: z5.string().optional(),
   /** Free-form data the harness attaches to a task, kept as written. */
-  metadata: z4.record(z4.string(), z4.unknown()).optional(),
-  blocks: z4.array(z4.string()),
-  blockedBy: z4.array(z4.string()),
+  metadata: z5.record(z5.string(), z5.unknown()).optional(),
+  blocks: z5.array(z5.string()),
+  blockedBy: z5.array(z5.string()),
   /** The id of the shared task list this task belongs to (a team's name, or a custom list id), absent for the session's own list. */
-  taskList: z4.string().optional()
+  taskList: z5.string().optional()
 });
-var WorkflowRunSchema = z4.strictObject({
-  runId: z4.string(),
-  workflowName: z4.string().optional(),
-  status: z4.string().optional(),
-  startTime: z4.number().optional(),
-  phases: z4.array(z4.string()),
-  summary: z4.string().optional()
+var WorkflowRunSchema = z5.strictObject({
+  runId: z5.string(),
+  workflowName: z5.string().optional(),
+  status: z5.string().optional(),
+  startTime: z5.number().optional(),
+  phases: z5.array(z5.string()),
+  summary: z5.string().optional()
 });
-var AgentTreeProblemSchema = z4.strictObject({
+var AgentTreeProblemSchema = z5.strictObject({
   /** Relative to the identity's configuration directory. */
-  path: z4.string(),
-  reason: z4.string()
+  path: z5.string(),
+  reason: z5.string()
 });
-var SessionSummarySchema = z4.strictObject({
-  project: z4.string(),
-  sessionId: z4.string(),
-  superseded: z4.boolean(),
+var SessionSummarySchema = z5.strictObject({
+  project: z5.string(),
+  sessionId: z5.string(),
+  superseded: z5.boolean(),
   /** The directory and transcript stem exactly as on disk, which differs from `sessionId` for a superseded session. */
-  entry: z4.string(),
-  agentCount: z4.number().int().nonnegative(),
-  workflowRunCount: z4.number().int().nonnegative(),
+  entry: z5.string(),
+  agentCount: z5.number().int().nonnegative(),
+  workflowRunCount: z5.number().int().nonnegative(),
   /** When the transcript was last written, as an ISO instant; absent when there is no transcript file. */
-  updatedAt: z4.iso.datetime().optional(),
-  identities: z4.array(z4.string())
+  updatedAt: z5.iso.datetime().optional(),
+  identities: z5.array(z5.string())
 });
-var SessionAgentTreeSchema = z4.strictObject({
-  project: z4.string(),
-  sessionId: z4.string(),
+var SessionAgentTreeSchema = z5.strictObject({
+  project: z5.string(),
+  sessionId: z5.string(),
   /** True for a session directory a resume superseded (`<session-id>.superseded-<epoch-ms>`). */
-  superseded: z4.boolean(),
+  superseded: z5.boolean(),
   /** The agents the session itself spawned, each with its descendants. */
-  agents: z4.array(AgentNodeSchema),
-  tasks: z4.array(TaskItemSchema),
-  workflowRuns: z4.array(WorkflowRunSchema),
-  problems: z4.array(AgentTreeProblemSchema)
+  agents: z5.array(AgentNodeSchema),
+  tasks: z5.array(TaskItemSchema),
+  workflowRuns: z5.array(WorkflowRunSchema),
+  problems: z5.array(AgentTreeProblemSchema)
 });
 
 // src/agents/liveTasks.ts
 var LIVE_TASK_CAP = 512;
 var RUNNING_STATUS = "running";
-var LiveTaskUsageSchema = z5.strictObject({
-  totalTokens: z5.number().optional(),
-  toolUses: z5.number().optional(),
-  durationMs: z5.number().optional()
+var LiveTaskUsageSchema = z6.strictObject({
+  totalTokens: z6.number().optional(),
+  toolUses: z6.number().optional(),
+  durationMs: z6.number().optional()
 });
-var LiveTaskSchema = z5.strictObject({
+var LiveTaskSchema = z6.strictObject({
   /** The `task_id`: for an unnamed subagent the stem of its `agent-<id>` files on disk. */
-  taskId: z5.string(),
+  taskId: z6.string(),
   /** The `cse_` session whose stream carried the task. */
-  sessionId: z5.string(),
-  runId: z5.string().optional(),
+  sessionId: z6.string(),
+  runId: z6.string().optional(),
   /** The `tool_use` block in the spawning transcript, which is the meta file's `toolUseId`. */
-  toolUseId: z5.string().optional(),
+  toolUseId: z6.string().optional(),
   /** `local_agent` for a subagent, `local_bash` for a backgrounded command; open because other kinds may exist. */
-  taskType: z5.string().optional(),
-  description: z5.string().optional(),
-  subagentType: z5.string().optional(),
-  spawnDepth: z5.number().int().nonnegative().optional(),
-  parentTaskId: z5.string().optional(),
-  backgrounded: z5.boolean().optional(),
-  status: z5.string(),
+  taskType: z6.string().optional(),
+  description: z6.string().optional(),
+  subagentType: z6.string().optional(),
+  spawnDepth: z6.number().int().nonnegative().optional(),
+  parentTaskId: z6.string().optional(),
+  backgrounded: z6.boolean().optional(),
+  status: z6.string(),
   /** `<tmpdir>/<project-slug>/<local session id>/tasks/<task_id>.output`, which embeds the local session id. */
-  outputFile: z5.string().optional(),
-  summary: z5.string().optional(),
-  lastToolName: z5.string().optional(),
+  outputFile: z6.string().optional(),
+  summary: z6.string().optional(),
+  lastToolName: z6.string().optional(),
   usage: LiveTaskUsageSchema.optional(),
   /** When the door last observed an event for this task, in epoch milliseconds from its injected clock. */
-  observedAt: z5.number()
+  observedAt: z6.number()
 });
 var SYSTEM_SUBTYPES = ["task_started", "task_progress", "task_updated", "task_notification", "background_tasks_changed"];
 function isRecord3(value) {
@@ -11996,22 +12125,22 @@ function applyAgentTaskEvent(book, sessionId, payload, observedAt2) {
   }
   return bounded(next);
 }
-var MergedProvenanceSchema = z5.enum(["disk", "both"]);
-var MergedAgentNodeSchema = z5.lazy(
-  () => z5.strictObject({
+var MergedProvenanceSchema = z6.enum(["disk", "both"]);
+var MergedAgentNodeSchema = z6.lazy(
+  () => z6.strictObject({
     ...AgentNodeFields,
     provenance: MergedProvenanceSchema,
     live: LiveTaskSchema.optional(),
-    children: z5.array(MergedAgentNodeSchema)
+    children: z6.array(MergedAgentNodeSchema)
   })
 );
-var MergedAgentTreeSchema = z5.strictObject({
+var MergedAgentTreeSchema = z6.strictObject({
   ...SessionAgentTreeSchema.shape,
-  agents: z5.array(MergedAgentNodeSchema),
+  agents: z6.array(MergedAgentNodeSchema),
   /** The `cse_` sessions whose live tasks matched this session. Empty when the session is not live or the door has not observed it. */
-  remoteSessions: z5.array(z5.string()),
+  remoteSessions: z6.array(z6.string()),
   /** Live tasks of those sessions that match no disk agent (a backgrounded command, or an agent whose files have not appeared yet). */
-  liveOnly: z5.array(LiveTaskSchema)
+  liveOnly: z6.array(LiveTaskSchema)
 });
 function mergeLiveTasks(tree, live) {
   const byTaskId = new Map(live.map((task) => [task.taskId, task]));
@@ -13882,162 +14011,162 @@ import { Agent as Agent3, fetch as undiciFetch } from "undici";
 init_capability();
 
 // src/frontdoor/rcSchemas.ts
-import { z as z6 } from "zod";
-var RcPermissionModeSchema = z6.enum(RC_PERMISSION_MODES);
-var RcSessionSummarySchema = z6.strictObject({
-  id: z6.string(),
-  createdAt: z6.number(),
-  lastSeenAt: z6.number()
+import { z as z7 } from "zod";
+var RcPermissionModeSchema = z7.enum(RC_PERMISSION_MODES);
+var RcSessionSummarySchema = z7.strictObject({
+  id: z7.string(),
+  createdAt: z7.number(),
+  lastSeenAt: z7.number()
 });
 function workerFactSchema(value) {
-  return z6.strictObject({ value, observedAt: z6.number() });
-}
-var RcPendingRequestSummarySchema = z6.strictObject({
-  sessionId: z6.string(),
-  requestId: z6.string(),
-  type: z6.string(),
-  summary: z6.string(),
-  observedAt: z6.number()
+  return z7.strictObject({ value, observedAt: z7.number() });
+}
+var RcPendingRequestSummarySchema = z7.strictObject({
+  sessionId: z7.string(),
+  requestId: z7.string(),
+  type: z7.string(),
+  summary: z7.string(),
+  observedAt: z7.number()
 });
-var RcSessionStatusSchema = z6.strictObject({
+var RcSessionStatusSchema = z7.strictObject({
   ...RcSessionSummarySchema.shape,
-  workerState: workerFactSchema(z6.string()).optional(),
-  workerIdleSeconds: workerFactSchema(z6.number()).optional(),
-  pending: z6.readonly(z6.array(RcPendingRequestSummarySchema))
+  workerState: workerFactSchema(z7.string()).optional(),
+  workerIdleSeconds: workerFactSchema(z7.number()).optional(),
+  pending: z7.readonly(z7.array(RcPendingRequestSummarySchema))
 });
-var RcStreamEnvelopeSchema = z6.looseObject({
+var RcStreamEnvelopeSchema = z7.looseObject({
   /** The envelope's own event id, when the host sent one. */
-  event_id: z6.string().optional(),
+  event_id: z7.string().optional(),
   /** The envelope's event type, the discriminator a consumer switches on (`control_request`, `user`, and kin). */
-  event_type: z6.string(),
+  event_type: z7.string(),
   /** The sequence number the host assigned, the value a resume continues after. */
-  sequence_num: z6.int(),
+  sequence_num: z7.int(),
   /** Who emitted the event (`worker` for the CLI's half, a client id for a client's). */
-  source: z6.string(),
+  source: z7.string(),
   /** The event's payload, carried verbatim: its shape is the payload family's, narrowed by whichever consumer needs it. Optional in the schema's own type because the door forwards the host's envelope as it arrived, asserting only the fields it relies on itself. */
-  payload: z6.unknown().optional(),
+  payload: z7.unknown().optional(),
   /** When the host created the event; the protocol's own type for this field is not established here, so it is forwarded rather than asserted. */
-  created_at: z6.unknown().optional()
+  created_at: z7.unknown().optional()
 });
-var RcStreamEventSchema = z6.strictObject({
-  session: z6.string(),
+var RcStreamEventSchema = z7.strictObject({
+  session: z7.string(),
   envelope: RcStreamEnvelopeSchema
 });
-var RcRateLimitWindowSchema = z6.looseObject({
+var RcRateLimitWindowSchema = z7.looseObject({
   /** The fraction of the window used, usually between 0 and 1, above 1 when usage legitimately runs past the window's cap (the CLI's own field description states both). */
-  utilization: z6.number().optional(),
+  utilization: z7.number().optional(),
   /** When the window resets, in unix epoch seconds: the unit is the CLI's own field description, stated in the 2.1.289 bundle's schema. */
-  resetsAt: z6.number().optional()
+  resetsAt: z7.number().optional()
 });
-var RcRateLimitInfoSchema = z6.looseObject({
+var RcRateLimitInfoSchema = z7.looseObject({
   /** The limiting window's own status (`allowed`, `allowed_warning`, `rejected`), asserted only as a string because the vocabulary grows with the CLI. */
-  status: z6.string(),
+  status: z7.string(),
   /** When the limiting window resets, in unix epoch seconds. */
-  resetsAt: z6.number().optional(),
+  resetsAt: z7.number().optional(),
   /** Which window the top-level fields describe (`five_hour`, `seven_day`, and kin), the payload's own name for it. */
-  rateLimitType: z6.string().optional(),
+  rateLimitType: z7.string().optional(),
   /** The fraction of the limiting window used, on the same scale the per-window utilizations carry. */
-  utilization: z6.number().optional(),
+  utilization: z7.number().optional(),
   /** Whether usage beyond the plan (extra usage) is currently covering the overflow, the payload's own flag for it. */
-  isUsingOverage: z6.boolean().optional(),
+  isUsingOverage: z7.boolean().optional(),
   /** The overage's own status, the same vocabulary the limiting window's `status` carries. */
-  overageStatus: z6.string().optional(),
+  overageStatus: z7.string().optional(),
   /** When the overage window resets, in unix epoch seconds. */
-  overageResetsAt: z6.number().optional(),
+  overageResetsAt: z7.number().optional(),
   /** Each subscription window the account's response headers carried: the session (five-hour), weekly (seven-day), and overage-included weekly windows, each present only when the account's responses carry it. */
-  unifiedWindows: z6.looseObject({ five_hour: RcRateLimitWindowSchema.optional(), seven_day: RcRateLimitWindowSchema.optional(), seven_day_overage_included: RcRateLimitWindowSchema.optional() }).optional()
+  unifiedWindows: z7.looseObject({ five_hour: RcRateLimitWindowSchema.optional(), seven_day: RcRateLimitWindowSchema.optional(), seven_day_overage_included: RcRateLimitWindowSchema.optional() }).optional()
 });
-var RcLiveRateLimitSchema = z6.strictObject({
-  session: z6.string(),
-  observedAt: z6.number(),
+var RcLiveRateLimitSchema = z7.strictObject({
+  session: z7.string(),
+  observedAt: z7.number(),
   rateLimit: RcRateLimitInfoSchema
 });
-var RcSessionQuerySchema = z6.strictObject({
-  session: z6.string().min(1).optional()
+var RcSessionQuerySchema = z7.strictObject({
+  session: z7.string().min(1).optional()
 });
-var RcSendInputSchema = z6.strictObject({
-  session: z6.string().min(1),
-  text: z6.string().min(1)
+var RcSendInputSchema = z7.strictObject({
+  session: z7.string().min(1),
+  text: z7.string().min(1)
 });
-var RcAnswerInputSchema = z6.strictObject({
-  session: z6.string().min(1),
-  request: z6.string().min(1),
-  approve: z6.boolean(),
-  text: z6.string().optional()
+var RcAnswerInputSchema = z7.strictObject({
+  session: z7.string().min(1),
+  request: z7.string().min(1),
+  approve: z7.boolean(),
+  text: z7.string().optional()
 }).refine((input) => !input.approve || input.text === void 0 || input.text === "", { message: "an approval carries no text (the protocol's allow result has no message field); text is the denial message" });
-var RcInterruptInputSchema = z6.strictObject({
-  session: z6.string().min(1)
+var RcInterruptInputSchema = z7.strictObject({
+  session: z7.string().min(1)
 });
-var RcSetModelInputSchema = z6.strictObject({
-  session: z6.string().min(1),
-  model: z6.string().min(1)
+var RcSetModelInputSchema = z7.strictObject({
+  session: z7.string().min(1),
+  model: z7.string().min(1)
 });
-var RcSetPermissionModeInputSchema = z6.strictObject({
-  session: z6.string().min(1),
+var RcSetPermissionModeInputSchema = z7.strictObject({
+  session: z7.string().min(1),
   mode: RcPermissionModeSchema
 });
-var RcEndSessionInputSchema = z6.strictObject({
-  session: z6.string().min(1),
-  reason: z6.string().min(1).optional()
+var RcEndSessionInputSchema = z7.strictObject({
+  session: z7.string().min(1),
+  reason: z7.string().min(1).optional()
 });
-var RcGetUsageInputSchema = z6.strictObject({
-  session: z6.string().min(1),
-  skipBehaviors: z6.boolean().optional()
+var RcGetUsageInputSchema = z7.strictObject({
+  session: z7.string().min(1),
+  skipBehaviors: z7.boolean().optional()
 });
-var RcGetContextUsageInputSchema = z6.strictObject({
-  session: z6.string().min(1),
-  detail: z6.enum(RC_CONTEXT_USAGE_DETAILS).optional()
+var RcGetContextUsageInputSchema = z7.strictObject({
+  session: z7.string().min(1),
+  detail: z7.enum(RC_CONTEXT_USAGE_DETAILS).optional()
 });
-var RcReadFileInputSchema = z6.strictObject({
-  session: z6.string().min(1),
-  path: z6.string().min(1),
-  maxBytes: z6.number().int().positive().optional(),
-  encoding: z6.enum(RC_READ_FILE_ENCODINGS).optional()
+var RcReadFileInputSchema = z7.strictObject({
+  session: z7.string().min(1),
+  path: z7.string().min(1),
+  maxBytes: z7.number().int().positive().optional(),
+  encoding: z7.enum(RC_READ_FILE_ENCODINGS).optional()
 });
-var RcFileSuggestionsInputSchema = z6.strictObject({
-  session: z6.string().min(1),
-  query: z6.string()
+var RcFileSuggestionsInputSchema = z7.strictObject({
+  session: z7.string().min(1),
+  query: z7.string()
 });
-var RcKeepAliveInputSchema = z6.strictObject({
-  session: z6.string().min(1)
+var RcKeepAliveInputSchema = z7.strictObject({
+  session: z7.string().min(1)
 });
-var RcMcpStatusInputSchema = z6.strictObject({
-  session: z6.string().min(1)
+var RcMcpStatusInputSchema = z7.strictObject({
+  session: z7.string().min(1)
 });
-var RcMcpReconnectInputSchema = z6.strictObject({
-  session: z6.string().min(1),
-  serverName: z6.string().min(1)
+var RcMcpReconnectInputSchema = z7.strictObject({
+  session: z7.string().min(1),
+  serverName: z7.string().min(1)
 });
-var RcMcpAuthenticateInputSchema = z6.strictObject({
-  session: z6.string().min(1),
-  serverName: z6.string().min(1),
-  redirectUri: z6.string().min(1)
+var RcMcpAuthenticateInputSchema = z7.strictObject({
+  session: z7.string().min(1),
+  serverName: z7.string().min(1),
+  redirectUri: z7.string().min(1)
 });
-var RcMcpOAuthCallbackUrlInputSchema = z6.strictObject({
-  session: z6.string().min(1),
-  serverName: z6.string().min(1),
-  callbackUrl: z6.string().min(1)
+var RcMcpOAuthCallbackUrlInputSchema = z7.strictObject({
+  session: z7.string().min(1),
+  serverName: z7.string().min(1),
+  callbackUrl: z7.string().min(1)
 });
-var RcTeleportInputSchema = z6.strictObject({
-  session: z6.string().min(1),
-  marker: z6.string().min(1)
+var RcTeleportInputSchema = z7.strictObject({
+  session: z7.string().min(1),
+  marker: z7.string().min(1)
 });
-var RcListOutputSchema = z6.strictObject({ sessions: z6.readonly(z6.array(RcSessionSummarySchema)) });
-var RcStatusOutputSchema = z6.strictObject({ statuses: z6.readonly(z6.array(RcSessionStatusSchema)) });
-var RcPendingOutputSchema = z6.strictObject({ pending: z6.readonly(z6.array(RcPendingRequestSummarySchema)) });
-var RcWriteOutputSchema = z6.strictObject({
-  session: z6.string(),
-  sequenceNums: z6.readonly(z6.array(z6.number()))
+var RcListOutputSchema = z7.strictObject({ sessions: z7.readonly(z7.array(RcSessionSummarySchema)) });
+var RcStatusOutputSchema = z7.strictObject({ statuses: z7.readonly(z7.array(RcSessionStatusSchema)) });
+var RcPendingOutputSchema = z7.strictObject({ pending: z7.readonly(z7.array(RcPendingRequestSummarySchema)) });
+var RcWriteOutputSchema = z7.strictObject({
+  session: z7.string(),
+  sequenceNums: z7.readonly(z7.array(z7.number()))
 });
-var RcControlWriteOutputSchema = z6.strictObject({
-  session: z6.string(),
-  request: z6.string(),
-  sequenceNums: z6.readonly(z6.array(z6.number()))
+var RcControlWriteOutputSchema = z7.strictObject({
+  session: z7.string(),
+  request: z7.string(),
+  sequenceNums: z7.readonly(z7.array(z7.number()))
 });
-var RcAnswerOutputSchema = z6.strictObject({
-  session: z6.string(),
-  request: z6.string(),
-  sequenceNums: z6.readonly(z6.array(z6.number()))
+var RcAnswerOutputSchema = z7.strictObject({
+  session: z7.string(),
+  request: z7.string(),
+  sequenceNums: z7.readonly(z7.array(z7.number()))
 });
 
 // src/frontdoor/rcApi.ts
@@ -14224,48 +14353,48 @@ init_cliError();
 init_package();
 
 // src/codex/appServerSchemas.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var CODEX_APP_SERVER_GENERATED_AGAINST = "0.160.0";
-var RateLimitWindowSchema = z7.object({
-  usedPercent: z7.number(),
-  resetsAt: z7.number().nullish(),
-  windowDurationMins: z7.number().nullish()
+var RateLimitWindowSchema = z8.object({
+  usedPercent: z8.number(),
+  resetsAt: z8.number().nullish(),
+  windowDurationMins: z8.number().nullish()
 });
-var RateLimitSnapshotSchema = z7.object({
-  limitId: z7.string().nullish(),
-  limitName: z7.string().nullish(),
-  planType: z7.string().nullish(),
+var RateLimitSnapshotSchema = z8.object({
+  limitId: z8.string().nullish(),
+  limitName: z8.string().nullish(),
+  planType: z8.string().nullish(),
   primary: RateLimitWindowSchema.nullish(),
   secondary: RateLimitWindowSchema.nullish(),
-  rateLimitReachedType: z7.string().nullish(),
-  spendControlReached: z7.boolean().nullish()
+  rateLimitReachedType: z8.string().nullish(),
+  spendControlReached: z8.boolean().nullish()
 });
-var RateLimitResetCreditSchema = z7.object({
-  id: z7.string(),
-  grantedAt: z7.number(),
-  expiresAt: z7.number().nullish(),
-  resetType: z7.string(),
-  status: z7.string(),
-  title: z7.string().nullish(),
-  description: z7.string().nullish()
+var RateLimitResetCreditSchema = z8.object({
+  id: z8.string(),
+  grantedAt: z8.number(),
+  expiresAt: z8.number().nullish(),
+  resetType: z8.string(),
+  status: z8.string(),
+  title: z8.string().nullish(),
+  description: z8.string().nullish()
 });
-var CodexAccountSchema = z7.discriminatedUnion("type", [
-  z7.object({ type: z7.literal("apiKey") }),
-  z7.object({ type: z7.literal("chatgpt"), email: z7.string().nullable(), planType: z7.string() }),
-  z7.object({ type: z7.literal("amazonBedrock"), usesCodexManagedCredentials: z7.boolean().default(false) })
+var CodexAccountSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("apiKey") }),
+  z8.object({ type: z8.literal("chatgpt"), email: z8.string().nullable(), planType: z8.string() }),
+  z8.object({ type: z8.literal("amazonBedrock"), usesCodexManagedCredentials: z8.boolean().default(false) })
 ]);
-var CodexAccountReadSchema = z7.object({
+var CodexAccountReadSchema = z8.object({
   account: CodexAccountSchema.nullable(),
-  requiresOpenaiAuth: z7.boolean()
+  requiresOpenaiAuth: z8.boolean()
 });
-var CodexRateLimitsReadSchema = z7.object({
+var CodexRateLimitsReadSchema = z8.object({
   rateLimits: RateLimitSnapshotSchema,
-  rateLimitsByLimitId: z7.record(z7.string(), RateLimitSnapshotSchema).nullish(),
-  rateLimitResetCredits: z7.object({ availableCount: z7.number(), credits: z7.array(RateLimitResetCreditSchema).nullish() }).nullish(),
-  accountId: z7.string().nullish(),
-  ordinaryUsageAllowed: z7.boolean().nullish()
+  rateLimitsByLimitId: z8.record(z8.string(), RateLimitSnapshotSchema).nullish(),
+  rateLimitResetCredits: z8.object({ availableCount: z8.number(), credits: z8.array(RateLimitResetCreditSchema).nullish() }).nullish(),
+  accountId: z8.string().nullish(),
+  ordinaryUsageAllowed: z8.boolean().nullish()
 });
-var CodexInitializeResultSchema = z7.object({ userAgent: z7.string() });
+var CodexInitializeResultSchema = z8.object({ userAgent: z8.string() });
 
 // src/codex/appServer.ts
 var CodexAppServerUnavailableError = class extends CliError {
@@ -14705,7 +14834,7 @@ init_providersStore();
 init_projects();
 init_pipeline();
 import path27 from "node:path";
-import { z as z16 } from "zod";
+import { z as z17 } 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;
@@ -14774,9 +14903,9 @@ function lookupKeychainService(run, farmRoot) {
   }
   return { checked: true, found: true, serviceName, note: `Keychain service name for this identity: "${serviceName}".` };
 }
-var SettingsSecretsShapeSchema = z16.looseObject({
-  env: z16.record(z16.string(), z16.unknown()).optional(),
-  hooks: z16.record(z16.string(), z16.array(z16.unknown())).optional()
+var SettingsSecretsShapeSchema = z17.looseObject({
+  env: z17.record(z17.string(), z17.unknown()).optional(),
+  hooks: z17.record(z17.string(), z17.array(z17.unknown())).optional()
 });
 function hookCommandCountOf(group) {
   if (typeof group !== "object" || group === null) {
@@ -15073,7 +15202,7 @@ init_schema();
 init_claudeVersion();
 init_identity();
 init_projects();
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/resolve/types.ts
 var LAYER_KINDS = [
@@ -15134,123 +15263,123 @@ var DIAGNOSTIC_SEVERITIES = ["error", "warning", "info"];
 
 // src/usage/pickReportSchema.ts
 init_plan2();
-import { z as z17 } from "zod";
-var PoolPickCandidateViewSchema = z17.strictObject({
-  identity: z17.string(),
+import { z as z18 } from "zod";
+var PoolPickCandidateViewSchema = z18.strictObject({
+  identity: z18.string(),
   /** In pick order: `scored` has usable quota data, `unknown` has none, `pay-per-use` bills by use, `ineligible` is refused right now. */
-  class: z17.enum(["scored", "unknown", "pay-per-use", "ineligible"]),
+  class: z18.enum(["scored", "unknown", "pay-per-use", "ineligible"]),
   /** Plan-size-weighted remaining quota per hour until its reset; present for `scored` only. */
-  score: z17.number().optional(),
+  score: z18.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: z17.enum(["sevenDay", "fiveHour"]).optional(),
+  scoreWindow: z18.enum(["sevenDay", "fiveHour"]).optional(),
   /** False when the five-hour window would run dry, at the observed pace, before it resets. */
-  feasible: z17.boolean(),
+  feasible: z18.boolean(),
   /** When an `ineligible` member can be used again, as an ISO instant. */
-  blockedUntil: z17.iso.datetime().optional(),
+  blockedUntil: z18.iso.datetime().optional(),
   plan: PlanClassSchema,
   /** The facts behind the class and score, in the order they matter. */
-  reasons: z17.array(z17.string())
+  reasons: z18.array(z18.string())
 });
-var PoolPickReportSchema = z17.strictObject({
-  pool: z17.string(),
-  directory: z17.string(),
+var PoolPickReportSchema = z18.strictObject({
+  pool: z18.string(),
+  directory: z18.string(),
   /** The member a launch would run as, absent when every member is refused. */
-  pick: z17.string().optional(),
-  candidates: z17.array(PoolPickCandidateViewSchema),
+  pick: z18.string().optional(),
+  candidates: z18.array(PoolPickCandidateViewSchema),
   /** Identity members anywhere in the pool's graph that do not exist; a launch skips them. */
-  missing: z17.array(z17.string()),
+  missing: z18.array(z18.string()),
   /** When nothing can be picked, the soonest any member returns. */
-  earliestReturn: z17.strictObject({ identity: z17.string(), at: z17.iso.datetime() }).optional(),
+  earliestReturn: z18.strictObject({ identity: z18.string(), at: z18.iso.datetime() }).optional(),
   /** The member a resumed conversation started on but moved off, and why, when the ranking could not keep it. */
-  movedOff: z17.strictObject({ identity: z17.string(), reason: z17.string() }).optional(),
+  movedOff: z18.strictObject({ identity: z18.string(), reason: z18.string() }).optional(),
   /** Why the last-pick record could not be read, when that is the case. */
-  stickyProblem: z17.string().optional()
+  stickyProblem: z18.string().optional()
 });
 
 // src/checkReportSchema.ts
 var CHECK_CREDENTIAL_APPLIES = ["provider", "identity", "stored-login"];
-var CheckLayerViewSchema = z18.strictObject({
-  id: z18.int(),
-  kind: z18.enum(LAYER_KINDS),
-  source: z18.string()
+var CheckLayerViewSchema = z19.strictObject({
+  id: z19.int(),
+  kind: z19.enum(LAYER_KINDS),
+  source: z19.string()
 });
-var CheckEntryViewSchema = z18.strictObject({
-  path: z18.string(),
-  shared: z18.boolean(),
-  via: z18.enum(DECISION_VIAS),
+var CheckEntryViewSchema = z19.strictObject({
+  path: z19.string(),
+  shared: z19.boolean(),
+  via: z19.enum(DECISION_VIAS),
   /** The entry's real category, or null when nothing classifies it. */
-  category: z18.enum(CATEGORY_NAMES).nullable(),
-  rule: z18.strictObject({ key: z18.string(), layer: z18.int() }).optional(),
+  category: z19.enum(CATEGORY_NAMES).nullable(),
+  rule: z19.strictObject({ key: z19.string(), layer: z19.int() }).optional(),
   /** Rules that matched but whose `when` condition failed, each with the conditions that failed. */
-  eliminated: z18.readonly(z18.array(z18.strictObject({ key: z18.string(), failed: z18.readonly(z18.array(z18.string())) }))).optional()
+  eliminated: z19.readonly(z19.array(z19.strictObject({ key: z19.string(), failed: z19.readonly(z19.array(z19.string())) }))).optional()
 });
-var CheckDiagnosticSchema = z18.strictObject({
-  code: z18.enum(DIAGNOSTIC_CODES),
-  severity: z18.enum(DIAGNOSTIC_SEVERITIES),
-  message: z18.string(),
-  subject: z18.string().optional(),
-  layer: z18.int().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 CheckAmbientCredentialSchema = z18.union([z18.strictObject({ ok: z18.literal(true) }), z18.strictObject({ ok: z18.literal(false), variable: z18.string(), message: z18.string() })]);
-var CheckKeychainSchema = z18.strictObject({
-  checked: z18.literal(true),
-  found: z18.boolean(),
-  serviceName: z18.string().optional(),
-  note: z18.string()
+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 CheckSettingsExposureSchema = z18.strictObject({
-  file: z18.string(),
-  envKeyNames: z18.readonly(z18.array(z18.string())),
-  hookEventNames: z18.readonly(z18.array(z18.string())),
-  hookCommandCount: z18.int().nonnegative()
+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 CredentialSourceSummarySchema = z18.union([
-  z18.strictObject({ kind: z18.literal("env"), variable: z18.string() }),
-  z18.strictObject({ kind: z18.literal("file"), path: z18.string() }),
-  z18.strictObject({ kind: z18.literal("command"), program: z18.string() }),
-  z18.strictObject({ kind: z18.literal("op"), reference: z18.string() }),
-  z18.strictObject({ kind: z18.literal("keychain"), service: z18.string(), account: z18.string().optional() }),
-  z18.strictObject({ kind: z18.literal("literal") })
+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 CredentialSummarySchema = z18.strictObject({
-  target: z18.enum(CREDENTIAL_TARGETS),
-  sources: z18.readonly(z18.array(CredentialSourceSummarySchema)),
+var CredentialSummarySchema = z19.strictObject({
+  target: z19.enum(CREDENTIAL_TARGETS),
+  sources: z19.readonly(z19.array(CredentialSourceSummarySchema)),
   cache: CredentialCacheSchema.optional()
 });
-var CachedCredentialStateSchema = z18.union([
-  z18.strictObject({ store: z18.enum(CREDENTIAL_CACHE_STORES), status: z18.literal("empty") }),
-  z18.strictObject({ store: z18.enum(CREDENTIAL_CACHE_STORES), status: z18.literal("unreadable"), reason: z18.string() }),
-  z18.strictObject({ store: z18.enum(CREDENTIAL_CACHE_STORES), status: z18.enum(["fresh", "expired"]), ageMs: z18.number(), expiresInMs: z18.number().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 CheckCredentialProviderSchema = z18.union([
-  z18.strictObject({ name: z18.string(), credential: CredentialSummarySchema.optional(), cached: CachedCredentialStateSchema.optional() }),
-  z18.strictObject({ name: z18.string(), problem: z18.string() })
+var CheckCredentialProviderSchema = z19.union([
+  z19.strictObject({ name: z19.string(), credential: CredentialSummarySchema.optional(), cached: CachedCredentialStateSchema.optional() }),
+  z19.strictObject({ name: z19.string(), problem: z19.string() })
 ]);
-var CheckCredentialSchema = z18.strictObject({
-  applies: z18.enum(CHECK_CREDENTIAL_APPLIES),
+var CheckCredentialSchema = z19.strictObject({
+  applies: z19.enum(CHECK_CREDENTIAL_APPLIES),
   provider: CheckCredentialProviderSchema.optional(),
   identity: CredentialSummarySchema.optional(),
   identityCached: CachedCredentialStateSchema.optional()
 });
-var CheckClaudeVersionSchema = z18.strictObject({
-  pinned: z18.strictObject({ version: z18.string(), source: z18.enum(CLAUDE_VERSION_SOURCES), installed: z18.boolean() }).optional(),
-  highestInstalled: z18.string().optional(),
-  installed: z18.readonly(z18.array(z18.string()))
+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 CheckReportJsonSchema = z18.strictObject({
-  identity: z18.strictObject({ name: z18.string().nullable(), source: z18.enum(IDENTITY_DECISION_SOURCES) }),
+var CheckReportJsonSchema = z19.strictObject({
+  identity: z19.strictObject({ name: z19.string().nullable(), source: z19.enum(IDENTITY_DECISION_SOURCES) }),
   /** The pool ranking, when the launch named a pool instead of an identity. */
   pool: PoolPickReportSchema.optional(),
-  configProfile: z18.strictObject({ name: z18.string().nullable(), source: z18.enum(CONFIG_PROFILE_DECISION_SOURCES) }),
-  layers: z18.readonly(z18.array(CheckLayerViewSchema)),
-  entries: z18.readonly(z18.array(CheckEntryViewSchema)),
-  projectEncodingAmbiguities: z18.readonly(
-    z18.array(z18.strictObject({ fragment: z18.string(), encoded: z18.string(), reason: z18.enum(ENCODING_AMBIGUITY_REASONS), detail: z18.string() }))
+  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() }))
   ),
-  diagnostics: z18.readonly(z18.array(CheckDiagnosticSchema)),
+  diagnostics: z19.readonly(z19.array(CheckDiagnosticSchema)),
   ambientCredential: CheckAmbientCredentialSchema,
   keychain: CheckKeychainSchema.optional(),
-  settingsExposure: z18.readonly(z18.array(CheckSettingsExposureSchema)),
+  settingsExposure: z19.readonly(z19.array(CheckSettingsExposureSchema)),
   credential: CheckCredentialSchema,
   claudeVersion: CheckClaudeVersionSchema.optional()
 });
@@ -15310,28 +15439,28 @@ function collectResets(snapshots, nowMs) {
 }
 
 // src/usage/resetsSchema.ts
-import { z as z19 } from "zod";
-var ResetRowSchema = z19.strictObject({
-  identity: z19.string(),
-  provider: z19.string(),
+import { z as z20 } from "zod";
+var ResetRowSchema = z20.strictObject({
+  identity: z20.string(),
+  provider: z20.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: z19.string(),
+  window: z20.string(),
   /** When the state the window comes from was observed, as an ISO instant. */
-  observedAt: z19.iso.datetime(),
+  observedAt: z20.iso.datetime(),
   /** When the window resets, as an ISO instant; absent when the upstream reported none. */
-  resetsAt: z19.iso.datetime().optional(),
+  resetsAt: z20.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: z19.boolean(),
+  reset: z20.boolean(),
   /** The fraction used, as `effectiveWindow` reads it at the report's own clock. */
-  utilization: z19.number().optional(),
+  utilization: z20.number().optional(),
   /** The window's own status, for a window that has not reset yet. */
-  status: z19.string().optional()
+  status: z20.string().optional()
 });
-var ResetScheduleSchema = z19.strictObject({ resets: z19.readonly(z19.array(ResetRowSchema)) });
+var ResetScheduleSchema = z20.strictObject({ resets: z20.readonly(z20.array(ResetRowSchema)) });
 
 // src/frontdoor/controlSchemas.ts
 import path32 from "node:path";
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/doctorReport.ts
 init_claudeShim();
@@ -15511,24 +15640,24 @@ import path31 from "node:path";
 init_signIn();
 
 // src/codex/siwcStore.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/codex/auth.ts
-import { z as z21 } from "zod";
-var AuthFileSchema = z21.looseObject({
-  tokens: z21.looseObject({
-    access_token: z21.string().optional(),
-    refresh_token: z21.string().optional(),
-    id_token: z21.string().optional(),
-    account_id: z21.string().optional()
+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()
   }).nullish(),
-  last_refresh: z21.string().optional()
+  last_refresh: z22.string().optional()
 });
-var TokenGrantSchema = z21.looseObject({
-  access_token: z21.string().min(1).optional(),
-  refresh_token: z21.string().min(1).optional(),
-  id_token: z21.string().min(1).optional(),
-  account_id: z21.string().min(1).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 CodexAuthError = class extends Error {
   constructor(message) {
@@ -15538,41 +15667,41 @@ var CodexAuthError = class extends Error {
 };
 
 // src/codex/siwc.ts
-import { z as z22 } from "zod";
+import { z as z23 } 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 = z22.looseObject({
-  access_token: z22.string().min(1),
-  refresh_token: z22.string().min(1).optional(),
-  id_token: z22.string().min(1).optional(),
-  expires_in: z22.number().positive(),
-  scope: z22.string().optional()
+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 JwtHeaderSchema = z22.looseObject({ alg: z22.string(), kid: z22.string().optional() });
-var IdTokenClaimsSchema = z22.looseObject({
-  iss: z22.string(),
-  sub: z22.string().min(1),
-  aud: z22.union([z22.string(), z22.array(z22.string())]),
-  exp: z22.number(),
-  nonce: z22.string().optional(),
-  email: z22.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 JwksSchema = z22.object({ keys: z22.array(z22.looseObject({ kid: z22.string().optional(), kty: z22.string() })) });
+var JwksSchema = z23.object({ keys: z23.array(z23.looseObject({ kid: z23.string().optional(), kty: z23.string() })) });
 
 // src/codex/siwcStore.ts
-var SiwcGrantSchema = z23.strictObject({
-  clientId: z23.string().min(1),
-  sub: z23.string().min(1),
-  email: z23.string().optional(),
-  idToken: z23.string().min(1),
-  accessToken: z23.string().min(1),
-  refreshToken: z23.string().min(1),
-  scopes: z23.array(z23.string()).readonly(),
+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(),
   /** When the access token stops working, in milliseconds since the epoch. */
-  expiresAt: z23.number()
+  expiresAt: z24.number()
 });
-var SiwcFileSchema = z23.strictObject({ registeredClientId: z23.string().min(1).optional(), grant: SiwcGrantSchema.optional() });
+var SiwcFileSchema = z24.strictObject({ registeredClientId: z24.string().min(1).optional(), grant: SiwcGrantSchema.optional() });
 function parseSiwcFile(raw, filePath) {
   let json;
   try {
@@ -16536,92 +16665,92 @@ function collectDoctorReport(params) {
 // src/frontdoor/controlSchemas.ts
 init_schema2();
 init_state();
-var UsageListOutputSchema = z26.strictObject({ snapshots: z26.readonly(z26.array(UsageSnapshotSchema)) });
-var UsageWindowsInputSchema = z26.strictObject({
-  identity: z26.string().min(1),
-  provider: z26.string().min(1).optional()
+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 EffectiveWindowSchema = z26.strictObject({
+var EffectiveWindowSchema = z27.strictObject({
   /** True when the window's reset time has passed, so the recorded observation describes a window that no longer exists. */
-  reset: z26.boolean(),
+  reset: z27.boolean(),
   /** The fraction used: 0 for a reset window, otherwise what was last observed, absent when none was reported. */
-  utilization: z26.number().optional(),
+  utilization: z27.number().optional(),
   /** The reset instant, for a window that has not reset yet and reported one. */
-  resetsAtMs: z26.number().optional(),
+  resetsAtMs: z27.number().optional(),
   /** The window's own status, for a window that has not reset yet. */
-  status: z26.string().optional()
+  status: z27.string().optional()
 });
-var UsageWindowsOutputSchema = z26.strictObject({
-  identity: z26.string(),
-  provider: z26.string(),
+var UsageWindowsOutputSchema = z27.strictObject({
+  identity: z27.string(),
+  provider: z27.string(),
   /** When the rate-limit state the windows come from was observed. */
-  observedAt: z26.iso.datetime().optional(),
+  observedAt: z27.iso.datetime().optional(),
   fiveHour: EffectiveWindowSchema.optional(),
   sevenDay: EffectiveWindowSchema.optional()
 });
-var UsageLiveOutputSchema = z26.strictObject({
+var UsageLiveOutputSchema = z27.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: z26.readonly(z26.array(RcLiveRateLimitSchema))
+  sessions: z27.readonly(z27.array(RcLiveRateLimitSchema))
 });
-var FrontDoorSessionStatusSchema = z26.strictObject({
-  pid: z26.int().positive(),
-  startedAt: z26.number(),
-  alive: z26.boolean()
+var FrontDoorSessionStatusSchema = z27.strictObject({
+  pid: z27.int().positive(),
+  startedAt: z27.number(),
+  alive: z27.boolean()
 });
-var HeadroomSocketTargetSchema = z26.union([z26.strictObject({ socketPath: z26.string() }), z26.strictObject({ refused: z26.string() })]);
-var FrontDoorStatusOutputSchema = z26.strictObject({
+var HeadroomSocketTargetSchema = z27.union([z27.strictObject({ socketPath: z27.string() }), z27.strictObject({ refused: z27.string() })]);
+var FrontDoorStatusOutputSchema = z27.strictObject({
   state: FrontDoorStateSchema,
-  supervisorAlive: z26.boolean(),
+  supervisorAlive: z27.boolean(),
   /** The pids of earlier doors that released their addresses and are finishing the connections they carried: running, but not serving anything new. */
-  draining: z26.readonly(z26.array(z26.number().int().positive())),
-  sessions: z26.readonly(z26.array(FrontDoorSessionStatusSchema)),
+  draining: z27.readonly(z27.array(z27.number().int().positive())),
+  sessions: z27.readonly(z27.array(FrontDoorSessionStatusSchema)),
   headroomSocket: HeadroomSocketTargetSchema.optional(),
-  logPath: z26.string(),
-  logExists: z26.boolean()
+  logPath: z27.string(),
+  logExists: z27.boolean()
 });
-var FrontDoorSessionsOutputSchema = z26.strictObject({ sessions: z26.readonly(z26.array(FrontDoorSessionStatusSchema)) });
-var CheckRunInputSchema = z26.strictObject({
-  path: z26.string().min(1),
-  identity: z26.string().min(1).optional()
+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()
 }).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 = z26.strictObject({
-  pool: z26.string().min(1),
-  path: z26.string().min(1)
+var PoolPickInputSchema = z27.strictObject({
+  pool: z27.string().min(1),
+  path: z27.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 = z26.strictObject({
-  section: z26.enum(DOCTOR_SECTIONS),
-  subject: z26.string().optional(),
-  severity: z26.enum(DOCTOR_SEVERITIES),
-  message: z26.string()
+var DoctorFindingSchema = z27.strictObject({
+  section: z27.enum(DOCTOR_SECTIONS),
+  subject: z27.string().optional(),
+  severity: z27.enum(DOCTOR_SEVERITIES),
+  message: z27.string()
 });
-var DoctorRunOutputSchema = z26.strictObject({
+var DoctorRunOutputSchema = z27.strictObject({
   /** False exactly when any finding is a `fail`; a `warn` never fails the report on its own. */
-  ok: z26.boolean(),
-  findings: z26.readonly(z26.array(DoctorFindingSchema))
+  ok: z27.boolean(),
+  findings: z27.readonly(z27.array(DoctorFindingSchema))
 });
-var FrontDoorRestartOutputSchema = z26.strictObject({
-  action: z26.literal("restarting"),
-  previousPid: z26.int().positive()
+var FrontDoorRestartOutputSchema = z27.strictObject({
+  action: z27.literal("restarting"),
+  previousPid: z27.int().positive()
 });
-var UpdateCheckOutputSchema = z26.strictObject({
-  current: z26.string(),
-  latest: z26.string(),
-  action: z26.enum(["current", "available", "updated"])
+var UpdateCheckOutputSchema = z27.strictObject({
+  current: z27.string(),
+  latest: z27.string(),
+  action: z27.enum(["current", "available", "updated"])
 });
-var CodexSignInSchema = z26.discriminatedUnion("state", [
-  z26.strictObject({ state: z26.literal("none") }),
-  z26.strictObject({ state: z26.literal("signed-in"), email: z26.string().optional(), planScope: z26.boolean(), accessTokenExpiresAt: z26.number() }),
-  z26.strictObject({ state: z26.literal("unreadable"), message: z26.string() })
+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 CodexStatusOutputSchema = z26.strictObject({
+var CodexStatusOutputSchema = z27.strictObject({
   signIn: CodexSignInSchema,
-  codexProviders: z26.readonly(z26.array(z26.string()))
+  codexProviders: z27.readonly(z27.array(z27.string()))
 });
-var CodexLogoutOutputSchema = z26.strictObject({
-  hadGrant: z26.boolean(),
-  revoked: z26.boolean()
+var CodexLogoutOutputSchema = z27.strictObject({
+  hadGrant: z27.boolean(),
+  revoked: z27.boolean()
 });
 
 // src/frontdoor/codexApi.ts
@@ -16780,143 +16909,145 @@ init_providersStore();
 
 // src/frontdoor/configSchemas.ts
 init_schema();
-import { z as z27 } from "zod";
-var RemovalConfirmationSchema = z27.boolean();
-var CredentialWriteSchema = (targets) => z27.strictObject({
-  sources: z27.array(RemoteCredentialSourceSchema).min(1).optional(),
-  target: z27.enum(targets).optional(),
-  cache: z27.union([z27.literal(false), CredentialCacheSchema]).optional()
+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()
 });
-var CredentialSummarySchema2 = z27.strictObject({
-  target: z27.enum(CREDENTIAL_TARGETS),
-  sources: z27.readonly(z27.array(
-    z27.discriminatedUnion("kind", [
-      z27.strictObject({ kind: z27.literal("env"), variable: z27.string() }),
-      z27.strictObject({ kind: z27.literal("file"), path: z27.string() }),
-      z27.strictObject({ kind: z27.literal("command"), program: z27.string() }),
-      z27.strictObject({ kind: z27.literal("op"), reference: z27.string() }),
-      z27.strictObject({ kind: z27.literal("keychain"), service: z27.string(), account: z27.string().optional() }),
-      z27.strictObject({ kind: z27.literal("literal") })
+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") })
     ])
   )),
   cache: CredentialCacheSchema.optional()
 });
-var mutationOutput = (kind, action) => z27.strictObject({ action: z27.literal(action), kind: z27.literal(kind), name: z27.string() });
-var storedMutationOutput = (kind, action, value) => z27.strictObject({ action: z27.literal(action), kind: z27.literal(kind), name: z27.string(), value });
-var IdentityValueSchema = z27.strictObject({
-  name: z27.string(),
-  defaultConfigProfile: z27.string().optional(),
-  allowAmbientCredential: z27.boolean(),
+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(),
   credential: CredentialSummarySchema2.optional(),
-  anchors: z27.array(AnchorSchema).optional()
+  anchors: z28.array(AnchorSchema).optional()
 });
 var ProfileValueSchema = ConfigProfileSchema.omit({ $schema: true });
-var ProviderValueSchema = z27.strictObject({
-  name: z27.string(),
-  kind: z27.enum(PROVIDER_KINDS),
-  displayName: z27.string(),
-  baseUrl: z27.string().optional(),
+var ProviderValueSchema = z28.strictObject({
+  name: z28.string(),
+  kind: z28.enum(PROVIDER_KINDS),
+  displayName: z28.string(),
+  baseUrl: z28.string().optional(),
   codex: CodexProviderConfigSchema.optional(),
   credential: CredentialSummarySchema2.optional(),
-  env: z27.record(z27.string(), z27.string()).optional()
+  env: z28.record(z28.string(), z28.string()).optional()
 });
-var ConfigNameInputSchema = z27.strictObject({ name: z27.string().min(1) });
+var ConfigNameInputSchema = z28.strictObject({ name: z28.string().min(1) });
 var ConfigIdentityAddOutputSchema = storedMutationOutput("identity", "created", IdentityValueSchema);
-var ConfigIdentitySetInputSchema = z27.strictObject({
-  name: z27.string().min(1),
-  defaultConfigProfile: z27.union([z27.string().min(1), z27.literal(false)]).optional(),
-  allowAmbientCredential: z27.boolean().optional(),
-  credential: z27.union([z27.literal(false), CredentialWriteSchema(CREDENTIAL_TARGETS)]).optional(),
+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(),
   /** `false` removes the anchors; a list replaces them. */
-  anchors: z27.union([z27.literal(false), z27.array(AnchorSchema).min(1)]).optional()
+  anchors: z28.union([z28.literal(false), z28.array(AnchorSchema).min(1)]).optional()
 });
 var ConfigIdentitySetOutputSchema = storedMutationOutput("identity", "updated", IdentityValueSchema);
-var ConfigIdentityRemoveInputSchema = z27.strictObject({ name: z27.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigIdentityRemoveInputSchema = z28.strictObject({ name: z28.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigIdentityRemoveOutputSchema = mutationOutput("identity", "removed");
 var ConfigIdentityUseOutputSchema = mutationOutput("identity", "selected");
-var ConfigProfileAddInputSchema = z27.strictObject({
-  name: z27.string().min(1),
-  extends: z27.array(z27.string().min(1)).optional(),
-  description: z27.string().optional()
+var ConfigProfileAddInputSchema = z28.strictObject({
+  name: z28.string().min(1),
+  extends: z28.array(z28.string().min(1)).optional(),
+  description: z28.string().optional()
 });
 var ConfigProfileAddOutputSchema = storedMutationOutput("profile", "created", ProfileValueSchema);
-var ConfigProfileSetInputSchema = z27.strictObject({
-  name: z27.string().min(1),
-  category: z27.record(z27.string(), z27.boolean()).optional(),
-  entry: z27.record(z27.string(), z27.boolean()).optional(),
-  extends: z27.union([z27.array(z27.string().min(1)), z27.literal(false)]).optional(),
-  description: z27.union([z27.string(), z27.literal(false)]).optional(),
-  launch: z27.strictObject({
-    skipPermissions: z27.boolean().optional(),
-    remoteControl: z27.boolean().optional(),
-    headroom: z27.boolean().optional(),
-    trackUsage: z27.boolean().optional(),
-    provider: z27.union([z27.string().min(1), z27.literal(false)]).optional(),
-    claudeVersion: z27.union([z27.string().min(1), z27.literal(false)]).optional(),
-    delay: z27.union([z27.string().regex(DURATION_RE), z27.literal(false)]).optional(),
-    pause: z27.boolean().optional(),
-    explain: z27.boolean().optional(),
-    proxyBypass: z27.union([z27.array(z27.string().min(1)), z27.literal(false)]).optional()
+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()
   }).optional()
 });
 var ConfigProfileSetOutputSchema = storedMutationOutput("profile", "updated", ProfileValueSchema);
-var ConfigProfileRemoveInputSchema = z27.strictObject({ name: z27.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProfileRemoveInputSchema = z28.strictObject({ name: z28.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigProfileRemoveOutputSchema = mutationOutput("profile", "removed");
 var ConfigProfileUseOutputSchema = mutationOutput("profile", "selected");
-var PoolMembersInputSchema = z27.array(z27.string().min(1)).min(1);
-var ConfigPoolAddInputSchema = z27.strictObject({
-  name: z27.string().min(1),
+var PoolMembersInputSchema = z28.array(z28.string().min(1)).min(1);
+var ConfigPoolAddInputSchema = z28.strictObject({
+  name: z28.string().min(1),
   identities: PoolMembersInputSchema,
-  preference: z27.enum(POOL_PREFERENCES).optional(),
-  resumeOnLimit: z27.boolean().optional(),
-  compactBeforeLimit: z27.boolean().optional(),
+  preference: z28.enum(POOL_PREFERENCES).optional(),
+  resumeOnLimit: z28.boolean().optional(),
+  compactBeforeLimit: z28.boolean().optional(),
   compactAtUtilisation: CompactAtUtilisationSchema.optional()
 });
 var ConfigPoolAddOutputSchema = storedMutationOutput("pool", "created", PoolSchema);
-var ConfigPoolSetInputSchema = z27.strictObject({
-  name: z27.string().min(1),
+var ConfigPoolSetInputSchema = z28.strictObject({
+  name: z28.string().min(1),
   identities: PoolMembersInputSchema.optional(),
-  preference: z27.union([z27.enum(POOL_PREFERENCES), z27.literal(false)]).optional(),
-  resumeOnLimit: z27.boolean().optional(),
-  compactBeforeLimit: z27.boolean().optional(),
-  compactAtUtilisation: z27.union([CompactAtUtilisationSchema, z27.literal(false)]).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()
 });
 var ConfigPoolSetOutputSchema = storedMutationOutput("pool", "updated", PoolSchema);
-var ConfigPoolRemoveInputSchema = z27.strictObject({ name: z27.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigPoolRemoveInputSchema = z28.strictObject({ name: z28.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigPoolRemoveOutputSchema = mutationOutput("pool", "removed");
 var ConfigPoolUseOutputSchema = mutationOutput("pool", "selected");
-var ConfigProviderAddInputSchema = z27.strictObject({
-  name: z27.string().min(1),
-  kind: z27.enum(PROVIDER_KINDS).optional(),
-  displayName: z27.string().min(1),
-  baseUrl: z27.string().min(1).optional(),
+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(),
   credential: CredentialWriteSchema(PROVIDER_CREDENTIAL_TARGETS).required({ sources: true }),
   codex: CodexProviderConfigSchema.optional()
 });
 var ConfigProviderAddOutputSchema = storedMutationOutput("provider", "created", ProviderValueSchema);
-var ConfigProviderSetInputSchema = z27.strictObject({
-  name: z27.string().min(1),
-  displayName: z27.string().min(1).optional(),
-  baseUrl: z27.string().min(1).optional(),
+var ConfigProviderSetInputSchema = z28.strictObject({
+  name: z28.string().min(1),
+  displayName: z28.string().min(1).optional(),
+  baseUrl: z28.string().min(1).optional(),
   credential: CredentialWriteSchema(PROVIDER_CREDENTIAL_TARGETS).optional(),
   codex: CodexProviderConfigSchema.optional()
 });
 var ConfigProviderSetOutputSchema = storedMutationOutput("provider", "updated", ProviderValueSchema);
-var ConfigProviderRemoveInputSchema = z27.strictObject({ name: z27.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProviderRemoveInputSchema = z28.strictObject({ name: z28.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigProviderRemoveOutputSchema = mutationOutput("provider", "removed");
-var ConfigRuleAddInputSchema = z27.strictObject({
-  path: z27.string().min(1),
-  configProfile: z27.string().min(1).optional(),
-  identity: z27.string().min(1).optional()
+var ConfigRuleAddInputSchema = z28.strictObject({
+  path: z28.string().min(1),
+  configProfile: z28.string().min(1).optional(),
+  identity: z28.string().min(1).optional()
 });
 var ConfigRuleAddOutputSchema = storedMutationOutput("rule", "created", DirectoryRuleSchema);
-var ConfigRuleSetInputSchema = z27.strictObject({
-  path: z27.string().min(1),
-  configProfile: z27.union([z27.string().min(1), z27.literal(false)]).optional(),
-  identity: z27.union([z27.string().min(1), z27.literal(false)]).optional()
+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 ConfigRuleSetOutputSchema = storedMutationOutput("rule", "updated", DirectoryRuleSchema);
-var ConfigRuleRemoveInputSchema = z27.strictObject({ path: z27.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigRuleRemoveInputSchema = z28.strictObject({ path: z28.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigRuleRemoveOutputSchema = mutationOutput("rule", "removed");
 
 // src/frontdoor/configApi.ts
@@ -17069,7 +17200,8 @@ function createConfigApiRouter(deps) {
               ...launch?.delay === void 0 ? {} : { launchDelay: launch.delay },
               ...launch?.pause === void 0 ? {} : { launchPause: launch.pause },
               ...launch?.explain === void 0 ? {} : { launchExplain: launch.explain },
-              ...launch?.proxyBypass === void 0 ? {} : { launchProxyBypass: launch.proxyBypass === false ? false : checkedProxyBypass(launch.proxyBypass, "launch.proxyBypass") }
+              ...launch?.proxyBypass === void 0 ? {} : { launchProxyBypass: launch.proxyBypass === false ? false : checkedProxyBypass(launch.proxyBypass, "launch.proxyBypass") },
+              ...launch?.statusline === void 0 ? {} : { launchStatusline: launch.statusline }
             });
             return { action: "updated", kind: "profile", name: input.name, value: profileValue(input.name, paths) };
           })
@@ -17228,43 +17360,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 z28 } from "zod";
+import { z as z29 } 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 = z28.strictObject({
-  source: z28.string().min(1),
+var DoorEventSchema = z29.strictObject({
+  source: z29.string().min(1),
   /** A positive integer because the backbone's counters start at one and only ever increase. */
-  sequence: z28.number().int().positive(),
-  payload: z28.unknown()
+  sequence: z29.number().int().positive(),
+  payload: z29.unknown()
 });
-var DoorEventSourceQuerySchema = z28.strictObject({
-  sources: z28.array(z28.string().min(1)).min(1).optional()
+var DoorEventSourceQuerySchema = z29.strictObject({
+  sources: z29.array(z29.string().min(1)).min(1).optional()
 });
-var LaunchLifecycleEventSchema = z28.strictObject({
-  kind: z28.enum(["registered", "pruned", "ended"]),
-  pid: z28.number().int().positive(),
-  startedAt: z28.number(),
-  observedAt: z28.number()
+var LaunchLifecycleEventSchema = z29.strictObject({
+  kind: z29.enum(["registered", "pruned", "ended"]),
+  pid: z29.number().int().positive(),
+  startedAt: z29.number(),
+  observedAt: z29.number()
 });
-var DoorHealthEventSchema = z28.discriminatedUnion("kind", [
-  z28.strictObject({ kind: z28.literal("generation"), pid: z28.number().int().positive(), providerPort: z28.number().int().positive(), connectPort: z28.number().int().positive(), directPort: z28.number().int().positive(), observedAt: z28.number() }),
-  z28.strictObject({ kind: z28.literal("listenerFailed"), pid: z28.number().int().positive(), listener: z28.enum(["provider", "connect", "direct"]), message: z28.string(), observedAt: z28.number() }),
-  z28.strictObject({ kind: z28.literal("binaryTurnover"), pid: z28.number().int().positive(), observedAt: z28.number() }),
-  z28.strictObject({ kind: z28.literal("idleShutdown"), pid: z28.number().int().positive(), observedAt: z28.number() }),
-  z28.strictObject({ kind: z28.literal("superseded"), pid: z28.number().int().positive(), ownerPid: z28.number().int().positive(), observedAt: z28.number() }),
-  z28.strictObject({ kind: z28.literal("drained"), pid: z28.number().int().positive(), observedAt: z28.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 QuotaExpiringEventSchema = z28.strictObject({
-  identity: z28.string().min(1),
-  provider: z28.string().min(1),
-  window: z28.enum(["fiveHour", "sevenDay"]),
+var QuotaExpiringEventSchema = z29.strictObject({
+  identity: z29.string().min(1),
+  provider: z29.string().min(1),
+  window: z29.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: z28.number().min(0).max(1),
-  resetsAt: z28.iso.datetime(),
-  observedAt: z28.number()
+  utilization: z29.number().min(0).max(1),
+  resetsAt: z29.iso.datetime(),
+  observedAt: z29.number()
 });
 
 // src/frontdoor/eventsApi.ts
@@ -17348,57 +17480,60 @@ import { openapi as openapi6 } from "@orpc/openapi";
 
 // src/frontdoor/launchSchemas.ts
 import path33 from "node:path";
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
+init_statusline();
 init_claudeVersion();
 init_identity();
-var LaunchResolveInputSchema = z29.strictObject({
-  path: z29.string().min(1),
+var LaunchResolveInputSchema = z30.strictObject({
+  path: z30.string().min(1),
   /** `@name`, launch flags, then the arguments for `claude`; empty for a bare launch. */
-  argv: z29.readonly(z29.array(z29.string())).optional(),
+  argv: z30.readonly(z30.array(z30.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: z29.record(z29.string(), z29.string()).optional()
+  env: z30.record(z30.string(), z30.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 = z29.strictObject({
-  name: z29.string(),
-  reasons: z29.readonly(z29.array(z29.string())),
-  movedOff: z29.strictObject({ identity: z29.string(), reason: z29.string() }).optional()
+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 LaunchDecisionSchema = z29.strictObject({
-  identity: z29.string().optional(),
-  identitySource: z29.enum(IDENTITY_DECISION_SOURCES),
+var LaunchDecisionSchema = z30.strictObject({
+  identity: z30.string().optional(),
+  identitySource: z30.enum(IDENTITY_DECISION_SOURCES),
   pool: LaunchPoolDecisionSchema.optional(),
-  configDirEscapeHatch: z29.boolean(),
-  configDir: z29.string().optional(),
-  configProfile: z29.string().optional(),
-  configProfileSource: z29.enum(CONFIG_PROFILE_DECISION_SOURCES),
-  provider: z29.string().optional()
+  configDirEscapeHatch: z30.boolean(),
+  configDir: z30.string().optional(),
+  configProfile: z30.string().optional(),
+  configProfileSource: z30.enum(CONFIG_PROFILE_DECISION_SOURCES),
+  provider: z30.string().optional()
 });
-var LaunchFlagsSchema = z29.strictObject({
-  skipPermissions: z29.boolean(),
-  remoteControl: z29.boolean(),
-  headroom: z29.boolean(),
-  trackUsage: z29.boolean(),
-  pause: z29.boolean(),
-  explain: z29.boolean(),
+var LaunchFlagsSchema = z30.strictObject({
+  skipPermissions: z30.boolean(),
+  remoteControl: z30.boolean(),
+  headroom: z30.boolean(),
+  trackUsage: z30.boolean(),
+  pause: z30.boolean(),
+  explain: z30.boolean(),
   /** How long the launch waits after its own output before it starts claude, in milliseconds. */
-  delayMs: z29.number(),
+  delayMs: z30.number(),
   /** The hosts the launch keeps off the front door by adding them to the child's `NO_PROXY`. */
-  proxyBypass: z29.array(z29.string()).readonly()
+  proxyBypass: z30.array(z30.string()).readonly(),
+  /** How the session's built-in statusline looks, when the launch configures any of it. */
+  statusline: StatuslineSchema.optional()
 });
-var LaunchResolveOutputSchema = z29.strictObject({
+var LaunchResolveOutputSchema = z30.strictObject({
   decision: LaunchDecisionSchema,
   flags: LaunchFlagsSchema,
-  claudeVersion: z29.strictObject({ version: z29.string(), source: z29.enum(CLAUDE_VERSION_SOURCES) }).optional(),
+  claudeVersion: z30.strictObject({ version: z30.string(), source: z30.enum(CLAUDE_VERSION_SOURCES) }).optional(),
   /** The real `claude` binary the launch would spawn, on the door's host. */
-  bin: z29.string(),
+  bin: z30.string(),
   /** The arguments the launch would pass it: the tool's own flags, then `CLAUDE_EXTRA_FLAGS`, then the caller's own. */
-  args: z29.readonly(z29.array(z29.string())),
+  args: z30.readonly(z30.array(z30.string())),
   /** The credential the launch would authenticate with, by target and source kinds. Absent when none applies. */
-  credential: z29.strictObject({ subject: z29.enum(["provider", "identity"]), name: z29.string(), summary: CredentialSummarySchema }).optional(),
-  routing: z29.strictObject({ frontDoor: z29.boolean(), headroom: z29.boolean() }),
+  credential: z30.strictObject({ subject: z30.enum(["provider", "identity"]), name: z30.string(), summary: CredentialSummarySchema }).optional(),
+  routing: z30.strictObject({ frontDoor: z30.boolean(), headroom: z30.boolean() }),
   /** The names of the environment variables the launch would set or unset, sorted. Values are not reported. */
-  environment: z29.readonly(z29.array(z29.string())),
-  warnings: z29.readonly(z29.array(z29.string()))
+  environment: z30.readonly(z30.array(z30.string())),
+  warnings: z30.readonly(z30.array(z30.string()))
 });
 
 // src/frontdoor/launchApi.ts
@@ -17434,22 +17569,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 z30 } from "zod";
+import { z as z31 } from "zod";
 init_cliError();
-var AgentTreesListInputSchema = z30.strictObject({
+var AgentTreesListInputSchema = z31.strictObject({
   /** Only this identity's sessions. */
-  identity: z30.string().optional(),
+  identity: z31.string().optional(),
   /** Include sessions that spawned no agent and ran no workflow. */
-  all: z30.boolean().optional()
+  all: z31.boolean().optional()
 });
-var AgentTreesListOutputSchema = z30.array(SessionSummarySchema);
-var AgentTreesShowInputSchema = z30.strictObject({
+var AgentTreesListOutputSchema = z31.array(SessionSummarySchema);
+var AgentTreesShowInputSchema = z31.strictObject({
   /** A session id, or an unambiguous prefix of one. */
-  session: z30.string().min(1),
+  session: z31.string().min(1),
   /** Look only in this identity. */
-  identity: z30.string().optional()
+  identity: z31.string().optional()
 });
-var AgentTreesShowOutputSchema = z30.strictObject({ identities: z30.array(z30.string()), ...MergedAgentTreeSchema.shape });
+var AgentTreesShowOutputSchema = z31.strictObject({ identities: z31.array(z31.string()), ...MergedAgentTreeSchema.shape });
 function asBadRequest(error) {
   if (error instanceof CliError) {
     throw new ORPCError6("BAD_REQUEST", { message: error.message });
@@ -19642,7 +19777,7 @@ init_poolPick();
 
 // src/agents/read.ts
 import path35 from "node:path";
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var PROJECTS_DIR = "projects";
 var TASKS_DIR = "tasks";
 var SUBAGENTS_DIR = "subagents";
@@ -19761,14 +19896,14 @@ function parseJson2(text) {
     return void 0;
   }
 }
-var TaskFileSchema = z31.object({ ...TaskItemSchema.omit({ taskList: true }).shape, blocks: z31.array(z31.string()).default([]), blockedBy: z31.array(z31.string()).default([]) });
-var WorkflowRunFileSchema = z31.object({
-  runId: z31.string(),
-  workflowName: z31.string().optional(),
-  status: z31.string().optional(),
-  startTime: z31.number().optional(),
-  phases: z31.array(z31.object({ title: z31.string() })).default([]),
-  summary: z31.string().optional()
+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()
 });
 function summariseSession(fs14, configDir, ref) {
   const sessionRelative = path35.join(PROJECTS_DIR, ref.project, ref.entry);