@timo972/cc-router 0.13.0-rc.3 → 0.13.0-rc.5

package/CHANGELOG.md

@@ -8,6 +8,24 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+### Changed
+
+- `cc-router usage` charts and its daily grid switch between tokens and
+  estimated API spend (`s`) and narrow to input or output (`i`); every bucket,
+  model series and day in the report now carries frozen-rate USD per token
+  category. The model view (`l`) lists input, output, cache and spend per
+  model. Input, output and cache figures share one colour each across the
+  header, the cost line and the model view.
+- The usage view fills the terminal like `cc-router status`, is indented one
+  column, and quits on `Esc`. Chart columns scale to the available width and
+  the chart shares the daily grid's right edge; the axis names its unit
+  instead of running day numbers together. Warnings sit below the grid.
+- Subscription cost and net savings are no longer displayed in the usage
+  dashboard or the plain-text summary; the API-equivalent value stands alone,
+  broken down by input, output and cache. Both remain in `--json` output and
+  `usage subscription` still records costs. A client talking to an older
+  router shows the per-category spend as unavailable rather than zero.
+
 ### ⚠️ Breaking
 
 - `cc-router accounts add-openai`, `login-openai`, `add-grok` and `login-grok`
@@ -35,6 +53,11 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - `POST /cc-router/accounts/:id/refresh` refreshes one account. The
   dashboard's `R` uses it when an account is selected and reloads the whole
   pool otherwise.
+- Dashboard `rst` column and `Ctrl+R` now cover Claude accounts: banked
+  usage-limit resets (e.g. the Opus 5.5 launch reset) are shown and can be
+  redeemed after confirmation. Claude usage polls now identify as Claude Code,
+  which Anthropic requires before offering resets. The redemption endpoint is
+  undocumented and may change.
 
 ### Fixed
 

package/README.md

@@ -109,12 +109,14 @@ it later. Adding more accounts is `cc-router accounts login`, re-signing one in
 Per-platform token extraction, Codex CLI, Docker and everything else lives in
 [the docs](docs/).
 
-## Usage history and savings
+## Usage history and API-equivalent cost
 
 Run `cc-router usage` for persistent token history, provider/model stacked bars,
