tokenmaxxing 1.12.0 → 1.13.1

package/DESIGN.md

@@ -79,7 +79,7 @@ Each terminal ran the supervisor, so each has its own child `claude` and its own
 ---
 
 ## 5. Rotation policy
-The decision engages at `five_hour >= 80%` (policy.greedySessionFloor): from there it greedily converges on the usable account furthest behind its weekly pace, staying put whenever the current account wins or ties. The **Layer 1 screening bars** - `five_hour >= <active rung>` (the 5h ladder `thresholds.session`, default `[90]`, a single rung: the lowest rung some pooled account still clears, the current one included) OR `seven_day >= 98%`, per org (`thresholds`) - force a switch onto a fresher account and also screen candidates. "Exhausted" is a **timestamped state** (`resets_at`), not a flag - an account is a candidate again after it resets. Optional projected threshold (`bar - policy.projectionMargin`, a fixed configured margin) so a single large turn is less likely to blow past 100% before the next Stop hook.
+The decision engages at `five_hour >= 80%` (policy.greedySessionFloor): from there it greedily converges on the usable account furthest behind its weekly pace, staying put whenever the current account wins or ties. The automatic greedy path adds **incumbent hysteresis** (`policy.greedySwapMargin`, default 0.15): the seat holds unless a parked account's pace pressure beats it by more than that fraction, so near-tied accounts stop trading the seat back and forth and busting the per-org prompt cache (each such swap forces a full uncached re-read next turn). The margin only gates lateral under-bar swaps, never a crossed bar or the wall; bare `tokenmaxxing switch` sets it to zero and still converges on the strictly best account. The **Layer 1 screening bars** - `five_hour >= <active rung>` (the 5h ladder `thresholds.session`, default `[90]`, a single rung: the lowest rung some pooled account still clears, the current one included) OR `seven_day >= 98%`, per org (`thresholds`) - force a switch onto a fresher account and also screen candidates. "Exhausted" is a **timestamped state** (`resets_at`), not a flag - an account is a candidate again after it resets. Optional projected threshold (`bar - policy.projectionMargin`, a fixed configured margin) so a single large turn is less likely to blow past 100% before the next Stop hook.
 
 **Two layers - pump the last drops.** The screening bars deliberately leave headroom, so when *every* account is over them Layer 1 alone would park the pool with 2-5% of each account's quota still unspent. **Layer 2 - the wall bars** (`hardThresholds`, default `100/100`, the server's own limit) - is the fallback reached only at that point: the session **holds its seat and squeezes** while it is under the wall, else swaps onto the best still-under-wall account (the same pace-pressure ranking as every other swap - squeeze the account whose weekly quota is most about to be forfeited first), and only parks (depleted-wait) once every account has truly walled. Recovery is then measured against the wall, not the screening bar, so an account whose 5h window drops below 100 is squeezable again even while its weekly window still sits above the Layer 1 bar. The wall reading is the statusLine's own `rate_limits` feed - the same server-side figure claude's `/rate-limit-options` renders - so when an account genuinely maxes out the tee shows 100 and Layer 2 moves on; a single-turn overshoot is caught one boundary later (the periodic `check` timer, or the next Stop hook) without needing to sniff assistant text. Set `hardThresholds` equal to `thresholds` to disable Layer 2. **Layer 2 is Claude-only:** a swap on Claude is a hot, in-place credential adoption every concurrent session follows automatically, whereas a running Codex refuses another account's credential (restart is the switch), so a last-drop-swap there would strand any sibling still on the walled account - Codex instead keeps riding its current account to the wall (its existing all-exhausted stay-put already squeezes it).
 

