claude-use 5.2.0 → 5.3.0

package/dist/cli.cjs

@@ -273458,7 +273458,7 @@ function resolveLaunchIdentity(paths, cwd) {
 // package.json
 var package_default = {
   name: "claude-use",
-  version: "5.2.0",
+  version: "5.3.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: "Apache-2.0",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -280549,6 +280549,44 @@ function spawnClaude(params) {
   return params.proc.exit(exitCodeFor(result));
 }
 
+// src/usage/preflight.ts
+var MS_PER_SECOND4 = 1e3;
+var SECONDS_PER_MINUTE = 60;
+var MINUTES_PER_HOUR = 60;
+var HOURS_PER_DAY = 24;
+var WARNING_STATUSES = /* @__PURE__ */ new Set(["allowed_warning", "rejected"]);
+function formatAge(ms) {
+  const minutes = Math.floor(ms / (MS_PER_SECOND4 * SECONDS_PER_MINUTE));
+  if (minutes < MINUTES_PER_HOUR) {
+    return `${String(Math.max(minutes, 0))}m`;
+  }
+  const hours = Math.floor(minutes / MINUTES_PER_HOUR);
+  return hours < HOURS_PER_DAY ? `${String(hours)}h` : `${String(Math.floor(hours / HOURS_PER_DAY))}d`;
+}
+function quotaWarnings(snapshot, provider, nowMs) {
+  const rateLimit = snapshot?.providers[provider]?.rateLimit;
+  const unified = rateLimit?.unified;
+  if (snapshot === void 0 || rateLimit === void 0 || unified === void 0) {
+    return [];
+  }
+  const age = formatAge(nowMs - Date.parse(rateLimit.observedAt));
+  const windows = [
+    { name: "five-hour", window: unified.fiveHour },
+    { name: "seven-day", window: unified.sevenDay }
+  ];
+  return windows.flatMap(({ name, window }) => {
+    if (window?.status === void 0 || !WARNING_STATUSES.has(window.status)) {
+      return [];
+    }
+    if (window.resetsAt !== void 0 && Date.parse(window.resetsAt) <= nowMs) {
+      return [];
+    }
+    const reset = window.resetsAt === void 0 ? "" : `, resets ${window.resetsAt}`;
+    const verdict = window.status === "rejected" ? "exhausted" : "nearly used";
+    return [`claude-use: identity ${snapshot.identity}: the ${name} quota is ${verdict}${reset} (last seen ${age} ago)`];
+  });
+}
+
 // src/launcher.ts
 function resolveIdentityCredential(identity, credential, env, port) {
   if (port === void 0) {
@@ -280645,6 +280683,19 @@ function runLauncher(params) {
   for (const warning of provider?.ok === true ? provider.warnings : []) {
     log.warn(warning);
   }
+  if (farm !== void 0 && farmIdentity !== void 0) {
+    try {
+      const snapshot = readUsageSnapshot(farm.fs, paths.usageSnapshotsDir, farmIdentity);
+      for (const warning of quotaWarnings(snapshot, resolvedProvider?.name ?? ANTHROPIC_PROVIDER, farm.now())) {
+        log.warn(warning);
+      }
+    } catch (error62) {
+      if (!(error62 instanceof UsageSnapshotError)) {
+        throw error62;
+      }
+      log.warn(`claude-use: ${error62.message}`);
+    }
+  }
   const identityCredentialBlock = loadedIdentity?.config.credential;
   const identityResolution = resolvedProvider === void 0 && farmIdentity !== void 0 && identityCredentialBlock !== void 0 ? resolveIdentityCredential(farmIdentity, identityCredentialBlock, env, params.credentials) : void 0;
   if (identityResolution !== void 0 && !identityResolution.ok) {

package/dist/index.cjs

@@ -37,6 +37,8 @@ __export(index_exports, {
   FrontDoorStartError: () => FrontDoorStartError,
   HeadroomStartError: () => HeadroomStartError,
   ROUTED_PATH_PREFIX: () => ROUTED_PATH_PREFIX,
+  UsageSnapshotError: () => UsageSnapshotError,
+  UsageSnapshotSchema: () => UsageSnapshotSchema,
   buildEntryFacts: () => buildEntryFacts,
   carryOver: () => carryOver,
   createLeafCache: () => createLeafCache,
@@ -49,9 +51,11 @@ __export(index_exports, {
   forwardableHeaders: () => forwardableHeaders,
   generateCa: () => generateCa,
   isInterceptedHost: () => isInterceptedHost,
+  listUsageSnapshots: () => listUsageSnapshots,
   mintLeaf: () => mintLeaf,
   parseConnectTarget: () => parseConnectTarget,
   readFarmManifest: () => readFarmManifest,
+  readUsageSnapshot: () => readUsageSnapshot,
   realConnectCertStore: () => realConnectCertStore,
   realConnectEffects: () => realConnectEffects,
   recoverFarm: () => recoverFarm,
@@ -62,6 +66,7 @@ __export(index_exports, {
   runFrontDoorSupervisor: () => runFrontDoorSupervisor,
   runSupervisor: () => runSupervisor,
   servedByPipeline: () => servedByPipeline,
+  snapshotPath: () => snapshotPath,
   startConnectServer: () => startConnectServer,
   topLevelNames: () => topLevelNames
 });
@@ -2346,8 +2351,8 @@ function parseConnectTarget(authority) {
 function isInterceptedHost(host, interceptHost) {
   return host === interceptHost;
 }
-function servedByPipeline(path7) {
-  return path7?.startsWith(ROUTED_PATH_PREFIX) === true;
+function servedByPipeline(path8) {
+  return path8?.startsWith(ROUTED_PATH_PREFIX) === true;
 }
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
@@ -2952,6 +2957,183 @@ function ensureFrontDoor(params) {
   }
 }
 
+// src/usage/read.ts
+var import_node_path7 = __toESM(require("node:path"), 1);
+
+// src/usage/schema.ts
+var import_zod5 = require("zod");
+var USAGE_SCHEMA_VERSION = 1;
+var VersionSchema = import_zod5.z.literal(USAGE_SCHEMA_VERSION);
+var InstantSchema = import_zod5.z.iso.datetime();
+var TokenCountSchema = import_zod5.z.number().int().nonnegative();
+var TokenUsageSchema = import_zod5.z.strictObject({
+  inputTokens: TokenCountSchema.optional(),
+  outputTokens: TokenCountSchema.optional(),
+  cacheCreationInputTokens: TokenCountSchema.optional(),
+  cacheReadInputTokens: TokenCountSchema.optional()
+});
+var LIMIT_KINDS = ["rate-limited", "quota-exhausted"];
+var LimitClassificationSchema = import_zod5.z.strictObject({
+  kind: import_zod5.z.enum(LIMIT_KINDS),
+  /** Seconds to wait before retrying, from the response's `retry-after`. */
+  retryAfterSeconds: import_zod5.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_zod5.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_zod5.z.array(import_zod5.z.string())
+});
+var UsageRecordSchema = import_zod5.z.strictObject({
+  schemaVersion: VersionSchema,
+  /** When the front door received the request. */
+  at: InstantSchema,
+  /** The launching identity, when the launch resolved one. */
+  identity: import_zod5.z.string().optional(),
+  /** `anthropic` for an OAuth session's request to Claude Code's own API, otherwise the provider's name. */
+  provider: import_zod5.z.string(),
+  /** The launch's session id, generated per launch. */
+  sessionId: import_zod5.z.string().optional(),
+  /** The project the launch ran in (its git repository root), when the launch sent one: headroom launches do. */
+  project: import_zod5.z.string().optional(),
+  /** The front-door route that served the request. */
+  route: import_zod5.z.string(),
+  method: import_zod5.z.string(),
+  /** The API path as the upstream sees it (`/v1/messages`), without the provider prefix or a query string. */
+  endpoint: import_zod5.z.string(),
+  /** The model the response named. */
+  model: import_zod5.z.string().optional(),
+  status: import_zod5.z.number().int(),
+  /** Milliseconds from the request's arrival to its response head. */
+  latencyMs: import_zod5.z.number().int().nonnegative(),
+  /** Milliseconds from the request's arrival to the end of its response body. */
+  durationMs: import_zod5.z.number().int().nonnegative(),
+  /** Whether the client received the whole body. */
+  outcome: import_zod5.z.enum(["completed", "aborted"]),
+  usage: TokenUsageSchema.optional(),
+  /** The response's quota and rate-limit headers, by name (see `isRateLimitHeader`). */
+  rateLimitHeaders: import_zod5.z.record(import_zod5.z.string(), import_zod5.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_zod5.z.string().optional()
+});
+var QuotaWindowSchema = import_zod5.z.strictObject({
+  /** The fraction of the window used, as the upstream reports it (0 to 1). */
+  utilization: import_zod5.z.number().nonnegative().optional(),
+  resetsAt: InstantSchema.optional(),
+  /** The window's own status (`allowed`, `allowed_warning`, `rejected`). */
+  status: import_zod5.z.string().optional()
+});
+var UnifiedRateLimitSchema = import_zod5.z.strictObject({
+  /** The overall status: `allowed`, `allowed_warning` or `rejected`. */
+  status: import_zod5.z.string().optional(),
+  fiveHour: QuotaWindowSchema.optional(),
+  sevenDay: QuotaWindowSchema.optional(),
+  /** The window that currently binds. */
+  representativeClaim: import_zod5.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_zod5.z.string().optional()
+});
+var RateLimitStateSchema = import_zod5.z.strictObject({
+  observedAt: InstantSchema,
+  /** Every quota and rate-limit header on that response, by name. */
+  headers: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.string()),
+  unified: UnifiedRateLimitSchema.optional()
+});
+var LimitEventSchema = LimitClassificationSchema.extend({
+  observedAt: InstantSchema,
+  status: import_zod5.z.number().int()
+});
+var ProviderUsageStateSchema = import_zod5.z.strictObject({
+  lastRequestAt: InstantSchema,
+  lastStatus: import_zod5.z.number().int(),
+  lastModel: import_zod5.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. */
+  lastLimit: LimitEventSchema.optional()
+});
+var AccountMetadataSchema = import_zod5.z.strictObject({
+  accountUuid: import_zod5.z.string().optional(),
+  emailAddress: import_zod5.z.string().optional(),
+  displayName: import_zod5.z.string().optional(),
+  organizationUuid: import_zod5.z.string().optional(),
+  organizationName: import_zod5.z.string().optional(),
+  organizationType: import_zod5.z.string().optional(),
+  organizationRole: import_zod5.z.string().optional(),
+  workspaceRole: import_zod5.z.string().optional(),
+  billingType: import_zod5.z.string().optional(),
+  seatTier: import_zod5.z.string().optional(),
+  organizationRateLimitTier: import_zod5.z.string().optional(),
+  userRateLimitTier: import_zod5.z.string().optional(),
+  hasExtraUsageEnabled: import_zod5.z.boolean().optional(),
+  subscriptionCreatedAt: import_zod5.z.string().optional(),
+  accountCreatedAt: import_zod5.z.string().optional()
+});
+var UsageSnapshotSchema = import_zod5.z.strictObject({
+  schemaVersion: VersionSchema,
+  identity: import_zod5.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_zod5.z.record(import_zod5.z.string(), ProviderUsageStateSchema)
+});
+
+// src/usage/account.ts
+function isIdentityName(name) {
+  return IdentitySchema.shape.name.safeParse(name).success;
+}
+
+// src/usage/read.ts
+var UsageSnapshotError = class extends Error {
+  constructor(file, detail) {
+    super(`${file} is not a usage snapshot this claude-use can read (schema version ${String(USAGE_SCHEMA_VERSION)}): ${detail}`);
+    this.file = file;
+    this.name = "UsageSnapshotError";
+  }
+  file;
+};
+function snapshotPath(snapshotsDir, identity) {
+  if (!isIdentityName(identity)) {
+    throw new Error(`"${identity}" is not a valid identity name.`);
+  }
+  return import_node_path7.default.join(snapshotsDir, `${identity}.json`);
+}
+function readUsageSnapshot(fs2, snapshotsDir, identity) {
+  const file = snapshotPath(snapshotsDir, identity);
+  const raw = fs2.readFileUtf8(file);
+  if (raw === void 0) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new UsageSnapshotError(file, "not valid JSON");
+  }
+  const snapshot = UsageSnapshotSchema.safeParse(parsed);
+  if (!snapshot.success) {
+    throw new UsageSnapshotError(file, snapshot.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; "));
+  }
+  return snapshot.data;
+}
+function listUsageSnapshots(fs2, snapshotsDir) {
+  return fs2.readdir(snapshotsDir).flatMap((name) => {
+    if (!name.endsWith(".json")) {
+      return [];
+    }
+    const identity = name.slice(0, -".json".length);
+    if (!isIdentityName(identity)) {
+      return [];
+    }
+    const snapshot = readUsageSnapshot(fs2, snapshotsDir, identity);
+    return snapshot === void 0 ? [] : [snapshot];
+  }).sort((left, right) => left.identity.localeCompare(right.identity));
+}
+
 // src/headroom/ensure.ts
 var HEADROOM_START_TIMEOUT_MS = 12e4;
 var HEADROOM_LAUNCHER_POLL_MS = 250;
@@ -3326,6 +3508,8 @@ function evaluateAmbientCredentialGuard(params) {
   FrontDoorStartError,
   HeadroomStartError,
   ROUTED_PATH_PREFIX,
+  UsageSnapshotError,
+  UsageSnapshotSchema,
   buildEntryFacts,
   carryOver,
   createLeafCache,
@@ -3338,9 +3522,11 @@ function evaluateAmbientCredentialGuard(params) {
   forwardableHeaders,
   generateCa,
   isInterceptedHost,
+  listUsageSnapshots,
   mintLeaf,
   parseConnectTarget,
   readFarmManifest,
+  readUsageSnapshot,
   realConnectCertStore,
   realConnectEffects,
   recoverFarm,
@@ -3351,6 +3537,7 @@ function evaluateAmbientCredentialGuard(params) {
   runFrontDoorSupervisor,
   runSupervisor,
   servedByPipeline,
+  snapshotPath,
   startConnectServer,
   topLevelNames
 });

package/dist/index.mjs

@@ -2277,8 +2277,8 @@ function parseConnectTarget(authority) {
 function isInterceptedHost(host, interceptHost) {
   return host === interceptHost;
 }
-function servedByPipeline(path7) {
-  return path7?.startsWith(ROUTED_PATH_PREFIX) === true;
+function servedByPipeline(path8) {
+  return path8?.startsWith(ROUTED_PATH_PREFIX) === true;
 }
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
@@ -2883,6 +2883,183 @@ function ensureFrontDoor(params) {
   }
 }
 
+// src/usage/read.ts
+import path7 from "node:path";
+
+// src/usage/schema.ts
+import { z as z5 } from "zod";
+var USAGE_SCHEMA_VERSION = 1;
+var VersionSchema = z5.literal(USAGE_SCHEMA_VERSION);
+var InstantSchema = z5.iso.datetime();
+var TokenCountSchema = z5.number().int().nonnegative();
+var TokenUsageSchema = z5.strictObject({
+  inputTokens: TokenCountSchema.optional(),
+  outputTokens: TokenCountSchema.optional(),
+  cacheCreationInputTokens: TokenCountSchema.optional(),
+  cacheReadInputTokens: TokenCountSchema.optional()
+});
+var LIMIT_KINDS = ["rate-limited", "quota-exhausted"];
+var LimitClassificationSchema = z5.strictObject({
+  kind: z5.enum(LIMIT_KINDS),
+  /** Seconds to wait before retrying, from the response's `retry-after`. */
+  retryAfterSeconds: z5.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: z5.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: z5.array(z5.string())
+});
+var UsageRecordSchema = z5.strictObject({
+  schemaVersion: VersionSchema,
+  /** When the front door received the request. */
+  at: InstantSchema,
+  /** The launching identity, when the launch resolved one. */
+  identity: z5.string().optional(),
+  /** `anthropic` for an OAuth session's request to Claude Code's own API, otherwise the provider's name. */
+  provider: z5.string(),
+  /** The launch's session id, generated per launch. */
+  sessionId: z5.string().optional(),
+  /** The project the launch ran in (its git repository root), when the launch sent one: headroom launches do. */
+  project: z5.string().optional(),
+  /** The front-door route that served the request. */
+  route: z5.string(),
+  method: z5.string(),
+  /** The API path as the upstream sees it (`/v1/messages`), without the provider prefix or a query string. */
+  endpoint: z5.string(),
+  /** The model the response named. */
+  model: z5.string().optional(),
+  status: z5.number().int(),
+  /** Milliseconds from the request's arrival to its response head. */
+  latencyMs: z5.number().int().nonnegative(),
+  /** Milliseconds from the request's arrival to the end of its response body. */
+  durationMs: z5.number().int().nonnegative(),
+  /** Whether the client received the whole body. */
+  outcome: z5.enum(["completed", "aborted"]),
+  usage: TokenUsageSchema.optional(),
+  /** The response's quota and rate-limit headers, by name (see `isRateLimitHeader`). */
+  rateLimitHeaders: z5.record(z5.string(), z5.string()).optional(),
+  limit: LimitClassificationSchema.optional(),
+  /** The upstream's request id (`request-id`), for matching a record to the provider's own logs. */
+  requestId: z5.string().optional()
+});
+var QuotaWindowSchema = z5.strictObject({
+  /** The fraction of the window used, as the upstream reports it (0 to 1). */
+  utilization: z5.number().nonnegative().optional(),
+  resetsAt: InstantSchema.optional(),
+  /** The window's own status (`allowed`, `allowed_warning`, `rejected`). */
+  status: z5.string().optional()
+});
+var UnifiedRateLimitSchema = z5.strictObject({
+  /** The overall status: `allowed`, `allowed_warning` or `rejected`. */
+  status: z5.string().optional(),
+  fiveHour: QuotaWindowSchema.optional(),
+  sevenDay: QuotaWindowSchema.optional(),
+  /** The window that currently binds. */
+  representativeClaim: z5.string().optional(),
+  /** When the binding window resets. */
+  resetAt: InstantSchema.optional(),
+  /** Whether usage beyond the plan (extra usage) is available: `allowed` or `rejected`. */
+  overageStatus: z5.string().optional()
+});
+var RateLimitStateSchema = z5.strictObject({
+  observedAt: InstantSchema,
+  /** Every quota and rate-limit header on that response, by name. */
+  headers: z5.record(z5.string(), z5.string()),
+  unified: UnifiedRateLimitSchema.optional()
+});
+var LimitEventSchema = LimitClassificationSchema.extend({
+  observedAt: InstantSchema,
+  status: z5.number().int()
+});
+var ProviderUsageStateSchema = z5.strictObject({
+  lastRequestAt: InstantSchema,
+  lastStatus: z5.number().int(),
+  lastModel: z5.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. */
+  lastLimit: LimitEventSchema.optional()
+});
+var AccountMetadataSchema = z5.strictObject({
+  accountUuid: z5.string().optional(),
+  emailAddress: z5.string().optional(),
+  displayName: z5.string().optional(),
+  organizationUuid: z5.string().optional(),
+  organizationName: z5.string().optional(),
+  organizationType: z5.string().optional(),
+  organizationRole: z5.string().optional(),
+  workspaceRole: z5.string().optional(),
+  billingType: z5.string().optional(),
+  seatTier: z5.string().optional(),
+  organizationRateLimitTier: z5.string().optional(),
+  userRateLimitTier: z5.string().optional(),
+  hasExtraUsageEnabled: z5.boolean().optional(),
+  subscriptionCreatedAt: z5.string().optional(),
+  accountCreatedAt: z5.string().optional()
+});
+var UsageSnapshotSchema = z5.strictObject({
+  schemaVersion: VersionSchema,
+  identity: z5.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: z5.record(z5.string(), ProviderUsageStateSchema)
+});
+
+// src/usage/account.ts
+function isIdentityName(name) {
+  return IdentitySchema.shape.name.safeParse(name).success;
+}
+
+// src/usage/read.ts
+var UsageSnapshotError = class extends Error {
+  constructor(file, detail) {
+    super(`${file} is not a usage snapshot this claude-use can read (schema version ${String(USAGE_SCHEMA_VERSION)}): ${detail}`);
+    this.file = file;
+    this.name = "UsageSnapshotError";
+  }
+  file;
+};
+function snapshotPath(snapshotsDir, identity) {
+  if (!isIdentityName(identity)) {
+    throw new Error(`"${identity}" is not a valid identity name.`);
+  }
+  return path7.join(snapshotsDir, `${identity}.json`);
+}
+function readUsageSnapshot(fs2, snapshotsDir, identity) {
+  const file = snapshotPath(snapshotsDir, identity);
+  const raw = fs2.readFileUtf8(file);
+  if (raw === void 0) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new UsageSnapshotError(file, "not valid JSON");
+  }
+  const snapshot = UsageSnapshotSchema.safeParse(parsed);
+  if (!snapshot.success) {
+    throw new UsageSnapshotError(file, snapshot.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; "));
+  }
+  return snapshot.data;
+}
+function listUsageSnapshots(fs2, snapshotsDir) {
+  return fs2.readdir(snapshotsDir).flatMap((name) => {
+    if (!name.endsWith(".json")) {
+      return [];
+    }
+    const identity = name.slice(0, -".json".length);
+    if (!isIdentityName(identity)) {
+      return [];
+    }
+    const snapshot = readUsageSnapshot(fs2, snapshotsDir, identity);
+    return snapshot === void 0 ? [] : [snapshot];
+  }).sort((left, right) => left.identity.localeCompare(right.identity));
+}
+
 // src/headroom/ensure.ts
 var HEADROOM_START_TIMEOUT_MS = 12e4;
 var HEADROOM_LAUNCHER_POLL_MS = 250;
@@ -3256,6 +3433,8 @@ export {
   FrontDoorStartError,
   HeadroomStartError,
   ROUTED_PATH_PREFIX,
+  UsageSnapshotError,
+  UsageSnapshotSchema,
   buildEntryFacts,
   carryOver,
   createLeafCache,
@@ -3268,9 +3447,11 @@ export {
   forwardableHeaders,
   generateCa,
   isInterceptedHost,
+  listUsageSnapshots,
   mintLeaf,
   parseConnectTarget,
   readFarmManifest,
+  readUsageSnapshot,
   realConnectCertStore,
   realConnectEffects,
   recoverFarm,
@@ -3281,6 +3462,7 @@ export {
   runFrontDoorSupervisor,
   runSupervisor,
   servedByPipeline,
+  snapshotPath,
   startConnectServer,
   topLevelNames
 };

package/dist/types/index.d.ts

@@ -1,9 +1,10 @@
 /**
- * The library surface of claude-use: the pure, port-injected parts other tools can call in-process instead of shelling out to the CLI. Three groups, none of which imports interactive prompting or argument parsing:
+ * The library surface of claude-use: the pure, port-injected parts other tools can call in-process instead of shelling out to the CLI. Four groups, none of which imports interactive prompting or argument parsing:
  *
  * - identity and configuration-profile resolution and farm sync (`resolveDecisions`, `resyncFarm`, `buildEntryFacts`, ...), pure over facts and ports passed in;
  * - routing: the front door's Remote-Control-preserving, capability-authenticated CONNECT surface and its certificate authority, the front-door supervisor and ensure lifecycle, and the headroom supervisor and ensure lifecycle, each pure over its injected ports;
- * - the ambient-credential guard.
+ * - the ambient-credential guard;
+ * - the per-identity usage snapshot a statusline or launcher reads: its schema and the reader over an injected filesystem.
  *
  * Everything the CLI alone needs (commander wiring, prompts, `doctor`, `check`) is deliberately not exported here.
  */
@@ -13,6 +14,8 @@ export { buildEntryFacts, carryOver, FARM_MANIFEST_FILENAME, readFarmManifest, r
 export { CONNECT_INTERCEPT_HOST, CONNECT_LIMITS, createLeafCache, ensureCa, forwardableHeaders, generateCa, isInterceptedHost, mintLeaf, parseConnectTarget, realConnectCertStore, realConnectEffects, ROUTED_PATH_PREFIX, servedByPipeline, startConnectServer, type CaMaterial, type ConnectCertStore, type ConnectEffects, type ConnectLimits, type ConnectServerConfig, type ConnectServerHandle, type ConnectTarget, type LeafCert, } from "./frontdoor/connect";
 export { ensureFrontDoor, FrontDoorStartError, type EnsureFrontDoorPorts } from "./frontdoor/ensure";
 export { runFrontDoorSupervisor, type FrontDoorSupervisorPorts, type RunFrontDoorSupervisorOptions } from "./frontdoor/supervisor";
+export { listUsageSnapshots, readUsageSnapshot, snapshotPath, UsageSnapshotError, type UsageReadFs } from "./usage/read";
+export { UsageSnapshotSchema, type UsageSnapshot } from "./usage/schema";
 export { ensureHeadroom, HeadroomStartError, type EnsureHeadroomPorts } from "./headroom/ensure";
 export { resolveSupervisorConfig, runSupervisor, type HeadroomSupervisorConfig, type RunSupervisorOptions, type SupervisorPorts } from "./headroom/supervisor";
 export { AMBIENT_CREDENTIAL_VARS, detectAmbientCredential, evaluateAmbientCredentialGuard, formatAmbientCredentialGuardMessage, type AmbientCredentialDetection, type AmbientCredentialGuardResult, type AmbientCredentialVar, type EvaluateAmbientCredentialGuardParams, type InjectedCredential, } from "./launcher/guard";

package/dist/types/usage/account.d.ts

@@ -0,0 +1,20 @@
+import { CliError } from "../cliError";
+import type { FarmFs } from "../launcher/ports";
+import { type AccountMetadata } from "./schema";
+/** Raised when an identity's `.claude.json` exists but cannot be read as account metadata (not a JSON object, or an `oauthAccount` field of an unexpected type): reported, never read as "no account". */
+export declare class AccountMetadataError extends CliError {
+    readonly file: string;
+    constructor(file: string, detail: string);
+}
+/** Whether `name` is a valid identity name, which is also what makes it safe as one path component under the identities and snapshots directories (no separator, no leading dot). */
+export declare function isIdentityName(name: string): boolean;
+/** The path of an identity's `.claude.json`. */
+export declare function claudeJsonPath(identitiesDir: string, identity: string): string;
+/**
+ * Reads an identity's account metadata from the `oauthAccount` block Claude Code writes into the identity's `.claude.json` when it logs in: the fields `AccountMetadataSchema` names and nothing else (the token is never in this file; Claude Code keeps it in the Keychain or `.credentials.json`). Undefined when the identity has no `.claude.json` or no `oauthAccount` (a setup-token identity, or one never logged in). Throws `AccountMetadataError` for a file that is not a JSON object, and on an invalid identity name, which could otherwise name a path outside the identities directory.
+ */
+export declare function readAccountMetadata(fs: Pick<FarmFs, "readFileUtf8">, identitiesDir: string, identity: string): AccountMetadata | undefined;
+/**
+ * An account reader for the long-running door: re-reads an identity's `.claude.json` only when its modification time or size has changed, since the door records every request and the file (which also holds Claude Code's per-project history) can be large while its account block rarely changes.
+ */
+export declare function createAccountReader(fs: Pick<FarmFs, "readFileUtf8" | "lstat">, identitiesDir: string): (identity: string) => AccountMetadata | undefined;

package/dist/types/usage/read.d.ts

@@ -0,0 +1,70 @@
+import type { FarmFs } from "../launcher/ports";
+import { type LimitKind, type UsageRecord, type UsageSnapshot } from "./schema";
+/**
+ * The read side of the usage store: pure over an injected filesystem, so the CLI, the library surface and tests all read the same way, and nothing here writes.
+ */
+/** The filesystem reads the usage store's readers need. */
+export type UsageReadFs = Pick<FarmFs, "readFileUtf8" | "readdir">;
+/** The UTC day an instant falls on, as a segment names it. */
+export declare function segmentDay(epochMs: number): string;
+/** A segment's file name for one writer on one day. */
+export declare function segmentName(day: string, pid: number): string;
+/** One log segment found on disk. */
+export interface LogSegment {
+    readonly name: string;
+    readonly day: string;
+    /** The epoch milliseconds the segment's day ends at: no record in it is later. */
+    readonly endsAt: number;
+}
+/** Lists the log's segments, oldest day first; files that are not segments (a stray temporary file) are not the log's and are ignored. */
+export declare function listLogSegments(fs: Pick<FarmFs, "readdir">, logDir: string): readonly LogSegment[];
+/** What a log read found. */
+export interface UsageLogRead {
+    /** Every valid record at or after the cut-off, oldest first. */
+    readonly records: readonly UsageRecord[];
+    /** Complete lines that did not parse as a record of this schema version: a corrupted line, or one a newer claude-use wrote. Reported, never silently dropped. */
+    readonly invalidLines: number;
+}
+/**
+ * Reads the usage log, optionally only from `sinceMs` on. Each segment has a single writer that appends whole lines, so the only incomplete line a reader can meet is the last one of a segment still being written, which has no trailing newline yet; it is left for the next read rather than counted as invalid.
+ */
+export declare function readUsageLog(fs: UsageReadFs, logDir: string, options?: {
+    readonly sinceMs?: number;
+}): UsageLogRead;
+/** Raised for a snapshot file that exists but does not hold a snapshot of this schema version. */
+export declare class UsageSnapshotError extends Error {
+    readonly file: string;
+    constructor(file: string, detail: string);
+}
+/** The path of an identity's snapshot. Throws for an invalid identity name, which could otherwise name a path outside the snapshots directory. */
+export declare function snapshotPath(snapshotsDir: string, identity: string): string;
+/** Reads one identity's snapshot: undefined when it has none yet, `UsageSnapshotError` when the file is there but unreadable. */
+export declare function readUsageSnapshot(fs: Pick<FarmFs, "readFileUtf8">, snapshotsDir: string, identity: string): UsageSnapshot | undefined;
+/** Reads every identity's snapshot, by identity name. */
+export declare function listUsageSnapshots(fs: UsageReadFs, snapshotsDir: string): readonly UsageSnapshot[];
+/** Token totals across a set of records. */
+interface TokenTotals {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheCreationInputTokens: number;
+    readonly cacheReadInputTokens: number;
+}
+/** The totals for one identity and provider over a set of records. */
+export interface UsageSummary {
+    /** The identity, or undefined for requests from a launch that resolved none. */
+    readonly identity: string | undefined;
+    readonly provider: string;
+    readonly requests: number;
+    /** Responses with a status of 400 or above (refusals included). */
+    readonly failed: number;
+    /** Classified refusals, by kind. */
+    readonly limits: Readonly<Record<LimitKind, number>>;
+    readonly tokens: TokenTotals;
+    readonly firstAt: string;
+    readonly lastAt: string;
+    /** The models the responses named, most-used first. */
+    readonly models: readonly string[];
+}
+/** Groups records by identity and provider and totals each group, ordered by identity then provider. */
+export declare function summariseUsage(records: readonly UsageRecord[]): readonly UsageSummary[];
+export {};

package/dist/types/usage/schema.d.ts

@@ -0,0 +1,259 @@
+import { z } from "zod";
+/**
+ * The usage store's one schema definition: every record the front door appends to the usage log, the per-identity snapshot other tools read, and the account metadata both carry. Each is a strict object, so a field not named here can never be written (the store validates every record and snapshot before it touches disk) and the published JSON Schemas (`schema/UsageRecord.schema.json`, `schema/UsageSnapshot.schema.json`) describe exactly what a reader can find.
+ *
+ * Metadata only, by construction: nothing here can hold a prompt, a response, tool content, or a credential. Rate-limit headers are kept by name from an allow-list of quota headers (`isRateLimitHeader`), never wholesale.
+ */
+/** The version of the record and snapshot shapes below. A reader checks it before trusting a document; a change that is not purely additive bumps it. */
+export declare const USAGE_SCHEMA_VERSION = 1;
+/** Token counts from a response body's `usage` object, renamed to this project's casing. Each field is present only when the response reported it. */
+export declare const TokenUsageSchema: z.ZodObject<{
+    inputTokens: z.ZodOptional<z.ZodNumber>;
+    outputTokens: z.ZodOptional<z.ZodNumber>;
+    cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+    cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type TokenUsage = z.infer<typeof TokenUsageSchema>;
+/** The two kinds of refusal a consumer acts on differently: a short rate limit is worth retrying on the same credential once its wait has passed, an exhausted quota means moving to the next credential until the reset. */
+declare const LIMIT_KINDS: readonly ["rate-limited", "quota-exhausted"];
+export type LimitKind = (typeof LIMIT_KINDS)[number];
+/** A 429 (or 402) classified, with the wait or reset the upstream announced and the signals the classification rests on. */
+export declare const LimitClassificationSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "rate-limited": "rate-limited";
+        "quota-exhausted": "quota-exhausted";
+    }>;
+    retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
+    resetAt: z.ZodOptional<z.ZodISODateTime>;
+    window: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type LimitClassification = z.infer<typeof LimitClassificationSchema>;
+/** One routed request, appended to the usage log when its response has finished. */
+export declare const UsageRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    at: z.ZodISODateTime;
+    identity: z.ZodOptional<z.ZodString>;
+    provider: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
+    route: z.ZodString;
+    method: z.ZodString;
+    endpoint: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    status: z.ZodNumber;
+    latencyMs: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    outcome: z.ZodEnum<{
+        completed: "completed";
+        aborted: "aborted";
+    }>;
+    usage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+        cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    rateLimitHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    limit: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "rate-limited": "rate-limited";
+            "quota-exhausted": "quota-exhausted";
+        }>;
+        retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
+        resetAt: z.ZodOptional<z.ZodISODateTime>;
+        window: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    requestId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type UsageRecord = z.infer<typeof UsageRecordSchema>;
+/** One quota window from Anthropic's unified rate-limit headers. */
+declare const QuotaWindowSchema: z.ZodObject<{
+    utilization: z.ZodOptional<z.ZodNumber>;
+    resetsAt: z.ZodOptional<z.ZodISODateTime>;
+    status: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type QuotaWindow = z.infer<typeof QuotaWindowSchema>;
+/** Anthropic's unified subscription rate-limit state, parsed from the `anthropic-ratelimit-unified-*` headers (which the in-process Codex route also derives from the Codex backend's own quota headers). */
+export declare const UnifiedRateLimitSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    fiveHour: z.ZodOptional<z.ZodObject<{
+        utilization: z.ZodOptional<z.ZodNumber>;
+        resetsAt: z.ZodOptional<z.ZodISODateTime>;
+        status: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    sevenDay: z.ZodOptional<z.ZodObject<{
+        utilization: z.ZodOptional<z.ZodNumber>;
+        resetsAt: z.ZodOptional<z.ZodISODateTime>;
+        status: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    representativeClaim: z.ZodOptional<z.ZodString>;
+    resetAt: z.ZodOptional<z.ZodISODateTime>;
+    overageStatus: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type UnifiedRateLimit = z.infer<typeof UnifiedRateLimitSchema>;
+/** The latest rate-limit state an upstream reported on any response. */
+declare const RateLimitStateSchema: z.ZodObject<{
+    observedAt: z.ZodISODateTime;
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    unified: z.ZodOptional<z.ZodObject<{
+        status: z.ZodOptional<z.ZodString>;
+        fiveHour: z.ZodOptional<z.ZodObject<{
+            utilization: z.ZodOptional<z.ZodNumber>;
+            resetsAt: z.ZodOptional<z.ZodISODateTime>;
+            status: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        sevenDay: z.ZodOptional<z.ZodObject<{
+            utilization: z.ZodOptional<z.ZodNumber>;
+            resetsAt: z.ZodOptional<z.ZodISODateTime>;
+            status: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        representativeClaim: z.ZodOptional<z.ZodString>;
+        resetAt: z.ZodOptional<z.ZodISODateTime>;
+        overageStatus: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RateLimitState = z.infer<typeof RateLimitStateSchema>;
+/** A classified refusal, with when it was seen and its status. */
+declare const LimitEventSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "rate-limited": "rate-limited";
+        "quota-exhausted": "quota-exhausted";
+    }>;
+    retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
+    resetAt: z.ZodOptional<z.ZodISODateTime>;
+    window: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodArray<z.ZodString>;
+    observedAt: z.ZodISODateTime;
+    status: z.ZodNumber;
+}, z.core.$strict>;
+export type LimitEvent = z.infer<typeof LimitEventSchema>;
+/** One provider's latest state under one identity. */
+declare const ProviderUsageStateSchema: z.ZodObject<{
+    lastRequestAt: z.ZodISODateTime;
+    lastStatus: z.ZodNumber;
+    lastModel: z.ZodOptional<z.ZodString>;
+    rateLimit: z.ZodOptional<z.ZodObject<{
+        observedAt: z.ZodISODateTime;
+        headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        unified: z.ZodOptional<z.ZodObject<{
+            status: z.ZodOptional<z.ZodString>;
+            fiveHour: z.ZodOptional<z.ZodObject<{
+                utilization: z.ZodOptional<z.ZodNumber>;
+                resetsAt: z.ZodOptional<z.ZodISODateTime>;
+                status: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            sevenDay: z.ZodOptional<z.ZodObject<{
+                utilization: z.ZodOptional<z.ZodNumber>;
+                resetsAt: z.ZodOptional<z.ZodISODateTime>;
+                status: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            representativeClaim: z.ZodOptional<z.ZodString>;
+            resetAt: z.ZodOptional<z.ZodISODateTime>;
+            overageStatus: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    lastLimit: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "rate-limited": "rate-limited";
+            "quota-exhausted": "quota-exhausted";
+        }>;
+        retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
+        resetAt: z.ZodOptional<z.ZodISODateTime>;
+        window: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodArray<z.ZodString>;
+        observedAt: z.ZodISODateTime;
+        status: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ProviderUsageState = z.infer<typeof ProviderUsageStateSchema>;
+/**
+ * The account fields copied from an identity's stored Claude login (`oauthAccount` in the identity's `.claude.json`): who the account is and which plan and tier it is on. Never the token, which Claude Code keeps elsewhere. Each field is present only when the stored login has it; a setup-token identity has no profile scope and so none of them (see issue #44).
+ */
+export declare const AccountMetadataSchema: z.ZodObject<{
+    accountUuid: z.ZodOptional<z.ZodString>;
+    emailAddress: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
+    organizationUuid: z.ZodOptional<z.ZodString>;
+    organizationName: z.ZodOptional<z.ZodString>;
+    organizationType: z.ZodOptional<z.ZodString>;
+    organizationRole: z.ZodOptional<z.ZodString>;
+    workspaceRole: z.ZodOptional<z.ZodString>;
+    billingType: z.ZodOptional<z.ZodString>;
+    seatTier: z.ZodOptional<z.ZodString>;
+    organizationRateLimitTier: z.ZodOptional<z.ZodString>;
+    userRateLimitTier: z.ZodOptional<z.ZodString>;
+    hasExtraUsageEnabled: z.ZodOptional<z.ZodBoolean>;
+    subscriptionCreatedAt: z.ZodOptional<z.ZodString>;
+    accountCreatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type AccountMetadata = z.infer<typeof AccountMetadataSchema>;
+/**
+ * The latest state for one identity, rewritten atomically after each recorded response: the snapshot file other tools read (`~/.claude-use/usage/snapshots/<identity>.json`) without shelling out to `claude-use`.
+ */
+export declare const UsageSnapshotSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    identity: z.ZodString;
+    updatedAt: z.ZodISODateTime;
+    account: z.ZodOptional<z.ZodObject<{
+        accountUuid: z.ZodOptional<z.ZodString>;
+        emailAddress: z.ZodOptional<z.ZodString>;
+        displayName: z.ZodOptional<z.ZodString>;
+        organizationUuid: z.ZodOptional<z.ZodString>;
+        organizationName: z.ZodOptional<z.ZodString>;
+        organizationType: z.ZodOptional<z.ZodString>;
+        organizationRole: z.ZodOptional<z.ZodString>;
+        workspaceRole: z.ZodOptional<z.ZodString>;
+        billingType: z.ZodOptional<z.ZodString>;
+        seatTier: z.ZodOptional<z.ZodString>;
+        organizationRateLimitTier: z.ZodOptional<z.ZodString>;
+        userRateLimitTier: z.ZodOptional<z.ZodString>;
+        hasExtraUsageEnabled: z.ZodOptional<z.ZodBoolean>;
+        subscriptionCreatedAt: z.ZodOptional<z.ZodString>;
+        accountCreatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        lastRequestAt: z.ZodISODateTime;
+        lastStatus: z.ZodNumber;
+        lastModel: z.ZodOptional<z.ZodString>;
+        rateLimit: z.ZodOptional<z.ZodObject<{
+            observedAt: z.ZodISODateTime;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+            unified: z.ZodOptional<z.ZodObject<{
+                status: z.ZodOptional<z.ZodString>;
+                fiveHour: z.ZodOptional<z.ZodObject<{
+                    utilization: z.ZodOptional<z.ZodNumber>;
+                    resetsAt: z.ZodOptional<z.ZodISODateTime>;
+                    status: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                sevenDay: z.ZodOptional<z.ZodObject<{
+                    utilization: z.ZodOptional<z.ZodNumber>;
+                    resetsAt: z.ZodOptional<z.ZodISODateTime>;
+                    status: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                representativeClaim: z.ZodOptional<z.ZodString>;
+                resetAt: z.ZodOptional<z.ZodISODateTime>;
+                overageStatus: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        lastLimit: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                "rate-limited": "rate-limited";
+                "quota-exhausted": "quota-exhausted";
+            }>;
+            retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
+            resetAt: z.ZodOptional<z.ZodISODateTime>;
+            window: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodArray<z.ZodString>;
+            observedAt: z.ZodISODateTime;
+            status: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type UsageSnapshot = z.infer<typeof UsageSnapshotSchema>;
+/**
+ * Whether a response header is one the store keeps: the quota and rate-limit families the upstreams claude-use routes to send (Anthropic's `anthropic-ratelimit-*`, the IETF draft's `ratelimit*`, the common `x-ratelimit-*`, the Codex backend's `x-codex-*` quota headers, which the Codex route forwards) and `retry-after`. Every one of these carries a number, a time or a status word; none carries a credential or content.
+ */
+export declare function isRateLimitHeader(name: string): boolean;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-use",
-  "version": "5.2.0",
+  "version": "5.3.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": "Apache-2.0",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",