-and a daily activity grid. Switch between day, week, month and year; history
-survives service restarts. Configure your monthly subscription costs to compare
-them with the estimated standard API token value:
+and a daily activity grid, each switchable between tokens and what the recorded
+tokens would have cost at standard API rates, and narrowable to input or output.
+Switch between day, week, month and year; history survives service restarts.
+Monthly subscription costs can be recorded for comparison in the `--json`
+report:
 
 ```bash
 cc-router usage subscription set personal --monthly-usd 100 --from 2026-09-01

package/dist/cli/cmd-usage.js

@@ -46,15 +46,16 @@ export function formatUsageText(report) {
     const money = (n) => n === null ? "unavailable" : `${n < 0 ? "-" : ""}$${Math.abs(n).toFixed(2)}`;
     return [
         `Usage ${report.period}: ${report.start.slice(0, 10)} — ${report.end.slice(0, 10)} (UTC, end exclusive)`,
+        // Same four categories the dashboard shows, so the two surfaces read alike.
         `Tokens: ${totalTokens(t).toLocaleString("en-US")} | input ${t.input} | output ${t.output} | cache read ${t.cacheRead} | cache write ${t.cacheWrite}`,
+        // Subscription cost and net savings are hidden for now; the API-equivalent
+        // value is the figure that stands on its own. Both remain in --json.
         `API equivalent: ${money(c.pricedApiUsd)}${c.coverage.pricingComplete ? "" : " (partial; unpriced tokens excluded)"}`,
-        `Subscription: ${money(c.subscriptionUsd)}${c.coverage.subscriptionComplete ? "" : " (partial; configure missing costs)"}`,
-        `Net savings: ${money(c.savingsUsd)}${c.savingsPercent === null ? "" : ` (${c.savingsPercent.toFixed(1)}%)`}`,
         ...report.warnings.map(w => `Warning: ${w}`),
     ].join("\n");
 }
 export function registerUsage(program) {
-    const usage = program.command("usage").description("Persistent token usage and API-equivalent subscription savings")
+    const usage = program.command("usage").description("Persistent token usage and its API-equivalent cost")
         .option("--period <period>", "day, week, month or year", "month")
         .option("--date <date>", "Date within the selected period (YYYY-MM-DD, UTC)")
         .option("--provider <provider>", "Filter Claude, OpenAI or Grok (repeatable)", (value, previous = []) => [...previous, value])

package/dist/cli/index.js

@@ -31,7 +31,7 @@ Examples:
   $ cc-router start --reconfigure# Re-ask run preferences
   $ cc-router stop               # Stop proxy (offers to remove auto-start / config)
   $ cc-router status             # Live dashboard with account stats
-  $ cc-router usage              # Persistent token usage and subscription savings
+  $ cc-router usage              # Persistent token usage and its API-equivalent cost
   $ cc-router models list        # List dynamically discovered provider models
   $ cc-router logs               # View proxy logs (background mode)
   $ cc-router accounts list      # Show Claude, ChatGPT, and Grok accounts

package/dist/providers/anthropic/usage-reset.js

@@ -0,0 +1,58 @@
+import { ResetNotSubmittedError, RESET_OUTCOME_UNKNOWN } from "../../proxy/reset-errors.js";
+import { CLAUDE_CODE_USER_AGENT, OAUTH_BETA_HEADER } from "./usage.js";
+const CODES = ["reset", "already_used", "not_limited", "cooldown", "ineligible"];
+// Claude Code maps these to "Couldn't confirm the reset went through" and keeps
+// the claim for a same-id retry; so do we, whatever `result` says.
+const UNCONFIRMED_REASONS = ["reset_unconfirmed", "stamp_indeterminate"];
+const ORG_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const GRANT_ID = /^[a-z0-9_-]{1,40}$/;
+const REQUEST_ID = /^[A-Za-z0-9_-]{1,64}$/;
+export async function consumeClaudeLimitReset(account, orgUuid, grantId, requestId, options = {}) {
+    // Contract: Claude Code 2.1.280 `/limit-reset` (program "cedar_ember").
+    // Undocumented; reverse-engineered from the CLI bundle on 2026-09-23.
+    if (!ORG_UUID.test(orgUuid) || !GRANT_ID.test(grantId) || !REQUEST_ID.test(requestId)) {
+        throw new ResetNotSubmittedError(503, "Reset request malformed; reset not submitted");
+    }
+    const request = options.fetch ?? globalThis.fetch;
+    // Never retry a spend with a fresh ID: a lost response may have consumed it.
+    try {
+        const response = await request(`https://api.anthropic.com/api/organizations/${orgUuid}/reset_rate_limits`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${account.tokens.accessToken}`,
+                "anthropic-beta": OAUTH_BETA_HEADER,
+                "user-agent": CLAUDE_CODE_USER_AGENT,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ program: "cedar_ember", grant_id: grantId, request_id: requestId }),
+            signal: AbortSignal.timeout(10_000),
+            redirect: "error",
+        });
+        if (response.status === 401 || response.status === 403) {
+            throw new ResetNotSubmittedError(503, "Account credentials rejected; reset not submitted");
+        }
+        if (response.ok) {
+            const body = await response.json();
+            if (body && typeof body === "object" && "result" in body) {
+                const code = body.result;
+                const left = body.resets_left;
+                const reason = body.reason;
+                // `unavailable` is not in CODES: an unconfirmed claim is never "nothing used".
+                if (typeof reason === "string" && UNCONFIRMED_REASONS.includes(reason))
+                    throw new Error(RESET_OUTCOME_UNKNOWN);
+                if (CODES.includes(code)) {
+                    return {
+                        code: code,
+                        ...(typeof left === "number" && Number.isInteger(left) && left >= 0 ? { resetsLeft: left } : {}),
+                    };
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof ResetNotSubmittedError)
+            throw error;
+        // Do not relay upstream bodies, credentials, or network error details.
+    }
+    throw new Error(RESET_OUTCOME_UNKNOWN);
+}

package/dist/providers/anthropic/usage.js

@@ -1,6 +1,9 @@
 import { nextEventSequence } from "../../proxy/event-sequence.js";
