tokenmaxxing 1.19.1 → 1.21.0

package/src/lib/decide.ts

@@ -2,11 +2,11 @@ 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, measureFamilyWindow, saveAccounts, saveDepletedWait, saveModelUsage, writeUsage } from "./state.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 { 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 { chooseAndSwap, isSkippableSwapError, performSwap, type VerifyVerdict } from "./swap.ts";
+import { probeParkedUsage } from "./sample.ts";
+import { currentWins, effectiveBars, hardBars, isExhausted, nextWeeklyReset, pickBest, pickEarliestReset, sessionLadder, usableAt, type PickCtx } from "./picker.ts";
 import { familyTokens, gatedFamilies, probeUsage, type EnforcedClass } from "./usage.ts";
 import { log } from "./log.ts";
 import { AccountSchema, ModelUsageStateSchema, UsageStateSchema, type Account, type Config, type EnforcedLimit, type ModelUsageState, type Thresholds, type UsageState, type UsageWindow } from "./types.ts";
@@ -16,12 +16,13 @@ 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>;
 
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 const FIVE_HOURS_MS = 5 * 60 * 60 * 1000;
+const VERIFY_PROBE_BUDGET = 2;
+const VERIFY_PROBE_KILL_MS = 12_000;
 
 function liveUsed(input: { window: UsageWindow; windowMs: number; sampledAt: number; now: number }): number {
   const { window: w, windowMs, sampledAt, now } = input;
@@ -37,17 +38,6 @@ 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;
@@ -76,41 +66,6 @@ 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);
@@ -146,7 +101,6 @@ 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();
@@ -158,7 +112,7 @@ async function loadFreshSnapshots(cfg: Config, account: string | null, now: numb
           writeUsage(u);
           uAt = ts;
         }
-        mu = { perModel: full.perModel, account, ts, sampledAt: ts, ...measureFamilyWindow(prevMu, account, full.session, familyCaps(full.perModel, cfg.policy.switchModels)) };
+        mu = { perModel: full.perModel, account, ts, sampledAt: ts };
         saveModelUsage(mu);
         const expected = gatedFamilies(u?.model ?? null, cfg.policy.switchModels);
         const rows = Object.keys(full.perModel);
@@ -166,7 +120,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, ...measureFamilyWindow(prevMu, account, null, {}) };
+        mu = { perModel: mu?.account === account ? (mu?.perModel ?? {}) : {}, account, ts, sampledAt: mu?.account === account ? (mu?.sampledAt ?? mu?.ts) : undefined };
         saveModelUsage(mu);
       }
     }
@@ -221,7 +175,6 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
       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.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) {
@@ -253,18 +206,60 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
       rejected.add(candidate.accountUuid);
       log("decide.candidate_rejected", { account: candidate.accountUuid.slice(0, 8), error: e instanceof Error ? e.message : String(e) });
     };
