claude-use 9.7.2 → 9.9.0

package/dist/index.cjs

@@ -626,9 +626,9 @@ function applyPatch(filePath, schema, patch, options = {}) {
   if (!result.success) {
     throw new ConfigValidationError(filePath, result.error.issues);
   }
-  const validated2 = result.data;
-  writeJsonAtomic(filePath, validated2, storeFs);
-  return validated2;
+  const validated3 = result.data;
+  writeJsonAtomic(filePath, validated3, storeFs);
+  return validated3;
 }
 var import_node_fs, import_node_path3, import_node_crypto, nodeStoreFs;
 var init_store = __esm({
@@ -2663,7 +2663,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "9.7.2",
+      version: "9.9.0",
       description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
       license: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -2891,37 +2891,37 @@ function readStartLock(fs12, lockFile) {
     return void 0;
   }
 }
-var import_node_crypto6, import_node_path11, import_zod5, HEADROOM_ANTHROPIC_UPSTREAM, HeadroomStateSchema, HeadroomSessionSchema, HeadroomLockSchema;
+var import_node_crypto6, import_node_path11, import_zod6, HEADROOM_ANTHROPIC_UPSTREAM, HeadroomStateSchema, HeadroomSessionSchema, HeadroomLockSchema;
 var init_state2 = __esm({
   "src/headroom/state.ts"() {
     "use strict";
     import_node_crypto6 = require("node:crypto");
     import_node_path11 = __toESM(require("node:path"), 1);
-    import_zod5 = require("zod");
+    import_zod6 = require("zod");
     init_schema();
     HEADROOM_ANTHROPIC_UPSTREAM = "https://api.anthropic.com";
-    HeadroomStateSchema = import_zod5.z.strictObject({
+    HeadroomStateSchema = import_zod6.z.strictObject({
       /** The supervisor process owning the daemon. Alive means someone is keeping headroom running. */
-      supervisorPid: import_zod5.z.number().int().positive().optional(),
+      supervisorPid: import_zod6.z.number().int().positive().optional(),
       /** The headroom proxy process itself. Absent while the supervisor is between restarts. */
-      headroomPid: import_zod5.z.number().int().positive().optional(),
+      headroomPid: import_zod6.z.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: import_zod5.z.string().min(1).optional(),
+      socketPath: import_zod6.z.string().min(1).optional(),
       /** The `headroom --version` output of the running install. */
-      version: import_zod5.z.string().optional(),
+      version: import_zod6.z.string().optional(),
       /** Hash of the allowlist the running proxy was started with, so a provider-file change is detected as drift. */
-      allowlistHash: import_zod5.z.string().optional(),
+      allowlistHash: import_zod6.z.string().optional(),
       /** Hash of the token-saving settings the running proxy was started with, so a settings change is detected as drift. */
-      settingsHash: import_zod5.z.string().optional(),
+      settingsHash: import_zod6.z.string().optional(),
       /** The install spec the running install was last installed from, so a `source` config change is detected as drift. */
-      installedSource: import_zod5.z.string().optional(),
+      installedSource: import_zod6.z.string().optional(),
       /** The last fatal error, kept across shutdowns so `headroom status` can explain a daemon that is not running. */
-      lastError: import_zod5.z.string().optional()
+      lastError: import_zod6.z.string().optional()
     });
-    HeadroomSessionSchema = import_zod5.z.strictObject({ pid: import_zod5.z.number().int().positive(), startedAt: import_zod5.z.number(), supervisorPid: import_zod5.z.number().int().positive() });
-    HeadroomLockSchema = import_zod5.z.strictObject({ pid: import_zod5.z.number().int().positive(), at: import_zod5.z.number() });
+    HeadroomSessionSchema = import_zod6.z.strictObject({ pid: import_zod6.z.number().int().positive(), startedAt: import_zod6.z.number(), supervisorPid: import_zod6.z.number().int().positive() });
+    HeadroomLockSchema = import_zod6.z.strictObject({ pid: import_zod6.z.number().int().positive(), at: import_zod6.z.number() });
   }
 });
 
@@ -3128,14 +3128,14 @@ function pinnedGitCommit(spec) {
   const ref = GIT_SPEC_RE.exec(spec)?.[1];
   return ref !== void 0 && COMMIT_SHA_RE.test(ref) ? ref.toLowerCase() : void 0;
 }
-var import_zod6, GIT_SPEC_RE, COMMIT_SHA_RE, DirectUrlSchema;
+var import_zod7, GIT_SPEC_RE, COMMIT_SHA_RE, DirectUrlSchema;
 var init_source = __esm({
   "src/headroom/source.ts"() {
     "use strict";
-    import_zod6 = require("zod");
+    import_zod7 = require("zod");
     GIT_SPEC_RE = /git\+[^@\s]+(?:@([^\s#]+))?/;
     COMMIT_SHA_RE = /^[0-9a-f]{40}$/i;
-    DirectUrlSchema = import_zod6.z.object({ vcs_info: import_zod6.z.object({ commit_id: import_zod6.z.string() }) });
+    DirectUrlSchema = import_zod7.z.object({ vcs_info: import_zod7.z.object({ commit_id: import_zod7.z.string() }) });
   }
 });
 
@@ -3421,7 +3421,7 @@ function realIsProcessAlive(pid) {
   }
 }
 function realIsProcessZombie(pid) {
-  const result = (0, import_node_child_process.spawnSync)("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf8" });
+  const result = (0, import_node_child_process2.spawnSync)("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf8" });
   return result.status === 0 && result.stdout.trim().startsWith("Z");
 }
 function realIsProcessRunning(pid) {
@@ -3432,7 +3432,7 @@ function expandHome2(filePath) {
 }
 function hasDesktopSession() {
   if (process.platform === "darwin") {
-    const result = (0, import_node_child_process.spawnSync)("launchctl", ["managername"], { encoding: "utf8" });
+    const result = (0, import_node_child_process2.spawnSync)("launchctl", ["managername"], { encoding: "utf8" });
     return result.status === 0 && result.stdout.trim() === MACOS_GUI_SESSION_MANAGER;
   }
   if (process.platform === "win32") {
@@ -3475,7 +3475,7 @@ function spawnDetachedDaemon(invocation, paths, subcommand, logPath) {
   import_node_fs2.default.mkdirSync(import_node_path13.default.dirname(logPath), { recursive: true });
   const logFd = import_node_fs2.default.openSync(logPath, "a");
   try {
-    const child = (0, import_node_child_process.spawn)(invocation.command, invocation.args, detachedDaemonSpawnOptions(logFd, { ...process.env, AGENT_SHIM_HOME: paths.root }));
+    const child = (0, import_node_child_process2.spawn)(invocation.command, invocation.args, detachedDaemonSpawnOptions(logFd, { ...process.env, AGENT_SHIM_HOME: paths.root }));
     child.unref();
     if (child.pid === void 0) {
       throw new Error(`spawning ${subcommand} returned no pid`);
@@ -3624,11 +3624,11 @@ function realResolveClaudeBinary(isOwnBinary) {
 function realInstalledClaudeVersions() {
   return installedVersions(listVersionsDir(defaultVersionsDir()));
 }
-var import_node_child_process, import_node_crypto8, import_node_fs2, import_node_os2, import_node_path13, import_node_sea, realFsPort, OWNER_ONLY_DIR_MODE, OWNER_ONLY_FILE_MODE, PERMISSION_BITS, realFarmFs, INT32_BYTE_LENGTH, realRunPort, MACOS_GUI_SESSION_MANAGER, realCredentialPort, SOCKET_PERMISSION_BITS, realHeadroomSocketTrust, realSpawnPort, realProcPort, EXECUTE_BITS_MASK, WINDOWS_DEFAULT_PATHEXT;
+var import_node_child_process2, import_node_crypto8, import_node_fs2, import_node_os2, import_node_path13, import_node_sea, realFsPort, OWNER_ONLY_DIR_MODE, OWNER_ONLY_FILE_MODE, PERMISSION_BITS, realFarmFs, INT32_BYTE_LENGTH, realRunPort, MACOS_GUI_SESSION_MANAGER, realCredentialPort, SOCKET_PERMISSION_BITS, realHeadroomSocketTrust, realSpawnPort, realProcPort, EXECUTE_BITS_MASK, WINDOWS_DEFAULT_PATHEXT;
 var init_realPorts = __esm({
   "src/realPorts.ts"() {
     "use strict";
-    import_node_child_process = require("node:child_process");
+    import_node_child_process2 = require("node:child_process");
     import_node_crypto8 = require("node:crypto");
     import_node_fs2 = __toESM(require("node:fs"), 1);
     import_node_os2 = __toESM(require("node:os"), 1);
@@ -3767,7 +3767,7 @@ var init_realPorts = __esm({
     INT32_BYTE_LENGTH = 4;
     realRunPort = {
       run(command, args) {
-        const result = (0, import_node_child_process.spawnSync)(command, [...args], { encoding: "utf8" });
+        const result = (0, import_node_child_process2.spawnSync)(command, [...args], { encoding: "utf8" });
         return { status: result.status, stdout: result.stdout, stderr: result.stderr };
       }
     };
@@ -3790,7 +3790,7 @@ var init_realPorts = __esm({
       },
       runCommand(argv, options) {
         const [command, ...args] = argv;
-        const result = (0, import_node_child_process.spawnSync)(command, args, {
+        const result = (0, import_node_child_process2.spawnSync)(command, args, {
           encoding: "utf8",
           timeout: options.timeoutMs,
           stdio: options.interactive ? ["inherit", "pipe", "inherit"] : ["ignore", "pipe", "pipe"]
@@ -3828,7 +3828,7 @@ var init_realPorts = __esm({
     };
     realSpawnPort = {
       spawnSync(command, args, options) {
-        const result = (0, import_node_child_process.spawnSync)(command, args, options);
+        const result = (0, import_node_child_process2.spawnSync)(command, args, options);
         return { status: result.status, signal: result.signal, ...result.error === void 0 ? {} : { error: result.error } };
       }
     };
@@ -4040,149 +4040,149 @@ var init_identity = __esm({
 });
 
 // src/usage/schema.ts
-var import_zod7, USAGE_SCHEMA_VERSION, VersionSchema, InstantSchema, TokenCountSchema, TokenUsageSchema, LIMIT_KINDS, LimitClassificationSchema, UsageRecordSchema, QuotaWindowSchema, ExtraUsageSpendSchema, UnifiedRateLimitSchema, RateLimitStateSchema, LimitEventSchema, ProviderQuotaWindowSchema, ProviderQuotaSchema, ProviderUsageStateSchema, AccountMetadataSchema, UsageSnapshotSchema;
+var import_zod8, USAGE_SCHEMA_VERSION, VersionSchema, InstantSchema, TokenCountSchema, TokenUsageSchema, LIMIT_KINDS, LimitClassificationSchema, UsageRecordSchema, QuotaWindowSchema, ExtraUsageSpendSchema, UnifiedRateLimitSchema, RateLimitStateSchema, LimitEventSchema, ProviderQuotaWindowSchema, ProviderQuotaSchema, ProviderUsageStateSchema, AccountMetadataSchema, UsageSnapshotSchema;
 var init_schema2 = __esm({
   "src/usage/schema.ts"() {
     "use strict";
-    import_zod7 = require("zod");
+    import_zod8 = require("zod");
     USAGE_SCHEMA_VERSION = 1;
-    VersionSchema = import_zod7.z.literal(USAGE_SCHEMA_VERSION);
-    InstantSchema = import_zod7.z.iso.datetime();
-    TokenCountSchema = import_zod7.z.number().int().nonnegative();
-    TokenUsageSchema = import_zod7.z.strictObject({
+    VersionSchema = import_zod8.z.literal(USAGE_SCHEMA_VERSION);
+    InstantSchema = import_zod8.z.iso.datetime();
+    TokenCountSchema = import_zod8.z.number().int().nonnegative();
+    TokenUsageSchema = import_zod8.z.strictObject({
       inputTokens: TokenCountSchema.optional(),
       outputTokens: TokenCountSchema.optional(),
       cacheCreationInputTokens: TokenCountSchema.optional(),
       cacheReadInputTokens: TokenCountSchema.optional()
     });
     LIMIT_KINDS = ["rate-limited", "quota-exhausted"];
-    LimitClassificationSchema = import_zod7.z.strictObject({
-      kind: import_zod7.z.enum(LIMIT_KINDS),
+    LimitClassificationSchema = import_zod8.z.strictObject({
+      kind: import_zod8.z.enum(LIMIT_KINDS),
       /** Seconds to wait before retrying, from the response's `retry-after`. */
-      retryAfterSeconds: import_zod7.z.number().nonnegative().optional(),
+      retryAfterSeconds: import_zod8.z.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: import_zod7.z.string().optional(),
+      window: import_zod8.z.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: import_zod7.z.array(import_zod7.z.string())
+      evidence: import_zod8.z.array(import_zod8.z.string())
     });
-    UsageRecordSchema = import_zod7.z.strictObject({
+    UsageRecordSchema = import_zod8.z.strictObject({
       schemaVersion: VersionSchema,
       /** When the front door received the request. */
       at: InstantSchema,
       /** The launching identity, when the launch resolved one. */
-      identity: import_zod7.z.string().optional(),
+      identity: import_zod8.z.string().optional(),
       /** `anthropic` for an OAuth session's request to Claude Code's own API, otherwise the provider's name. */
-      provider: import_zod7.z.string(),
+      provider: import_zod8.z.string(),
       /** The launch's session id, generated per launch. */
-      sessionId: import_zod7.z.string().optional(),
+      sessionId: import_zod8.z.string().optional(),
       /** The project the launch ran in (its git repository root), when the launch sent one: headroom launches do. */
-      project: import_zod7.z.string().optional(),
+      project: import_zod8.z.string().optional(),
       /** The front-door route that served the request. */
-      route: import_zod7.z.string(),
-      method: import_zod7.z.string(),
+      route: import_zod8.z.string(),
+      method: import_zod8.z.string(),
       /** The API path as the upstream sees it (`/v1/messages`), without the provider prefix or a query string. */
-      endpoint: import_zod7.z.string(),
+      endpoint: import_zod8.z.string(),
       /** The model the response named. */
-      model: import_zod7.z.string().optional(),
-      status: import_zod7.z.number().int(),
+      model: import_zod8.z.string().optional(),
+      status: import_zod8.z.number().int(),
       /** Milliseconds from the request's arrival to its response head. */
-      latencyMs: import_zod7.z.number().int().nonnegative(),
+      latencyMs: import_zod8.z.number().int().nonnegative(),
       /** Milliseconds from the request's arrival to the end of its response body. */
-      durationMs: import_zod7.z.number().int().nonnegative(),
+      durationMs: import_zod8.z.number().int().nonnegative(),
       /** Whether the client received the whole body. */
-      outcome: import_zod7.z.enum(["completed", "aborted"]),
+      outcome: import_zod8.z.enum(["completed", "aborted"]),
       usage: TokenUsageSchema.optional(),
       /** The response's quota and rate-limit headers, by name (see `isRateLimitHeader`). */
-      rateLimitHeaders: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional(),
+      rateLimitHeaders: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).optional(),
       limit: LimitClassificationSchema.optional(),
       /** The upstream's request id (`request-id`), for matching a record to the provider's own logs. */
-      requestId: import_zod7.z.string().optional()
+      requestId: import_zod8.z.string().optional()
     });
-    QuotaWindowSchema = import_zod7.z.strictObject({
+    QuotaWindowSchema = import_zod8.z.strictObject({
       /** The fraction of the window used, as the upstream reports it (0 to 1). */
-      utilization: import_zod7.z.number().nonnegative().optional(),
+      utilization: import_zod8.z.number().nonnegative().optional(),
       resetsAt: InstantSchema.optional(),
       /** The window's own status (`allowed`, `allowed_warning`, `rejected`). */
-      status: import_zod7.z.string().optional(),
+      status: import_zod8.z.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: import_zod7.z.number().nonnegative().optional()
+      graceUtilization: import_zod8.z.number().nonnegative().optional()
     });
-    ExtraUsageSpendSchema = import_zod7.z.strictObject({
+    ExtraUsageSpendSchema = import_zod8.z.strictObject({
       /** Spent so far in the allowance's period, in the currency's minor units (pence, cents). */
-      usedMinor: import_zod7.z.number().nonnegative(),
+      usedMinor: import_zod8.z.number().nonnegative(),
       /** The allowance's cap in the same units, when it has one. */
-      limitMinor: import_zod7.z.number().nonnegative().optional(),
+      limitMinor: import_zod8.z.number().nonnegative().optional(),
       /** The ISO 4217 currency code. */
-      currency: import_zod7.z.string()
+      currency: import_zod8.z.string()
     });
-    UnifiedRateLimitSchema = import_zod7.z.strictObject({
+    UnifiedRateLimitSchema = import_zod8.z.strictObject({
       /** The overall status: `allowed`, `allowed_warning` or `rejected`. */
-      status: import_zod7.z.string().optional(),
+      status: import_zod8.z.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: import_zod7.z.string().optional(),
+      representativeClaim: import_zod8.z.string().optional(),
       /** When the binding window resets. */
       resetAt: InstantSchema.optional(),
       /** Whether usage beyond the plan (extra usage) is available: `allowed` or `rejected`. */
-      overageStatus: import_zod7.z.string().optional(),
+      overageStatus: import_zod8.z.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: import_zod7.z.number().nonnegative().optional(),
+      overageUtilization: import_zod8.z.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: import_zod7.z.string().optional(),
+      overageDisabledReason: import_zod8.z.string().optional(),
       /** Whether the response was served on extra usage, as the upstream states it. */
-      overageInUse: import_zod7.z.boolean().optional(),
+      overageInUse: import_zod8.z.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: import_zod7.z.boolean().optional()
+      fallbackAvailable: import_zod8.z.boolean().optional()
     });
-    RateLimitStateSchema = import_zod7.z.strictObject({
+    RateLimitStateSchema = import_zod8.z.strictObject({
       observedAt: InstantSchema,
       /** Every quota and rate-limit header on that response, by name. */
-      headers: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()),
+      headers: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.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: import_zod7.z.number().int()
+      status: import_zod8.z.number().int()
     });
-    ProviderQuotaWindowSchema = import_zod7.z.strictObject({
+    ProviderQuotaWindowSchema = import_zod8.z.strictObject({
       /** What the window measures, in the provider's terms (`tokens`, `tool-calls`). */
-      measures: import_zod7.z.string(),
+      measures: import_zod8.z.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: import_zod7.z.number().int().positive().optional(),
+      periodMs: import_zod8.z.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: import_zod7.z.string().optional(),
+      period: import_zod8.z.string().optional(),
       /** The fraction of the window used (0 to 1). */
-      utilization: import_zod7.z.number().nonnegative(),
+      utilization: import_zod8.z.number().nonnegative(),
       resetsAt: InstantSchema.optional(),
       /** Absolute counts, when the provider reports them for this window. */
-      limit: import_zod7.z.number().nonnegative().optional(),
-      used: import_zod7.z.number().nonnegative().optional(),
-      remaining: import_zod7.z.number().nonnegative().optional()
+      limit: import_zod8.z.number().nonnegative().optional(),
+      used: import_zod8.z.number().nonnegative().optional(),
+      remaining: import_zod8.z.number().nonnegative().optional()
     });
-    ProviderQuotaSchema = import_zod7.z.strictObject({
+    ProviderQuotaSchema = import_zod8.z.strictObject({
       observedAt: InstantSchema,
       /** Which usage endpoint produced it (`z.ai`). */
-      source: import_zod7.z.string(),
+      source: import_zod8.z.string(),
       /** The subscription level the endpoint reports, when it does. */
-      level: import_zod7.z.string().optional(),
-      windows: import_zod7.z.array(ProviderQuotaWindowSchema)
+      level: import_zod8.z.string().optional(),
+      windows: import_zod8.z.array(ProviderQuotaWindowSchema)
     });
-    ProviderUsageStateSchema = import_zod7.z.strictObject({
+    ProviderUsageStateSchema = import_zod8.z.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: import_zod7.z.number().int().optional(),
-      lastModel: import_zod7.z.string().optional(),
+      lastStatus: import_zod8.z.number().int().optional(),
+      lastModel: import_zod8.z.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. */
@@ -4190,31 +4190,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 = import_zod7.z.strictObject({
-      accountUuid: import_zod7.z.string().optional(),
-      emailAddress: import_zod7.z.string().optional(),
-      displayName: import_zod7.z.string().optional(),
-      organizationUuid: import_zod7.z.string().optional(),
-      organizationName: import_zod7.z.string().optional(),
-      organizationType: import_zod7.z.string().optional(),
-      organizationRole: import_zod7.z.string().optional(),
-      workspaceRole: import_zod7.z.string().optional(),
-      billingType: import_zod7.z.string().optional(),
-      seatTier: import_zod7.z.string().optional(),
-      organizationRateLimitTier: import_zod7.z.string().optional(),
-      userRateLimitTier: import_zod7.z.string().optional(),
-      hasExtraUsageEnabled: import_zod7.z.boolean().optional(),
-      subscriptionCreatedAt: import_zod7.z.string().optional(),
-      accountCreatedAt: import_zod7.z.string().optional()
+    AccountMetadataSchema = import_zod8.z.strictObject({
+      accountUuid: import_zod8.z.string().optional(),
+      emailAddress: import_zod8.z.string().optional(),
+      displayName: import_zod8.z.string().optional(),
+      organizationUuid: import_zod8.z.string().optional(),
+      organizationName: import_zod8.z.string().optional(),
+      organizationType: import_zod8.z.string().optional(),
+      organizationRole: import_zod8.z.string().optional(),
+      workspaceRole: import_zod8.z.string().optional(),
+      billingType: import_zod8.z.string().optional(),
+      seatTier: import_zod8.z.string().optional(),
+      organizationRateLimitTier: import_zod8.z.string().optional(),
+      userRateLimitTier: import_zod8.z.string().optional(),
+      hasExtraUsageEnabled: import_zod8.z.boolean().optional(),
+      subscriptionCreatedAt: import_zod8.z.string().optional(),
+      accountCreatedAt: import_zod8.z.string().optional()
     });
-    UsageSnapshotSchema = import_zod7.z.strictObject({
+    UsageSnapshotSchema = import_zod8.z.strictObject({
       schemaVersion: VersionSchema,
-      identity: import_zod7.z.string(),
+      identity: import_zod8.z.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: import_zod7.z.record(import_zod7.z.string(), ProviderUsageStateSchema)
+      providers: import_zod8.z.record(import_zod8.z.string(), ProviderUsageStateSchema)
     });
   }
 });
@@ -4321,24 +4321,24 @@ function planOf(account) {
   }
   return { kind: "subscription", capacity: 1, recognised: BASE_TIER.test(tier), ...tierField };
 }
-var import_zod8, PlanClassSchema, TIER_MULTIPLIER, ZERO_TIER, BASE_TIER;
+var import_zod9, PlanClassSchema, TIER_MULTIPLIER, ZERO_TIER, BASE_TIER;
 var init_plan2 = __esm({
   "src/usage/plan.ts"() {
     "use strict";
-    import_zod8 = require("zod");
-    PlanClassSchema = import_zod8.z.union([
-      import_zod8.z.strictObject({
-        kind: import_zod8.z.literal("subscription"),
+    import_zod9 = require("zod");
+    PlanClassSchema = import_zod9.z.union([
+      import_zod9.z.strictObject({
+        kind: import_zod9.z.literal("subscription"),
         /** The plan's size as a multiple of the smallest subscription tier (Max 5x is 5, Max 20x is 20). */
-        capacity: import_zod8.z.number().positive(),
+        capacity: import_zod9.z.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: import_zod8.z.boolean(),
+        recognised: import_zod9.z.boolean(),
         /** The tier string the classification rests on, when the account had one. */
-        tier: import_zod8.z.string().optional()
+        tier: import_zod9.z.string().optional()
       }),
-      import_zod8.z.strictObject({
-        kind: import_zod8.z.literal("pay-per-use"),
-        tier: import_zod8.z.string().optional()
+      import_zod9.z.strictObject({
+        kind: import_zod9.z.literal("pay-per-use"),
+        tier: import_zod9.z.string().optional()
       })
     ]);
     TIER_MULTIPLIER = /(?:^|_)(\d+)x$/;
@@ -4439,21 +4439,21 @@ var init_rateLimit = __esm({
 });
 
 // src/usage/scan.ts
-var import_zod9, AnthropicUsageSchema, ErrorObjectSchema;
+var import_zod10, AnthropicUsageSchema, ErrorObjectSchema;
 var init_scan = __esm({
   "src/usage/scan.ts"() {
     "use strict";
-    import_zod9 = require("zod");
-    AnthropicUsageSchema = import_zod9.z.looseObject({
-      input_tokens: import_zod9.z.number().int().nonnegative().nullish(),
-      output_tokens: import_zod9.z.number().int().nonnegative().nullish(),
-      cache_creation_input_tokens: import_zod9.z.number().int().nonnegative().nullish(),
-      cache_read_input_tokens: import_zod9.z.number().int().nonnegative().nullish()
+    import_zod10 = require("zod");
+    AnthropicUsageSchema = import_zod10.z.looseObject({
+      input_tokens: import_zod10.z.number().int().nonnegative().nullish(),
+      output_tokens: import_zod10.z.number().int().nonnegative().nullish(),
+      cache_creation_input_tokens: import_zod10.z.number().int().nonnegative().nullish(),
+      cache_read_input_tokens: import_zod10.z.number().int().nonnegative().nullish()
     });
-    ErrorObjectSchema = import_zod9.z.looseObject({
-      type: import_zod9.z.string().optional(),
-      code: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).optional(),
-      message: import_zod9.z.string().optional()
+    ErrorObjectSchema = import_zod10.z.looseObject({
+      type: import_zod10.z.string().optional(),
+      code: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.number()]).optional(),
+      message: import_zod10.z.string().optional()
     });
   }
 });
@@ -5156,12 +5156,12 @@ function recordStickyPick(fs12, picksFile, directory, identity, nowMs) {
   fs12.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
 `);
 }
-var import_node_path20, import_zod10, PoolGraphError, SCHEMA_VERSION, PickEntrySchema, PicksFileSchema;
+var import_node_path20, import_zod11, PoolGraphError, SCHEMA_VERSION, PickEntrySchema, PicksFileSchema;
 var init_poolPick = __esm({
   "src/usage/poolPick.ts"() {
     "use strict";
     import_node_path20 = __toESM(require("node:path"), 1);
-    import_zod10 = require("zod");
+    import_zod11 = require("zod");
     init_cliError();
     init_identity();
     init_schema();
@@ -5177,10 +5177,10 @@ var init_poolPick = __esm({
       }
     };
     SCHEMA_VERSION = 1;
-    PickEntrySchema = import_zod10.z.strictObject({ identity: import_zod10.z.string().min(1), at: import_zod10.z.iso.datetime() });
-    PicksFileSchema = import_zod10.z.strictObject({
-      schemaVersion: import_zod10.z.literal(SCHEMA_VERSION),
-      picks: import_zod10.z.record(import_zod10.z.string().min(1), PickEntrySchema)
+    PickEntrySchema = import_zod11.z.strictObject({ identity: import_zod11.z.string().min(1), at: import_zod11.z.iso.datetime() });
+    PicksFileSchema = import_zod11.z.strictObject({
+      schemaVersion: import_zod11.z.literal(SCHEMA_VERSION),
+      picks: import_zod11.z.record(import_zod11.z.string().min(1), PickEntrySchema)
     });
   }
 });
@@ -5316,17 +5316,17 @@ function formatCachedCredentialState(state) {
   }
   return state.status === "fresh" ? `${age}, expires in ${formatAge(state.expiresInMs)}` : `${age}, expired ${formatAge(-state.expiresInMs)} ago`;
 }
-var import_zod11, MS_PER_UNIT, CachedCredentialSchema;
+var import_zod12, MS_PER_UNIT, CachedCredentialSchema;
 var init_credentialCache = __esm({
   "src/credentialCache.ts"() {
     "use strict";
-    import_zod11 = require("zod");
+    import_zod12 = require("zod");
     init_schema();
     init_preflight();
     MS_PER_UNIT = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
-    CachedCredentialSchema = import_zod11.z.strictObject({
-      token: import_zod11.z.string().min(1),
-      fetchedAt: import_zod11.z.number().int().nonnegative(),
+    CachedCredentialSchema = import_zod12.z.strictObject({
+      token: import_zod12.z.string().min(1),
+      fetchedAt: import_zod12.z.number().int().nonnegative(),
       source: CredentialSourceSchema
     });
   }
@@ -5352,7 +5352,7 @@ function requireKeychain() {
   }
 }
 function security(args, stdin) {
-  const result = (0, import_node_child_process2.spawnSync)("security", args, { encoding: "utf8", ...stdin === void 0 ? {} : { input: stdin }, stdio: ["pipe", "pipe", "ignore"] });
+  const result = (0, import_node_child_process3.spawnSync)("security", args, { encoding: "utf8", ...stdin === void 0 ? {} : { input: stdin }, stdio: ["pipe", "pipe", "ignore"] });
   return { status: result.status, stdout: result.stdout };
 }
 function createRealCredentialCache(root) {
@@ -5403,11 +5403,11 @@ function createRealCredentialCache(root) {
 function realCredentialCacheEnv(paths) {
   return { port: createRealCredentialCache(paths.root), platform: process.platform, now: () => Date.now() };
 }
-var import_node_child_process2, import_node_fs5, import_node_path23, KEYCHAIN_CACHE_SERVICE, CACHE_DIR_MODE, CACHE_FILE_MODE;
+var import_node_child_process3, import_node_fs5, import_node_path23, KEYCHAIN_CACHE_SERVICE, CACHE_DIR_MODE, CACHE_FILE_MODE;
 var init_realCredentialCache = __esm({
   "src/realCredentialCache.ts"() {
     "use strict";
-    import_node_child_process2 = require("node:child_process");
+    import_node_child_process3 = require("node:child_process");
     import_node_fs5 = __toESM(require("node:fs"), 1);
     import_node_path23 = __toESM(require("node:path"), 1);
     init_credentialCache();
@@ -5928,7 +5928,7 @@ var init_envBool = __esm({
 });
 
 // src/launcher/claudeVersion.ts
-function validated(value, origin) {
+function validated2(value, origin) {
   if (!NUMERIC_DOTTED_VERSION_RE.test(value)) {
     throw new InvalidClaudeVersionError(value, origin);
   }
@@ -5936,11 +5936,11 @@ function validated(value, origin) {
 }
 function resolveClaudeVersion(params) {
   if (params.flag !== void 0) {
-    return { version: validated(params.flag, "--claude-version"), source: "flag" };
+    return { version: validated2(params.flag, "--claude-version"), source: "flag" };
   }
   const fromEnv = params.env.AGENT_SHIM_CLAUDE_VERSION;
   if (fromEnv !== void 0 && fromEnv !== "") {
-    return { version: validated(fromEnv, "AGENT_SHIM_CLAUDE_VERSION"), source: "environment" };
+    return { version: validated2(fromEnv, "AGENT_SHIM_CLAUDE_VERSION"), source: "environment" };
   }
   return params.cascade === void 0 ? void 0 : { version: params.cascade, source: "cascade" };
 }
@@ -6067,21 +6067,21 @@ function findPathShadow(params) {
   }
   return params.pathDirs.some((dir) => import_node_path26.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
 }
-var import_node_fs7, import_node_path26, import_zod15, ClaudeShimStateSchema, nodeLinkFs;
+var import_node_fs7, import_node_path26, import_zod16, ClaudeShimStateSchema, nodeLinkFs;
 var init_claudeShim = __esm({
   "src/claudeShim.ts"() {
     "use strict";
     import_node_fs7 = __toESM(require("node:fs"), 1);
     import_node_path26 = __toESM(require("node:path"), 1);
-    import_zod15 = require("zod");
+    import_zod16 = require("zod");
     init_commandDeps();
     init_store();
     init_realPorts();
     init_cliError();
-    ClaudeShimStateSchema = import_zod15.z.strictObject({
-      targetPath: import_zod15.z.string().min(1),
-      method: import_zod15.z.enum(["hardlink", "copy"]),
-      installedAtMs: import_zod15.z.number()
+    ClaudeShimStateSchema = import_zod16.z.strictObject({
+      targetPath: import_zod16.z.string().min(1),
+      method: import_zod16.z.enum(["hardlink", "copy"]),
+      installedAtMs: import_zod16.z.number()
     });
     nodeLinkFs = { link: import_node_fs7.default.linkSync, copyFile: import_node_fs7.default.copyFileSync, chmod: import_node_fs7.default.chmodSync };
   }
@@ -6567,7 +6567,7 @@ function buildEnv(params) {
   const parentCustomHeaders = params.baseEnv.ANTHROPIC_CUSTOM_HEADERS;
   let providerCustomHeaders;
   if (!params.configDirEscapeHatch && params.resolvedIdentityName !== void 0) {
-    env.CLAUDE_CONFIG_DIR = import_node_path32.default.join(params.identitiesDir, params.resolvedIdentityName);
+    env.CLAUDE_CONFIG_DIR = import_node_path33.default.join(params.identitiesDir, params.resolvedIdentityName);
   }
   if (params.provider !== void 0) {
     const providerEnv = params.provider.definition.env ?? {};
@@ -6611,11 +6611,11 @@ function buildEnv(params) {
   }
   return env;
 }
-var import_node_path32, LOOPBACK_HOSTS;
+var import_node_path33, LOOPBACK_HOSTS;
 var init_flags = __esm({
   "src/launcher/flags.ts"() {
     "use strict";
-    import_node_path32 = __toESM(require("node:path"), 1);
+    import_node_path33 = __toESM(require("node:path"), 1);
     init_envBool();
     init_credential();
     init_headers();
@@ -6938,7 +6938,7 @@ function decideLaunch(params, readOnly) {
     identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
     globalDefaultConfigProfile: params.globalDefaultConfigProfile
   });
-  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path33.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path34.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
     log.error(
       `agent-shim: no configuration profile named "${configProfileDecision.name}" (selected via ${configProfileDecision.source}). Run \`agent-shim profile add ${configProfileDecision.name}\` first.`
     );
@@ -7050,7 +7050,7 @@ function decideLaunch(params, readOnly) {
     extraFlags: splitExtraFlags(env.CLAUDE_EXTRA_FLAGS),
     passthrough: parsedArgv.rest
   });
-  const configDir = configDirEscapeHatchApplies || identityDecision.name === void 0 ? env.CLAUDE_CONFIG_DIR : import_node_path33.default.join(paths.identitiesDir, identityDecision.name);
+  const configDir = configDirEscapeHatchApplies || identityDecision.name === void 0 ? env.CLAUDE_CONFIG_DIR : import_node_path34.default.join(paths.identitiesDir, identityDecision.name);
   const decision = {
     identitySource: identityDecision.source,
     configDirEscapeHatch: identityDecision.configDirEscapeHatch,
@@ -7091,7 +7091,7 @@ function prepareLaunch(params) {
   );
   const updateCheck = runLaunchUpdateCheck({
     mode: params.updateMode ?? "off",
-    checkPath: import_node_path33.default.join(paths.root, "update.check"),
+    checkPath: import_node_path34.default.join(paths.root, "update.check"),
     currentVersion: package_default.version,
     port: params.update
   });
@@ -7207,10 +7207,10 @@ function resolveLaunch(params) {
     environment
   };
 }
-function runLaunchPlan(plan, spawn2) {
+function runLaunchPlan(plan, spawn3) {
   try {
     plan.markChildStarted();
-    const result = spawn2.spawnSync(plan.bin, plan.args, { stdio: "inherit", env: plan.env });
+    const result = spawn3.spawnSync(plan.bin, plan.args, { stdio: "inherit", env: plan.env });
     if (result.error !== void 0) {
       throw result.error;
     }
@@ -7222,12 +7222,12 @@ function runLaunchPlan(plan, spawn2) {
 function runLauncher(params) {
   params.proc.exit(runLaunchPlan(prepareLaunch(params), params.spawn));
 }
-var import_node_crypto10, import_node_path33;
+var import_node_crypto10, import_node_path34;
 var init_launcher = __esm({
   "src/launcher.ts"() {
     "use strict";
     import_node_crypto10 = require("node:crypto");
-    import_node_path33 = __toESM(require("node:path"), 1);
+    import_node_path34 = __toESM(require("node:path"), 1);
     init_package();
     init_envBool();
     init_argv();
@@ -7258,13 +7258,13 @@ function agentShimCliPath(distDir = typeof __AGENT_SHIM_DIST_DIR__ === "string"
   if (distDir === void 0) {
     throw new OwnCliPathUnknownError();
   }
-  return import_node_path34.default.join(distDir, OWN_CLI_FILE_NAME);
+  return import_node_path35.default.join(distDir, OWN_CLI_FILE_NAME);
 }
-var import_node_path34, OWN_CLI_FILE_NAME, OwnCliPathUnknownError;
+var import_node_path35, OWN_CLI_FILE_NAME, OwnCliPathUnknownError;
 var init_ownCli = __esm({
   "src/ownCli.ts"() {
     "use strict";
-    import_node_path34 = __toESM(require("node:path"), 1);
+    import_node_path35 = __toESM(require("node:path"), 1);
     init_cliError();
     OWN_CLI_FILE_NAME = "cli.cjs";
     OwnCliPathUnknownError = class extends CliError {
@@ -7349,7 +7349,7 @@ request.on("error", (error) => finish(failed, (error.code ? error.code + ": " :
 // src/frontdoor/trust.ts
 function resolveTrustBundle(params) {
   const { caCertFile, bundlesDir, variable, inherited, fs: fs12 } = params;
-  if (inherited === void 0 || inherited === "" || import_node_path35.default.resolve(inherited) === import_node_path35.default.resolve(caCertFile)) {
+  if (inherited === void 0 || inherited === "" || import_node_path36.default.resolve(inherited) === import_node_path36.default.resolve(caCertFile)) {
     return { path: caCertFile };
   }
   const caPem = fs12.readFileUtf8(caCertFile);
@@ -7367,19 +7367,19 @@ function resolveTrustBundle(params) {
   }
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
-  const bundle = import_node_path35.default.join(bundlesDir, `${(0, import_node_crypto11.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  const bundle = import_node_path36.default.join(bundlesDir, `${(0, import_node_crypto11.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
   if (!fs12.exists(bundle)) {
     fs12.mkdirp(bundlesDir);
     fs12.writeFileAtomic(bundle, combined);
   }
   return { path: bundle };
 }
-var import_node_crypto11, import_node_path35, BUNDLE_NAME_HEX_DIGITS;
+var import_node_crypto11, import_node_path36, BUNDLE_NAME_HEX_DIGITS;
 var init_trust = __esm({
   "src/frontdoor/trust.ts"() {
     "use strict";
     import_node_crypto11 = require("node:crypto");
-    import_node_path35 = __toESM(require("node:path"), 1);
+    import_node_path36 = __toESM(require("node:path"), 1);
     BUNDLE_NAME_HEX_DIGITS = 16;
   }
 });
@@ -7717,11 +7717,11 @@ var init_anthropicUsageRefresh = __esm({
 });
 
 // src/usage/providerQuota.ts
-var import_zod23, MS_PER_SECOND7, SECONDS_PER_HOUR, HOURS_PER_DAY3, DAYS_PER_MONTH, ZAI_HOST, ZAI_QUOTA_URL, ZAI_UNIT_HOURS, ZAI_UNIT_MONTHS, ZAI_UNIT_MS, ZaiLimitSchema, ZaiResponseSchema, OPENROUTER_HOST, OPENROUTER_KEY_URL, OPENROUTER_CREDITS_URL, MS_PER_DAY3, OpenRouterKeySchema, OpenRouterCreditsSchema;
+var import_zod24, MS_PER_SECOND7, SECONDS_PER_HOUR, HOURS_PER_DAY3, DAYS_PER_MONTH, ZAI_HOST, ZAI_QUOTA_URL, ZAI_UNIT_HOURS, ZAI_UNIT_MONTHS, ZAI_UNIT_MS, ZaiLimitSchema, ZaiResponseSchema, OPENROUTER_HOST, OPENROUTER_KEY_URL, OPENROUTER_CREDITS_URL, MS_PER_DAY3, OpenRouterKeySchema, OpenRouterCreditsSchema;
 var init_providerQuota = __esm({
   "src/usage/providerQuota.ts"() {
     "use strict";
-    import_zod23 = require("zod");
+    import_zod24 = require("zod");
     init_schema2();
     MS_PER_SECOND7 = 1e3;
     SECONDS_PER_HOUR = 3600;
@@ -7735,35 +7735,35 @@ var init_providerQuota = __esm({
       [ZAI_UNIT_HOURS, SECONDS_PER_HOUR * MS_PER_SECOND7],
       [ZAI_UNIT_MONTHS, DAYS_PER_MONTH * HOURS_PER_DAY3 * SECONDS_PER_HOUR * MS_PER_SECOND7]
     ]);
-    ZaiLimitSchema = import_zod23.z.object({
-      type: import_zod23.z.string(),
-      unit: import_zod23.z.number().int(),
-      number: import_zod23.z.number().int().positive(),
-      percentage: import_zod23.z.number().nonnegative(),
-      nextResetTime: import_zod23.z.number().positive().optional(),
-      usage: import_zod23.z.number().nonnegative().optional(),
-      currentValue: import_zod23.z.number().nonnegative().optional(),
-      remaining: import_zod23.z.number().nonnegative().optional()
+    ZaiLimitSchema = import_zod24.z.object({
+      type: import_zod24.z.string(),
+      unit: import_zod24.z.number().int(),
+      number: import_zod24.z.number().int().positive(),
+      percentage: import_zod24.z.number().nonnegative(),
+      nextResetTime: import_zod24.z.number().positive().optional(),
+      usage: import_zod24.z.number().nonnegative().optional(),
+      currentValue: import_zod24.z.number().nonnegative().optional(),
+      remaining: import_zod24.z.number().nonnegative().optional()
     });
-    ZaiResponseSchema = import_zod23.z.object({
-      success: import_zod23.z.boolean(),
-      msg: import_zod23.z.string().optional(),
-      data: import_zod23.z.object({ level: import_zod23.z.string().optional(), limits: import_zod23.z.array(ZaiLimitSchema) })
+    ZaiResponseSchema = import_zod24.z.object({
+      success: import_zod24.z.boolean(),
+      msg: import_zod24.z.string().optional(),
+      data: import_zod24.z.object({ level: import_zod24.z.string().optional(), limits: import_zod24.z.array(ZaiLimitSchema) })
     });
     OPENROUTER_HOST = "openrouter.ai";
     OPENROUTER_KEY_URL = `https://${OPENROUTER_HOST}/api/v1/key`;
     OPENROUTER_CREDITS_URL = `https://${OPENROUTER_HOST}/api/v1/credits`;
     MS_PER_DAY3 = HOURS_PER_DAY3 * SECONDS_PER_HOUR * MS_PER_SECOND7;
-    OpenRouterKeySchema = import_zod23.z.object({
-      data: import_zod23.z.object({
-        limit: import_zod23.z.number().nonnegative().nullable(),
-        limit_remaining: import_zod23.z.number().nullable(),
-        limit_reset: import_zod23.z.string().nullable(),
-        is_free_tier: import_zod23.z.boolean().optional(),
-        free_model_daily_requests: import_zod23.z.object({ used: import_zod23.z.number().nonnegative(), limit: import_zod23.z.number().nonnegative(), remaining: import_zod23.z.number() }).optional()
+    OpenRouterKeySchema = import_zod24.z.object({
+      data: import_zod24.z.object({
+        limit: import_zod24.z.number().nonnegative().nullable(),
+        limit_remaining: import_zod24.z.number().nullable(),
+        limit_reset: import_zod24.z.string().nullable(),
+        is_free_tier: import_zod24.z.boolean().optional(),
+        free_model_daily_requests: import_zod24.z.object({ used: import_zod24.z.number().nonnegative(), limit: import_zod24.z.number().nonnegative(), remaining: import_zod24.z.number() }).optional()
       })
     });
-    OpenRouterCreditsSchema = import_zod23.z.object({ data: import_zod23.z.object({ total_credits: import_zod23.z.number().nonnegative(), total_usage: import_zod23.z.number().nonnegative() }) });
+    OpenRouterCreditsSchema = import_zod24.z.object({ data: import_zod24.z.object({ total_credits: import_zod24.z.number().nonnegative(), total_usage: import_zod24.z.number().nonnegative() }) });
   }
 });
 
@@ -7885,6 +7885,8 @@ var index_exports = {};
 __export(index_exports, {
   AMBIENT_CREDENTIAL_VARS: () => AMBIENT_CREDENTIAL_VARS,
   CHECK_CREDENTIAL_APPLIES: () => CHECK_CREDENTIAL_APPLIES,
+  CODEX_APP_SERVER_GENERATED_AGAINST: () => CODEX_APP_SERVER_GENERATED_AGAINST,
+  CODEX_APP_SERVER_TIMEOUT_MS: () => CODEX_APP_SERVER_TIMEOUT_MS,
   CONNECT_INTERCEPT_HOST: () => CONNECT_INTERCEPT_HOST,
   CONNECT_INTERCEPT_HOSTS: () => CONNECT_INTERCEPT_HOSTS,
   CONNECT_LIMITS: () => CONNECT_LIMITS,
@@ -7895,7 +7897,12 @@ __export(index_exports, {
   CheckReportJsonSchema: () => CheckReportJsonSchema,
   CheckRunInputSchema: () => CheckRunInputSchema,
   CliError: () => CliError,
+  CodexAccountReadSchema: () => CodexAccountReadSchema,
+  CodexAppServerProtocolError: () => CodexAppServerProtocolError,
+  CodexAppServerRequestError: () => CodexAppServerRequestError,
+  CodexAppServerUnavailableError: () => CodexAppServerUnavailableError,
   CodexLogoutOutputSchema: () => CodexLogoutOutputSchema,
+  CodexRateLimitsReadSchema: () => CodexRateLimitsReadSchema,
   CodexSignInSchema: () => CodexSignInSchema,
   CodexStatusOutputSchema: () => CodexStatusOutputSchema,
   ConfigIdentityAddOutputSchema: () => ConfigIdentityAddOutputSchema,
@@ -8153,6 +8160,8 @@ __export(index_exports, {
   rcSelfHostFromEnv: () => rcSelfHostFromEnv,
   rcWebFetchAllowsPrivateFromEnv: () => rcWebFetchAllowsPrivateFromEnv,
   readActiveIdentity: () => readActiveIdentity2,
+  readCodexAccount: () => readCodexAccount,
+  readCodexRateLimits: () => readCodexRateLimits,
   readDirectoryRules: () => readDirectoryRules,
   readFarmManifest: () => readFarmManifest,
   readFrontDoorControlMaterial: () => readFrontDoorControlMaterial,
@@ -8164,6 +8173,7 @@ __export(index_exports, {
   readRcSelfHostRecord: () => readRcSelfHostRecord,
   readRcSessionFile: () => readRcSessionFile,
   readUsageSnapshot: () => readUsageSnapshot,
+  realCodexAppServerPort: () => realCodexAppServerPort,
   realConnectCertStore: () => realConnectCertStore,
   realConnectEffects: () => realConnectEffects,
   realRcControlTransport: () => realRcControlTransport,
@@ -8723,8 +8733,8 @@ function parseConnectTarget(authority) {
 function isInterceptedHost(host, interceptHosts) {
   return interceptHosts.includes(host);
 }
-function servedByPipeline(path36) {
-  return path36?.startsWith(ROUTED_PATH_PREFIX) === true;
+function servedByPipeline(path37) {
+  return path37?.startsWith(ROUTED_PATH_PREFIX) === true;
 }
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
@@ -9259,11 +9269,11 @@ function createRcSessionTracker(deps) {
   };
   const observeExchange = (request4) => {
     const method = (request4.method ?? "").toUpperCase();
-    const path36 = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
-    if (!path36.startsWith(RC_SESSIONS_PATH_PREFIX)) {
+    const path37 = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
+    if (!path37.startsWith(RC_SESSIONS_PATH_PREFIX)) {
       return void 0;
     }
-    const tail = path36.slice(RC_SESSIONS_PATH_PREFIX.length);
+    const tail = path37.slice(RC_SESSIONS_PATH_PREFIX.length);
     const facts = {
       oauthAuthorization: oauthAuthorizationOf(request4.headers),
       anthropicVersion: singleHeader(request4.headers, "anthropic-version"),
@@ -9645,8 +9655,8 @@ var RC_READ_FILE_ENCODINGS = ["utf-8", "base64"];
 function isRcReadFileEncoding(value) {
   return RC_READ_FILE_ENCODINGS.some((encoding) => encoding === value);
 }
-function buildRcReadFilePayload(requestId, path36, options) {
-  return buildRcControlRequestPayload(requestId, { subtype: "read_file", path: path36, ...options?.maxBytes === void 0 ? {} : { max_bytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } });
+function buildRcReadFilePayload(requestId, path37, options) {
+  return buildRcControlRequestPayload(requestId, { subtype: "read_file", path: path37, ...options?.maxBytes === void 0 ? {} : { max_bytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } });
 }
 function buildRcFileSuggestionsPayload(requestId, query) {
   return buildRcControlRequestPayload(requestId, { subtype: "file_suggestions", query });
@@ -9748,15 +9758,15 @@ async function getRcSessionContextUsage(deps, sessionId, detail) {
   const result = await deliverRcClientPayload(deps, sessionId, buildRcGetContextUsagePayload(requestId, detail), `request the context usage of session ${sessionId}`);
   return result.ok ? { ...result, requestId } : result;
 }
-async function readRcSessionFile(deps, sessionId, path36, options) {
-  if (path36 === "") {
+async function readRcSessionFile(deps, sessionId, path37, options) {
+  if (path37 === "") {
     return { ok: false, message: "a read-file write needs a non-empty path: the SDK's own field names the file the worker resolves against the session's cwd, and an empty string names none" };
   }
   if (options?.maxBytes !== void 0 && (!Number.isInteger(options.maxBytes) || options.maxBytes <= 0)) {
     return { ok: false, message: "a read-file write's max-bytes is a positive whole number of bytes: the SDK's own field caps the read, and a zero or negative cap reads nothing" };
   }
   const requestId = deps.newUuid();
-  const result = await deliverRcClientPayload(deps, sessionId, buildRcReadFilePayload(requestId, path36, options), `read ${path36} from session ${sessionId}`);
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcReadFilePayload(requestId, path37, options), `read ${path37} from session ${sessionId}`);
   return result.ok ? { ...result, requestId } : result;
 }
 async function suggestRcSessionFiles(deps, sessionId, query) {
@@ -9925,11 +9935,11 @@ function createRcControlHandler(deps) {
       path: "read-file",
       read: (body) => {
         const session = bodyString(body, "session");
-        const path36 = bodyString(body, "path");
+        const path37 = bodyString(body, "path");
         const maxBytes = "maxBytes" in body ? bodyPositiveInteger(body, "maxBytes") : void 0;
         const encoding = "encoding" in body && isRcReadFileEncoding(body.encoding) ? body.encoding : void 0;
-        const refused2 = session === void 0 || path36 === void 0 || "maxBytes" in body && maxBytes === void 0 || "encoding" in body && encoding === void 0;
-        return refused2 ? { error: `the read-file body must be JSON naming a non-empty session id and path, maxBytes only as a positive whole number or absent, and an encoding the SDK's own type permits (${RC_READ_FILE_ENCODINGS.join(", ")}) or none` } : { session, run: async () => await deps.readFile(session, path36, { ...maxBytes === void 0 ? {} : { maxBytes }, ...encoding === void 0 ? {} : { encoding } }) };
+        const refused2 = session === void 0 || path37 === void 0 || "maxBytes" in body && maxBytes === void 0 || "encoding" in body && encoding === void 0;
+        return refused2 ? { error: `the read-file body must be JSON naming a non-empty session id and path, maxBytes only as a positive whole number or absent, and an encoding the SDK's own type permits (${RC_READ_FILE_ENCODINGS.join(", ")}) or none` } : { session, run: async () => await deps.readFile(session, path37, { ...maxBytes === void 0 ? {} : { maxBytes }, ...encoding === void 0 ? {} : { encoding } }) };
       }
     },
     {
@@ -10239,9 +10249,9 @@ function requestIdOfBody(body) {
 }
 function frontDoorRcControl(transport, token) {
   const headers = { authorization: `Bearer ${token}` };
-  const listAnswerOf = async (path36, what) => {
+  const listAnswerOf = async (path37, what) => {
     try {
-      return await transport.request({ method: "GET", path: path36, headers });
+      return await transport.request({ method: "GET", path: path37, headers });
     } catch (error) {
       throw new Error(`${what}: could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
@@ -10313,10 +10323,10 @@ function frontDoorRcControl(transport, token) {
     }
     return pending;
   };
-  const writeOf = async (path36, body, describeFailure) => {
+  const writeOf = async (path37, body, describeFailure) => {
     let answer;
     try {
-      answer = await transport.request({ method: "POST", path: path36, headers: { ...headers, "content-type": "application/json" }, body });
+      answer = await transport.request({ method: "POST", path: path37, headers: { ...headers, "content-type": "application/json" }, body });
     } catch (error) {
       return { ok: false, message: `could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}` };
     }
@@ -10347,10 +10357,10 @@ function frontDoorRcControl(transport, token) {
     endSession: async (sessionId, reason) => await writeOf(`${CONTROL_PATH_PREFIX}/end-session`, JSON.stringify({ session: sessionId, ...reason === void 0 ? {} : { reason } }), (status, message) => `ending ${sessionId} failed (HTTP ${String(status)}): ${message}`),
     getUsage: async (sessionId, skipBehaviors) => await writeOf(`${CONTROL_PATH_PREFIX}/get-usage`, JSON.stringify({ session: sessionId, ...skipBehaviors === void 0 ? {} : { skipBehaviors } }), (status, message) => `requesting the usage of ${sessionId} failed (HTTP ${String(status)}): ${message}`),
     getContextUsage: async (sessionId, detail) => await writeOf(`${CONTROL_PATH_PREFIX}/get-context-usage`, JSON.stringify({ session: sessionId, ...detail === void 0 ? {} : { detail } }), (status, message) => `requesting the context usage of ${sessionId} failed (HTTP ${String(status)}): ${message}`),
-    readFile: async (sessionId, path36, options) => await writeOf(
+    readFile: async (sessionId, path37, options) => await writeOf(
       `${CONTROL_PATH_PREFIX}/read-file`,
-      JSON.stringify({ session: sessionId, path: path36, ...options?.maxBytes === void 0 ? {} : { maxBytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } }),
-      (status, message) => `reading ${path36} from ${sessionId} failed (HTTP ${String(status)}): ${message}`
+      JSON.stringify({ session: sessionId, path: path37, ...options?.maxBytes === void 0 ? {} : { maxBytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } }),
+      (status, message) => `reading ${path37} from ${sessionId} failed (HTTP ${String(status)}): ${message}`
     ),
     fileSuggestions: async (sessionId, query) => await writeOf(`${CONTROL_PATH_PREFIX}/file-suggestions`, JSON.stringify({ session: sessionId, query }), (status, message) => `requesting file suggestions from ${sessionId} failed (HTTP ${String(status)}): ${message}`),
     keepAlive: async (sessionId) => await writeOf(`${CONTROL_PATH_PREFIX}/keep-alive`, JSON.stringify({ session: sessionId }), (status, message) => `keeping ${sessionId} alive failed (HTTP ${String(status)}): ${message}`),
@@ -10509,12 +10519,12 @@ function tlsFacts(options) {
 }
 function realRcEventDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
   const agent = new ExemptTlsAgent();
-  const post = async (path36, headers, body) => await new Promise((resolve, reject) => {
+  const post = async (path37, headers, body) => await new Promise((resolve, reject) => {
     const options = {
       host: target.host,
       port: target.port,
       method: "POST",
-      path: path36,
+      path: path37,
       // The Host header names the host whose API this is, not the address dialled: a redirected test dials a loopback stand-in while still speaking to the API host by name, exactly as the forwarded paths present their SNI.
       headers: { ...headers, host: target.servername ?? target.host, "content-length": String(Buffer.byteLength(body, "utf8")) },
       agent
@@ -10579,12 +10589,12 @@ function lateRcStreamDial(resolve) {
 }
 function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
   const agent = new ExemptTlsAgent();
-  const request4 = async (method, path36, headers, body, signal) => await new Promise((resolve, reject) => {
+  const request4 = async (method, path37, headers, body, signal) => await new Promise((resolve, reject) => {
     const options = {
       host: target.host,
       port: target.port,
       method,
-      path: path36,
+      path: path37,
       // The Host header names the host whose API this is, not the address dialled: a redirected test dials a loopback stand-in while still speaking to the API host by name, exactly as the forwarded paths present their SNI.
       headers: { ...headers, host: target.servername ?? target.host, ...body === void 0 ? {} : { "content-length": String(Buffer.byteLength(body, "utf8")) } },
       agent,
@@ -10626,9 +10636,9 @@ function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_P
       return { status, body: await readAll(response) };
     },
     openStream: async (sessionId, headers, resume, signal) => {
-      const path36 = resume === void 0 ? `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream` : `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream?from_sequence_num=${String(resume.fromSequenceNum)}`;
+      const path37 = resume === void 0 ? `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream` : `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream?from_sequence_num=${String(resume.fromSequenceNum)}`;
       const streamHeaders = resume === void 0 ? headers : { ...headers, "last-event-id": String(resume.fromSequenceNum) };
-      const { status, response } = await request4("GET", path36, streamHeaders, void 0, signal);
+      const { status, response } = await request4("GET", path37, streamHeaders, void 0, signal);
       if (!isSuccessful2(status)) {
         await readAll(response);
         return { status, chunks: NO_CHUNKS };
@@ -11268,6 +11278,242 @@ function frontDoorRcApiClient(port, ca, token) {
   return (0, import_client.createORPCClient)(frontDoorApiLink(port, ca, token));
 }
 
+// src/codex/appServer.ts
+init_cliError();
+init_package();
+
+// src/codex/appServerSchemas.ts
+var import_zod5 = require("zod");
+var CODEX_APP_SERVER_GENERATED_AGAINST = "0.160.0";
+var RateLimitWindowSchema = import_zod5.z.object({
+  usedPercent: import_zod5.z.number(),
+  resetsAt: import_zod5.z.number().nullish(),
+  windowDurationMins: import_zod5.z.number().nullish()
+});
+var RateLimitSnapshotSchema = import_zod5.z.object({
+  limitId: import_zod5.z.string().nullish(),
+  limitName: import_zod5.z.string().nullish(),
+  planType: import_zod5.z.string().nullish(),
+  primary: RateLimitWindowSchema.nullish(),
+  secondary: RateLimitWindowSchema.nullish(),
+  rateLimitReachedType: import_zod5.z.string().nullish(),
+  spendControlReached: import_zod5.z.boolean().nullish()
+});
+var RateLimitResetCreditSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  grantedAt: import_zod5.z.number(),
+  expiresAt: import_zod5.z.number().nullish(),
+  resetType: import_zod5.z.string(),
+  status: import_zod5.z.string(),
+  title: import_zod5.z.string().nullish(),
+  description: import_zod5.z.string().nullish()
+});
+var CodexAccountSchema = import_zod5.z.discriminatedUnion("type", [
+  import_zod5.z.object({ type: import_zod5.z.literal("apiKey") }),
+  import_zod5.z.object({ type: import_zod5.z.literal("chatgpt"), email: import_zod5.z.string().nullable(), planType: import_zod5.z.string() }),
+  import_zod5.z.object({ type: import_zod5.z.literal("amazonBedrock"), usesCodexManagedCredentials: import_zod5.z.boolean().default(false) })
+]);
+var CodexAccountReadSchema = import_zod5.z.object({
+  account: CodexAccountSchema.nullable(),
+  requiresOpenaiAuth: import_zod5.z.boolean()
+});
+var CodexRateLimitsReadSchema = import_zod5.z.object({
+  rateLimits: RateLimitSnapshotSchema,
+  rateLimitsByLimitId: import_zod5.z.record(import_zod5.z.string(), RateLimitSnapshotSchema).nullish(),
+  rateLimitResetCredits: import_zod5.z.object({ availableCount: import_zod5.z.number(), credits: import_zod5.z.array(RateLimitResetCreditSchema).nullish() }).nullish(),
+  accountId: import_zod5.z.string().nullish(),
+  ordinaryUsageAllowed: import_zod5.z.boolean().nullish()
+});
+var CodexInitializeResultSchema = import_zod5.z.object({ userAgent: import_zod5.z.string() });
+
+// src/codex/appServer.ts
+var CodexAppServerUnavailableError = class extends CliError {
+  constructor(detail) {
+    super(`The Codex app-server is not available: ${detail}.`);
+    this.name = "CodexAppServerUnavailableError";
+  }
+};
+var CodexAppServerRequestError = class extends CliError {
+  constructor(method, rpcCode, detail) {
+    super(`Codex app-server ${method} failed (${String(rpcCode)}): ${detail}`);
+    this.method = method;
+    this.rpcCode = rpcCode;
+    this.name = "CodexAppServerRequestError";
+  }
+  method;
+  rpcCode;
+};
+var CodexAppServerProtocolError = class extends CliError {
+  constructor(method, installedVersion, detail) {
+    super(
+      `Codex app-server ${method} answered in a shape this reader does not know (installed Codex ${installedVersion ?? "of unknown version"}, shapes generated against ${CODEX_APP_SERVER_GENERATED_AGAINST}): ${detail}`
+    );
+    this.method = method;
+    this.installedVersion = installedVersion;
+    this.name = "CodexAppServerProtocolError";
+  }
+  method;
+  installedVersion;
+};
+var CODEX_APP_SERVER_TIMEOUT_MS = 3e4;
+var CLIENT_NAME = "agent-shim";
+function installedVersionOf(userAgent) {
+  return /^[^/\s]+\/(\S+)/.exec(userAgent)?.[1];
+}
+function responseTo(message, id) {
+  if (typeof message !== "object" || message === null || !("id" in message) || message.id !== id) {
+    return void 0;
+  }
+  if ("error" in message && typeof message.error === "object" && message.error !== null) {
+    const { error } = message;
+    const code = "code" in error && typeof error.code === "number" ? error.code : 0;
+    const detail = "message" in error && typeof error.message === "string" ? error.message : "no message";
+    return { error: { code, message: detail } };
+  }
+  return "result" in message ? { result: message.result } : void 0;
+}
+async function withAppServer(port, options, ask) {
+  const connection = await port.open({ bin: options.bin ?? "codex", codexHome: options.codexHome });
+  let nextId = 0;
+  const timeoutMs = options.timeoutMs ?? CODEX_APP_SERVER_TIMEOUT_MS;
+  const stopper = AbortSignal.any([...options.signal === void 0 ? [] : [options.signal], AbortSignal.timeout(timeoutMs)]);
+  const stopReason = () => {
+    if (options.signal?.aborted !== true) {
+      return new CodexAppServerUnavailableError(`it did not answer within ${String(timeoutMs)} ms`);
+    }
+    const reason = options.signal.reason;
+    return reason instanceof Error ? reason : new Error(`the Codex app-server read was aborted: ${String(reason)}`);
+  };
+  const aborted = new Promise((_resolve, reject) => {
+    if (stopper.aborted) {
+      reject(stopReason());
+      return;
+    }
+    stopper.addEventListener(
+      "abort",
+      () => {
+        reject(stopReason());
+      },
+      { once: true }
+    );
+  });
+  aborted.catch(() => void 0);
+  const request4 = async (method, params) => {
+    nextId += 1;
+    const id = nextId;
+    connection.send({ jsonrpc: "2.0", id, method, params });
+    for (; ; ) {
+      const message = await Promise.race([connection.receive(), aborted]);
+      if (message === void 0) {
+        throw new CodexAppServerUnavailableError(`it ended before answering ${method}`);
+      }
+      const response = responseTo(message, id);
+      if (response === void 0) {
+        continue;
+      }
+      if ("error" in response) {
+        throw new CodexAppServerRequestError(method, response.error.code, response.error.message);
+      }
+      return response.result;
+    }
+  };
+  try {
+    const initialised = CodexInitializeResultSchema.safeParse(await request4("initialize", { clientInfo: { name: CLIENT_NAME, title: null, version: package_default.version } }));
+    if (!initialised.success) {
+      throw new CodexAppServerProtocolError("initialize", void 0, initialised.error.message);
+    }
+    connection.send({ jsonrpc: "2.0", method: "initialized" });
+    return await ask(request4, installedVersionOf(initialised.data.userAgent));
+  } finally {
+    await connection.close();
+  }
+}
+function validated(method, installedVersion, schema, value) {
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    throw new CodexAppServerProtocolError(method, installedVersion, parsed.error.message);
+  }
+  return parsed.data;
+}
+async function readCodexAccount(port, options) {
+  return await withAppServer(port, options, async (request4, version) => validated("account/read", version, CodexAccountReadSchema, await request4("account/read", { refreshToken: false })));
+}
+async function readCodexRateLimits(port, options) {
+  return await withAppServer(port, options, async (request4, version) => validated("account/rateLimits/read", version, CodexRateLimitsReadSchema, await request4("account/rateLimits/read", void 0)));
+}
+
+// src/codex/realAppServer.ts
+var import_node_child_process = require("node:child_process");
+var import_node_readline = __toESM(require("node:readline"), 1);
+var SHUTDOWN_GRACE_MS = 5e3;
+var realCodexAppServerPort = {
+  open: async ({ bin, codexHome }) => {
+    const child = (0, import_node_child_process.spawn)(bin, ["app-server"], { stdio: ["pipe", "pipe", "ignore"], env: { ...process.env, CODEX_HOME: codexHome } });
+    await new Promise((resolve, reject) => {
+      child.once("spawn", resolve);
+      child.once("error", (error) => {
+        reject(new CodexAppServerUnavailableError(`${bin} could not be started (${error.message})`));
+      });
+    });
+    const exited = new Promise((resolve) => {
+      child.once("exit", () => {
+        resolve();
+      });
+    });
+    const pending = [];
+    const waiting = [];
+    let ended = false;
+    const deliver = (message) => {
+      const waiter = waiting.shift();
+      if (waiter === void 0) {
+        pending.push(message);
+      } else {
+        waiter(message);
+      }
+    };
+    const lines = import_node_readline.default.createInterface({ input: child.stdout });
+    lines.on("line", (line) => {
+      try {
+        deliver(JSON.parse(line));
+      } catch {
+      }
+    });
+    lines.on("close", () => {
+      ended = true;
+      for (const waiter of waiting.splice(0)) {
+        waiter(void 0);
+      }
+    });
+    const connection = {
+      send: (message) => {
+        child.stdin.write(`${JSON.stringify(message)}
+`);
+      },
+      receive: async () => {
+        if (pending.length > 0) {
+          return pending.shift();
+        }
+        if (ended) {
+          return void 0;
+        }
+        return await new Promise((resolve) => {
+          waiting.push(resolve);
+        });
+      },
+      close: async () => {
+        child.stdin.end();
+        const timer = setTimeout(() => {
+          child.kill("SIGKILL");
+        }, SHUTDOWN_GRACE_MS);
+        await exited;
+        clearTimeout(timer);
+        lines.close();
+      }
+    };
+    return connection;
+  }
+};
+
 // src/frontdoor/doorClient.ts
 init_cliError();
 init_realPorts();
@@ -11543,19 +11789,19 @@ function writePools(paths, pools) {
   applyPatch(paths.globalConfigFile, GlobalConfigSchema, { pools }, { defaults: {} });
 }
 function poolCycleOf(pools, name) {
-  const walk = (current, path36) => {
+  const walk = (current, path37) => {
     for (const entry of pools[current]?.identities ?? []) {
       const nested = poolNameOf(poolMemberIdentity(entry));
       if (nested === void 0) {
         continue;
       }
       if (nested === name) {
-        return [...path36, nested];
+        return [...path37, nested];
       }
-      if (path36.includes(nested)) {
+      if (path37.includes(nested)) {
         continue;
       }
-      const found = walk(nested, [...path36, nested]);
+      const found = walk(nested, [...path37, nested]);
       if (found !== void 0) {
         return found;
       }
@@ -11655,7 +11901,7 @@ init_realCredentialCache();
 init_providersStore();
 init_realPorts();
 var import_node_path25 = __toESM(require("node:path"), 1);
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 init_envBool();
 init_load();
 init_schema();
@@ -11743,9 +11989,9 @@ function lookupKeychainService(run, farmRoot) {
     note: serviceName === void 0 ? `A Keychain entry was found for account "${farmRoot}" but its service name could not be parsed from security's output.` : `Keychain service name for this identity: "${serviceName}".`
   };
 }
-var SettingsSecretsShapeSchema = import_zod12.z.looseObject({
-  env: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown()).optional(),
-  hooks: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.array(import_zod12.z.unknown())).optional()
+var SettingsSecretsShapeSchema = import_zod13.z.looseObject({
+  env: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()).optional(),
+  hooks: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.array(import_zod13.z.unknown())).optional()
 });
 function hookCommandCountOf(group) {
   if (typeof group !== "object" || group === null) {
@@ -12037,7 +12283,7 @@ function collectCheckReport(params) {
 }
 
 // src/checkReportSchema.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 init_schema();
 init_claudeVersion();
 init_identity();
@@ -12101,124 +12347,124 @@ var DIAGNOSTIC_CODES = [
 var DIAGNOSTIC_SEVERITIES = ["error", "warning", "info"];
 
 // src/usage/pickReportSchema.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 init_plan2();
-var PoolPickCandidateViewSchema = import_zod13.z.strictObject({
-  identity: import_zod13.z.string(),
+var PoolPickCandidateViewSchema = import_zod14.z.strictObject({
+  identity: import_zod14.z.string(),
   /** In pick order: `scored` has usable quota data, `unknown` has none, `pay-per-use` bills by use, `ineligible` is refused right now. */
-  class: import_zod13.z.enum(["scored", "unknown", "pay-per-use", "ineligible"]),
+  class: import_zod14.z.enum(["scored", "unknown", "pay-per-use", "ineligible"]),
   /** Plan-size-weighted remaining quota per hour until its reset; present for `scored` only. */
-  score: import_zod13.z.number().optional(),
+  score: import_zod14.z.number().optional(),
   /** Which window's reset divides the score: the seven-day window, or the five-hour one when the member reports no seven-day utilisation; present with `score`. */
-  scoreWindow: import_zod13.z.enum(["sevenDay", "fiveHour"]).optional(),
+  scoreWindow: import_zod14.z.enum(["sevenDay", "fiveHour"]).optional(),
   /** False when the five-hour window would run dry, at the observed pace, before it resets. */
-  feasible: import_zod13.z.boolean(),
+  feasible: import_zod14.z.boolean(),
   /** When an `ineligible` member can be used again, as an ISO instant. */
-  blockedUntil: import_zod13.z.iso.datetime().optional(),
+  blockedUntil: import_zod14.z.iso.datetime().optional(),
   plan: PlanClassSchema,
   /** The facts behind the class and score, in the order they matter. */
-  reasons: import_zod13.z.array(import_zod13.z.string())
+  reasons: import_zod14.z.array(import_zod14.z.string())
 });
-var PoolPickReportSchema = import_zod13.z.strictObject({
-  pool: import_zod13.z.string(),
-  directory: import_zod13.z.string(),
+var PoolPickReportSchema = import_zod14.z.strictObject({
+  pool: import_zod14.z.string(),
+  directory: import_zod14.z.string(),
   /** The member a launch would run as, absent when every member is refused. */
-  pick: import_zod13.z.string().optional(),
-  candidates: import_zod13.z.array(PoolPickCandidateViewSchema),
+  pick: import_zod14.z.string().optional(),
+  candidates: import_zod14.z.array(PoolPickCandidateViewSchema),
   /** Identity members anywhere in the pool's graph that do not exist; a launch skips them. */
-  missing: import_zod13.z.array(import_zod13.z.string()),
+  missing: import_zod14.z.array(import_zod14.z.string()),
   /** When nothing can be picked, the soonest any member returns. */
-  earliestReturn: import_zod13.z.strictObject({ identity: import_zod13.z.string(), at: import_zod13.z.iso.datetime() }).optional(),
+  earliestReturn: import_zod14.z.strictObject({ identity: import_zod14.z.string(), at: import_zod14.z.iso.datetime() }).optional(),
   /** The member a resumed conversation started on but moved off, and why, when the ranking could not keep it. */
-  movedOff: import_zod13.z.strictObject({ identity: import_zod13.z.string(), reason: import_zod13.z.string() }).optional(),
+  movedOff: import_zod14.z.strictObject({ identity: import_zod14.z.string(), reason: import_zod14.z.string() }).optional(),
   /** Why the last-pick record could not be read, when that is the case. */
-  stickyProblem: import_zod13.z.string().optional()
+  stickyProblem: import_zod14.z.string().optional()
 });
 
 // src/checkReportSchema.ts
 var CHECK_CREDENTIAL_APPLIES = ["provider", "identity", "stored-login"];
-var CheckLayerViewSchema = import_zod14.z.strictObject({
-  id: import_zod14.z.int(),
-  kind: import_zod14.z.enum(LAYER_KINDS),
-  source: import_zod14.z.string()
+var CheckLayerViewSchema = import_zod15.z.strictObject({
+  id: import_zod15.z.int(),
+  kind: import_zod15.z.enum(LAYER_KINDS),
+  source: import_zod15.z.string()
 });
-var CheckEntryViewSchema = import_zod14.z.strictObject({
-  path: import_zod14.z.string(),
-  shared: import_zod14.z.boolean(),
-  via: import_zod14.z.enum(DECISION_VIAS),
+var CheckEntryViewSchema = import_zod15.z.strictObject({
+  path: import_zod15.z.string(),
+  shared: import_zod15.z.boolean(),
+  via: import_zod15.z.enum(DECISION_VIAS),
   /** The entry's real category, or null when nothing classifies it. */
-  category: import_zod14.z.enum(CATEGORY_NAMES).nullable(),
-  rule: import_zod14.z.strictObject({ key: import_zod14.z.string(), layer: import_zod14.z.int() }).optional(),
+  category: import_zod15.z.enum(CATEGORY_NAMES).nullable(),
+  rule: import_zod15.z.strictObject({ key: import_zod15.z.string(), layer: import_zod15.z.int() }).optional(),
   /** Rules that matched but whose `when` condition failed, each with the conditions that failed. */
-  eliminated: import_zod14.z.readonly(import_zod14.z.array(import_zod14.z.strictObject({ key: import_zod14.z.string(), failed: import_zod14.z.readonly(import_zod14.z.array(import_zod14.z.string())) }))).optional()
+  eliminated: import_zod15.z.readonly(import_zod15.z.array(import_zod15.z.strictObject({ key: import_zod15.z.string(), failed: import_zod15.z.readonly(import_zod15.z.array(import_zod15.z.string())) }))).optional()
 });
-var CheckDiagnosticSchema = import_zod14.z.strictObject({
-  code: import_zod14.z.enum(DIAGNOSTIC_CODES),
-  severity: import_zod14.z.enum(DIAGNOSTIC_SEVERITIES),
-  message: import_zod14.z.string(),
-  subject: import_zod14.z.string().optional(),
-  layer: import_zod14.z.int().optional()
+var CheckDiagnosticSchema = import_zod15.z.strictObject({
+  code: import_zod15.z.enum(DIAGNOSTIC_CODES),
+  severity: import_zod15.z.enum(DIAGNOSTIC_SEVERITIES),
+  message: import_zod15.z.string(),
+  subject: import_zod15.z.string().optional(),
+  layer: import_zod15.z.int().optional()
 });
-var CheckAmbientCredentialSchema = import_zod14.z.union([import_zod14.z.strictObject({ ok: import_zod14.z.literal(true) }), import_zod14.z.strictObject({ ok: import_zod14.z.literal(false), variable: import_zod14.z.string(), message: import_zod14.z.string() })]);
-var CheckKeychainSchema = import_zod14.z.strictObject({
-  checked: import_zod14.z.literal(true),
-  found: import_zod14.z.boolean(),
-  serviceName: import_zod14.z.string().optional(),
-  note: import_zod14.z.string()
+var CheckAmbientCredentialSchema = import_zod15.z.union([import_zod15.z.strictObject({ ok: import_zod15.z.literal(true) }), import_zod15.z.strictObject({ ok: import_zod15.z.literal(false), variable: import_zod15.z.string(), message: import_zod15.z.string() })]);
+var CheckKeychainSchema = import_zod15.z.strictObject({
+  checked: import_zod15.z.literal(true),
+  found: import_zod15.z.boolean(),
+  serviceName: import_zod15.z.string().optional(),
+  note: import_zod15.z.string()
 });
-var CheckSettingsExposureSchema = import_zod14.z.strictObject({
-  file: import_zod14.z.string(),
-  envKeyNames: import_zod14.z.readonly(import_zod14.z.array(import_zod14.z.string())),
-  hookEventNames: import_zod14.z.readonly(import_zod14.z.array(import_zod14.z.string())),
-  hookCommandCount: import_zod14.z.int().nonnegative()
+var CheckSettingsExposureSchema = import_zod15.z.strictObject({
+  file: import_zod15.z.string(),
+  envKeyNames: import_zod15.z.readonly(import_zod15.z.array(import_zod15.z.string())),
+  hookEventNames: import_zod15.z.readonly(import_zod15.z.array(import_zod15.z.string())),
+  hookCommandCount: import_zod15.z.int().nonnegative()
 });
-var CredentialSourceSummarySchema = import_zod14.z.union([
-  import_zod14.z.strictObject({ kind: import_zod14.z.literal("env"), variable: import_zod14.z.string() }),
-  import_zod14.z.strictObject({ kind: import_zod14.z.literal("file"), path: import_zod14.z.string() }),
-  import_zod14.z.strictObject({ kind: import_zod14.z.literal("command"), program: import_zod14.z.string() }),
-  import_zod14.z.strictObject({ kind: import_zod14.z.literal("op"), reference: import_zod14.z.string() }),
-  import_zod14.z.strictObject({ kind: import_zod14.z.literal("keychain"), service: import_zod14.z.string(), account: import_zod14.z.string().optional() }),
-  import_zod14.z.strictObject({ kind: import_zod14.z.literal("literal") })
+var CredentialSourceSummarySchema = import_zod15.z.union([
+  import_zod15.z.strictObject({ kind: import_zod15.z.literal("env"), variable: import_zod15.z.string() }),
+  import_zod15.z.strictObject({ kind: import_zod15.z.literal("file"), path: import_zod15.z.string() }),
+  import_zod15.z.strictObject({ kind: import_zod15.z.literal("command"), program: import_zod15.z.string() }),
+  import_zod15.z.strictObject({ kind: import_zod15.z.literal("op"), reference: import_zod15.z.string() }),
+  import_zod15.z.strictObject({ kind: import_zod15.z.literal("keychain"), service: import_zod15.z.string(), account: import_zod15.z.string().optional() }),
+  import_zod15.z.strictObject({ kind: import_zod15.z.literal("literal") })
 ]);
-var CredentialSummarySchema = import_zod14.z.strictObject({
-  target: import_zod14.z.enum(CREDENTIAL_TARGETS),
-  sources: import_zod14.z.readonly(import_zod14.z.array(CredentialSourceSummarySchema)),
+var CredentialSummarySchema = import_zod15.z.strictObject({
+  target: import_zod15.z.enum(CREDENTIAL_TARGETS),
+  sources: import_zod15.z.readonly(import_zod15.z.array(CredentialSourceSummarySchema)),
   cache: CredentialCacheSchema.optional()
 });
-var CachedCredentialStateSchema = import_zod14.z.union([
-  import_zod14.z.strictObject({ store: import_zod14.z.enum(CREDENTIAL_CACHE_STORES), status: import_zod14.z.literal("empty") }),
-  import_zod14.z.strictObject({ store: import_zod14.z.enum(CREDENTIAL_CACHE_STORES), status: import_zod14.z.literal("unreadable"), reason: import_zod14.z.string() }),
-  import_zod14.z.strictObject({ store: import_zod14.z.enum(CREDENTIAL_CACHE_STORES), status: import_zod14.z.enum(["fresh", "expired"]), ageMs: import_zod14.z.number(), expiresInMs: import_zod14.z.number().optional() })
+var CachedCredentialStateSchema = import_zod15.z.union([
+  import_zod15.z.strictObject({ store: import_zod15.z.enum(CREDENTIAL_CACHE_STORES), status: import_zod15.z.literal("empty") }),
+  import_zod15.z.strictObject({ store: import_zod15.z.enum(CREDENTIAL_CACHE_STORES), status: import_zod15.z.literal("unreadable"), reason: import_zod15.z.string() }),
+  import_zod15.z.strictObject({ store: import_zod15.z.enum(CREDENTIAL_CACHE_STORES), status: import_zod15.z.enum(["fresh", "expired"]), ageMs: import_zod15.z.number(), expiresInMs: import_zod15.z.number().optional() })
 ]);
-var CheckCredentialProviderSchema = import_zod14.z.union([
-  import_zod14.z.strictObject({ name: import_zod14.z.string(), credential: CredentialSummarySchema, cached: CachedCredentialStateSchema.optional() }),
-  import_zod14.z.strictObject({ name: import_zod14.z.string(), problem: import_zod14.z.string() })
+var CheckCredentialProviderSchema = import_zod15.z.union([
+  import_zod15.z.strictObject({ name: import_zod15.z.string(), credential: CredentialSummarySchema, cached: CachedCredentialStateSchema.optional() }),
+  import_zod15.z.strictObject({ name: import_zod15.z.string(), problem: import_zod15.z.string() })
 ]);
-var CheckCredentialSchema = import_zod14.z.strictObject({
-  applies: import_zod14.z.enum(CHECK_CREDENTIAL_APPLIES),
+var CheckCredentialSchema = import_zod15.z.strictObject({
+  applies: import_zod15.z.enum(CHECK_CREDENTIAL_APPLIES),
   provider: CheckCredentialProviderSchema.optional(),
   identity: CredentialSummarySchema.optional(),
   identityCached: CachedCredentialStateSchema.optional()
 });
-var CheckClaudeVersionSchema = import_zod14.z.strictObject({
-  pinned: import_zod14.z.strictObject({ version: import_zod14.z.string(), source: import_zod14.z.enum(CLAUDE_VERSION_SOURCES), installed: import_zod14.z.boolean() }).optional(),
-  highestInstalled: import_zod14.z.string().optional(),
-  installed: import_zod14.z.readonly(import_zod14.z.array(import_zod14.z.string()))
+var CheckClaudeVersionSchema = import_zod15.z.strictObject({
+  pinned: import_zod15.z.strictObject({ version: import_zod15.z.string(), source: import_zod15.z.enum(CLAUDE_VERSION_SOURCES), installed: import_zod15.z.boolean() }).optional(),
+  highestInstalled: import_zod15.z.string().optional(),
+  installed: import_zod15.z.readonly(import_zod15.z.array(import_zod15.z.string()))
 });
-var CheckReportJsonSchema = import_zod14.z.strictObject({
-  identity: import_zod14.z.strictObject({ name: import_zod14.z.string().nullable(), source: import_zod14.z.enum(IDENTITY_DECISION_SOURCES) }),
+var CheckReportJsonSchema = import_zod15.z.strictObject({
+  identity: import_zod15.z.strictObject({ name: import_zod15.z.string().nullable(), source: import_zod15.z.enum(IDENTITY_DECISION_SOURCES) }),
   /** The pool ranking, when the launch named a pool instead of an identity. */
   pool: PoolPickReportSchema.optional(),
-  configProfile: import_zod14.z.strictObject({ name: import_zod14.z.string().nullable(), source: import_zod14.z.enum(CONFIG_PROFILE_DECISION_SOURCES) }),
-  layers: import_zod14.z.readonly(import_zod14.z.array(CheckLayerViewSchema)),
-  entries: import_zod14.z.readonly(import_zod14.z.array(CheckEntryViewSchema)),
-  projectEncodingAmbiguities: import_zod14.z.readonly(
-    import_zod14.z.array(import_zod14.z.strictObject({ fragment: import_zod14.z.string(), encoded: import_zod14.z.string(), reason: import_zod14.z.enum(ENCODING_AMBIGUITY_REASONS), detail: import_zod14.z.string() }))
+  configProfile: import_zod15.z.strictObject({ name: import_zod15.z.string().nullable(), source: import_zod15.z.enum(CONFIG_PROFILE_DECISION_SOURCES) }),
+  layers: import_zod15.z.readonly(import_zod15.z.array(CheckLayerViewSchema)),
+  entries: import_zod15.z.readonly(import_zod15.z.array(CheckEntryViewSchema)),
+  projectEncodingAmbiguities: import_zod15.z.readonly(
+    import_zod15.z.array(import_zod15.z.strictObject({ fragment: import_zod15.z.string(), encoded: import_zod15.z.string(), reason: import_zod15.z.enum(ENCODING_AMBIGUITY_REASONS), detail: import_zod15.z.string() }))
   ),
-  diagnostics: import_zod14.z.readonly(import_zod14.z.array(CheckDiagnosticSchema)),
+  diagnostics: import_zod15.z.readonly(import_zod15.z.array(CheckDiagnosticSchema)),
   ambientCredential: CheckAmbientCredentialSchema,
   keychain: CheckKeychainSchema.optional(),
-  settingsExposure: import_zod14.z.readonly(import_zod14.z.array(CheckSettingsExposureSchema)),
+  settingsExposure: import_zod15.z.readonly(import_zod15.z.array(CheckSettingsExposureSchema)),
   credential: CheckCredentialSchema,
   claudeVersion: CheckClaudeVersionSchema.optional()
 });
@@ -12228,8 +12474,8 @@ init_middleware();
 init_preflight();
 
 // src/frontdoor/controlSchemas.ts
-var import_node_path29 = __toESM(require("node:path"), 1);
-var import_zod19 = require("zod");
+var import_node_path30 = __toESM(require("node:path"), 1);
+var import_zod20 = require("zod");
 
 // src/doctorReport.ts
 init_claudeShim();
@@ -12399,27 +12645,49 @@ function removeIdentity(paths, name) {
 // src/doctorReport.ts
 init_realPorts();
 var import_node_fs9 = __toESM(require("node:fs"), 1);
+var import_node_path29 = __toESM(require("node:path"), 1);
+
+// src/usage/signIn.ts
 var import_node_path28 = __toESM(require("node:path"), 1);
+var CREDENTIALS_FILE = ".credentials.json";
+function keychainHasItem(run, account) {
+  return run.run("security", ["find-generic-password", "-a", account]).status === 0;
+}
+function decideSignIn(facts) {
+  if (facts.hasCredentialBlock) {
+    return { state: "token", detail: "supplies its own credential through a credential block, so a stored login is not what a launch uses" };
+  }
+  if (facts.keychainItem === true) {
+    return { state: "signed-in", detail: "a login is stored in the macOS Keychain" };
+  }
+  if (facts.credentialsFile) {
+    return { state: "signed-in", detail: `a login is stored in ${CREDENTIALS_FILE}` };
+  }
+  return { state: "signed-out", detail: facts.platform === "darwin" ? `no Keychain item and no ${CREDENTIALS_FILE}` : `no ${CREDENTIALS_FILE}` };
+}
+function credentialsFilePath(farmRoot) {
+  return import_node_path28.default.join(farmRoot, CREDENTIALS_FILE);
+}
 
 // src/codex/siwcStore.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 
 // src/codex/auth.ts
-var import_zod16 = require("zod");
-var AuthFileSchema = import_zod16.z.looseObject({
-  tokens: import_zod16.z.looseObject({
-    access_token: import_zod16.z.string().optional(),
-    refresh_token: import_zod16.z.string().optional(),
-    id_token: import_zod16.z.string().optional(),
-    account_id: import_zod16.z.string().optional()
+var import_zod17 = require("zod");
+var AuthFileSchema = import_zod17.z.looseObject({
+  tokens: import_zod17.z.looseObject({
+    access_token: import_zod17.z.string().optional(),
+    refresh_token: import_zod17.z.string().optional(),
+    id_token: import_zod17.z.string().optional(),
+    account_id: import_zod17.z.string().optional()
   }).nullish(),
-  last_refresh: import_zod16.z.string().optional()
+  last_refresh: import_zod17.z.string().optional()
 });
-var TokenGrantSchema = import_zod16.z.looseObject({
-  access_token: import_zod16.z.string().min(1).optional(),
-  refresh_token: import_zod16.z.string().min(1).optional(),
-  id_token: import_zod16.z.string().min(1).optional(),
-  account_id: import_zod16.z.string().min(1).optional()
+var TokenGrantSchema = import_zod17.z.looseObject({
+  access_token: import_zod17.z.string().min(1).optional(),
+  refresh_token: import_zod17.z.string().min(1).optional(),
+  id_token: import_zod17.z.string().min(1).optional(),
+  account_id: import_zod17.z.string().min(1).optional()
 });
 var CodexAuthError = class extends Error {
   constructor(message) {
@@ -12429,41 +12697,41 @@ var CodexAuthError = class extends Error {
 };
 
 // src/codex/siwc.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 var SIWC_RESOURCE = "https://api.openai.com/v1";
 var SIWC_RESPONSES_URL = `${SIWC_RESOURCE}/responses`;
 var SIWC_PLAN_SCOPE = "chatgpt.tokens.use.direct";
-var TokenResponseSchema = import_zod17.z.looseObject({
-  access_token: import_zod17.z.string().min(1),
-  refresh_token: import_zod17.z.string().min(1).optional(),
-  id_token: import_zod17.z.string().min(1).optional(),
-  expires_in: import_zod17.z.number().positive(),
-  scope: import_zod17.z.string().optional()
+var TokenResponseSchema = import_zod18.z.looseObject({
+  access_token: import_zod18.z.string().min(1),
+  refresh_token: import_zod18.z.string().min(1).optional(),
+  id_token: import_zod18.z.string().min(1).optional(),
+  expires_in: import_zod18.z.number().positive(),
+  scope: import_zod18.z.string().optional()
 });
-var JwtHeaderSchema = import_zod17.z.looseObject({ alg: import_zod17.z.string(), kid: import_zod17.z.string().optional() });
-var IdTokenClaimsSchema = import_zod17.z.looseObject({
-  iss: import_zod17.z.string(),
-  sub: import_zod17.z.string().min(1),
-  aud: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.array(import_zod17.z.string())]),
-  exp: import_zod17.z.number(),
-  nonce: import_zod17.z.string().optional(),
-  email: import_zod17.z.string().optional()
+var JwtHeaderSchema = import_zod18.z.looseObject({ alg: import_zod18.z.string(), kid: import_zod18.z.string().optional() });
+var IdTokenClaimsSchema = import_zod18.z.looseObject({
+  iss: import_zod18.z.string(),
+  sub: import_zod18.z.string().min(1),
+  aud: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.array(import_zod18.z.string())]),
+  exp: import_zod18.z.number(),
+  nonce: import_zod18.z.string().optional(),
+  email: import_zod18.z.string().optional()
 });
-var JwksSchema = import_zod17.z.object({ keys: import_zod17.z.array(import_zod17.z.looseObject({ kid: import_zod17.z.string().optional(), kty: import_zod17.z.string() })) });
+var JwksSchema = import_zod18.z.object({ keys: import_zod18.z.array(import_zod18.z.looseObject({ kid: import_zod18.z.string().optional(), kty: import_zod18.z.string() })) });
 
 // src/codex/siwcStore.ts
-var SiwcGrantSchema = import_zod18.z.strictObject({
-  clientId: import_zod18.z.string().min(1),
-  sub: import_zod18.z.string().min(1),
-  email: import_zod18.z.string().optional(),
-  idToken: import_zod18.z.string().min(1),
-  accessToken: import_zod18.z.string().min(1),
-  refreshToken: import_zod18.z.string().min(1),
-  scopes: import_zod18.z.array(import_zod18.z.string()).readonly(),
+var SiwcGrantSchema = import_zod19.z.strictObject({
+  clientId: import_zod19.z.string().min(1),
+  sub: import_zod19.z.string().min(1),
+  email: import_zod19.z.string().optional(),
+  idToken: import_zod19.z.string().min(1),
+  accessToken: import_zod19.z.string().min(1),
+  refreshToken: import_zod19.z.string().min(1),
+  scopes: import_zod19.z.array(import_zod19.z.string()).readonly(),
   /** When the access token stops working, in milliseconds since the epoch. */
-  expiresAt: import_zod18.z.number()
+  expiresAt: import_zod19.z.number()
 });
-var SiwcFileSchema = import_zod18.z.strictObject({ registeredClientId: import_zod18.z.string().min(1).optional(), grant: SiwcGrantSchema.optional() });
+var SiwcFileSchema = import_zod19.z.strictObject({ registeredClientId: import_zod19.z.string().min(1).optional(), grant: SiwcGrantSchema.optional() });
 function parseSiwcFile(raw, filePath) {
   let json;
   try {
@@ -12500,6 +12768,7 @@ var DOCTOR_SECTIONS = [
   "legacy-name",
   "config-profile",
   "identity",
+  "sign-in",
   "pool",
   "provider",
   "keychain",
@@ -12542,7 +12811,7 @@ function tcpPortEraRecord(raw) {
   return (has("port") || has("lastPort")) && !has("socketPath");
 }
 function pushPathResolution(push, resolution) {
-  const ownDir = import_node_path28.default.dirname(resolution.ownExecutablePath);
+  const ownDir = import_node_path29.default.dirname(resolution.ownExecutablePath);
   switch (resolution.agentShim.status) {
     case "ok":
       push("path-resolution", "pass", `\`agent-shim\` on PATH resolves to this running executable, ${resolution.ownExecutablePath}.`, "agent-shim");
@@ -12622,17 +12891,17 @@ function pushProvider(push, entry, cacheEnv, signIn) {
     push("provider", "fail", new LegacyProviderFileError(entry.path, conversion).message, entry.name);
     return;
   }
-  const validated2 = ProviderSchema.safeParse(parsed);
-  if (!validated2.success) {
-    push("provider", "fail", new ConfigValidationError(entry.path, validated2.error.issues).message, entry.name);
+  const validated3 = ProviderSchema.safeParse(parsed);
+  if (!validated3.success) {
+    push("provider", "fail", new ConfigValidationError(entry.path, validated3.error.issues).message, entry.name);
     return;
   }
-  const cache = cacheClause(cacheEnv, `provider ${entry.name}`, validated2.data.credential);
-  push("provider", cache.unreadable ? "fail" : "pass", `${entry.name} is valid (${describeProviderEndpoint(validated2.data)}, credential ${describeCredential(validated2.data.credential)})${cache.text}.`, entry.name);
-  if (validated2.data.env?.ENABLE_TOOL_SEARCH === void 0) {
+  const cache = cacheClause(cacheEnv, `provider ${entry.name}`, validated3.data.credential);
+  push("provider", cache.unreadable ? "fail" : "pass", `${entry.name} is valid (${describeProviderEndpoint(validated3.data)}, credential ${describeCredential(validated3.data.credential)})${cache.text}.`, entry.name);
+  if (validated3.data.env?.ENABLE_TOOL_SEARCH === void 0) {
     push("provider", "warn", `${entry.name} does not set ENABLE_TOOL_SEARCH: a session on this provider keeps Claude Code's own API as its base URL, so it defers MCP tool loading and sends tool_reference payloads the upstream backend must understand. Set ENABLE_TOOL_SEARCH=false in the provider's env block to load tools upfront instead, when the backend does not support them.`, entry.name);
   }
-  if (signIn !== void 0 && isCodexProvider(validated2.data) && validated2.data.codex?.login === "chatgpt-sign-in") {
+  if (signIn !== void 0 && isCodexProvider(validated3.data) && validated3.data.codex?.login === "chatgpt-sign-in") {
     const problem = signInProblem(signIn);
     if (problem !== void 0) {
       push("provider", "warn", `${entry.name} uses the Sign in with ChatGPT login, but ${problem}`, entry.name);
@@ -12641,14 +12910,14 @@ function pushProvider(push, entry, cacheEnv, signIn) {
 }
 function pushLegacyName(push, params) {
   const legacyVariables = Object.keys(params.env).filter((name) => name.startsWith(LEGACY_ENV_PREFIX) && params.env[name] !== void 0).sort();
-  if (legacyVariables.length === 0 && import_node_path28.default.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
+  if (legacyVariables.length === 0 && import_node_path29.default.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
     push("legacy-name", "pass", "Nothing here still uses the former `claude-use` name.");
     return;
   }
   for (const name of legacyVariables) {
     push("legacy-name", "warn", `${name} is the former name of ${name.replace(LEGACY_ENV_PREFIX, ENV_PREFIX)}. Rename it; the old name still works but is only a fallback.`, name);
   }
-  if (import_node_path28.default.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
+  if (import_node_path29.default.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
     push(
       "legacy-name",
       "warn",
@@ -12700,13 +12969,13 @@ function runDoctor(params) {
   pushLegacyName(push, params);
   const profileSources = /* @__PURE__ */ new Map();
   for (const entry of params.configProfiles) {
-    const validated2 = validateJson(ConfigProfileSchema, entry);
-    if (!validated2.ok) {
-      push("config-profile", "fail", validated2.message, entry.name);
+    const validated3 = validateJson(ConfigProfileSchema, entry);
+    if (!validated3.ok) {
+      push("config-profile", "fail", validated3.message, entry.name);
       continue;
     }
-    profileSources.set(entry.name, { name: entry.name, profile: validated2.data });
-    checkPin("config-profile", entry.name, `Configuration profile "${entry.name}"`, validated2.data.launch?.claudeVersion);
+    profileSources.set(entry.name, { name: entry.name, profile: validated3.data });
+    checkPin("config-profile", entry.name, `Configuration profile "${entry.name}"`, validated3.data.launch?.claudeVersion);
   }
   const loadProfile = (name) => profileSources.get(name);
   for (const name of profileSources.keys()) {
@@ -12722,13 +12991,13 @@ function runDoctor(params) {
   const validProfileNames = new Set(profileSources.keys());
   const validIdentityNames = /* @__PURE__ */ new Set();
   for (const entry of params.identities) {
-    const validated2 = validateJson(IdentitySchema, entry);
-    if (!validated2.ok) {
-      push("identity", "fail", validated2.message, entry.name);
+    const validated3 = validateJson(IdentitySchema, entry);
+    if (!validated3.ok) {
+      push("identity", "fail", validated3.message, entry.name);
       continue;
     }
     validIdentityNames.add(entry.name);
-    const defaultProfile = validated2.data.defaultConfigProfile;
+    const defaultProfile = validated3.data.defaultConfigProfile;
     if (defaultProfile !== void 0 && !validProfileNames.has(defaultProfile)) {
       push(
         "identity",
@@ -12737,7 +13006,7 @@ function runDoctor(params) {
         entry.name
       );
     } else {
-      const credential = validated2.data.credential;
+      const credential = validated3.data.credential;
       const cache = credential === void 0 ? { text: "", unreadable: false } : cacheClause(params.credentialCache, `identity ${entry.name}`, credential);
       push(
         "identity",
@@ -12745,6 +13014,18 @@ function runDoctor(params) {
         `${entry.name} is valid and authenticates with ${credential === void 0 ? "its stored login" : `credential ${describeCredential(credential)}`}${cache.text}.`,
         entry.name
       );
+      const signIn = decideSignIn({
+        hasCredentialBlock: credential !== void 0,
+        keychainItem: params.platform === "darwin" && params.run !== void 0 ? keychainHasItem(params.run, entry.farmRoot) : void 0,
+        credentialsFile: entry.credentialsFilePresent,
+        platform: params.platform
+      });
+      push(
+        "sign-in",
+        signIn.state === "signed-out" ? "warn" : "pass",
+        signIn.state === "signed-out" ? `${entry.name} is signed out (${signIn.detail}). Run \`agent-shim run @${entry.name}\` and sign in.` : `${entry.name} ${signIn.state === "token" ? "uses a credential block" : "is signed in"} (${signIn.detail}).`,
+        entry.name
+      );
     }
   }
   const validatedGlobalConfig = params.globalConfig.raw === void 0 ? void 0 : validateJson(GlobalConfigSchema, params.globalConfig);
@@ -12790,18 +13071,18 @@ function runDoctor(params) {
   } else {
     for (const entry of params.identities) {
       const result = lookupKeychainService(params.run, entry.farmRoot);
-      push("keychain", result.found ? "pass" : "warn", result.note, entry.name);
+      push("keychain", "pass", result.found ? result.note : `${result.note} The sign-in section reports whether a login is stored elsewhere.`, entry.name);
     }
   }
   if (params.directoryRules.raw === void 0) {
     push("directory-rules", "pass", "No directory-rules.json configured.");
   } else {
-    const validated2 = validateJson(DirectoryRulesSchema, params.directoryRules);
-    if (!validated2.ok) {
-      push("directory-rules", "fail", validated2.message);
+    const validated3 = validateJson(DirectoryRulesSchema, params.directoryRules);
+    if (!validated3.ok) {
+      push("directory-rules", "fail", validated3.message);
     } else {
       push("directory-rules", "pass", `${params.directoryRules.path} is valid.`);
-      for (const rule of validated2.data.rules) {
+      for (const rule of validated3.data.rules) {
         const badRefs = [];
         if (rule.identity !== void 0 && !selectionExists(rule.identity)) {
           badRefs.push(poolNameOf(rule.identity) === void 0 ? `identity "${rule.identity}"` : `pool "${poolNameOf(rule.identity) ?? ""}"`);
@@ -12821,11 +13102,11 @@ function runDoctor(params) {
   if (params.globalConfig.raw === void 0) {
     push("global-config", "pass", "No config.json configured.");
   } else {
-    const validated2 = validateJson(GlobalConfigSchema, params.globalConfig);
-    if (!validated2.ok) {
-      push("global-config", "fail", validated2.message);
+    const validated3 = validateJson(GlobalConfigSchema, params.globalConfig);
+    if (!validated3.ok) {
+      push("global-config", "fail", validated3.message);
     } else {
-      const defaultProfile = validated2.data.defaultConfigProfile;
+      const defaultProfile = validated3.data.defaultConfigProfile;
       if (defaultProfile !== void 0 && !validProfileNames.has(defaultProfile)) {
         push(
           "global-config",
@@ -12834,18 +13115,18 @@ function runDoctor(params) {
         );
       } else {
         push("global-config", "pass", `${params.globalConfig.path} is valid.`);
-        checkPin("global-config", void 0, "config.json", validated2.data.launch?.claudeVersion);
+        checkPin("global-config", void 0, "config.json", validated3.data.launch?.claudeVersion);
       }
     }
   }
   if (params.categoriesLocal.raw === void 0) {
     push("categories-local", "pass", "No categories.local.json configured.");
   } else {
-    const validated2 = validateJson(CategoryClassificationOverlaySchema, params.categoriesLocal);
+    const validated3 = validateJson(CategoryClassificationOverlaySchema, params.categoriesLocal);
     push(
       "categories-local",
-      validated2.ok ? "pass" : "fail",
-      validated2.ok ? `${params.categoriesLocal.path} is valid.` : validated2.message
+      validated3.ok ? "pass" : "fail",
+      validated3.ok ? `${params.categoriesLocal.path} is valid.` : validated3.message
     );
   }
   if (params.headroom.state.raw === void 0) {
@@ -12853,11 +13134,11 @@ function runDoctor(params) {
   } else if (tcpPortEraRecord(params.headroom.state.raw)) {
     push("headroom", "pass", `${params.headroom.state.path} holds a previous release's TCP-port state record; the next launch through headroom claims over it.`);
   } else {
-    const validated2 = validateJson(HeadroomStateSchema, params.headroom.state);
-    if (!validated2.ok) {
-      push("headroom", "fail", validated2.message);
+    const validated3 = validateJson(HeadroomStateSchema, params.headroom.state);
+    if (!validated3.ok) {
+      push("headroom", "fail", validated3.message);
     } else {
-      const state = validated2.data;
+      const state = validated3.data;
       const supervisorAlive = state.supervisorPid !== void 0 && params.headroom.isRunning(state.supervisorPid);
       const headroomAlive = state.headroomPid !== void 0 && params.headroom.isRunning(state.headroomPid);
       if (state.supervisorPid === void 0) {
@@ -12925,6 +13206,7 @@ var SECTION_TITLES = {
   "legacy-name": "Former `claude-use` name",
   "config-profile": "Configuration profiles",
   identity: "Identities",
+  "sign-in": "Sign-in",
   pool: "Pools",
   provider: "Providers",
   keychain: "macOS Keychain",
@@ -12941,6 +13223,7 @@ var SECTION_ORDER = [
   "path-resolution",
   "config-profile",
   "identity",
+  "sign-in",
   "pool",
   "provider",
   "keychain",
@@ -12990,18 +13273,18 @@ function collectDoctorReport(params) {
   const { paths } = params;
   const identityNames = import_node_fs9.default.existsSync(paths.identitiesDir) ? import_node_fs9.default.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isIdentityDirectoryName(entry.name)).map((entry) => entry.name).sort() : [];
   const identities = identityNames.map((name) => {
-    const farmRoot = import_node_path28.default.join(paths.identitiesDir, name);
-    const identityPath = import_node_path28.default.join(farmRoot, "identity.json");
-    return { name, path: identityPath, raw: realFsPort.readFileUtf8(identityPath), farmRoot };
+    const farmRoot = import_node_path29.default.join(paths.identitiesDir, name);
+    const identityPath = import_node_path29.default.join(farmRoot, "identity.json");
+    return { name, path: identityPath, raw: realFsPort.readFileUtf8(identityPath), farmRoot, credentialsFilePresent: import_node_fs9.default.existsSync(credentialsFilePath(farmRoot)) };
   });
   const profileNames = import_node_fs9.default.existsSync(paths.configProfilesDir) ? import_node_fs9.default.readdirSync(paths.configProfilesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
   const configProfiles = profileNames.map((name) => {
-    const profilePath = import_node_path28.default.join(paths.configProfilesDir, `${name}.json`);
+    const profilePath = import_node_path29.default.join(paths.configProfilesDir, `${name}.json`);
     return { name, path: profilePath, raw: realFsPort.readFileUtf8(profilePath) };
   });
   const providerNames = import_node_fs9.default.existsSync(paths.providersDir) ? import_node_fs9.default.readdirSync(paths.providersDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
   const providers = providerNames.map((name) => {
-    const providerPath = import_node_path28.default.join(paths.providersDir, `${name}.json`);
+    const providerPath = import_node_path29.default.join(paths.providersDir, `${name}.json`);
     return { name, path: providerPath, raw: realFsPort.readFileUtf8(providerPath) };
   });
   const ownExecutablePath = realOwnExecutablePath();
@@ -13013,12 +13296,12 @@ function collectDoctorReport(params) {
     binaryDiscovery = { ok: false, message: error instanceof Error ? error.message : String(error) };
   }
   const shimState = readJson(paths.claudeShimFile, ClaudeShimStateSchema);
-  const pathDirs = (params.env.PATH ?? "").split(import_node_path28.default.delimiter).filter((dir) => dir !== "");
+  const pathDirs = (params.env.PATH ?? "").split(import_node_path29.default.delimiter).filter((dir) => dir !== "");
   const claudeShimShadow = shimState === void 0 ? void 0 : refinePathShadow(
     findPathShadow({
       pathDirs,
-      targetDir: import_node_path28.default.dirname(shimState.targetPath),
-      targetFilename: import_node_path28.default.basename(shimState.targetPath),
+      targetDir: import_node_path29.default.dirname(shimState.targetPath),
+      targetFilename: import_node_path29.default.basename(shimState.targetPath),
       findExecutableInDir
     }),
     shimState.targetPath,
@@ -13044,7 +13327,7 @@ function collectDoctorReport(params) {
       agentShim: refinePathShadow(
         findPathShadow({
           pathDirs,
-          targetDir: import_node_path28.default.dirname(ownExecutablePath),
+          targetDir: import_node_path29.default.dirname(ownExecutablePath),
           targetFilename: commandFilename(ownExecutablePath, "agent-shim"),
           findExecutableInDir
         }),
@@ -13071,90 +13354,90 @@ function collectDoctorReport(params) {
 // src/frontdoor/controlSchemas.ts
 init_schema2();
 init_state();
-var UsageListOutputSchema = import_zod19.z.strictObject({ snapshots: import_zod19.z.readonly(import_zod19.z.array(UsageSnapshotSchema)) });
-var UsageWindowsInputSchema = import_zod19.z.strictObject({
-  identity: import_zod19.z.string().min(1),
-  provider: import_zod19.z.string().min(1).optional()
+var UsageListOutputSchema = import_zod20.z.strictObject({ snapshots: import_zod20.z.readonly(import_zod20.z.array(UsageSnapshotSchema)) });
+var UsageWindowsInputSchema = import_zod20.z.strictObject({
+  identity: import_zod20.z.string().min(1),
+  provider: import_zod20.z.string().min(1).optional()
 });
-var EffectiveWindowSchema = import_zod19.z.strictObject({
+var EffectiveWindowSchema = import_zod20.z.strictObject({
   /** True when the window's reset time has passed, so the recorded observation describes a window that no longer exists. */
-  reset: import_zod19.z.boolean(),
+  reset: import_zod20.z.boolean(),
   /** The fraction used: 0 for a reset window, otherwise what was last observed, absent when none was reported. */
-  utilization: import_zod19.z.number().optional(),
+  utilization: import_zod20.z.number().optional(),
   /** The reset instant, for a window that has not reset yet and reported one. */
-  resetsAtMs: import_zod19.z.number().optional(),
+  resetsAtMs: import_zod20.z.number().optional(),
   /** The window's own status, for a window that has not reset yet. */
-  status: import_zod19.z.string().optional()
+  status: import_zod20.z.string().optional()
 });
-var UsageWindowsOutputSchema = import_zod19.z.strictObject({
-  identity: import_zod19.z.string(),
-  provider: import_zod19.z.string(),
+var UsageWindowsOutputSchema = import_zod20.z.strictObject({
+  identity: import_zod20.z.string(),
+  provider: import_zod20.z.string(),
   /** When the rate-limit state the windows come from was observed. */
-  observedAt: import_zod19.z.iso.datetime().optional(),
+  observedAt: import_zod20.z.iso.datetime().optional(),
   fiveHour: EffectiveWindowSchema.optional(),
   sevenDay: EffectiveWindowSchema.optional()
 });
-var UsageLiveOutputSchema = import_zod19.z.strictObject({
+var UsageLiveOutputSchema = import_zod20.z.strictObject({
   /** The freshest observation the door holds, never narrowed by the read's session filter because it is the door's single latest statement of the account's quota; absent while no rate_limit_event has been filed at all. */
   latest: RcLiveRateLimitSchema.optional(),
   /** One observation per session whose stream has filed a rate_limit_event this door generation. */
-  sessions: import_zod19.z.readonly(import_zod19.z.array(RcLiveRateLimitSchema))
+  sessions: import_zod20.z.readonly(import_zod20.z.array(RcLiveRateLimitSchema))
 });
-var FrontDoorSessionStatusSchema = import_zod19.z.strictObject({
-  pid: import_zod19.z.int().positive(),
-  startedAt: import_zod19.z.number(),
-  alive: import_zod19.z.boolean()
+var FrontDoorSessionStatusSchema = import_zod20.z.strictObject({
+  pid: import_zod20.z.int().positive(),
+  startedAt: import_zod20.z.number(),
+  alive: import_zod20.z.boolean()
 });
-var HeadroomSocketTargetSchema = import_zod19.z.union([import_zod19.z.strictObject({ socketPath: import_zod19.z.string() }), import_zod19.z.strictObject({ refused: import_zod19.z.string() })]);
-var FrontDoorStatusOutputSchema = import_zod19.z.strictObject({
+var HeadroomSocketTargetSchema = import_zod20.z.union([import_zod20.z.strictObject({ socketPath: import_zod20.z.string() }), import_zod20.z.strictObject({ refused: import_zod20.z.string() })]);
+var FrontDoorStatusOutputSchema = import_zod20.z.strictObject({
   state: FrontDoorStateSchema,
-  supervisorAlive: import_zod19.z.boolean(),
-  sessions: import_zod19.z.readonly(import_zod19.z.array(FrontDoorSessionStatusSchema)),
+  supervisorAlive: import_zod20.z.boolean(),
+  sessions: import_zod20.z.readonly(import_zod20.z.array(FrontDoorSessionStatusSchema)),
   headroomSocket: HeadroomSocketTargetSchema.optional(),
-  logPath: import_zod19.z.string(),
-  logExists: import_zod19.z.boolean()
+  logPath: import_zod20.z.string(),
+  logExists: import_zod20.z.boolean()
 });
-var FrontDoorSessionsOutputSchema = import_zod19.z.strictObject({ sessions: import_zod19.z.readonly(import_zod19.z.array(FrontDoorSessionStatusSchema)) });
-var CheckRunInputSchema = import_zod19.z.strictObject({
-  path: import_zod19.z.string().min(1),
-  identity: import_zod19.z.string().min(1).optional()
-}).refine((input) => import_node_path29.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
-var PoolPickInputSchema = import_zod19.z.strictObject({
-  pool: import_zod19.z.string().min(1),
-  path: import_zod19.z.string().min(1)
-}).refine((input) => import_node_path29.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
-var DoctorFindingSchema = import_zod19.z.strictObject({
-  section: import_zod19.z.enum(DOCTOR_SECTIONS),
-  subject: import_zod19.z.string().optional(),
-  severity: import_zod19.z.enum(DOCTOR_SEVERITIES),
-  message: import_zod19.z.string()
+var FrontDoorSessionsOutputSchema = import_zod20.z.strictObject({ sessions: import_zod20.z.readonly(import_zod20.z.array(FrontDoorSessionStatusSchema)) });
+var CheckRunInputSchema = import_zod20.z.strictObject({
+  path: import_zod20.z.string().min(1),
+  identity: import_zod20.z.string().min(1).optional()
+}).refine((input) => import_node_path30.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+var PoolPickInputSchema = import_zod20.z.strictObject({
+  pool: import_zod20.z.string().min(1),
+  path: import_zod20.z.string().min(1)
+}).refine((input) => import_node_path30.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+var DoctorFindingSchema = import_zod20.z.strictObject({
+  section: import_zod20.z.enum(DOCTOR_SECTIONS),
+  subject: import_zod20.z.string().optional(),
+  severity: import_zod20.z.enum(DOCTOR_SEVERITIES),
+  message: import_zod20.z.string()
 });
-var DoctorRunOutputSchema = import_zod19.z.strictObject({
+var DoctorRunOutputSchema = import_zod20.z.strictObject({
   /** False exactly when any finding is a `fail`; a `warn` never fails the report on its own. */
-  ok: import_zod19.z.boolean(),
-  findings: import_zod19.z.readonly(import_zod19.z.array(DoctorFindingSchema))
+  ok: import_zod20.z.boolean(),
+  findings: import_zod20.z.readonly(import_zod20.z.array(DoctorFindingSchema))
 });
-var FrontDoorRestartOutputSchema = import_zod19.z.strictObject({
-  action: import_zod19.z.literal("restarting"),
-  previousPid: import_zod19.z.int().positive()
+var FrontDoorRestartOutputSchema = import_zod20.z.strictObject({
+  action: import_zod20.z.literal("restarting"),
+  previousPid: import_zod20.z.int().positive()
 });
-var UpdateCheckOutputSchema = import_zod19.z.strictObject({
-  current: import_zod19.z.string(),
-  latest: import_zod19.z.string(),
-  action: import_zod19.z.enum(["current", "available", "updated"])
+var UpdateCheckOutputSchema = import_zod20.z.strictObject({
+  current: import_zod20.z.string(),
+  latest: import_zod20.z.string(),
+  action: import_zod20.z.enum(["current", "available", "updated"])
 });
-var CodexSignInSchema = import_zod19.z.discriminatedUnion("state", [
-  import_zod19.z.strictObject({ state: import_zod19.z.literal("none") }),
-  import_zod19.z.strictObject({ state: import_zod19.z.literal("signed-in"), email: import_zod19.z.string().optional(), planScope: import_zod19.z.boolean(), accessTokenExpiresAt: import_zod19.z.number() }),
-  import_zod19.z.strictObject({ state: import_zod19.z.literal("unreadable"), message: import_zod19.z.string() })
+var CodexSignInSchema = import_zod20.z.discriminatedUnion("state", [
+  import_zod20.z.strictObject({ state: import_zod20.z.literal("none") }),
+  import_zod20.z.strictObject({ state: import_zod20.z.literal("signed-in"), email: import_zod20.z.string().optional(), planScope: import_zod20.z.boolean(), accessTokenExpiresAt: import_zod20.z.number() }),
+  import_zod20.z.strictObject({ state: import_zod20.z.literal("unreadable"), message: import_zod20.z.string() })
 ]);
-var CodexStatusOutputSchema = import_zod19.z.strictObject({
+var CodexStatusOutputSchema = import_zod20.z.strictObject({
   signIn: CodexSignInSchema,
-  codexProviders: import_zod19.z.readonly(import_zod19.z.array(import_zod19.z.string()))
+  codexProviders: import_zod20.z.readonly(import_zod20.z.array(import_zod20.z.string()))
 });
-var CodexLogoutOutputSchema = import_zod19.z.strictObject({
-  hadGrant: import_zod19.z.boolean(),
-  revoked: import_zod19.z.boolean()
+var CodexLogoutOutputSchema = import_zod20.z.strictObject({
+  hadGrant: import_zod20.z.boolean(),
+  revoked: import_zod20.z.boolean()
 });
 
 // src/frontdoor/codexApi.ts
@@ -13310,131 +13593,131 @@ init_identity();
 init_providersStore();
 
 // src/frontdoor/configSchemas.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 init_schema();
-var RemovalConfirmationSchema = import_zod20.z.boolean();
-var CredentialWriteSchema = (targets) => import_zod20.z.strictObject({
-  sources: import_zod20.z.array(RemoteCredentialSourceSchema).min(1).optional(),
-  target: import_zod20.z.enum(targets).optional(),
-  cache: import_zod20.z.union([import_zod20.z.literal(false), CredentialCacheSchema]).optional()
+var RemovalConfirmationSchema = import_zod21.z.boolean();
+var CredentialWriteSchema = (targets) => import_zod21.z.strictObject({
+  sources: import_zod21.z.array(RemoteCredentialSourceSchema).min(1).optional(),
+  target: import_zod21.z.enum(targets).optional(),
+  cache: import_zod21.z.union([import_zod21.z.literal(false), CredentialCacheSchema]).optional()
 });
-var CredentialSummarySchema2 = import_zod20.z.strictObject({
-  target: import_zod20.z.enum(CREDENTIAL_TARGETS),
-  sources: import_zod20.z.readonly(import_zod20.z.array(
-    import_zod20.z.discriminatedUnion("kind", [
-      import_zod20.z.strictObject({ kind: import_zod20.z.literal("env"), variable: import_zod20.z.string() }),
-      import_zod20.z.strictObject({ kind: import_zod20.z.literal("file"), path: import_zod20.z.string() }),
-      import_zod20.z.strictObject({ kind: import_zod20.z.literal("command"), program: import_zod20.z.string() }),
-      import_zod20.z.strictObject({ kind: import_zod20.z.literal("op"), reference: import_zod20.z.string() }),
-      import_zod20.z.strictObject({ kind: import_zod20.z.literal("keychain"), service: import_zod20.z.string(), account: import_zod20.z.string().optional() }),
-      import_zod20.z.strictObject({ kind: import_zod20.z.literal("literal") })
+var CredentialSummarySchema2 = import_zod21.z.strictObject({
+  target: import_zod21.z.enum(CREDENTIAL_TARGETS),
+  sources: import_zod21.z.readonly(import_zod21.z.array(
+    import_zod21.z.discriminatedUnion("kind", [
+      import_zod21.z.strictObject({ kind: import_zod21.z.literal("env"), variable: import_zod21.z.string() }),
+      import_zod21.z.strictObject({ kind: import_zod21.z.literal("file"), path: import_zod21.z.string() }),
+      import_zod21.z.strictObject({ kind: import_zod21.z.literal("command"), program: import_zod21.z.string() }),
+      import_zod21.z.strictObject({ kind: import_zod21.z.literal("op"), reference: import_zod21.z.string() }),
+      import_zod21.z.strictObject({ kind: import_zod21.z.literal("keychain"), service: import_zod21.z.string(), account: import_zod21.z.string().optional() }),
+      import_zod21.z.strictObject({ kind: import_zod21.z.literal("literal") })
     ])
   )),
   cache: CredentialCacheSchema.optional()
 });
-var mutationOutput = (kind, action) => import_zod20.z.strictObject({ action: import_zod20.z.literal(action), kind: import_zod20.z.literal(kind), name: import_zod20.z.string() });
-var storedMutationOutput = (kind, action, value) => import_zod20.z.strictObject({ action: import_zod20.z.literal(action), kind: import_zod20.z.literal(kind), name: import_zod20.z.string(), value });
-var IdentityValueSchema = import_zod20.z.strictObject({
-  name: import_zod20.z.string(),
-  defaultConfigProfile: import_zod20.z.string().optional(),
-  allowAmbientCredential: import_zod20.z.boolean(),
+var mutationOutput = (kind, action) => import_zod21.z.strictObject({ action: import_zod21.z.literal(action), kind: import_zod21.z.literal(kind), name: import_zod21.z.string() });
+var storedMutationOutput = (kind, action, value) => import_zod21.z.strictObject({ action: import_zod21.z.literal(action), kind: import_zod21.z.literal(kind), name: import_zod21.z.string(), value });
+var IdentityValueSchema = import_zod21.z.strictObject({
+  name: import_zod21.z.string(),
+  defaultConfigProfile: import_zod21.z.string().optional(),
+  allowAmbientCredential: import_zod21.z.boolean(),
   credential: CredentialSummarySchema2.optional()
 });
 var ProfileValueSchema = ConfigProfileSchema.omit({ $schema: true });
-var ProviderValueSchema = import_zod20.z.strictObject({
-  name: import_zod20.z.string(),
-  kind: import_zod20.z.enum(PROVIDER_KINDS),
-  displayName: import_zod20.z.string(),
-  baseUrl: import_zod20.z.string().optional(),
+var ProviderValueSchema = import_zod21.z.strictObject({
+  name: import_zod21.z.string(),
+  kind: import_zod21.z.enum(PROVIDER_KINDS),
+  displayName: import_zod21.z.string(),
+  baseUrl: import_zod21.z.string().optional(),
   codex: CodexProviderConfigSchema.optional(),
   credential: CredentialSummarySchema2,
-  env: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.string()).optional()
+  env: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.string()).optional()
 });
-var ConfigNameInputSchema = import_zod20.z.strictObject({ name: import_zod20.z.string().min(1) });
+var ConfigNameInputSchema = import_zod21.z.strictObject({ name: import_zod21.z.string().min(1) });
 var ConfigIdentityAddOutputSchema = storedMutationOutput("identity", "created", IdentityValueSchema);
-var ConfigIdentitySetInputSchema = import_zod20.z.strictObject({
-  name: import_zod20.z.string().min(1),
-  defaultConfigProfile: import_zod20.z.union([import_zod20.z.string().min(1), import_zod20.z.literal(false)]).optional(),
-  allowAmbientCredential: import_zod20.z.boolean().optional(),
-  credential: import_zod20.z.union([import_zod20.z.literal(false), CredentialWriteSchema(CREDENTIAL_TARGETS)]).optional()
+var ConfigIdentitySetInputSchema = import_zod21.z.strictObject({
+  name: import_zod21.z.string().min(1),
+  defaultConfigProfile: import_zod21.z.union([import_zod21.z.string().min(1), import_zod21.z.literal(false)]).optional(),
+  allowAmbientCredential: import_zod21.z.boolean().optional(),
+  credential: import_zod21.z.union([import_zod21.z.literal(false), CredentialWriteSchema(CREDENTIAL_TARGETS)]).optional()
 });
 var ConfigIdentitySetOutputSchema = storedMutationOutput("identity", "updated", IdentityValueSchema);
-var ConfigIdentityRemoveInputSchema = import_zod20.z.strictObject({ name: import_zod20.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigIdentityRemoveInputSchema = import_zod21.z.strictObject({ name: import_zod21.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigIdentityRemoveOutputSchema = mutationOutput("identity", "removed");
 var ConfigIdentityUseOutputSchema = mutationOutput("identity", "selected");
-var ConfigProfileAddInputSchema = import_zod20.z.strictObject({
-  name: import_zod20.z.string().min(1),
-  extends: import_zod20.z.array(import_zod20.z.string().min(1)).optional(),
-  description: import_zod20.z.string().optional()
+var ConfigProfileAddInputSchema = import_zod21.z.strictObject({
+  name: import_zod21.z.string().min(1),
+  extends: import_zod21.z.array(import_zod21.z.string().min(1)).optional(),
+  description: import_zod21.z.string().optional()
 });
 var ConfigProfileAddOutputSchema = storedMutationOutput("profile", "created", ProfileValueSchema);
-var ConfigProfileSetInputSchema = import_zod20.z.strictObject({
-  name: import_zod20.z.string().min(1),
-  category: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.boolean()).optional(),
-  entry: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.boolean()).optional(),
-  extends: import_zod20.z.union([import_zod20.z.array(import_zod20.z.string().min(1)), import_zod20.z.literal(false)]).optional(),
-  description: import_zod20.z.union([import_zod20.z.string(), import_zod20.z.literal(false)]).optional(),
-  launch: import_zod20.z.strictObject({
-    skipPermissions: import_zod20.z.boolean().optional(),
-    remoteControl: import_zod20.z.boolean().optional(),
-    headroom: import_zod20.z.boolean().optional(),
-    trackUsage: import_zod20.z.boolean().optional(),
-    provider: import_zod20.z.union([import_zod20.z.string().min(1), import_zod20.z.literal(false)]).optional(),
-    claudeVersion: import_zod20.z.union([import_zod20.z.string().min(1), import_zod20.z.literal(false)]).optional()
+var ConfigProfileSetInputSchema = import_zod21.z.strictObject({
+  name: import_zod21.z.string().min(1),
+  category: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.boolean()).optional(),
+  entry: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.boolean()).optional(),
+  extends: import_zod21.z.union([import_zod21.z.array(import_zod21.z.string().min(1)), import_zod21.z.literal(false)]).optional(),
+  description: import_zod21.z.union([import_zod21.z.string(), import_zod21.z.literal(false)]).optional(),
+  launch: import_zod21.z.strictObject({
+    skipPermissions: import_zod21.z.boolean().optional(),
+    remoteControl: import_zod21.z.boolean().optional(),
+    headroom: import_zod21.z.boolean().optional(),
+    trackUsage: import_zod21.z.boolean().optional(),
+    provider: import_zod21.z.union([import_zod21.z.string().min(1), import_zod21.z.literal(false)]).optional(),
+    claudeVersion: import_zod21.z.union([import_zod21.z.string().min(1), import_zod21.z.literal(false)]).optional()
   }).optional()
 });
 var ConfigProfileSetOutputSchema = storedMutationOutput("profile", "updated", ProfileValueSchema);
-var ConfigProfileRemoveInputSchema = import_zod20.z.strictObject({ name: import_zod20.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProfileRemoveInputSchema = import_zod21.z.strictObject({ name: import_zod21.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigProfileRemoveOutputSchema = mutationOutput("profile", "removed");
 var ConfigProfileUseOutputSchema = mutationOutput("profile", "selected");
-var PoolMembersInputSchema = import_zod20.z.array(import_zod20.z.string().min(1)).min(1);
-var ConfigPoolAddInputSchema = import_zod20.z.strictObject({
-  name: import_zod20.z.string().min(1),
+var PoolMembersInputSchema = import_zod21.z.array(import_zod21.z.string().min(1)).min(1);
+var ConfigPoolAddInputSchema = import_zod21.z.strictObject({
+  name: import_zod21.z.string().min(1),
   identities: PoolMembersInputSchema,
-  preference: import_zod20.z.enum(POOL_PREFERENCES).optional()
+  preference: import_zod21.z.enum(POOL_PREFERENCES).optional()
 });
 var ConfigPoolAddOutputSchema = storedMutationOutput("pool", "created", PoolSchema);
-var ConfigPoolSetInputSchema = import_zod20.z.strictObject({
-  name: import_zod20.z.string().min(1),
+var ConfigPoolSetInputSchema = import_zod21.z.strictObject({
+  name: import_zod21.z.string().min(1),
   identities: PoolMembersInputSchema.optional(),
-  preference: import_zod20.z.union([import_zod20.z.enum(POOL_PREFERENCES), import_zod20.z.literal(false)]).optional()
+  preference: import_zod21.z.union([import_zod21.z.enum(POOL_PREFERENCES), import_zod21.z.literal(false)]).optional()
 });
 var ConfigPoolSetOutputSchema = storedMutationOutput("pool", "updated", PoolSchema);
-var ConfigPoolRemoveInputSchema = import_zod20.z.strictObject({ name: import_zod20.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigPoolRemoveInputSchema = import_zod21.z.strictObject({ name: import_zod21.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigPoolRemoveOutputSchema = mutationOutput("pool", "removed");
 var ConfigPoolUseOutputSchema = mutationOutput("pool", "selected");
-var ConfigProviderAddInputSchema = import_zod20.z.strictObject({
-  name: import_zod20.z.string().min(1),
-  kind: import_zod20.z.enum(PROVIDER_KINDS).optional(),
-  displayName: import_zod20.z.string().min(1),
-  baseUrl: import_zod20.z.string().min(1).optional(),
+var ConfigProviderAddInputSchema = import_zod21.z.strictObject({
+  name: import_zod21.z.string().min(1),
+  kind: import_zod21.z.enum(PROVIDER_KINDS).optional(),
+  displayName: import_zod21.z.string().min(1),
+  baseUrl: import_zod21.z.string().min(1).optional(),
   credential: CredentialWriteSchema(PROVIDER_CREDENTIAL_TARGETS).required({ sources: true }),
   codex: CodexProviderConfigSchema.optional()
 });
 var ConfigProviderAddOutputSchema = storedMutationOutput("provider", "created", ProviderValueSchema);
-var ConfigProviderSetInputSchema = import_zod20.z.strictObject({
-  name: import_zod20.z.string().min(1),
-  displayName: import_zod20.z.string().min(1).optional(),
-  baseUrl: import_zod20.z.string().min(1).optional(),
+var ConfigProviderSetInputSchema = import_zod21.z.strictObject({
+  name: import_zod21.z.string().min(1),
+  displayName: import_zod21.z.string().min(1).optional(),
+  baseUrl: import_zod21.z.string().min(1).optional(),
   credential: CredentialWriteSchema(PROVIDER_CREDENTIAL_TARGETS).optional(),
   codex: CodexProviderConfigSchema.optional()
 });
 var ConfigProviderSetOutputSchema = storedMutationOutput("provider", "updated", ProviderValueSchema);
-var ConfigProviderRemoveInputSchema = import_zod20.z.strictObject({ name: import_zod20.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProviderRemoveInputSchema = import_zod21.z.strictObject({ name: import_zod21.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigProviderRemoveOutputSchema = mutationOutput("provider", "removed");
-var ConfigRuleAddInputSchema = import_zod20.z.strictObject({
-  path: import_zod20.z.string().min(1),
-  configProfile: import_zod20.z.string().min(1).optional(),
-  identity: import_zod20.z.string().min(1).optional()
+var ConfigRuleAddInputSchema = import_zod21.z.strictObject({
+  path: import_zod21.z.string().min(1),
+  configProfile: import_zod21.z.string().min(1).optional(),
+  identity: import_zod21.z.string().min(1).optional()
 });
 var ConfigRuleAddOutputSchema = storedMutationOutput("rule", "created", DirectoryRuleSchema);
-var ConfigRuleSetInputSchema = import_zod20.z.strictObject({
-  path: import_zod20.z.string().min(1),
-  configProfile: import_zod20.z.union([import_zod20.z.string().min(1), import_zod20.z.literal(false)]).optional(),
-  identity: import_zod20.z.union([import_zod20.z.string().min(1), import_zod20.z.literal(false)]).optional()
+var ConfigRuleSetInputSchema = import_zod21.z.strictObject({
+  path: import_zod21.z.string().min(1),
+  configProfile: import_zod21.z.union([import_zod21.z.string().min(1), import_zod21.z.literal(false)]).optional(),
+  identity: import_zod21.z.union([import_zod21.z.string().min(1), import_zod21.z.literal(false)]).optional()
 });
 var ConfigRuleSetOutputSchema = storedMutationOutput("rule", "updated", DirectoryRuleSchema);
-var ConfigRuleRemoveInputSchema = import_zod20.z.strictObject({ path: import_zod20.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigRuleRemoveInputSchema = import_zod21.z.strictObject({ path: import_zod21.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigRuleRemoveOutputSchema = mutationOutput("rule", "removed");
 
 // src/frontdoor/configApi.ts
@@ -13498,7 +13781,7 @@ function profileValue(name, paths) {
 function createConfigApiRouter(deps) {
   const authed = doorApiAuth(deps.expectedToken);
   const { paths } = deps;
-  const route = (path36, summary) => authed.meta((0, import_openapi3.openapi)({ method: "POST", path: path36, summary, tags: [CONFIG_API_TAG] }));
+  const route = (path37, summary) => authed.meta((0, import_openapi3.openapi)({ method: "POST", path: path37, summary, tags: [CONFIG_API_TAG] }));
   return {
     config: {
       identity: {
@@ -13740,41 +14023,41 @@ var import_openapi4 = require("@orpc/openapi");
 var import_server3 = require("@orpc/server");
 
 // src/frontdoor/eventSchemas.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 var DOOR_EVENT_SOURCE_RC = "rc";
 var LAUNCH_EVENT_SOURCE = "launch";
 var USAGE_EVENT_SOURCE = "usage";
 var DOOR_HEALTH_EVENT_SOURCE = "door";
 var QUOTA_EXPIRING_EVENT_SOURCE = "quota-expiring";
-var DoorEventSchema = import_zod21.z.strictObject({
-  source: import_zod21.z.string().min(1),
+var DoorEventSchema = import_zod22.z.strictObject({
+  source: import_zod22.z.string().min(1),
   /** A positive integer because the backbone's counters start at one and only ever increase. */
-  sequence: import_zod21.z.number().int().positive(),
-  payload: import_zod21.z.unknown()
+  sequence: import_zod22.z.number().int().positive(),
+  payload: import_zod22.z.unknown()
 });
-var DoorEventSourceQuerySchema = import_zod21.z.strictObject({
-  sources: import_zod21.z.array(import_zod21.z.string().min(1)).min(1).optional()
+var DoorEventSourceQuerySchema = import_zod22.z.strictObject({
+  sources: import_zod22.z.array(import_zod22.z.string().min(1)).min(1).optional()
 });
-var LaunchLifecycleEventSchema = import_zod21.z.strictObject({
-  kind: import_zod21.z.enum(["registered", "pruned", "ended"]),
-  pid: import_zod21.z.number().int().positive(),
-  startedAt: import_zod21.z.number(),
-  observedAt: import_zod21.z.number()
+var LaunchLifecycleEventSchema = import_zod22.z.strictObject({
+  kind: import_zod22.z.enum(["registered", "pruned", "ended"]),
+  pid: import_zod22.z.number().int().positive(),
+  startedAt: import_zod22.z.number(),
+  observedAt: import_zod22.z.number()
 });
-var DoorHealthEventSchema = import_zod21.z.discriminatedUnion("kind", [
-  import_zod21.z.strictObject({ kind: import_zod21.z.literal("generation"), pid: import_zod21.z.number().int().positive(), providerPort: import_zod21.z.number().int().positive(), connectPort: import_zod21.z.number().int().positive(), directPort: import_zod21.z.number().int().positive(), observedAt: import_zod21.z.number() }),
-  import_zod21.z.strictObject({ kind: import_zod21.z.literal("listenerFailed"), pid: import_zod21.z.number().int().positive(), listener: import_zod21.z.enum(["provider", "connect", "direct"]), message: import_zod21.z.string(), observedAt: import_zod21.z.number() }),
-  import_zod21.z.strictObject({ kind: import_zod21.z.literal("binaryTurnover"), pid: import_zod21.z.number().int().positive(), observedAt: import_zod21.z.number() }),
-  import_zod21.z.strictObject({ kind: import_zod21.z.literal("idleShutdown"), pid: import_zod21.z.number().int().positive(), observedAt: import_zod21.z.number() })
+var DoorHealthEventSchema = import_zod22.z.discriminatedUnion("kind", [
+  import_zod22.z.strictObject({ kind: import_zod22.z.literal("generation"), pid: import_zod22.z.number().int().positive(), providerPort: import_zod22.z.number().int().positive(), connectPort: import_zod22.z.number().int().positive(), directPort: import_zod22.z.number().int().positive(), observedAt: import_zod22.z.number() }),
+  import_zod22.z.strictObject({ kind: import_zod22.z.literal("listenerFailed"), pid: import_zod22.z.number().int().positive(), listener: import_zod22.z.enum(["provider", "connect", "direct"]), message: import_zod22.z.string(), observedAt: import_zod22.z.number() }),
+  import_zod22.z.strictObject({ kind: import_zod22.z.literal("binaryTurnover"), pid: import_zod22.z.number().int().positive(), observedAt: import_zod22.z.number() }),
+  import_zod22.z.strictObject({ kind: import_zod22.z.literal("idleShutdown"), pid: import_zod22.z.number().int().positive(), observedAt: import_zod22.z.number() })
 ]);
-var QuotaExpiringEventSchema = import_zod21.z.strictObject({
-  identity: import_zod21.z.string().min(1),
-  provider: import_zod21.z.string().min(1),
-  window: import_zod21.z.enum(["fiveHour", "sevenDay"]),
+var QuotaExpiringEventSchema = import_zod22.z.strictObject({
+  identity: import_zod22.z.string().min(1),
+  provider: import_zod22.z.string().min(1),
+  window: import_zod22.z.enum(["fiveHour", "sevenDay"]),
   /** The fraction of the window already used when it was seen expiring, always below one because a fully used window has nothing left to spend. */
-  utilization: import_zod21.z.number().min(0).max(1),
-  resetsAt: import_zod21.z.iso.datetime(),
-  observedAt: import_zod21.z.number()
+  utilization: import_zod22.z.number().min(0).max(1),
+  resetsAt: import_zod22.z.iso.datetime(),
+  observedAt: import_zod22.z.number()
 });
 
 // src/frontdoor/eventsApi.ts
@@ -13857,52 +14140,52 @@ var import_openapi6 = require("@orpc/openapi");
 init_cliError();
 
 // src/frontdoor/launchSchemas.ts
-var import_node_path30 = __toESM(require("node:path"), 1);
-var import_zod22 = require("zod");
+var import_node_path31 = __toESM(require("node:path"), 1);
+var import_zod23 = require("zod");
 init_claudeVersion();
 init_identity();
-var LaunchResolveInputSchema = import_zod22.z.strictObject({
-  path: import_zod22.z.string().min(1),
+var LaunchResolveInputSchema = import_zod23.z.strictObject({
+  path: import_zod23.z.string().min(1),
   /** `@name`, launch flags, then the arguments for `claude`; empty for a bare launch. */
-  argv: import_zod22.z.readonly(import_zod22.z.array(import_zod22.z.string())).optional(),
+  argv: import_zod23.z.readonly(import_zod23.z.array(import_zod23.z.string())).optional(),
   /** The launch's inherited environment. Absent means an empty one: the door's own environment is never a substitute for the caller's, so a caller that wants `AGENT_SHIM_*` switches or a `CLAUDE_CONFIG_DIR` considered names them here. Values are read, never reported. */
-  env: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).optional()
-}).refine((input) => import_node_path30.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
-var LaunchPoolDecisionSchema = import_zod22.z.strictObject({
-  name: import_zod22.z.string(),
-  reasons: import_zod22.z.readonly(import_zod22.z.array(import_zod22.z.string())),
-  movedOff: import_zod22.z.strictObject({ identity: import_zod22.z.string(), reason: import_zod22.z.string() }).optional()
+  env: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.string()).optional()
+}).refine((input) => import_node_path31.default.isAbsolute(input.path), { message: "path must be absolute: the door cannot resolve a relative path against the caller's working directory" });
+var LaunchPoolDecisionSchema = import_zod23.z.strictObject({
+  name: import_zod23.z.string(),
+  reasons: import_zod23.z.readonly(import_zod23.z.array(import_zod23.z.string())),
+  movedOff: import_zod23.z.strictObject({ identity: import_zod23.z.string(), reason: import_zod23.z.string() }).optional()
 });
-var LaunchDecisionSchema = import_zod22.z.strictObject({
-  identity: import_zod22.z.string().optional(),
-  identitySource: import_zod22.z.enum(IDENTITY_DECISION_SOURCES),
+var LaunchDecisionSchema = import_zod23.z.strictObject({
+  identity: import_zod23.z.string().optional(),
+  identitySource: import_zod23.z.enum(IDENTITY_DECISION_SOURCES),
   pool: LaunchPoolDecisionSchema.optional(),
-  configDirEscapeHatch: import_zod22.z.boolean(),
-  configDir: import_zod22.z.string().optional(),
-  configProfile: import_zod22.z.string().optional(),
-  configProfileSource: import_zod22.z.enum(CONFIG_PROFILE_DECISION_SOURCES),
-  provider: import_zod22.z.string().optional()
+  configDirEscapeHatch: import_zod23.z.boolean(),
+  configDir: import_zod23.z.string().optional(),
+  configProfile: import_zod23.z.string().optional(),
+  configProfileSource: import_zod23.z.enum(CONFIG_PROFILE_DECISION_SOURCES),
+  provider: import_zod23.z.string().optional()
 });
-var LaunchFlagsSchema = import_zod22.z.strictObject({
-  skipPermissions: import_zod22.z.boolean(),
-  remoteControl: import_zod22.z.boolean(),
-  headroom: import_zod22.z.boolean(),
-  trackUsage: import_zod22.z.boolean()
+var LaunchFlagsSchema = import_zod23.z.strictObject({
+  skipPermissions: import_zod23.z.boolean(),
+  remoteControl: import_zod23.z.boolean(),
+  headroom: import_zod23.z.boolean(),
+  trackUsage: import_zod23.z.boolean()
 });
-var LaunchResolveOutputSchema = import_zod22.z.strictObject({
+var LaunchResolveOutputSchema = import_zod23.z.strictObject({
   decision: LaunchDecisionSchema,
   flags: LaunchFlagsSchema,
-  claudeVersion: import_zod22.z.strictObject({ version: import_zod22.z.string(), source: import_zod22.z.enum(CLAUDE_VERSION_SOURCES) }).optional(),
+  claudeVersion: import_zod23.z.strictObject({ version: import_zod23.z.string(), source: import_zod23.z.enum(CLAUDE_VERSION_SOURCES) }).optional(),
   /** The real `claude` binary the launch would spawn, on the door's host. */
-  bin: import_zod22.z.string(),
+  bin: import_zod23.z.string(),
   /** The arguments the launch would pass it: the tool's own flags, then `CLAUDE_EXTRA_FLAGS`, then the caller's own. */
-  args: import_zod22.z.readonly(import_zod22.z.array(import_zod22.z.string())),
+  args: import_zod23.z.readonly(import_zod23.z.array(import_zod23.z.string())),
   /** The credential the launch would authenticate with, by target and source kinds. Absent when none applies. */
-  credential: import_zod22.z.strictObject({ subject: import_zod22.z.enum(["provider", "identity"]), name: import_zod22.z.string(), summary: CredentialSummarySchema }).optional(),
-  routing: import_zod22.z.strictObject({ frontDoor: import_zod22.z.boolean(), headroom: import_zod22.z.boolean() }),
+  credential: import_zod23.z.strictObject({ subject: import_zod23.z.enum(["provider", "identity"]), name: import_zod23.z.string(), summary: CredentialSummarySchema }).optional(),
+  routing: import_zod23.z.strictObject({ frontDoor: import_zod23.z.boolean(), headroom: import_zod23.z.boolean() }),
   /** The names of the environment variables the launch would set or unset, sorted. Values are not reported. */
-  environment: import_zod22.z.readonly(import_zod22.z.array(import_zod22.z.string())),
-  warnings: import_zod22.z.readonly(import_zod22.z.array(import_zod22.z.string()))
+  environment: import_zod23.z.readonly(import_zod23.z.array(import_zod23.z.string())),
+  warnings: import_zod23.z.readonly(import_zod23.z.array(import_zod23.z.string()))
 });
 
 // src/frontdoor/launchApi.ts
@@ -15962,9 +16245,9 @@ data: ${JSON.stringify(envelope)}
 }
 
 // src/frontdoor/rcSelfHostMint.ts
-var import_node_path31 = __toESM(require("node:path"), 1);
+var import_node_path32 = __toESM(require("node:path"), 1);
 init_account();
-var CREDENTIALS_FILE = ".credentials.json";
+var CREDENTIALS_FILE2 = ".credentials.json";
 var CLAUDE_JSON2 = ".claude.json";
 var RC_SELF_HOST_RECORD_DIR = "rc-selfhost";
 var RC_SELF_HOST_RECORD_FILE = "credential.json";
@@ -15987,7 +16270,7 @@ function readJsonObject(fs12, file) {
   return isRecord11(parsed) ? parsed : void 0;
 }
 function readRcSelfHostRecord(fs12, frontdoorDir) {
-  const parsed = readJsonObject(fs12, import_node_path31.default.join(frontdoorDir, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE));
+  const parsed = readJsonObject(fs12, import_node_path32.default.join(frontdoorDir, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE));
   if (parsed === void 0) {
     return void 0;
   }
@@ -16001,11 +16284,11 @@ function mintRcSelfHostCredential(deps) {
   if (!isIdentityName(deps.identity)) {
     throw new Error(`"${deps.identity}" is not a valid identity name.`);
   }
-  const identityDir = import_node_path31.default.join(deps.identitiesDir, deps.identity);
-  const credentialsFile = import_node_path31.default.join(identityDir, CREDENTIALS_FILE);
-  const claudeJsonFile = import_node_path31.default.join(identityDir, CLAUDE_JSON2);
-  const recordDir = import_node_path31.default.join(deps.frontdoorDir, RC_SELF_HOST_RECORD_DIR);
-  const recordFile = import_node_path31.default.join(recordDir, RC_SELF_HOST_RECORD_FILE);
+  const identityDir = import_node_path32.default.join(deps.identitiesDir, deps.identity);
+  const credentialsFile = import_node_path32.default.join(identityDir, CREDENTIALS_FILE2);
+  const claudeJsonFile = import_node_path32.default.join(identityDir, CLAUDE_JSON2);
+  const recordDir = import_node_path32.default.join(deps.frontdoorDir, RC_SELF_HOST_RECORD_DIR);
+  const recordFile = import_node_path32.default.join(recordDir, RC_SELF_HOST_RECORD_FILE);
   const previousRecord = readRcSelfHostRecord(deps.fs, deps.frontdoorDir);
   const existingCredentials = readJsonObject(deps.fs, credentialsFile);
   const existingOauth = isRecord11(existingCredentials?.claudeAiOauth) ? existingCredentials.claudeAiOauth : void 0;
@@ -16021,7 +16304,7 @@ function mintRcSelfHostCredential(deps) {
   const organizationUuid = deps.newUuid();
   const accountUuid = deps.newUuid();
   const mintedAt = new Date(deps.now()).toISOString();
-  deps.fs.mkdirPrivate(import_node_path31.default.dirname(credentialsFile));
+  deps.fs.mkdirPrivate(import_node_path32.default.dirname(credentialsFile));
   deps.fs.writeFilePrivate(credentialsFile, `${JSON.stringify({ ...existingCredentials, claudeAiOauth: { accessToken, refreshToken, expiresAt: null, scopes: [...RC_SELF_HOST_SCOPE_LIST], subscriptionType: SELF_HOST_SUBSCRIPTION_TYPE, rateLimitTier: null } }, null, 2)}
 `);
   const claudeJson = readJsonObject(deps.fs, claudeJsonFile) ?? {};
@@ -16170,6 +16453,8 @@ init_ownCli();
 0 && (module.exports = {
   AMBIENT_CREDENTIAL_VARS,
   CHECK_CREDENTIAL_APPLIES,
+  CODEX_APP_SERVER_GENERATED_AGAINST,
+  CODEX_APP_SERVER_TIMEOUT_MS,
   CONNECT_INTERCEPT_HOST,
   CONNECT_INTERCEPT_HOSTS,
   CONNECT_LIMITS,
@@ -16180,7 +16465,12 @@ init_ownCli();
   CheckReportJsonSchema,
   CheckRunInputSchema,
   CliError,
+  CodexAccountReadSchema,
+  CodexAppServerProtocolError,
+  CodexAppServerRequestError,
+  CodexAppServerUnavailableError,
   CodexLogoutOutputSchema,
+  CodexRateLimitsReadSchema,
   CodexSignInSchema,
   CodexStatusOutputSchema,
   ConfigIdentityAddOutputSchema,
@@ -16438,6 +16728,8 @@ init_ownCli();
   rcSelfHostFromEnv,
   rcWebFetchAllowsPrivateFromEnv,
   readActiveIdentity,
+  readCodexAccount,
+  readCodexRateLimits,
   readDirectoryRules,
   readFarmManifest,
   readFrontDoorControlMaterial,
@@ -16449,6 +16741,7 @@ init_ownCli();
   readRcSelfHostRecord,
   readRcSessionFile,
   readUsageSnapshot,
+  realCodexAppServerPort,
   realConnectCertStore,
   realConnectEffects,
   realRcControlTransport,