tokenmaxxing 1.18.1 → 1.19.0

package/DESIGN.md

@@ -85,6 +85,8 @@ The decision engages at `five_hour >= 80%` (policy.greedySessionFloor): from the
 
 **Model-aware trigger.** Claude subscriptions also enforce **per-model weekly caps** - currently only for Sonnet and Fable (there is no Opus-only quota), and Fable's tighter limit binds *before* the aggregate (e.g. 80% week-Fable at only 50% week-all-models). This cap isn't in statusLine stdin, so when the active model is in `policy.switchModels` we read it from `claude -p '/usage'` (free, 0 tokens, TTL-cached) and add `week(<activeModel>) >= threshold` to the trigger. A Fable session switches on the Fable cap; a Sonnet session rides the aggregate. Both layers apply the per-model gate: a burnt Fable cap screens an account out of a Layer 1 switch, and a Fable cap at the wall screens it out of the Layer 2 squeeze too.
 
+**Banked resets (opt-in).** Both CLIs can reset a hit limit on the same account: Claude Code's `/limit-reset` (the `juniper_tide` server program, claimed by `POST /api/organizations/<org>/reset_rate_limits`, once a week, and the reset window still counts toward the weekly limit; the slash command is interactive-only, so tokenmaxxing makes the claim call itself with the live credential) and Codex's banked reset (`POST .../wham/rate-limit-reset-credits/consume` with an idempotency key; it refreshes the 5h and weekly windows together). `policy.preferToUseBankedReset` (a provider list, default `[]`) makes the hard path spend one before swapping, because a swap cold-starts the per-org prompt cache while a reset keeps the seat. Claude holds between the session rung and the wall only while the account still has weekly room for one more session window at its measured rate (`sessionWindowWeeklyCost`, learned from the tee within one window; unmeasured swaps), claims at the wall, and on `reset` respawns the failed turn in place. Codex rides to the wall while the usage endpoint reports a credit, consumes one, re-samples, and never restarts. Detail: `docs/switching.mdx` §Banked resets, `src/lib/bankedreset.ts`, `src/lib/codexreset.ts`.
+
 ---
 
 ## 6. Honest papercuts

package/README.md

@@ -101,12 +101,13 @@ The **target** is chosen greedily off each account's cached windows: among usabl
     "greedySessionFloor": 80,
     "switchModels": ["fable"],
     "usagePollTtlMs": 90000,
