claude-use 9.10.1 → 9.12.0

package/dist/index.cjs

@@ -2663,7 +2663,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "9.10.1",
+      version: "9.12.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>",
@@ -4585,6 +4585,25 @@ function windowBurn(records, which) {
   }
   return (last.utilization - first.utilization) / (last.atMs - first.atMs);
 }
+function windowRatio(records) {
+  const points = [];
+  for (const record of records) {
+    const unified = record.rateLimitHeaders === void 0 ? void 0 : parseUnifiedRateLimit(record.rateLimitHeaders);
+    const five = unified?.fiveHour;
+    const seven = unified?.sevenDay;
+    if (five?.utilization !== void 0 && five.resetsAt !== void 0 && seven?.utilization !== void 0 && seven.resetsAt !== void 0) {
+      points.push({ fiveResetsAt: five.resetsAt, sevenResetsAt: seven.resetsAt, five: five.utilization, seven: seven.utilization });
+    }
+  }
+  const latest = points.at(-1);
+  const current = points.filter((point) => point.fiveResetsAt === latest?.fiveResetsAt && point.sevenResetsAt === latest.sevenResetsAt);
+  const first = current.at(0);
+  const last = current.at(-1);
+  if (first === void 0 || last === void 0 || last.five <= first.five || last.seven <= first.seven) {
+    return void 0;
+  }
+  return (last.seven - first.seven) / (last.five - first.five);
+}
 function percent(fraction) {
   return `${String(Math.round(fraction * PERCENT))}%`;
 }
@@ -4666,15 +4685,21 @@ function assessIdentity(member, nowMs) {
   }
   const remaining = Math.max(0, 1 - basis.window.utilization);
   const untilResetMs = basis.window.resetsAtMs === void 0 ? basis.windowMs : Math.max(basis.window.resetsAtMs - nowMs, MS_PER_SECOND4);
-  const score = remaining * plan.capacity / (untilResetMs / MS_PER_HOUR2);
+  const weeklyScore = remaining * plan.capacity / (untilResetMs / MS_PER_HOUR2);
   const fiveRemaining = five?.utilization === void 0 ? void 0 : Math.max(0, 1 - five.utilization);
   const fiveUntil = five?.resetsAtMs === void 0 ? FIVE_HOUR_WINDOW_MS : Math.max(five.resetsAtMs - nowMs, MS_PER_SECOND4);