+    let probeBudget = VERIFY_PROBE_BUDGET;
+    const verified = async (candidate: Account, ctx: PickCtx): Promise<VerifyVerdict> => {
+      if (candidate.lastUsageAt != null && now - candidate.lastUsageAt <= cfg.policy.usagePollTtlMs) return "go";
+      const short = candidate.accountUuid.slice(0, 8);
+      const idx2 = loadAccounts();
+      const stored = idx2.accounts.find((a) => a.accountUuid === candidate.accountUuid);
+      if (!stored) return "go";
+      if (probeBudget <= 0) {
+        log("decide.verify_budget_spent", { account: short });
+        return "go";
+      }
+      probeBudget -= 1;
+      const sample = await probeParkedUsage(stored, { retries: 0, refreshParked: false, killMs: VERIFY_PROBE_KILL_MS, signal: AbortSignal.timeout(VERIFY_PROBE_KILL_MS) });
+      if (sample.ok) {
+        const at = Date.now();
+        stored.lastUsage = { fiveHour: sample.usage.session, sevenDay: sample.usage.weekAll };
+        stored.lastUsageAt = at;
+        if (Object.keys(sample.usage.perModel).length > 0) {
+          stored.lastPerModel = sample.usage.perModel;
+          stored.lastPerModelAt = at;
+        }
+      }
+      if (sample.ok || stored.needsReauth === true) saveAccounts(idx2);
+      if (stored.needsReauth === true) {
+        rejected.add(candidate.accountUuid);
+        log("decide.candidate_rejected", { account: short, error: "needs reauth" });
+        return "skip";
+      }
+      if (!sample.ok) {
+        log("decide.candidate_unverified", { account: short });
+        return "go";
+      }
+      log(isExhausted(stored, ctx) ? "decide.candidate_walled" : "decide.candidate_verified", {
+        account: short,
+        session: sample.usage.session.usedPercentage,
+        weekly: sample.usage.weekAll.usedPercentage,
+      });
+      return "rerank";
+    };
 
     const greedy = async (holdMargin: number): Promise<SwapDecision> => {
       while (true) {
         const cur = loadAccounts();
         const active = seatOf(cur);
-        const pool = usable(cur.accounts);
-        const ctxAll = { now, thresholds: barsOf(cur.accounts), currentAccountUuid: null, switchFamilies, holdMargin };
+        const ctxAll = { now, thresholds: barsOf(cur.accounts), currentAccountUuid: null, currentOrganizationUuid: active?.organizationUuid ?? null, orgAffinityFloor: cfg.policy.greedySessionFloor, switchFamilies, holdMargin };
+        const seatOrg = active != null && !active.needsReauth && !isExhausted(active, ctxAll) ? active.organizationUuid : null;
+        const pool = usable(cur.accounts).filter((a) => seatOrg == null || a.organizationUuid === seatOrg);
         if (currentWins(active, pool, ctxAll)) {
           return { swapped: false, account: null, reason: "current-best" };
         }
-        const best = pickBest(pool, { ...ctxAll, currentAccountUuid: active?.accountUuid ?? null });
+        const ctx = { ...ctxAll, currentAccountUuid: active?.accountUuid ?? null };
+        const best = pickBest(pool, ctx);
         if (!best) return { swapped: false, account: null, reason: "no-usable-target" };
+        if ((await verified(best, ctx)) !== "go") continue;
         try {
           await performSwap(best);
         } catch (e) {
@@ -277,34 +272,23 @@ 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 });
+      const ctx = { now, thresholds, currentAccountUuid: seat?.accountUuid ?? null, currentOrganizationUuid: seat?.organizationUuid ?? null, orgAffinityFloor: cfg.policy.greedySessionFloor, switchFamilies };
+      const best = pickBest(pool, ctx);
       if (!best) break;
+      if ((await verified(best, ctx)) !== "go") continue;
       try {
         await performSwap(best);
       } catch (e) {
         skipOrThrow(e, best);
         continue;
       }
+      log("decide.hard_swap", { account: best.accountUuid.slice(0, 8), enforced: enforced2 != null });
       return { swapped: true, account: best, reason: "swapped" };
     }
 
@@ -314,7 +298,7 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
       log("decide.last_drop_hold", { account: seat.accountUuid.slice(0, 8) });
       return { swapped: false, account: null, reason: "last-drop-hold" };
     }
