tokenmaxxing 1.18.0 → 1.19.0

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) {
@@ -209,7 +259,7 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
         const cur = loadAccounts();
         const active = seatOf(cur);
         const pool = usable(cur.accounts);
-        const ctxAll = { now, thresholds: barsOf(pool), currentAccountUuid: null, switchFamilies, holdMargin };
+        const ctxAll = { now, thresholds: barsOf(cur.accounts), currentAccountUuid: null, switchFamilies, holdMargin };
         if (currentWins(active, pool, ctxAll)) {
           return { swapped: false, account: null, reason: "current-best" };
         }
@@ -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(pool);
+      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 };
   });