+  const ratio = windowRatio(member.records);
+  const fiveHourScore = basis.name === "sevenDay" && fiveRemaining !== void 0 && ratio !== void 0 ? Math.min(fiveRemaining * ratio, remaining) * plan.capacity / (fiveUntil / MS_PER_HOUR2) : void 0;
+  const fiveHourLeads = fiveHourScore !== void 0 && fiveHourScore > weeklyScore;
+  const score = fiveHourLeads ? fiveHourScore : weeklyScore;
+  const scoreWindow = fiveHourLeads ? "fiveHour" : basis.name;
+  const fiveHourTermReasons = basis.name !== "sevenDay" || fiveRemaining === void 0 ? [] : ratio === void 0 ? ["5h reset not scored: no measured 5h to 7d ratio yet"] : fiveHourLeads ? [`5h term leads: ${percent(fiveRemaining)} of 5h unused is about ${percent(Math.min(fiveRemaining * ratio, remaining))} of the week at the measured ratio, resets in ${formatAge(fiveUntil)}`] : [];
   const burn = windowBurn(member.records, "fiveHour");
   const sevenRemaining = seven?.utilization === void 0 ? void 0 : Math.max(0, 1 - seven.utilization);
   const sevenUntil = seven?.resetsAtMs === void 0 ? SEVEN_DAY_WINDOW_MS : Math.max(seven.resetsAtMs - nowMs, MS_PER_SECOND4);
   const sevenDayBurn = windowBurn(member.records, "sevenDay");
   return {
-    candidate: { ...base, class: "scored", score, scoreWindow: basis.name, reasons: [...windowReasons.map((reason, index) => index === windowReasons.length - 1 ? `${reason}${observedAgo}` : reason), ...planReasons] },
+    candidate: { ...base, class: "scored", score, scoreWindow, reasons: [...fiveHourTermReasons, ...windowReasons.map((reason, index) => index === windowReasons.length - 1 ? `${reason}${observedAgo}` : reason), ...planReasons] },
     ...fiveRemaining === void 0 ? {} : { fiveHour: { remaining: fiveRemaining, untilResetMs: fiveUntil } },
     ...burn === void 0 ? {} : { burn },
     ...sevenRemaining === void 0 ? {} : { sevenDay: { remaining: sevenRemaining, untilResetMs: sevenUntil } },
@@ -6068,21 +6093,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_zod16, ClaudeShimStateSchema, nodeLinkFs;
+var import_node_fs7, import_node_path26, import_zod17, 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_zod16 = require("zod");
+    import_zod17 = require("zod");
     init_commandDeps();
     init_store();
     init_realPorts();
     init_cliError();
-    ClaudeShimStateSchema = import_zod16.z.strictObject({
-      targetPath: import_zod16.z.string().min(1),
-      method: import_zod16.z.enum(["hardlink", "copy"]),
-      installedAtMs: import_zod16.z.number()
+    ClaudeShimStateSchema = import_zod17.z.strictObject({
+      targetPath: import_zod17.z.string().min(1),
+      method: import_zod17.z.enum(["hardlink", "copy"]),
+      installedAtMs: import_zod17.z.number()
     });
     nodeLinkFs = { link: import_node_fs7.default.linkSync, copyFile: import_node_fs7.default.copyFileSync, chmod: import_node_fs7.default.chmodSync };
   }
@@ -7718,15 +7743,15 @@ var init_anthropicUsageRefresh = __esm({
 });
 
 // src/usage/providerQuota.ts
-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 import_zod25, MS_PER_SECOND7, SECONDS_PER_HOUR, HOURS_PER_DAY4, 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_zod24 = require("zod");
+    import_zod25 = require("zod");
     init_schema2();
     MS_PER_SECOND7 = 1e3;
     SECONDS_PER_HOUR = 3600;
-    HOURS_PER_DAY3 = 24;
+    HOURS_PER_DAY4 = 24;
     DAYS_PER_MONTH = 30;
     ZAI_HOST = "api.z.ai";
     ZAI_QUOTA_URL = `https://${ZAI_HOST}/api/monitor/usage/quota/limit`;
@@ -7734,37 +7759,37 @@ var init_providerQuota = __esm({
     ZAI_UNIT_MONTHS = 5;
     ZAI_UNIT_MS = /* @__PURE__ */ new Map([
       [ZAI_UNIT_HOURS, SECONDS_PER_HOUR * MS_PER_SECOND7],
-      [ZAI_UNIT_MONTHS, DAYS_PER_MONTH * HOURS_PER_DAY3 * SECONDS_PER_HOUR * MS_PER_SECOND7]
+      [ZAI_UNIT_MONTHS, DAYS_PER_MONTH * HOURS_PER_DAY4 * SECONDS_PER_HOUR * MS_PER_SECOND7]
     ]);
-    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()
+    ZaiLimitSchema = import_zod25.z.object({
+      type: import_zod25.z.string(),
+      unit: import_zod25.z.number().int(),
+      number: import_zod25.z.number().int().positive(),
+      percentage: import_zod25.z.number().nonnegative(),
+      nextResetTime: import_zod25.z.number().positive().optional(),
+      usage: import_zod25.z.number().nonnegative().optional(),
+      currentValue: import_zod25.z.number().nonnegative().optional(),
+      remaining: import_zod25.z.number().nonnegative().optional()
     });
-    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) })
+    ZaiResponseSchema = import_zod25.z.object({
+      success: import_zod25.z.boolean(),
+      msg: import_zod25.z.string().optional(),
+      data: import_zod25.z.object({ level: import_zod25.z.string().optional(), limits: import_zod25.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_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()
+    MS_PER_DAY3 = HOURS_PER_DAY4 * SECONDS_PER_HOUR * MS_PER_SECOND7;
+    OpenRouterKeySchema = import_zod25.z.object({
+      data: import_zod25.z.object({
+        limit: import_zod25.z.number().nonnegative().nullable(),
+        limit_remaining: import_zod25.z.number().nullable(),
+        limit_reset: import_zod25.z.string().nullable(),
+        is_free_tier: import_zod25.z.boolean().optional(),
+        free_model_daily_requests: import_zod25.z.object({ used: import_zod25.z.number().nonnegative(), limit: import_zod25.z.number().nonnegative(), remaining: import_zod25.z.number() }).optional()
       })
     });
-    OpenRouterCreditsSchema = import_zod24.z.object({ data: import_zod24.z.object({ total_credits: import_zod24.z.number().nonnegative(), total_usage: import_zod24.z.number().nonnegative() }) });
+    OpenRouterCreditsSchema = import_zod25.z.object({ data: import_zod25.z.object({ total_credits: import_zod25.z.number().nonnegative(), total_usage: import_zod25.z.number().nonnegative() }) });
   }
 });
 
@@ -8029,6 +8054,8 @@ __export(index_exports, {
   RcRateLimitWindowSchema: () => RcRateLimitWindowSchema,
   RcStreamEnvelopeSchema: () => RcStreamEnvelopeSchema,
   RcStreamEventSchema: () => RcStreamEventSchema,
+  ResetRowSchema: () => ResetRowSchema,
+  ResetScheduleSchema: () => ResetScheduleSchema,
   USAGE_EVENT_SOURCE: () => USAGE_EVENT_SOURCE,
   UpdateCheckOutputSchema: () => UpdateCheckOutputSchema,
   UsageError: () => UsageError,
@@ -8073,6 +8100,7 @@ __export(index_exports, {
   collectDoctorReport: () => collectDoctorReport,
   collectFrontDoorStatus: () => collectFrontDoorStatus,
   collectPoolPick: () => collectPoolPick,
+  collectResets: () => collectResets,
   createCodexApiRouter: () => createCodexApiRouter,
   createConfigApiRouter: () => createConfigApiRouter,
   createControlApiRouter: () => createControlApiRouter,
@@ -12356,7 +12384,7 @@ var PoolPickCandidateViewSchema = import_zod14.z.strictObject({
   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_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`. */
+  /** Which window's reset divides the score: the seven-day window, or the five-hour one when the member reports no seven-day utilisation or its measured-ratio five-hour term outranks the weekly one; present with `score`. */
   scoreWindow: import_zod14.z.enum(["sevenDay", "fiveHour"]).optional(),
   /** False when the five-hour window would run dry, at the observed pace, before it resets. */
   feasible: import_zod14.z.boolean(),
@@ -12474,9 +12502,79 @@ var CheckReportJsonSchema = import_zod15.z.strictObject({
 init_middleware();
 init_preflight();
 
+// src/usage/resets.ts
+init_preflight();
+init_rateLimit();
+var MS_PER_HOUR3 = 36e5;
+var HOURS_PER_DAY3 = 24;
+function formatPeriod(window) {
+  if (window.periodMs === void 0) {
+    return window.period ?? "unknown period";
+  }
+  const hours = window.periodMs / MS_PER_HOUR3;
+  return hours >= HOURS_PER_DAY3 && Number.isInteger(hours / HOURS_PER_DAY3) ? `${String(hours / HOURS_PER_DAY3)}d` : `${String(hours)}h`;
+}
+function groupOf(row) {
+  return row.resetsAt === void 0 ? 2 : row.reset ? 1 : 0;
+}
+function compareRows(left, right) {
+  return groupOf(left) - groupOf(right) || (left.resetsAt ?? "").localeCompare(right.resetsAt ?? "") || left.identity.localeCompare(right.identity) || left.provider.localeCompare(right.provider) || left.window.localeCompare(right.window);
+}
+function rowOf(snapshot, provider, window, observedAt2, recorded, nowMs) {
+  const effective = effectiveWindow(recorded, nowMs);
+  return {
+    identity: snapshot.identity,
+    provider,
+    window,
+    observedAt: observedAt2,
+    ...recorded.resetsAt === void 0 ? {} : { resetsAt: recorded.resetsAt },
+    reset: effective.reset,
+    ...effective.utilization === void 0 ? {} : { utilization: effective.utilization },
+    ...effective.status === void 0 ? {} : { status: effective.status }
+  };
+}
+function collectResets(snapshots, nowMs) {
+  const rows = snapshots.flatMap(
+    (snapshot) => Object.entries(snapshot.providers).flatMap(([provider, state]) => {
+      const unified = state.rateLimit?.unified;
+      const observedAt2 = state.rateLimit?.observedAt;
+      const overage = unified === void 0 ? void 0 : soleOverageWindow(unified);
+      const headerRows = observedAt2 === void 0 || unified === void 0 ? [] : [
+        ...unified.fiveHour === void 0 ? [] : [rowOf(snapshot, provider, "5h", observedAt2, unified.fiveHour, nowMs)],
+        ...unified.sevenDay === void 0 ? [] : [rowOf(snapshot, provider, "7d", observedAt2, unified.sevenDay, nowMs)],
+        ...overage === void 0 ? [] : [rowOf(snapshot, provider, "extra usage", observedAt2, overage, nowMs)]
+      ];
+      const quota = state.quota;
+      const quotaRows = quota === void 0 ? [] : quota.windows.map((window) => rowOf(snapshot, provider, `${window.measures} ${formatPeriod(window)}`, quota.observedAt, window, nowMs));
+      return [...headerRows, ...quotaRows];
+    })
+  );
+  return { resets: rows.sort(compareRows) };
+}
+
+// src/usage/resetsSchema.ts
+var import_zod16 = require("zod");
+var ResetRowSchema = import_zod16.z.strictObject({
+  identity: import_zod16.z.string(),
+  provider: import_zod16.z.string(),
+  /** What the window is: `5h`, `7d` or `extra usage` for an Anthropic account, or the provider's own measure and period (`tokens 5h`). */
+  window: import_zod16.z.string(),
+  /** When the state the window comes from was observed, as an ISO instant. */
+  observedAt: import_zod16.z.iso.datetime(),
+  /** When the window resets, as an ISO instant; absent when the upstream reported none. */
+  resetsAt: import_zod16.z.iso.datetime().optional(),
+  /** True when the reset time has passed, so the recorded observation describes a window that no longer exists and its utilisation reads as 0. */
+  reset: import_zod16.z.boolean(),
+  /** The fraction used, as `effectiveWindow` reads it at the report's own clock. */
+  utilization: import_zod16.z.number().optional(),
+  /** The window's own status, for a window that has not reset yet. */
+  status: import_zod16.z.string().optional()
+});
+var ResetScheduleSchema = import_zod16.z.strictObject({ resets: import_zod16.z.readonly(import_zod16.z.array(ResetRowSchema)) });
+
 // src/frontdoor/controlSchemas.ts
 var import_node_path30 = __toESM(require("node:path"), 1);
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 
 // src/doctorReport.ts
 init_claudeShim();
@@ -12671,24 +12769,24 @@ function credentialsFilePath(farmRoot) {
 }
 
 // src/codex/siwcStore.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 
 // src/codex/auth.ts
-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()
+var import_zod18 = require("zod");
+var AuthFileSchema = import_zod18.z.looseObject({
+  tokens: import_zod18.z.looseObject({
+    access_token: import_zod18.z.string().optional(),
+    refresh_token: import_zod18.z.string().optional(),
+    id_token: import_zod18.z.string().optional(),
+    account_id: import_zod18.z.string().optional()
   }).nullish(),
-  last_refresh: import_zod17.z.string().optional()
+  last_refresh: import_zod18.z.string().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 TokenGrantSchema = import_zod18.z.looseObject({
+  access_token: import_zod18.z.string().min(1).optional(),
+  refresh_token: import_zod18.z.string().min(1).optional(),
+  id_token: import_zod18.z.string().min(1).optional(),
+  account_id: import_zod18.z.string().min(1).optional()
 });
 var CodexAuthError = class extends Error {
   constructor(message) {
@@ -12698,41 +12796,41 @@ var CodexAuthError = class extends Error {
 };
 
 // src/codex/siwc.ts
-var import_zod18 = require("zod");
+var import_zod19 = 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_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 TokenResponseSchema = import_zod19.z.looseObject({
+  access_token: import_zod19.z.string().min(1),
+  refresh_token: import_zod19.z.string().min(1).optional(),
+  id_token: import_zod19.z.string().min(1).optional(),
+  expires_in: import_zod19.z.number().positive(),
+  scope: import_zod19.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 JwtHeaderSchema = import_zod19.z.looseObject({ alg: import_zod19.z.string(), kid: import_zod19.z.string().optional() });
+var IdTokenClaimsSchema = import_zod19.z.looseObject({
+  iss: import_zod19.z.string(),
+  sub: import_zod19.z.string().min(1),
+  aud: import_zod19.z.union([import_zod19.z.string(), import_zod19.z.array(import_zod19.z.string())]),
+  exp: import_zod19.z.number(),
+  nonce: import_zod19.z.string().optional(),
+  email: import_zod19.z.string().optional()
 });
-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() })) });
+var JwksSchema = import_zod19.z.object({ keys: import_zod19.z.array(import_zod19.z.looseObject({ kid: import_zod19.z.string().optional(), kty: import_zod19.z.string() })) });
 
 // src/codex/siwcStore.ts
-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(),
+var SiwcGrantSchema = import_zod20.z.strictObject({
+  clientId: import_zod20.z.string().min(1),
+  sub: import_zod20.z.string().min(1),
+  email: import_zod20.z.string().optional(),
+  idToken: import_zod20.z.string().min(1),
+  accessToken: import_zod20.z.string().min(1),
+  refreshToken: import_zod20.z.string().min(1),
+  scopes: import_zod20.z.array(import_zod20.z.string()).readonly(),
   /** When the access token stops working, in milliseconds since the epoch. */
-  expiresAt: import_zod19.z.number()
+  expiresAt: import_zod20.z.number()
 });
-var SiwcFileSchema = import_zod19.z.strictObject({ registeredClientId: import_zod19.z.string().min(1).optional(), grant: SiwcGrantSchema.optional() });
+var SiwcFileSchema = import_zod20.z.strictObject({ registeredClientId: import_zod20.z.string().min(1).optional(), grant: SiwcGrantSchema.optional() });
 function parseSiwcFile(raw, filePath) {
   let json;
   try {
@@ -13355,90 +13453,90 @@ function collectDoctorReport(params) {
 // src/frontdoor/controlSchemas.ts
 init_schema2();
 init_state();
-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 UsageListOutputSchema = import_zod21.z.strictObject({ snapshots: import_zod21.z.readonly(import_zod21.z.array(UsageSnapshotSchema)) });
+var UsageWindowsInputSchema = import_zod21.z.strictObject({
+  identity: import_zod21.z.string().min(1),
+  provider: import_zod21.z.string().min(1).optional()
 });
-var EffectiveWindowSchema = import_zod20.z.strictObject({
+var EffectiveWindowSchema = import_zod21.z.strictObject({
   /** True when the window's reset time has passed, so the recorded observation describes a window that no longer exists. */
-  reset: import_zod20.z.boolean(),
+  reset: import_zod21.z.boolean(),
   /** The fraction used: 0 for a reset window, otherwise what was last observed, absent when none was reported. */
-  utilization: import_zod20.z.number().optional(),
+  utilization: import_zod21.z.number().optional(),
   /** The reset instant, for a window that has not reset yet and reported one. */
-  resetsAtMs: import_zod20.z.number().optional(),
+  resetsAtMs: import_zod21.z.number().optional(),
   /** The window's own status, for a window that has not reset yet. */
-  status: import_zod20.z.string().optional()
+  status: import_zod21.z.string().optional()
 });
-var UsageWindowsOutputSchema = import_zod20.z.strictObject({
-  identity: import_zod20.z.string(),
-  provider: import_zod20.z.string(),
+var UsageWindowsOutputSchema = import_zod21.z.strictObject({
+  identity: import_zod21.z.string(),
+  provider: import_zod21.z.string(),
   /** When the rate-limit state the windows come from was observed. */
-  observedAt: import_zod20.z.iso.datetime().optional(),
+  observedAt: import_zod21.z.iso.datetime().optional(),
   fiveHour: EffectiveWindowSchema.optional(),
   sevenDay: EffectiveWindowSchema.optional()
 });
-var UsageLiveOutputSchema = import_zod20.z.strictObject({
+var UsageLiveOutputSchema = import_zod21.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_zod20.z.readonly(import_zod20.z.array(RcLiveRateLimitSchema))
+  sessions: import_zod21.z.readonly(import_zod21.z.array(RcLiveRateLimitSchema))
 });
-var FrontDoorSessionStatusSchema = import_zod20.z.strictObject({
-  pid: import_zod20.z.int().positive(),
-  startedAt: import_zod20.z.number(),
-  alive: import_zod20.z.boolean()
+var FrontDoorSessionStatusSchema = import_zod21.z.strictObject({
+  pid: import_zod21.z.int().positive(),
+  startedAt: import_zod21.z.number(),
+  alive: import_zod21.z.boolean()
 });
-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({
+var HeadroomSocketTargetSchema = import_zod21.z.union([import_zod21.z.strictObject({ socketPath: import_zod21.z.string() }), import_zod21.z.strictObject({ refused: import_zod21.z.string() })]);
+var FrontDoorStatusOutputSchema = import_zod21.z.strictObject({
   state: FrontDoorStateSchema,
-  supervisorAlive: import_zod20.z.boolean(),
-  sessions: import_zod20.z.readonly(import_zod20.z.array(FrontDoorSessionStatusSchema)),
+  supervisorAlive: import_zod21.z.boolean(),
+  sessions: import_zod21.z.readonly(import_zod21.z.array(FrontDoorSessionStatusSchema)),
   headroomSocket: HeadroomSocketTargetSchema.optional(),
-  logPath: import_zod20.z.string(),
-  logExists: import_zod20.z.boolean()
+  logPath: import_zod21.z.string(),
+  logExists: import_zod21.z.boolean()
 });
-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()
+var FrontDoorSessionsOutputSchema = import_zod21.z.strictObject({ sessions: import_zod21.z.readonly(import_zod21.z.array(FrontDoorSessionStatusSchema)) });
+var CheckRunInputSchema = import_zod21.z.strictObject({
+  path: import_zod21.z.string().min(1),
+  identity: import_zod21.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)
+var PoolPickInputSchema = import_zod21.z.strictObject({
+  pool: import_zod21.z.string().min(1),
+  path: import_zod21.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 DoctorFindingSchema = import_zod21.z.strictObject({
+  section: import_zod21.z.enum(DOCTOR_SECTIONS),
+  subject: import_zod21.z.string().optional(),
+  severity: import_zod21.z.enum(DOCTOR_SEVERITIES),
+  message: import_zod21.z.string()
 });
-var DoctorRunOutputSchema = import_zod20.z.strictObject({
+var DoctorRunOutputSchema = import_zod21.z.strictObject({
   /** False exactly when any finding is a `fail`; a `warn` never fails the report on its own. */
-  ok: import_zod20.z.boolean(),
-  findings: import_zod20.z.readonly(import_zod20.z.array(DoctorFindingSchema))
+  ok: import_zod21.z.boolean(),
+  findings: import_zod21.z.readonly(import_zod21.z.array(DoctorFindingSchema))
 });
-var FrontDoorRestartOutputSchema = import_zod20.z.strictObject({
-  action: import_zod20.z.literal("restarting"),
-  previousPid: import_zod20.z.int().positive()
+var FrontDoorRestartOutputSchema = import_zod21.z.strictObject({
+  action: import_zod21.z.literal("restarting"),
+  previousPid: import_zod21.z.int().positive()
 });
-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 UpdateCheckOutputSchema = import_zod21.z.strictObject({
+  current: import_zod21.z.string(),
+  latest: import_zod21.z.string(),
+  action: import_zod21.z.enum(["current", "available", "updated"])
 });
-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 CodexSignInSchema = import_zod21.z.discriminatedUnion("state", [
+  import_zod21.z.strictObject({ state: import_zod21.z.literal("none") }),
+  import_zod21.z.strictObject({ state: import_zod21.z.literal("signed-in"), email: import_zod21.z.string().optional(), planScope: import_zod21.z.boolean(), accessTokenExpiresAt: import_zod21.z.number() }),
+  import_zod21.z.strictObject({ state: import_zod21.z.literal("unreadable"), message: import_zod21.z.string() })
 ]);
-var CodexStatusOutputSchema = import_zod20.z.strictObject({
+var CodexStatusOutputSchema = import_zod21.z.strictObject({
   signIn: CodexSignInSchema,
-  codexProviders: import_zod20.z.readonly(import_zod20.z.array(import_zod20.z.string()))
+  codexProviders: import_zod21.z.readonly(import_zod21.z.array(import_zod21.z.string()))
 });
-var CodexLogoutOutputSchema = import_zod20.z.strictObject({
-  hadGrant: import_zod20.z.boolean(),
-  revoked: import_zod20.z.boolean()
+var CodexLogoutOutputSchema = import_zod21.z.strictObject({
+  hadGrant: import_zod21.z.boolean(),
+  revoked: import_zod21.z.boolean()
 });
 
 // src/frontdoor/codexApi.ts
@@ -13594,131 +13692,131 @@ init_identity();
 init_providersStore();
 
 // src/frontdoor/configSchemas.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 init_schema();
-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 RemovalConfirmationSchema = import_zod22.z.boolean();
+var CredentialWriteSchema = (targets) => import_zod22.z.strictObject({
+  sources: import_zod22.z.array(RemoteCredentialSourceSchema).min(1).optional(),
+  target: import_zod22.z.enum(targets).optional(),
+  cache: import_zod22.z.union([import_zod22.z.literal(false), CredentialCacheSchema]).optional()
 });
-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") })
+var CredentialSummarySchema2 = import_zod22.z.strictObject({
+  target: import_zod22.z.enum(CREDENTIAL_TARGETS),
+  sources: import_zod22.z.readonly(import_zod22.z.array(
+    import_zod22.z.discriminatedUnion("kind", [
+      import_zod22.z.strictObject({ kind: import_zod22.z.literal("env"), variable: import_zod22.z.string() }),
+      import_zod22.z.strictObject({ kind: import_zod22.z.literal("file"), path: import_zod22.z.string() }),
+      import_zod22.z.strictObject({ kind: import_zod22.z.literal("command"), program: import_zod22.z.string() }),
+      import_zod22.z.strictObject({ kind: import_zod22.z.literal("op"), reference: import_zod22.z.string() }),
+      import_zod22.z.strictObject({ kind: import_zod22.z.literal("keychain"), service: import_zod22.z.string(), account: import_zod22.z.string().optional() }),
+      import_zod22.z.strictObject({ kind: import_zod22.z.literal("literal") })
     ])
   )),
   cache: CredentialCacheSchema.optional()
 });
-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(),
+var mutationOutput = (kind, action) => import_zod22.z.strictObject({ action: import_zod22.z.literal(action), kind: import_zod22.z.literal(kind), name: import_zod22.z.string() });
+var storedMutationOutput = (kind, action, value) => import_zod22.z.strictObject({ action: import_zod22.z.literal(action), kind: import_zod22.z.literal(kind), name: import_zod22.z.string(), value });
+var IdentityValueSchema = import_zod22.z.strictObject({
+  name: import_zod22.z.string(),
+  defaultConfigProfile: import_zod22.z.string().optional(),
+  allowAmbientCredential: import_zod22.z.boolean(),
   credential: CredentialSummarySchema2.optional()
 });
 var ProfileValueSchema = ConfigProfileSchema.omit({ $schema: true });
-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(),
+var ProviderValueSchema = import_zod22.z.strictObject({
+  name: import_zod22.z.string(),
+  kind: import_zod22.z.enum(PROVIDER_KINDS),
+  displayName: import_zod22.z.string(),
+  baseUrl: import_zod22.z.string().optional(),
   codex: CodexProviderConfigSchema.optional(),
   credential: CredentialSummarySchema2,
-  env: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.string()).optional()
+  env: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string()).optional()
 });
-var ConfigNameInputSchema = import_zod21.z.strictObject({ name: import_zod21.z.string().min(1) });
+var ConfigNameInputSchema = import_zod22.z.strictObject({ name: import_zod22.z.string().min(1) });
 var ConfigIdentityAddOutputSchema = storedMutationOutput("identity", "created", IdentityValueSchema);
-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 ConfigIdentitySetInputSchema = import_zod22.z.strictObject({
+  name: import_zod22.z.string().min(1),
+  defaultConfigProfile: import_zod22.z.union([import_zod22.z.string().min(1), import_zod22.z.literal(false)]).optional(),
+  allowAmbientCredential: import_zod22.z.boolean().optional(),
+  credential: import_zod22.z.union([import_zod22.z.literal(false), CredentialWriteSchema(CREDENTIAL_TARGETS)]).optional()
 });
 var ConfigIdentitySetOutputSchema = storedMutationOutput("identity", "updated", IdentityValueSchema);
-var ConfigIdentityRemoveInputSchema = import_zod21.z.strictObject({ name: import_zod21.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigIdentityRemoveInputSchema = import_zod22.z.strictObject({ name: import_zod22.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigIdentityRemoveOutputSchema = mutationOutput("identity", "removed");
 var ConfigIdentityUseOutputSchema = mutationOutput("identity", "selected");
-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 ConfigProfileAddInputSchema = import_zod22.z.strictObject({
+  name: import_zod22.z.string().min(1),
+  extends: import_zod22.z.array(import_zod22.z.string().min(1)).optional(),
+  description: import_zod22.z.string().optional()
 });
 var ConfigProfileAddOutputSchema = storedMutationOutput("profile", "created", ProfileValueSchema);
-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()
+var ConfigProfileSetInputSchema = import_zod22.z.strictObject({
+  name: import_zod22.z.string().min(1),
+  category: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.boolean()).optional(),
+  entry: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.boolean()).optional(),
+  extends: import_zod22.z.union([import_zod22.z.array(import_zod22.z.string().min(1)), import_zod22.z.literal(false)]).optional(),
+  description: import_zod22.z.union([import_zod22.z.string(), import_zod22.z.literal(false)]).optional(),
+  launch: import_zod22.z.strictObject({
+    skipPermissions: import_zod22.z.boolean().optional(),
+    remoteControl: import_zod22.z.boolean().optional(),
+    headroom: import_zod22.z.boolean().optional(),
+    trackUsage: import_zod22.z.boolean().optional(),
+    provider: import_zod22.z.union([import_zod22.z.string().min(1), import_zod22.z.literal(false)]).optional(),
+    claudeVersion: import_zod22.z.union([import_zod22.z.string().min(1), import_zod22.z.literal(false)]).optional()
   }).optional()
 });
 var ConfigProfileSetOutputSchema = storedMutationOutput("profile", "updated", ProfileValueSchema);
-var ConfigProfileRemoveInputSchema = import_zod21.z.strictObject({ name: import_zod21.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProfileRemoveInputSchema = import_zod22.z.strictObject({ name: import_zod22.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigProfileRemoveOutputSchema = mutationOutput("profile", "removed");
 var ConfigProfileUseOutputSchema = mutationOutput("profile", "selected");
-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),
+var PoolMembersInputSchema = import_zod22.z.array(import_zod22.z.string().min(1)).min(1);
+var ConfigPoolAddInputSchema = import_zod22.z.strictObject({
+  name: import_zod22.z.string().min(1),
   identities: PoolMembersInputSchema,
-  preference: import_zod21.z.enum(POOL_PREFERENCES).optional()
+  preference: import_zod22.z.enum(POOL_PREFERENCES).optional()
 });
 var ConfigPoolAddOutputSchema = storedMutationOutput("pool", "created", PoolSchema);
-var ConfigPoolSetInputSchema = import_zod21.z.strictObject({
-  name: import_zod21.z.string().min(1),
+var ConfigPoolSetInputSchema = import_zod22.z.strictObject({
+  name: import_zod22.z.string().min(1),
   identities: PoolMembersInputSchema.optional(),
-  preference: import_zod21.z.union([import_zod21.z.enum(POOL_PREFERENCES), import_zod21.z.literal(false)]).optional()
+  preference: import_zod22.z.union([import_zod22.z.enum(POOL_PREFERENCES), import_zod22.z.literal(false)]).optional()
 });
 var ConfigPoolSetOutputSchema = storedMutationOutput("pool", "updated", PoolSchema);
-var ConfigPoolRemoveInputSchema = import_zod21.z.strictObject({ name: import_zod21.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigPoolRemoveInputSchema = import_zod22.z.strictObject({ name: import_zod22.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigPoolRemoveOutputSchema = mutationOutput("pool", "removed");
 var ConfigPoolUseOutputSchema = mutationOutput("pool", "selected");
-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(),
+var ConfigProviderAddInputSchema = import_zod22.z.strictObject({
+  name: import_zod22.z.string().min(1),
+  kind: import_zod22.z.enum(PROVIDER_KINDS).optional(),
+  displayName: import_zod22.z.string().min(1),
+  baseUrl: import_zod22.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_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(),
+var ConfigProviderSetInputSchema = import_zod22.z.strictObject({
+  name: import_zod22.z.string().min(1),
+  displayName: import_zod22.z.string().min(1).optional(),
+  baseUrl: import_zod22.z.string().min(1).optional(),
   credential: CredentialWriteSchema(PROVIDER_CREDENTIAL_TARGETS).optional(),
   codex: CodexProviderConfigSchema.optional()
 });
 var ConfigProviderSetOutputSchema = storedMutationOutput("provider", "updated", ProviderValueSchema);
-var ConfigProviderRemoveInputSchema = import_zod21.z.strictObject({ name: import_zod21.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigProviderRemoveInputSchema = import_zod22.z.strictObject({ name: import_zod22.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigProviderRemoveOutputSchema = mutationOutput("provider", "removed");
-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 ConfigRuleAddInputSchema = import_zod22.z.strictObject({
+  path: import_zod22.z.string().min(1),
+  configProfile: import_zod22.z.string().min(1).optional(),
+  identity: import_zod22.z.string().min(1).optional()
 });
 var ConfigRuleAddOutputSchema = storedMutationOutput("rule", "created", DirectoryRuleSchema);
-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 ConfigRuleSetInputSchema = import_zod22.z.strictObject({
+  path: import_zod22.z.string().min(1),
+  configProfile: import_zod22.z.union([import_zod22.z.string().min(1), import_zod22.z.literal(false)]).optional(),
+  identity: import_zod22.z.union([import_zod22.z.string().min(1), import_zod22.z.literal(false)]).optional()
 });
 var ConfigRuleSetOutputSchema = storedMutationOutput("rule", "updated", DirectoryRuleSchema);
-var ConfigRuleRemoveInputSchema = import_zod21.z.strictObject({ path: import_zod21.z.string().min(1), confirm: RemovalConfirmationSchema });
+var ConfigRuleRemoveInputSchema = import_zod22.z.strictObject({ path: import_zod22.z.string().min(1), confirm: RemovalConfirmationSchema });
 var ConfigRuleRemoveOutputSchema = mutationOutput("rule", "removed");
 
 // src/frontdoor/configApi.ts
@@ -14024,41 +14122,41 @@ var import_openapi4 = require("@orpc/openapi");
 var import_server3 = require("@orpc/server");
 
 // src/frontdoor/eventSchemas.ts
-var import_zod22 = require("zod");
+var import_zod23 = 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_zod22.z.strictObject({
-  source: import_zod22.z.string().min(1),
+var DoorEventSchema = import_zod23.z.strictObject({
+  source: import_zod23.z.string().min(1),
   /** A positive integer because the backbone's counters start at one and only ever increase. */
-  sequence: import_zod22.z.number().int().positive(),
-  payload: import_zod22.z.unknown()
+  sequence: import_zod23.z.number().int().positive(),
+  payload: import_zod23.z.unknown()
 });
-var DoorEventSourceQuerySchema = import_zod22.z.strictObject({
-  sources: import_zod22.z.array(import_zod22.z.string().min(1)).min(1).optional()
+var DoorEventSourceQuerySchema = import_zod23.z.strictObject({
+  sources: import_zod23.z.array(import_zod23.z.string().min(1)).min(1).optional()
 });
-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 LaunchLifecycleEventSchema = import_zod23.z.strictObject({
+  kind: import_zod23.z.enum(["registered", "pruned", "ended"]),
+  pid: import_zod23.z.number().int().positive(),
+  startedAt: import_zod23.z.number(),
+  observedAt: import_zod23.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 DoorHealthEventSchema = import_zod23.z.discriminatedUnion("kind", [
+  import_zod23.z.strictObject({ kind: import_zod23.z.literal("generation"), pid: import_zod23.z.number().int().positive(), providerPort: import_zod23.z.number().int().positive(), connectPort: import_zod23.z.number().int().positive(), directPort: import_zod23.z.number().int().positive(), observedAt: import_zod23.z.number() }),
+  import_zod23.z.strictObject({ kind: import_zod23.z.literal("listenerFailed"), pid: import_zod23.z.number().int().positive(), listener: import_zod23.z.enum(["provider", "connect", "direct"]), message: import_zod23.z.string(), observedAt: import_zod23.z.number() }),
+  import_zod23.z.strictObject({ kind: import_zod23.z.literal("binaryTurnover"), pid: import_zod23.z.number().int().positive(), observedAt: import_zod23.z.number() }),
+  import_zod23.z.strictObject({ kind: import_zod23.z.literal("idleShutdown"), pid: import_zod23.z.number().int().positive(), observedAt: import_zod23.z.number() })
 ]);
-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"]),
+var QuotaExpiringEventSchema = import_zod23.z.strictObject({
+  identity: import_zod23.z.string().min(1),
+  provider: import_zod23.z.string().min(1),
+  window: import_zod23.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_zod22.z.number().min(0).max(1),
-  resetsAt: import_zod22.z.iso.datetime(),
-  observedAt: import_zod22.z.number()
+  utilization: import_zod23.z.number().min(0).max(1),
+  resetsAt: import_zod23.z.iso.datetime(),
+  observedAt: import_zod23.z.number()
 });
 
 // src/frontdoor/eventsApi.ts
@@ -14142,51 +14240,51 @@ init_cliError();
 
 // src/frontdoor/launchSchemas.ts
 var import_node_path31 = __toESM(require("node:path"), 1);
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
 init_claudeVersion();
 init_identity();
-var LaunchResolveInputSchema = import_zod23.z.strictObject({
-  path: import_zod23.z.string().min(1),
+var LaunchResolveInputSchema = import_zod24.z.strictObject({
+  path: import_zod24.z.string().min(1),
   /** `@name`, launch flags, then the arguments for `claude`; empty for a bare launch. */
-  argv: import_zod23.z.readonly(import_zod23.z.array(import_zod23.z.string())).optional(),
+  argv: import_zod24.z.readonly(import_zod24.z.array(import_zod24.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_zod23.z.record(import_zod23.z.string(), import_zod23.z.string()).optional()
+  env: import_zod24.z.record(import_zod24.z.string(), import_zod24.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 LaunchPoolDecisionSchema = import_zod24.z.strictObject({
+  name: import_zod24.z.string(),
+  reasons: import_zod24.z.readonly(import_zod24.z.array(import_zod24.z.string())),
+  movedOff: import_zod24.z.strictObject({ identity: import_zod24.z.string(), reason: import_zod24.z.string() }).optional()
 });
-var LaunchDecisionSchema = import_zod23.z.strictObject({
-  identity: import_zod23.z.string().optional(),
-  identitySource: import_zod23.z.enum(IDENTITY_DECISION_SOURCES),
+var LaunchDecisionSchema = import_zod24.z.strictObject({
+  identity: import_zod24.z.string().optional(),
+  identitySource: import_zod24.z.enum(IDENTITY_DECISION_SOURCES),
   pool: LaunchPoolDecisionSchema.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()
+  configDirEscapeHatch: import_zod24.z.boolean(),
+  configDir: import_zod24.z.string().optional(),
+  configProfile: import_zod24.z.string().optional(),
+  configProfileSource: import_zod24.z.enum(CONFIG_PROFILE_DECISION_SOURCES),
+  provider: import_zod24.z.string().optional()
 });
-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 LaunchFlagsSchema = import_zod24.z.strictObject({
+  skipPermissions: import_zod24.z.boolean(),
+  remoteControl: import_zod24.z.boolean(),
+  headroom: import_zod24.z.boolean(),
+  trackUsage: import_zod24.z.boolean()
 });
-var LaunchResolveOutputSchema = import_zod23.z.strictObject({
+var LaunchResolveOutputSchema = import_zod24.z.strictObject({
   decision: LaunchDecisionSchema,
   flags: LaunchFlagsSchema,
-  claudeVersion: import_zod23.z.strictObject({ version: import_zod23.z.string(), source: import_zod23.z.enum(CLAUDE_VERSION_SOURCES) }).optional(),
+  claudeVersion: import_zod24.z.strictObject({ version: import_zod24.z.string(), source: import_zod24.z.enum(CLAUDE_VERSION_SOURCES) }).optional(),
   /** The real `claude` binary the launch would spawn, on the door's host. */
-  bin: import_zod23.z.string(),
+  bin: import_zod24.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_zod23.z.readonly(import_zod23.z.array(import_zod23.z.string())),
+  args: import_zod24.z.readonly(import_zod24.z.array(import_zod24.z.string())),
   /** The credential the launch would authenticate with, by target and source kinds. Absent when none applies. */
-  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() }),
+  credential: import_zod24.z.strictObject({ subject: import_zod24.z.enum(["provider", "identity"]), name: import_zod24.z.string(), summary: CredentialSummarySchema }).optional(),
+  routing: import_zod24.z.strictObject({ frontDoor: import_zod24.z.boolean(), headroom: import_zod24.z.boolean() }),
   /** The names of the environment variables the launch would set or unset, sorted. Values are not reported. */
-  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()))
+  environment: import_zod24.z.readonly(import_zod24.z.array(import_zod24.z.string())),
+  warnings: import_zod24.z.readonly(import_zod24.z.array(import_zod24.z.string()))
 });
 
 // src/frontdoor/launchApi.ts
@@ -14230,6 +14328,7 @@ function createControlApiRouter(deps) {
   return {
     usage: {
       list: authed.meta((0, import_openapi7.openapi)({ method: "GET", path: "/rest/usage/snapshots", summary: "List every identity's usage snapshot", tags: [USAGE_API_TAG] })).output(UsageListOutputSchema).handler(() => ({ snapshots: deps.usageSnapshots() })),
+      resets: authed.meta((0, import_openapi7.openapi)({ method: "GET", path: "/rest/usage/resets", summary: "List every recorded quota window with when it resets", tags: [USAGE_API_TAG] })).output(ResetScheduleSchema).handler(() => collectResets(deps.usageSnapshots(), deps.now())),
       effectiveWindow: authed.meta((0, import_openapi7.openapi)({ method: "GET", path: "/rest/usage/windows", summary: "Read one identity's effective quota windows", tags: [USAGE_API_TAG] })).input(UsageWindowsInputSchema).output(UsageWindowsOutputSchema).handler(({ input }) => {
         const snapshot = deps.usageSnapshotOf(input.identity);
         if (snapshot === void 0) {
@@ -14551,11 +14650,11 @@ function createDoorHealthPublisher(hub, now, pid) {
 
 // src/frontdoor/quotaExpiringEvents.ts
 init_schema2();
-var MS_PER_HOUR3 = 36e5;
+var MS_PER_HOUR4 = 36e5;
 var MS_PER_DAY2 = 864e5;
 var FIVE_HOUR_WINDOW_HOURS = 5;
 var SEVEN_DAY_WINDOW_DAYS = 7;
-var FIVE_HOUR_WINDOW_MS2 = FIVE_HOUR_WINDOW_HOURS * MS_PER_HOUR3;
+var FIVE_HOUR_WINDOW_MS2 = FIVE_HOUR_WINDOW_HOURS * MS_PER_HOUR4;
 var SEVEN_DAY_WINDOW_MS2 = SEVEN_DAY_WINDOW_DAYS * MS_PER_DAY2;
 var FINAL_SPAN_DENOMINATOR = 30;
 var QUOTA_EXPIRING_WINDOW_FRACTION = 1 / FINAL_SPAN_DENOMINATOR;
@@ -14996,7 +15095,7 @@ function numberOf(record, field) {
   }
   return void 0;
 }
-function pageOfRcChannel(url, rows, idOf, rowOf) {
+function pageOfRcChannel(url, rows, idOf, rowOf2) {
   const query = new URL(url, "http://127.0.0.1").searchParams;
   const anchor = query.get("after_event_id") ?? query.get("cursor");
   const rawLimit = query.get("limit");
@@ -15010,7 +15109,7 @@ function pageOfRcChannel(url, rows, idOf, rowOf) {
   }
   const page = limit === void 0 ? rows.slice(from) : rows.slice(from, from + limit);
   const last = page[page.length - 1];
-  return { data: page.map(rowOf), ...last === void 0 ? {} : { next_cursor: idOf(last) } };
+  return { data: page.map(rowOf2), ...last === void 0 ? {} : { next_cursor: idOf(last) } };
 }
 async function serveRcClientChannels(ctx, tail, method, maxBatchEvents) {
   const { request: request4, response, host } = ctx;
@@ -16597,6 +16696,8 @@ init_ownCli();
   RcRateLimitWindowSchema,
   RcStreamEnvelopeSchema,
   RcStreamEventSchema,
+  ResetRowSchema,
+  ResetScheduleSchema,
   USAGE_EVENT_SOURCE,
   UpdateCheckOutputSchema,
   UsageError,
@@ -16641,6 +16742,7 @@ init_ownCli();
   collectDoctorReport,
   collectFrontDoorStatus,
   collectPoolPick,
+  collectResets,
   createCodexApiRouter,
   createConfigApiRouter,
   createControlApiRouter,