-    const squeezed = await chooseAndSwap({ ...hardCtx, currentAccountUuid: seat?.accountUuid ?? null }, rejected);
+    const squeezed = await chooseAndSwap({ ...hardCtx, currentAccountUuid: seat?.accountUuid ?? null, currentOrganizationUuid: seat?.organizationUuid ?? null, orgAffinityFloor: cfg.policy.greedySessionFloor }, rejected, verified);
     if (squeezed) {
       log("decide.last_drop_swap", { account: squeezed.accountUuid.slice(0, 8) });
       return { swapped: true, account: squeezed, reason: "last-drop-swap" };
@@ -404,12 +388,11 @@ 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, ...measureFamilyWindow(muSame, accountUuid, null, {}) });
+    saveModelUsage({ perModel: carriedRows, account: accountUuid, ts: now, sampledAt });
     if (account && limit.resetsAt != null) {
       account.enforcedUntil = limit.resetsAt;
       saveAccounts(idx);

package/src/lib/oauth.ts

@@ -94,11 +94,12 @@ export function isAccessTokenExpiring(creds: OAuthCreds, skewMs = 120_000, now =
   return !creds.expiresAt || creds.expiresAt - now <= skewMs;
 }
 
-export async function fetchTokenIdentity(accessToken: string): Promise<TokenIdentity> {
+export async function fetchTokenIdentity(accessToken: string, signal?: AbortSignal): Promise<TokenIdentity> {
   let res: Response;
   try {
     res = await http.get(PROFILE_URL, {
       headers: { Authorization: `Bearer ${accessToken}`, "Content-Type": "application/json" },
+      signal,
     });
   } catch (e) {
     throw new IdentityUnavailableError(null, e instanceof Error ? e.message : String(e));

package/src/lib/paths.ts

@@ -19,7 +19,6 @@ 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/picker.ts

@@ -34,6 +34,8 @@ const PickCtxSchema = z.object({
   now: z.number(),
   thresholds: ThresholdsSchema,
   currentAccountUuid: z.string().nullable(),
+  currentOrganizationUuid: z.string().nullable().optional(),
+  orgAffinityFloor: z.number().optional(),
   switchFamilies: z.array(z.string()),
   holdMargin: z.number().min(0).optional(),
 });
@@ -94,9 +96,27 @@ export function pacePressure(a: Account, now: number): number {
   return Math.max(0, 100 - used) / Math.max(1, reset - now);
 }
 
-const swapPreference = (now: number) => [
-  (a: Account) => -pacePressure(a, now),
-  (a: Account) => weeklyExpiry(a, now),
+function sessionUsed(a: Account, now: number): number {
+  const w = a.lastUsage?.fiveHour;
+  if (w == null) return 101;
+  if (w.resetsAt != null) return w.resetsAt <= now ? 0 : w.usedPercentage;
+  if (a.lastUsageAt != null && now >= a.lastUsageAt + FIVE_HOURS_MS) return 0;
+  return w.usedPercentage;
+}
+
+function orgTier(a: Account, ctx: PickCtx): number {
+  if (ctx.currentOrganizationUuid == null || a.organizationUuid !== ctx.currentOrganizationUuid) return 1;
+  if (ctx.orgAffinityFloor != null && sessionUsed(a, ctx.now) >= ctx.orgAffinityFloor) return 1;
+  if (!a.lastUsage || ctx.switchFamilies.some((family) => gatedPerModelWindows(a, [family]).length === 0)) return 1;
+  const headroom = Math.max(1, ctx.thresholds.session - (ctx.orgAffinityFloor ?? ctx.thresholds.session));
+  if (isExhausted(a, { ...ctx, thresholds: { session: ctx.thresholds.session - headroom, weekly: ctx.thresholds.weekly - headroom } })) return 1;
+  return 0;
+}
+
+const swapPreference = (ctx: PickCtx) => [
+  (a: Account) => orgTier(a, ctx),
+  (a: Account) => -pacePressure(a, ctx.now),
+  (a: Account) => weeklyExpiry(a, ctx.now),
   (a: Account) => a.lastUsage?.sevenDay.usedPercentage ?? 101,
 ];
 
@@ -104,7 +124,7 @@ export function pickBest(accounts: Account[], ctx: PickCtx): Account | null {
   const usable = accounts.filter(
     (a) => a.accountUuid !== ctx.currentAccountUuid && !a.needsReauth && !isExhausted(a, ctx),
   );
-  return sortBy(usable, swapPreference(ctx.now))[0] ?? null;
+  return sortBy(usable, swapPreference(ctx))[0] ?? null;
 }
 
 export function currentWins(active: Account | null, accounts: Account[], ctx: PickCtx): boolean {
@@ -114,7 +134,7 @@ export function currentWins(active: Account | null, accounts: Account[], ctx: Pi
   const margin = ctx.holdMargin ?? 0;
   const bestPace = pacePressure(best, ctx.now);
   if (margin > 0 && bestPace > 0 && bestPace <= pacePressure(active, ctx.now) * (1 + margin)) return true;
-  return swapPreference(ctx.now).every((k) => k(active) === k(best));
+  return swapPreference(ctx).every((k) => k(active) === k(best));
 }
 
 export function usableAt(a: Account, ctx: PickCtx): number {

package/src/lib/sample.ts

@@ -24,10 +24,10 @@ const IdentityCheckSchema = z.discriminatedUnion("status", [
 ]);
 type IdentityCheck = z.infer<typeof IdentityCheckSchema>;
 
-async function checkIdentity(creds: OAuthCreds, account: Account): Promise<IdentityCheck> {
+async function checkIdentity(creds: OAuthCreds, account: Account, signal?: AbortSignal): Promise<IdentityCheck> {
   let identity: TokenIdentity;
   try {
-    identity = await fetchTokenIdentity(creds.accessToken);
+    identity = await fetchTokenIdentity(creds.accessToken, signal);
   } catch (e) {
     return {
       status: "unavailable",
@@ -44,7 +44,10 @@ function refreshPlanFields(account: Account, creds: OAuthCreds): void {
   if (creds.rateLimitTier != null) account.rateLimitTier = creds.rateLimitTier;
 }
 
-export async function probeParkedUsage(account: Account, opts: { ping?: boolean } = {}): Promise<SampleOutcome> {
+export async function probeParkedUsage(
+  account: Account,
+  opts: { ping?: boolean; retries?: number; refreshParked?: boolean; killMs?: number; signal?: AbortSignal } = {},
+): Promise<SampleOutcome> {
   const backup = parkedTarget(account.keychainItem);
   const parkedRaw = await readItem(backup);
   if (!parkedRaw) return { ok: false, reason: "no parked credential - run `tokenmaxxing auth`" };
@@ -59,6 +62,9 @@ export async function probeParkedUsage(account: Account, opts: { ping?: boolean
     account.needsReauth = true;
     return { ok: false, reason: "parked credential was cleared after a failed refresh - re-auth with `tokenmaxxing auth`" };
   }
+  if (opts.refreshParked === false && isAccessTokenExpiring(creds, 300_000)) {
+    return { ok: false, reason: "parked access token is near expiry - verification requires an unexpired token" };
+  }
 
   const liveRaw = await readItem(liveTarget());
   let liveAccount: string | null = null;
@@ -73,7 +79,7 @@ export async function probeParkedUsage(account: Account, opts: { ping?: boolean
     if (!isDeadCredential(liveCreds)) {
       liveToken = liveCreds.accessToken;
       try {
-        liveAccount = (await fetchTokenIdentity(liveCreds.accessToken)).accountUuid;
+        liveAccount = (await fetchTokenIdentity(liveCreds.accessToken, opts.signal)).accountUuid;
       } catch (e) {
         return { ok: false, reason: `cannot verify the live credential's owner (${(e instanceof Error ? e.message : String(e)).slice(0, 80)}) - refusing to sample a possibly-live account` };
       }
@@ -92,6 +98,9 @@ export async function probeParkedUsage(account: Account, opts: { ping?: boolean
   };
 
   if (isAccessTokenExpiring(creds, 300_000)) {
+    if (opts.refreshParked === false) {
+      return { ok: false, reason: "parked access token is near expiry - verification requires an unexpired token" };
+    }
     const owner = await checkIdentity(creds, account);
     if (owner.status === "mismatch") {
       const kept = await relocate(owner.owner);
@@ -136,7 +145,7 @@ export async function probeParkedUsage(account: Account, opts: { ping?: boolean
     await writeItem(backup, JSON.stringify({ claudeAiOauth: creds }));
   }
 
-  const identity = await checkIdentity(creds, account);
+  const identity = await checkIdentity(creds, account, opts.signal);
   if (identity.status === "mismatch") {
     const kept = await relocate(identity.owner);
     account.needsReauth = true;
@@ -151,13 +160,13 @@ export async function probeParkedUsage(account: Account, opts: { ping?: boolean
   rmSync(dir, { recursive: true, force: true });
   mkdirSync(dir, { recursive: true });
   const isoTarget = isolatedTarget(dir);
-  const installed = JSON.stringify({ claudeAiOauth: creds });
+  const installed = JSON.stringify({ claudeAiOauth: opts.refreshParked === false ? { ...creds, refreshToken: "" } : creds });
 
   try {
     await writeItem(isoTarget, installed);
     writeFileSync(join(dir, ".claude.json"), JSON.stringify({ oauthAccount: account.oauthAccount, hasCompletedOnboarding: true }));
     const ping = opts.ping ? await pingSession(dir) : null;
-    const usage = await probeUsage(dir);
+    const usage = await probeUsage(dir, Date.now(), opts);
     const outcome: SampleOutcome = usage
       ? { ok: true, usage }
       : { ok: false, reason: "`/usage` returned no limit data (see log)" };
@@ -167,10 +176,15 @@ export async function probeParkedUsage(account: Account, opts: { ping?: boolean
     }
     return outcome;
   } finally {
-    const afterIso = await readItem(isoTarget);
-    if (afterIso && afterIso !== installed) await writeItem(backup, claudeAiOauthOnly(afterIso));
-    await deleteItem(isoTarget);
-    rmSync(dir, { recursive: true, force: true });
+    try {
+      if (opts.refreshParked !== false) {
+        const afterIso = await readItem(isoTarget);
+        if (afterIso && afterIso !== installed) await writeItem(backup, claudeAiOauthOnly(afterIso));
+      }
+    } finally {
+      await deleteItem(isoTarget);
+      rmSync(dir, { recursive: true, force: true });
+    }
   }
 }
 

package/src/lib/state.ts

@@ -1,11 +1,10 @@
 import { closeSync, existsSync, fstatSync, openSync, readFileSync, rmSync, utimesSync } from "node:fs";
-import { isEqual, uniq } from "es-toolkit";
+import { isEqual } 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,
@@ -14,11 +13,8 @@ import {
   UsageStateSchema,
   type AccountsIndex,
   type Config,
-  type FamilyAnchor,
   type ModelUsageState,
   type UsageState,
-  type UsageWindow,
-  type WindowAnchor,
 } from "./types.ts";
 
 const DEFAULT_CONFIG: Config = {
@@ -34,7 +30,6 @@ const DEFAULT_CONFIG: Config = {
     usagePollTtlMs: 90_000,
     maxWaitMs: 3_600_000,
     checkIntervalMs: 60_000,
-    preferToUseBankedReset: [],
   },
 };
 
@@ -55,7 +50,6 @@ export const ConfigFileSchema = z
         usagePollTtlMs: z.number().int().positive(),
         maxWaitMs: z.number().int().positive(),
         checkIntervalMs: z.number().int().min(10_000),
-        preferToUseBankedReset: BankedResetProvidersSchema,
       })
       .partial(),
   })
@@ -89,9 +83,6 @@ 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();
@@ -196,29 +187,6 @@ 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>;
 
@@ -270,61 +238,13 @@ 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(input: UsageState, opts: { stamp?: boolean } = {}): boolean {
   const prev = loadUsage();
   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 } : {}) };
+  const next: UsageState = { ...input, ...(sampledAt != null ? { sampledAt } : {}) };
   if (
     prev &&
     isEqual({ ...prev, ts: 0, sampledAt: 0 }, { ...next, ts: 0, sampledAt: 0 }) &&

package/src/lib/swap.ts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { clearDepletedWait, clearNextCheck, clearUsageSnapshots, loadAccounts, saveAccounts, saveLastSwapAt } from "./state.ts";
 import { readItem, writeItem, liveTarget, parkedTarget, claudeAiOauthOnly, mergeIntoLive } from "./credstore.ts";
 import { refreshCredential, isAccessTokenExpiring, isDeadCredential, fetchTokenIdentity, describeIdentity, IdentityUnavailableError, InvalidGrantError, RefreshRejectedError } from "./oauth.ts";
@@ -11,6 +12,9 @@ function parseBlob(raw: string) {
   return CredentialBlobSchema.parse(JSON.parse(raw));
 }
 
+const VerifyVerdictSchema = z.enum(["go", "rerank", "skip"]);
+export type VerifyVerdict = z.infer<typeof VerifyVerdictSchema>;
+
 export async function performSwap(target: Account): Promise<void> {
   const idx = loadAccounts();
 
@@ -196,13 +200,25 @@ export function isSkippableSwapError(e: unknown): boolean {
   return e instanceof InvalidGrantError || e instanceof RefreshRejectedError || e instanceof IdentityUnavailableError;
 }
 
-export async function chooseAndSwap(ctx: PickCtx, exclude: ReadonlySet<string> = new Set()): Promise<Account | null> {
+export async function chooseAndSwap(
+  ctx: PickCtx,
+  exclude: ReadonlySet<string> = new Set(),
+  verify?: (candidate: Account, ctx: PickCtx) => Promise<VerifyVerdict>,
+): Promise<Account | null> {
   const tried = new Set<string>(exclude);
   while (true) {
     const idx = loadAccounts();
     const candidates = idx.accounts.filter((a) => !tried.has(a.accountUuid));
     const best = pickBest(candidates, ctx);
     if (!best) return null;
+    if (verify) {
+      const verdict = await verify(best, ctx);
+      if (verdict === "rerank") continue;
+      if (verdict === "skip") {
+        tried.add(best.accountUuid);
+        continue;
+      }
+    }
     tried.add(best.accountUuid);
     try {
       await performSwap(best);