-const ANTHROPIC_USAGE_ENDPOINT = "https://api.anthropic.com/api/oauth/usage";
-const OAUTH_BETA_HEADER = "oauth-2025-04-20";
+const ANTHROPIC_USAGE_ENDPOINT = "https://api.anthropic.com/api/oauth/usage?cedar_ember=1";
+export const OAUTH_BETA_HEADER = "oauth-2025-04-20";
+/** Reset status is only offered to the Claude Code surface; bump when the server answers `cli_version`. */
+export const CLAUDE_CODE_UA_VERSION = "2.1.280";
+export const CLAUDE_CODE_USER_AGENT = `claude-cli/${CLAUDE_CODE_UA_VERSION} (external, cli)`;
 const DEFAULT_USAGE_TIMEOUT_MS = 5_000;
 const USAGE_FIELDS = new Set([
     "five_hour",
@@ -136,6 +139,59 @@ function parseExtraUsage(value) {
         parsed.limitMinor = limitMinor;
     return parsed;
 }
+const GRANT_ID = /^[a-z0-9_-]{1,40}$/;
+const RESET_WINDOWS = [
+    "five_hour", "seven_day", "seven_day_overage_included", "seven_day_opus", "seven_day_sonnet",
+];
+const INELIGIBLE_REASONS = new Set([
+    "config_off", "tier", "seat", "mobile", "surface", "cli_version", "no_grant",
+    "tenure", "other_experiment", "unavailable",
+]);
+function parseResetGrant(value) {
+    if (!isRecord(value))
+        return undefined;
+    const id = typeof value.id === "string" && GRANT_ID.test(value.id) ? value.id : undefined;
+    const left = value.resets_left;
+    if (!id || typeof left !== "number" || !Number.isInteger(left) || left < 0)
+        return undefined;
+    const reported = Array.isArray(value.clears) ? value.clears : undefined;
+    const clears = reported ? RESET_WINDOWS.filter(window => reported.includes(window)) : [];
+    // Anything not named here would be refilled without the operator seeing it.
+    const clearsOther = !reported || reported.some(window => !RESET_WINDOWS.includes(window));
+    return {
+        id,
+        resetsLeft: left,
+        endsAt: resetAt(value.ends_at),
+        clears,
+        clearsOther,
+        usableNow: value.usable_now === true,
+        useRequiresLimit: value.use_requires_limit !== false,
+        paused: value.paused === true,
+    };
+}
+/** Parse the cedar_ember block. Unknown or malformed → undefined, never "zero resets". */
+export function parseLimitResets(value) {
+    if (!isRecord(value) || typeof value.eligible !== "boolean")
+        return undefined;
+    // An eligible account's count is only established by an actual list; an
+    // explicit [] is a real zero. Ineligible blocks may omit it.
+    if (value.eligible && !Array.isArray(value.grants))
+        return undefined;
+    const grants = (Array.isArray(value.grants) ? value.grants : [])
+        .map(parseResetGrant)
+        .filter((grant) => grant !== undefined);
+    const next = typeof value.next_grant_id === "string" && grants.some(grant => grant.id === value.next_grant_id)
+        ? value.next_grant_id
+        : undefined;
+    const reason = stringValue(value.ineligible_reason);
+    return {
+        eligible: value.eligible,
+        ...(reason ? { ineligibleReason: INELIGIBLE_REASONS.has(reason) ? reason : "unknown" } : {}),
+        grants,
+        ...(next ? { nextGrantId: next } : {}),
+        cooldownUntil: resetAt(value.cooldown_until),
+    };
+}
 function legacyModelLimit(family, value) {
     const window = parseWindow(value);
     if (!window)
@@ -171,12 +227,15 @@ export function parseAnthropicUsage(value, fetchedAt, requestedSeq) {
     const fiveHour = parseWindow(value.five_hour);
     const sevenDay = parseWindow(value.seven_day);
     const extraUsage = parseExtraUsage(value.extra_usage);
+    const limitResets = parseLimitResets(value.cedar_ember);
     if (fiveHour)
         snapshot.fiveHour = fiveHour;
     if (sevenDay)
         snapshot.sevenDay = sevenDay;
     if (extraUsage)
         snapshot.extraUsage = extraUsage;
+    if (limitResets)
+        snapshot.limitResets = limitResets;
     return snapshot;
 }
 export function canUseExtraUsage(state) {
@@ -208,6 +267,7 @@ export async function fetchAnthropicUsage(account, options = {}) {
             headers: {
                 Authorization: `Bearer ${account.tokens.accessToken}`,
                 "anthropic-beta": OAUTH_BETA_HEADER,
+                "user-agent": CLAUDE_CODE_USER_AGENT,
             },
             signal: controller.signal,
         });

package/dist/proxy/account-usage-reset.js

@@ -1,3 +1,12 @@
+import { ResetNotSubmittedError, RESET_OUTCOME_UNKNOWN } from "./reset-errors.js";
+/**
+ * Answer with a refusal that provably sent nothing upstream. The explicit
+ * `notSubmitted` marker is what lets a client tell it apart from an error a
+ * gateway in between may synthesize after the claim did go out.
+ */
+function refuse(res, status, error, extra = {}) {
+    res.status(status).json({ error, notSubmitted: true, ...extra });
+}
 export function createUsageResetHandler(options) {
     const inFlight = new WeakSet();
     // One retained snapshot per account allows an uncertain retry to reconcile
@@ -7,33 +16,35 @@ export function createUsageResetHandler(options) {
         const id = req.params.id;
         const requestId = req.body?.redeemRequestId;
         if (typeof requestId !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(requestId)) {
-            res.status(400).json({ error: "redeemRequestId must be a UUID" });
+            refuse(res, 400, "redeemRequestId must be a UUID");
             return;
         }
         const account = options.findAccount(id);
         if (!account) {
-            res.status(404).json({ error: "ChatGPT account not found" });
+            refuse(res, 404, "Account not found");
             return;
         }
         if (inFlight.has(account)) {
-            res.status(409).json({ error: "Reset already running for this account" });
+            refuse(res, 409, "Reset already running for this account");
             return;
         }
         inFlight.add(account);
         try {
             if (!await options.prepare(account)) {
-                res.status(503).json({ error: "Account credentials unavailable; reset not submitted" });
+                refuse(res, 503, "Account credentials unavailable; reset not submitted");
                 return;
             }
             if (options.findAccount(id) !== account) {
-                res.status(404).json({ error: "ChatGPT account changed; reset not submitted" });
+                refuse(res, 404, "Account changed; reset not submitted");
                 return;
             }
             const previous = snapshots.get(account);
-            const replay = previous?.id === requestId;
-            const snapshot = replay ? previous : { id: requestId, reconcile: options.captureReset?.(account) };
+            const sameSnapshot = previous?.id === requestId;
+            // Read before consume: consuming is what records the id as sent.
+            const replay = options.isReplay ? options.isReplay(account, requestId) : sameSnapshot;
+            const snapshot = sameSnapshot ? previous : { id: requestId, reconcile: options.captureReset?.(account) };
             snapshots.set(account, snapshot);
-            const result = await options.consume(account, requestId);
+            const result = await options.consume(account, requestId, { retry: req.body?.retry === true, offer: req.body?.offer });
             if (result.code === "already_redeemed" && !replay) {
                 // This UUID predates our ownership. Repeated historical replays must
                 // never promote its newly captured quota snapshot into trusted evidence.
@@ -52,10 +63,17 @@ export function createUsageResetHandler(options) {
                 }
                 catch { /* retain confirmed redemption */ }
             }
-            res.json({ reset: { ...result, usageRefreshed } });
+            res.json({ reset: { provider: options.provider, ...result, usageRefreshed, replay } });
         }
-        catch {
-            res.status(502).json({ error: "Reset outcome unknown; retry with the same redemption ID" });
+        catch (error) {
+            if (error instanceof ResetNotSubmittedError) {
+                refuse(res, error.status, error.message, {
+                    ...(error.abandon ? { abandon: true } : {}),
+                    ...(error.pendingRedemption ? { pendingRedemption: error.pendingRedemption } : {}),
+                });
+                return;
+            }
+            res.status(502).json({ error: RESET_OUTCOME_UNKNOWN });
         }
         finally {
             inFlight.delete(account);

package/dist/proxy/claude-usage-reset.js

@@ -0,0 +1,120 @@
+import { ResetNotSubmittedError } from "./reset-errors.js";
+import { consumeClaudeLimitReset } from "../providers/anthropic/usage-reset.js";
+/** Whether the confirmed terms are exactly the next grant's, as publicLimitResets shows them. */
+function offerMatches(offer, grant) {
+    if (typeof offer !== "object" || offer === null)
+        return false;
+    const { useBy, clears, clearsOther } = offer;
+    return useBy === (grant.endsAt > 0 ? grant.endsAt : 0)
+        && Array.isArray(clears) && clears.length === grant.clears.length && clears.every((w, i) => w === grant.clears[i])
+        && clearsOther === grant.clearsOther;
+}
+const MAX_PINNED_PER_ACCOUNT = 8;
+/**
+ * Binds each redemption id to the grant and account holder it first
+ * targeted. A replay after an unknown outcome must hit the same grant, or a
+ * moved `next_grant_id` would turn "retry" into "spend a second reset".
+ *
+ * Pins are keyed by account id, not the Account object, so a re-auth that
+ * replaces the object keeps them, and a rename moves them. They live in
+ * memory only, and each account keeps its 8 most recent ids. While one of an
+ * account's claims is unsettled (no definite answer yet), new ids for that
+ * account are refused and pointed at it, so eviction only ever drops settled
+ * pins. A retry whose pin is gone (router restart) is refused before sending
+ * rather than re-derived: its original grant can no longer be named, and only
+ * fresh usage can tell whether it was spent. A pin is written only right
+ * before the claim is sent, and dropped again if that first claim provably
+ * never left (409/503): a refusal before submission leaves nothing pinned.
+ *
+ * The returned `resetsLeft` is account-wide (the redeemed grant's count plus
+ * the other non-paused grants), matching the rst column.
+ */
+export function createClaudeResetConsumer(deps) {
+    const consume = deps.consume ?? consumeClaudeLimitReset;
+    // `settled`: a definite upstream answer came back for this id.
+    const pinned = new Map();
+    const run = async (account, requestId, attempt = {}) => {
+        const pin = pinned.get(account.id)?.get(requestId);
+        let grantId = pin?.grantId;
+        if (!grantId) {
+            if (attempt.retry) {
+                throw new ResetNotSubmittedError(409, "Earlier reset attempt can't be matched any more (router restarted?) — check rst before redeeming again; nothing sent", true);
+            }
+            // One unresolved claim per account: a client that lost track of it
+            // (renamed row, restarted dashboard) is handed its id to retry instead
+            // of starting a claim that could spend another grant.
+            const unresolved = [...(pinned.get(account.id) ?? [])].find(([, entry]) => !entry.settled)?.[0];
+            if (unresolved) {
+                throw new ResetNotSubmittedError(409, "An earlier reset attempt on this account never confirmed — press Ctrl+R again to retry it; nothing sent", false, unresolved);
+            }
+            const usage = account.rateLimits.usage;
+            if (usage?.fetchStatus !== "fresh")
+                throw new ResetNotSubmittedError(409, "Reset status is stale — reload with R; nothing sent");
+            const resets = usage.limitResets;
+            const next = resets?.eligible ? resets.grants.find(grant => grant.id === resets.nextGrantId) : undefined;
+            if (!next)
+                throw new ResetNotSubmittedError(409, "No reset available for this account");
+            if (next.clears.length === 0) {
+                throw new ResetNotSubmittedError(409, "Reset refill scope unknown — update cc-router; nothing sent");
+            }
+            if (!offerMatches(attempt.offer, next)) {
+                throw new ResetNotSubmittedError(409, "Reset offer changed since you confirmed — review it and confirm again; nothing sent");
+            }
+            grantId = next.id;
+        }
+        const who = await deps.identity(account);
+        if (!who?.org || !who.principal)
+            throw new ResetNotSubmittedError(503, "Account identity unknown; reset not submitted");
+        const { org, principal } = who;
+        // Grant ids are shared across accounts (and teammates): re-authenticating
+        // this id as anyone else — another organization, or another member of the
+        // same one — must not aim the old claim at their reset. Only the
+        // original account holder can settle it.
+        if (pin && (pin.org !== org || pin.principal !== principal)) {
+            // Abandoned for good: it must not hold this account's new redemptions.
+            pinned.get(account.id)?.delete(requestId);
+            throw new ResetNotSubmittedError(409, "Account now signs in as someone other than the earlier reset attempt — check rst before redeeming again; nothing sent", true);
+        }
+        let pins = pinned.get(account.id);
+        if (!pins)
+            pinned.set(account.id, pins = new Map());
+        const firstAttempt = !pins.has(requestId);
+        if (firstAttempt) {
+            pins.set(requestId, { grantId, org, principal, settled: false });
+            while (pins.size > MAX_PINNED_PER_ACCOUNT)
+                pins.delete(pins.keys().next().value);
+        }
+        // Other grants are untouched by this claim; summing them with the
+        // returned per-grant count matches the rst column (non-paused grants).
+        const othersLeft = (account.rateLimits.usage?.limitResets?.grants ?? [])
+            .filter(grant => grant.id !== grantId && !grant.paused)
+            .reduce((sum, grant) => sum + grant.resetsLeft, 0);
+        let result;
+        try {
+            result = await consume(account, org, grantId, requestId);
+        }
+        catch (error) {
+            // A first claim that provably never left must not bind this id: the
+            // next press may confirm a different offer. A pin from an earlier,
+            // possibly-sent attempt stays — that one still needs its own grant.
+            if (firstAttempt && error instanceof ResetNotSubmittedError)
+                pinned.get(account.id)?.delete(requestId);
+            throw error;
+        }
+        const entry = pinned.get(account.id)?.get(requestId);
+        if (entry)
+            entry.settled = true;
+        return result.resetsLeft === undefined ? result : { ...result, resetsLeft: othersLeft + result.resetsLeft };
+    };
+    /** Whether this id was already sent for this account id — survives re-auth, unlike per-object state. */
+    const isReplay = (account, requestId) => pinned.get(account.id)?.has(requestId) === true;
+    /** Called by the rename transaction (and its rollback): pins follow the router id. */
+    const renameAccount = (oldId, newId) => {
+        const pins = pinned.get(oldId);
+        if (!pins)
+            return;
+        pinned.delete(oldId);
+        pinned.set(newId, pins);
+    };
+    return Object.assign(run, { isReplay, renameAccount });
+}

package/dist/proxy/public-limit-resets.js

@@ -0,0 +1,15 @@
+/** Disclosure-safe summary: counts, dates and flags only — grant ids stay in-process. */
+export function publicLimitResets(state) {
+    const next = state.grants.find(grant => grant.id === state.nextGrantId);
+    const available = state.grants.filter(grant => !grant.paused).reduce((sum, grant) => sum + grant.resetsLeft, 0);
+    return {
+        eligible: state.eligible === true,
+        ...(state.ineligibleReason ? { ineligibleReason: state.ineligibleReason } : {}),
+        available: Math.max(0, Math.min(99, Math.floor(available))),
+        usableNow: next?.usableNow === true,
+        requiresLimit: next?.useRequiresLimit !== false,
+        useBy: next && next.endsAt > 0 ? next.endsAt : 0,
+        clears: next ? [...next.clears] : [],
+        clearsOther: next?.clearsOther === true,
+    };
+}

package/dist/proxy/reset-errors.js

@@ -0,0 +1,21 @@
+/** The redemption was provably never sent (or rejected before spending); safe to report as "nothing used". */
+export class ResetNotSubmittedError extends Error {
+    status;
+    abandon;
+    pendingRedemption;
+    /**
+     * @param abandon The client's pending redemption id can never be retried
+     *   safely (its grant binding is gone); the client should drop it and look
+     *   at fresh usage before starting a new redemption.
+     * @param pendingRedemption An earlier, unresolved redemption id for this
+     *   account that the client should retry instead of starting a new one.
+     */
+    constructor(status, message, abandon = false, pendingRedemption) {
+        super(message);
+        this.status = status;
+        this.abandon = abandon;
+        this.pendingRedemption = pendingRedemption;
+        this.name = "ResetNotSubmittedError";
+    }
+}
+export const RESET_OUTCOME_UNKNOWN = "Reset outcome unknown; retry with the same redemption ID";

package/dist/proxy/server.js

@@ -4,6 +4,8 @@ import { createUsageRouter } from "../usage/http.js";
 import { usageDirectoryForAccounts, withUsageRename } from "../usage/account-lifecycle.js";
 import { consumeCodexResetCredit } from "../providers/openai/usage-reset.js";
 import { createUsageResetHandler } from "./account-usage-reset.js";
+import { createClaudeResetConsumer } from "./claude-usage-reset.js";
+import { publicLimitResets } from "./public-limit-resets.js";
 import express from "express";
 import { createProxyMiddleware } from "http-proxy-middleware";
 import { ServerResponse } from "http";
@@ -182,6 +184,7 @@ function publicUsageSnapshot(usage) {
                 usable: usage.fetchStatus === "fresh" && canUseExtraUsage(usage.extraUsage),
             },
         } : {}),
+        ...(usage.limitResets ? { limitResets: publicLimitResets(usage.limitResets) } : {}),
         fetchedAt: publicTimestamp(usage.fetchedAt),
         fetchStatus: usage.fetchStatus,
     };
@@ -669,13 +672,65 @@ export async function startServer(opts = {}) {
     // the SSE streaming on /v1/* is never touched (see comment at /v1 handler).
     const accountsRouter = express.Router();
     accountsRouter.use(express.json({ limit: "32kb" }));
-    accountsRouter.post("/:id/reset-usage", createUsageResetHandler({
+    const openAIReset = createUsageResetHandler({
+        provider: "openai",
         findAccount: id => openAIAccounts.find(account => account.id === id),
         prepare: account => prepareOpenAIAccountForRequest(account, openAIAccounts, persistOpenAIAccounts),
         consume: consumeCodexResetCredit,
         captureReset: account => openAIPool.captureUsageReset(account),
         refresh: account => openAIUsageRefresher.refreshAfterCurrent(account),
-    }));
+    });
+    // Org and account UUIDs are identity metadata the profile fetch already
+    // caches (keyed to the current token, so a re-auth reads the new holder).
+    const claudeIdentity = async (account) => {
+        const read = () => {
+            const source = accountInfoSources().find(row => row.provider === "anthropic_subscription" && row.id === account.id);
+            const info = source ? accountInfoCache.get(source) : undefined;
+            return info?.workspaceId && info.accountId ? { org: info.workspaceId, principal: info.accountId } : undefined;
+        };
+        const cached = read();
+        if (cached)
+            return cached;
+        // Nothing is submitted yet: a failed profile fetch must read as "not
+        // submitted" (the consumer's 503), never as an unknown outcome.
+        try {
+            await accountInfoCache.refreshOne({ id: account.id, provider: "anthropic_subscription" });
+        }
+        catch { /* re-read below */ }
+        return read();
+    };
+    const claudeResetConsumer = createClaudeResetConsumer({ identity: claudeIdentity });
+    const claudeReset = createUsageResetHandler({
+        provider: "anthropic",
+        findAccount: id => pool.findById(id) ?? undefined,
+        prepare: async (account) => {
+            if (account.authExpired)
+                return false;
+            if (needsRefresh(account)) {
+                // A throw here would surface as "outcome unknown"; nothing was sent.
+                try {
+                    await refreshAccountIfCurrent(account, pool, { persist: persistAnthropicAccounts });
+                }
+                catch {
+                    return false;
+                }
+            }
+            return !account.authExpired && account.tokens.expiresAt > Date.now();
+        },
+        consume: claudeResetConsumer,
+        // The grant pin, not the per-object snapshot, knows a replay across re-auth.
+        isReplay: claudeResetConsumer.isReplay,
+        refresh: account => usageRefresher.refreshAfterCurrent(account),
+    });
+    accountsRouter.post("/:id/reset-usage", (req, res, next) => {
+        const id = req.params.id;
+        // Anthropic first, matching the /:id/refresh runner.
+        if (pool.findById(id))
+            return claudeReset(req, res, next);
+        if (openAIAccounts.some(account => account.id === id))
+            return openAIReset(req, res, next);
+        res.status(404).json({ error: "Account not found", notSubmitted: true });
+    });
     // ─── Per-account refresh (authenticated) ──────────────────────────────────
     // The whole-pool reload above, narrowed to one row: the operator who just
     // re-authenticated a single account should not have to pay for every other
@@ -887,7 +942,12 @@ export async function startServer(opts = {}) {
                 renameAccountTransaction(id, newId, takenIds, inAnthropic
                     ? {
                         rename: (oldId, nextId) => pool.renameAccount(oldId, nextId) !== null,
-                        renameSessions: (oldId, nextId) => { sessionRouter.renameAccount(oldId, nextId); },
+                        // Reset pins follow the id too (and back again on rollback), so an
+                        // unknown-outcome redemption stays retryable under the new name.
+                        renameSessions: (oldId, nextId) => {
+                            sessionRouter.renameAccount(oldId, nextId);
+                            claudeResetConsumer.renameAccount(oldId, nextId);
+                        },
                         persist: () => withUsageRename(accountsFile, id, newId, () => persistAnthropicAccounts(pool.getAll())),
                     }
                     : {