tokenmaxxing 1.31.0 → 1.33.0

package/DESIGN.md

@@ -31,7 +31,7 @@ It is a process manager only - spawn with inherited stdio plus saved `stty -g` t
 - Four `~/.claude/settings.json` entries (merged - other settings keys are preserved, but the `statusLine` slot is taken over): the tokenmaxxing `statusLine` renderer (native since 2026-07-11; it also tees usage), a `subagentStatusLine` (per-subagent rows in the agents panel), a `Stop` hook, a `SessionStart` hook.
 - **`~/.config/tokenmaxxing/`** - the single home for config and state:
   - `config.json` - SPARSE overrides only (thresholds.session/weekly, claudeBin/codexBin pins, policy.*); defaults apply at read time, `xx config` prints the path and the effective values, and edits happen in an editor.
-  - `accounts.json` - non-secret index `{email, organizationUuid, accountUuid, label, lastUsage, lastPerModel, needsReauth, ...}` (window resets live inside lastUsage).
+  - `accounts.json` - non-secret index `{email, organizationUuid, accountUuid, label, lastUsage, needsReauth, ...}` (window resets and the per-model rows live inside lastUsage).
   - `usage.json` - live usage, written by the statusLine shim.
   - `respawn/<session-id>` - per-session respawn markers (the hook→supervisor signal, depleted-pool waits only).
   - `bin/claude` - the supervisor.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.31.0",
+  "version": "1.33.0",
   "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/add.ts

@@ -4,6 +4,7 @@ import { credItemFor, paths } from "../lib/paths.ts";
 import { writeItem, parkedTarget, claudeAiOauthOnly } from "../lib/credstore.ts";
 import { harvestIsolatedLogin } from "./onboard.ts";
 import { type Account } from "../lib/types.ts";
+import { keepRows } from "../lib/usage.ts";
 import { c, claudeTierLabel, count } from "./render.ts";
 
 export async function cmdAdd(): Promise<number> {
@@ -22,6 +23,7 @@ export async function cmdAdd(): Promise<number> {
     await writeItem(parkedTarget(keychainItem), claudeAiOauthOnly(blobRaw));
     const idx = loadAccounts();
     const existing = idx.accounts.find((a) => a.accountUuid === uuid);
+    const sampledAt = Date.now();
     const fresh: Account = {
       accountUuid: uuid,
       email: oauthAccount.emailAddress,
@@ -33,10 +35,8 @@ export async function cmdAdd(): Promise<number> {
       subscriptionType: blob.claudeAiOauth.subscriptionType,
       rateLimitTier: blob.claudeAiOauth.rateLimitTier,
       needsReauth: false,
-      lastUsage: sampled ? { fiveHour: sampled.session, sevenDay: sampled.weekAll } : existing?.lastUsage,
-      lastPerModel: sampled && Object.keys(sampled.perModel).length > 0 ? sampled.perModel : existing?.lastPerModel,
-      lastPerModelAt: sampled && Object.keys(sampled.perModel).length > 0 ? Date.now() : existing?.lastPerModelAt,
-      lastUsageAt: sampled ? Date.now() : existing?.lastUsageAt,
+      lastUsage: sampled ? keepRows(sampled, existing?.lastUsage, sampledAt) : existing?.lastUsage,
+      lastUsageAt: sampled ? sampledAt : existing?.lastUsageAt,
     };
     if (existing) Object.assign(existing, fresh);
     else idx.accounts.push(fresh);
@@ -45,7 +45,7 @@ export async function cmdAdd(): Promise<number> {
   });
 
   console.log();
-  const usageNote = sampled ? ` (session ${sampled.session.usedPercentage}% / week ${sampled.weekAll.usedPercentage}%)` : "";
+  const usageNote = sampled ? ` (session ${sampled.fiveHour.usedPercentage}% / week ${sampled.sevenDay.usedPercentage}%)` : "";
   console.log(`${c.green("✓")} added ${c.bold(account.email)} (${claudeTierLabel(account) ?? "?"})${usageNote} → pool now has ${count({ n: poolSize, noun: "account" })}`);
   return 0;
 }

package/src/cli/auth.ts

@@ -6,6 +6,7 @@ import { paths } from "../lib/paths.ts";
 import { writeItem, parkedTarget, claudeAiOauthOnly } from "../lib/credstore.ts";
 import { findAccount } from "./rename.ts";
 import { harvestIsolatedLogin } from "./onboard.ts";
+import { keepRows } from "../lib/usage.ts";
 import { c, claudeTierLabel, count } from "./render.ts";
 import type { Account, AccountsIndex } from "../lib/types.ts";
 
@@ -101,19 +102,15 @@ async function reauthOne(target: Account): Promise<boolean> {
     account.rateLimitTier = blob.claudeAiOauth.rateLimitTier;
     account.needsReauth = false;
     if (sampled) {
-      account.lastUsage = { fiveHour: sampled.session, sevenDay: sampled.weekAll };
       account.lastUsageAt = Date.now();
-      if (Object.keys(sampled.perModel).length > 0) {
-        account.lastPerModel = sampled.perModel;
-        account.lastPerModelAt = account.lastUsageAt;
-      }
+      account.lastUsage = keepRows(sampled, account.lastUsage, account.lastUsageAt);
     }
     saveAccounts(idx);
     return idx.activeAccountUuid === target.accountUuid;
   });
   if (isActive === null) return false;
 