package/agent-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "tokenmaxxing",
-  "version": "1.12.0",
+  "version": "1.13.1",
   "description": "Pool Claude Code and Codex logins, switch on pace pressure, and expose safe ops tools to agent clients.",
   "author": {
     "name": "anaclumos",

package/agent-plugin/skills/switching-policy/SKILL.md

@@ -8,7 +8,7 @@ description: Explain and apply tokenmaxxing switch policy (greedy vs hard path,
 ## Vocabulary
 
 - **Engaged**: session used >= `policy.greedySessionFloor` (default 80) or any screening bar crossed.
-- **GREEDY path**: engaged but under every bar. Rank all accounts by pace pressure; keep seat on best-or-tie (`currentWins`); else swap to strictly better. Never depleted-waits or pre-parks.
+- **GREEDY path**: engaged but under every bar. Rank all accounts by pace pressure; keep seat on best-or-tie (`currentWins`); else swap to strictly better. Never depleted-waits or pre-parks. The automatic path adds incumbent hysteresis (`policy.greedySwapMargin`, default 0.15): hold the seat unless a parked account's pace pressure exceeds the current one's by more than that fraction, so near-tied accounts stop trading the seat and busting the per-org prompt cache. The margin gates lateral under-bar swaps only, never a crossed bar or the wall; bare `tokenmaxxing switch` uses margin 0 and always takes the strictly best account.
 - **HARD path**: a screening bar crossed. Swap to best usable target; if none, Layer 2 wall logic (Claude only).
 - **Pace pressure**: remaining weekly percent / time to weekly reset (highest first). Not most-remaining.
 - **Effective bars**: `effectiveBars(cfg, pool)` = the active rung of the 5h ladder (`thresholds.session`, default `[90]`, a single rung: the lowest rung some pooled account, the current one included, still clears) and the weekly bar, each minus `policy.projectionMargin`. Trigger and screening must share these bars or swaps ping-pong. Codex reads `terminalBars(cfg)`, the top rung only. The check cadence is capped one band per rung climbed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.12.0",
+  "version": "1.13.1",
   "description": "Automatic Claude Code account switching: pool multiple accounts and hot-swap when quota fills, resuming your session on the fresh account.",
   "type": "module",
   "license": "MIT",

package/src/cli/config.ts

@@ -16,6 +16,7 @@ export const KNOWN_KEYS = [
   "codexBin",
   "policy.projectionMargin",
   "policy.greedySessionFloor",
+  "policy.greedySwapMargin",
   "policy.switchModels",
   "policy.usagePollTtlMs",
   "policy.maxWaitMs",

package/src/cli/status.ts

@@ -1,6 +1,6 @@
 import { sortBy } from "es-toolkit";
 import { z } from "zod";
-import { loadAccounts, loadConfig, loadUsage, loadModelUsage, saveAccounts } from "../lib/state.ts";
+import { loadAccounts, loadConfig, loadUsage, loadUsageSnapshot, loadModelUsage, saveAccounts } from "../lib/state.ts";
 import { readOAuthAccount } from "../lib/claudejson.ts";
 import { ensureLiveTokenFresh, probeActiveUsage, probeParkedUsage, type SampleOutcome } from "../lib/sample.ts";
 import { withLock } from "../lib/lock.ts";
@@ -33,6 +33,7 @@ const ClaudeStatusAccountSchema = z.object({
   usageAt: z.number().nullable(),
   sample: SampleReportSchema,
   pingError: z.string().nullable(),
+  pingRejected: z.boolean(),
   pinged: z.boolean(),
 });
 type ClaudeStatusAccount = z.infer<typeof ClaudeStatusAccountSchema>;
@@ -93,15 +94,18 @@ async function collectClaude(input: { cfg: Config; force: boolean; now: number }
     console.error(c.dim(force ? "pinging every account (starts each 5h session timer) + sampling live usage..." : "sampling live usage..."));
     await withLock(paths.lockFile, async () => {
       idx = loadAccounts();
-      const live = loadUsage();
+      const tee = loadUsageSnapshot();
+      const live = tee?.state ?? null;
+      const teeAt = tee?.at ?? null;
       const modelUsage = loadModelUsage();
       const liveOAuth = readOAuthAccount();
       const activeOrg = liveOAuth?.organizationUuid ?? null;
       const probeOne = async (a: Account) => {
         const isActive = activeOrg != null && activeOrg === a.organizationUuid;
         if (isActive && liveOAuth?.organizationRateLimitTier != null) a.rateLimitTier = liveOAuth.organizationRateLimitTier;
+        const teeCurrent = teeAt != null && (a.lastUsageAt == null || teeAt >= a.lastUsageAt);
         const fromStatusLine: FullUsage | null =
-          isActive && live && live.org === a.organizationUuid
+          isActive && live && teeCurrent && live.org === a.organizationUuid
             ? {
                 session: live.fiveHour,
                 weekAll: live.sevenDay,
@@ -115,7 +119,10 @@ async function collectClaude(input: { cfg: Config; force: boolean; now: number }
           if (!outcome.ok && fromStatusLine && outcome.reason.includes("no limit data")) {
             const failed = outcome;
             outcome = { ok: true, usage: fromStatusLine };
-            if (failed.pingError != null) outcome.pingError = failed.pingError;
+            if (failed.pingError != null) {
+              outcome.pingError = failed.pingError;
+              outcome.pingRejected = failed.pingRejected;
+            }
             viaTee = true;
           }
         } else {
@@ -129,7 +136,7 @@ async function collectClaude(input: { cfg: Config; force: boolean; now: number }
         samples.set(a.accountUuid, { outcome, viaTee });
         if (!outcome.ok) return;
         a.lastUsage = { fiveHour: outcome.usage.session, sevenDay: outcome.usage.weekAll };
-        a.lastUsageAt = viaTee && live ? live.ts : Date.now();
+        a.lastUsageAt = viaTee && teeAt != null ? teeAt : Date.now();
         if (Object.keys(outcome.usage.perModel).length > 0) {
           a.lastPerModel = outcome.usage.perModel;
           a.lastPerModelAt = viaTee && modelUsage ? (modelUsage.sampledAt ?? modelUsage.ts) : a.lastUsageAt;
@@ -169,6 +176,7 @@ async function collectClaude(input: { cfg: Config; force: boolean; now: number }
       usageAt: a.lastUsageAt ?? null,
       sample: sampled.outcome.ok ? { ok: true, source: sampled.viaTee ? "statusline" : "probe" } : { ok: false, reason: sampled.outcome.reason },
       pingError: sampled.outcome.pingError ?? null,
+      pingRejected: sampled.outcome.pingRejected === true,
       pinged: force && sampled.outcome.ok && sampled.outcome.pingError == null && aggregate != null && aggregate.fiveHour.resetsAt == null,
     };
   });
@@ -277,8 +285,14 @@ function rowPrinter(now: number): (name: string, w: UsageWindow) => void {
   };
 }
 
-function renderClaude(input: { claude: StatusReport["claude"]; codexPooled: boolean; now: number; row: (name: string, w: UsageWindow) => void }): void {
-  const { claude, codexPooled, now, row } = input;
+function renderClaude(input: {
+  claude: StatusReport["claude"];
+  codexPooled: boolean;
+  now: number;
+  staleAfterMs: number;
+  row: (name: string, w: UsageWindow) => void;
+}): void {
+  const { claude, codexPooled, now, staleAfterMs, row } = input;
   if (claude.accounts.length === 0) {
     if (!codexPooled) {
       console.log(c.dim("no accounts yet, run `tokenmaxxing init` (or `tokenmaxxing init --codex`)"));
@@ -303,11 +317,21 @@ function renderClaude(input: { claude: StatusReport["claude"]; codexPooled: bool
       row("week", a.usage.week);
     }
     for (const [name, w] of Object.entries(a.perModel)) row(name.toLowerCase(), w);
+    if (a.sample.ok && a.sample.source === "statusline") {
+      const stale = a.usageAt == null || now - a.usageAt > staleAfterMs;
+      const age = a.usageAt != null ? fmtAgo(a.usageAt, now) : "age unknown";
+      console.log(`    ${(stale ? c.yellow : c.dim)(`statusline tee ${age}${stale ? " (stale)" : ""}`)}`);
+    }
     if (!a.sample.ok) {
       const cached = a.usage || Object.keys(a.perModel).length > 0 ? `cached${a.usageAt != null ? ` ${fmtAgo(a.usageAt, now)}` : ""}, ` : "";
       console.log(`    ${c.yellow(`${cached}live sample failed`)}: ${c.dim(a.sample.reason)}`);
     }
-    if (a.pingError != null) {
+    if (a.pingError != null && a.pingRejected) {
+      const at = a.pingError.indexOf(": ");
+      const head = at >= 0 ? a.pingError.slice(0, at) : a.pingError;
+      const tail = at >= 0 ? a.pingError.slice(at + 2) : "";
+      console.log(`    ${c.yellow(`ping ${head}`)}${tail ? `: ${c.dim(tail)}` : ""}`);
+    } else if (a.pingError != null) {
       console.log(`    ${c.yellow("ping failed (5h timer may not have started)")}: ${c.dim(a.pingError)}`);
     }
     if (a.pinged) {
@@ -321,11 +345,11 @@ export async function cmdStatus(opts: { force?: boolean; json?: boolean; preRend
   const { force = false, json = false } = opts;
   const cfg = loadConfig();
   const now = Date.now();
-  const row = rowPrinter(now);
   const claude = await collectClaude({ cfg, force, now });
   if (!json) {
     opts.preRender?.();
-    renderClaude({ claude, codexPooled: loadCodexAccounts().accounts.length > 0, now, row });
+    const at = Date.now();
+    renderClaude({ claude, codexPooled: loadCodexAccounts().accounts.length > 0, now: at, staleAfterMs: cfg.policy.usagePollTtlMs, row: rowPrinter(at) });
   }
   const codex = await collectCodex({ cfg, now });
   if (json) {
@@ -333,6 +357,7 @@ export async function cmdStatus(opts: { force?: boolean; json?: boolean; preRend
     emitJson({ ok: true, ...report });
     return 0;
   }
-  renderCodex({ codex, now, row });
+  const at = Date.now();
+  renderCodex({ codex, now: at, row: rowPrinter(at) });
   return 0;
 }

package/src/lib/decide.ts

@@ -2,7 +2,7 @@ import { maxBy } from "es-toolkit";
 import { z } from "zod";
 import { withLock } from "./lock.ts";
 import { paths } from "./paths.ts";
-import { MAX_CHECK_DELAY_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsage, loadModelUsage, saveAccounts, saveDepletedWait, saveModelUsage, usageTeeAt, writeUsage } from "./state.ts";
+import { MAX_CHECK_DELAY_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsage, loadUsageSnapshot, loadModelUsage, saveAccounts, saveDepletedWait, saveModelUsage, writeUsage } from "./state.ts";
 import { readOAuthAccount } from "./claudejson.ts";
 import { chooseAndSwap, performSwap } from "./swap.ts";
 import { currentWins, effectiveBars, hardBars, isExhausted, nextWeeklyReset, pickBest, pickEarliestReset, sessionLadder, usableAt } from "./picker.ts";
@@ -72,31 +72,43 @@ function isEngaged(u: UsageState | null, mu: ModelUsageState | null, org: string
 const SnapshotsSchema = z.object({
   u: UsageStateSchema.nullable(),
   mu: ModelUsageStateSchema.nullable(),
+  uAt: z.number().nullable(),
 });
 type Snapshots = z.infer<typeof SnapshotsSchema>;
 
-function usageFresh(u: UsageState | null, org: string | null, ttl: number, now: number): boolean {
-  if (u == null || u.org !== org) return false;
-  const teeAt = usageTeeAt();
-  return teeAt != null && now - teeAt <= ttl;
+function usageFresh(u: UsageState | null, uAt: number | null, org: string | null, ttl: number, now: number): boolean {
+  return u != null && u.org === org && 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.org === account.organizationUuid && uAt < account.lastUsageAt) {
+    return { ...u, fiveHour: stored.fiveHour, sevenDay: stored.sevenDay, ts: account.lastUsageAt };
+  }
+  return { ...u, ts: uAt };
 }
 
 async function loadFreshSnapshots(cfg: Config, org: string | null, now: number): Promise<Snapshots> {
-  let u = loadUsage();
+  const snap = loadUsageSnapshot();
+  let u = snap?.state ?? null;
+  let uAt = snap?.at ?? null;
   let mu = loadModelUsage();
   const ttl = cfg.policy.usagePollTtlMs;
   const probeAttempted = mu != null && mu.org === org && now - mu.ts <= ttl;
-  if (org && !probeAttempted && (!usageFresh(u, org, ttl, now) || needsPerModel(u, cfg))) {
+  if (org && !probeAttempted && (!usageFresh(u, uAt, org, ttl, now) || needsPerModel(u, cfg))) {
     const full = await probeUsage();
     const ts = Date.now();
     if (readOAuthAccount()?.organizationUuid === org) {
       if (full) {
-        const teed = loadUsage();
-        if (usageFresh(teed, org, ttl, ts)) {
-          u = teed;
+        const teed = loadUsageSnapshot();
+        if (teed && usageFresh(teed.state, teed.at, org, ttl, ts)) {
+          u = teed.state;
+          uAt = teed.at;
         } else {
           u = { fiveHour: full.session, sevenDay: full.weekAll, org, ts, model: null };
           writeUsage(u);
+          uAt = ts;
         }
         mu = { perModel: full.perModel, org, ts, sampledAt: ts };
         saveModelUsage(mu);
@@ -111,7 +123,7 @@ async function loadFreshSnapshots(cfg: Config, org: string | null, now: number):
       }
     }
   }
-  return { u, mu };
+  return { u, mu, uAt };
 }
 
 export const POST_SWAP_COOLDOWN_MS = 45_000;
@@ -127,9 +139,11 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
 
   const cfg = loadConfig();
 
-  const { u: usage, mu } = await loadFreshSnapshots(cfg, activeOrg, now);
+  const { u: teeUsage, mu, uAt } = await loadFreshSnapshots(cfg, activeOrg, now);
+  const pool = loadAccounts();
+  const usage = freshest(teeUsage, uAt, pool.accounts.find((a) => a.organizationUuid === activeOrg));
   const bars0 = effectiveBars(cfg, {
-    accounts: overlayLive(loadAccounts().accounts, usage, mu, activeOrg),
+    accounts: overlayLive(pool.accounts, usage, mu, activeOrg),
     now,
     switchFamilies: gatedFamilies(usage?.model ?? null, cfg.policy.switchModels),
   });
@@ -147,19 +161,20 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
     const idx = loadAccounts();
     const org2 = readOAuthAccount()?.organizationUuid ?? null;
     const enforced2 = enforced0 && enforced0.org === org2 ? enforced0 : null;
-    const u2 = loadUsage() ?? usage;
+    const tee = loadUsageSnapshot();
+    const active = org2 ? idx.accounts.find((a) => a.organizationUuid === org2) : undefined;
+    const u2 = tee ? freshest(tee.state, tee.at, active) : usage;
     const mu2 = needsPerModel(u2, cfg) || enforced2?.family ? loadModelUsage() ?? mu : null;
 
-    if (org2 != null && !idx.accounts.some((a) => a.organizationUuid === org2)) {
+    if (org2 != null && !active) {
       return { swapped: false, account: null, reason: "live-credential-not-in-pool" };
     }
 
-    const active = org2 ? idx.accounts.find((a) => a.organizationUuid === org2) : undefined;
     if (active) {
       let sampled = false;
-      if (u2 && u2.org === org2) {
-        active.lastUsage = { fiveHour: u2.fiveHour, sevenDay: u2.sevenDay };
-        active.lastUsageAt = u2.ts;
+      if (tee && tee.state.org === org2 && (active.lastUsageAt == null || tee.at >= active.lastUsageAt)) {
+        active.lastUsage = { fiveHour: tee.state.fiveHour, sevenDay: tee.state.sevenDay };
+        active.lastUsageAt = tee.at;
         sampled = true;
       }
       if (mu2 && mu2.org === org2 && Object.keys(mu2.perModel).length > 0) {
@@ -184,11 +199,11 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
       idx2.accounts.find((a) => a.accountUuid === idx2.activeAccountUuid) ??
       null;
 
-    const greedy = async (): Promise<SwapDecision> => {
+    const greedy = async (holdMargin: number): Promise<SwapDecision> => {
       while (true) {
         const cur = loadAccounts();
         const active = seatOf(cur);
-        const ctxAll = { now, thresholds: barsOf(cur.accounts), currentAccountUuid: null, switchFamilies };
+        const ctxAll = { now, thresholds: barsOf(cur.accounts), currentAccountUuid: null, switchFamilies, holdMargin };
         if (currentWins(active, cur.accounts, ctxAll)) {
           return { swapped: false, account: null, reason: "current-best" };
         }
@@ -204,13 +219,13 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
         return { swapped: true, account: best, reason: "swapped" };
       }
     };
-    if (!enforced2 && !isOver(u2, mu2, org2, bars, cfg, now)) return greedy();
+    if (!enforced2 && !isOver(u2, mu2, org2, bars, cfg, now)) return greedy(cfg.policy.greedySwapMargin);
 
     while (true) {
       const cur = loadAccounts();
       const seat = seatOf(cur);
       const thresholds = barsOf(cur.accounts);
-      if (!enforced2 && seat && !seat.needsReauth && !isExhausted(seat, { now, thresholds, currentAccountUuid: null, switchFamilies })) return greedy();
+      if (!enforced2 && seat && !seat.needsReauth && !isExhausted(seat, { now, thresholds, currentAccountUuid: null, switchFamilies })) return greedy(0);
       const best = pickBest(cur.accounts, { now, thresholds, currentAccountUuid: seat?.accountUuid ?? null, switchFamilies });
       if (!best) break;
       try {
@@ -351,12 +366,14 @@ export function checkDelayMs(input: { cfg: Config; org: string | null; now: numb
   if (decision.waitUntil !== undefined) return Math.min(MAX_CHECK_DELAY_MS, Math.max(CHECK_DELAY_FLOOR_MS, decision.waitUntil - now));
   const swapAt = loadLastSwapAt();
   if (swapAt != null && now - swapAt < POST_SWAP_COOLDOWN_MS) return swapAt + POST_SWAP_COOLDOWN_MS - now;
-  const u = loadUsage();
-  if (!org || !u || !usageFresh(u, org, cfg.policy.usagePollTtlMs, now)) return CHECK_DELAY_UNKNOWN_MS;
+  const snap = loadUsageSnapshot();
+  if (!org || !snap || !usageFresh(snap.state, snap.at, org, cfg.policy.usagePollTtlMs, now)) return CHECK_DELAY_UNKNOWN_MS;
+  const accounts = loadAccounts().accounts;
+  const u = freshest(snap.state, snap.at, accounts.find((a) => a.organizationUuid === org)) ?? { ...snap.state, ts: snap.at };
   const mu = loadModelUsage();
   const muSame = mu && mu.org === org ? mu : null;
   const families = gatedFamilies(u.model, cfg.policy.switchModels);
-  const bars = effectiveBars(cfg, { accounts: overlayLive(loadAccounts().accounts, u, muSame, org), now, switchFamilies: families });
+  const bars = effectiveBars(cfg, { accounts: overlayLive(accounts, u, muSame, org), now, switchFamilies: families });
   const heads = [
     bars.session - liveUsed({ window: u.fiveHour, windowMs: FIVE_HOURS_MS, sampledAt: u.ts, now }),
     bars.weekly - liveUsed({ window: u.sevenDay, windowMs: WEEK_MS, sampledAt: u.ts, now }),

package/src/lib/picker.ts

@@ -35,6 +35,7 @@ const PickCtxSchema = z.object({
   thresholds: ThresholdsSchema,
   currentAccountUuid: z.string().nullable(),
   switchFamilies: z.array(z.string()),
+  holdMargin: z.number().min(0).optional(),
 });
 export type PickCtx = z.infer<typeof PickCtxSchema>;
 
@@ -110,6 +111,9 @@ export function currentWins(active: Account | null, accounts: Account[], ctx: Pi
   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 margin = ctx.holdMargin ?? 0;
+  const bestPace = pacePressure(best, ctx.now);
+  if (margin > 0 && bestPace > 0 && bestPace <= pacePressure(active, ctx.now) * (1 + margin)) return true;
   return swapPreference(ctx.now).every((k) => k(active) === k(best));
 }
 

package/src/lib/sample.ts

@@ -9,8 +9,8 @@ import { FullUsageSchema, pingSession, probeUsage } from "./usage.ts";
 import { CredentialBlobSchema, type Account, type OAuthCreds, type RolesResponse } from "./types.ts";
 
 const SampleOutcomeSchema = z.discriminatedUnion("ok", [
-  z.object({ ok: z.literal(true), usage: FullUsageSchema, pingError: z.string().optional() }),
-  z.object({ ok: z.literal(false), reason: z.string(), pingError: z.string().optional() }),
+  z.object({ ok: z.literal(true), usage: FullUsageSchema, pingError: z.string().optional(), pingRejected: z.boolean().optional() }),
+  z.object({ ok: z.literal(false), reason: z.string(), pingError: z.string().optional(), pingRejected: z.boolean().optional() }),
 ]);
 export type SampleOutcome = z.infer<typeof SampleOutcomeSchema>;
 
@@ -95,12 +95,15 @@ export async function probeParkedUsage(account: Account, opts: { ping?: boolean
   try {
     await writeItem(isoTarget, installed);
     writeFileSync(join(dir, ".claude.json"), JSON.stringify({ oauthAccount: account.oauthAccount, hasCompletedOnboarding: true }));
-    const pingError = opts.ping ? await pingSession(dir) : null;
+    const ping = opts.ping ? await pingSession(dir) : null;
     const usage = await probeUsage(dir);
     const outcome: SampleOutcome = usage
       ? { ok: true, usage }
       : { ok: false, reason: "`/usage` returned no limit data (see log)" };
-    if (pingError != null) outcome.pingError = pingError;
+    if (ping != null) {
+      outcome.pingError = ping.reason;
+      outcome.pingRejected = ping.rejected;
+    }
     return outcome;
   } finally {
     const afterIso = await readItem(isoTarget);
@@ -152,9 +155,12 @@ export async function probeActiveUsage(account: Account, opts: { ping?: boolean
   if (identity.status === "unavailable") return { ok: false, reason: identity.reason };
   refreshPlanFields(account, creds);
 
-  const pingError = opts.ping ? await pingSession() : null;
+  const ping = opts.ping ? await pingSession() : null;
   const usage = await probeUsage();
   const outcome: SampleOutcome = usage ? { ok: true, usage } : { ok: false, reason: "`/usage` returned no limit data (see log)" };
-  if (pingError != null) outcome.pingError = pingError;
+  if (ping != null) {
+    outcome.pingError = ping.reason;
+    outcome.pingRejected = ping.rejected;
+  }
   return outcome;
 }

package/src/lib/state.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, rmSync, statSync, utimesSync } from "node:fs";
+import { closeSync, existsSync, fstatSync, openSync, readFileSync, rmSync, utimesSync } from "node:fs";
 import { isEqual } from "es-toolkit";
 import { z } from "zod";
 import { paths, realClaudeBinFromEnv, realCodexBinFromEnv } from "./paths.ts";
@@ -22,7 +22,7 @@ const DEFAULT_CONFIG: Config = {
   hardThresholds: { session: 100, weekly: 100 },
   claudeBin: "",
   codexBin: "",
-  policy: { projectionMargin: 0, greedySessionFloor: 80, switchModels: ["fable"], usagePollTtlMs: 90_000, maxWaitMs: 3_600_000 },
+  policy: { projectionMargin: 0, greedySessionFloor: 80, greedySwapMargin: 0.15, switchModels: ["fable"], usagePollTtlMs: 90_000, maxWaitMs: 3_600_000 },
 };
 
 const PercentSchema = z.number().min(0).max(100);
@@ -37,6 +37,7 @@ export const ConfigFileSchema = z
       .object({
         projectionMargin: PercentSchema,
         greedySessionFloor: PercentSchema,
+        greedySwapMargin: z.number().min(0).max(1),
         switchModels: z.array(z.string()),
         usagePollTtlMs: z.number().int().positive(),
         maxWaitMs: z.number().int().positive(),
@@ -66,6 +67,7 @@ export function mergeConfigFile(p: z.infer<typeof ConfigFileSchema>): MergeOutco
   cfg.codexBin = p.codexBin ?? cfg.codexBin;
   cfg.policy.projectionMargin = p.policy?.projectionMargin ?? cfg.policy.projectionMargin;
   cfg.policy.greedySessionFloor = p.policy?.greedySessionFloor ?? cfg.policy.greedySessionFloor;
+  cfg.policy.greedySwapMargin = p.policy?.greedySwapMargin ?? cfg.policy.greedySwapMargin;
   cfg.policy.usagePollTtlMs = p.policy?.usagePollTtlMs ?? cfg.policy.usagePollTtlMs;
   cfg.policy.maxWaitMs = p.policy?.maxWaitMs ?? cfg.policy.maxWaitMs;
   if (p.policy?.switchModels) {
@@ -133,16 +135,28 @@ export function saveAccounts(idx: AccountsIndex): void {
   writeFileAtomic(paths.accountsJson, JSON.stringify(AccountsIndexSchema.parse(idx), null, 2) + "\n");
 }
 
-export function loadUsage(): UsageState | null {
-  if (!existsSync(paths.usageJson)) return null;
+export function loadUsageSnapshot(): { state: UsageState; at: number } | null {
+  let fd: number;
   try {
-    const parsed = UsageStateSchema.safeParse(JSON.parse(readFileSync(paths.usageJson, "utf8")));
-    return parsed.success ? parsed.data : null;
+    fd = openSync(paths.usageJson, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const at = fstatSync(fd).mtimeMs;
+    const parsed = UsageStateSchema.safeParse(JSON.parse(readFileSync(fd, "utf8")));
+    return parsed.success ? { state: parsed.data, at } : null;
   } catch {
     return null;
+  } finally {
+    closeSync(fd);
   }
 }
 
+export function loadUsage(): UsageState | null {
+  return loadUsageSnapshot()?.state ?? null;
+}
+
 export function clearUsageSnapshots(): void {
   rmSync(paths.usageJson, { force: true });
   rmSync(paths.modelUsageJson, { force: true });
@@ -224,14 +238,6 @@ export function writeUsage(next: UsageState): boolean {
   return true;
 }
 
-export function usageTeeAt(): number | null {
-  try {
-    return statSync(paths.usageJson).mtimeMs;
-  } catch {
-    return null;
-  }
-}
-
 export function loadModelUsage(): ModelUsageState | null {
   if (!existsSync(paths.modelUsageJson)) return null;
   try {

package/src/lib/types.ts

@@ -121,6 +121,7 @@ export const ConfigSchema = z
     policy: z.object({
       projectionMargin: z.number().min(0).max(100),
       greedySessionFloor: z.number().min(0).max(100),
+      greedySwapMargin: z.number().min(0).max(1),
       switchModels: z.array(z.string()),
       usagePollTtlMs: z.number().int().positive(),
       maxWaitMs: z.number().int().positive(),

package/src/lib/usage.ts

@@ -1,4 +1,4 @@
-import { closeSync, fstatSync, mkdirSync, openSync, readSync } from "node:fs";
+import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readSync } from "node:fs";
 import { join } from "node:path";
 import { delay } from "es-toolkit";
 import { z } from "zod";
@@ -366,13 +366,36 @@ const PING_ARGS = [
   "--output-format", "json",
 ];
 
-const PingResultSchema = z.looseObject({ is_error: z.boolean(), result: z.string().optional() });
+const PingResultSchema = z.looseObject({ is_error: z.boolean().optional(), result: z.string().optional(), session_id: z.string().optional() });
 
-export async function pingSession(configDir?: string): Promise<string | null> {
+export const PingFailureSchema = z.object({ reason: z.string(), rejected: z.boolean() });
+export type PingFailure = z.infer<typeof PingFailureSchema>;
+
+export function transcriptSlug(cwd: string): string {
+  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+
+export function pingTranscriptPath(input: { configDir: string; cwd: string; sessionId: string }): string {
+  return join(input.configDir, "projects", transcriptSlug(input.cwd), `${input.sessionId}.jsonl`);
+}
+
+const LIMIT_LABELS: Record<string, string> = { five_hour: "5h", seven_day: "weekly" };
+
+export function pingRejection(rows: TranscriptRow[]): string | null {
+  const row = rows.findLast((r) => r.isApiErrorMessage === true);
+  if (!row || row.error !== "rate_limit" || row.apiErrorIsTransient === true) return null;
+  const type = row.quotaLimits?.rateLimitType ?? "";
+  if (type === "" && parseErrorBody(row.errorDetails)?.error?.type !== "rate_limit_error") return null;
+  const label = LIMIT_LABELS[type] ?? (type !== "" ? type.replace(/_/g, " ") : "usage");
+  const text = transcriptRowText(row);
+  return `${label} limit${text ? `: ${text}` : ""}`;
+}
+
+export async function pingSession(configDir?: string): Promise<PingFailure | null> {
   const cwd = join(paths.sampleDir, "ping-cwd");
-  const fail = (reason: string): string => {
-    log("usage.ping_failed", { dir: configDir ?? "live", reason: reason.slice(0, 200) });
-    return reason;
+  const fail = (reason: string, rejected = false): PingFailure => {
+    log("usage.ping_failed", { dir: configDir ?? "live", rejected, reason: reason.slice(0, 200) });
+    return { reason, rejected };
   };
   let r: SpawnResult | null;
   try {
@@ -382,10 +405,21 @@ export async function pingSession(configDir?: string): Promise<string | null> {
     return fail(e instanceof Error ? e.message : String(e));
   }
   if (r === null) return fail("output pipes still open after child exit (leaked descendant)");
-  if (r.exitCode !== 0) return fail(`claude exited ${r.exitCode ?? "on signal"}: ${(r.stderr.trim() || r.stdout.trim()).slice(0, 160)}`);
   const parsed = PingResultSchema.safeParse((() => { try { return JSON.parse(r.stdout); } catch { return null; } })());
-  if (!parsed.success) return fail(`unrecognized ping output: ${r.stdout.trim().slice(0, 120)}`);
-  if (parsed.data.is_error) return fail((parsed.data.result?.trim() || "request errored").slice(0, 160));
-  log("usage.ping_ok", { dir: configDir ?? "live" });
-  return null;
+  const result = parsed.success ? parsed.data : null;
+  if (r.exitCode === 0 && result?.is_error === false) {
+    log("usage.ping_ok", { dir: configDir ?? "live" });
+    return null;
+  }
+  if (result?.session_id) {
+    const transcript = pingTranscriptPath({ configDir: configDir ?? paths.claudeDir, cwd, sessionId: result.session_id });
+    const rejection = existsSync(transcript) ? pingRejection(readTranscriptTail(transcript)) : null;
+    if (rejection) return fail(`rejected at the ${rejection}`.slice(0, 200), true);
+  }
+  if (r.exitCode !== 0) {
+    const detail = result?.result?.trim() || r.stderr.trim() || r.stdout.trim();
+    return fail(`claude exited ${r.exitCode ?? "on signal"}: ${detail.slice(0, 160)}`);
+  }
+  if (result?.is_error === true) return fail((result.result?.trim() || "request errored").slice(0, 160));
+  return fail(`unrecognized ping output: ${r.stdout.trim().slice(0, 120)}`);
 }