-    "checkIntervalMs": 60000
+    "checkIntervalMs": 60000,
+    "preferToUseBankedReset": []
   }
 }
 ```
 
-`thresholds.session` is a ladder: the bar is the lowest rung some pooled account still clears, so the default `[90]` is one bar, while with `[50, 80, 95]` a seat past 50 hands off while a sibling is under 50, and the bar climbs to 80 and then 95 as the whole pool fills; `projectionMargin` is a fixed safety margin subtracted from each threshold bar (effective bar = threshold - margin), so a large turn is less likely to blow past a bar between checks; `greedySessionFloor` is the session-used % at which the greedy convergence engages; `switchModels` names the models whose per-model cap triggers a switch; `usagePollTtlMs` is how long a `/usage` per-model poll stays fresh; `maxWaitMs` bounds the depleted-pool countdown - a soonest reset further out than this does not pause the session (no respawn marker is written and the session simply keeps hitting its limit until an account recovers); `checkIntervalMs` is the periodic check tick (default 60s), which `init` writes into the timer and which every headroom band is a multiple of, one tick near a bar up to five with plenty of headroom (a depleted wait and the post-swap cooldown sleep to their own deadlines instead) - re-run `tokenmaxxing init` after changing it so the timer unit picks up the new tick.
+`thresholds.session` is a ladder: the bar is the lowest rung some pooled account still clears, so the default `[90]` is one bar, while with `[50, 80, 95]` a seat past 50 hands off while a sibling is under 50, and the bar climbs to 80 and then 95 as the whole pool fills; `projectionMargin` is a fixed safety margin subtracted from each threshold bar (effective bar = threshold - margin), so a large turn is less likely to blow past a bar between checks; `greedySessionFloor` is the session-used % at which the greedy convergence engages; `switchModels` names the models whose per-model cap triggers a switch; `usagePollTtlMs` is how long a `/usage` per-model poll stays fresh; `maxWaitMs` bounds the depleted-pool countdown - a soonest reset further out than this does not pause the session (no respawn marker is written and the session simply keeps hitting its limit until an account recovers); `checkIntervalMs` is the periodic check tick (default 60s), which `init` writes into the timer and which every headroom band is a multiple of, one tick near a bar up to five with plenty of headroom (a depleted wait and the post-swap cooldown sleep to their own deadlines instead) - re-run `tokenmaxxing init` after changing it so the timer unit picks up the new tick; `preferToUseBankedReset` lists the providers (`claude`, `codex`) that spend a banked limit reset (Claude Code's weekly `/limit-reset`, Codex's banked reset) on the same account before swapping, which keeps the prompt cache a swap would cold-start - on Claude the seat holds past the session rung only while the account has weekly room for one more session window at its measured rate, and claims the reset at the wall.
 
 State lives entirely in `~/.config/tokenmaxxing/`. Per-account credentials follow the platform's Claude Code store: the login keychain on macOS (`tokenmaxxing-cred-<uuid8>` items, never plaintext on disk), 0600 files under `~/.config/tokenmaxxing/creds/` on Linux (the same plaintext model claude itself uses for `~/.claude/.credentials.json`).
 
@@ -148,7 +149,7 @@ codex                       # use codex as always
 
 Codex mechanics differ from Claude Code in one hard way: a running codex process refuses a credential swapped to a different account, so **a restart is the switch**. The installed Stop hook runs the same greedy pace-pressure decision at each turn boundary (usage read free from codex's own rate-limit endpoint: percentages plus absolute reset times, weekly aggregate and per-model caps alike); when it swaps, the supervisor relaunches `codex resume <session-id>` on the fresh account with the transcript intact. `tokenmaxxing switch --codex [sel]` does it manually, `status`/`watch`/`ls` show both pools.
 
-Two codex-specific facts worth knowing: codex does not run hooks it has not been told to trust, so after `init --codex` you must open codex once and trust the tokenmaxxing Stop hook via `/hooks` (auto-switching is inert until then); and codex has no cross-process lock on `auth.json`, so tokenmaxxing serializes all of its own credential writes behind its own lock and swaps only at idle turn boundaries.
+Two codex-specific facts worth knowing: codex does not run hooks it has not been told to trust, so after `init --codex` you must open codex once and trust the tokenmaxxing Stop hook via `/hooks` (auto-switching is inert until then); and codex has no cross-process lock on `auth.json`, so tokenmaxxing serializes all of its own credential writes behind its own lock and swaps only at idle turn boundaries. With `codex` in `policy.preferToUseBankedReset`, a seat at its limit consumes a banked reset credit (which refreshes both windows) and keeps running instead of restarting onto another account.
 
 ## Honest limitations
 

package/agent-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "tokenmaxxing",
-  "version": "1.18.1",
+  "version": "1.19.0",
   "description": "Pool Claude Code and Codex logins, switch on pace pressure, and expose safe ops tools to agent clients.",
   "author": {
     "name": "anaclumos",

package/agent-plugin/skills/switching-policy/SKILL.md

@@ -12,6 +12,7 @@ description: Explain and apply tokenmaxxing switch policy (greedy vs hard path,
 - **HARD path**: a screening bar crossed. Swap to best usable target; if none, Layer 2 wall logic (Claude only).
 - **Pace pressure**: remaining weekly percent / time to weekly reset (highest first). Not most-remaining.
 - **Effective bars**: `effectiveBars(cfg, pool)` = the active rung of the 5h ladder (`thresholds.session`, default `[90]`, a single rung: the lowest rung some pooled account, the current one included, still clears) and the weekly bar, each minus `policy.projectionMargin`. Trigger and screening must share these bars or swaps ping-pong. Codex reads `terminalBars(cfg)`, the top rung only. The check cadence is capped one band per rung climbed, and every band is a multiple of the tick `policy.checkIntervalMs` (default 60000).
+- **Banked reset**: opt-in via `policy.preferToUseBankedReset` (a provider list, default `[]`), hard path only. Claude: the seat holds between the session rung and the wall while a reset is believed available and the weekly windows have room for one more measured session window (`sessionWindowWeeklyCost`; unmeasured swaps), claims the `/limit-reset` server call at the wall, and keeps the seat on `reset` (the failed turn is retriggered in place). Codex: rides to the wall while a reset credit exists, consumes one, no restart. The greedy path never resets.
 
 ## Layer 2 (Claude only)
 

package/agent-plugin/skills/switching-policy/references/policy.md

@@ -2,6 +2,7 @@
 
 - `docs/content/docs/switching.mdx`
 - `src/lib/decide.ts`, `src/lib/picker.ts`
+- `src/lib/bankedreset.ts`, `src/lib/codexreset.ts` (banked limit resets)
 - `.memory/switch-policy-pace-pressure.md`
 
-Default screening bars: session ladder [90] (a single rung; add lower rungs such as [50, 80, 95] to hand off earlier) with the active rung resolved per pool, weekly 98. Engagement floor 80. Wall defaults 100. Cooldown 45s on the automatic path after a swap. Check tick `policy.checkIntervalMs` (default 60000, minimum 10000); `init` writes it into the timer unit. Check cadence ceiling per rung: five ticks, three, two, then the one-tick floor, with the headroom bands at the same multiples (40 points sleeps five ticks, 20 three, 8 two, less every tick).
+Default screening bars: session ladder [90] (a single rung; add lower rungs such as [50, 80, 95] to hand off earlier) with the active rung resolved per pool, weekly 98. Engagement floor 80. Wall defaults 100. Cooldown 45s on the automatic path after a swap. Check tick `policy.checkIntervalMs` (default 60000, minimum 10000); `init` writes it into the timer unit. Check cadence ceiling per rung: five ticks, three, two, then the one-tick floor, with the headroom bands at the same multiples (40 points sleeps five ticks, 20 three, 8 two, less every tick). Banked resets off by default (`policy.preferToUseBankedReset: []`); Claude claims once a week per account at the wall, Codex consumes one credit at the wall.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.18.1",
+  "version": "1.19.0",
   "description": "Automatic Claude Code account switching: pool multiple accounts and hot-swap when quota fills, resuming your session on the fresh account.",
   "type": "module",
   "license": "MIT",

package/src/cli/check.ts

@@ -30,6 +30,7 @@ export async function cmdCheck(args: string[] = [], json = false): Promise<numbe
       ok: true,
       due: true,
       swapped: d.swapped,
+      reset: d.reset === true,
       account: d.account?.label ?? null,
       reason: d.reason,
       waitUntil: d.waitUntil ?? null,
@@ -40,6 +41,8 @@ export async function cmdCheck(args: string[] = [], json = false): Promise<numbe
   const next = c.dim(`next in ${Math.round(delayMs / 1000)}s`);
   if (d.swapped && d.account) {
     console.log(`${c.green("↻")} switched to ${c.bold(d.account.label)} ${next}`);
+  } else if (d.reset && d.account) {
+    console.log(`${c.green("↻")} reset the session limit on ${c.bold(d.account.label)} ${next}`);
   } else if (d.waitUntil !== undefined && d.account) {
     console.log(c.yellow(`all accounts at limit - staying on ${c.bold(d.account.label)} (${fmtReset(d.waitUntil)})`) + ` ${next}`);
   } else {

package/src/cli/config.ts

@@ -21,6 +21,7 @@ export const KNOWN_KEYS = [
   "policy.usagePollTtlMs",
   "policy.maxWaitMs",
   "policy.checkIntervalMs",
+  "policy.preferToUseBankedReset",
 ] as const;
 
 const TIMER_REWRITE_NOTE = "note: run `tokenmaxxing init` to rewrite the periodic timer at the new tick";

package/src/cli/status.ts

@@ -12,7 +12,7 @@ import { isCodexExhausted } from "../lib/codexpick.ts";
 import { codexLimitLabel, isSessionWindow } from "../lib/codexusage.ts";
 import { bar, c, claudeTierLabel, count, emitJson, fmtAgo } from "./render.ts";
 import { gatedFamilies, type FullUsage } from "../lib/usage.ts";
-import { ThresholdsSchema, UsageWindowSchema, type Account, type CodexWindow, type Config, type UsageWindow } from "../lib/types.ts";
+import { BankedResetRecordSchema, ThresholdsSchema, UsageWindowSchema, type Account, type CodexWindow, type Config, type UsageWindow } from "../lib/types.ts";
 
 const SampleReportSchema = z.discriminatedUnion("ok", [
   z.object({ ok: z.literal(true), source: z.enum(["statusline", "probe"]) }),
@@ -35,6 +35,9 @@ const ClaudeStatusAccountSchema = z.object({
   pingError: z.string().nullable(),
   pingRejected: z.boolean(),
   pinged: z.boolean(),
+  bankedReset: BankedResetRecordSchema.nullable(),
+  sessionWindowWeeklyCost: z.number().nullable(),
+  sessionWindowFamilyCosts: z.record(z.string(), z.number()).nullable(),
 });
 type ClaudeStatusAccount = z.infer<typeof ClaudeStatusAccountSchema>;
 
@@ -56,6 +59,7 @@ const CodexStatusAccountSchema = z.object({
     .nullable(),
   usageAt: z.number().nullable(),
   sample: SampleReportSchema,
+  resetCredits: z.number().int().nullable(),
 });
 type CodexStatusAccount = z.infer<typeof CodexStatusAccountSchema>;
 
@@ -153,7 +157,8 @@ async function collectClaude(input: { cfg: Config; ping: boolean; pingCount: num
         samples.set(a.accountUuid, { outcome, viaTee });
         if (!outcome.ok) return;
         a.lastUsage = { fiveHour: outcome.usage.session, sevenDay: outcome.usage.weekAll };
-        a.lastUsageAt = viaTee && teeAt != null ? teeAt : Date.now();
+        a.lastUsageAt = viaTee && teeAt != null ? (live?.sampledAt ?? teeAt) : Date.now();
+        if (viaTee && live?.sessionWindowWeeklyCost != null) a.sessionWindowWeeklyCost = live.sessionWindowWeeklyCost;
         if (Object.keys(outcome.usage.perModel).length > 0) {
           a.lastPerModel = outcome.usage.perModel;
           a.lastPerModelAt = viaTee && modelUsage ? (modelUsage.sampledAt ?? modelUsage.ts) : a.lastUsageAt;
@@ -173,6 +178,7 @@ async function collectClaude(input: { cfg: Config; ping: boolean; pingCount: num
   const families = gatedFamilies(loadUsage()?.model ?? null, cfg.policy.switchModels);
   const bars = effectiveBars(cfg, { accounts: idx.accounts, now, switchFamilies: families });
   const liveAccount = readOAuthAccount()?.accountUuid ?? null;
+  const liveModelUsage = loadModelUsage();
   const ordered = sortBy(idx.accounts, [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, now)]);
   const accounts = ordered.map((a): ClaudeStatusAccount => {
     const sampled = samples.get(a.accountUuid) ?? { outcome: { ok: false, reason: "not sampled" }, viaTee: false };
@@ -195,6 +201,9 @@ async function collectClaude(input: { cfg: Config; ping: boolean; pingCount: num
       pingError: sampled.outcome.pingError ?? null,
       pingRejected: sampled.outcome.pingRejected === true,
       pinged: pings.has(a.accountUuid) && sampled.outcome.ok && sampled.outcome.pingError == null && aggregate != null && aggregate.fiveHour.resetsAt == null,
+      bankedReset: a.bankedReset ?? null,
+      sessionWindowWeeklyCost: a.sessionWindowWeeklyCost ?? null,
+      sessionWindowFamilyCosts: liveModelUsage && liveModelUsage.account === a.accountUuid ? (liveModelUsage.familyCosts ?? null) : null,
     };
   });
   return {
@@ -222,7 +231,7 @@ async function collectCodex(input: { cfg: Config; now: number }): Promise<Status
         const outcome = await sampleCodexAccount({ account, liveAccountId: liveId, now });
         outcomes.set(account.accountId, outcome);
         if (outcome.ok) {
-          account.lastUsage = { aggregate: outcome.usage.aggregate, perLimit: outcome.usage.perLimit };
+          account.lastUsage = { aggregate: outcome.usage.aggregate, perLimit: outcome.usage.perLimit, resetCredits: outcome.usage.resetCredits, reachedType: outcome.usage.reachedType };
           account.lastUsageAt = Date.now();
           if (outcome.usage.email != null) account.email = outcome.usage.email;
           if (outcome.usage.planType != null) account.planType = outcome.usage.planType;
@@ -263,6 +272,7 @@ async function collectCodex(input: { cfg: Config; now: number }): Promise<Status
         : null,
       usageAt: account.lastUsageAt ?? null,
       sample: outcome.ok ? { ok: true, source: "probe" } : { ok: false, reason: outcome.reason },
+      resetCredits: usage?.resetCredits ?? null,
     };
   });
   return { bars, accounts };

package/src/entries/codexstophook.ts

@@ -99,6 +99,7 @@ export async function handleCodexStop(input: { rawStdin: string }): Promise<void
     }
     if (await promoteReconcile({ supervisorId, sessionId })) return;
     const decision = await evaluateAndMaybeSwapCodex({});
+    if (decision.reset && decision.account) log("codexstop.reset", { account: decision.account.accountId.slice(0, 8) });
     if (decision.swapped && decision.account) {
       mkdirSync(codexPaths.respawnDir, { recursive: true });
       const payload = CodexRespawnMarkerSchema.parse({

package/src/entries/stopfailurehook.ts

@@ -4,12 +4,13 @@ import { paths } from "../lib/paths.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
 import { readOAuthAccount } from "../lib/claudejson.ts";
 import { enforcedWindowMs, evaluateAndMaybeSwap, postSwapProof, recordEnforcedLimit } from "../lib/decide.ts";
-import { loadConfig, loadLastSwapAt } from "../lib/state.ts";
+import { loadConfig, loadLastSeatChangeAt, loadLastSwapAt } from "../lib/state.ts";
 import { classifyEnforcedLimit, findEnforcedRow, parseErrorBody, readTranscriptTail } from "../lib/usage.ts";
 import { RespawnMarkerSchema, type EnforcedLimit } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
 
 export const RETRIGGER_PROMPT = "Continue where the previous turn left off; it was interrupted by a usage limit and tokenmaxxing switched accounts.";
+export const RETRIGGER_RESET_PROMPT = "Continue where the previous turn left off; it was interrupted by the session limit and tokenmaxxing reset that limit on the same account.";
 
 const StopFailureStdin = z.looseObject({
   session_id: z.uuid().optional().catch(undefined),
@@ -52,11 +53,11 @@ export async function runStopFailureHook(): Promise<number> {
 
     let enforced: EnforcedLimit | null = null;
     if (limit && found && account) {
-      if (postSwapProof({ swapAt: loadLastSwapAt(), launchedAt, errorAt: found.errorAt, now })) {
+      if (postSwapProof({ swapAt: limit.kind === "session" ? loadLastSeatChangeAt() : loadLastSwapAt(), launchedAt, errorAt: found.errorAt, now })) {
         const stamp = await recordEnforcedLimit({ limit, account, now });
         log("stopfailure.enforced", { kind: limit.kind, family: limit.kind === "model" ? limit.family : undefined, outcome: stamp.outcome, resetsAt: stamp.resetsAt, subagent: !mainLoop });
         if (stamp.outcome !== "account-moved") {
-          enforced = { account, family: limit.kind === "model" ? limit.family : null, resetsAt: stamp.resetsAt, windowMs: enforcedWindowMs(limit) };
+          enforced = { account, kind: limit.kind, family: limit.kind === "model" ? limit.family : null, resetsAt: stamp.resetsAt, windowMs: enforcedWindowMs(limit) };
         }
       } else {
         log("stopfailure.unproven", { kind: limit.kind });
@@ -71,18 +72,20 @@ export async function runStopFailureHook(): Promise<number> {
     }
 
     const decision = await evaluateAndMaybeSwap(now, canPause && enforced != null, enforced);
-    if (enforced && canPause && pinnedSid && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
+    const reset = decision.reset === true;
+    if (enforced && canPause && pinnedSid && decision.account && (decision.swapped || decision.waitUntil !== undefined || reset)) {
       const marker = join(paths.respawnDir, pinnedSid);
       const payload = RespawnMarkerSchema.parse({
         account: decision.account.label,
         ts: Date.now(),
         waitUntil: decision.waitUntil ?? now,
         sessionId: stdinSid ?? pinnedSid,
-        prompt: RETRIGGER_PROMPT,
+        prompt: reset ? RETRIGGER_RESET_PROMPT : RETRIGGER_PROMPT,
         ...(launchedAt != null ? { launchedAt } : {}),
+        ...(reset ? { reset } : {}),
       });
       writeFileAtomic(marker, JSON.stringify(payload));
-      log("stopfailure.marker", { session: (stdinSid ?? pinnedSid).slice(0, 8), account: decision.account.accountUuid.slice(0, 8), waitUntil: payload.waitUntil });
+      log("stopfailure.marker", { session: (stdinSid ?? pinnedSid).slice(0, 8), account: decision.account.accountUuid.slice(0, 8), waitUntil: payload.waitUntil, reset });
     } else {
       log("stopfailure.decision", { reason: decision.reason, swapped: decision.swapped, account: decision.account?.accountUuid.slice(0, 8), waitUntil: decision.waitUntil });
     }

package/src/entries/stophook.ts

@@ -25,6 +25,7 @@ export async function runStopHook(): Promise<number> {
   try {
     const canPause = process.env.TOKENMAXXING_SUPERVISED === "1" && pinnedSid != null;
     const decision = await evaluateAndMaybeSwap(Date.now(), canPause);
+    if (decision.reset && decision.account) log("stop.reset", { account: decision.account.accountUuid.slice(0, 8) });
     if (decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
       log(decision.swapped ? "stop.swapped" : "stop.wait", { account: decision.account.accountUuid.slice(0, 8), waitUntil: decision.waitUntil });
       if (decision.waitUntil !== undefined && canPause && pinnedSid) {

package/src/entries/supervisor.ts

@@ -286,7 +286,8 @@ export async function runSupervisor(argv: string[]): Promise<number> {
       respawns++;
       if (m.waitUntil > Date.now()) {
         if (await countdownWait(m.account, m.waitUntil)) overriddenUntil = m.waitUntil;
-      } else process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: switched to ${m.account} - resuming...\x1b[0m\n`);
+      } else if (m.reset) process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: reset the session limit on ${m.account} - resuming...\x1b[0m\n`);
+      else process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: switched to ${m.account} - resuming...\x1b[0m\n`);
       saveSessionFlags(m.sessionId, persistable, process.cwd());
       launchArgs = ["--resume", m.sessionId, ...persistable, ...(m.prompt ? ["--", m.prompt] : [])];
       continue;

