tokenmaxxing 1.86.0 → 1.88.0

package/DESIGN.md

@@ -37,7 +37,7 @@ It is a process manager only - spawn with inherited stdio (stdin through a relay
   - `usage/<uuid8>.json` - the statusline tee per account, written by the sessions running on it.
   - `live/<session-id>` - PID-validated presence per supervised session, naming its account; placement counts them.
   - `respawn/<session-id>` - per-session respawn markers (the hook→supervisor signal): the target account, the session to resume, a `waitUntil`, a `compact` flag, the `origin` (the hook or the seat watch that wrote it), and the launch time the marker was written for.
-  - `wait-queue.json` - the depleted-pool wait claims (`{sessionId, accountId, at, waitUntil}`), so at most four sessions wait on one account; a session that arrives when every account already has four waiters takes the soonest reset anyway.
+  - `wait-queue.json` - the claims of supervised sessions that are moving or waiting (`{sessionId, accountId, at, waitUntil}`), naming the account each relaunches on: placement counts a claimed session there, and at most four sessions wait on one account; a session that arrives when every account already has four waiters takes the soonest reset anyway.
   - `bin/claude` and `bin/codex` - the supervisors, beside the `tokenmaxxing` and `xx` entry points; `bin/pi` after `init --pi`.
   - `pi-stores/claude/<uuid8>/` and `pi-stores/codex/<uuid8>/` - one pi store per pooled account that has a pi login: the account's own pi grant in `auth.json`, everything else symlinked to the shared `~/.pi/agent` ([pi support](docs/content/docs/pi.mdx)).
   - `sessions/<sid>.json`, `onboard/`, `hub-key`, `update.json`, `spawnrate.json`, `tokenmaxxing.log`, the codex `codex-onboard/`, `codex-respawn/`, and `codex-live/`, and the `grok-*` and `opencode-go-*` state of the status-only pools: the full table is in [State directory layout](docs/content/docs/state-directory.mdx).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.86.0",
+  "version": "1.88.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/cli/serve.ts

@@ -14,7 +14,7 @@ import type { Provider } from "../lib/provider.ts";
 import { foldTee } from "../lib/sample.ts";
 import { loadAccounts, loadConfig } from "../lib/state.ts";
 import { OAUTH_USAGE_URL } from "../lib/usage.ts";
-import type { Account, Config } from "../lib/types.ts";
+import type { Account, Config, Thresholds } from "../lib/types.ts";
 import { c, emitError } from "./render.ts";
 import { usageReport, type UsageReport, type WindowReport } from "./status.ts";
 
@@ -24,7 +24,7 @@ const STALE_AFTER_MS = 2 * 60 * 60_000;
 type HubPool = {
   provider: Provider;
   usageUrl: string;
-  fold: (account: Account) => void;
+  fold: (account: Account, thresholds: Thresholds) => void;
   read: (account: Account, cfg: Config, now: number) => Promise<Account>;
   body: (usage: UsageReport, account: Account) => unknown;
 };
@@ -96,7 +96,7 @@ function authFiles(cfg: Config, now: number): unknown {
   const files = POOLS.flatMap((pool) => {
     const ctx = { now, thresholds: thresholdBars(cfg), currentId: null, families: pool.provider.gatedFamilies(cfg), seats: null };
     return loadAccounts(pool.provider.pool).accounts.map((a) => {
-      pool.fold(a);
+      pool.fold(a, ctx.thresholds);
       return {
         id: a.id,
         auth_index: authIndex(pool, a),
@@ -140,8 +140,9 @@ async function apiCall(req: Request): Promise<Response> {
   const account = loadAccounts(pool.provider.pool).accounts.find((a) => authIndex(pool, a) === index);
   if (!account) return json({ error: "auth credential not found for auth_index" }, 400);
   const now = Date.now();
-  const current = await pool.read(account, loadConfig(), now);
-  pool.fold(current);
+  const cfg = loadConfig();
+  const current = await pool.read(account, cfg, now);
+  pool.fold(current, thresholdBars(cfg));
   const usage = usageReport({ ...current, windows: current.windows.filter((w) => now - w.sampledAt <= STALE_AFTER_MS) }, now);
   if (!usage || (!usage.fiveHour && !usage.week)) return json({ error: `no usage figure newer than ${STALE_AFTER_MS / 3_600_000}h for this account` }, 502);
   return json({ status_code: 200, header: { "Content-Type": ["application/json"] }, body: JSON.stringify(pool.body(usage, current)) });

package/src/cli/status.ts

@@ -6,7 +6,7 @@ import { opencodeGo } from "../lib/opencodego.ts";
 import { loadAccounts, loadConfig, saveAccounts } from "../lib/state.ts";
 import { withLock } from "../lib/lock.ts";
 import { codexPool, grokPool, opencodeGoPool } from "../lib/paths.ts";
-import { earliestReset, gatedWindows, isExhausted, isSessionWindow, limitWindows, liveUsed, nextWeeklyReset, sessionWindow, thresholdBars, weeklyWindow } from "../lib/picker.ts";
+import { earliestReset, gatedWindows, landWindows, isExhausted, isSessionWindow, limitWindows, liveUsed, nextWeeklyReset, sessionWindow, thresholdBars, weeklyWindow } from "../lib/picker.ts";
 import type { Provider, SampleReport } from "../lib/provider.ts";
 import { bar, c, count, emitJson, fmtAgo } from "./render.ts";
 import type { Account, Config, Thresholds, Window } from "../lib/types.ts";
@@ -84,25 +84,46 @@ function gatedNote(accounts: Account[], families: string[] | null, weeklyBar: nu
 }
 
 async function collect(p: Provider, cfg: Config, now: number, cached: boolean): Promise<PoolReport> {
+  const bars = thresholdBars(cfg);
   let idx = loadAccounts(p.pool);
   let reports = new Map<string, SampleReport>();
   let liveId: string | null = null;
   if (!cached && idx.accounts.length > 0) {
-    await withLock(p.pool.lockFile, async () => {
-      idx = loadAccounts(p.pool);
-      const notice = process.stderr.isTTY;
-      if (notice) process.stderr.write(c.dim(`sampling ${p.name} usage...`));
-      try {
-        liveId = p.liveId();
-        reports = await p.samplePool(idx.accounts, liveId, now);
-      } finally {
-        if (notice) process.stderr.write("\r\x1b[2K");
-      }
-      saveAccounts(p.pool, idx);
-    });
+    const notice = process.stderr.isTTY;
+    if (notice) process.stderr.write(c.dim(`sampling ${p.name} usage...`));
+    try {
+      liveId = p.liveId();
+      const retries = new Map(idx.accounts.map((a) => [a.id, a.usageRetryAt ?? null]));
+      reports = await p.samplePool(idx.accounts, liveId, now);
+      await withLock(p.pool.lockFile, () => {
+        const fresh = loadAccounts(p.pool);
+        let dirty = false;
+        for (const a of idx.accounts) {
+          const stored = fresh.accounts.find((x) => x.id === a.id);
+          if (!stored) continue;
+          if (a.needsReauth === true && stored.needsReauth !== true) {
+            stored.needsReauth = true;
+            dirty = true;
+          }
+          if ((a.usageRetryAt ?? null) !== retries.get(a.id)) {
+            stored.usageRetryAt = a.usageRetryAt;
+            dirty = true;
+          }
+          if (a.lastUsageAt != null && (stored.lastUsageAt == null || a.lastUsageAt > stored.lastUsageAt)) {
+            landWindows(stored, p.mergeWindows(a.windows, stored.windows), a.lastUsageAt, bars);
+            if (a.email != null) stored.email = a.email;
+            if (a.tier != null) stored.tier = a.tier;
+            dirty = true;
+          }
+        }
+        if (dirty) saveAccounts(p.pool, fresh);
+        idx = fresh;
+      });
+    } finally {
+      if (notice) process.stderr.write("\r\x1b[2K");
+    }
   }
 
-  const bars = thresholdBars(cfg);
   const present = p.presence();
   const ctx = { now, thresholds: bars, currentId: null, families: p.gatedFamilies(cfg), seats: null };
   const ordered = sortBy(idx.accounts, [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, now)]);
@@ -235,7 +256,7 @@ export async function cmdStatus(opts: { json?: boolean; cached?: boolean } = {})
       console.log(c.dim("no claude accounts (run `tokenmaxxing init` to pool claude too)"));
       console.log();
     } else {
-      const header = `thresholds 5h ${claudeReport.thresholds.session}% weekly ${claudeReport.thresholds.weekly}%  (${count({ n: claudeReport.accounts.length, noun: "claude account" })})`;
+      const header = `thresholds 5h ${claudeReport.thresholds.session}% weekly ${claudeReport.thresholds.weekly}%  bars 5h ${claudeReport.bars.session}% weekly ${claudeReport.bars.weekly}%  (${count({ n: claudeReport.accounts.length, noun: "claude account" })})`;
       renderPool(claude, claudeReport, header, Date.now(), cfg.policy.usagePollTtlMs);
     }
   }

package/src/entries/pisupervisor.ts

@@ -386,6 +386,13 @@ export async function runPiSupervisor(argv: string[]): Promise<number> {
             savedTermios,
           });
         }
+        if (pool === "claude") {
+          try {
+            releaseWaitClaim(id);
+          } catch (e) {
+            log("pisupervisor.claim_release_failed", { err: errorMessage(e) });
+          }
+        }
         return { proc: spawned, seat: picked };
       });
       if (launched == null) {
@@ -422,7 +429,6 @@ export async function runPiSupervisor(argv: string[]): Promise<number> {
         if (waitUntil > Date.now()) {
           if (await countdownWait(target.label, waitUntil, { stream: false, say })) overriddenUntil = waitUntil;
         } else say(`\n\x1b[36m↻ tokenmaxxing: moving pi to ${target.label} - resuming...\x1b[0m\n`);
-        await releaseClaim();
         wanted = target.id;
         launchArgs = sessionExists(dirs, sid) ? ["--session-id", sid, ...args.flags, "--", RESUME_PROMPT] : firstArgs;
         continue;

package/src/entries/stopfailurehook.ts

@@ -80,8 +80,8 @@ export async function runStopFailureHook(): Promise<number> {
       );
     }
 
-    const decision = await evaluateAndMaybeSwap(claude, now, canRespawn && enforced != null, enforced, { waiterId: canRespawn ? session?.sid : undefined });
-    if (enforced && session && canRespawn && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
+    const decision = await evaluateAndMaybeSwap(claude, now, canRespawn, enforced, { waiterId: canRespawn ? session?.sid : undefined });
+    if (session && canRespawn && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
       writeRespawnMarker({ session, accountId: decision.account.id, waitUntil: decision.waitUntil ?? now, compact: false, origin: "stopfailure" });
       log("stopfailure.marker", { session: session.sid.slice(0, 8), live: session.live.slice(0, 8), account: decision.account.id.slice(0, 8), waitUntil: decision.waitUntil ?? now });
     } else {

package/src/entries/supervisor.ts

@@ -180,7 +180,24 @@ type MarkerGate = {
   overriddenUntil: number;
 };
 
-function consumableMarker(marker: string, gate: MarkerGate): z.infer<typeof RespawnMarkerSchema> | null {
+function releaseClaimLocked(sid: string): void {
+  try {
+    releaseWaitClaim(sid);
+  } catch (e) {
+    log("supervisor.claim_release_failed", { err: errorMessage(e) });
+  }
+}
+
+async function discardMarker(marker: string, event: string, fields: Record<string, unknown>): Promise<null> {
+  await withLock(claudePool.lockFile, () => {
+    rmSync(marker, { force: true });
+    releaseClaimLocked(basename(marker));
+  });
+  log(event, fields);
+  return null;
+}
+
+async function consumableMarker(marker: string, gate: MarkerGate): Promise<z.infer<typeof RespawnMarkerSchema> | null> {
   let m: z.infer<typeof RespawnMarkerSchema>;
   try {
     m = readJsonFile(marker, RespawnMarkerSchema);
@@ -191,14 +208,10 @@ function consumableMarker(marker: string, gate: MarkerGate): z.infer<typeof Resp
     );
   }
   if (m.launchedAt !== undefined && m.launchedAt !== gate.launchedAt) {
-    rmSync(marker, { force: true });
-    log("supervisor.marker_stale", { markerLaunch: m.launchedAt, childLaunch: gate.launchedAt });
-    return null;
+    return discardMarker(marker, "supervisor.marker_stale", { markerLaunch: m.launchedAt, childLaunch: gate.launchedAt });
   }
   if (m.waitUntil > Date.now() && m.waitUntil <= gate.overriddenUntil) {
-    rmSync(marker, { force: true });
-    log("supervisor.marker_overridden", { waitUntil: m.waitUntil });
-    return null;
+    return discardMarker(marker, "supervisor.marker_overridden", { waitUntil: m.waitUntil });
   }
   return m;
 }
@@ -450,6 +463,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
           savedTermios,
         });
       }
+      releaseClaimLocked(sid);
       return { child: spawned, seat: picked };
     });
     if (launched == null) {
@@ -462,7 +476,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
     await raceMarkerOrExit({
       child: proc,
       tick: async () => {
-        if (existsSync(marker) && consumableMarker(marker, gate) != null) return true;
+        if (existsSync(marker) && (await consumableMarker(marker, gate)) != null) return true;
         if (seat && !terminating && Date.now() >= seatCheckAt) {
           const decided = await moveExhaustedSeat(seat, sid, gate, model);
           seatCheckAt = Date.now() + (decided ? SEAT_RETRY_MS : SEAT_POLL_MS);
@@ -478,7 +492,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
       },
     });
 
-    const m = !terminating && existsSync(marker) ? consumableMarker(marker, gate) : null;
+    const m = !terminating && existsSync(marker) ? await consumableMarker(marker, gate) : null;
     if (m) {
       rmSync(marker, { force: true });
       respawns++;
@@ -511,7 +525,6 @@ export async function runSupervisor(argv: string[]): Promise<number> {
       if (m.waitUntil > Date.now()) {
         if (await countdownWait(label, m.waitUntil, { stream, say })) overriddenUntil = m.waitUntil;
       } else say(`\n\x1b[36m↻ tokenmaxxing: moving to ${label} - resuming...\x1b[0m\n`, `tokenmaxxing: moving to ${label} and resuming.`);
-      await releaseClaim();
       wanted = m.accountId;
       saveSessionFlags(m.sessionId, persistable, process.cwd());
       const prompt = resumable ? resumePrompt({ compacted, origin: m.origin }) : null;

package/src/lib/claude.ts

@@ -1,5 +1,6 @@
 import { mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { countBy } from "es-toolkit";
 import { z } from "zod";
 import { readItem, writeItem, deleteItem, isolatedTarget, readStore, storeTarget, claudeAiOauthOnly } from "./credstore.ts";
 import { CLAUDE_BIN, resolveRealBin, resolveVerifiedClaude } from "./claudebin.ts";
@@ -8,12 +9,12 @@ import { withLock } from "./lock.ts";
 import { errorMessage, log } from "./log.ts";
 import { claudeTierLabel, describeIdentity, fetchTokenIdentity, isDeadCredential, InvalidGrantError } from "./oauth.ts";
 import { claudePool, env, paths, seatFromEnv, storeDirFor } from "./paths.ts";
-import { pickBest, pickEarliestReset, thresholdBars, type PickCtx } from "./picker.ts";
+import { landWindows, pickBest, pickEarliestReset, thresholdBars, type PickCtx } from "./picker.ts";
 import { deletePiStore } from "./piauth.ts";
-import { seatCounts } from "./presence.ts";
+import { livingPresences } from "./presence.ts";
 import { StoreUnusableError, type Observation, type Provider, type SampleReport } from "./provider.ts";
 import { foldTee, sampleAccountUsage, teeObservation, usageBlockedUntil } from "./sample.ts";
-import { clearUsageSnapshot, loadAccounts, loadConfig, loadUsageSnapshot, pinBinOverride, readJsonFile, saveAccounts, type Harvest } from "./state.ts";
+import { clearUsageSnapshot, liveWaitClaims, loadAccounts, loadConfig, loadUsageSnapshot, pinBinOverride, readJsonFile, saveAccounts, type Harvest } from "./state.ts";
 import { saveTermios, restoreTermios } from "./tty.ts";
 import { fetchUsageDirect, gatedFamilies, mergeWindows, modelFromFlag, scrubCredentialEnv, windowsOf } from "./usage.ts";
 import { CredentialBlobSchema, JsonTextSchema, OAuthAccountSchema, type Account, type Config, type ModelInfo } from "./types.ts";
@@ -24,7 +25,9 @@ function liveId(): string | null {
 }
 
 function presence(): Map<string, number> {
-  return seatCounts(paths.presenceDir);
+  const seats = new Map(livingPresences(paths.presenceDir).map((s) => [s.id, s.accountId]));
+  for (const claim of liveWaitClaims(Date.now())) seats.set(claim.sessionId, claim.accountId);
+  return new Map(Object.entries(countBy([...seats.values()], (id) => id)));
 }
 
 const PROBE_BACKOFF_CAP_MS = 30 * 60 * 1000;
@@ -48,8 +51,7 @@ async function observeLive(account: Account, cfg: Config, now: number, opts: { p
       if (outcome.ok) {
         a.probeFails = 0;
         if (a.lastUsageAt == null || startedAt > a.lastUsageAt) {
-          a.windows = mergeWindows(windowsOf(outcome.usage, startedAt), a.windows);
-          a.lastUsageAt = startedAt;
+          landWindows(a, mergeWindows(windowsOf(outcome.usage, startedAt), a.windows), startedAt, thresholdBars(cfg));
         }
       } else {
         a.probeFails = (a.probeFails ?? 0) + 1;
@@ -64,12 +66,13 @@ async function observeLive(account: Account, cfg: Config, now: number, opts: { p
 
 async function samplePool(accounts: Account[]): Promise<Map<string, SampleReport>> {
   const reports = new Map<string, SampleReport>();
+  const bars = thresholdBars(loadConfig());
   await Promise.all(
     accounts.map(async (a) => {
       const tee = loadUsageSnapshot(a.id);
       const teeAt = tee == null ? null : (tee.state.sampledAt ?? tee.state.ts);
       if (teeAt != null && (a.lastUsageAt == null || teeAt >= a.lastUsageAt)) {
-        foldTee(a);
+        foldTee(a, bars);
         reports.set(a.id, { ok: true, source: "statusline" });
         return;
       }
@@ -80,8 +83,7 @@ async function samplePool(accounts: Account[]): Promise<Map<string, SampleReport
         return;
       }
       const at = Date.now();
-      a.lastUsageAt = at;
-      a.windows = mergeWindows(windowsOf(outcome.usage, at), a.windows);
+      landWindows(a, mergeWindows(windowsOf(outcome.usage, at), a.windows), at, bars);
       reports.set(a.id, { ok: true, source: "probe" });
     }),
   );
@@ -120,11 +122,12 @@ async function storeUsable(a: Account): Promise<boolean> {
 
 export function pickSeat(now: number, model: ModelInfo | null, eligible: (a: Account) => boolean = () => true): Account | null {
   const cfg = loadConfig();
+  const bars = thresholdBars(cfg);
   const idx = loadAccounts(claudePool);
   let dirty = false;
-  for (const a of idx.accounts) dirty = foldTee(a) || dirty;
+  for (const a of idx.accounts) dirty = foldTee(a, bars) || dirty;
   if (dirty) saveAccounts(claudePool, idx);
-  const ctx: PickCtx = { now, thresholds: thresholdBars(cfg), currentId: null, families: gatedFamilies(model, cfg.policy.switchModels), seats: presence() };
+  const ctx: PickCtx = { now, thresholds: bars, currentId: null, families: gatedFamilies(model, cfg.policy.switchModels), seats: presence() };
   const candidates = idx.accounts.filter(eligible);
   return pickBest(candidates, ctx) ?? pickEarliestReset(candidates, ctx)?.account ?? null;
 }

package/src/lib/codex.ts

@@ -33,9 +33,10 @@ function applyUsage(account: Account, usage: CodexUsage, at: number): void {
   if (usage.planType != null) account.tier = usage.planType;
 }
 
-type CodexReadOutcome = { ok: true; usage: CodexUsage; at: number } | { ok: false; reason: string; deadGrant: boolean };
+type CodexReadFailure = { ok: false; reason: string; deadGrant: boolean; expiring?: boolean };
+type CodexReadOutcome = { ok: true; usage: CodexUsage; at: number } | CodexReadFailure;
 
-async function readCodexUsage(account: Account, now: number, refresh: boolean, holder?: string): Promise<CodexReadOutcome> {
+async function freshCodexAuth(account: Account, now: number, refresh: boolean, holder?: string): Promise<{ ok: true; auth: CodexAuthJson } | CodexReadFailure> {
   let auth: CodexAuthJson | null;
   try {
     auth = readCodexStoreAuth(account.id);
@@ -43,22 +44,30 @@ async function readCodexUsage(account: Account, now: number, refresh: boolean, h
     return { ok: false, reason: `store credential unreadable (${errorMessage(e).slice(0, 80)})`, deadGrant: false };
   }
   if (!auth) return { ok: false, reason: "no credential in this account's store - run `tokenmaxxing auth --codex`", deadGrant: false };
+  if (!isCodexAccessExpiring({ auth, now })) return { ok: true, auth };
+  if (!refresh) return { ok: false, reason: "stored access token is expiring and this read never refreshes a store", deadGrant: false, expiring: true };
+  if (livingPresences(codexPaths.presenceDir).some((p) => p.accountId === account.id && p.id !== holder)) {
+    return { ok: false, reason: "running in a live codex session (store refresh unsafe)", deadGrant: false };
+  }
   try {
-    if (isCodexAccessExpiring({ auth, now })) {
-      if (!refresh) {
-        return { ok: false, reason: "stored access token is expiring and this read never refreshes a store", deadGrant: false };
-      }
-      if (livingPresences(codexPaths.presenceDir).some((p) => p.accountId === account.id && p.id !== holder)) {
-        return { ok: false, reason: "running in a live codex session (store refresh unsafe)", deadGrant: false };
-      }
-      auth = await refreshCodexAuth({ auth, now });
-      writeCodexStoreAuth(account.id, auth);
-    }
-    const at = Date.now();
-    return { ok: true, usage: await fetchCodexUsage({ auth, at }), at };
+    auth = await refreshCodexAuth({ auth, now });
   } catch (e) {
     if (e instanceof CodexInvalidGrantError) return { ok: false, reason: e.message, deadGrant: true };
-    if (e instanceof CodexRefreshFailedError || e instanceof CodexUsageReadError) return { ok: false, reason: e.message, deadGrant: false };
+    if (e instanceof CodexRefreshFailedError) return { ok: false, reason: e.message, deadGrant: false };
+    throw e;
+  }
+  writeCodexStoreAuth(account.id, auth);
+  return { ok: true, auth };
+}
+
+async function readCodexUsage(account: Account, now: number, refresh: boolean, holder?: string): Promise<CodexReadOutcome> {
+  const fresh = await freshCodexAuth(account, now, refresh, holder);
+  if (!fresh.ok) return fresh;
+  try {
+    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 };
     throw e;
   }
 }
@@ -86,18 +95,27 @@ export async function observeCodex(account: Account, cfg: Config, now: number, o
 
 async function samplePool(accounts: Account[], _liveId: string | null, now: number): Promise<Map<string, SampleReport>> {
   const reports = new Map<string, SampleReport>();
+  const record = (account: Account, outcome: CodexReadOutcome): void => {
+    if (outcome.ok) {
+      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[] = [];
   await Promise.all(
     accounts.map(async (account) => {
-      const outcome = await readCodexUsage(account, now, true);
-      if (outcome.ok) {
-        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 outcome = await readCodexUsage(account, now, false);
+      if (!outcome.ok && outcome.expiring === true) expiring.push(account);
+      else record(account, outcome);
     }),
   );
+  if (expiring.length > 0) {
+    const rotated = await withLock(codexPool.lockFile, () => Promise.all(expiring.map(async (account) => ({ account, fresh: await freshCodexAuth(account, now, true) }))));
+    await Promise.all(rotated.map(async ({ account, fresh }) => record(account, fresh.ok ? await readCodexUsage(account, now, false) : fresh)));
+  }
   return reports;
 }
 

package/src/lib/decide.ts

@@ -1,7 +1,8 @@
 import { countBy } from "es-toolkit";
+import { CLAUDE_COMPACT_KILL_MS } from "./compact.ts";
 import { withLock } from "./lock.ts";
 import { loadAccounts, loadConfig, liveWaitClaims, releaseWaitClaim, replaceWaitClaim, saveAccounts } from "./state.ts";
-import { isExhausted, limitWindows, liveUsed, nextWeeklyReset, pickBest, pickWaitTarget, sessionWindow, thresholdBars, weeklyWindow, type PickCtx } from "./picker.ts";
+import { isExhausted, landWindows, limitWindows, liveUsed, nextWeeklyReset, pickBest, pickWaitTarget, sessionWindow, thresholdBars, weeklyWindow, type PickCtx } from "./picker.ts";
 import { familyTokens } from "./usage.ts";
 import { errorMessage, log } from "./log.ts";
 import type { Observation, Provider } from "./provider.ts";
@@ -16,6 +17,7 @@ export type EvalOpts = {
 };
 
 const MAX_WAITERS_PER_ACCOUNT = 4;
+const MOVE_CLAIM_MS = 2 * CLAUDE_COMPACT_KILL_MS;
 
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 const FIVE_HOURS_MS = 5 * 60 * 60 * 1000;
@@ -100,10 +102,7 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), canRes
     for (const a of idx.accounts) {
       const obs = await p.observeLive(a, cfg, now, { probe: false, perModel: false });
       if (a === active) obs2 = obs;
-      if (obs && (a.lastUsageAt == null || obs.at > a.lastUsageAt)) {
-        a.windows = p.mergeWindows(obs.windows, a.windows);
-        a.lastUsageAt = obs.at;
-      }
+      if (obs && (a.lastUsageAt == null || obs.at > a.lastUsageAt)) landWindows(a, p.mergeWindows(obs.windows, a.windows), obs.at, bars);
     }
     saveAccounts(p.pool, idx);
 
@@ -146,6 +145,7 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), canRes
         continue;
       }
       log("decide.swap", { account: best.id.slice(0, 8), enforced: enforced2 != null });
+      if (waiterId != null && p.seats === "shared") replaceWaitClaim({ sessionId: waiterId, accountId: best.id, at: now, waitUntil: now + MOVE_CLAIM_MS });
       return { swapped: true, account: best, reason: "swapped" };
     }
 

package/src/lib/picker.ts

@@ -53,16 +53,16 @@ function barFor(w: Window, thresholds: Thresholds): number {
   return isSessionWindow(w) ? thresholds.session : thresholds.weekly;
 }
 
-function blockedUntil(w: Window, bar: number): number {
-  if (w.usedPercentage < bar) return 0;
+function blockedUntil(w: Window, bar: number, now: number): number {
+  if (liveUsed(w, now) < bar) return 0;
   if (w.resetsAt != null) return w.resetsAt;
-  return w.windowSeconds != null ? w.sampledAt + w.windowSeconds * 1000 : Number.POSITIVE_INFINITY;
+  return w.sampledAt + (w.windowSeconds ?? 0) * 1000;
 }
 
 function blockingUntil(a: Account, ctx: PickCtx): number[] {
   return [
-    ...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.windows.filter((w) => w.name == null).map((w) => blockedUntil(w, barFor(w, ctx.thresholds), ctx.now)),
+    ...gatedWindows(a, ctx.families).map((w) => blockedUntil(w, barFor(w, ctx.thresholds), ctx.now)),
     ...(a.enforcedUntil != null ? [a.enforcedUntil] : []),
   ];
 }
@@ -71,6 +71,14 @@ export function isExhausted(a: Account, ctx: PickCtx): boolean {
   return blockingUntil(a, ctx).some((t) => t > ctx.now);
 }
 
+export function landWindows(a: Account, windows: Window[], at: number, thresholds: Thresholds): void {
+  const ctx: PickCtx = { now: at, thresholds, currentId: null, families: [], seats: null };
+  const blocked = a.enforcedUntil != null && isExhausted({ ...a, enforcedUntil: undefined }, ctx);
+  a.windows = windows;
+  a.lastUsageAt = at;
+  if (blocked && !isExhausted({ ...a, enforcedUntil: undefined }, ctx)) a.enforcedUntil = undefined;
+}
+
 export function nextWeeklyReset(resetsAt: number | null, now: number): number | null {
   if (resetsAt == null || resetsAt > now) return resetsAt;
   return resetsAt + (Math.floor((now - resetsAt) / WEEK_MS) + 1) * WEEK_MS;

package/src/lib/sample.ts

@@ -3,11 +3,12 @@ import { withLock } from "./lock.ts";
 import { errorMessage, log } from "./log.ts";
 import { claudeTierLabel, isDeadCredential } from "./oauth.ts";
 import { claudePool, paths } from "./paths.ts";
+import { landWindows, thresholdBars } from "./picker.ts";
 import { seatCounts } from "./presence.ts";
 import type { Observation } from "./provider.ts";
 import { loadAccounts, loadUsageSnapshot, saveAccounts } from "./state.ts";
 import { fetchUsageDirect, mergeWindows, windowsOf } from "./usage.ts";
-import type { Account, Config, UsageWindows } from "./types.ts";
+import type { Account, Config, Thresholds, UsageWindows } from "./types.ts";
 
 export type SampleOutcome = { ok: true; usage: UsageWindows; via: "get" } | { ok: false; reason: string; retryAt?: number };
 
@@ -23,11 +24,10 @@ export function teeObservation(account: Account): Observation | null {
   return { windows: mergeWindows(aggregate, account.windows), at };
 }
 
-export function foldTee(account: Account): boolean {
+export function foldTee(account: Account, thresholds: Thresholds): boolean {
   const observed = teeObservation(account);
   if (!observed || (account.lastUsageAt != null && observed.at <= account.lastUsageAt)) return false;
-  account.windows = observed.windows;
-  account.lastUsageAt = observed.at;
+  landWindows(account, observed.windows, observed.at, thresholds);
   return true;
 }
 
@@ -79,7 +79,7 @@ export async function sampleOldest(cfg: Config): Promise<void> {
     const now = Date.now();
     const idx = loadAccounts(claudePool);
     let dirty = false;
-    for (const a of idx.accounts) dirty = foldTee(a) || dirty;
+    for (const a of idx.accounts) dirty = foldTee(a, thresholdBars(cfg)) || dirty;
     const sampledAt = (a: Account) => Math.max(a.lastUsageAt ?? 0, a.lastProbeAt ?? 0);
     const seats = seatCounts(paths.presenceDir);
     const stale = idx.accounts
@@ -123,8 +123,7 @@ export async function sampleOldest(cfg: Config): Promise<void> {
           dirty = true;
         }
         if (stored && outcome.ok && (stored.lastUsageAt == null || startedAt > stored.lastUsageAt)) {
-          stored.windows = mergeWindows(windowsOf(outcome.usage, startedAt), stored.windows);
-          stored.lastUsageAt = startedAt;
+          landWindows(stored, mergeWindows(windowsOf(outcome.usage, startedAt), stored.windows), startedAt, thresholdBars(cfg));
           dirty = true;
         }
         if (dirty) saveAccounts(claudePool, idx);