tokenmaxxing 1.19.1 → 1.21.0

package/src/lib/types.ts

@@ -41,51 +41,22 @@ 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(),
@@ -102,8 +73,6 @@ 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>;
 
@@ -120,7 +89,6 @@ 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(),
@@ -145,10 +113,6 @@ 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,
@@ -163,7 +127,6 @@ 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), {
@@ -181,7 +144,6 @@ 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({
@@ -281,21 +243,9 @@ 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("\\"), {
@@ -314,12 +264,9 @@ 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>;
 

package/src/lib/usage.ts

@@ -286,9 +286,14 @@ async function spawnClaudeBounded(
   cmd: string[],
   env: Record<string, string>,
   cwd?: string,
+  killMs = PROBE_KILL_MS,
+  signal?: AbortSignal,
 ): Promise<SpawnResult | null> {
+  signal?.throwIfAborted();
   const p = Bun.spawn(cmd, { env, cwd, stdout: "pipe", stderr: "pipe" });
-  const killer = setTimeout(() => p.kill("SIGKILL"), PROBE_KILL_MS);
+  const abort = () => p.kill("SIGKILL");
+  signal?.addEventListener("abort", abort, { once: true });
+  const killer = setTimeout(() => p.kill("SIGKILL"), killMs);
   try {
     const reads = Promise.all([new Response(p.stdout).text(), new Response(p.stderr).text()]);
     const settled = await Promise.race([
@@ -301,13 +306,14 @@ async function spawnClaudeBounded(
     return { exitCode: p.exitCode, stdout, stderr };
   } finally {
     clearTimeout(killer);
+    signal?.removeEventListener("abort", abort);
   }
 }
 
-async function probeUsageOnce(env: Record<string, string>, now: number): Promise<FullUsage | null> {
+async function probeUsageOnce(env: Record<string, string>, now: number, killMs: number, signal?: AbortSignal): Promise<FullUsage | null> {
   let out: string;
   try {
-    const r = await spawnClaudeBounded([resolveRealClaude(), "-p", "/usage", "--output-format", "json"], env);
+    const r = await spawnClaudeBounded([resolveRealClaude(), "-p", "/usage", "--output-format", "json"], env, undefined, killMs, signal);
     if (r === null) {
       log("usage.probe_failed", { err: "output pipes still open after child exit (leaked descendant)" });
       return null;
@@ -345,17 +351,17 @@ function probeEnv(configDir?: string): Record<string, string> {
   return env;
 }
 
-export async function probeUsage(configDir?: string, now = Date.now()): Promise<FullUsage | null> {
+export async function probeUsage(configDir?: string, now = Date.now(), opts: { retries?: number; killMs?: number; signal?: AbortSignal } = {}): Promise<FullUsage | null> {
   const env = probeEnv(configDir);
 
   for (let attempt = 0; ; attempt++) {
-    const full = await probeUsageOnce(env, now);
+    const full = await probeUsageOnce(env, now, opts.killMs ?? PROBE_KILL_MS, opts.signal);
     if (full) return full;
-    if (attempt >= PROBE_RETRY_DELAYS_MS.length) {
+    if (attempt >= (opts.retries ?? PROBE_RETRY_DELAYS_MS.length) || opts.signal?.aborted) {
       log("usage.probe_gave_up", { attempts: attempt + 1 });
       return null;
     }
-    await delay(PROBE_RETRY_DELAYS_MS[attempt]!);
+    await delay(PROBE_RETRY_DELAYS_MS[Math.min(attempt, PROBE_RETRY_DELAYS_MS.length - 1)]!);
   }
 }
 

package/src/lib/bankedreset.ts

@@ -1,234 +0,0 @@
-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/codexreset.ts

@@ -1,122 +0,0 @@
-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";
-}