@jameslovespancakes/pi-plus 1.0.11 → 1.0.13

package/README.md

@@ -5,7 +5,7 @@
 **Everything [pi](https://pi.dev/) is missing, in one install.**
 
 [![npm](https://img.shields.io/npm/v/@jameslovespancakes/pi-plus?color=%234D9ABF&label=npm)](https://www.npmjs.com/package/@jameslovespancakes/pi-plus)
-[![build](https://github.com/jameslovespancakes/pi-plus/actions/workflows/release.yml/badge.svg?branch=main)](https://github.com/jameslovespancakes/pi-plus/actions/workflows/release.yml)
+[![CI](https://github.com/jameslovespancakes/pi-plus/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/jameslovespancakes/pi-plus/actions/workflows/ci.yml)
 [![license](https://img.shields.io/badge/license-MIT-F1BE58)](LICENSE)
 [![pi-package](https://img.shields.io/badge/pi--package-F09082)](https://pi.dev/packages)
 
@@ -29,7 +29,7 @@ on any row starts that setup.
 ```
 ──────────────────────────────────────────────────────────
  pi-plus
-› ● Subscriptions   2 accounts · optimal
+› ● Subscriptions   2 accounts · quota-aware
   ● Model Information  catalogue cached
   ● Providers       2 allowed · 4 need approval
   ● Agent Board     not configured
@@ -48,19 +48,20 @@ Nothing else is required, every feature configures itself from within pi.
 
 ### Pool every subscription
 
-Add all the Claude accounts you own. pi-plus balances sessions across them by
-**remaining quota and time-to-reset**, keeps caches sticky, and migrates only on
-confirmed exhaustion.
+Add multiple Claude, ChatGPT/Codex, Kimi Code, or xAI/Grok accounts. pi-plus
+keeps credentials separate, refreshes them safely, and supports sequential or
+quota-aware routing.
 
 ```
-/account anthropic add work
-/routing optimal
+/accounts add anthropic work
+/accounts add kimi-coding personal
+/routing quota-aware
 ```
 
 Your live quota, always in the footer:
 
 ```
-  Claude Σ2 · 2/2 ready · partial                 Codex · pro
+  Claude Σ2 · 2/2 ready                           Codex · pro
   5h     █████████████████░░░░░░░░░   65% 1h     5h     ███████████████████████░░░   88% 57m
   weekly ███████████████░░░░░░░░░░░   58% 3d     weekly ████████████████████████░░   93% 6d
   Fable  ████████████░░░░░░░░░░░░░░  ~47% 3d
@@ -70,9 +71,9 @@ Your live quota, always in the footer:
 With more than two accounts only the two most recently used are listed, so the
 footer stays a fixed height however many you pool.
 
-Account and routing commands are provider-agnostic: they dispatch through an
-adapter registry, so a second provider is one adapter, not a new command
-surface. Anthropic ships today.
+Account and routing commands are provider-agnostic. Sequential routing uses
+account order; quota-aware routing uses reported capacity and fairly probes
+accounts whose provider does not publish quota headers.
 
 ### Pick models on evidence
 
@@ -153,6 +154,42 @@ across every running pi agent. `/board` opens the messaging view:
 any Mac or Linux host over SSH, where launchd or systemd brings it back after a
 reboot.
 
+### Compact without deleting the source
+
+Better Compact replaces Pi's normal compaction with a reversible local archive,
+deterministic protection and extractive compression. Jev mode adds six-signal
+routing through OpenRouter's decisions API; Jev ranks compression but cannot
+override protected facts or authorize source deletion.
+
+```
+/compact better on    # switch to local deterministic routing and compact now
+/compact better jev   # switch to Jev routing and compact now
+/compact better off   # restore Pi compaction and compact now
+```
+
+The selected mode persists for later manual and automatic compactions. Jev mode
+requires `OPENROUTER_API_KEY` (or OpenRouter auth configured in Pi). Original
+chunks stay under `~/.pi/agent/super-context/archives/`; the
+`super_context_recall` tool performs bounded retrieval from the current branch's
+checkpoint.
+
+### Orchestrate repeatable workflows
+
+The built-in workflow engine runs named or inline multi-agent workflows with
+optional concurrency limits, replay, background runs, worktree isolation, progress,
+and usage accounting. `code-review`, `diagnose`, `perf-review`,
+`refactor-scout`, and `research` ship in this package—no external workflow
+package is installed.
+
+```
+/workflow code-review HEAD~3
+/workflow research "Compare the current provider implementations"
+```
+
+The `workflow` tool exposes the same engine to the model. Runs have no agent,
+timeout, submission, or token-budget limit by default; set limits explicitly
+with workflow options when a task needs them.
+
 ---
 
 ## Commands
@@ -161,10 +198,10 @@ reboot.
 | --- | --- |
 | `/pi-plus` | status modal for every feature |
 | `/pi-plus help` | model explains the pack and what is missing |
-| `/account` | account hub: toggle, add, reauth, switch routing |
-| `/account <provider> add [label]` | add a subscription |
-| `/account <provider> reauth [label]` | reauthorize one |
-| `/routing standard \| optimal` | main-first, or balance by quota |
+| `/accounts` | account hub: toggle, add, reauth, switch routing |
+| `/accounts add <provider> [label]` | add a subscription |
+| `/accounts reauth <provider> [label]` | reauthorize one |
+| `/routing sequential \| quota-aware` | account order, or remaining capacity |
 | `/usage [on\|off\|text]` | quota bars |
 | `/models [sort]` | ranked catalog |
 | `/model-info <id>` | every benchmark for one model |
@@ -176,9 +213,12 @@ reboot.
 | `/remote add \| rename \| remove` | jump to one step |
 | `/board` | live agent board UI |
 | `/board setup \| restart \| clear \| status` | manage the board server |
+| `/compact better on \| off \| jev` | select reversible compaction and compact now |
+| `/workflow` | open the running workflow agent board |
+| `/workflow <name> [args]` | run a bundled workflow |
 
-**Tools available to the agent:** `list_models`, `agent_board`, `remote_status`,
-`remote_test`.
+**Tools available to the agent:** `workflow`, `list_models`, `agent_board`,
+`remote_status`, `remote_test`, `super_context_recall`.
 
 ---
 
@@ -190,7 +230,8 @@ Everything lives in one file, `~/.pi/agent/pi-plus.json`, created on first use:
 {
   "env":    { "ARTIFICIAL_ANALYSIS_API_KEY": "aa_…", "AGENT_BOARD_URL": "ws://…" },
   "policy": { "autoApprove": [], "requireApproval": [], "deny": [] },
-  "remote": { "workers": [] }
+  "remote": { "workers": [] },
+  "compact": { "better": "off" }
 }
 ```
 
@@ -213,13 +254,13 @@ src/
               usage-service, the single quota poller
   ui/         dumb render primitives: format · usage-bars
   domains/    one pi extension entry each
-              setup · subscriptions · models · agents · remote
-  vendor/     anthropic.ts, the only file importing @cortexkit/*
-server/       the agent board server, one file and one dependency (ws)
+              setup · subscriptions · models · workflows · agents · remote
+server/       agent board server
+config/       example settings and bundled skills
 ```
 
 ```sh
-npm install && npm run verify   # typecheck + 106 tests
+npm install && npm run verify   # lint + type check + tests
 ```
 
 ---
@@ -232,6 +273,10 @@ pi-plus is a thin layer over other people's work.
 | --- | --- | --- |
 | [`pi`](https://pi.dev/) | the host agent and the entire extension API | MIT |
 | [`xxhash-wasm`](https://github.com/jungomi/xxhash-wasm) | vendored into `src/core/anthropic/vendor/` for the billing checksum | MIT |
+| [`pi-workflow-engine`](https://github.com/timbrinded/pi-workflow-engine) | embedded workflow runtime and built-in workflows | MIT |
+
+The workflow engine keeps its upstream license in
+[`src/domains/workflows/LICENSE.md`](src/domains/workflows/LICENSE.md).
 
 The Anthropic provider, OAuth, quota and routing were originally adopted from
 [`@cortexkit/pi-anthropic-auth`](https://github.com/cortexkit/anthropic-auth)

package/config/skills/workflow-code-review-actions/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: workflow-code-review-actions
+description: "Act on selected workflow code-review findings: make minimal fixes or post GitHub PR inline comments using gh, GitHub MCP/tools, or project-specific tools."
+---
+
+Use this skill when the parent agent receives selected findings from the workflow code review.
+
+## Inputs
+
+The prompt will include compact JSON with:
+
+- `context`: workflow name, target, diff command, changed files, and optional summary.
+- `issues`: selected findings with `id`, `summary`, `category`, `severity`, `confidence`, `location`, `impact`, `evidence`, and `recommendation`.
+
+## Fix mode
+
+When mode is `fix selected code-review findings`:
+
+1. Inspect the selected issue JSON before editing.
+2. Make minimal edits that address only the selected findings.
+3. Preserve unrelated user changes and avoid broad refactors.
+4. Run focused validation if available for the touched files or behavior.
+5. Summarize changed files and validation results.
+6. Do not post GitHub PR comments in fix mode.
+
+## Comment mode
+
+When mode is `post inline GitHub PR comments`:
+
+1. Do not edit files or make code changes.
+2. Prefer installed GitHub MCP/tools if visible in the active tool list.
+3. If no GitHub MCP/tools are available, use `gh`:
+   - Resolve the PR with `gh pr view --json number,headRefOid,url,headRepositoryOwner,headRepository`.
+   - Resolve the repository with `gh repo view --json nameWithOwner` when owner/name is missing.
+   - Post each inline comment with `gh api repos/{owner}/{repo}/pulls/{number}/comments` and include `commit_id`, `path`, `line`, and `side=RIGHT`.
+4. Keep each comment concise: summary, severity/confidence/category, impact, evidence, and recommendation.
+5. Report posted, skipped, and failed counts.
+
+## Safety rules
+
+- Do not post duplicate comments.
+- Do not comment line-less findings inline.
+- Ask the user if the upstream PR cannot be identified.
+- Keep actions scoped to the selected issue IDs only.

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@jameslovespancakes/pi-plus",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "type": "module",
-  "description": "Consolidated pi extensions: Claude subscription accounts and quota HUD, benchmark-driven model catalog and billing policy, live agent board, and capacity-gated remote test workers.",
+  "description": "pi and more",
   "license": "MIT",
   "author": "james",
   "keywords": [
@@ -12,7 +12,9 @@
     "anthropic",
     "claude",
     "quota",
-    "models"
+    "models",
+    "workflows",
+    "multi-agent"
   ],
   "repository": {
     "type": "git",
@@ -35,6 +37,8 @@
       "./src/domains/setup/index.ts",
       "./src/domains/subscriptions/index.ts",
       "./src/domains/models/index.ts",
+      "./src/domains/compact/index.ts",
+      "./src/domains/workflows/index.ts",
       "./src/domains/agents/index.ts",
       "./src/domains/remote/index.ts"
     ],
@@ -61,6 +65,7 @@
     "version:next": "node scripts/bump-version.mjs --dry-run"
   },
   "devDependencies": {
-    "oxlint": "^1.83.0"
+    "oxlint": "^1.83.0",
+    "typescript": "5.9.3"
   }
 }

package/src/core/accounts/oauth-pool.ts

@@ -0,0 +1,137 @@
+import type { OAuthCredential } from "@earendil-works/pi-ai";
+import { agentPath, readJson, writeJson } from "../store.ts";
+import { normalizeRoutingMode, type AccountQuotaState, type AccountRoutingMode } from "./routing.ts";
+
+export type OAuthPoolMode = AccountRoutingMode;
+
+export interface PooledOAuthAccount extends OAuthCredential {
+  id: string;
+  label: string;
+  enabled?: boolean;
+  identity?: string;
+  addedAt: number;
+  lastUsed?: number;
+  quota?: AccountQuotaState;
+}
+
+export interface ProviderOAuthPool {
+  accounts: PooledOAuthAccount[];
+  mode: OAuthPoolMode;
+}
+
+/**
+ * Storage behind a pooled provider.
+ *
+ * Most providers share one `pi-plus-oauth-accounts.json`, but a provider that
+ * already owns a file with extra fields (Codex carries `accountId`/`plan`, and
+ * its quota snapshot feeds the usage bars) supplies its own implementation so
+ * it can join the shared serving path without a risky file migration.
+ */
+export interface PooledOAuthStore {
+  load(): ProviderOAuthPool;
+  saveAccount(account: PooledOAuthAccount): void;
+  saveMode(mode: OAuthPoolMode): void;
+  /** Routing state for the credential pi itself is logged in as. */
+  primaryQuota(): AccountQuotaState | undefined;
+}
+
+interface OAuthPoolFile {
+  version: 1;
+  providers: Record<string, ProviderOAuthPool>;
+}
+
+const EMPTY_FILE: OAuthPoolFile = { version: 1, providers: {} };
+const DEFAULT_PATH = "pi-plus-oauth-accounts.json";
+const fileCache = new Map<string, OAuthPoolFile>();
+
+export function oauthPoolPath(): string {
+  return process.env.PI_PLUS_OAUTH_ACCOUNTS_FILE ?? agentPath(DEFAULT_PATH);
+}
+
+function loadFile(path = oauthPoolPath()): OAuthPoolFile {
+  const cached = fileCache.get(path);
+  if (cached) return cached;
+
+  const raw = readJson<Partial<OAuthPoolFile>>(path, EMPTY_FILE);
+  const file: OAuthPoolFile = {
+    version: 1,
+    providers: raw.providers && typeof raw.providers === "object" ? raw.providers : {},
+  };
+  fileCache.set(path, file);
+  return file;
+}
+
+function saveFile(file: OAuthPoolFile, path = oauthPoolPath()): void {
+  fileCache.set(path, file);
+  if (!writeJson(path, file, true, 0o600)) throw new Error(`Could not write OAuth accounts to ${path}`);
+}
+
+export function loadOAuthPool(providerId: string, path = oauthPoolPath()): ProviderOAuthPool {
+  const pool = loadFile(path).providers[providerId];
+  return {
+    accounts: Array.isArray(pool?.accounts) ? pool.accounts : [],
+    mode: normalizeRoutingMode(pool?.mode as string | undefined),
+  };
+}
+
+export function saveOAuthPool(providerId: string, pool: ProviderOAuthPool, path = oauthPoolPath()): void {
+  const file = loadFile(path);
+  file.providers[providerId] = pool;
+  saveFile(file, path);
+}
+
+export function saveOAuthAccount(providerId: string, account: PooledOAuthAccount, path = oauthPoolPath()): void {
+  const pool = loadOAuthPool(providerId, path);
+  const index = pool.accounts.findIndex((candidate) => candidate.id === account.id);
+  if (index === -1) pool.accounts.push(account);
+  else pool.accounts[index] = { ...pool.accounts[index], ...account };
+  saveOAuthPool(providerId, pool, path);
+}
+
+export function removeOAuthAccount(providerId: string, accountId: string, path = oauthPoolPath()): boolean {
+  const pool = loadOAuthPool(providerId, path);
+  const accounts = pool.accounts.filter((account) => account.id !== accountId);
+  if (accounts.length === pool.accounts.length) return false;
+  saveOAuthPool(providerId, { ...pool, accounts }, path);
+  return true;
+}
+
+export function setOAuthPoolMode(providerId: string, mode: OAuthPoolMode, path = oauthPoolPath()): void {
+  saveOAuthPool(providerId, { ...loadOAuthPool(providerId, path), mode }, path);
+}
+
+export function oauthIdentity(access: string): string | undefined {
+  try {
+    const payload = JSON.parse(Buffer.from(access.split(".")[1] ?? "", "base64url").toString()) as Record<string, unknown>;
+    for (const key of ["sub", "email", "account_id", "user_id", "uid"]) {
+      const value = payload[key];
+      if (typeof value === "string" && value) return `${key}:${value}`;
+    }
+  } catch {
+    // Opaque access tokens have no local identity.
+  }
+  return undefined;
+}
+
+/** In-memory quota for each provider's primary (host) credential. */
+const primaryQuotas = new Map<string, AccountQuotaState>();
+
+/** Default store: the shared pool file, with primary quota held in memory. */
+export function sharedOAuthPoolStore(providerId: string): PooledOAuthStore {
+  return {
+    load: () => loadOAuthPool(providerId),
+    saveAccount: (account) => saveOAuthAccount(providerId, account),
+    saveMode: (mode) => setOAuthPoolMode(providerId, mode),
+    primaryQuota: () => primaryQuotas.get(providerId),
+  };
+}
+
+/** Records routing state for a provider's primary credential. */
+export function setPrimaryQuota(providerId: string, quota: AccountQuotaState): void {
+  primaryQuotas.set(providerId, quota);
+}
+
+export function resetOAuthPoolCache(): void {
+  fileCache.clear();
+  primaryQuotas.clear();
+}

package/src/core/accounts/registry.ts

@@ -1,13 +1,4 @@
-/**
- * Provider-agnostic subscription accounts.
- *
- * Today only Anthropic implements this, through
- * `domains/subscriptions/providers/anthropic.ts`. The point of the indirection
- * is that `/account` and `/routing` contain no provider-specific logic, so a
- * second provider is a new adapter rather than a new command surface.
- *
- * Structural types only; nothing here imports pi.
- */
+/** Provider-agnostic subscription account adapters. */
 
 export interface ManagedAccount {
   id: string;
@@ -18,17 +9,16 @@ export interface ManagedAccount {
   expiresAt?: number;
   /** True for the account pi itself is authenticated as. */
   primary?: boolean;
+  /** Provider-stable identity used only to collapse duplicate logins. */
+  identity?: string;
 }
 
-/**
- * `standard` uses the main account first and falls back only when it is
- * exhausted. `optimal` balances across accounts by remaining quota and time to
- * reset, keeping session caches sticky.
- */
-export type RoutingMode = "standard" | "optimal";
+/** Fixed account order or provider quota-aware selection. */
+export type RoutingMode = "sequential" | "quota-aware";
 
 export interface AccountUi {
   input(title: string, placeholder?: string): Promise<string | undefined>;
+  select(title: string, options: string[]): Promise<string | undefined>;
   confirm(title: string, message: string): Promise<boolean>;
   notify(message: string, type?: "info" | "warning" | "error"): void;
 }
@@ -36,7 +26,8 @@ export interface AccountUi {
 export interface AccountContext {
   ui: AccountUi;
   hasUI: boolean;
-  /** Opens a URL in the user's browser, for OAuth flows. */
+  signal?: AbortSignal;
+  /** Opens an OAuth URL. */
   openBrowser(url: string): Promise<void>;
 }
 
@@ -52,19 +43,15 @@ export interface AccountProvider {
   /** Human name, e.g. "Claude". */
   label: string;
   list(): Promise<ManagedAccount[]>;
+  /** Resolves a provider-stable identity from an OAuth access token. */
+  identify?(accessToken: string): string | undefined | Promise<string | undefined>;
   /** Returns the label of the account that was added. */
   add(ctx: AccountContext, label: string): Promise<string | undefined>;
   /** Returns the label of the account that was reauthorized. */
   reauth(ctx: AccountContext, accountId: string): Promise<string | undefined>;
-  /**
-   * Enables or disables one account without removing its credentials.
-   * Optional: a provider that cannot suspend accounts simply omits it.
-   */
+  /** Enables or disables an account without removing credentials. */
   setEnabled?(accountId: string, enabled: boolean): Promise<void>;
-  /**
-   * Changes an account's display label. Credentials are untouched, so this is
-   * purely cosmetic and never needs a re-authorization.
-   */
+  /** Changes only the display label. */
   rename?(accountId: string, label: string): Promise<void>;
   routing?: RoutingSupport;
 }

package/src/core/accounts/routing.ts

@@ -0,0 +1,144 @@
+export interface AccountQuotaState {
+  remainingPercent?: number;
+  resetAt?: number;
+  checkedAt: number;
+  blockedUntil?: number;
+}
+
+export interface AccountRoutingCandidate<T> {
+  readonly id: string;
+  readonly order: number;
+  readonly lastUsed: number;
+  readonly quota?: AccountQuotaState;
+  readonly value: T;
+}
+
+export type AccountRoutingMode = "sequential" | "quota-aware";
+
+/**
+ * Upper bound on a token refresh, matching pi-ai's own
+ * `DEFAULT_OAUTH_REFRESH_TIMEOUT_MS` in `auth/resolve.js`.
+ *
+ * Routed auth runs outside pi-ai's refresh path, so nothing else bounds it.
+ * An unbounded refresh against a stalled token endpoint hangs the request
+ * forever, and because in-flight refreshes are de-duplicated per account,
+ * every later request joins the same hung promise.
+ */
+export const OAUTH_REFRESH_TIMEOUT_MS = 15_000;
+
+/** Bounds a refresh, honouring a caller signal when one is available. */
+export function refreshAbortSignal(signal?: AbortSignal): AbortSignal {
+  const timeout = AbortSignal.timeout(OAUTH_REFRESH_TIMEOUT_MS);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+
+/** Maps stored legacy names onto the two routing modes. */
+export function normalizeRoutingMode(value: string | undefined): AccountRoutingMode {
+  return value === "quota-aware" || value === "optimal" || value === "sticky-balanced"
+    ? "quota-aware"
+    : "sequential";
+}
+
+/** Sequential keeps account order; quota-aware prefers unmeasured then highest remaining capacity. */
+export function selectRoutingCandidate<T>(
+  candidates: readonly AccountRoutingCandidate<T>[],
+  mode: AccountRoutingMode,
+  now = Date.now(),
+): AccountRoutingCandidate<T> | undefined {
+  if (candidates.length === 0) return undefined;
+  const viable = candidates.filter((candidate) => isCandidateViable(candidate.quota, now));
+  if (viable.length === 0) return undefined;
+
+  if (mode === "sequential") {
+    return [...viable].sort((left, right) => left.order - right.order)[0];
+  }
+
+  const unmeasured = viable.filter((candidate) => candidate.quota?.remainingPercent === undefined);
+  if (unmeasured.length > 0) return leastRecentlyUsed(unmeasured);
+
+  return [...viable].sort((left, right) =>
+    (right.quota?.remainingPercent ?? 0) - (left.quota?.remainingPercent ?? 0)
+    || left.lastUsed - right.lastUsed
+    || left.order - right.order
+    || left.id.localeCompare(right.id))[0];
+}
+
+export function quotaStateFromHeaders(
+  status: number,
+  headers: Record<string, string>,
+  previous?: AccountQuotaState,
+  now = Date.now(),
+): AccountQuotaState | undefined {
+  const normalized = new Map(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
+  const remaining = firstNumber(normalized, [
+    "x-ratelimit-remaining-requests",
+    "ratelimit-remaining-requests",
+    "x-ratelimit-remaining",
+    "ratelimit-remaining",
+  ]);
+  const limit = firstNumber(normalized, [
+    "x-ratelimit-limit-requests",
+    "ratelimit-limit-requests",
+    "x-ratelimit-limit",
+    "ratelimit-limit",
+  ]);
+  const resetAt = parseResetAt(normalized, now);
+
+  if (status === 429) {
+    return {
+      remainingPercent: 0,
+      resetAt,
+      checkedAt: now,
+      blockedUntil: resetAt ?? now + 60_000,
+    };
+  }
+  if (remaining === undefined) return previous;
+
+  const remainingPercent = limit && limit > 0
+    ? Math.max(0, Math.min(100, remaining / limit * 100))
+    : Math.max(0, Math.min(100, remaining));
+  return { remainingPercent, resetAt, checkedAt: now };
+}
+
+/**
+ * Exhausted-with-no-reset is already handled by `isCandidateViable` below, so
+ * callers never need a sentinel `blockedUntil`. Persisting `Infinity` would
+ * serialize to `null` and silently unblock on the next load.
+ */
+function isCandidateViable(quota: AccountQuotaState | undefined, now: number): boolean {
+  if (!quota) return true;
+  if (quota.blockedUntil !== undefined && quota.blockedUntil > now) return false;
+  if (quota.remainingPercent !== 0) return true;
+  return quota.resetAt !== undefined && quota.resetAt <= now;
+}
+
+function leastRecentlyUsed<T>(candidates: readonly AccountRoutingCandidate<T>[]): AccountRoutingCandidate<T> {
+  return [...candidates].sort((left, right) =>
+    left.lastUsed - right.lastUsed
+    || left.order - right.order
+    || left.id.localeCompare(right.id))[0];
+}
+
+function firstNumber(headers: ReadonlyMap<string, string>, names: readonly string[]): number | undefined {
+  for (const name of names) {
+    const value = Number(headers.get(name));
+    if (Number.isFinite(value)) return value;
+  }
+  return undefined;
+}
+
+function parseResetAt(headers: ReadonlyMap<string, string>, now: number): number | undefined {
+  const retryAfter = Number(headers.get("retry-after"));
+  if (Number.isFinite(retryAfter) && retryAfter >= 0) return now + retryAfter * 1_000;
+
+  const raw = firstNumber(headers, [
+    "x-ratelimit-reset-requests",
+    "ratelimit-reset-requests",
+    "x-ratelimit-reset",
+    "ratelimit-reset",
+  ]);
+  if (raw === undefined) return undefined;
+  if (raw > 1_000_000_000_000) return raw;
+  if (raw > 1_000_000_000) return raw * 1_000;
+  return now + raw * 1_000;
+}