package/src/lib/bankedreset.ts

@@ -0,0 +1,234 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import { MAX_WRAP_DEPTH, WRAP_DEPTH_ENV, resolveRealClaude } from "./claudebin.ts";
+import { withClaudeRefreshLock } from "./claudelock.ts";
+import { liveTarget, mergeIntoLive, readItem, writeItem } from "./credstore.ts";
+import { http, safeErrorDetail } from "./http.ts";
+import { log } from "./log.ts";
+import { InvalidGrantError, fetchTokenIdentity, isAccessTokenExpiring, isDeadCredential, refreshCredential } from "./oauth.ts";
+import { clearDepletedWait, clearNextCheck, loadAccounts, loadUsage, saveAccounts, saveLastResetAt, writeUsage } from "./state.ts";
+import { keepRotatedPair } from "./swap.ts";
+import { normalizeResetsAt } from "./usage.ts";
+import { CredentialBlobSchema, type Account, type BankedResetOutcome, type BankedResetRecord, type OAuthCreds } from "./types.ts";
+
+const EnvOverrideSchema = z.string().min(1).optional().catch(undefined);
+const API_BASE_URL = EnvOverrideSchema.parse(process.env.TOKENMAXXING_OAUTH_API_BASE_URL) ?? "https://api.anthropic.com";
+const OAUTH_BETA = "oauth-2025-04-20";
+const RESET_PROGRAM = "juniper_tide";
+const CLAIM_TIMEOUT_MS = 25_000;
+const VERSION_PROBE_TIMEOUT_MS = 5_000;
+const REFRESH_SKEW_MS = 300_000;
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+const INELIGIBLE_TTL_MS = 24 * 60 * 60 * 1000;
+
+const ClaimResponseSchema = z.looseObject({
+  result: z.enum(["reset", "already_used", "not_limited", "ineligible", "unavailable"]).catch("unavailable"),
+  next_available_at: z.union([z.string(), z.number()]).nullable().optional().catch(null),
+});
+
+const ClaimSchema = z.object({ outcome: z.enum(["reset", "pass"]) });
+export type Claim = z.infer<typeof ClaimSchema>["outcome"];
+
+export function bankedResetBelievedAvailable(account: Account, now: number): boolean {
+  const rec = account.bankedReset;
+  if (!rec) return true;
+  if (rec.nextAvailableAt != null) return rec.nextAvailableAt <= now;
+  if (rec.outcome === "reset" || rec.outcome === "already_used") return now - rec.at >= WEEK_MS;
+  if (rec.outcome === "ineligible") return now - rec.at >= INELIGIBLE_TTL_MS;
+  return true;
+}
+
+const VersionSchema = z.string().regex(/^\d+\.\d+\.\d+\S*$/);
+const PackageJsonSchema = z.looseObject({ version: VersionSchema });
+
+function claudeVersion(): string | undefined {
+  const bin = resolveRealClaude();
+  const fromPath = VersionSchema.safeParse(bin.match(/\/versions\/(\d+\.\d+\.\d+[^/]*)$/)?.[1]);
+  if (fromPath.success) return fromPath.data;
+  try {
+    const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync(join(dirname(bin), "package.json"), "utf8")));
+    if (pkg.success) return pkg.data.version;
+  } catch {
+  }
+  try {
+    const r = Bun.spawnSync([bin, "--version"], {
+      env: { ...process.env, TOKENMAXXING_PROBE: "1", [WRAP_DEPTH_ENV]: String(MAX_WRAP_DEPTH) },
+      stdout: "pipe",
+      stderr: "pipe",
+      timeout: VERSION_PROBE_TIMEOUT_MS,
+    });
+    const spawned = VersionSchema.safeParse(r.stdout.toString("utf8").trim().match(/^(\d+\.\d+\.\d+\S*)/)?.[1]);
+    if (spawned.success) return spawned.data;
+  } catch {
+  }
+  return undefined;
+}
+
+function claudeUserAgent(): string {
+  const version = claudeVersion();
+  return version ? `claude-cli/${version} (external, cli)` : "claude-cli (external, cli)";
+}
+
+const LiveTokenSchema = z.discriminatedUnion("ok", [
+  z.object({ ok: z.literal(true), accessToken: z.string(), organizationUuid: z.string() }),
+  z.object({ ok: z.literal(false), outcome: z.enum(["auth_error", "error"]), detail: z.string() }),
+]);
+type LiveToken = z.infer<typeof LiveTokenSchema>;
+
+function liveAccessToken(raw: string | null): string | null {
+  if (raw == null) return null;
+  const parsed = CredentialBlobSchema.safeParse((() => {
+    try { return JSON.parse(raw); } catch { return null; }
+  })());
+  return parsed.success ? parsed.data.claudeAiOauth.accessToken : null;
+}
+
+async function liveTokenLocked(account: Account, lock: { compromised: () => boolean }): Promise<LiveToken> {
+  const raw = await readItem(liveTarget());
+  if (!raw) return { ok: false, outcome: "auth_error", detail: "no live credential" };
+  let creds: OAuthCreds;
+  try {
+    creds = CredentialBlobSchema.parse(JSON.parse(raw)).claudeAiOauth;
+  } catch (e) {
+    return { ok: false, outcome: "error", detail: `live credential blob unreadable (${(e instanceof Error ? e.message : String(e)).slice(0, 80)})` };
+  }
+  if (isDeadCredential(creds)) return { ok: false, outcome: "auth_error", detail: "live credential was cleared after a failed refresh" };
+  if (isAccessTokenExpiring(creds, REFRESH_SKEW_MS)) {
+    let next: OAuthCreds;
+    try {
+      next = await refreshCredential(creds);
+    } catch (e) {
+      const detail = e instanceof Error ? e.message : String(e);
+      return { ok: false, outcome: e instanceof InvalidGrantError ? "auth_error" : "error", detail };
+    }
+    if (lock.compromised()) {
+      let owner: Account | null = null;
+      try {
+        const id = await fetchTokenIdentity(next.accessToken);
+        owner = loadAccounts().accounts.find((a) => a.accountUuid === id.accountUuid) ?? null;
+      } catch {
+      }
+      const kept = await keepRotatedPair({ fresh: next, owner, fallback: account, liveOwnerUuid: account.accountUuid, expectedLiveToken: creds.accessToken, lock });
+      return { ok: false, outcome: "error", detail: `refresh lock compromised mid-refresh - the rotated token ${kept}` };
+    }
+    await writeItem(liveTarget(), mergeIntoLive(raw, next));
+    creds = next;
+  }
+  let identity;
+  try {
+    identity = await fetchTokenIdentity(creds.accessToken);
+  } catch (e) {
+    return { ok: false, outcome: "error", detail: e instanceof Error ? e.message : String(e) };
+  }
+  if (identity.accountUuid !== account.accountUuid) {
+    return { ok: false, outcome: "error", detail: `live credential belongs to account ${identity.accountUuid.slice(0, 8)}, not the seat` };
+  }
+  return { ok: true, accessToken: creds.accessToken, organizationUuid: identity.organizationUuid };
+}
+
+const PostResultSchema = z.object({
+  outcome: z.enum(["reset", "already_used", "not_limited", "ineligible", "unavailable", "rate_limited", "auth_error", "error"]),
+  nextAvailableAt: z.number().nullable(),
+  detail: z.string(),
+  ambiguous: z.boolean().optional(),
+});
+type PostResult = z.infer<typeof PostResultSchema>;
+
+async function postClaim(input: { accessToken: string; organizationUuid: string; userAgent: string }): Promise<PostResult> {
+  const url = `${API_BASE_URL}/api/organizations/${input.organizationUuid}/reset_rate_limits`;
+  let res: Response;
+  try {
+    res = await http.post(url, {
+      headers: {
+        Authorization: `Bearer ${input.accessToken}`,
+        "anthropic-beta": OAUTH_BETA,
+        "Content-Type": "application/json",
+        "User-Agent": input.userAgent,
+      },
+      body: JSON.stringify({ program: RESET_PROGRAM }),
+      timeout: CLAIM_TIMEOUT_MS,
+    });
+  } catch (e) {
+    return { outcome: "error", nextAvailableAt: null, detail: `reset endpoint unreachable: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  let text: string;
+  try {
+    text = await res.text();
+  } catch (e) {
+    return { outcome: "error", nextAvailableAt: null, detail: `reset endpoint answered HTTP ${res.status} but the body could not be read: ${e instanceof Error ? e.message : String(e)}`, ambiguous: true };
+  }
+  if (!res.ok) {
+    const detail = `HTTP ${res.status}: ${safeErrorDetail({ text })}`;
+    if (res.status === 429) return { outcome: "rate_limited", nextAvailableAt: null, detail };
+    if (res.status === 401 || res.status === 403) return { outcome: "auth_error", nextAvailableAt: null, detail };
+    return { outcome: "error", nextAvailableAt: null, detail };
+  }
+  const parsed = ClaimResponseSchema.safeParse((() => {
+    try { return JSON.parse(text); } catch { return null; }
+  })());
+  if (!parsed.success) {
+    return { outcome: "error", nextAvailableAt: null, detail: `reset endpoint answered HTTP ${res.status} with an unrecognized body (${text.length} bytes, withheld)`, ambiguous: true };
+  }
+  return { outcome: parsed.data.result, nextAvailableAt: normalizeResetsAt(parsed.data.next_available_at), detail: parsed.data.result };
+}
+
+function record(accountUuid: string, rec: BankedResetRecord, reset: boolean, now: number): void {
+  const idx = loadAccounts();
+  const account = idx.accounts.find((a) => a.accountUuid === accountUuid);
+  if (!account) return;
+  account.bankedReset = rec;
+  if (reset) {
+    delete account.enforcedUntil;
+    if (account.lastUsage) {
+      account.lastUsage = { ...account.lastUsage, fiveHour: { usedPercentage: 0, resetsAt: null } };
+    }
+  }
+  saveAccounts(idx);
+  if (!reset) return;
+  const u = loadUsage();
+  if (u && u.account === accountUuid) {
+    writeUsage({ ...u, fiveHour: { usedPercentage: 0, resetsAt: null }, ts: now }, { stamp: true });
+  }
+  saveLastResetAt(now);
+  clearDepletedWait();
+  clearNextCheck();
+}
+
+export async function claimBankedReset(input: { account: Account }): Promise<Claim> {
+  const { account } = input;
+  const short = account.accountUuid.slice(0, 8);
+  let result: PostResult;
+  let moved = false;
+  try {
+    const userAgent = claudeUserAgent();
+    ({ result, moved } = await withClaudeRefreshLock(async (lock) => {
+      const token = await liveTokenLocked(account, lock);
+      if (!token.ok) return { result: { outcome: token.outcome, nextAvailableAt: null, detail: token.detail }, moved: false };
+      let posted = await postClaim({ accessToken: token.accessToken, organizationUuid: token.organizationUuid, userAgent });
+      if (posted.ambiguous) {
+        const again = await postClaim({ accessToken: token.accessToken, organizationUuid: token.organizationUuid, userAgent });
+        posted =
+          again.outcome === "already_used"
+            ? { outcome: "reset", nextAvailableAt: again.nextAvailableAt, detail: "already_used on the confirming claim, so the ambiguous claim was the reset", ambiguous: true }
+            : again;
+      }
+      return { result: posted, moved: liveAccessToken(await readItem(liveTarget())) !== token.accessToken };
+    }));
+  } catch (e) {
+    result = { outcome: "error", nextAvailableAt: null, detail: `claim aborted: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  const outcome: BankedResetOutcome = result.outcome;
+  const reset = outcome === "reset";
+  const completedAt = Date.now();
+  record(account.accountUuid, { outcome, at: completedAt, nextAvailableAt: result.nextAvailableAt }, reset, completedAt);
+  log(reset ? "bankedreset.claimed" : "bankedreset.refused", {
+    account: short,
+    outcome,
+    nextAvailableAt: result.nextAvailableAt,
+    moved,
+    ambiguous: result.ambiguous === true ? true : undefined,
+    detail: reset && result.ambiguous !== true ? undefined : result.detail.slice(0, 200),
+  });
+  return reset && !moved ? "reset" : "pass";
+}

package/src/lib/codexdecide.ts

@@ -11,6 +11,7 @@ import { performCodexSwap } from "./codexswap.ts";
 import { CodexInvalidGrantError, refreshCodexAuth } from "./codexoauth.ts";
 import { fetchCodexUsage } from "./codexusage.ts";
 import { codexIdentityOf, isCodexAccessExpiring, readLiveCodexAuth, writeLiveCodexAuth, writeParkedCodexAuth } from "./codexauth.ts";
+import { codexBankedResetVerdict, consumeLiveCodexBankedReset } from "./codexreset.ts";
 import { liveCodexAccountId } from "./codexsample.ts";
 import { livingCodexPresences, presentCodexAccountIds, targetableCodexAccounts } from "./codexpresence.ts";
 import { terminalBars } from "./picker.ts";
@@ -21,6 +22,7 @@ const CodexSwapDecisionSchema = z.object({
   swapped: z.boolean(),
   account: CodexAccountSchema.nullable(),
   reason: z.string(),
+  reset: z.boolean().optional(),
 });
 export type CodexSwapDecision = z.infer<typeof CodexSwapDecisionSchema>;
 
@@ -51,7 +53,7 @@ async function sampleLiveOntoOwner(input: { now: number }): Promise<string | nul
     writeParkedCodexAuth({ credFile: owner.credFile, auth: live });
   }
   const usage = await fetchCodexUsage({ auth: live });
-  owner.lastUsage = { aggregate: usage.aggregate, perLimit: usage.perLimit };
+  owner.lastUsage = { aggregate: usage.aggregate, perLimit: usage.perLimit, resetCredits: usage.resetCredits, reachedType: usage.reachedType };
   owner.lastUsageAt = now;
   if (usage.email != null) owner.email = usage.email;
   if (usage.planType != null) owner.planType = usage.planType;
@@ -137,6 +139,28 @@ export async function evaluateAndMaybeSwapCodex(input: { now?: number }): Promis
       isCodexExhausted({ account: active, thresholds: bars, now });
     if (!engaged) return { swapped: false, account: null, reason: "under-threshold-or-stale" };
 
+    if (cfg.policy.preferToUseBankedReset.includes("codex") && active.needsReauth !== true) {
+      const seat = active;
+      const verdict = codexBankedResetVerdict({ account: seat, thresholds: bars, now, pollTtlMs: cfg.policy.usagePollTtlMs });
+      if (verdict === "hold") {
+        log("codexdecide.banked_reset_hold", { account: seat.accountId.slice(0, 8) });
+        return { swapped: false, account: seat, reason: "banked-reset-hold" };
+      }
+      if (verdict === "claim") {
+        const claim = await consumeLiveCodexBankedReset({ account: seat, now });
+        if (claim === "reset") {
+          try {
+            await sampleLiveOntoOwner({ now: Date.now() });
+          } catch (e) {
+            log("codexdecide.resample_failed", { err: e instanceof Error ? e.message : String(e) });
+          }
+          const fresh = loadCodexAccounts().accounts.find((account) => account.accountId === activeId) ?? seat;
+          if (fresh.lastUsage) postSwapResweep({ liveAccountId: activeId, bars, now });
+          return { swapped: false, account: fresh, reason: "banked-reset", reset: true };
+        }
+      }
+    }
+
     if (!isCodexExhausted({ account: active, thresholds: bars, now })) {
       while (true) {
         const current = loadCodexAccounts();

package/src/lib/codexpick.ts

@@ -3,20 +3,20 @@ import { nextWeeklyReset } from "./picker.ts";
 import { isSessionWindow, weeklyWindowOf } from "./codexusage.ts";
 import type { CodexAccount, CodexWindow, Thresholds } from "./types.ts";
 
-function liveUsed(input: { window: CodexWindow; now: number; sampledAt: number | null }): number {
+export function liveUsed(input: { window: CodexWindow; now: number; sampledAt: number | null }): number {
   const { window, now, sampledAt } = input;
   if (window.resetsAt != null) return window.resetsAt <= now ? 0 : window.usedPercentage;
   if (sampledAt != null && window.windowSeconds != null && now >= sampledAt + window.windowSeconds * 1000) return 0;
   return window.usedPercentage;
 }
 
-function allWindows(account: CodexAccount): CodexWindow[] {
+export function allWindows(account: CodexAccount): CodexWindow[] {
   const usage = account.lastUsage;
   if (!usage) return [];
   return [...usage.aggregate, ...Object.values(usage.perLimit).flat()];
 }
 
-function barFor(input: { window: CodexWindow; thresholds: Thresholds }): number {
+export function barFor(input: { window: CodexWindow; thresholds: Thresholds }): number {
   return isSessionWindow({ window: input.window }) ? input.thresholds.session : input.thresholds.weekly;
 }
 

package/src/lib/codexreset.ts

@@ -0,0 +1,122 @@
+import { z } from "zod";
+import { codexIdentityOf, readLiveCodexAuth } from "./codexauth.ts";
+import { allWindows, barFor, liveUsed } from "./codexpick.ts";
+import { loadCodexAccounts, saveCodexAccounts } from "./codexstate.ts";
+import { http, safeErrorDetail } from "./http.ts";
+import { log } from "./log.ts";
+import type { CodexAccount, CodexAuthJson, CodexBankedResetOutcome, Thresholds } from "./types.ts";
+
+const EnvOverrideSchema = z.string().min(1).optional().catch(undefined);
+const CONSUME_URL =
+  EnvOverrideSchema.parse(process.env.TOKENMAXXING_CODEX_RESET_URL) ?? "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume";
+const CONSUME_TIMEOUT_MS = 30_000;
+const RETRY_KEY_TTL_MS = 10 * 60_000;
+const WALL_PERCENT = 100;
+const LIMIT_REACHED = "rate_limit_reached";
+
+const VerdictSchema = z.enum(["hold", "claim", "pass"]);
+export type CodexBankedVerdict = z.infer<typeof VerdictSchema>;
+const ClaimSchema = z.enum(["reset", "pass"]);
+export type CodexBankedClaim = z.infer<typeof ClaimSchema>;
+
+export function codexBankedResetVerdict(input: { account: CodexAccount; thresholds: Thresholds; now: number; pollTtlMs: number }): CodexBankedVerdict {
+  const { account, thresholds, now, pollTtlMs } = input;
+  const usage = account.lastUsage;
+  if (!usage) return "pass";
+  const credits = usage.resetCredits ?? null;
+  if (credits == null || credits <= 0) return "pass";
+  const rec = account.bankedReset;
+  if (rec != null && rec.outcome !== "reset" && now - rec.at < pollTtlMs) return "pass";
+  const sampledAt = account.lastUsageAt ?? null;
+  const windows = allWindows(account);
+  const over = windows.some((window) => liveUsed({ window, now, sampledAt }) >= barFor({ window, thresholds }));
+  if (!over) return "pass";
+  const atWall = usage.reachedType === LIMIT_REACHED || windows.some((window) => liveUsed({ window, now, sampledAt }) >= WALL_PERCENT);
+  return atWall ? "claim" : "hold";
+}
+
+const ConsumeResponseSchema = z.looseObject({
+  code: z.enum(["reset", "nothing_to_reset", "no_credit", "already_redeemed"]),
+  windows_reset: z.number().int().nullish(),
+});
+
+const ConsumeResultSchema = z.object({ outcome: z.enum(["reset", "nothing_to_reset", "no_credit", "already_redeemed", "auth_error", "error"]), detail: z.string() });
+type ConsumeResult = z.infer<typeof ConsumeResultSchema>;
+
+export async function consumeCodexBankedReset(input: { auth: CodexAuthJson; idempotencyKey: string }): Promise<ConsumeResult> {
+  const { auth, idempotencyKey } = input;
+  const identity = codexIdentityOf({ auth });
+  let res: Response;
+  let text: string;
+  try {
+    res = await http.post(CONSUME_URL, {
+      headers: {
+        Authorization: `Bearer ${auth.tokens.access_token}`,
+        "ChatGPT-Account-Id": identity.accountId,
+        "User-Agent": "codex-cli",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ redeem_request_id: idempotencyKey }),
+      timeout: CONSUME_TIMEOUT_MS,
+    });
+    text = await res.text();
+  } catch (e) {
+    return { outcome: "error", detail: `reset endpoint unreachable: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  if (!res.ok) {
+    const detail = `HTTP ${res.status}: ${safeErrorDetail({ text })}`;
+    if (res.status === 401 || res.status === 403) return { outcome: "auth_error", detail };
+    return { outcome: "error", detail };
+  }
+  const parsed = ConsumeResponseSchema.safeParse((() => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  })());
+  if (!parsed.success) return { outcome: "error", detail: `reset endpoint returned an unrecognized body (${text.length} bytes, withheld)` };
+  return { outcome: parsed.data.code, detail: `${parsed.data.code} (windows reset: ${parsed.data.windows_reset ?? "unknown"})` };
+}
+
+function rememberPendingKey(accountId: string, key: string, now: number): void {
+  const index = loadCodexAccounts();
+  const entry = index.accounts.find((a) => a.accountId === accountId);
+  if (!entry) return;
+  entry.bankedReset = { outcome: "error", at: now, key };
+  saveCodexAccounts({ index });
+}
+
+export async function consumeLiveCodexBankedReset(input: { account: CodexAccount; now: number }): Promise<CodexBankedClaim> {
+  const { account, now } = input;
+  const short = account.accountId.slice(0, 8);
+  const live = readLiveCodexAuth();
+  let result: ConsumeResult;
+  let idempotencyKey: string | null = null;
+  if (!live) {
+    result = { outcome: "auth_error", detail: "live auth.json vanished" };
+  } else if (codexIdentityOf({ auth: live }).accountId !== account.accountId) {
+    result = { outcome: "error", detail: "live codex credential belongs to another account" };
+  } else {
+    const prior = account.bankedReset;
+    const retrying = prior != null && prior.outcome === "error" && prior.key != null && now - prior.at < RETRY_KEY_TTL_MS;
+    idempotencyKey = retrying ? prior.key! : crypto.randomUUID();
+    if (!retrying) rememberPendingKey(account.accountId, idempotencyKey, now);
+    result = await consumeCodexBankedReset({ auth: live, idempotencyKey });
+    if (result.outcome === "already_redeemed" && retrying) result = { outcome: "reset", detail: `${result.detail}; the retried key had already completed` };
+  }
+  const outcome: CodexBankedResetOutcome = result.outcome;
+  const reset = outcome === "reset";
+  const index = loadCodexAccounts();
+  const entry = index.accounts.find((a) => a.accountId === account.accountId);
+  if (entry) {
+    entry.bankedReset = { outcome, at: now, ...(outcome === "error" && idempotencyKey != null ? { key: idempotencyKey } : {}) };
+    if (reset) {
+      delete entry.lastUsage;
+      delete entry.lastUsageAt;
+    }
+    saveCodexAccounts({ index });
+  }
+  log(reset ? "codexreset.consumed" : "codexreset.refused", { account: short, outcome, detail: result.detail.slice(0, 200) });
+  return reset ? "reset" : "pass";
+}

package/src/lib/codexusage.ts

@@ -25,6 +25,8 @@ const WireRateLimitSchema = z.looseObject({
   secondary_window: WireWindowSchema.nullish(),
 });
 
+const WireReachedTypeSchema = z.union([z.string(), z.looseObject({ type: z.string().nullish(), kind: z.string().nullish() })]).nullish().catch(null);
+
 const WireUsageSchema = z.looseObject({
   account_id: z.string(),
   email: z.string().nullish(),
@@ -33,6 +35,8 @@ const WireUsageSchema = z.looseObject({
   additional_rate_limits: z
     .array(z.looseObject({ limit_name: z.string(), rate_limit: WireRateLimitSchema.nullish() }))
     .nullish(),
+  rate_limit_reset_credits: z.looseObject({ available_count: z.number().int().nullish() }).nullish(),
+  rate_limit_reached_type: WireReachedTypeSchema,
 });
 
 function toWindows(rateLimit: z.infer<typeof WireRateLimitSchema> | null | undefined): CodexWindow[] {
@@ -92,6 +96,11 @@ export async function fetchCodexUsage(input: { auth: CodexAuthJson }): Promise<C
     planType: wire.plan_type ?? null,
     aggregate: toWindows(wire.rate_limit),
     perLimit,
+    resetCredits: wire.rate_limit_reset_credits?.available_count ?? null,
+    reachedType:
+      typeof wire.rate_limit_reached_type === "string"
+        ? wire.rate_limit_reached_type
+        : (wire.rate_limit_reached_type?.type ?? wire.rate_limit_reached_type?.kind ?? null),
   });
 }
 

package/src/lib/decide.ts

@@ -2,8 +2,9 @@ import { maxBy } from "es-toolkit";
 import { z } from "zod";
 import { withLock } from "./lock.ts";
 import { paths } from "./paths.ts";
-import { MAX_CHECK_DELAY_TICKS, POST_SWAP_COOLDOWN_MS, maxCheckDelayMs, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsage, loadUsageSnapshot, loadModelUsage, saveAccounts, saveDepletedWait, saveModelUsage, writeUsage } from "./state.ts";
+import { MAX_CHECK_DELAY_TICKS, POST_SWAP_COOLDOWN_MS, maxCheckDelayMs, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsage, loadUsageSnapshot, loadModelUsage, measureFamilyWindow, saveAccounts, saveDepletedWait, saveModelUsage, writeUsage } from "./state.ts";
 import { readOAuthAccount } from "./claudejson.ts";
+import { bankedResetBelievedAvailable, claimBankedReset } from "./bankedreset.ts";
 import { chooseAndSwap, isSkippableSwapError, performSwap } from "./swap.ts";
 import { currentWins, effectiveBars, hardBars, isExhausted, nextWeeklyReset, pickBest, pickEarliestReset, sessionLadder, usableAt } from "./picker.ts";
 import { familyTokens, gatedFamilies, probeUsage, type EnforcedClass } from "./usage.ts";
@@ -15,6 +16,7 @@ const SwapDecisionSchema = z.object({
   account: AccountSchema.nullable(),
   reason: z.string(),
   waitUntil: z.number().optional(),
+  reset: z.boolean().optional(),
 });
 export type SwapDecision = z.infer<typeof SwapDecisionSchema>;
 
@@ -35,6 +37,17 @@ function capForFamily(mu: ModelUsageState, family: string, now: number): UsageWi
   return maxBy(rows, (w) => liveUsed({ window: w, windowMs: WEEK_MS, sampledAt: mu.sampledAt ?? mu.ts, now }));
 }
 
+function familyCaps(perModel: Record<string, UsageWindow>, families: string[]): Record<string, number> {
+  return Object.fromEntries(
+    families.flatMap((family) => {
+      const rows = Object.entries(perModel)
+        .filter(([k]) => familyTokens(k).includes(family))
+        .map(([, w]) => w.usedPercentage);
+      return rows.length > 0 ? [[family, Math.max(...rows)] as const] : [];
+    }),
+  );
+}
+
 function overlayLive(accounts: Account[], u: UsageState | null, mu: ModelUsageState | null, account: string | null): Account[] {
   return accounts.map((a) => {
     if (account == null || a.accountUuid !== account) return a;
@@ -63,6 +76,41 @@ function needsPerModel(u: UsageState | null, cfg: Config): boolean {
   return u != null && gatedFamilies(u.model, cfg.policy.switchModels).length > 0;
 }
 
+const BankedVerdictSchema = z.enum(["hold", "claim", "pass"]);
+type BankedVerdict = z.infer<typeof BankedVerdictSchema>;
+
+function bankedResetVerdict(input: {
+  seat: Account;
+  u: UsageState | null;
+  mu: ModelUsageState | null;
+  enforced: EnforcedLimit | null;
+  cfg: Config;
+  bars: Thresholds;
+  switchFamilies: string[];
+  now: number;
+}): BankedVerdict {
+  const { seat, u, mu, enforced, cfg, bars, switchFamilies, now } = input;
+  if (enforced && enforced.kind !== "session") return "pass";
+  if (!u || u.account !== seat.accountUuid) return "pass";
+  if (!bankedResetBelievedAvailable(seat, now)) return "pass";
+  if (u.sampledAt == null || now - u.sampledAt > cfg.policy.usagePollTtlMs) return "pass";
+  const cost = u.sessionWindowWeeklyCost ?? seat.sessionWindowWeeklyCost;
+  if (cost == null) return "pass";
+  const weeklyUsed = liveUsed({ window: u.sevenDay, windowMs: WEEK_MS, sampledAt: u.ts, now });
+  if (weeklyUsed + cost > bars.weekly) return "pass";
+  const muSame = mu && mu.account === seat.accountUuid && now - (mu.sampledAt ?? mu.ts) <= cfg.policy.usagePollTtlMs ? mu : null;
+  for (const family of switchFamilies) {
+    const cap = muSame ? capForFamily(muSame, family, now) : undefined;
+    if (!cap || !muSame) return "pass";
+    const familyCost = muSame.familyCosts?.[family];
+    if (familyCost == null) return "pass";
+    const capUsed = liveUsed({ window: cap, windowMs: WEEK_MS, sampledAt: muSame.sampledAt ?? muSame.ts, now });
+    if (capUsed + familyCost > bars.weekly) return "pass";
+  }
+  const atWall = enforced?.kind === "session" || liveUsed({ window: u.fiveHour, windowMs: FIVE_HOURS_MS, sampledAt: u.ts, now }) >= hardBars(cfg).session;
+  return atWall ? "claim" : "hold";
+}
+
 function isEngaged(u: UsageState | null, mu: ModelUsageState | null, account: string | null, bars: Thresholds, cfg: Config, now: number): boolean {
   if (!u || !account || u.account !== account) return false;
   return liveUsed({ window: u.fiveHour, windowMs: FIVE_HOURS_MS, sampledAt: u.ts, now }) >= cfg.policy.greedySessionFloor || isOver(u, mu, account, bars, cfg, now);
@@ -98,6 +146,7 @@ async function loadFreshSnapshots(cfg: Config, account: string | null, now: numb
   if (account && !probeAttempted && (!usageFresh(u, uAt, account, ttl, now) || needsPerModel(u, cfg))) {
     const full = await probeUsage();
     const ts = Date.now();
+    const prevMu = mu;
     if (readOAuthAccount()?.accountUuid === account) {
       if (full) {
         const teed = loadUsageSnapshot();
@@ -109,7 +158,7 @@ async function loadFreshSnapshots(cfg: Config, account: string | null, now: numb
           writeUsage(u);
           uAt = ts;
         }
-        mu = { perModel: full.perModel, account, ts, sampledAt: ts };
+        mu = { perModel: full.perModel, account, ts, sampledAt: ts, ...measureFamilyWindow(prevMu, account, full.session, familyCaps(full.perModel, cfg.policy.switchModels)) };
         saveModelUsage(mu);
         const expected = gatedFamilies(u?.model ?? null, cfg.policy.switchModels);
         const rows = Object.keys(full.perModel);
@@ -117,7 +166,7 @@ async function loadFreshSnapshots(cfg: Config, account: string | null, now: numb
           log("usage.no_permodel_row", { families: expected.join(","), rows: rows.join(",") });
         }
       } else {
-        mu = { perModel: mu?.account === account ? (mu?.perModel ?? {}) : {}, account, ts, sampledAt: mu?.account === account ? (mu?.sampledAt ?? mu?.ts) : undefined };
+        mu = { perModel: mu?.account === account ? (mu?.perModel ?? {}) : {}, account, ts, sampledAt: mu?.account === account ? (mu?.sampledAt ?? mu?.ts) : undefined, ...measureFamilyWindow(prevMu, account, null, {}) };
         saveModelUsage(mu);
       }
     }
@@ -171,7 +220,8 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
       let sampled = false;
       if (tee && tee.state.account === account2 && (active.lastUsageAt == null || tee.at >= active.lastUsageAt)) {
         active.lastUsage = { fiveHour: tee.state.fiveHour, sevenDay: tee.state.sevenDay };
-        active.lastUsageAt = tee.at;
+        active.lastUsageAt = tee.state.sampledAt ?? tee.at;
+        if (tee.state.sessionWindowWeeklyCost != null) active.sessionWindowWeeklyCost = tee.state.sessionWindowWeeklyCost;
         sampled = true;
       }
       if (mu2 && mu2.account === account2 && Object.keys(mu2.perModel).length > 0) {
@@ -227,12 +277,26 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
     };
     if (!enforced2 && !isOver(u2, mu2, account2, bars, cfg, now)) return greedy(cfg.policy.greedySwapMargin);
 
+    const resetPreferred = cfg.policy.preferToUseBankedReset.includes("claude");
+    let resetTried = false;
     while (true) {
       const cur = loadAccounts();
       const seat = seatOf(cur);
       const pool = usable(cur.accounts);
       const thresholds = barsOf(cur.accounts);
       if (!enforced2 && seat && !seat.needsReauth && !isExhausted(seat, { now, thresholds, currentAccountUuid: null, switchFamilies })) return greedy(0);
+      if (resetPreferred && !resetTried && seat && !seat.needsReauth) {
+        const verdict = bankedResetVerdict({ seat, u: u2, mu: mu2, enforced: enforced2, cfg, bars: thresholds, switchFamilies, now });
+        if (verdict === "hold") {
+          log("decide.banked_reset_hold", { account: seat.accountUuid.slice(0, 8), enforced: enforced2 != null });
+          return { swapped: false, account: seat, reason: "banked-reset-hold" };
+        }
+        if (verdict === "claim") {
+          resetTried = true;
+          const claim = await claimBankedReset({ account: seat });
+          if (claim === "reset") return { swapped: false, account: seat, reason: "banked-reset", reset: true };
+        }
+      }
       const best = pickBest(pool, { now, thresholds, currentAccountUuid: seat?.accountUuid ?? null, switchFamilies });
       if (!best) break;
       try {
@@ -340,11 +404,12 @@ export async function recordEnforcedLimit(input: { limit: EnforcedClass; account
         account: accountUuid,
         ts: now,
         sampledAt: resetsAt == null ? now : sampledAt ?? now,
+        ...measureFamilyWindow(muSame, accountUuid, null, {}),
       });
       log("usage.enforced_limit", { kind: limit.kind, family: limit.family, resetsAt });
       return { outcome: "stamped", resetsAt };
     }
-    saveModelUsage({ perModel: carriedRows, account: accountUuid, ts: now, sampledAt });
+    saveModelUsage({ perModel: carriedRows, account: accountUuid, ts: now, sampledAt, ...measureFamilyWindow(muSame, accountUuid, null, {}) });
     if (account && limit.resetsAt != null) {
       account.enforcedUntil = limit.resetsAt;
       saveAccounts(idx);
@@ -353,12 +418,14 @@ export async function recordEnforcedLimit(input: { limit: EnforcedClass; account
     if (!carrier) return { outcome: "no-carrier", resetsAt: limit.resetsAt };
     const window: UsageWindow = { usedPercentage: 100, resetsAt: limit.resetsAt };
     writeUsage({
+      ...(priorSame ?? {}),
+      ...(priorSame == null && account?.lastUsageAt != null ? { sampledAt: account.lastUsageAt } : {}),
       fiveHour: limit.kind === "session" ? window : carrier.fiveHour,
       sevenDay: limit.kind === "weekly" ? window : carrier.sevenDay,
       account: accountUuid,
       ts: now,
       model: carrier.model,
-    });
+    }, { stamp: true });
     log("usage.enforced_limit", { kind: limit.kind, resetsAt: limit.resetsAt });
     return { outcome: "stamped", resetsAt: limit.resetsAt };
   });

package/src/lib/paths.ts

@@ -19,6 +19,7 @@ export const paths = {
   usageJson: join(TM_HOME, "usage.json"),
   modelUsageJson: join(TM_HOME, "model-usage.json"),
   lastSwapJson: join(TM_HOME, "lastswap.json"),
+  lastResetJson: join(TM_HOME, "lastreset.json"),
   depletedJson: join(TM_HOME, "depleted.json"),
   nextCheckJson: join(TM_HOME, "nextcheck.json"),
   respawnDir: join(TM_HOME, "respawn"),

package/src/lib/state.ts

@@ -1,10 +1,11 @@
 import { closeSync, existsSync, fstatSync, openSync, readFileSync, rmSync, utimesSync } from "node:fs";
-import { isEqual } from "es-toolkit";
+import { isEqual, uniq } from "es-toolkit";
 import { z } from "zod";
 import { paths, realClaudeBinFromEnv, realCodexBinFromEnv } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
 import {
   AccountsIndexSchema,
+  BankedResetProvidersSchema,
   ConfigSchema,
   LastSwapSchema,
   ModelUsageStateSchema,
@@ -13,8 +14,11 @@ import {
   UsageStateSchema,
   type AccountsIndex,
   type Config,
+  type FamilyAnchor,
   type ModelUsageState,
   type UsageState,
+  type UsageWindow,
+  type WindowAnchor,
 } from "./types.ts";
 
 const DEFAULT_CONFIG: Config = {
@@ -30,6 +34,7 @@ const DEFAULT_CONFIG: Config = {
     usagePollTtlMs: 90_000,
     maxWaitMs: 3_600_000,
     checkIntervalMs: 60_000,
+    preferToUseBankedReset: [],
   },
 };
 
@@ -50,6 +55,7 @@ export const ConfigFileSchema = z
         usagePollTtlMs: z.number().int().positive(),
         maxWaitMs: z.number().int().positive(),
         checkIntervalMs: z.number().int().min(10_000),
+        preferToUseBankedReset: BankedResetProvidersSchema,
       })
       .partial(),
   })
@@ -83,6 +89,9 @@ export function mergeConfigFile(p: z.infer<typeof ConfigFileSchema>): MergeOutco
   if (p.policy?.switchModels) {
     cfg.policy.switchModels = p.policy.switchModels.map((s) => s.toLowerCase());
   }
+  if (p.policy?.preferToUseBankedReset) {
+    cfg.policy.preferToUseBankedReset = uniq(p.policy.preferToUseBankedReset);
+  }
   const envBin = realClaudeBinFromEnv();
   if (envBin) cfg.claudeBin = envBin;
   const envCodexBin = realCodexBinFromEnv();
@@ -187,6 +196,29 @@ export function saveLastSwapAt(ts: number): void {
   writeFileAtomic(paths.lastSwapJson, JSON.stringify(LastSwapSchema.parse({ ts })));
 }
 
+export function loadLastResetAt(): number | null {
+  if (!existsSync(paths.lastResetJson)) return null;
+  let json: unknown;
+  try {
+    json = JSON.parse(readFileSync(paths.lastResetJson, "utf8"));
+  } catch {
+    throw new Error(`${paths.lastResetJson} is corrupt (unparsable JSON) - refusing to treat a damaged reset clock as never-reset; repair or remove the file`);
+  }
+  return LastSwapSchema.parse(json).ts;
+}
+
+export function saveLastResetAt(ts: number): void {
+  writeFileAtomic(paths.lastResetJson, JSON.stringify(LastSwapSchema.parse({ ts })));
+}
+
+export function loadLastSeatChangeAt(): number | null {
+  const swapAt = loadLastSwapAt();
+  const resetAt = loadLastResetAt();
+  if (swapAt == null) return resetAt;
+  if (resetAt == null) return swapAt;
+  return Math.max(swapAt, resetAt);
+}
+
 const DepletedWaitSchema = z.object({ waitUntil: z.number(), accountUuid: z.string(), ts: z.number() });
 export type DepletedWait = z.infer<typeof DepletedWaitSchema>;
 
@@ -237,10 +269,68 @@ export function clearNextCheck(): void {
 }
 
 const USAGE_TS_REFRESH_MS = 10 * 60_000;
+const SAMPLED_AT_REFRESH_MS = 30_000;
+const SESSION_COST_MIN_DELTA = 25;
+
+function anchorHolds(anchor: WindowAnchor, next: UsageState): boolean {
+  return (
+    anchor.fiveHourResetsAt === next.fiveHour.resetsAt &&
+    anchor.sevenDayResetsAt === next.sevenDay.resetsAt &&
+    next.fiveHour.usedPercentage >= anchor.session &&
+    next.sevenDay.usedPercentage >= anchor.weekly
+  );
+}
+
+export function measureSessionWindow(prev: UsageState | null, next: UsageState, stamp: boolean): Pick<UsageState, "anchor" | "sessionWindowWeeklyCost"> {
+  const same = prev != null && prev.account === next.account;
+  const carried = same ? prev.sessionWindowWeeklyCost : undefined;
+  if (stamp) return { ...(same && prev.anchor ? { anchor: prev.anchor } : {}), ...(carried != null ? { sessionWindowWeeklyCost: carried } : {}) };
+  const anchor: WindowAnchor =
+    same && prev.anchor && anchorHolds(prev.anchor, next)
+      ? prev.anchor
+      : { fiveHourResetsAt: next.fiveHour.resetsAt, sevenDayResetsAt: next.sevenDay.resetsAt, session: next.fiveHour.usedPercentage, weekly: next.sevenDay.usedPercentage };
+  const sessionDelta = next.fiveHour.usedPercentage - anchor.session;
+  const weeklyDelta = next.sevenDay.usedPercentage - anchor.weekly;
+  const measured = sessionDelta >= SESSION_COST_MIN_DELTA && weeklyDelta > 0 ? (100 * weeklyDelta) / sessionDelta : undefined;
+  const cost = measured ?? carried;
+  return { anchor, ...(cost != null ? { sessionWindowWeeklyCost: cost } : {}) };
+}
+
+function familyAnchorHolds(anchor: FamilyAnchor, session: UsageWindow, caps: Record<string, number>): boolean {
+  return (
+    anchor.fiveHourResetsAt === session.resetsAt &&
+    session.usedPercentage >= anchor.session &&
+    Object.entries(caps).every(([family, used]) => anchor.caps[family] == null || used >= anchor.caps[family])
+  );
+}
+
+export function measureFamilyWindow(prev: ModelUsageState | null, account: string | null, session: UsageWindow | null, caps: Record<string, number>): Pick<ModelUsageState, "anchor" | "familyCosts"> {
+  const same = prev != null && prev.account === account;
+  const carried = same ? prev.familyCosts : undefined;
+  if (session == null) return { ...(same && prev.anchor ? { anchor: prev.anchor } : {}), ...(carried != null ? { familyCosts: carried } : {}) };
+  const held = same && prev.anchor && familyAnchorHolds(prev.anchor, session, caps) ? prev.anchor : null;
+  const anchor: FamilyAnchor = held ? { ...held, caps: { ...caps, ...held.caps } } : { fiveHourResetsAt: session.resetsAt, session: session.usedPercentage, caps };
+  const sessionDelta = session.usedPercentage - anchor.session;
+  const measured = Object.entries(caps).flatMap(([family, used]) => {
+    const capDelta = used - (anchor.caps[family] ?? used);
+    return sessionDelta >= SESSION_COST_MIN_DELTA && capDelta > 0 ? [[family, (100 * capDelta) / sessionDelta] as const] : [];
+  });
+  const familyCosts = { ...carried, ...Object.fromEntries(measured) };
+  return { anchor, ...(Object.keys(familyCosts).length > 0 ? { familyCosts } : {}) };
+}
 
-export function writeUsage(next: UsageState): boolean {
+export function writeUsage(input: UsageState, opts: { stamp?: boolean } = {}): boolean {
   const prev = loadUsage();
-  if (prev && isEqual({ ...prev, ts: 0 }, { ...next, ts: 0 }) && next.ts - prev.ts < USAGE_TS_REFRESH_MS) {
+  const stamp = opts.stamp === true;
+  const carriedSampleAt = prev != null && prev.account === input.account ? (prev.sampledAt ?? prev.ts) : undefined;
+  const sampledAt = stamp ? (carriedSampleAt ?? input.sampledAt) : input.ts;
+  const next: UsageState = { ...input, ...measureSessionWindow(prev, input, stamp), ...(sampledAt != null ? { sampledAt } : {}) };
+  if (
+    prev &&
+    isEqual({ ...prev, ts: 0, sampledAt: 0 }, { ...next, ts: 0, sampledAt: 0 }) &&
+    next.ts - prev.ts < USAGE_TS_REFRESH_MS &&
+    (stamp || next.ts - (prev.sampledAt ?? prev.ts) < SAMPLED_AT_REFRESH_MS)
+  ) {
     try {
       utimesSync(paths.usageJson, new Date(next.ts), new Date(next.ts));
     } catch (e) {

package/src/lib/types.ts

@@ -41,21 +41,51 @@ export type UsageWindows = z.infer<typeof UsageWindowsSchema>;
 const ModelInfoSchema = z.object({ id: z.string(), display: z.string() });
 export type ModelInfo = z.infer<typeof ModelInfoSchema>;
 
+const WindowAnchorSchema = z.object({
+  fiveHourResetsAt: z.number().nullable(),
+  sevenDayResetsAt: z.number().nullable(),
+  session: z.number(),
+  weekly: z.number(),
+});
+export type WindowAnchor = z.infer<typeof WindowAnchorSchema>;
+
 export const UsageStateSchema = UsageWindowsSchema.extend({
   account: z.string().nullable(),
   ts: z.number(),
   model: ModelInfoSchema.nullable().default(null),
+  anchor: WindowAnchorSchema.optional(),
+  sessionWindowWeeklyCost: z.number().positive().optional(),
+  sampledAt: z.number().optional(),
 });
 export type UsageState = z.infer<typeof UsageStateSchema>;
 
+const FamilyAnchorSchema = z.object({
+  fiveHourResetsAt: z.number().nullable(),
+  session: z.number(),
+  caps: z.record(z.string(), z.number()),
+});
+export type FamilyAnchor = z.infer<typeof FamilyAnchorSchema>;
+
 export const ModelUsageStateSchema = z.object({
   perModel: z.record(z.string(), UsageWindowSchema).default({}),
   account: z.string().nullable(),
   ts: z.number(),
   sampledAt: z.number().optional(),
+  anchor: FamilyAnchorSchema.optional(),
+  familyCosts: z.record(z.string(), z.number()).optional(),
 });
 export type ModelUsageState = z.infer<typeof ModelUsageStateSchema>;
 
+export const BankedResetOutcomeSchema = z.enum(["reset", "already_used", "not_limited", "ineligible", "unavailable", "rate_limited", "auth_error", "error"]);
+export type BankedResetOutcome = z.infer<typeof BankedResetOutcomeSchema>;
+
+export const BankedResetRecordSchema = z.object({
+  outcome: BankedResetOutcomeSchema,
+  at: z.number(),
+  nextAvailableAt: z.number().nullable(),
+});
+export type BankedResetRecord = z.infer<typeof BankedResetRecordSchema>;
+
 export const AccountSchema = z.object({
   accountUuid: z.string(),
   email: z.string(),
@@ -72,6 +102,8 @@ export const AccountSchema = z.object({
   needsReauth: z.boolean().optional(),
   subscriptionType: z.string().optional(),
   rateLimitTier: z.string().optional(),
+  sessionWindowWeeklyCost: z.number().positive().optional(),
+  bankedReset: BankedResetRecordSchema.optional(),
 });
 export type Account = z.infer<typeof AccountSchema>;
 
@@ -88,6 +120,7 @@ export const NextCheckSchema = z.object({ dueAt: z.number(), ts: z.number() });
 
 export const EnforcedLimitSchema = z.object({
   account: z.string(),
+  kind: z.enum(["session", "weekly", "model"]),
   family: z.string().nullable(),
   resetsAt: z.number().nullable(),
   windowMs: z.number(),
@@ -112,6 +145,10 @@ export const ScreeningThresholdsSchema = z.object({
   weekly: z.number().min(0).max(100),
 });
 
+export const BankedResetProviderSchema = z.enum(["claude", "codex"]);
+export type BankedResetProvider = z.infer<typeof BankedResetProviderSchema>;
+export const BankedResetProvidersSchema = z.array(BankedResetProviderSchema);
+
 export const ConfigSchema = z
   .object({
     thresholds: ScreeningThresholdsSchema,
@@ -126,6 +163,7 @@ export const ConfigSchema = z
       usagePollTtlMs: z.number().int().positive(),
       maxWaitMs: z.number().int().positive(),
       checkIntervalMs: z.number().int().min(10_000),
+      preferToUseBankedReset: BankedResetProvidersSchema,
     }),
   })
   .refine((cfg) => cfg.policy.projectionMargin < Math.min(...cfg.thresholds.session, cfg.thresholds.weekly), {
@@ -143,6 +181,7 @@ export const RespawnMarkerSchema = z.object({
   sessionId: z.string(),
   prompt: z.string().optional(),
   launchedAt: z.number().optional(),
+  reset: z.boolean().optional(),
 });
 
 export const RateLimitsStdinSchema = z.looseObject({
@@ -242,9 +281,21 @@ export const CodexUsageSchema = z.object({
   planType: z.string().nullable(),
   aggregate: z.array(CodexWindowSchema),
   perLimit: z.record(z.string(), z.array(CodexWindowSchema)),
+  resetCredits: z.number().int().nullable(),
+  reachedType: z.string().nullable(),
 });
 export type CodexUsage = z.infer<typeof CodexUsageSchema>;
 
+export const CodexBankedResetOutcomeSchema = z.enum(["reset", "nothing_to_reset", "no_credit", "already_redeemed", "auth_error", "error"]);
+export type CodexBankedResetOutcome = z.infer<typeof CodexBankedResetOutcomeSchema>;
+
+export const CodexBankedResetRecordSchema = z.object({
+  outcome: CodexBankedResetOutcomeSchema,
+  at: z.number(),
+  key: z.string().optional(),
+});
+export type CodexBankedResetRecord = z.infer<typeof CodexBankedResetRecordSchema>;
+
 const BareFileNameSchema = z
   .string()
   .refine((s) => s.length > 0 && s !== "." && s !== ".." && !s.includes("/") && !s.includes("\\"), {
@@ -263,9 +314,12 @@ export const CodexAccountSchema = z.object({
     .object({
       aggregate: z.array(CodexWindowSchema),
       perLimit: z.record(z.string(), z.array(CodexWindowSchema)),
+      resetCredits: z.number().int().nullable().optional(),
+      reachedType: z.string().nullable().optional(),
     })
     .optional(),
   lastUsageAt: z.number().optional(),
+  bankedReset: CodexBankedResetRecordSchema.optional(),
 });
 export type CodexAccount = z.infer<typeof CodexAccountSchema>;