tokenmaxxing 1.34.0 → 1.35.0

package/src/lib/decide.ts

@@ -1,14 +1,11 @@
-import { maxBy } from "es-toolkit";
 import { z } from "zod";
 import { withLock } from "./lock.ts";
-import { paths } from "./paths.ts";
-import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsageSnapshot, saveAccounts, saveDepletedWait, writeUsage } from "./state.ts";
-import { readOAuthAccount } from "./claudejson.ts";
-import { isSkippableSwapError, performSwap } from "./swap.ts";
-import { isExhausted, nextWeeklyReset, pickBest, pickEarliestReset, thresholdBars, usableAt } from "./picker.ts";
-import { familyTokens, gatedFamilies, keepRows, probeUsage } from "./usage.ts";
+import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, saveAccounts, saveDepletedWait } from "./state.ts";
+import { isExhausted, limitWindows, nextWeeklyReset, pickBest, pickEarliestReset, sessionWindow, thresholdBars, usableAt, weeklyWindow, type PickCtx } from "./picker.ts";
+import { familyTokens } from "./usage.ts";
 import { log } from "./log.ts";
-import { AccountSchema, UsageStateSchema, type Account, type Config, type EnforcedLimit, type Thresholds, type UsageState, type UsageWindow } from "./types.ts";
+import type { Observation, Provider } from "./provider.ts";
+import { AccountSchema, type Account, type EnforcedLimit } from "./types.ts";
 
 const SwapDecisionSchema = z.object({
   swapped: z.boolean(),
@@ -21,201 +18,132 @@ export type SwapDecision = z.infer<typeof SwapDecisionSchema>;
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 const FIVE_HOURS_MS = 5 * 60 * 60 * 1000;
 
-function liveUsed(input: { window: UsageWindow; windowMs: number; sampledAt: number; now: number }): number {
-  const { window: w, windowMs, sampledAt, now } = input;
-  if (w.resetsAt != null) return w.resetsAt <= now ? 0 : w.usedPercentage;
-  if (now >= sampledAt + windowMs) return 0;
-  return w.usedPercentage;
-}
-
-function rowsSampledAt(account: Account, now: number): number {
-  return account.lastUsage?.rowsAt ?? account.lastUsageAt ?? now;
-}
-
-function capForFamily(account: Account, family: string, now: number): UsageWindow | undefined {
-  const rows = Object.entries(account.lastUsage?.perModel ?? {})
-    .filter(([k]) => familyTokens(k).includes(family))
-    .map(([, w]) => w);
-  return maxBy(rows, (w) => liveUsed({ window: w, windowMs: WEEK_MS, sampledAt: rowsSampledAt(account, now), now }));
-}
-
-function isOver(u: UsageState | null, account: Account | undefined, bars: Thresholds, cfg: Config, now: number): boolean {
+function isOver(account: Account | undefined, observed: Observation | null, ctx: PickCtx): boolean {
   if (!account) return false;
-  if (account.enforcedUntil != null && account.enforcedUntil > now) return true;
-  if (!u || u.account !== account.accountUuid) return false;
-  if (
-    liveUsed({ window: u.fiveHour, windowMs: FIVE_HOURS_MS, sampledAt: u.ts, now }) >= bars.session ||
-    liveUsed({ window: u.sevenDay, windowMs: WEEK_MS, sampledAt: u.ts, now }) >= bars.weekly
-  ) return true;
-  for (const family of gatedFamilies(u.model, cfg.policy.switchModels)) {
-    const cap = capForFamily(account, family, now);
-    if (cap && liveUsed({ window: cap, windowMs: WEEK_MS, sampledAt: rowsSampledAt(account, now), now }) >= bars.weekly) return true;
-  }
-  return false;
-}
-
-function needsPerModel(u: UsageState | null, cfg: Config): boolean {
-  return u != null && gatedFamilies(u.model, cfg.policy.switchModels).length > 0;
-}
-
-const SnapshotsSchema = z.object({
-  u: UsageStateSchema.nullable(),
-  uAt: z.number().nullable(),
-});
-type Snapshots = z.infer<typeof SnapshotsSchema>;
-
-function usageFresh(u: UsageState | null, uAt: number | null, account: string | null, ttl: number, now: number): boolean {
-  return u != null && u.account === account && uAt != null && now - uAt <= ttl;
-}
-
-function freshest(u: UsageState | null, uAt: number | null, account: Account | undefined): UsageState | null {
-  if (!u || uAt == null) return u;
-  const stored = account?.lastUsage;
-  if (stored && account.lastUsageAt != null && u.account === account.accountUuid && uAt < account.lastUsageAt) {
-    return { ...u, fiveHour: stored.fiveHour, sevenDay: stored.sevenDay, ts: account.lastUsageAt };
-  }
-  return { ...u, ts: uAt };
+  if (account.needsReauth === true) return true;
+  if (account.enforcedUntil != null && account.enforcedUntil > ctx.now) return true;
+  if (!observed) return false;
+  return isExhausted({ ...account, windows: observed.windows }, ctx);
 }
 
-async function loadFreshSnapshots(cfg: Config, account: string | null, now: number, probe: boolean): Promise<Snapshots> {
-  const snap = loadUsageSnapshot();
-  let u = snap?.state ?? null;
-  let uAt = snap?.at ?? null;
-  const ttl = cfg.policy.usagePollTtlMs;
-  const stored = loadAccounts().accounts.find((a) => a.accountUuid === account);
-  const probeAttempted = stored?.lastProbeAt != null && now - stored.lastProbeAt <= ttl;
-  const walled = stored?.enforcedUntil != null && stored.enforcedUntil > now;
-  if (probe && account && stored && !walled && !probeAttempted && (!usageFresh(u, uAt, account, ttl, now) || needsPerModel(u, cfg))) {
-    const startedAt = Date.now();
-    const full = await probeUsage();
-    const ts = Date.now();
-    if (readOAuthAccount()?.accountUuid === account) {
-      if (full) {
-        const teed = loadUsageSnapshot();
-        if (teed && usageFresh(teed.state, teed.at, account, ttl, ts)) {
-          u = teed.state;
-          uAt = teed.at;
-        } else {
-          u = { fiveHour: full.fiveHour, sevenDay: full.sevenDay, account, ts, model: null };
-          writeUsage(u);
-          uAt = ts;
-        }
-        const expected = gatedFamilies(u?.model ?? null, cfg.policy.switchModels);
-        const rows = Object.keys(full.perModel);
-        if (expected.length > 0 && !expected.some((f) => rows.some((k) => familyTokens(k).includes(f)))) {
-          log("usage.no_permodel_row", { families: expected.join(","), rows: rows.join(",") });
-        }
-      }
-      await withLock(paths.lockFile, () => {
-        const idx = loadAccounts();
-        const a = idx.accounts.find((x) => x.accountUuid === account);
-        if (!a) return;
-        a.lastProbeAt = startedAt;
-        if (full) {
-          if (!a.lastUsage) a.lastUsageAt = startedAt;
-          a.lastUsage = keepRows({ ...(a.lastUsage ?? full), perModel: full.perModel }, a.lastUsage, startedAt);
-        }
-        saveAccounts(idx);
-      });
-    }
-  }
-  return { u, uAt };
+function enforcedWall(limit: EnforcedLimit, account: Account, now: number): number {
+  const { family } = limit;
+  const familyReset =
+    family == null
+      ? null
+      : limitWindows(account)
+          .filter((w) => familyTokens(w.name ?? "").includes(family))
+          .map((w) => w.resetsAt)
+          .find((r): r is number => r != null) ?? null;
+  const session = sessionWindow(account)?.resetsAt ?? null;
+  const cachedReset =
+    limit.kind === "session"
+      ? session != null && session > now ? session : null
+      : nextWeeklyReset(familyReset ?? weeklyWindow(account)?.resetsAt ?? null, now);
+  return limit.resetsAt ?? cachedReset ?? now + (limit.kind === "session" ? FIVE_HOURS_MS : WEEK_MS);
 }
 
-export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = false, enforced: EnforcedLimit | null = null): Promise<SwapDecision> {
-  const activeAccount = readOAuthAccount()?.accountUuid ?? null;
+export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), anticipatory = false, enforced: EnforcedLimit | null = null): Promise<SwapDecision> {
+  const activeId = p.liveId();
 
-  const lastSwapAt = loadLastSwapAt();
+  const lastSwapAt = loadLastSwapAt(p.pool);
   if (!enforced && lastSwapAt != null && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
-    return depletedReplay(now) ?? { swapped: false, account: null, reason: "post-swap-cooldown" };
+    return depletedReplay(p, now) ?? { swapped: false, account: null, reason: "post-swap-cooldown" };
   }
 
   const cfg = loadConfig();
   const bars = thresholdBars(cfg);
-
-  const { u: teeUsage, uAt } = await loadFreshSnapshots(cfg, activeAccount, now, enforced == null);
-  const stored = loadAccounts().accounts.find((a) => a.accountUuid === activeAccount);
-  const usage = freshest(teeUsage, uAt, stored);
-
-  if (!enforced && !isOver(usage, stored, bars, cfg, now)) {
-    const measured = usage != null && activeAccount != null && usage.account === activeAccount;
-    if (!measured) {
-      const replay = depletedReplay(now);
+  const stored0 = loadAccounts(p.pool).accounts.find((a) => a.id === activeId);
+  const walled0 = stored0?.enforcedUntil != null && stored0.enforcedUntil > now;
+  const observed = stored0 ? await p.observeLive(stored0, cfg, now, { probe: enforced == null && !walled0 }) : null;
+  const stored = loadAccounts(p.pool).accounts.find((a) => a.id === activeId);
+
+  if (!enforced && !isOver(stored, observed, { now, thresholds: bars, currentId: activeId, families: p.gatedFamilies(cfg) })) {
+    if (!observed) {
+      const replay = depletedReplay(p, now);
       if (replay) return replay;
     }
     return { swapped: false, account: null, reason: "under-threshold-or-stale" };
   }
 
-  return withLock(paths.lockFile, async () => {
-    const idx = loadAccounts();
-    const account2 = readOAuthAccount()?.accountUuid ?? null;
-    const tee = loadUsageSnapshot();
-    const active = account2 ? idx.accounts.find((a) => a.accountUuid === account2) : undefined;
-    const u2 = tee ? freshest(tee.state, tee.at, active) : usage;
+  return withLock(p.pool.lockFile, async () => {
+    const lastSwapAt2 = loadLastSwapAt(p.pool);
+    if (!enforced && lastSwapAt2 != null && now - lastSwapAt2 < POST_SWAP_COOLDOWN_MS) {
+      return { swapped: false, account: null, reason: "raced-already-swapped" };
+    }
+    const idx = loadAccounts(p.pool);
+    const id2 = p.liveId();
+    const active = id2 ? idx.accounts.find((a) => a.id === id2) : undefined;
 
-    const origin = enforced ? idx.accounts.find((a) => a.accountUuid === enforced.account) : undefined;
+    const origin = enforced ? idx.accounts.find((a) => a.id === enforced.account) : undefined;
     const prior = origin?.enforcedUntil != null && origin.enforcedUntil > now;
     if (enforced && origin) {
       origin.enforcedUntil = Math.max(origin.enforcedUntil ?? 0, enforcedWall(enforced, origin, now));
       origin.lastProbeAt = now;
-      saveAccounts(idx);
+      saveAccounts(p.pool, idx);
       log("usage.enforced_limit", { kind: enforced.kind, family: enforced.family ?? undefined, resetsAt: origin.enforcedUntil, blind: prior || enforced.blind, live: origin === active });
     }
     const enforced2 = enforced && origin && origin === active ? enforced : null;
 
-    if (account2 != null && !active) {
+    if (id2 != null && !active) {
       return { swapped: false, account: null, reason: "live-credential-not-in-pool" };
     }
 
-    if (active && tee && tee.state.account === account2 && (active.lastUsageAt == null || tee.at >= active.lastUsageAt)) {
-      active.lastUsageAt = tee.state.sampledAt ?? tee.at;
-      active.lastUsage = keepRows({ fiveHour: tee.state.fiveHour, sevenDay: tee.state.sevenDay, perModel: {} }, active.lastUsage, active.lastUsageAt);
-      saveAccounts(idx);
+    const obs2 = active ? await p.observeLive(active, cfg, now, { probe: false }) : null;
+    if (active && obs2 && (active.lastUsageAt == null || obs2.at > active.lastUsageAt)) {
+      active.windows = p.mergeWindows(obs2.windows, active.windows);
+      active.lastUsageAt = obs2.at;
+      saveAccounts(p.pool, idx);
     }
 
+    const families = p.gatedFamilies(cfg);
     const walled = active?.enforcedUntil != null && active.enforcedUntil > now;
     const blindScreen = (enforced != null && (prior || enforced.blind)) || (walled && !enforced2);
-    const gated = blindScreen ? cfg.policy.switchModels : gatedFamilies(u2?.model ?? null, cfg.policy.switchModels);
+    const screened = blindScreen && families != null ? cfg.policy.switchModels : families;
     const family = enforced?.family ?? null;
-    const switchFamilies = family != null && !gated.includes(family) ? [...gated, family] : gated;
+    const switchFamilies = screened == null ? null : family != null && !screened.includes(family) ? [...screened, family] : screened;
 
-    const seatExhausted = active != null && isExhausted(active, { now, thresholds: bars, currentAccountUuid: account2, switchFamilies });
-    if (!enforced2 && !isOver(u2, active, bars, cfg, now) && !(enforced && seatExhausted)) {
-      return depletedReplay(now) ?? { swapped: false, account: null, reason: "raced-already-swapped" };
+    const seatExhausted = active != null && isExhausted(active, { now, thresholds: bars, currentId: id2, families: switchFamilies });
+    if (!enforced2 && !isOver(active, obs2, { now, thresholds: bars, currentId: id2, families }) && !(enforced && seatExhausted)) {
+      return depletedReplay(p, now) ?? { swapped: false, account: null, reason: "raced-already-swapped" };
     }
 
-    const seatOf = (idx2: { activeAccountUuid: string | null; accounts: Account[] }): Account | null =>
-      idx2.accounts.find((a) => a.accountUuid === account2) ??
-      idx2.accounts.find((a) => a.accountUuid === idx2.activeAccountUuid) ??
-      null;
+    const seatOf = (cur: { activeId: string | null; accounts: Account[] }): Account | null =>
+      cur.accounts.find((a) => a.id === id2) ?? cur.accounts.find((a) => a.id === cur.activeId) ?? null;
 
+    const present = p.presentIds();
     const rejected = new Set<string>();
-    const usable = (accounts: Account[]): Account[] => accounts.filter((a) => !rejected.has(a.accountUuid));
+    const usable = (accounts: Account[]): Account[] => accounts.filter((a) => !rejected.has(a.id) && (a.id === id2 || !present.has(a.id)));
     const skipOrThrow = (e: unknown, candidate: Account): void => {
-      if (!isSkippableSwapError(e)) throw e;
-      rejected.add(candidate.accountUuid);
-      log("decide.candidate_rejected", { account: candidate.accountUuid.slice(0, 8), error: e instanceof Error ? e.message : String(e) });
+      if (p.classifySwapError(e) === "fatal") throw e;
+      rejected.add(candidate.id);
+      log("decide.candidate_rejected", { account: candidate.id.slice(0, 8), error: e instanceof Error ? e.message : String(e) });
     };
     while (true) {
-      const cur = loadAccounts();
+      const cur = loadAccounts(p.pool);
       const seat = seatOf(cur);
-      const ctx = { now, thresholds: bars, currentAccountUuid: seat?.accountUuid ?? null, switchFamilies };
+      const ctx: PickCtx = { now, thresholds: bars, currentId: seat?.id ?? null, families: switchFamilies };
       const best = pickBest(usable(cur.accounts), ctx);
       if (!best) break;
       try {
-        await performSwap(best);
+        await p.swap(best);
       } catch (e) {
         skipOrThrow(e, best);
         continue;
       }
-      log("decide.swap", { account: best.accountUuid.slice(0, 8), enforced: enforced2 != null });
+      log("decide.swap", { account: best.id.slice(0, 8), enforced: enforced2 != null });
       return { swapped: true, account: best, reason: "swapped" };
     }
 
+    if (!p.waitsWhenDepleted) {
+      log("decide.depleted", { waitUntil: 0 });
+      return { swapped: false, account: null, reason: "all-depleted" };
+    }
+
     while (true) {
-      const fresh = loadAccounts();
+      const fresh = loadAccounts(p.pool);
       const current = seatOf(fresh);
-      const ctx = { now, thresholds: bars, currentAccountUuid: current?.accountUuid ?? null, switchFamilies };
+      const ctx: PickCtx = { now, thresholds: bars, currentId: current?.id ?? null, families: switchFamilies };
       const currentAt = current ? usableAt(current, ctx) : Number.POSITIVE_INFINITY;
       const other = pickEarliestReset(usable(fresh.accounts), ctx);
 
@@ -230,48 +158,32 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
         return { swapped: false, account: null, reason: "all-depleted", ...(Number.isFinite(waitUntil) ? { waitUntil } : {}) };
       }
 
-      const isCurrent = target.accountUuid === (current?.accountUuid ?? null);
+      const isCurrent = target.id === (current?.id ?? null);
       if (!isCurrent && !anticipatory) {
-        log("decide.depleted_no_park", { account: target.accountUuid.slice(0, 8), waitUntil });
+        log("decide.depleted_no_park", { account: target.id.slice(0, 8), waitUntil });
         return { swapped: false, account: null, reason: "all-depleted", waitUntil };
       }
       if (!isCurrent) {
         try {
-          await performSwap(target);
+          await p.swap(target);
         } catch (e) {
           skipOrThrow(e, target);
           continue;
         }
       }
-      saveDepletedWait({ waitUntil, accountUuid: target.accountUuid, ts: now });
-      log("decide.depleted_wait", { account: target.accountUuid.slice(0, 8), waitUntil });
+      saveDepletedWait({ waitUntil, id: target.id, ts: now });
+      log("decide.depleted_wait", { account: target.id.slice(0, 8), waitUntil });
       return { swapped: !isCurrent, account: target, reason: "depleted-wait", waitUntil };
     }
   });
 }
 
-function depletedReplay(now: number): SwapDecision | null {
+function depletedReplay(p: Provider, now: number): SwapDecision | null {
+  if (!p.waitsWhenDepleted) return null;
   const rec = loadDepletedWait();
   if (!rec || rec.waitUntil <= now) return null;
-  const account = loadAccounts().accounts.find((a) => a.accountUuid === rec.accountUuid) ?? null;
+  const account = loadAccounts(p.pool).accounts.find((a) => a.id === rec.id) ?? null;
   if (!account) return null;
-  if (account.accountUuid !== (readOAuthAccount()?.accountUuid ?? null)) return null;
+  if (account.id !== p.liveId()) return null;
   return { swapped: false, account, reason: "depleted-wait", waitUntil: rec.waitUntil };
 }
-
-function enforcedWall(limit: EnforcedLimit, account: Account, now: number): number {
-  const cached = account.lastUsage;
-  const { family } = limit;
-  const familyReset =
-    family == null
-      ? null
-      : Object.entries(cached?.perModel ?? {})
-          .filter(([k]) => familyTokens(k).includes(family))
-          .map(([, w]) => w.resetsAt)
-          .find((r): r is number => r != null) ?? null;
-  const cachedReset =
-    limit.kind === "session"
-      ? cached?.fiveHour.resetsAt != null && cached.fiveHour.resetsAt > now ? cached.fiveHour.resetsAt : null
-      : nextWeeklyReset(familyReset ?? cached?.sevenDay.resetsAt ?? null, now);
-  return limit.resetsAt ?? cachedReset ?? now + (limit.kind === "session" ? FIVE_HOURS_MS : WEEK_MS);
-}

package/src/lib/oauth.ts

@@ -40,6 +40,13 @@ export function isDeadCredential(creds: OAuthCreds): boolean {
   return creds.refreshToken === "" || creds.accessToken === "";
 }
 
+export function claudeTierLabel(input: { subscriptionType?: string; rateLimitTier?: string }): string | null {
+  const segments = input.rateLimitTier?.split("_") ?? [];
+  const multiplier = segments.find((seg) => seg.length > 1 && seg.endsWith("x") && Number.isInteger(Number(seg.slice(0, -1))));
+  if (input.subscriptionType == null) return multiplier ?? null;
+  return multiplier ? `${input.subscriptionType} ${multiplier}` : input.subscriptionType;
+}
+
 export async function refreshCredential(creds: OAuthCreds, now = Date.now(), signal?: AbortSignal): Promise<OAuthCreds> {
   if (isDeadCredential(creds)) throw new InvalidGrantError("credential was cleared after a failed refresh");
   const scope = (creds.scopes?.length ? creds.scopes : DEFAULT_SCOPES).join(" ");

package/src/lib/paths.ts

@@ -15,14 +15,11 @@ const TM_HOME = env("TOKENMAXXING_HOME", join(HOME, ".config", "tokenmaxxing"));
 export const paths = {
   home: TM_HOME,
   configJson: join(TM_HOME, "config.json"),
-  accountsJson: join(TM_HOME, "accounts.json"),
   usageJson: join(TM_HOME, "usage.json"),
-  lastSwapJson: join(TM_HOME, "lastswap.json"),
   depletedJson: join(TM_HOME, "depleted.json"),
   respawnDir: join(TM_HOME, "respawn"),
   binDir: join(TM_HOME, "bin"),
   supervisorLink: join(TM_HOME, "bin", "claude"),
-  lockFile: join(TM_HOME, "lock"),
   logFile: join(TM_HOME, "tokenmaxxing.log"),
   onboardDir: join(TM_HOME, "onboard"),
   sampleDir: join(TM_HOME, "sample"),
@@ -44,15 +41,26 @@ export const paths = {
   systemdUserDir: env("TOKENMAXXING_SYSTEMD_USER_DIR", join(HOME, ".config", "systemd", "user")),
 } as const;
 
+export const claudePool = {
+  accountsJson: join(TM_HOME, "accounts.json"),
+  lastSwapJson: join(TM_HOME, "lastswap.json"),
+  lockFile: join(TM_HOME, "lock"),
+} as const;
+
+export const codexPool = {
+  accountsJson: join(TM_HOME, "codex-accounts.json"),
+  lastSwapJson: join(TM_HOME, "codex-lastswap.json"),
+  lockFile: join(TM_HOME, "codex-lock"),
+} as const;
+
+export type PoolPaths = { accountsJson: string; lastSwapJson: string; lockFile: string };
+
 const CODEX_HOME = env("TOKENMAXXING_CODEX_HOME", env("CODEX_HOME", join(HOME, ".codex")));
 
 export const codexPaths = {
   home: CODEX_HOME,
   authJson: join(CODEX_HOME, "auth.json"),
   hooksJson: join(CODEX_HOME, "hooks.json"),
-  accountsJson: join(TM_HOME, "codex-accounts.json"),
-  lastSwapJson: join(TM_HOME, "codex-lastswap.json"),
-  lockFile: join(TM_HOME, "codex-lock"),
   credsDir: join(TM_HOME, "codex-creds"),
   onboardDir: join(TM_HOME, "codex-onboard"),
   respawnDir: join(TM_HOME, "codex-respawn"),

package/src/lib/picker.ts

@@ -1,7 +1,7 @@
-import { minBy, sortBy } from "es-toolkit";
+import { maxBy, minBy, sortBy } from "es-toolkit";
 import { z } from "zod";
 import { familyTokens } from "./usage.ts";
-import { AccountSchema, ThresholdsSchema, type Account, type Config, type Thresholds, type UsageWindow } from "./types.ts";
+import { AccountSchema, ThresholdsSchema, type Account, type Config, type Thresholds, type Window } from "./types.ts";
 
 export function thresholdBars(cfg: Config): Thresholds {
   return {
@@ -13,36 +13,57 @@ export function thresholdBars(cfg: Config): Thresholds {
 const PickCtxSchema = z.object({
   now: z.number(),
   thresholds: ThresholdsSchema,
-  currentAccountUuid: z.string().nullable(),
-  switchFamilies: z.array(z.string()),
+  currentId: z.string().nullable(),
+  families: z.array(z.string()).nullable(),
 });
 export type PickCtx = z.infer<typeof PickCtxSchema>;
 
-function gatedPerModelWindows(a: Account, families: string[]): UsageWindow[] {
-  return Object.entries(a.lastUsage?.perModel ?? {})
-    .filter(([model]) => families.some((f) => familyTokens(model).includes(f)))
-    .map(([, w]) => w);
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+const SESSION_WINDOW_MAX_S = 6 * 3600;
+
+export function isSessionWindow(w: Window): boolean {
+  return w.windowSeconds != null && w.windowSeconds <= SESSION_WINDOW_MAX_S;
 }
 
-const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
-const FIVE_HOURS_MS = 5 * 60 * 60 * 1000;
+export function sessionWindow(a: Account): Window | undefined {
+  return a.windows.find((w) => w.name == null && isSessionWindow(w));
+}
+
+export function weeklyWindow(a: Account): Window | undefined {
+  return maxBy(a.windows.filter((w) => w.name == null && !isSessionWindow(w)), (w) => w.windowSeconds ?? 0);
+}
+
+export function limitWindows(a: Account): Window[] {
+  return a.windows.filter((w) => w.name != null);
+}
+
+export function gatedWindows(a: Account, families: string[] | null): Window[] {
+  return a.windows.filter((w) => {
+    const name = w.name;
+    return name != null && (families == null || families.some((f) => familyTokens(name).includes(f)));
+  });
+}
+
+export function liveUsed(w: Window, now: number): number {
+  if (w.resetsAt != null) return w.resetsAt <= now ? 0 : w.usedPercentage;
+  if (w.windowSeconds != null && now >= w.sampledAt + w.windowSeconds * 1000) return 0;
+  return w.usedPercentage;
+}
+
+function barFor(w: Window, thresholds: Thresholds): number {
+  return isSessionWindow(w) ? thresholds.session : thresholds.weekly;
+}
 
-function blockedUntil(w: UsageWindow, windowMs: number, sampledAt: number | undefined, threshold: number): number {
-  if (w.usedPercentage < threshold) return 0;
+function blockedUntil(w: Window, bar: number): number {
+  if (w.usedPercentage < bar) return 0;
   if (w.resetsAt != null) return w.resetsAt;
-  return sampledAt != null ? sampledAt + windowMs : Number.POSITIVE_INFINITY;
+  return w.windowSeconds != null ? w.sampledAt + w.windowSeconds * 1000 : Number.POSITIVE_INFINITY;
 }
 
 function blockingUntil(a: Account, ctx: PickCtx): number[] {
-  const u = a.lastUsage;
   return [
-    ...(u
-      ? [
-          blockedUntil(u.fiveHour, FIVE_HOURS_MS, a.lastUsageAt, ctx.thresholds.session),
-          blockedUntil(u.sevenDay, WEEK_MS, a.lastUsageAt, ctx.thresholds.weekly),
-        ]
-      : []),
-    ...gatedPerModelWindows(a, ctx.switchFamilies).map((w) => blockedUntil(w, WEEK_MS, u?.rowsAt ?? a.lastUsageAt, ctx.thresholds.weekly)),
+    ...a.windows.filter((w) => w.name == null).map((w) => blockedUntil(w, barFor(w, ctx.thresholds))),
+    ...gatedWindows(a, ctx.families).map((w) => blockedUntil(w, barFor(w, ctx.thresholds))),
     ...(a.enforcedUntil != null ? [a.enforcedUntil] : []),
   ];
 }
@@ -57,39 +78,37 @@ export function nextWeeklyReset(resetsAt: number | null, now: number): number |
 }
 
 export function weeklyExpiry(a: Account, now: number): number {
-  return nextWeeklyReset(a.lastUsage?.sevenDay.resetsAt ?? null, now) ?? Number.POSITIVE_INFINITY;
+  return nextWeeklyReset(weeklyWindow(a)?.resetsAt ?? null, now) ?? Number.POSITIVE_INFINITY;
 }
 
 export function earliestReset(a: Account, now: number): number {
-  const fiveHour = a.lastUsage?.fiveHour.resetsAt;
-  return Math.min(fiveHour != null && fiveHour > now ? fiveHour : Number.POSITIVE_INFINITY, weeklyExpiry(a, now));
+  const session = sessionWindow(a)?.resetsAt;
+  return Math.min(session != null && session > now ? session : Number.POSITIVE_INFINITY, weeklyExpiry(a, now));
 }
 
 export function pacePressure(a: Account, now: number): number {
-  const cached = a.lastUsage?.sevenDay;
-  const reset = nextWeeklyReset(cached?.resetsAt ?? null, now);
-  if (cached == null || reset == null) return 0;
-  const used = cached.resetsAt != null && cached.resetsAt <= now ? 0 : cached.usedPercentage;
-  return Math.max(0, 100 - used) / Math.max(1, reset - now);
+  const weekly = weeklyWindow(a);
+  const reset = nextWeeklyReset(weekly?.resetsAt ?? null, now);
+  if (weekly == null || reset == null) return 0;
+  return Math.max(0, 100 - liveUsed(weekly, now)) / Math.max(1, reset - now);
 }
 
 const swapPreference = (ctx: PickCtx) => [
   (a: Account) => -pacePressure(a, ctx.now),
   (a: Account) => weeklyExpiry(a, ctx.now),
-  (a: Account) => a.lastUsage?.sevenDay.usedPercentage ?? 101,
+  (a: Account) => weeklyWindow(a)?.usedPercentage ?? 101,
 ];
 
 export function pickBest(accounts: Account[], ctx: PickCtx): Account | null {
-  const usable = accounts.filter(
-    (a) => a.accountUuid !== ctx.currentAccountUuid && !a.needsReauth && !isExhausted(a, ctx),
-  );
+  const usable = accounts.filter((a) => a.id !== ctx.currentId && !a.needsReauth && !isExhausted(a, ctx));
   return sortBy(usable, swapPreference(ctx))[0] ?? null;
 }
 
-export function currentWins(active: Account | null, accounts: Account[], ctx: PickCtx): boolean {
+export function currentWins(active: Account | null, accounts: Account[], ctx: PickCtx, margin = 1): boolean {
   if (!active || active.needsReauth || isExhausted(active, ctx)) return false;
-  const best = pickBest(accounts, { ...ctx, currentAccountUuid: null });
-  if (best == null || best.accountUuid === active.accountUuid) return true;
+  const best = pickBest(accounts, { ...ctx, currentId: null });
+  if (best == null || best.id === active.id) return true;
+  if (margin > 1) return pacePressure(best, ctx.now) <= pacePressure(active, ctx.now) * margin;
   return swapPreference(ctx).every((k) => k(active) === k(best));
 }
 
@@ -103,7 +122,7 @@ export type EarliestReset = z.infer<typeof EarliestResetSchema>;
 
 export function pickEarliestReset(accounts: Account[], ctx: PickCtx): EarliestReset | null {
   const mapped = accounts
-    .filter((a) => a.accountUuid !== ctx.currentAccountUuid && !a.needsReauth)
+    .filter((a) => a.id !== ctx.currentId && !a.needsReauth)
     .map((a) => ({ account: a, availableAt: usableAt(a, ctx) }))
     .filter((x) => Number.isFinite(x.availableAt));
   return minBy(mapped, (x) => x.availableAt) ?? null;

package/src/lib/provider.ts

@@ -0,0 +1,34 @@
+import type { PoolPaths } from "./paths.ts";
+import type { Harvest } from "./state.ts";
+import type { Account, Config, Window } from "./types.ts";
+
+export type Observation = { windows: Window[]; at: number };
+
+export type SampleReport = { ok: true; source: "statusline" | "probe" } | { ok: false; reason: string };
+
+export type SwapFailure = "dead-grant" | "skip" | "fatal";
+
+export type Provider = {
+  name: "claude" | "codex";
+  flag: string;
+  pool: PoolPaths;
+  waitsWhenDepleted: boolean;
+  switchMargin: number;
+  switchNote: string;
+  liveId(): string | null;
+  liveOwner(): Promise<string | null>;
+  presentIds(): Set<string>;
+  gatedFamilies(cfg: Config): string[] | null;
+  observeLive(account: Account, cfg: Config, now: number, opts: { probe: boolean }): Promise<Observation | null>;
+  samplePool(accounts: Account[], liveId: string | null, now: number): Promise<Map<string, SampleReport>>;
+  mergeWindows(next: Window[], prev: Window[]): Window[];
+  swap(target: Account): Promise<void>;
+  classifySwapError(e: unknown): SwapFailure;
+  removeCredentials(account: Account): Promise<void>;
+  login(): Promise<Harvest | null>;
+  importLive(): Promise<Harvest | null>;
+  preflight(): void;
+  install(): void;
+  loginStep(who: string): string;
+  windowLabel(name: string): string;
+};