tokenmaxxing 1.171.0 → 1.173.0

package/README.md

@@ -1,6 +1,6 @@
 # tokenmaxxing
 
-**Automatic Claude Code account switching.** Run `claude` exactly as you always do; each session starts on the pooled account with the most headroom per running session, and when that account nears its usage limit, tokenmaxxing resumes the session on a fresher account at a safe turn boundary - same conversation, compacted on the account it leaves and restarted under another account's credential store with a first prompt that asks Claude to continue. Works across many concurrent sessions, which spread over the pool instead of draining one account together. When the whole pool is at its limit, a session queues first come first served for a reset (at most eight sessions wait on one account; overflow waits for the next reset with room) and pauses with a countdown until its assigned reset, when that reset falls within twice `policy.maxWaitMs` (default 1h - a longer wait stays put rather than parking your terminal for hours).
+**Automatic Claude Code account switching.** Run `claude` exactly as you always do; each session starts on the pooled account with room for it whose weekly quota is closest to expiring unused, and when that account nears its usage limit, tokenmaxxing resumes the session on a fresher account at a safe turn boundary - same conversation, compacted on the account it leaves and restarted under another account's credential store with a first prompt that asks Claude to continue. Works across many concurrent sessions, which spread over the pool instead of draining one account together. When the whole pool is at its limit, a session queues first come first served for a reset (at most eight sessions wait on one account; overflow waits for the next reset with room) and pauses with a countdown until its assigned reset, when that reset falls within twice `policy.maxWaitMs` (default 1h - a longer wait stays put rather than parking your terminal for hours).
 
 > **Scope:** Claude Code on macOS and Linux, plus OpenAI's Codex CLI as a second switching pool; grok and Muse Code as status-only pools. It pools **subscription** accounts (Pro/Max), not API keys.
 
@@ -62,7 +62,7 @@ Each session runs on its own seat. One rule: while the seat is under its bars, n
 
 The bars' headroom is deliberate: it's the budget to reach a clean turn boundary before the account's real limit. The session bar sits lower (90) because a 5-hour reset is cheap to sit out; weekly quota is use-it-or-lose-it, so it drains closer to the limit (98). The default margin is 0, so the configured thresholds and the effective bars read the same.
 
-Launches and moves rank usable accounts by session-window headroom per running session, `(bar - used) / (sessions + 1)`, so two fresh accounts alternate and a third session goes to whichever has more headroom left per session; ties break by pace pressure (remaining percent of the binding gated per-model cap, or of the weekly aggregate for an account with no gated row, divided by time to its reset, highest first), then soonest weekly reset, then lowest weekly use. Organization membership is not an input.
+Launches and moves rank usable accounts in groups first: plan headroom before usage credits, a credential store that read cleanly, room for a whole session (session-window headroom per running session, `(bar - used) / (sessions + 1)`, scaled by plan size, at least 15 unless the session window resets within the hour), a weekly reset within 4 days, and a usage figure under 6 hours old. Within a group, the highest pace pressure scaled by plan size wins (remaining percent of the binding gated per-model cap, or of the weekly aggregate for an account with no gated row, divided by time to its reset), so weekly quota closest to expiring unused is spent first; ties break by soonest weekly reset, then headroom per session, then lowest weekly use, then fewest sessions. Plan size reads the account's tier: a Claude multiplier divided by 5 (`max 20x` is 4, `pro` 0.2), Codex relative to Plus (`prolite` 5, `pro` 10, `promax` 20). Organization membership is not an input.
 
 - Every periodic check tick folds fresh session tees (the statusline of a terminal session, the `rate_limit_event` stream of a T3 Code or Agent SDK session) into the index and samples up to three accounts whose last sample attempt is oldest, skipping any attempted within the account's sample interval (15 minutes for an empty account or one with no session on this host, shrinking to `policy.usagePollTtlMs` as a live account nears a bar, and 15 minutes again at or over an aggregate bar), with the direct no-spend usage read; a move reads the cached figures, which are as fresh as each account's last successful attempt or its sessions' latest push. A sample that finds the stored access token expired has Claude Code refresh it first (`claude -p /usage` under that store) and reads with the new token.
 - When no account is usable, the session queues first come first served onto a reset target (at most eight waiters per account; overflow waits for the next reset with room) and pauses until that reset if it lands within twice `policy.maxWaitMs`, and otherwise stays put.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.171.0",
