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

package/CHANGELOG.md

@@ -53,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/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())),
                     }
                     : {

package/dist/ui/Dashboard.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { randomUUID } from "node:crypto";
 import React, { useState, useEffect, useCallback, useRef } from "react";
 import { Box, Text, useInput, useApp, useStdout, measureElement } from "ink";
-import { createAccountsApi } from "./accountsApi.js";
+import { createAccountsApi, RouterRefusedResetError } from "./accountsApi.js";
 import { createModelsApi } from "./modelsApi.js";
 import { getCurrentVersion } from "../utils/self-update.js";
 import { readClaudeRouting, readCodexRouting, setClaudeRouting, setCodexRouting, } from "../utils/cli-routing.js";
@@ -241,11 +241,61 @@ export function isXaiAccount(account) {
 export function isClaudeAccount(account) {
     return !isOpenAIAccount(account) && !isXaiAccount(account);
 }
-/** Compact `rst` column: banked Codex usage-limit resets. Claude is an em dash. */
+/** Compact `rst` column: banked usage-limit resets. Grok and unknown or
+ *  ineligible Claude status are an em dash. */
 export function resetCreditsColumnLabel(account) {
-    if (!isOpenAIAccount(account))
+    if (isOpenAIAccount(account))
+        return String(account.codexRateLimits?.resetCredits?.available ?? 0);
+    if (!isClaudeAccount(account))
         return "—";
-    return String(account.codexRateLimits?.resetCredits?.available ?? 0);
+    const resets = account.rateLimits?.usage?.limitResets;
+    return resets?.eligible ? String(resets.available) : "—";
+}
+// Every window a grant can clear (LimitResetWindow): the operator must see
+// the whole scope of a spend before confirming it.
+const RESET_WINDOW_LABELS = {
+    five_hour: "5h",
+    seven_day: "7d",
+    seven_day_overage_included: "7d overage",
+    seven_day_opus: "7d Opus",
+    seven_day_sonnet: "7d Sonnet",
+};
+/** Why Ctrl+R cannot start a NEW Claude reset, or undefined when it can. */
+export function claudeResetBlocker(account) {
+    const usage = account.rateLimits?.usage;
+    const resets = usage?.limitResets;
+    if (!resets)
+        return "Reset status unknown — reload with R";
+    // A failed poll keeps the last grant data but marks it stale; a new
+    // redemption must not be chosen from it.
+    if (usage.fetchStatus !== "fresh")
+        return "Reset status is out of date — reload with R";
+    if (!resets.eligible) {
+        return resets.ineligibleReason === "cli_version"
+            ? "Claude Code version too old for resets — update cc-router"
+            : `Resets unavailable for this account (${resets.ineligibleReason ?? "unknown"})`;
+    }
+    if (resets.available <= 0)
+        return "No resets available";
+    // Never spend a reset whose effect cannot be shown in the confirmation.
+    if (resets.clears.length === 0)
+        return "Reset refill scope unknown — update cc-router";
+    if (!resets.usableNow)
+        return resets.requiresLimit ? "Reset only usable at a limit" : "Reset not usable right now";
+    return undefined;
+}
+/** Whether two Claude offers carry the same terms the confirmation shows. */
+export function sameResetOffer(a, b) {
+    return a.useBy === b.useBy && a.clearsOther === b.clearsOther
+        && a.clears.length === b.clears.length && a.clears.every((window, i) => window === b.clears[i]);
+}
+export function claudeResetConfirmText(id, resets) {
+    const windows = resets.clears.map(window => RESET_WINDOW_LABELS[window]).filter(Boolean);
+    if (resets.clearsOther)
+        windows.push("other");
+    const refills = windows.length > 0 ? `Refills ${windows.join(" + ")} limits` : "Refills your limits";
+    const useBy = resets.useBy > 0 ? ` · use by ${new Date(resets.useBy * 1000).toISOString().slice(0, 10)}` : "";
+    return `Redeem 1 reset for "${id}"? ${refills} · ${resets.available} left${useBy}`;
 }
 export function isLimitedAccount(account) {
     if (isXaiAccount(account))
@@ -675,6 +725,9 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
     const [focus, setFocus] = useState("logs");
     const [mode, setMode] = useState("view");
     const [resetTarget, setResetTarget] = useState(null);
+    // The Claude offer as it stood when the confirmation opened: what is shown
+    // and what is sent, however polls move the live grant meanwhile.
+    const [resetOffer, setResetOffer] = useState(null);
     // Compact ("zen") view: hides TOTALS + RECENT ACTIVITY so the account list
     // gets the whole vertical budget — the fix for a short terminal starving a
     // long fleet (e.g. showing 1 of 11 accounts). Toggled with [z], view-only,
@@ -791,6 +844,10 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
         ? Math.max(0, orderedAccounts.findIndex(a => a.id === selectedAccountId))
         : 0;
     const selectedAccount = orderedAccounts[selectedAccountIndex] ?? null;
+    const resetTargetAccount = resetTarget ? orderedAccounts.find(a => a.id === resetTarget) : undefined;
+    const resetTargetClaudeResets = resetTargetAccount && isClaudeAccount(resetTargetAccount)
+        ? resetTargetAccount.rateLimits?.usage?.limitResets
+        : undefined;
     // Identity for the selected row: health never carries it, so it comes from
     // the authenticated /cc-router/accounts poll above. The detail line and the
     // re-auth intent must agree on which email they mean, so both read this.
@@ -1035,23 +1092,48 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
             showBanner(`Models error: ${errMsg(err)}`, "red");
         }
     }, [modelsApi, selectedModel, showBanner]);
