tokenmaxxing 1.34.0 → 1.38.0

package/src/lib/install.ts

@@ -7,6 +7,7 @@ import { writeFileAtomic } from "./atomic.ts";
 import { installedBin, installSettings, isOurHookCommand, uninstallSettings } from "./settings.ts";
 import { resolveRealClaude } from "./claudebin.ts";
 import { loadConfig } from "./state.ts";
+import { ErrnoSchema } from "./types.ts";
 
 const InstallOutcomeSchema = z.object({
   claudeWrapper: z.string(),
@@ -49,10 +50,6 @@ function isNixStorePath(path: string): boolean {
   return path === "/nix/store" || path.startsWith("/nix/store/");
 }
 
-function isEacces(e: unknown): boolean {
-  return typeof e === "object" && e != null && "code" in e && e.code === "EACCES";
-}
-
 function cannotWriteRcTarget(target: string): boolean {
   if (EnvFlagSchema.parse(process.env.TOKENMAXXING_SKIP_SHELL_RC) != null) return true;
   if (isNixStorePath(target)) return true;
@@ -355,7 +352,7 @@ export function ensurePathInRc(rc: string): "added" | "present" | "skipped" {
     try {
       writeFileAtomic(target, `${body}${sep0}${addition}`, statSync(target).mode & 0o777);
     } catch (e) {
-      if (isEacces(e)) return "skipped";
+      if (ErrnoSchema.safeParse(e).data?.code === "EACCES") return "skipped";
       throw e;
     }
     return "added";
@@ -366,7 +363,7 @@ export function ensurePathInRc(rc: string): "added" | "present" | "skipped" {
   try {
     appendFileSync(target, `${sep}export PATH="${dir}:$PATH" ${PATH_LINE_MARK}\n`);
   } catch (e) {
-    if (isEacces(e)) return "skipped";
+    if (ErrnoSchema.safeParse(e).data?.code === "EACCES") return "skipped";
     throw e;
   }
   return "added";
@@ -411,7 +408,7 @@ export function removePathFromRc(rc: string): boolean {
   try {
     writeFileAtomic(target, kept.join("\n"), statSync(target).mode & 0o777);
   } catch (e) {
-    if (isEacces(e)) return false;
+    if (ErrnoSchema.safeParse(e).data?.code === "EACCES") return false;
     throw e;
   }
   return true;

package/src/lib/oauth.ts

@@ -1,11 +1,10 @@
-import { z } from "zod";
 import { http, oauthErrorCode, safeErrorDetail } from "./http.ts";
-import { ProfileResponseSchema, RefreshResponseSchema, TokenIdentitySchema, type OAuthCreds, type TokenIdentity } from "./types.ts";
+import { env } from "./paths.ts";
+import { JsonTextSchema, ProfileResponseSchema, RefreshResponseSchema, TokenIdentitySchema, type OAuthCreds, type TokenIdentity } from "./types.ts";
 
-const EnvOverrideSchema = z.string().min(1).optional().catch(undefined);
-const TOKEN_URL = EnvOverrideSchema.parse(process.env.TOKENMAXXING_OAUTH_TOKEN_URL) ?? "https://platform.claude.com/v1/oauth/token";
-const CLIENT_ID = EnvOverrideSchema.parse(process.env.TOKENMAXXING_OAUTH_CLIENT_ID) ?? "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-const PROFILE_URL = EnvOverrideSchema.parse(process.env.TOKENMAXXING_OAUTH_PROFILE_URL) ?? "https://api.anthropic.com/api/oauth/profile";
+const TOKEN_URL = env("TOKENMAXXING_OAUTH_TOKEN_URL", "https://platform.claude.com/v1/oauth/token");
+const CLIENT_ID = env("TOKENMAXXING_OAUTH_CLIENT_ID", "9d1c250a-e61b-44d9-88ed-5944d1962f5e");
+const PROFILE_URL = env("TOKENMAXXING_OAUTH_PROFILE_URL", "https://api.anthropic.com/api/oauth/profile");
 
 const DEFAULT_SCOPES = [
   "user:profile",
@@ -40,6 +39,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(" ");
@@ -69,9 +75,7 @@ export async function refreshCredential(creds: OAuthCreds, now = Date.now(), sig
     throw new Error(`token refresh failed (HTTP ${res.status}): ${detail}`);
   }
 
-  const parsed = RefreshResponseSchema.safeParse((() => {
-    try { return JSON.parse(text); } catch { return null; }
-  })());
+  const parsed = RefreshResponseSchema.safeParse(JsonTextSchema.safeParse(text).data);
   if (!parsed.success) {
     throw new Error(`token endpoint returned an unrecognized body (${text.length} bytes, withheld)`);
   }
@@ -112,9 +116,7 @@ export async function fetchTokenIdentity(accessToken: string, signal?: AbortSign
     throw new IdentityUnavailableError(res.status, `profile response body unreadable: ${e instanceof Error ? e.message : String(e)}`);
   }
   if (!res.ok) throw new IdentityUnavailableError(res.status, safeErrorDetail({ text }));
-  const parsed = ProfileResponseSchema.safeParse((() => {
-    try { return JSON.parse(text); } catch { return null; }
-  })());
+  const parsed = ProfileResponseSchema.safeParse(JsonTextSchema.safeParse(text).data);
   if (!parsed.success) throw new IdentityUnavailableError(res.status, `profile endpoint returned an unrecognized body (${text.length} bytes, withheld)`);
   return TokenIdentitySchema.parse({
     accountUuid: parsed.data.account.uuid,

package/src/lib/paths.ts

@@ -6,7 +6,7 @@ const HOME = homedir();
 
 const EnvOverrideSchema = z.string().min(1).optional().catch(undefined);
 
-function env(name: string, fallback: string): string {
+export function env(name: string, fallback: string): string {
   return EnvOverrideSchema.parse(process.env[name]) ?? fallback;
 }
 
@@ -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/proc.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { ErrnoSchema } from "./types.ts";
 
 export function pidStartTime(pid: number): string | null {
   const res = Bun.spawnSync(["ps", "-p", String(pid), "-o", "lstart="], { env: { ...process.env, LC_ALL: "C" } });
@@ -12,9 +12,9 @@ export function pidExists(pid: number): boolean {
     process.kill(pid, 0);
     return true;
   } catch (e) {
-    const errno = z.object({ code: z.string() }).safeParse(e);
-    if (errno.success && errno.data.code === "ESRCH") return false;
-    if (errno.success && errno.data.code === "EPERM") return true;
+    const code = ErrnoSchema.safeParse(e).data?.code;
+    if (code === "ESRCH") return false;
+    if (code === "EPERM") return true;
     throw e;
   }
 }

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;
+};

package/src/lib/sample.ts

@@ -3,12 +3,12 @@ import { join } from "node:path";
 import { minBy } from "es-toolkit";
 import { z } from "zod";
 import { readItem, writeItem, deleteItem, liveTarget, parkedTarget, isolatedTarget, claudeAiOauthOnly, mergeIntoLive } from "./credstore.ts";
-import { credItemFor, paths } from "./paths.ts";
+import { claudePool, credItemFor, paths } from "./paths.ts";
 import { withClaudeRefreshLock } from "./claudelock.ts";
 import { withLock } from "./lock.ts";
 import { readOAuthAccount } from "./claudejson.ts";
-import { refreshCredential, isAccessTokenExpiring, isDeadCredential, fetchTokenIdentity, describeIdentity, IdentityUnavailableError, InvalidGrantError } from "./oauth.ts";
-import { keepRows, probeUsage } from "./usage.ts";
+import { claudeTierLabel, refreshCredential, isAccessTokenExpiring, isDeadCredential, fetchTokenIdentity, describeIdentity, IdentityUnavailableError, InvalidGrantError } from "./oauth.ts";
+import { mergeWindows, probeUsage, windowsOf } from "./usage.ts";
 import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadLastSwapAt, saveAccounts } from "./state.ts";
 import { keepRotatedPair } from "./swap.ts";
 import { log } from "./log.ts";
@@ -38,13 +38,12 @@ async function checkIdentity(creds: OAuthCreds, account: Account, signal?: Abort
       stale: e instanceof IdentityUnavailableError && e.status === 401,
     };
   }
-  if (identity.accountUuid === account.accountUuid) return { status: "match" };
+  if (identity.accountUuid === account.id) return { status: "match" };
   return { status: "mismatch", reason: `credential actually belongs to ${describeIdentity(identity)}`, owner: identity };
 }
 
-function refreshPlanFields(account: Account, creds: OAuthCreds): void {
-  if (creds.subscriptionType != null) account.subscriptionType = creds.subscriptionType;
-  if (creds.rateLimitTier != null) account.rateLimitTier = creds.rateLimitTier;
+function refreshTier(account: Account, creds: OAuthCreds): void {
+  account.tier = claudeTierLabel(creds) ?? account.tier;
 }
 
 const ProbeFailureSchema = z.object({ ok: z.literal(false), reason: z.string() });
@@ -53,9 +52,10 @@ const PreparedProbeSchema = z.discriminatedUnion("ok", [z.object({ ok: z.literal
 type PreparedProbe = z.infer<typeof PreparedProbeSchema>;
 
 async function prepareParkedProbe(account: Account, dir: string, signal?: AbortSignal): Promise<PreparedProbe> {
-  const backup = parkedTarget(account.keychainItem);
+  const backup = parkedTarget(credItemFor(account.id));
   const parkedRaw = await readItem(backup);
   if (!parkedRaw) return { ok: false, reason: "no parked credential - run `tokenmaxxing auth`" };
+  if (!account.oauthAccount) return { ok: false, reason: "account record has no oauthAccount - run `tokenmaxxing auth`" };
 
   let creds: OAuthCreds;
   try {
@@ -87,17 +87,17 @@ async function prepareParkedProbe(account: Account, dir: string, signal?: AbortS
       } 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` };
       }
-      if (liveAccount === account.accountUuid) {
+      if (liveAccount === account.id) {
         return { ok: false, reason: "this account holds the LIVE login (active label drifted) - run `tokenmaxxing switch` to reconcile" };
       }
     }
   }
 
   const relocate = async (owner: TokenIdentity): Promise<string> => {
-    const pooled = loadAccounts().accounts.find((a) => a.accountUuid === owner.accountUuid) ?? null;
-    if (pooled == null || pooled.accountUuid === liveAccount) return "was left in place";
-    await writeItem(parkedTarget(pooled.keychainItem), JSON.stringify({ claudeAiOauth: creds }));
-    log("swap.parked_relocated", { account: pooled.accountUuid.slice(0, 8) });
+    const pooled = loadAccounts(claudePool).accounts.find((a) => a.id === owner.accountUuid) ?? null;
+    if (pooled == null || pooled.id === liveAccount) return "was left in place";
+    await writeItem(parkedTarget(credItemFor(pooled.id)), JSON.stringify({ claudeAiOauth: creds }));
+    log("swap.parked_relocated", { account: pooled.id.slice(0, 8) });
     return "was copied to that account's slot";
   };
 
@@ -140,8 +140,8 @@ async function prepareParkedProbe(account: Account, dir: string, signal?: AbortS
             await writeItem(backup, JSON.stringify({ claudeAiOauth: rotated.fresh }));
             return { failed: { ok: false, reason: `${verified.reason} - the rotated pair stays in this slot unverified until the next pass` } };
           }
-          const trueOwner = loadAccounts().accounts.find((a) => a.accountUuid === verified.owner.accountUuid) ?? null;
-          const kept = await keepRotatedPair({ fresh: rotated.fresh, owner: trueOwner, fallback: account, liveOwnerUuid: liveAccount, expectedLiveToken: liveToken, lock });
+          const trueOwner = loadAccounts(claudePool).accounts.find((a) => a.id === verified.owner.accountUuid) ?? null;
+          const kept = await keepRotatedPair({ fresh: rotated.fresh, owner: trueOwner, fallback: account, liveOwnerId: liveAccount, expectedLiveToken: liveToken, lock });
           account.needsReauth = true;
           return { failed: { ok: false, reason: `${verified.reason}, whose grant this refresh rotated - the rotated token ${kept}; re-auth with \`tokenmaxxing auth\`` } };
         });
@@ -163,7 +163,7 @@ async function prepareParkedProbe(account: Account, dir: string, signal?: AbortS
   if (identity.status === "unavailable") {
     return { ok: false, reason: identity.reason };
   }
-  refreshPlanFields(account, creds);
+  refreshTier(account, creds);
 
   rmSync(dir, { recursive: true, force: true });
   mkdirSync(dir, { recursive: true });
@@ -185,7 +185,7 @@ async function runParkedProbe(dir: string, opts: { retries?: number }): Promise<
 
 async function finishParkedProbe(account: Account, prepared: { dir: string; installed: string }): Promise<void> {
   const isoTarget = isolatedTarget(prepared.dir);
-  const backup = parkedTarget(account.keychainItem);
+  const backup = parkedTarget(credItemFor(account.id));
   try {
     const afterIso = await readItem(isoTarget);
     if (afterIso && afterIso !== prepared.installed) {
@@ -193,7 +193,7 @@ async function finishParkedProbe(account: Account, prepared: { dir: string; inst
       const installedToken = CredentialBlobSchema.parse(JSON.parse(prepared.installed)).claudeAiOauth.accessToken;
       const parkedToken = parkedNow == null ? null : CredentialBlobSchema.parse(JSON.parse(parkedNow)).claudeAiOauth.accessToken;
       if (parkedToken === installedToken) await writeItem(backup, claudeAiOauthOnly(afterIso));
-      else log("sample.harvest_skipped", { account: account.accountUuid.slice(0, 8) });
+      else log("sample.harvest_skipped", { account: account.id.slice(0, 8) });
     }
   } finally {
     await deleteItem(isoTarget);
@@ -202,7 +202,7 @@ async function finishParkedProbe(account: Account, prepared: { dir: string; inst
 }
 
 export async function probeParkedUsage(account: Account): Promise<SampleOutcome> {
-  const prepared = await prepareParkedProbe(account, join(paths.sampleDir, credItemFor(account.accountUuid)));
+  const prepared = await prepareParkedProbe(account, join(paths.sampleDir, credItemFor(account.id)));
   if (!prepared.ok) return prepared;
   try {
     return await runParkedProbe(prepared.dir, {});
@@ -214,21 +214,21 @@ export async function probeParkedUsage(account: Account): Promise<SampleOutcome>
 const PREPARE_DEADLINE_MS = 20_000;
 
 export async function sampleOldestParked(cfg: Config): Promise<void> {
-  const reserved = await withLock(paths.lockFile, async () => {
+  const reserved = await withLock(claudePool.lockFile, async () => {
     const now = Date.now();
-    const lastSwapAt = loadLastSwapAt();
+    const lastSwapAt = loadLastSwapAt(claudePool);
     if (lastSwapAt != null && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) return null;
-    const idx = loadAccounts();
+    const idx = loadAccounts(claudePool);
     const live = readOAuthAccount()?.accountUuid ?? null;
     const sampledAt = (a: Account) => Math.max(a.lastUsageAt ?? 0, a.lastProbeAt ?? 0);
-    const stale = idx.accounts.filter((a) => a.accountUuid !== live && a.needsReauth !== true && now - sampledAt(a) > cfg.policy.usagePollTtlMs);
+    const stale = idx.accounts.filter((a) => a.id !== live && a.needsReauth !== true && now - sampledAt(a) > cfg.policy.usagePollTtlMs);
     const target = minBy(stale, sampledAt);
     if (!target) return null;
     target.lastProbeAt = now;
-    const prepared = await prepareParkedProbe(target, join(paths.sampleDir, `${credItemFor(target.accountUuid)}-tick`), AbortSignal.timeout(PREPARE_DEADLINE_MS));
-    saveAccounts(idx);
+    const prepared = await prepareParkedProbe(target, join(paths.sampleDir, `${credItemFor(target.id)}-tick`), AbortSignal.timeout(PREPARE_DEADLINE_MS));
+    saveAccounts(claudePool, idx);
     if (!prepared.ok) {
-      log("sample.parked_failed", { account: target.accountUuid.slice(0, 8), reason: prepared.reason.slice(0, 200) });
+      log("sample.parked_failed", { account: target.id.slice(0, 8), reason: prepared.reason.slice(0, 200) });
       return null;
     }
     return { account: target, prepared };
@@ -240,18 +240,18 @@ export async function sampleOldestParked(cfg: Config): Promise<void> {
   try {
     outcome = await runParkedProbe(prepared.dir, { retries: 0 });
   } finally {
-    await withLock(paths.lockFile, async () => {
+    await withLock(claudePool.lockFile, async () => {
       await finishParkedProbe(account, prepared);
       if (outcome == null) return;
-      const idx = loadAccounts();
-      const stored = idx.accounts.find((a) => a.accountUuid === account.accountUuid);
+      const idx = loadAccounts(claudePool);
+      const stored = idx.accounts.find((a) => a.id === account.id);
       if (stored && outcome.ok && (stored.lastUsageAt == null || startedAt > stored.lastUsageAt)) {
-        stored.lastUsage = keepRows(outcome.usage, stored.lastUsage, startedAt);
+        stored.windows = mergeWindows(windowsOf(outcome.usage, startedAt), stored.windows);
         stored.lastUsageAt = startedAt;
-        saveAccounts(idx);
+        saveAccounts(claudePool, idx);
       }
       log(outcome.ok ? "sample.parked_ok" : "sample.parked_failed", {
-        account: account.accountUuid.slice(0, 8),
+        account: account.id.slice(0, 8),
         ...(outcome.ok ? {} : { reason: outcome.reason.slice(0, 200) }),
       });
     });
@@ -300,7 +300,7 @@ export async function probeActiveUsage(account: Account): Promise<SampleOutcome>
   const identity = await checkIdentity(creds, account);
   if (identity.status === "mismatch") return { ok: false, reason: `live ${identity.reason} - active label drifted; run \`tokenmaxxing switch\`` };
   if (identity.status === "unavailable") return { ok: false, reason: identity.reason };
-  refreshPlanFields(account, creds);
+  refreshTier(account, creds);
 
   const usage = await probeUsage();
   return usage ? { ok: true, usage } : { ok: false, reason: "`/usage` returned no limit data (see log)" };