-  const usageNote = sampled ? ` (session ${sampled.session.usedPercentage}% / week ${sampled.weekAll.usedPercentage}%)` : "";
+  const usageNote = sampled ? ` (session ${sampled.fiveHour.usedPercentage}% / week ${sampled.sevenDay.usedPercentage}%)` : "";
   const tier = claudeTierLabel(blob.claudeAiOauth) ?? "?";
   console.log(`${c.green("✓")} reauthed ${c.bold(oauthAccount.emailAddress)} (${tier})${usageNote}`);
   if (isActive) {

package/src/cli/onboard.ts

@@ -3,17 +3,17 @@ import { join } from "node:path";
 import { z } from "zod";
 import { readItem, deleteItem, isolatedTarget } from "../lib/credstore.ts";
 import { resolveRealClaude } from "../lib/claudebin.ts";
-import { CRED_ENV_OVERRIDES, probeUsage, FullUsageSchema } from "../lib/usage.ts";
+import { CRED_ENV_OVERRIDES, probeUsage } from "../lib/usage.ts";
 import { saveTermios, restoreTermios } from "../lib/tty.ts";
 import { paths } from "../lib/paths.ts";
-import { CredentialBlobSchema, OAuthAccountSchema } from "../lib/types.ts";
+import { CredentialBlobSchema, OAuthAccountSchema, UsageWindowsSchema } from "../lib/types.ts";
 import { c } from "./render.ts";
 
 const HarvestedLoginSchema = z.object({
   blobRaw: z.string(),
   blob: CredentialBlobSchema,
   oauthAccount: OAuthAccountSchema,
-  sampled: FullUsageSchema.nullable(),
+  sampled: UsageWindowsSchema.nullable(),
 });
 export type HarvestedLogin = z.infer<typeof HarvestedLoginSchema>;
 

package/src/cli/status.ts

@@ -1,6 +1,6 @@
 import { chunk, sortBy } from "es-toolkit";
 import { z } from "zod";
-import { loadAccounts, loadConfig, loadUsage, loadUsageSnapshot, loadModelUsage, saveAccounts } from "../lib/state.ts";
+import { loadAccounts, loadConfig, loadUsage, loadUsageSnapshot, 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";
@@ -11,8 +11,8 @@ import { liveCodexAccountId, sampleCodexAccount, type CodexSampleOutcome } from
 import { isCodexExhausted } from "../lib/codexpick.ts";
 import { codexLimitLabel, isSessionWindow } from "../lib/codexusage.ts";
 import { bar, c, claudeTierLabel, count, emitJson, fmtAgo } from "./render.ts";
-import { gatedFamilies, type FullUsage } from "../lib/usage.ts";
-import { ThresholdsSchema, UsageWindowSchema, type Account, type CodexWindow, type Config, type UsageWindow } from "../lib/types.ts";
+import { gatedFamilies, keepRows } from "../lib/usage.ts";
+import { ThresholdsSchema, UsageWindowSchema, type Account, type CodexWindow, type Config, type UsageWindow, type UsageWindows } from "../lib/types.ts";
 
 const SampleReportSchema = z.discriminatedUnion("ok", [
   z.object({ ok: z.literal(true), source: z.enum(["statusline", "probe", "cached"]) }),
@@ -95,21 +95,14 @@ async function collectClaude(input: { cfg: Config; now: number; cached: boolean
       const tee = loadUsageSnapshot();
       const live = tee?.state ?? null;
       const teeAt = tee?.at ?? null;
-      const modelUsage = loadModelUsage();
       const liveOAuth = readOAuthAccount();
       const liveAccount = liveOAuth?.accountUuid ?? null;
       const probeOne = async (a: Account) => {
         const isActive = liveAccount != null && liveAccount === a.accountUuid;
         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 && teeCurrent && live.account === a.accountUuid
-            ? {
-                session: live.fiveHour,
-                weekAll: live.sevenDay,
-                perModel: modelUsage && modelUsage.account === a.accountUuid ? modelUsage.perModel : {},
-              }
-            : null;
+        const fromStatusLine: UsageWindows | null =
+          isActive && live && teeCurrent && live.account === a.accountUuid ? { fiveHour: live.fiveHour, sevenDay: live.sevenDay, perModel: {} } : null;
         const viaTee = fromStatusLine != null;
         const outcome: SampleOutcome = fromStatusLine
           ? { ok: true, usage: fromStatusLine }
@@ -118,12 +111,8 @@ async function collectClaude(input: { cfg: Config; now: number; cached: boolean
             : await probeParkedUsage(a);
         samples.set(a.accountUuid, { outcome, viaTee });
         if (!outcome.ok) return;
-        a.lastUsage = { fiveHour: outcome.usage.session, sevenDay: outcome.usage.weekAll };
         a.lastUsageAt = viaTee && teeAt != null ? (live?.sampledAt ?? 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;
-        }
+        a.lastUsage = keepRows(outcome.usage, a.lastUsage, a.lastUsageAt);
       };
       const activeAccount = idx.accounts.find((a) => liveAccount != null && liveAccount === a.accountUuid) ?? null;
       if (activeAccount) await probeOne(activeAccount);
@@ -142,9 +131,8 @@ async function collectClaude(input: { cfg: Config; now: number; cached: boolean
   const ordered = sortBy(idx.accounts, [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, now)]);
   const accounts = ordered.map((a): ClaudeStatusAccount => {
     const sampled = samples.get(a.accountUuid);
-    const usage = sampled?.outcome.ok ? sampled.outcome.usage : undefined;
-    const aggregate = usage ? { fiveHour: usage.session, sevenDay: usage.weekAll } : a.lastUsage;
-    const perModel = usage ? usage.perModel : (a.lastPerModel ?? {});
+    const aggregate = a.lastUsage;
+    const perModel = aggregate?.perModel ?? {};
     return {
       label: a.label,
       email: a.email,
@@ -157,7 +145,7 @@ async function collectClaude(input: { cfg: Config; now: number; cached: boolean
       usage: aggregate ? { fiveHour: currentWindow(aggregate.fiveHour, false, now), week: currentWindow(aggregate.sevenDay, true, now) } : null,
       perModel: Object.fromEntries(Object.entries(perModel).map(([name, w]) => [name, currentWindow(w, true, now)])),
       usageAt: a.lastUsageAt ?? null,
-      perModelAt: a.lastPerModelAt ?? null,
+      perModelAt: aggregate?.rowsAt ?? null,
       sample: sampled
         ? sampled.outcome.ok
           ? { ok: true, source: sampled.viaTee ? "statusline" : "probe" }

package/src/entries/statusline.ts

@@ -1,7 +1,7 @@
 import { sortBy } from "es-toolkit";
 import { z } from "zod";
 import { readOAuthAccount } from "../lib/claudejson.ts";
-import { loadAccounts, loadConfig, loadLastSwapAt, loadModelUsage, writeUsage } from "../lib/state.ts";
+import { loadAccounts, loadConfig, loadLastSwapAt, writeUsage } from "../lib/state.ts";
 import { familyTokens, matchedFamily, parseStatusLineStdin, parseStatusLineModel } from "../lib/usage.ts";
 import { earliestReset, weeklyExpiry } from "../lib/picker.ts";
 import { worktreeName } from "../lib/worktree.ts";
@@ -80,11 +80,16 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
   const seatUuid =
     (ctx.liveAccount != null && ctx.accounts.accounts.some((a) => a.accountUuid === ctx.liveAccount) ? ctx.liveAccount : null) ??
     ctx.accounts.activeAccountUuid;
+  const walled = (a: Account) => a.enforcedUntil != null && a.enforcedUntil > ctx.now;
+  const wallSeg = (wall: number) => seg("", { usedPercentage: 100, resetsAt: wall }, wall);
+  const seat = ctx.accounts.accounts.find((a) => a.accountUuid === seatUuid);
+  if (seat?.enforcedUntil != null && walled(seat)) windows.push(wallSeg(seat.enforcedUntil));
+  const seatMarker = seat && walled(seat) ? paint(100)("◆") : col.green("◆");
   const active =
     windows.length > 0
-      ? `${col.green("◆")} ${windows.join(" ")}`
+      ? `${seatMarker} ${windows.join(" ")}`
       : seatUuid != null
-        ? `${col.green("◆")} ?`
+        ? `${seatMarker} ?`
         : "";
 
   const parked = sortBy(
@@ -92,14 +97,15 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
     [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, ctx.now)],
   );
   const poolSeg = (a: Account): string => {
-    const marker = a.needsReauth ? col.red("✗") : col.cyan("◇");
+    const marker = a.needsReauth ? col.red("✗") : walled(a) ? paint(100)("◇") : col.cyan("◇");
+    if (a.enforcedUntil != null && walled(a)) return `${marker} ${wallSeg(a.enforcedUntil)}`;
     const week = a.lastUsage?.sevenDay;
     if (week == null) return `${marker} ?`;
     const weekUsed = used(week);
     if (Math.round(weekUsed) <= 0) return `${marker} ${paint(0)("full")}`;
 
     const parts: string[] = [];
-    for (const [name, w] of Object.entries(a.lastPerModel ?? {})) {
+    for (const [name, w] of Object.entries(a.lastUsage?.perModel ?? {})) {
       if (used(w) > weekUsed) parts.push(seg(initial(name), w, null));
     }
     const expiry = weeklyExpiry(a, ctx.now);
@@ -125,7 +131,7 @@ export async function runStatusline(): Promise<number> {
     const windows = obj == null ? null : parseStatusLineStdin(obj);
     const lastSwapAt = loadLastSwapAt();
     if (windows && (lastSwapAt == null || now - lastSwapAt >= ADOPTION_GRACE_MS)) {
-      const state: UsageState = { ...windows, account, ts: now, model: parseStatusLineModel(obj) };
+      const state: UsageState = { fiveHour: windows.fiveHour, sevenDay: windows.sevenDay, account, ts: now, model: parseStatusLineModel(obj) };
       writeUsage(state);
     }
   } catch {
@@ -134,13 +140,13 @@ export async function runStatusline(): Promise<number> {
   let line: string;
   try {
     const cfg = loadConfig();
-    const modelUsage = loadModelUsage();
+    const accounts = loadAccounts();
     const stdin = StatusLineStdinSchema.safeParse(obj);
     const dir = stdin.success ? (stdin.data.workspace?.current_dir ?? stdin.data.workspace?.project_dir ?? null) : null;
     const colorterm = z.string().optional().parse(process.env.COLORTERM);
     const ctx: RenderCtx = {
-      accounts: loadAccounts(),
-      perModel: modelUsage && modelUsage.account === account ? modelUsage.perModel : {},
+      accounts,
+      perModel: accounts.accounts.find((a) => a.accountUuid === account)?.lastUsage?.perModel ?? {},
       switchModels: cfg.policy.switchModels,
       worktree: dir == null ? null : worktreeName(dir),
       liveAccount: account,

package/src/entries/stopfailurehook.ts

@@ -3,14 +3,13 @@ import { z } from "zod";
 import { paths } from "../lib/paths.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
 import { readOAuthAccount } from "../lib/claudejson.ts";
-import { enforcedWindowMs, evaluateAndMaybeSwap, postSwapProof, recordEnforcedLimit } from "../lib/decide.ts";
-import { loadConfig, loadLastSwapAt } from "../lib/state.ts";
+import { evaluateAndMaybeSwap } from "../lib/decide.ts";
+import { withLock } from "../lib/lock.ts";
+import { POST_SWAP_COOLDOWN_MS, loadConfig, loadLastSwapAt } from "../lib/state.ts";
 import { classifyEnforcedLimit, findEnforcedRow, parseErrorBody, readTranscriptTail } from "../lib/usage.ts";
 import { RespawnMarkerSchema, type EnforcedLimit } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
 
-export const RETRIGGER_PROMPT = "Continue where the previous turn left off; it was interrupted by a usage limit and tokenmaxxing switched accounts.";
-
 const StopFailureStdin = z.looseObject({
   session_id: z.uuid().optional().catch(undefined),
   transcript_path: z.string().optional().catch(undefined),
@@ -30,7 +29,8 @@ async function readStdin(): Promise<string> {
 export async function runStopFailureHook(): Promise<number> {
   if (process.env.TOKENMAXXING_PROBE) return 0;
 
-  const account = readOAuthAccount()?.accountUuid ?? null;
+  const entry = await withLock(paths.lockFile, () => ({ swapClock: loadLastSwapAt(), account: readOAuthAccount()?.accountUuid ?? null }));
+  const account = entry.account;
   const now = Date.now();
   const raw = await readStdin();
   const parsed = StopFailureStdin.safeParse((() => { try { return JSON.parse(raw); } catch { return {}; } })());
@@ -44,29 +44,27 @@ export async function runStopFailureHook(): Promise<number> {
   const canPause = process.env.TOKENMAXXING_SUPERVISED === "1" && pinnedSid != null && mainLoop;
 
   try {
+    const lastSwapAt = loadLastSwapAt();
+    if (lastSwapAt != null && lastSwapAt === entry.swapClock && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
+      log("stopfailure.cooldown", { sinceSwapMs: now - lastSwapAt });
+      return 0;
+    }
     const cfg = loadConfig();
-    const found = stdin.transcript_path
+    const row = stdin.transcript_path
       ? findEnforcedRow({ rows: readTranscriptTail(stdin.transcript_path), lastAssistantMessage: stdin.last_assistant_message, now })
       : null;
-    const limit = found ? classifyEnforcedLimit(found.row, cfg.policy.switchModels) : null;
+    const limit = row ? classifyEnforcedLimit(row, cfg.policy.switchModels) : null;
 
     let enforced: EnforcedLimit | null = null;
-    if (limit && found && account) {
-      if (postSwapProof({ swapAt: loadLastSwapAt(), launchedAt, errorAt: found.errorAt, now })) {
-        const stamp = await recordEnforcedLimit({ limit, account, now });
-        log("stopfailure.enforced", { kind: limit.kind, family: limit.kind === "model" ? limit.family : undefined, outcome: stamp.outcome, resetsAt: stamp.resetsAt, subagent: !mainLoop });
-        if (stamp.outcome !== "account-moved") {
-          enforced = { account, family: limit.kind === "model" ? limit.family : null, resetsAt: stamp.resetsAt, windowMs: enforcedWindowMs(limit) };
-        }
-      } else {
-        log("stopfailure.unproven", { kind: limit.kind });
-      }
+    if (limit && account) {
+      enforced = { account, kind: limit.kind, family: limit.kind === "model" ? limit.family : null, resetsAt: limit.resetsAt, blind: !mainLoop && limit.kind !== "model" };
+      log("stopfailure.enforced", { kind: limit.kind, family: enforced.family ?? undefined, resetsAt: limit.resetsAt, subagent: !mainLoop });
     } else {
       log("stopfailure.unclassified", {
-        row: found != null,
-        type: found?.row.quotaLimits?.rateLimitType,
-        transient: found?.row.apiErrorIsTransient,
-        body: found ? parseErrorBody(found.row.errorDetails)?.error?.type : undefined,
+        row: row != null,
+        type: row?.quotaLimits?.rateLimitType,
+        transient: row?.apiErrorIsTransient,
+        body: row ? parseErrorBody(row.errorDetails)?.error?.type : undefined,
       });
     }
 
@@ -78,7 +76,6 @@ export async function runStopFailureHook(): Promise<number> {
         ts: Date.now(),
         waitUntil: decision.waitUntil ?? now,
         sessionId: stdinSid ?? pinnedSid,
-        prompt: RETRIGGER_PROMPT,
         ...(launchedAt != null ? { launchedAt } : {}),
       });
       writeFileAtomic(marker, JSON.stringify(payload));

package/src/entries/supervisor.ts

@@ -292,7 +292,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
         if (await countdownWait(m.account, m.waitUntil)) overriddenUntil = m.waitUntil;
       } else process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: switched to ${m.account} - resuming...\x1b[0m\n`);
       saveSessionFlags(m.sessionId, persistable, process.cwd());
-      launchArgs = ["--resume", m.sessionId, ...persistable, ...(m.prompt ? ["--", m.prompt] : [])];
+      launchArgs = ["--resume", m.sessionId, ...persistable];
       continue;
     }
     log("supervisor.exit", { sid, respawns, code: child.exitCode, signal: child.signalCode });

package/src/lib/decide.ts

@@ -2,13 +2,13 @@ import { maxBy } from "es-toolkit";
 import { z } from "zod";
 import { withLock } from "./lock.ts";
 import { paths } from "./paths.ts";
-import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsage, loadUsageSnapshot, loadModelUsage, saveAccounts, saveDepletedWait, saveModelUsage, writeUsage } from "./state.ts";
+import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsageSnapshot, saveAccounts, saveDepletedWait, writeUsage } from "./state.ts";
 import { readOAuthAccount } from "./claudejson.ts";
 import { isSkippableSwapError, performSwap } from "./swap.ts";
-import { nextWeeklyReset, pickBest, pickEarliestReset, thresholdBars, usableAt } from "./picker.ts";
-import { familyTokens, gatedFamilies, probeUsage, type EnforcedClass } from "./usage.ts";
+import { isExhausted, nextWeeklyReset, pickBest, pickEarliestReset, thresholdBars, usableAt } from "./picker.ts";
+import { familyTokens, gatedFamilies, keepRows, probeUsage } from "./usage.ts";
 import { log } from "./log.ts";
-import { AccountSchema, ModelUsageStateSchema, UsageStateSchema, type Account, type Config, type EnforcedLimit, type ModelUsageState, type Thresholds, type UsageState, type UsageWindow } from "./types.ts";
+import { AccountSchema, UsageStateSchema, type Account, type Config, type EnforcedLimit, type Thresholds, type UsageState, type UsageWindow } from "./types.ts";
 
 const SwapDecisionSchema = z.object({
   swapped: z.boolean(),
@@ -28,24 +28,28 @@ function liveUsed(input: { window: UsageWindow; windowMs: number; sampledAt: num
   return w.usedPercentage;
 }
 
-function capForFamily(mu: ModelUsageState, family: string, now: number): UsageWindow | undefined {
-  const rows = Object.entries(mu.perModel)
+function rowsSampledAt(account: Account, now: number): number {
+  return account.lastUsage?.rowsAt ?? account.lastUsageAt ?? now;
+}
+
+function capForFamily(account: Account, family: string, now: number): UsageWindow | undefined {
+  const rows = Object.entries(account.lastUsage?.perModel ?? {})
     .filter(([k]) => familyTokens(k).includes(family))
     .map(([, w]) => w);
-  return maxBy(rows, (w) => liveUsed({ window: w, windowMs: WEEK_MS, sampledAt: mu.sampledAt ?? mu.ts, now }));
+  return maxBy(rows, (w) => liveUsed({ window: w, windowMs: WEEK_MS, sampledAt: rowsSampledAt(account, now), now }));
 }
 
-function isOver(u: UsageState | null, mu: ModelUsageState | null, account: string | null, bars: Thresholds, cfg: Config, now: number): boolean {
-  if (!u || !account || u.account !== account) return false;
+function isOver(u: UsageState | null, account: Account | undefined, bars: Thresholds, cfg: Config, now: number): boolean {
+  if (!account) return false;
+  if (account.enforcedUntil != null && account.enforcedUntil > now) return true;
+  if (!u || u.account !== account.accountUuid) return false;
   if (
     liveUsed({ window: u.fiveHour, windowMs: FIVE_HOURS_MS, sampledAt: u.ts, now }) >= bars.session ||
     liveUsed({ window: u.sevenDay, windowMs: WEEK_MS, sampledAt: u.ts, now }) >= bars.weekly
   ) return true;
-  if (mu && mu.account === account) {
-    for (const family of gatedFamilies(u.model, cfg.policy.switchModels)) {
-      const cap = capForFamily(mu, family, now);
-      if (cap && liveUsed({ window: cap, windowMs: WEEK_MS, sampledAt: mu.sampledAt ?? mu.ts, now }) >= bars.weekly) return true;
-    }
+  for (const family of gatedFamilies(u.model, cfg.policy.switchModels)) {
+    const cap = capForFamily(account, family, now);
+    if (cap && liveUsed({ window: cap, windowMs: WEEK_MS, sampledAt: rowsSampledAt(account, now), now }) >= bars.weekly) return true;
   }
   return false;
 }
@@ -56,7 +60,6 @@ function needsPerModel(u: UsageState | null, cfg: Config): boolean {
 
 const SnapshotsSchema = z.object({
   u: UsageStateSchema.nullable(),
-  mu: ModelUsageStateSchema.nullable(),
   uAt: z.number().nullable(),
 });
 type Snapshots = z.infer<typeof SnapshotsSchema>;
@@ -74,14 +77,16 @@ function freshest(u: UsageState | null, uAt: number | null, account: Account | u
   return { ...u, ts: uAt };
 }
 
-async function loadFreshSnapshots(cfg: Config, account: string | null, now: number): Promise<Snapshots> {
+async function loadFreshSnapshots(cfg: Config, account: string | null, now: number, probe: boolean): Promise<Snapshots> {
   const snap = loadUsageSnapshot();
   let u = snap?.state ?? null;
   let uAt = snap?.at ?? null;
-  let mu = loadModelUsage();
   const ttl = cfg.policy.usagePollTtlMs;
-  const probeAttempted = mu != null && mu.account === account && now - mu.ts <= ttl;
-  if (account && !probeAttempted && (!usageFresh(u, uAt, account, ttl, now) || needsPerModel(u, cfg))) {
+  const stored = loadAccounts().accounts.find((a) => a.accountUuid === account);
+  const probeAttempted = stored?.lastProbeAt != null && now - stored.lastProbeAt <= ttl;
+  const walled = stored?.enforcedUntil != null && stored.enforcedUntil > now;
+  if (probe && account && stored && !walled && !probeAttempted && (!usageFresh(u, uAt, account, ttl, now) || needsPerModel(u, cfg))) {
+    const startedAt = Date.now();
     const full = await probeUsage();
     const ts = Date.now();
     if (readOAuthAccount()?.accountUuid === account) {
@@ -91,43 +96,48 @@ async function loadFreshSnapshots(cfg: Config, account: string | null, now: numb
           u = teed.state;
           uAt = teed.at;
         } else {
-          u = { fiveHour: full.session, sevenDay: full.weekAll, account, ts, model: null };
+          u = { fiveHour: full.fiveHour, sevenDay: full.sevenDay, account, ts, model: null };
           writeUsage(u);
           uAt = ts;
         }
-        mu = { perModel: full.perModel, account, ts, sampledAt: ts };
-        saveModelUsage(mu);
         const expected = gatedFamilies(u?.model ?? null, cfg.policy.switchModels);
         const rows = Object.keys(full.perModel);
         if (expected.length > 0 && !expected.some((f) => rows.some((k) => familyTokens(k).includes(f)))) {
           log("usage.no_permodel_row", { families: expected.join(","), rows: rows.join(",") });
         }
-      } else {
-        mu = { perModel: mu?.account === account ? (mu?.perModel ?? {}) : {}, account, ts, sampledAt: mu?.account === account ? (mu?.sampledAt ?? mu?.ts) : undefined };
-        saveModelUsage(mu);
       }
+      await withLock(paths.lockFile, () => {
+        const idx = loadAccounts();
+        const a = idx.accounts.find((x) => x.accountUuid === account);
+        if (!a) return;
+        a.lastProbeAt = startedAt;
+        if (full) {
+          if (!a.lastUsage) a.lastUsageAt = startedAt;
+          a.lastUsage = keepRows({ ...(a.lastUsage ?? full), perModel: full.perModel }, a.lastUsage, startedAt);
+        }
+        saveAccounts(idx);
+      });
     }
   }
-  return { u, mu, uAt };
+  return { u, uAt };
 }
 
 export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = false, enforced: EnforcedLimit | null = null): Promise<SwapDecision> {
   const activeAccount = readOAuthAccount()?.accountUuid ?? null;
-  const enforced0 = enforced && enforced.account === activeAccount ? enforced : null;
 
   const lastSwapAt = loadLastSwapAt();
-  if (!enforced0 && lastSwapAt != null && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
+  if (!enforced && lastSwapAt != null && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
     return depletedReplay(now) ?? { swapped: false, account: null, reason: "post-swap-cooldown" };
   }
 
   const cfg = loadConfig();
   const bars = thresholdBars(cfg);
 
-  const { u: teeUsage, mu, uAt } = await loadFreshSnapshots(cfg, activeAccount, now);
-  const pool = loadAccounts();
-  const usage = freshest(teeUsage, uAt, pool.accounts.find((a) => a.accountUuid === activeAccount));
+  const { u: teeUsage, uAt } = await loadFreshSnapshots(cfg, activeAccount, now, enforced == null);
+  const stored = loadAccounts().accounts.find((a) => a.accountUuid === activeAccount);
+  const usage = freshest(teeUsage, uAt, stored);
 
-  if (!enforced0 && !isOver(usage, mu, activeAccount, bars, cfg, now)) {
+  if (!enforced && !isOver(usage, stored, bars, cfg, now)) {
     const measured = usage != null && activeAccount != null && usage.account === activeAccount;
     if (!measured) {
       const replay = depletedReplay(now);
@@ -139,35 +149,38 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
   return withLock(paths.lockFile, async () => {
     const idx = loadAccounts();
     const account2 = readOAuthAccount()?.accountUuid ?? null;
-    const enforced2 = enforced0 && enforced0.account === account2 ? enforced0 : null;
     const tee = loadUsageSnapshot();
     const active = account2 ? idx.accounts.find((a) => a.accountUuid === account2) : undefined;
     const u2 = tee ? freshest(tee.state, tee.at, active) : usage;
-    const mu2 = needsPerModel(u2, cfg) || enforced2?.family ? loadModelUsage() ?? mu : null;
+
+    const origin = enforced ? idx.accounts.find((a) => a.accountUuid === enforced.account) : undefined;
+    const prior = origin?.enforcedUntil != null && origin.enforcedUntil > now;
+    if (enforced && origin) {
+      origin.enforcedUntil = Math.max(origin.enforcedUntil ?? 0, enforcedWall(enforced, origin, now));
+      origin.lastProbeAt = now;
+      saveAccounts(idx);
+      log("usage.enforced_limit", { kind: enforced.kind, family: enforced.family ?? undefined, resetsAt: origin.enforcedUntil, blind: prior || enforced.blind, live: origin === active });
+    }
+    const enforced2 = enforced && origin && origin === active ? enforced : null;
 
     if (account2 != null && !active) {
       return { swapped: false, account: null, reason: "live-credential-not-in-pool" };
     }
 
-    if (active) {
-      let sampled = false;
-      if (tee && tee.state.account === account2 && (active.lastUsageAt == null || tee.at >= active.lastUsageAt)) {
-        active.lastUsage = { fiveHour: tee.state.fiveHour, sevenDay: tee.state.sevenDay };
-        active.lastUsageAt = tee.state.sampledAt ?? tee.at;
-        sampled = true;
-      }
-      if (mu2 && mu2.account === account2 && Object.keys(mu2.perModel).length > 0) {
-        active.lastPerModel = mu2.perModel;
-        active.lastPerModelAt = mu2.sampledAt ?? mu2.ts;
-        sampled = true;
-      }
-      if (sampled) saveAccounts(idx);
+    if (active && tee && tee.state.account === account2 && (active.lastUsageAt == null || tee.at >= active.lastUsageAt)) {
+      active.lastUsageAt = tee.state.sampledAt ?? tee.at;
+      active.lastUsage = keepRows({ fiveHour: tee.state.fiveHour, sevenDay: tee.state.sevenDay, perModel: {} }, active.lastUsage, active.lastUsageAt);
+      saveAccounts(idx);
     }
 
-    const gated = gatedFamilies(u2?.model ?? null, cfg.policy.switchModels);
-    const switchFamilies = enforced2?.family && !gated.includes(enforced2.family) ? [...gated, enforced2.family] : gated;
+    const walled = active?.enforcedUntil != null && active.enforcedUntil > now;
+    const blindScreen = (enforced != null && (prior || enforced.blind)) || (walled && !enforced2);
+    const gated = blindScreen ? cfg.policy.switchModels : gatedFamilies(u2?.model ?? null, cfg.policy.switchModels);
+    const family = enforced?.family ?? null;
+    const switchFamilies = family != null && !gated.includes(family) ? [...gated, family] : gated;
 
-    if (!enforced2 && !isOver(u2, mu2, account2, bars, cfg, now)) {
+    const seatExhausted = active != null && isExhausted(active, { now, thresholds: bars, currentAccountUuid: account2, switchFamilies });
+    if (!enforced2 && !isOver(u2, active, bars, cfg, now) && !(enforced && seatExhausted)) {
       return depletedReplay(now) ?? { swapped: false, account: null, reason: "raced-already-swapped" };
     }
 
@@ -203,8 +216,7 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
       const fresh = loadAccounts();
       const current = seatOf(fresh);
       const ctx = { now, thresholds: bars, currentAccountUuid: current?.accountUuid ?? null, switchFamilies };
-      const enforcedUntil = enforced2 && current && current.accountUuid === enforced2.account ? (enforced2.resetsAt ?? now + enforced2.windowMs) : 0;
-      const currentAt = current ? Math.max(usableAt(current, ctx), enforcedUntil) : Number.POSITIVE_INFINITY;
+      const currentAt = current ? usableAt(current, ctx) : Number.POSITIVE_INFINITY;
       const other = pickEarliestReset(usable(fresh.accounts), ctx);
 
       let target: Account | null = null;
@@ -247,64 +259,19 @@ function depletedReplay(now: number): SwapDecision | null {
   return { swapped: false, account, reason: "depleted-wait", waitUntil: rec.waitUntil };
 }
 
-export function enforcedWindowMs(limit: EnforcedClass): number {
-  return limit.kind === "session" ? FIVE_HOURS_MS : WEEK_MS;
-}
-
-export function postSwapProof(input: { swapAt: number | null; launchedAt: number | null; errorAt: number | null; now: number }): boolean {
-  const { swapAt, launchedAt, errorAt, now } = input;
-  if (swapAt == null) return true;
-  if (launchedAt != null && launchedAt > swapAt) return true;
-  return (errorAt ?? now) - swapAt >= POST_SWAP_COOLDOWN_MS;
-}
-
-const StampSchema = z.object({ outcome: z.enum(["stamped", "account-moved", "no-carrier"]), resetsAt: z.number().nullable() });
-export type Stamp = z.infer<typeof StampSchema>;
-
-export async function recordEnforcedLimit(input: { limit: EnforcedClass; account: string; now: number }): Promise<Stamp> {
-  const { limit, account: accountUuid, now } = input;
-  return withLock(paths.lockFile, () => {
-    if ((readOAuthAccount()?.accountUuid ?? null) !== accountUuid) return { outcome: "account-moved", resetsAt: limit.resetsAt };
-    const prior = loadUsage();
-    const priorSame = prior && prior.account === accountUuid ? prior : null;
-    const idx = loadAccounts();
-    const account = idx.accounts.find((a) => a.accountUuid === accountUuid);
-    const mu = loadModelUsage();
-    const muSame = mu && mu.account === accountUuid ? mu : null;
-    const carriedRows = muSame?.perModel ?? {};
-    const sampledAt = muSame?.sampledAt ?? muSame?.ts;
-    if (limit.kind === "model") {
-      const rowsFor = (rows: Record<string, UsageWindow>) => Object.entries(rows).filter(([k]) => familyTokens(k).includes(limit.family)).map(([, w]) => w);
-      const knownReset = [...rowsFor(carriedRows), ...rowsFor(account?.lastPerModel ?? {})].map((w) => w.resetsAt).find((r): r is number => r != null) ?? null;
-      const weeklyReset = priorSame?.sevenDay.resetsAt ?? account?.lastUsage?.sevenDay.resetsAt ?? null;
-      const resetsAt = limit.resetsAt ?? nextWeeklyReset(knownReset ?? weeklyReset, now);
-      saveModelUsage({
-        perModel: { ...carriedRows, [limit.family]: { usedPercentage: 100, resetsAt } },
-        account: accountUuid,
-        ts: now,
-        sampledAt: resetsAt == null ? now : sampledAt ?? now,
-      });
-      log("usage.enforced_limit", { kind: limit.kind, family: limit.family, resetsAt });
-      return { outcome: "stamped", resetsAt };
-    }
-    saveModelUsage({ perModel: carriedRows, account: accountUuid, ts: now, sampledAt });
-    if (account && limit.resetsAt != null) {
-      account.enforcedUntil = limit.resetsAt;
-      saveAccounts(idx);
-    }
-    const carrier = priorSame ?? (account?.lastUsage ? { ...account.lastUsage, model: null } : null);
-    if (!carrier) return { outcome: "no-carrier", resetsAt: limit.resetsAt };
-    const window: UsageWindow = { usedPercentage: 100, resetsAt: limit.resetsAt };
-    writeUsage({
-      ...(priorSame ?? {}),
-      ...(priorSame == null && account?.lastUsageAt != null ? { sampledAt: account.lastUsageAt } : {}),
-      fiveHour: limit.kind === "session" ? window : carrier.fiveHour,
-      sevenDay: limit.kind === "weekly" ? window : carrier.sevenDay,
-      account: accountUuid,
-      ts: now,
-      model: carrier.model,
-    }, { stamp: true });
-    log("usage.enforced_limit", { kind: limit.kind, resetsAt: limit.resetsAt });
-    return { outcome: "stamped", resetsAt: limit.resetsAt };
-  });
+function enforcedWall(limit: EnforcedLimit, account: Account, now: number): number {
+  const cached = account.lastUsage;
+  const { family } = limit;
+  const familyReset =
+    family == null
+      ? null
+      : Object.entries(cached?.perModel ?? {})
+          .filter(([k]) => familyTokens(k).includes(family))
+          .map(([, w]) => w.resetsAt)
+          .find((r): r is number => r != null) ?? null;
+  const cachedReset =
+    limit.kind === "session"
+      ? cached?.fiveHour.resetsAt != null && cached.fiveHour.resetsAt > now ? cached.fiveHour.resetsAt : null
+      : nextWeeklyReset(familyReset ?? cached?.sevenDay.resetsAt ?? null, now);
+  return limit.resetsAt ?? cachedReset ?? now + (limit.kind === "session" ? FIVE_HOURS_MS : WEEK_MS);
 }

package/src/lib/paths.ts

@@ -17,7 +17,6 @@ export const paths = {
   configJson: join(TM_HOME, "config.json"),
   accountsJson: join(TM_HOME, "accounts.json"),
   usageJson: join(TM_HOME, "usage.json"),
-  modelUsageJson: join(TM_HOME, "model-usage.json"),
   lastSwapJson: join(TM_HOME, "lastswap.json"),
   depletedJson: join(TM_HOME, "depleted.json"),
   respawnDir: join(TM_HOME, "respawn"),

package/src/lib/picker.ts

@@ -19,7 +19,7 @@ const PickCtxSchema = z.object({
 export type PickCtx = z.infer<typeof PickCtxSchema>;
 
 function gatedPerModelWindows(a: Account, families: string[]): UsageWindow[] {
-  return Object.entries(a.lastPerModel ?? {})
+  return Object.entries(a.lastUsage?.perModel ?? {})
     .filter(([model]) => families.some((f) => familyTokens(model).includes(f)))
     .map(([, w]) => w);
 }
@@ -42,7 +42,7 @@ function blockingUntil(a: Account, ctx: PickCtx): number[] {
           blockedUntil(u.sevenDay, WEEK_MS, a.lastUsageAt, ctx.thresholds.weekly),
         ]
       : []),
-    ...gatedPerModelWindows(a, ctx.switchFamilies).map((w) => blockedUntil(w, WEEK_MS, a.lastPerModelAt ?? a.lastUsageAt, ctx.thresholds.weekly)),
+    ...gatedPerModelWindows(a, ctx.switchFamilies).map((w) => blockedUntil(w, WEEK_MS, u?.rowsAt ?? a.lastUsageAt, ctx.thresholds.weekly)),
     ...(a.enforcedUntil != null ? [a.enforcedUntil] : []),
   ];
 }

package/src/lib/sample.ts

@@ -8,14 +8,14 @@ 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 { FullUsageSchema, probeUsage } from "./usage.ts";
+import { keepRows, probeUsage } from "./usage.ts";
 import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadLastSwapAt, saveAccounts } from "./state.ts";
 import { keepRotatedPair } from "./swap.ts";
 import { log } from "./log.ts";
-import { CredentialBlobSchema, TokenIdentitySchema, type Account, type Config, type OAuthCreds, type TokenIdentity } from "./types.ts";
+import { CredentialBlobSchema, TokenIdentitySchema, UsageWindowsSchema, type Account, type Config, type OAuthCreds, type TokenIdentity } from "./types.ts";
 
 const SampleOutcomeSchema = z.discriminatedUnion("ok", [
-  z.object({ ok: z.literal(true), usage: FullUsageSchema }),
+  z.object({ ok: z.literal(true), usage: UsageWindowsSchema }),
   z.object({ ok: z.literal(false), reason: z.string() }),
 ]);
 export type SampleOutcome = z.infer<typeof SampleOutcomeSchema>;
@@ -246,12 +246,8 @@ export async function sampleOldestParked(cfg: Config): Promise<void> {
       const idx = loadAccounts();
       const stored = idx.accounts.find((a) => a.accountUuid === account.accountUuid);
       if (stored && outcome.ok && (stored.lastUsageAt == null || startedAt > stored.lastUsageAt)) {
-        stored.lastUsage = { fiveHour: outcome.usage.session, sevenDay: outcome.usage.weekAll };
+        stored.lastUsage = keepRows(outcome.usage, stored.lastUsage, startedAt);
         stored.lastUsageAt = startedAt;
-        if (Object.keys(outcome.usage.perModel).length > 0) {
-          stored.lastPerModel = outcome.usage.perModel;
-          stored.lastPerModelAt = startedAt;
-        }
         saveAccounts(idx);
       }
       log(outcome.ok ? "sample.parked_ok" : "sample.parked_failed", {

package/src/lib/state.ts

@@ -7,11 +7,9 @@ import {
   AccountsIndexSchema,
   ConfigSchema,
   LastSwapSchema,
-  ModelUsageStateSchema,
   UsageStateSchema,
   type AccountsIndex,
   type Config,
-  type ModelUsageState,
   type UsageState,
 } from "./types.ts";
 
@@ -91,7 +89,6 @@ export function loadUsage(): UsageState | null {
 
 export function clearUsageSnapshots(): void {
   rmSync(paths.usageJson, { force: true });
-  rmSync(paths.modelUsageJson, { force: true });
 }
 
 export function loadLastSwapAt(): number | null {
@@ -159,17 +156,3 @@ export function writeUsage(input: UsageState, opts: { stamp?: boolean } = {}): b
   writeFileAtomic(paths.usageJson, JSON.stringify(next));
   return true;
 }
-
-export function loadModelUsage(): ModelUsageState | null {
-  if (!existsSync(paths.modelUsageJson)) return null;
-  try {
-    const parsed = ModelUsageStateSchema.safeParse(JSON.parse(readFileSync(paths.modelUsageJson, "utf8")));
-    return parsed.success ? parsed.data : null;
-  } catch {
-    return null;
-  }
-}
-
-export function saveModelUsage(next: ModelUsageState): void {
-  writeFileAtomic(paths.modelUsageJson, JSON.stringify(next));
-}

package/src/lib/types.ts

@@ -31,16 +31,21 @@ export const UsageWindowSchema = z.object({
 });
 export type UsageWindow = z.infer<typeof UsageWindowSchema>;
 
-const UsageWindowsSchema = z.object({
+const AggregateWindowsSchema = z.object({
   fiveHour: UsageWindowSchema,
   sevenDay: UsageWindowSchema,
 });
+
+export const UsageWindowsSchema = AggregateWindowsSchema.extend({
+  perModel: z.record(z.string(), UsageWindowSchema).default({}),
+  rowsAt: z.number().optional(),
+});
 export type UsageWindows = z.infer<typeof UsageWindowsSchema>;
 
 const ModelInfoSchema = z.object({ id: z.string(), display: z.string() });
 export type ModelInfo = z.infer<typeof ModelInfoSchema>;
 
-export const UsageStateSchema = UsageWindowsSchema.extend({
+export const UsageStateSchema = AggregateWindowsSchema.extend({
   account: z.string().nullable(),
   ts: z.number(),
   model: ModelInfoSchema.nullable().default(null),
@@ -48,14 +53,6 @@ export const UsageStateSchema = UsageWindowsSchema.extend({
 });
 export type UsageState = z.infer<typeof UsageStateSchema>;
 
-export const ModelUsageStateSchema = z.object({
-  perModel: z.record(z.string(), UsageWindowSchema).default({}),
-  account: z.string().nullable(),
-  ts: z.number(),
-  sampledAt: z.number().optional(),
-});
-export type ModelUsageState = z.infer<typeof ModelUsageStateSchema>;
-
 export const AccountSchema = z.object({
   accountUuid: z.string(),
   email: z.string(),
@@ -65,8 +62,6 @@ export const AccountSchema = z.object({
   oauthAccount: OAuthAccountSchema,
   addedAt: z.string(),
   lastUsage: UsageWindowsSchema.optional(),
-  lastPerModel: z.record(z.string(), UsageWindowSchema).optional(),
-  lastPerModelAt: z.number().optional(),
   lastUsageAt: z.number().optional(),
   lastProbeAt: z.number().optional(),
   enforcedUntil: z.number().optional(),
@@ -87,9 +82,10 @@ export type AccountsIndex = z.infer<typeof AccountsIndexSchema>;
 
 export const EnforcedLimitSchema = z.object({
   account: z.string(),
+  kind: z.enum(["session", "weekly", "model"]),
   family: z.string().nullable(),
   resetsAt: z.number().nullable(),
-  windowMs: z.number(),
+  blind: z.boolean(),
 });
 export type EnforcedLimit = z.infer<typeof EnforcedLimitSchema>;
 
@@ -133,7 +129,6 @@ export const RespawnMarkerSchema = z.object({
   ts: z.number(),
   waitUntil: z.number(),
   sessionId: z.string(),
-  prompt: z.string().optional(),
   launchedAt: z.number().optional(),
 });
 

package/src/lib/usage.ts

@@ -3,7 +3,7 @@ import { delay } from "es-toolkit";
 import { z } from "zod";
 import { MAX_WRAP_DEPTH, WRAP_DEPTH_ENV, resolveRealClaude } from "./claudebin.ts";
 import { log } from "./log.ts";
-import { RateLimitsStdinSchema, UsageWindowSchema, type ModelInfo, type UsageWindow, type UsageWindows } from "./types.ts";
+import { RateLimitsStdinSchema, type ModelInfo, type UsageWindow, type UsageWindows } from "./types.ts";
 
 export function normalizeResetsAt(v: unknown): number | null {
   const num = z.number().finite().safeParse(v);
@@ -30,7 +30,7 @@ export function parseStatusLineStdin(obj: unknown): UsageWindows | null {
   if (!parsed.success) return null;
   const rl = parsed.data.rate_limits;
   if (!rl?.five_hour || !rl.seven_day) return null;
-  return { fiveHour: win(rl.five_hour), sevenDay: win(rl.seven_day) };
+  return { fiveHour: win(rl.five_hour), sevenDay: win(rl.seven_day), perModel: {} };
 }
 
 export function parseStatusLineModel(obj: unknown): ModelInfo | null {
@@ -57,13 +57,6 @@ export function gatedFamilies(model: ModelInfo | null, families: string[]): stri
   return family ? [family] : [];
 }
 
-export const FullUsageSchema = z.object({
-  session: UsageWindowSchema,
-  weekAll: UsageWindowSchema,
-  perModel: z.record(z.string(), UsageWindowSchema),
-});
-export type FullUsage = z.infer<typeof FullUsageSchema>;
-
 const MONTHS: Record<string, number> = {
   jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5, jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11,
 };
@@ -176,13 +169,7 @@ export function transcriptRowText(row: TranscriptRow): string {
 
 const ROW_RECENCY_MS = 60_000;
 
-const EnforcedRowSchema = z.object({
-  row: TranscriptRowSchema,
-  errorAt: z.number().nullable(),
-});
-export type EnforcedRow = z.infer<typeof EnforcedRowSchema>;
-
-export function findEnforcedRow(input: { rows: TranscriptRow[]; lastAssistantMessage: string | undefined; now: number }): EnforcedRow | null {
+export function findEnforcedRow(input: { rows: TranscriptRow[]; lastAssistantMessage: string | undefined; now: number }): TranscriptRow | null {
   const { rows, lastAssistantMessage, now } = input;
   for (let i = rows.length - 1; i >= 0; i--) {
     const row = rows[i]!;
@@ -190,8 +177,7 @@ export function findEnforcedRow(input: { rows: TranscriptRow[]; lastAssistantMes
     const ts = row.timestamp ? Date.parse(row.timestamp) : Number.NaN;
     const byContent = lastAssistantMessage != null && lastAssistantMessage !== "" && transcriptRowText(row) === lastAssistantMessage;
     const byRecency = Number.isFinite(ts) && Math.abs(now - ts) <= ROW_RECENCY_MS;
-    if (!byContent && !byRecency) continue;
-    return { row, errorAt: Number.isFinite(ts) ? ts : null };
+    if (byContent || byRecency) return row;
   }
   return null;
 }
@@ -237,26 +223,25 @@ export function classifyEnforcedLimit(row: TranscriptRow, switchModels: string[]
   return family ? { kind: "model", family, resetsAt: null } : null;
 }
 
-export function parseUsageTextFull(text: string, now = Date.now()): FullUsage | null {
+export function parseUsageText(text: string, now = Date.now()): UsageWindows | null {
   if (!text) return null;
   const re = /current (session|week \(([^)]+)\)):\s*(\d+)\s*%(?:(?:(?!current)[^\n])*?\bresets\s+([A-Z][a-z]{2,8}\s+\d{1,2}(?:[^\S\n]+at[^\S\n]+|,[^\S\n]*)\d{1,2}(?::\d{2})?\s*[ap]m\s*\([^)]+\)))?/gi;
-  let session: UsageWindow | null = null;
-  let weekAll: UsageWindow | null = null;
+  let fiveHour: UsageWindow | null = null;
+  let sevenDay: UsageWindow | null = null;
   const perModel: Record<string, UsageWindow> = {};
   for (let m = re.exec(text); m !== null; m = re.exec(text)) {
     const window: UsageWindow = { usedPercentage: Number(m[3]), resetsAt: m[4] ? parseResetClock(m[4], now) : null };
-    if (m[1]!.toLowerCase() === "session") session = window;
-    else if (/^all models$/i.test(m[2]!.trim())) weekAll = window;
+    if (m[1]!.toLowerCase() === "session") fiveHour = window;
+    else if (/^all models$/i.test(m[2]!.trim())) sevenDay = window;
     else perModel[m[2]!.trim()] = window;
   }
-  if (!session || !weekAll) return null;
-  return { session, weekAll, perModel };
+  if (!fiveHour || !sevenDay) return null;
+  return { fiveHour, sevenDay, perModel };
 }
 
-export function parseUsageText(text: string, now = Date.now()): UsageWindows | null {
-  const f = parseUsageTextFull(text, now);
-  if (!f) return null;
-  return { fiveHour: f.session, sevenDay: f.weekAll };
+export function keepRows(next: UsageWindows, prev: UsageWindows | undefined, at: number): UsageWindows {
+  if (Object.keys(next.perModel).length > 0 && (prev?.rowsAt == null || prev.rowsAt <= at)) return { ...next, rowsAt: at };
+  return { ...next, perModel: prev?.perModel ?? {}, ...(prev?.rowsAt != null ? { rowsAt: prev.rowsAt } : {}) };
 }
 
 export const CRED_ENV_OVERRIDES = [
@@ -298,7 +283,7 @@ async function spawnClaudeBounded(cmd: string[], env: Record<string, string>): P
   }
 }
 
-async function probeUsageOnce(env: Record<string, string>, now: number): Promise<FullUsage | null> {
+async function probeUsageOnce(env: Record<string, string>, now: number): Promise<UsageWindows | null> {
   let out: string;
   try {
     const r = await spawnClaudeBounded([resolveRealClaude(), "-p", "/usage", "--output-format", "json"], env);
@@ -318,12 +303,12 @@ async function probeUsageOnce(env: Record<string, string>, now: number): Promise
 
   const j = z.object({ result: z.string() }).safeParse((() => { try { return JSON.parse(out); } catch { return null; } })());
   const text = j.success ? j.data.result : out;
-  const full = parseUsageTextFull(text, now);
+  const full = parseUsageText(text, now);
   if (!full) {
     log("usage.probe_unparsed", { sample: text.trim().slice(0, 200) });
   } else {
     const clockLine = text.split("\n").find((l) => /^current /i.test(l) && /\bresets\b/i.test(l));
-    if (clockLine && [full.session, full.weekAll, ...Object.values(full.perModel)].every((w) => w.resetsAt === null)) {
+    if (clockLine && [full.fiveHour, full.sevenDay, ...Object.values(full.perModel)].every((w) => w.resetsAt === null)) {
       log("usage.reset_clock_unparsed", { sample: clockLine.slice(0, 120) });
     }
   }
@@ -344,7 +329,7 @@ function probeEnv(configDir?: string): Record<string, string> {
   return env;
 }
 
-export async function probeUsage(configDir?: string, now = Date.now(), opts: { retries?: number } = {}): Promise<FullUsage | null> {
+export async function probeUsage(configDir?: string, now = Date.now(), opts: { retries?: number } = {}): Promise<UsageWindows | null> {
   const env = probeEnv(configDir);
 
   for (let attempt = 0; ; attempt++) {