-    const doResetUsage = useCallback(async (id) => {
+    const doResetUsage = useCallback(async (id, shownOffer) => {
         if (resetSession.inFlight)
             return;
         resetSession.inFlight = true;
-        const requestId = resetSession.pendingIds.get(id) ?? randomUUID();
-        resetSession.pendingIds.set(id, requestId);
+        const pending = resetSession.pendingIds.get(id) ?? { requestId: randomUUID(), maybeSubmitted: false };
+        resetSession.pendingIds.set(id, pending);
         showBanner(`Redeeming usage reset for ${id}…`, "yellow", REFRESH_ALL_BANNER_MS);
         try {
-            const result = await api.resetUsage(id, requestId);
+            // Only a retry of a possibly-sent id may reuse its grant; the router
+            // refuses such a retry outright if it can no longer match it.
+            // The terms shown at confirmation: the router refuses if the grant it
+            // would spend no longer matches them.
+            const offer = shownOffer ? { useBy: shownOffer.useBy, clears: shownOffer.clears, clearsOther: shownOffer.clearsOther } : undefined;
+            const result = await api.resetUsage(id, pending.requestId, { retry: pending.maybeSubmitted, ...(offer ? { offer } : {}) });
             resetSession.pendingIds.delete(id);
-            const messages = {
-                reset: `Usage reset redeemed for ${id}`,
-                already_redeemed: `Usage reset already redeemed for ${id}`,
-                nothing_to_reset: `Nothing to reset for ${id}`,
-                no_credit: `No reset credits available for ${id}`,
-            };
-            showBanner(messages[result.code] + (result.usageRefreshed ? "" : " — usage refresh failed; reload with R"), result.usageRefreshed && (result.code === "reset" || result.code === "already_redeemed") ? "green" : "yellow");
+            const text = result.provider === "anthropic"
+                ? ({
+                    reset: `Limits reset for ${id}${result.resetsLeft !== undefined ? ` · ${result.resetsLeft} left` : ""}`,
+                    // A replayed id may have spent on the earlier, unconfirmed attempt:
+                    // only a first attempt can promise that nothing was used.
+                    already_used: result.replay
+                        ? `Reset already used for ${id} · nothing more spent`
+                        : `Reset already used elsewhere for ${id} · nothing spent now`,
+                    not_limited: result.replay
+                        ? `${id} is not at a limit · an earlier attempt may have used a reset — check rst`
+                        : `${id} is not at a limit · nothing used`,
+                    cooldown: result.replay
+                        ? `Resets are cooling down for ${id} · an earlier attempt may have used a reset — check rst`
+                        : `Resets are cooling down for ${id} · try later`,
+                    ineligible: result.replay
+                        ? `Reset unavailable for ${id} · an earlier attempt may have used a reset — check rst`
+                        : `Reset unavailable for ${id} · nothing used`,
+                })[result.code]
+                : ({
+                    reset: `Usage reset redeemed for ${id}`,
+                    already_redeemed: `Usage reset already redeemed for ${id}`,
+                    nothing_to_reset: `Nothing to reset for ${id}`,
+                    no_credit: `No reset credits available for ${id}`,
+                })[result.code];
+            const confirmed = result.code === "reset" || result.code === "already_redeemed"
+                || (result.code === "already_used" && result.replay);
+            showBanner(text + (result.usageRefreshed ? "" : " — usage refresh failed; reload with R"), result.usageRefreshed && confirmed ? "green" : "yellow");
             // Failure to poll the dashboard must not turn a confirmed spend into an
             // unknown outcome or encourage another redemption.
             try {
@@ -1059,8 +1141,26 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
             }
             catch { /* the regular poll will retry */ }
         }
-        catch {
-            showBanner(`Reset outcome unknown for ${id}; Ctrl+R retries the same redemption (keep dashboard open)`, "red");
+        catch (error) {
+            // The pending id is kept even when the router refused before submitting:
+            // an earlier attempt under the same id may still have an unknown outcome,
+            // and a fresh id would let the next press spend a second reset.
+            // Only when the router says the id can never be matched again is it
+            // dropped, and then the next press has to pass the fresh-status blocker.
+            if (error instanceof RouterRefusedResetError) {
+                if (error.abandon)
+                    resetSession.pendingIds.delete(id);
+                // The router still holds an unresolved claim for this account (e.g.
+                // it was renamed, or this dashboard restarted): retry that one next.
+                if (error.pendingRedemption) {
+                    resetSession.pendingIds.set(id, { requestId: error.pendingRedemption, maybeSubmitted: true });
+                }
+                showBanner(`${error.message} (${id})`, "yellow");
+            }
+            else {
+                pending.maybeSubmitted = true;
+                showBanner(`Reset outcome unknown for ${id}; Ctrl+R retries the same redemption (keep dashboard open)`, "red");
+            }
         }
         finally {
             resetSession.inFlight = false;
@@ -1098,11 +1198,21 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
             return;
         }
         if (mode === "confirmReset") {
-            if ((input === "y" || input === "Y") && resetTarget)
-                void doResetUsage(resetTarget);
+            if ((input === "y" || input === "Y") && resetTarget) {
+                // A retry of a possibly-sent id must go out to learn its outcome; an
+                // earlier spend may well have moved the next grant.
+                const retrying = resetSession.pendingIds.get(resetTarget)?.maybeSubmitted === true;
+                if (resetOffer && !retrying && (!resetTargetClaudeResets || !sameResetOffer(resetOffer, resetTargetClaudeResets))) {
+                    showBanner("Reset offer changed while you were confirming — press Ctrl+R to review it; nothing sent", "yellow");
+                }
+                else {
+                    void doResetUsage(resetTarget, resetOffer ?? undefined);
+                }
+            }
             else
                 showBanner("Reset cancelled", "gray");
             setResetTarget(null);
+            setResetOffer(null);
             setMode("view");
             return;
         }
@@ -1144,15 +1254,26 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
                 showBanner("Reset already running", "yellow");
                 return;
             }
-            if (selectedAccount.provider !== "openai_subscription") {
-                showBanner("Usage resets are only available for ChatGPT accounts", "yellow");
+            // A pending id means an earlier attempt's outcome is unknown: let the
+            // retry through so the router can deduplicate it under the same id.
+            const pending = resetSession.pendingIds.has(selectedAccount.id);
+            if (isClaudeAccount(selectedAccount)) {
+                const blocker = pending ? undefined : claudeResetBlocker(selectedAccount);
+                if (blocker) {
+                    showBanner(blocker, "yellow");
+                    return;
+                }
+            }
+            else if (selectedAccount.provider !== "openai_subscription") {
+                showBanner("Usage resets are not available for Grok accounts", "yellow");
                 return;
             }
-            if (!resetSession.pendingIds.has(selectedAccount.id) && (selectedAccount.codexRateLimits?.resetCredits?.available ?? 0) <= 0) {
+            else if (!pending && (selectedAccount.codexRateLimits?.resetCredits?.available ?? 0) <= 0) {
                 showBanner("No reset credits available", "yellow");
                 return;
             }
             setResetTarget(selectedAccount.id);
+            setResetOffer(isClaudeAccount(selectedAccount) ? selectedAccount.rateLimits?.usage?.limitResets ?? null : null);
             setMode("confirmReset");
             return;
         }
@@ -1325,7 +1446,9 @@ function LiveDashboard({ data, port, baseUrl, lastUpdate, api, modelsApi, onInte
     });
     const selectedLog = logs[selectedLogIndex] ?? null;
     const visibleLogs = logs.slice(logWindowTop, logWindowTop + logVisible);
-    return (_jsx(Box, { flexDirection: "column", height: frameBound, overflowY: "hidden", children: _jsxs(Box, { flexDirection: "column", flexShrink: 0, ref: contentRef, children: [_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: " CC-Router " }), _jsx(Text, { color: "gray", children: "\u00B7 " }), _jsx(Text, { color: "green", children: data.mode }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsxs(Text, { children: ["up ", formatUptime(data.uptime)] }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsx(Text, { color: "cyan", children: data.totalRequests }), _jsx(Text, { color: "gray", children: " req  " }), _jsx(Text, { color: data.totalErrors > 0 ? "red" : "green", children: data.totalErrors }), _jsx(Text, { color: "gray", children: " err" }), _jsx(CacheHealthBadge, { read: data.totalCacheReadTokens, created: data.totalCacheCreationTokens, input: data.totalInputTokens }), _jsx(Text, { color: "gray", children: "  \u00B7  [q] quit" })] }), mode === "editWeekly" && selectedAccount && (_jsxs(Box, { paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: "Set 7d cap for " }), _jsx(Text, { color: "white", bold: true, children: selectedAccount.id }), _jsx(Text, { color: "cyan", children: " (0\u2013100%): " }), _jsx(Text, { color: "white", bold: true, children: editBuffer }), _jsx(Text, { color: "gray", children: "\u2588  [Enter] save  [Esc] cancel" })] })), mode === "editSession" && selectedAccount && (_jsxs(Box, { paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: "Set 5h cap for " }), _jsx(Text, { color: "white", bold: true, children: selectedAccount.id }), _jsx(Text, { color: "cyan", children: " (0\u2013100%): " }), _jsx(Text, { color: "white", bold: true, children: editBuffer }), _jsx(Text, { color: "gray", children: "\u2588  [Enter] save  [Esc] cancel" })] })), mode === "confirmReset" && resetTarget && (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { color: "yellow", bold: true, children: ["Redeem 1 reset for \"", resetTarget, "\"?  [y] yes  [n/Esc] cancel"] }) })), mode === "confirmDelete" && selectedAccount && (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { color: "red", bold: true, children: ["Delete \"", selectedAccount.id, "\"?  [y] yes  [n/Esc] cancel"] }) })), data.version !== DASHBOARD_VERSION && (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "yellow", children: " \u26A0 VERSION MISMATCH  " }), _jsxs(Text, { color: "yellow", children: [data.version !== undefined
+    return (_jsx(Box, { flexDirection: "column", height: frameBound, overflowY: "hidden", children: _jsxs(Box, { flexDirection: "column", flexShrink: 0, ref: contentRef, children: [_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: " CC-Router " }), _jsx(Text, { color: "gray", children: "\u00B7 " }), _jsx(Text, { color: "green", children: data.mode }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsxs(Text, { children: ["up ", formatUptime(data.uptime)] }), _jsx(Text, { color: "gray", children: "  \u00B7  " }), _jsx(Text, { color: "cyan", children: data.totalRequests }), _jsx(Text, { color: "gray", children: " req  " }), _jsx(Text, { color: data.totalErrors > 0 ? "red" : "green", children: data.totalErrors }), _jsx(Text, { color: "gray", children: " err" }), _jsx(CacheHealthBadge, { read: data.totalCacheReadTokens, created: data.totalCacheCreationTokens, input: data.totalInputTokens }), _jsx(Text, { color: "gray", children: "  \u00B7  [q] quit" })] }), mode === "editWeekly" && selectedAccount && (_jsxs(Box, { paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: "Set 7d cap for " }), _jsx(Text, { color: "white", bold: true, children: selectedAccount.id }), _jsx(Text, { color: "cyan", children: " (0\u2013100%): " }), _jsx(Text, { color: "white", bold: true, children: editBuffer }), _jsx(Text, { color: "gray", children: "\u2588  [Enter] save  [Esc] cancel" })] })), mode === "editSession" && selectedAccount && (_jsxs(Box, { paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: "Set 5h cap for " }), _jsx(Text, { color: "white", bold: true, children: selectedAccount.id }), _jsx(Text, { color: "cyan", children: " (0\u2013100%): " }), _jsx(Text, { color: "white", bold: true, children: editBuffer }), _jsx(Text, { color: "gray", children: "\u2588  [Enter] save  [Esc] cancel" })] })), mode === "confirmReset" && resetTarget && (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: "yellow", bold: true, children: resetOffer
+                                    ? `${claudeResetConfirmText(resetTarget, resetOffer)}  [y] yes  [n/Esc] cancel`
+                                    : `Redeem 1 reset for "${resetTarget}"?  [y] yes  [n/Esc] cancel` }) })), mode === "confirmDelete" && selectedAccount && (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { color: "red", bold: true, children: ["Delete \"", selectedAccount.id, "\"?  [y] yes  [n/Esc] cancel"] }) })), data.version !== DASHBOARD_VERSION && (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "yellow", children: " \u26A0 VERSION MISMATCH  " }), _jsxs(Text, { color: "yellow", children: [data.version !== undefined
                                             ? `daemon v${data.version}`
                                             : "daemon version unreported (older build)", ` · dashboard v${DASHBOARD_VERSION}`] }), LOCAL_TARGET_RE.test(baseUrl) ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: "gray", children: "  \u2014  restart: " }), _jsx(Text, { color: "cyan", children: "cc-router stop --keep-config && cc-router start" })] })) : (
                                 // A remote router can only be restarted where it runs; printing a

package/dist/ui/accountsApi.js

@@ -17,6 +17,29 @@ const REFRESH_ALL_TIMEOUT_MS = 120_000;
 // still lands rather than the dashboard reporting a timeout it caused.
 const REFRESH_ONE_TIMEOUT_MS = 30_000;
 const MAX_PUBLIC_ROWS = 12;
+const OPENAI_RESET_CODES = ["reset", "nothing_to_reset", "no_credit", "already_redeemed"];
+const CLAUDE_RESET_CODES = ["reset", "already_used", "not_limited", "cooldown", "ineligible"];
+// Statuses where the router answered before submitting anything upstream, so
+// its error text is safe and useful to show. Every other status (notably 502,
+// "outcome unknown") stays a bare `HTTP <status>`.
+const NOT_SUBMITTED_STATUSES = new Set([400, 404, 409, 503]);
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** The router refused a redemption before submitting it (its error text is
+ *  the message). Network failures, timeouts and bare `HTTP <status>` errors
+ *  are never this type: their outcome is unknown. */
+export class RouterRefusedResetError extends Error {
+    abandon;
+    pendingRedemption;
+    name = "RouterRefusedResetError";
+    /** The router can never match this redemption id again; start over from fresh usage. */
+    constructor(message, abandon = false, 
+    /** An earlier unresolved redemption id the router wants retried instead. */
+    pendingRedemption) {
+        super(message);
+        this.abandon = abandon;
+        this.pendingRedemption = pendingRedemption;
+    }
+}
 export function createAccountsApi(baseUrl, authToken) {
     const root = baseUrl.replace(/\/+$/, "");
     const base = root + "/cc-router/accounts";
@@ -79,21 +102,46 @@ export function createAccountsApi(baseUrl, authToken) {
                 durationMs: publicInteger(r.durationMs),
             };
         },
-        async resetUsage(id, redeemRequestId) {
+        async resetUsage(id, redeemRequestId, attempt = {}) {
             const response = await fetch(`${base}/${encodeURIComponent(id)}/reset-usage`, {
                 method: "POST",
                 headers: { ...authHeaders, "content-type": "application/json" },
-                body: JSON.stringify({ redeemRequestId }),
+                body: JSON.stringify({ redeemRequestId, retry: attempt.retry === true, ...(attempt.offer ? { offer: attempt.offer } : {}) }),
                 signal: AbortSignal.timeout(REFRESH_ALL_TIMEOUT_MS),
             });
-            if (!response.ok)
-                throw new Error(`HTTP ${response.status}`);
+            if (!response.ok) {
+                const fallback = `HTTP ${response.status}`;
+                if (!NOT_SUBMITTED_STATUSES.has(response.status))
+                    throw new Error(fallback);
+                const errorBody = await response.json().catch(() => undefined);
+                // Only the router's explicit marker proves nothing was sent: a gateway
+                // in between can answer with the same status and an `error` string
+                // after the claim already went out.
+                if (!isRecord(errorBody) || errorBody.notSubmitted !== true)
+                    throw new Error(fallback);
+                const text = publicText(errorBody.error, 160, fallback);
+                if (text === fallback)
+                    throw new Error(fallback);
+                const pending = typeof errorBody.pendingRedemption === "string" && UUID.test(errorBody.pendingRedemption)
+                    ? errorBody.pendingRedemption : undefined;
+                throw new RouterRefusedResetError(text, errorBody.abandon === true, pending);
+            }
             const body = await response.json();
             const reset = isRecord(body) ? body.reset : undefined;
-            if (!isRecord(reset) || typeof reset.code !== "string" || !["reset", "nothing_to_reset", "no_credit", "already_redeemed"].includes(reset.code)
-                || typeof reset.usageRefreshed !== "boolean")
+            if (!isRecord(reset) || typeof reset.code !== "string" || typeof reset.usageRefreshed !== "boolean")
                 throw new Error("Invalid reset response");
-            return { code: reset.code, usageRefreshed: reset.usageRefreshed };
+            // True only when the router re-submitted a request id it had already sent.
+            const replay = reset.replay === true;
+            if (reset.provider === "anthropic" && CLAUDE_RESET_CODES.includes(reset.code)) {
+                return {
+                    provider: "anthropic", code: reset.code, usageRefreshed: reset.usageRefreshed, replay,
+                    ...(typeof reset.resetsLeft === "number" ? { resetsLeft: publicInteger(reset.resetsLeft) } : {}),
+                };
+            }
+            if (reset.provider === "openai" && OPENAI_RESET_CODES.includes(reset.code)) {
+                return { provider: "openai", code: reset.code, usageRefreshed: reset.usageRefreshed, replay };
+            }
+            throw new Error("Invalid reset response");
         },
         patch(id, patch) { return send("PATCH", `/${encodeURIComponent(id)}`, patch); },
         setProviderEnabled(provider, enabled) { return send("PATCH", `/providers/${encodeURIComponent(provider)}`, { enabled }); },

package/dist/ui/usage-chart.js

@@ -71,12 +71,37 @@ export function chartColumns(buckets, width, height, models, legendLimit = 8) {
         const filled = max > 0 ? Math.max(total > 0 ? 1 : 0, Math.round(total / max * rows)) : 0;
         const allocations = legend.map(item => {
             const exact = total > 0 ? (group.values.get(item.key) ?? 0) / total * filled : 0;
-            return { key: item.key, cells: Math.floor(exact), fraction: exact % 1 };
+            return { key: item.key, exact, cells: Math.floor(exact), fraction: exact % 1 };
         });
+        // Height stays tied to the total. Within it every series keeps at least one cell, so a provider
+        // at a few percent of the bucket no longer rounds to nothing and leaves the other one alone;
+        // when series outnumber the cells, the largest contributors get them.
+        const visible = new Set(allocations.filter(a => a.exact > 0).sort((a, b) => b.exact - a.exact).slice(0, filled));
+        for (const a of allocations)
+            if (!visible.has(a))
+                a.fraction = 0;
         let remaining = filled - allocations.reduce((n, a) => n + a.cells, 0);
+        for (const a of visible)
+            if (a.cells === 0) {
+                a.cells = 1;
+                a.fraction = 0;
+                remaining--;
+            }
         for (const a of [...allocations].sort((a, b) => b.fraction - a.fraction)) {
-            if (remaining-- > 0)
+            if (remaining > 0 && a.fraction > 0) {
                 a.cells++;
+                remaining--;
+            }
+        }
+        // Minimum cells may overdraw the column, or dropped fractions underfill it: settle on the largest series.
+        const largest = () => allocations.reduce((a, b) => b.cells > a.cells ? b : a);
+        while (remaining < 0 && largest().cells > 1) {
+            largest().cells--;
+            remaining++;
+        }
+        while (remaining > 0) {
+            largest().cells++;
+            remaining--;
         }
         const stack = allocations.flatMap(a => Array(a.cells).fill(a.key));
         return { label: group.label, total, cells: [...Array(rows - filled).fill(null), ...stack.reverse()] };

package/dist/usage/pricing.js

@@ -4,16 +4,26 @@ import { utcTimestamp } from "./types.js";
  * Verified against these official pages on 2026-09-16. Never prefix-match models.
  * Unknown cache-write duration stays unpriced unless the user supplies a rate. */
 const VERIFIED = "2026-09-16";
+/** Opus 5.5 and the GPT-6 / GPT-5.6 families, verified against the same pages. */
+const VERIFIED_2026_09_24 = "2026-09-24";
 const ANTHROPIC = "https://platform.claude.com/docs/en/about-claude/pricing";
 const OPENAI = "https://developers.openai.com/api/docs/pricing";
-const claude = (model, input, output, cacheRead = input / 10) => ({
+const claude = (model, input, output, cacheRead = input / 10, effectiveDate = VERIFIED) => ({
     provider: "anthropic_subscription", model, input, output, cacheRead,
-    cacheWrite5m: input * 1.25, cacheWrite1h: input * 2, source: ANTHROPIC, effectiveDate: VERIFIED,
+    cacheWrite5m: input * 1.25, cacheWrite1h: input * 2, source: ANTHROPIC, effectiveDate,
 });
-const codex = (model, input, output, source = OPENAI) => ({
-    provider: "openai_subscription", model, input, output, cacheRead: input / 10, source, effectiveDate: VERIFIED,
+const codex = (model, input, output, source = OPENAI, effectiveDate = VERIFIED) => ({
+    provider: "openai_subscription", model, input, output, cacheRead: input / 10, source, effectiveDate,
 });
+const modelPage = (model) => `https://developers.openai.com/api/docs/models/${model}`;
+/** Short-context (<=272K input) rates; longer prompts stay unpriced, see LONG_CONTEXT_272K. */
+const GPT_6_AND_5_6 = [
+    ["gpt-6-astra", 10, 50], ["gpt-6-sol", 2, 10], ["gpt-6-luna", 0.1, 0.5],
+    ["gpt-5.6-sol", 4, 20], ["gpt-5.6-terra", 2, 12], ["gpt-5.6-luna", 0.2, 1.2],
+];
+const LONG_CONTEXT_272K = new Set(["gpt-5.4", "gpt-5.4-2026-03-05", "gpt-5.5", "gpt-5.5-2026-04-23", ...GPT_6_AND_5_6.map(([model]) => model)]);
 const CATALOG = [
+    claude("claude-opus-5-5", 4, 20, 0.2, VERIFIED_2026_09_24),
     ...["claude-fable-5-1", "claude-mythos-5-1"].map(model => claude(model, 10, 50, 0.25)),
     ...["claude-fable-5", "claude-mythos-5"].map(model => claude(model, 10, 50)),
     ...["claude-opus-5", "claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6", "claude-opus-4-5", "claude-opus-4-5-20251101"].map(model => claude(model, 5, 25)),
@@ -27,6 +37,8 @@ const CATALOG = [
     codex("gpt-5.3-codex", 1.75, 14),
     ...["gpt-5.5", "gpt-5.5-2026-04-23"].map(model => codex(model, 5, 30, "https://developers.openai.com/api/docs/models/gpt-5.5")),
     ...["gpt-5.4", "gpt-5.4-2026-03-05"].map(model => codex(model, 2.5, 15, "https://developers.openai.com/api/docs/models/gpt-5.4")),
+    ...GPT_6_AND_5_6.map(([model, input, output]) => codex(model, input, output, modelPage(model), VERIFIED_2026_09_24)),
+    codex("gpt-5.6-cyber", 12.5, 75, OPENAI, VERIFIED_2026_09_24),
 ];
 export function lookupUsageRates(provider, model, inputContext = undefined, overrides = []) {
     const override = overrides.find(rate => rate.provider === provider && rate.model === model);
@@ -34,7 +46,7 @@ export function lookupUsageRates(provider, model, inputContext = undefined, over
     if (!rate)
         return undefined;
     // Never use short-context rates for a prompt that might have tiered pricing.
-    const threshold = provider === "openai_subscription" && ["gpt-5.4", "gpt-5.4-2026-03-05", "gpt-5.5", "gpt-5.5-2026-04-23"].includes(model) ? 272_000
+    const threshold = provider === "openai_subscription" && LONG_CONTEXT_272K.has(model) ? 272_000
         : provider === "anthropic_subscription" && ["claude-sonnet-4-5", "claude-sonnet-4-5-20250929"].includes(model) ? 200_000 : undefined;
     if (inputContext !== undefined && (!Number.isSafeInteger(inputContext) || inputContext < 0))
         return undefined;

package/docs/README.md

@@ -20,7 +20,7 @@ Start with the [README](../README.md) for what CC-Router is and a quickstart.
 |---|---|
 | [Architecture](architecture.md) | The request path and what each component does |
 | [Session routing](session-routing.md) | How an account is picked, failover behaviour, running it for a team |
-| [Dashboard](dashboard.md) | The live TUI, keybindings, model management, ChatGPT usage resets |
+| [Dashboard](dashboard.md) | The live TUI, keybindings, model management, usage resets |
 | [Troubleshooting](troubleshooting.md) | When something doesn't connect |
 
 ## Reference

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timo972/cc-router",
-  "version": "0.13.0-rc.4",
+  "version": "0.13.0-rc.5",
   "description": "Cache-aware session router for Claude Max OAuth tokens — use multiple Claude Max accounts with Claude Code",
   "type": "module",
   "bin": {