+  "version": "1.173.0",
   "description": "Automatic Claude Code account switching: pool multiple accounts, start each session on its own account, and resume a session on a fresher account when quota fills.",
   "type": "module",
   "license": "MIT",

package/src/lib/claude.ts

@@ -140,6 +140,12 @@ async function storeUsable(a: Account): Promise<boolean> {
   }
 }
 
+export function claudePlanWeight(a: Account): number {
+  const multiplier = a.tier?.match(/(\d+)x\b/)?.[1];
+  if (multiplier != null) return Number(multiplier) / 5;
+  return a.tier?.startsWith("pro") ? 0.2 : 1;
+}
+
 export type Seat = { account: Account; depletedUntil?: number };
 
 export function pickSeat(now: number, model: ModelInfo | null, eligible: (a: Account) => boolean = () => true): Seat | null {
@@ -150,7 +156,7 @@ export function pickSeat(now: number, model: ModelInfo | null, eligible: (a: Acc
   for (const a of idx.accounts) dirty = foldTee(a, bars) || dirty;
   if (dirty) saveAccounts(claudePool, idx);
   const seats = presence();
-  const ctx: PickCtx = { now, thresholds: bars, currentId: null, families: gatedFamilies(model, cfg.policy.switchModels), seats };
+  const ctx: PickCtx = { now, thresholds: bars, currentId: null, families: gatedFamilies(model, cfg.policy.switchModels), seats, planWeight: claudePlanWeight };
   const candidates = idx.accounts.filter(eligible);
   const best = pickBest(candidates, ctx);
   if (best) return { account: best };
@@ -204,7 +210,7 @@ export async function borrowClaudeSeat(pid: number, named?: string): Promise<Sea
     }
     const open = idx.accounts.filter((a) => a.needsReauth !== true);
     const usable = await Promise.all(open.map(storeUsable));
-    const ctx: PickCtx = { now: Date.now(), thresholds: bars, currentId: null, families: gatedFamilies(null, cfg.policy.switchModels), seats: presence(living) };
+    const ctx: PickCtx = { now: Date.now(), thresholds: bars, currentId: null, families: gatedFamilies(null, cfg.policy.switchModels), seats: presence(living), planWeight: claudePlanWeight };
     const picked = pickBest(open.filter((_, i) => usable[i]), ctx);
     if (!picked) return null;
     writePresence({ dir: paths.presenceDir, id: seatId, accountId: picked.id, pid });
@@ -361,6 +367,7 @@ export const claude: Provider = {
   apiKeys: claudeApiKeys,
   liveId,
   presence,
+  planWeight: claudePlanWeight,
   gatedFamilies: (cfg) => {
     const seat = liveId();
     const model = modelFromFlag(env("TOKENMAXXING_MODEL", "")) ?? (seat == null ? null : (loadUsageSnapshot(seat)?.state.model ?? null));

package/src/lib/codex.ts

@@ -41,13 +41,22 @@ function applyUsage(account: Account, usage: CodexUsage, at: number): void {
   if (usage.planType != null) account.tier = usage.planType;
 }
 
-type CodexReadFailure = { ok: false; reason: string; deadGrant: boolean; expiring?: boolean; rejectedToken?: string };
+type CodexReadFailure = { ok: false; reason: string; deadGrant: boolean; deadAccessToken?: string; expiring?: boolean; rejected?: boolean; rejectedToken?: string };
 type CodexReadOutcome = { ok: true; usage: CodexUsage; at: number } | CodexReadFailure;
 
 const REJECTED_REFRESH_BACKOFF_MS = 60 * 60 * 1000;
 
 function afterRejection(rejected: CodexReadFailure, refreshFailure: CodexReadFailure): CodexReadFailure {
-  return { ...refreshFailure, reason: `${rejected.reason}; refresh skipped: ${refreshFailure.reason}` };
+  return { ...refreshFailure, rejected: true, reason: `${rejected.reason}; refresh skipped: ${refreshFailure.reason}` };
+}
+
+function storeHolds(accountId: string, accessToken: string | undefined): boolean {
+  if (accessToken === undefined) return true;
+  try {
+    return readCodexStoreAuth(accountId)?.tokens.access_token === accessToken;
+  } catch {
+    return false;
+  }
 }
 
 async function freshCodexAuth(account: Account, now: number, refresh: boolean, holder?: string, rejectedToken?: string): Promise<{ ok: true; auth: CodexAuthJson } | CodexReadFailure> {
@@ -70,7 +79,7 @@ async function freshCodexAuth(account: Account, now: number, refresh: boolean, h
   try {
     auth = await refreshCodexAuth({ auth, now });
   } catch (e) {
-    if (e instanceof CodexInvalidGrantError) return { ok: false, reason: e.message, deadGrant: true };
+    if (e instanceof CodexInvalidGrantError) return { ok: false, reason: e.message, deadGrant: true, deadAccessToken: auth.tokens.access_token };
     if (e instanceof CodexRefreshFailedError) return { ok: false, reason: e.message, deadGrant: false };
     throw e;
   }
@@ -85,22 +94,25 @@ async function readCodexUsageOnce(account: Account, now: number, refresh: boolea
     const at = Date.now();
     return { ok: true, usage: await fetchCodexUsage({ auth: fresh.auth, at }), at };
   } catch (e) {
-    if (e instanceof CodexUsageReadError) return { ok: false, reason: e.message, deadGrant: false, rejectedToken: e.status === 401 ? fresh.auth.tokens.access_token : undefined };
+    if (e instanceof CodexUsageReadError) return { ok: false, reason: e.message, deadGrant: false, rejected: e.status === 401, rejectedToken: e.status === 401 ? fresh.auth.tokens.access_token : undefined };
     throw e;
   }
 }
 
 async function readCodexUsage(account: Account, now: number, refresh: boolean, holder?: string): Promise<CodexReadOutcome> {
   const outcome = await readCodexUsageOnce(account, now, refresh, holder);
-  if (outcome.ok || outcome.rejectedToken === undefined || !refresh) return outcome;
+  if (outcome.ok || outcome.rejectedToken === undefined) return outcome;
   const { rejectedToken } = outcome;
   const fresh = await withLock(codexPool.lockFile, () => freshCodexAuth(account, now, true, holder, rejectedToken));
-  return fresh.ok ? readCodexUsageOnce(account, now, false) : afterRejection(outcome, fresh);
+  if (!fresh.ok) return afterRejection(outcome, fresh);
+  const retried = await readCodexUsageOnce(account, now, false);
+  return retried.ok ? retried : { ...retried, rejectedToken: undefined };
 }
 
-export async function observeCodex(account: Account, cfg: Config, now: number, opts: { probe: boolean; refresh: boolean; holder?: string }): Promise<Observation | null> {
+export async function observeCodex(account: Account, cfg: Config, now: number, opts: { probe: boolean; refresh: boolean; holder?: string; rejected?: Set<string> }): Promise<Observation | null> {
   if (opts.probe && (account.lastUsageAt == null || now - account.lastUsageAt > cfg.policy.usagePollTtlMs)) {
     const outcome = await readCodexUsage(account, now, opts.refresh, opts.holder);
+    if (!outcome.ok && outcome.rejected === true) opts.rejected?.add(account.id);
     await withLock(codexPool.lockFile, () => {
       const idx = loadAccounts(codexPool);
       const a = idx.accounts.find((x) => x.id === account.id);
@@ -109,7 +121,7 @@ export async function observeCodex(account: Account, cfg: Config, now: number, o
         if (a.lastUsageAt == null || outcome.at > a.lastUsageAt) {
           applyUsage(a, outcome.usage, outcome.at);
         }
-      } else if (outcome.deadGrant) {
+      } else if (outcome.deadGrant && storeHolds(a.id, outcome.deadAccessToken)) {
         a.needsReauth = true;
       }
       saveAccounts(codexPool, idx);
@@ -126,23 +138,31 @@ async function samplePool(accounts: Account[], now: number): Promise<Map<string,
       applyUsage(account, outcome.usage, outcome.at);
       reports.set(account.id, { ok: true, source: "probe" });
     } else {
-      if (outcome.deadGrant) account.needsReauth = true;
       reports.set(account.id, { ok: false, reason: outcome.reason });
     }
   };
   const expiring: { account: Account; rejected?: CodexReadFailure }[] = [];
   await Promise.all(
     accounts.map(async (account) => {
-      const outcome = await readCodexUsage(account, now, false);
+      const outcome = await readCodexUsageOnce(account, now, false);
       if (!outcome.ok && (outcome.expiring === true || outcome.rejectedToken !== undefined)) expiring.push({ account, rejected: outcome.rejectedToken === undefined ? undefined : outcome });
       else record(account, outcome);
     }),
   );
   if (expiring.length > 0) {
-    const rotated = await withLock(codexPool.lockFile, () => Promise.all(expiring.map(async ({ account, rejected }) => ({ account, rejected, fresh: await freshCodexAuth(account, now, true, undefined, rejected?.rejectedToken) }))));
+    const rotated = await withLock(codexPool.lockFile, async () => {
+      const results = await Promise.all(expiring.map(async ({ account, rejected }) => ({ account, rejected, fresh: await freshCodexAuth(account, now, true, undefined, rejected?.rejectedToken) })));
+      const dead = new Set(results.filter(({ fresh }) => !fresh.ok && fresh.deadGrant).map(({ account }) => account.id));
+      if (dead.size > 0) {
+        const idx = loadAccounts(codexPool);
+        for (const a of idx.accounts) if (dead.has(a.id)) a.needsReauth = true;
+        saveAccounts(codexPool, idx);
+      }
+      return results;
+    });
     await Promise.all(
       rotated.map(async ({ account, rejected, fresh }) =>
-        record(account, fresh.ok ? await readCodexUsage(account, now, false) : rejected ? afterRejection(rejected, fresh) : fresh),
+        record(account, fresh.ok ? await readCodexUsageOnce(account, now, false) : rejected ? afterRejection(rejected, fresh) : fresh),
       ),
     );
   }
@@ -256,8 +276,31 @@ function install(): void {
   console.log(c.yellow("`tokenmaxxing doctor` lists seats still needing trust."));
 }
 
+// Relative to Plus. prolite (Pro 100) is 5x per OpenAI's launch; pro (Pro 200) was 20x and is about 10x for new
+// subscribers; promax (Pro 500) is unpublished beyond "the most". Business, Enterprise, and Edu seats match Plus.
+const CODEX_PLAN_WEIGHTS: Record<string, number> = {
+  free: 0.2,
+  go: 0.5,
+  plus: 1,
+  team: 1,
+  business: 1,
+  enterprise: 1,
+  ent26: 1,
+  edu: 1,
+  edu_plus: 1,
+  prolite: 5,
+  self_serve_business_prolite: 5,
+  edu_pro: 5,
+  pro: 10,
+  promax: 20,
+};
+
+export function codexPlanWeight(a: Account): number {
+  return (a.tier == null ? undefined : CODEX_PLAN_WEIGHTS[a.tier.toLowerCase()]) ?? 1;
+}
+
 export function codexPickCtx(now: number, currentId: string | null): PickCtx {
-  return { now, thresholds: thresholdBars(loadConfig()), currentId, families: null, seats: null };
+  return { now, thresholds: thresholdBars(loadConfig()), currentId, families: null, seats: null, planWeight: codexPlanWeight };
 }
 
 export function pickCodexSeat(now: number, eligible: (a: Account) => boolean = (a) => codexStoreUsable(a.id)): Account | null {
@@ -271,10 +314,11 @@ export async function borrowCodexSeat(pid: number): Promise<SeatBorrow> {
   const now = Date.now();
   const seatId = `seat-${pid}`;
   const cfg = loadConfig();
+  const rejected = new Set<string>();
   await Promise.all(
     loadAccounts(codexPool)
       .accounts.filter((a) => a.needsReauth !== true && codexStoreUsable(a.id))
-      .map((a) => observeCodex(a, cfg, now, { probe: true, refresh: false })),
+      .map((a) => observeCodex(a, cfg, now, { probe: true, refresh: false, rejected })),
   );
   const granted = await withLock(codexPool.lockFile, (): SeatBorrow => {
     const ctx = codexPickCtx(now, null);
@@ -283,6 +327,9 @@ export async function borrowCodexSeat(pid: number): Promise<SeatBorrow> {
     const held = living.find((p) => p.id === seatId);
     const heldAccount = held ? (idx.accounts.find((x) => x.id === held.accountId) ?? null) : null;
     if (heldAccount) {
+      if (rejected.has(heldAccount.id)) {
+        return { denied: "the usage endpoint rejects the account this pid holds and its store could not be refreshed now - borrow again later" };
+      }
       if (heldAccount.needsReauth === true) {
         return { denied: "the account this pid holds needs reauthentication - run `tokenmaxxing auth --codex` and borrow again" };
       }
@@ -295,7 +342,7 @@ export async function borrowCodexSeat(pid: number): Promise<SeatBorrow> {
     const closed = new Set(living.filter((p) => p.id === parent || p.id.startsWith(PI_PRESENCE_PREFIX)).map((p) => p.accountId));
     const lent = countBy(living, (p) => p.accountId);
     const usable = idx.accounts.filter(
-      (a) => !closed.has(a.id) && a.needsReauth !== true && !isExhausted(a, ctx) && codexStoreUsable(a.id)
+      (a) => !closed.has(a.id) && !rejected.has(a.id) && a.needsReauth !== true && !isExhausted(a, ctx) && codexStoreUsable(a.id)
     );
     const plan = usable.filter((a) => !onCredits(a, ctx));
     const open = plan.length > 0 ? plan : usable;
@@ -319,6 +366,7 @@ export const codex: Provider = {
   statusOnly: false,
   liveId,
   presence,
+  planWeight: codexPlanWeight,
   gatedFamilies: () => null,
   observeLive: (account, cfg, now, opts) => observeCodex(account, cfg, now, { probe: opts.probe, refresh: true }),
   samplePool,

package/src/lib/decide.ts

@@ -199,7 +199,7 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), canRes
     while (true) {
       const cur = loadAccounts(p.pool);
       const seat = seatOf(cur);
-      const ctx: PickCtx = { now, thresholds: bars, currentId: seat?.id ?? null, families: switchFamilies, seats };
+      const ctx: PickCtx = { now, thresholds: bars, currentId: seat?.id ?? null, families: switchFamilies, seats, planWeight: p.planWeight };
       const credited = !enforced2 && seat != null && !seat.needsReauth && !isExhausted(seat, ctx) && onCredits(seat, ctx);
       const best = pickBest(usable(cur.accounts).filter((a) => !((credited || keyId != null) && opts.refused?.includes(a.id))), ctx);
       if (credited && (best == null || onCredits(best, ctx))) return { swapped: false, account: null, reason: "no-plan-headroom" };
@@ -232,7 +232,7 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), canRes
     while (true) {
       const fresh = loadAccounts(p.pool);
       const current = seatOf(fresh);
-      const ctx: PickCtx = { now, thresholds: bars, currentId: current?.id ?? null, families: switchFamilies, seats };
+      const ctx: PickCtx = { now, thresholds: bars, currentId: current?.id ?? null, families: switchFamilies, seats, planWeight: p.planWeight };
       const others = liveWaitClaims(now).filter((c) => c.sessionId !== waiterId);
       const waiters = new Map(Object.entries(countBy(others, (c) => c.accountId)));
       const waitable = usable(fresh.accounts).filter((a) => keyId == null || !opts.refused?.includes(a.id));

package/src/lib/picker.ts

@@ -17,6 +17,7 @@ export type PickCtx = {
   currentId: string | null;
   families: string[] | null;
   seats: Map<string, number> | null;
+  planWeight?: (a: Account) => number;
 };
 
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
@@ -166,29 +167,58 @@ export function seatHeadroom(a: Account, ctx: PickCtx): number {
 
 const MIN_SEAT_HEADROOM = 5;
 
+const planWeight = (a: Account, ctx: PickCtx): number => ctx.planWeight?.(a) ?? 1;
+
 function seatFull(a: Account, ctx: PickCtx): boolean {
   const session = sessionWindow(a);
   if (ctx.seats == null || session == null || spendsCredits(a, ctx.thresholds)) return false;
-  return seatHeadroom(a, ctx) < MIN_SEAT_HEADROOM;
+  return seatHeadroom(a, ctx) * planWeight(a, ctx) < MIN_SEAT_HEADROOM;
 }
 
 export function onCredits(a: Account, ctx: PickCtx): boolean {
   return spendsCredits(a, ctx.thresholds) && isExhausted({ ...a, hasCredits: false }, ctx);
 }
 
+const DAY_MS = 24 * 60 * 60 * 1000;
+const WEEKLY_SOON_MS = 4 * DAY_MS;
+const THREAD_HEADROOM = 15;
+const SESSION_SOON_MS = 60 * 60 * 1000;
+const STALE_MS = 6 * 60 * 60 * 1000;
+
+function cramped(a: Account, ctx: PickCtx): boolean {
+  const session = sessionWindow(a);
+  if (session == null || spendsCredits(a, ctx.thresholds)) return false;
+  const end = windowEnd(session);
+  const resetsSoon = end > ctx.now && end - ctx.now <= SESSION_SOON_MS;
+  return !resetsSoon && seatHeadroom(a, ctx) * planWeight(a, ctx) < THREAD_HEADROOM;
+}
+
+// Judged per window, because a fresh statusline sample refreshes the session and weekly figures but carries an old per-model cap forward.
+function stale(a: Account, ctx: PickCtx): boolean {
+  const read = [sessionWindow(a), weeklyWindow(a), ...gatedWindows(a, ctx.families)];
+  return read.some((w) => w != null && windowEnd(w) > ctx.now && ctx.now - w.sampledAt > STALE_MS);
+}
+
 const swapPreference = (ctx: PickCtx) => [
   (a: Account) => (onCredits(a, ctx) ? 1 : 0),
-  ...(ctx.seats == null ? [] : [(a: Account) => -seatHeadroom(a, ctx)]),
-  (a: Account) => -pacePressure(a, ctx),
+  (a: Account) => ((a.storeFails ?? 0) > 0 ? 1 : 0),
+  (a: Account) => (a.windows.length === 0 ? 1 : 0),
+  // A full account ranks after every open one, and among full accounts the most room per session wins.
+  (a: Account) => (seatFull(a, ctx) ? 1 : 0),
+  (a: Account) => (seatFull(a, ctx) ? -seatHeadroom(a, ctx) * planWeight(a, ctx) : 0),
+  (a: Account) => (cramped(a, ctx) ? 1 : 0),
+  (a: Account) => (weeklyExpiry(a, ctx.now) - ctx.now <= WEEKLY_SOON_MS ? 0 : 1),
+  (a: Account) => (stale(a, ctx) ? 1 : 0),
+  (a: Account) => -pacePressure(a, ctx) * planWeight(a, ctx),
   (a: Account) => weeklyExpiry(a, ctx.now),
+  ...(ctx.seats == null ? [] : [(a: Account) => -seatHeadroom(a, ctx) * planWeight(a, ctx)]),
   (a: Account) => weeklyWindow(a)?.usedPercentage ?? 101,
   ...(ctx.seats == null ? [] : [(a: Account) => ctx.seats?.get(a.id) ?? 0]),
 ];
 
 export function pickBest(accounts: Account[], ctx: PickCtx): Account | null {
   const usable = accounts.filter((a) => a.id !== ctx.currentId && !a.needsReauth && !isExhausted(a, ctx));
-  const open = usable.filter((a) => !seatFull(a, ctx));
-  return sortBy(open.length > 0 ? open : usable, swapPreference(ctx))[0] ?? null;
+  return sortBy(usable, swapPreference(ctx))[0] ?? null;
 }
 
 export function usableAt(a: Account, ctx: PickCtx): number {

package/src/lib/provider.ts

@@ -36,6 +36,7 @@ export type Provider = {
   liveId(): string | null;
   presence(): Map<string, number>;
   gatedFamilies(cfg: Config): string[] | null;
+  planWeight?(account: Account): number;
   observeLive(account: Account, cfg: Config, now: number, opts: { probe: boolean; perModel: boolean }): Promise<Observation | null>;
   samplePool(accounts: Account[], now: number): Promise<Map<string, SampleReport>>;
   mergeWindows(next: Window[], prev: Window[]): Window[];