tokenmaxxing 1.30.0 → 1.32.0

package/DESIGN.md

@@ -30,8 +30,8 @@ It is a process manager only - spawn with inherited stdio plus saved `stty -g` t
 - A `claude` **supervisor** on your PATH ahead of the real binary (`~/.config/tokenmaxxing/bin/claude`), or a shell function - you invoke it identically.
 - 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 merge at read time, `xx config` edits it.
-  - `accounts.json` - non-secret index `{email, organizationUuid, accountUuid, label, lastUsage, lastPerModel, needsReauth, ...}` (window resets live inside lastUsage).
+  - `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, 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/README.md

@@ -69,7 +69,7 @@ claude                  # use claude as always
 | `tokenmaxxing switch [sel]` | switch the claude pool: bare picks the best account (no-op when the current one wins), a selector targets one |
 | `tokenmaxxing switch --codex [sel]` | switch the codex pool (takes effect on the next codex start) |
 | `tokenmaxxing status [--cached]` | accounts with 5h / weekly usage bars, active + exhausted-until-reset; `--cached` renders the stored figures without sampling |
-| `tokenmaxxing config` | effective config with sources; `get`/`set`/`unset` dotted keys, `tidy` prunes unknown keys |
+| `tokenmaxxing config` | the config path and the effective values; edit the file in an editor, a bad value fails the next load with the field name |
 | `tokenmaxxing doctor` | verify the supervisor + settings entries survived |
 | `tokenmaxxing rename [--codex] <sel> <label>` / `rm [--codex] <sel>` | manage the pool (`--codex` targets the codex pool: one email can hold both a claude and a codex account) |
 | `tokenmaxxing uninstall` | remove supervisor + settings entries (accounts/credentials kept) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.30.0",
+  "version": "1.32.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/config.ts

@@ -1,242 +1,25 @@
-import { existsSync, readFileSync } from "node:fs";
-import { isPlainObject } from "es-toolkit";
-import { get, set, unset } from "es-toolkit/compat";
-import { z } from "zod";
-import { paths, realClaudeBinFromEnv, realCodexBinFromEnv } from "../lib/paths.ts";
-import { ConfigFileSchema, loadConfig, mergeConfigFile } from "../lib/state.ts";
-import { writeFileAtomic } from "../lib/atomic.ts";
+import { paths } from "../lib/paths.ts";
+import { loadConfig } from "../lib/state.ts";
+import type { Config } from "../lib/types.ts";
 import { c, emitError, emitJson } from "./render.ts";
 
-export const KNOWN_KEYS = [
-  "thresholds.session",
-  "thresholds.weekly",
-  "claudeBin",
-  "codexBin",
-  "policy.projectionMargin",
-  "policy.switchModels",
-  "policy.usagePollTtlMs",
-  "policy.maxWaitMs",
-  "policy.checkIntervalMs",
-] as const;
-
-const TIMER_REWRITE_NOTE = "note: run `tokenmaxxing init` to rewrite the periodic timer at the new tick";
-
-const RawFileSchema = z.record(z.string(), z.unknown());
-
-function readRawFile(): Record<string, unknown> {
-  if (!existsSync(paths.configJson)) return {};
-  return RawFileSchema.parse(JSON.parse(readFileSync(paths.configJson, "utf8")));
-}
-
-function writeRawFile(input: { raw: Record<string, unknown> }): void {
-  writeFileAtomic(paths.configJson, JSON.stringify(input.raw, null, 2) + "\n");
-}
-
-function dottedKeys(obj: Record<string, unknown>): string[] {
-  const keys: string[] = [];
-  for (const [key, value] of Object.entries(obj)) {
-    if (isPlainObject(value)) {
-      for (const nested of Object.keys(value)) keys.push(`${key}.${nested}`);
-      continue;
-    }
-    keys.push(key);
-  }
-  return keys;
-}
-
-function unknownFileKeys(raw: Record<string, unknown>): string[] {
-  const known = new Set<string>(KNOWN_KEYS);
-  return dottedKeys(raw).filter((key) => !known.has(key));
-}
-
-function isKnownKey(key: string): boolean {
-  return KNOWN_KEYS.some((known) => known === key);
-}
-
-function envSourceFor(key: string): string | null {
-  if (key === "claudeBin" && realClaudeBinFromEnv()) return "TOKENMAXXING_CLAUDE_BIN";
-  if (key === "codexBin" && realCodexBinFromEnv()) return "TOKENMAXXING_CODEX_BIN";
-  return null;
-}
-
-function sourceOf(input: { key: string; raw: Record<string, unknown> }): { source: "env" | "file" | "default"; env: string | null } {
-  const env = envSourceFor(input.key);
-  if (env) return { source: "env", env };
-  return { source: get(input.raw, input.key) !== undefined ? "file" : "default", env: null };
-}
-
-function unknownKey(input: { key: string; json: boolean }): number {
-  emitError({
-    json: input.json,
-    message: `unknown config key: ${input.key}`,
-    notes: [`known keys: ${KNOWN_KEYS.join(", ")}`],
-    extra: { knownKeys: KNOWN_KEYS },
-  });
-  return 1;
-}
-
-function printEffective(json: boolean): number {
-  const effective = loadConfig();
-  const raw = readRawFile();
-  const unknown = unknownFileKeys(raw);
-  if (json) {
-    const sources: Record<string, string> = {};
-    const envOverrides: Record<string, string> = {};
-    for (const key of KNOWN_KEYS) {
-      const { source, env } = sourceOf({ key, raw });
-      sources[key] = source;
-      if (env) envOverrides[key] = env;
-    }
-    emitJson({ ok: true, path: paths.configJson, config: effective, sources, envOverrides, unknownKeys: unknown });
-    return 0;
-  }
-  console.log(c.dim(`config.json: ${paths.configJson}`));
-  for (const key of KNOWN_KEYS) {
-    const { source, env } = sourceOf({ key, raw });
-    const painted = source === "env" ? c.yellow(`env ${env}`) : source === "file" ? c.green("file") : c.dim("default");
-    console.log(`  ${key.padEnd(28)} ${JSON.stringify(get(effective, key))}  ${painted}`);
-  }
-  if (unknown.length > 0) {
-    console.log();
-    console.log(c.yellow(`unknown keys in the file (ignored by the loader): ${unknown.join(", ")}`));
-    console.log(c.dim("run `tokenmaxxing config tidy` to drop them"));
-  }
-  return 0;
-}
-
-function cmdGet(key: string, json: boolean): number {
-  if (!isKnownKey(key)) return unknownKey({ key, json });
-  const value = get(loadConfig(), key);
-  if (json) {
-    emitJson({ ok: true, key, value, source: sourceOf({ key, raw: readRawFile() }).source });
-    return 0;
+export function cmdConfig(args: string[], json = false): number {
+  if (args.length > 0) {
+    emitError({ json, message: `unknown config option: ${args[0]} (config takes no options; edit ${paths.configJson} in an editor)` });
+    return 2;
   }
-  console.log(JSON.stringify(value));
-  return 0;
-}
-
-function parseValue(text: string): unknown {
+  let effective: Config;
   try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-
-function cmdSet(key: string, valueText: string, json: boolean): number {
-  if (!isKnownKey(key)) return unknownKey({ key, json });
-  const raw = readRawFile();
-  const next = structuredClone(raw);
-  set(next, key, parseValue(valueText));
-  const validated = ConfigFileSchema.safeParse(next);
-  if (!validated.success) {
-    emitError({ json, message: `rejected: ${validated.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}` });
-    return 1;
-  }
-  const mergedCheck = mergeConfigFile(validated.data);
-  if (!mergedCheck.ok) {
-    emitError({ json, message: `rejected: ${mergedCheck.detail}` });
-    return 1;
-  }
-  writeRawFile({ raw: next });
-  const beforeFile = get(raw, key);
-  const env = envSourceFor(key);
-  if (json) {
-    emitJson({ ok: true, key, before: beforeFile === undefined ? null : beforeFile, after: get(next, key), envOverride: env });
-    return 0;
-  }
-  console.log(
-    `${key}: ${beforeFile === undefined ? "(default)" : JSON.stringify(beforeFile)} -> ${JSON.stringify(get(next, key))}`,
-  );
-  if (env) console.log(c.yellow(`note: ${env} is set and overrides the file value in this environment`));
-  if (key === "policy.checkIntervalMs") console.log(c.yellow(TIMER_REWRITE_NOTE));
-  return 0;
-}
-
-function pruneEmptyParents(raw: Record<string, unknown>): void {
-  for (const [topKey, value] of Object.entries(raw)) {
-    if (isPlainObject(value) && Object.keys(value).length === 0) {
-      delete raw[topKey];
-    }
-  }
-}
-
-function cmdUnset(key: string, json: boolean): number {
-  if (!isKnownKey(key)) return unknownKey({ key, json });
-  const raw = readRawFile();
-  if (get(raw, key) === undefined) {
-    if (json) emitJson({ ok: true, key, unset: false, value: get(loadConfig(), key) });
-    else console.log(c.dim(`${key} has no file override (default already applies)`));
-    return 0;
-  }
-  const next = structuredClone(raw);
-  unset(next, key);
-  pruneEmptyParents(next);
-  const validated = ConfigFileSchema.safeParse(next);
-  if (!validated.success) {
-    emitError({ json, message: `rejected: ${validated.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}` });
-    return 1;
-  }
-  const mergedCheck = mergeConfigFile(validated.data);
-  if (!mergedCheck.ok) {
-    emitError({ json, message: `rejected: ${mergedCheck.detail} (adjust the conflicting override before unsetting ${key})` });
+    effective = loadConfig();
+  } catch (e) {
+    emitError({ json, message: e instanceof Error ? e.message : String(e), extra: { path: paths.configJson } });
     return 1;
   }
-  writeRawFile({ raw: next });
-  const value = get(loadConfig(), key);
   if (json) {
-    emitJson({ ok: true, key, unset: true, value });
-    return 0;
-  }
-  console.log(`${key} unset -> ${JSON.stringify(value)} (default)`);
-  if (key === "policy.checkIntervalMs") console.log(c.yellow(TIMER_REWRITE_NOTE));
-  return 0;
-}
-
-function cmdTidy(json: boolean): number {
-  const raw = readRawFile();
-  const dropped = unknownFileKeys(raw);
-  const parsed = ConfigFileSchema.parse(raw);
-  const next = RawFileSchema.parse(JSON.parse(JSON.stringify(parsed)));
-  const models = get(next, "policy.switchModels");
-  const normalized = Array.isArray(models) ? models.map((model) => String(model).toLowerCase()) : null;
-  const casingChanged = normalized != null && JSON.stringify(normalized) !== JSON.stringify(models);
-  if (normalized != null) set(next, "policy.switchModels", normalized);
-  pruneEmptyParents(next);
-
-  const changed = JSON.stringify(next) !== JSON.stringify(raw);
-  if (changed) writeRawFile({ raw: next });
-  if (json) {
-    emitJson({ ok: true, changed, droppedKeys: dropped, casingNormalized: casingChanged });
-    return 0;
-  }
-  if (!changed) {
-    console.log(c.dim("nothing to tidy"));
+    emitJson({ ok: true, path: paths.configJson, effective });
     return 0;
   }
-  if (dropped.length > 0) console.log(`dropped unknown keys: ${dropped.join(", ")}`);
-  if (casingChanged) console.log("normalized switchModels casing");
-  if (dropped.length === 0 && !casingChanged) console.log("canonicalized file layout (pruned empty sections / key order)");
+  console.log(c.dim(`config.json: ${paths.configJson}`));
+  console.log(JSON.stringify(effective, null, 2));
   return 0;
 }
-
-export function cmdConfig(args: string[], json = false): number {
-  const [sub, key, value] = args;
-  try {
-    if (sub === undefined) return printEffective(json);
-    if (sub === "get" && key !== undefined) return cmdGet(key, json);
-    if (sub === "set" && key !== undefined && value !== undefined) return cmdSet(key, value, json);
-    if (sub === "unset" && key !== undefined) return cmdUnset(key, json);
-    if (sub === "tidy") return cmdTidy(json);
-  } catch (e) {
-    emitError({
-      json,
-      message: `config.json is unreadable: ${e instanceof Error ? e.message : String(e)}`,
-      notes: [`fix or delete ${paths.configJson} (defaults apply when it is absent), then re-run`],
-      extra: { path: paths.configJson },
-    });
-    return 1;
-  }
-  emitError({ json, message: "usage: tokenmaxxing config [get <key> | set <key> <value> | unset <key> | tidy]" });
-  return 2;
-}

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";
@@ -99,7 +99,7 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
     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 +125,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 +134,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/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, loadUsage, 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 { familyTokens, gatedFamilies, keepRows, probeUsage, type EnforcedClass } 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,26 @@ 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 (!u || !account || 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 +58,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>;
@@ -78,10 +79,11 @@ async function loadFreshSnapshots(cfg: Config, account: string | null, now: numb
   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;
+  if (account && stored && !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,24 +93,30 @@ 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> {
@@ -123,11 +131,11 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
   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);
+  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 (!enforced0 && !isOver(usage, stored, bars, cfg, now)) {
     const measured = usage != null && activeAccount != null && usage.account === activeAccount;
     if (!measured) {
       const replay = depletedReplay(now);
@@ -143,31 +151,21 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
     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;
 
     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;
 
-    if (!enforced2 && !isOver(u2, mu2, account2, bars, cfg, now)) {
+    if (!enforced2 && !isOver(u2, active, bars, cfg, now)) {
       return depletedReplay(now) ?? { swapped: false, account: null, reason: "raced-already-swapped" };
     }
 
@@ -269,27 +267,26 @@ export async function recordEnforcedLimit(input: { limit: EnforcedClass; account
     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 rows = account?.lastUsage?.perModel ?? {};
+      const knownReset = Object.entries(rows).filter(([k]) => familyTokens(k).includes(limit.family)).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,
-      });
+      if (!account) return { outcome: "no-carrier", resetsAt };
+      if (account.lastUsage) {
+        const others = Object.fromEntries(Object.entries(rows).filter(([k]) => !familyTokens(k).includes(limit.family)));
+        account.lastUsage = { ...account.lastUsage, perModel: { ...others, [limit.family]: { usedPercentage: 100, resetsAt } }, ...(resetsAt == null ? { rowsAt: now } : {}) };
+      } else {
+        account.enforcedUntil = resetsAt ?? now + WEEK_MS;
+      }
+      account.lastProbeAt = now;
+      saveAccounts(idx);
       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;
+    if (account) {
+      account.lastProbeAt = now;
+      if (limit.resetsAt != null) account.enforcedUntil = limit.resetsAt;
       saveAccounts(idx);
     }
     const carrier = priorSame ?? (account?.lastUsage ? { ...account.lastUsage, model: null } : null);

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,99 +7,32 @@ import {
   AccountsIndexSchema,
   ConfigSchema,
   LastSwapSchema,
-  ModelUsageStateSchema,
   UsageStateSchema,
   type AccountsIndex,
   type Config,
-  type ModelUsageState,
   type UsageState,
 } from "./types.ts";
 
-const DEFAULT_CONFIG: Config = {
-  thresholds: { session: 90, weekly: 98 },
-  claudeBin: "",
-  codexBin: "",
-  policy: {
-    projectionMargin: 0,
-    switchModels: ["fable"],
-    usagePollTtlMs: 90_000,
-    maxWaitMs: 3_600_000,
-    checkIntervalMs: 60_000,
-  },
-};
-
-const PercentSchema = z.number().min(0).max(100);
-
-export const ConfigFileSchema = z
-  .object({
-    thresholds: z.object({ session: PercentSchema, weekly: PercentSchema }).partial(),
-    claudeBin: z.string(),
-    codexBin: z.string(),
-    policy: z
-      .object({
-        projectionMargin: PercentSchema,
-        switchModels: z.array(z.string()),
-        usagePollTtlMs: z.number().int().positive(),
-        maxWaitMs: z.number().int().positive(),
-        checkIntervalMs: z.number().int().min(10_000),
-      })
-      .partial(),
-  })
-  .partial();
-
-const MergeOutcomeSchema = z.union([
-  z.object({ ok: z.literal(true), config: ConfigSchema }),
-  z.object({ ok: z.literal(false), detail: z.string() }),
-]);
-export type MergeOutcome = z.infer<typeof MergeOutcomeSchema>;
-
-export function mergeConfigFile(p: z.infer<typeof ConfigFileSchema>): MergeOutcome {
-  const cfg: Config = {
-    ...DEFAULT_CONFIG,
-    thresholds: { ...DEFAULT_CONFIG.thresholds },
-    policy: { ...DEFAULT_CONFIG.policy },
-  };
-  cfg.thresholds.session = p.thresholds?.session ?? cfg.thresholds.session;
-  cfg.thresholds.weekly = p.thresholds?.weekly ?? cfg.thresholds.weekly;
-  cfg.claudeBin = p.claudeBin ?? cfg.claudeBin;
-  cfg.codexBin = p.codexBin ?? cfg.codexBin;
-  cfg.policy.projectionMargin = p.policy?.projectionMargin ?? cfg.policy.projectionMargin;
-  cfg.policy.usagePollTtlMs = p.policy?.usagePollTtlMs ?? cfg.policy.usagePollTtlMs;
-  cfg.policy.maxWaitMs = p.policy?.maxWaitMs ?? cfg.policy.maxWaitMs;
-  cfg.policy.checkIntervalMs = p.policy?.checkIntervalMs ?? cfg.policy.checkIntervalMs;
-  if (p.policy?.switchModels) {
-    cfg.policy.switchModels = p.policy.switchModels.map((s) => s.toLowerCase());
-  }
-  const envBin = realClaudeBinFromEnv();
-  if (envBin) cfg.claudeBin = envBin;
-  const envCodexBin = realCodexBinFromEnv();
-  if (envCodexBin) cfg.codexBin = envCodexBin;
-  const merged = ConfigSchema.safeParse(cfg);
-  if (!merged.success) {
-    return { ok: false, detail: merged.error.issues.map((issue) => issue.message).join("; ") };
-  }
-  return { ok: true, config: merged.data };
-}
-
 export function loadConfig(): Config {
-  let fileData: z.infer<typeof ConfigFileSchema> = {};
+  let raw: unknown = {};
   if (existsSync(paths.configJson)) {
-    let raw: unknown;
     try {
       raw = JSON.parse(readFileSync(paths.configJson, "utf8"));
     } catch {
       throw new Error(`${paths.configJson} is corrupt (unparsable JSON) - fix or remove it`);
     }
-    const parsed = ConfigFileSchema.safeParse(raw);
-    if (!parsed.success) {
-      const fields = parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
-      throw new Error(`${paths.configJson} has wrong-typed values (${fields}) - fix or remove them`);
-    }
-    fileData = parsed.data;
   }
-  const outcome = mergeConfigFile(fileData);
-  if (!outcome.ok) throw new Error(`${paths.configJson} is invalid: ${outcome.detail} - fix or remove the offending values`);
-  return outcome.config;
+  const parsed = ConfigSchema.safeParse(raw);
+  if (!parsed.success) {
+    const fields = parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+    throw new Error(`${paths.configJson} is invalid (${fields}) - fix or remove the offending values`);
+  }
+  const cfg = parsed.data;
+  const envBin = realClaudeBinFromEnv();
+  if (envBin) cfg.claudeBin = envBin;
+  const envCodexBin = realCodexBinFromEnv();
+  if (envCodexBin) cfg.codexBin = envCodexBin;
+  return cfg;
 }
 
 export function pinBinOverride(input: { key: "claudeBin" | "codexBin"; bin: string }): void {
@@ -156,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 {
@@ -224,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(),
@@ -101,19 +96,30 @@ export type Thresholds = z.infer<typeof ThresholdsSchema>;
 
 export const ConfigSchema = z
   .object({
-    thresholds: ThresholdsSchema,
-    claudeBin: z.string(),
-    codexBin: z.string(),
-    policy: z.object({
-      projectionMargin: z.number().min(0).max(100),
-      switchModels: z.array(z.string()),
-      usagePollTtlMs: z.number().int().positive(),
-      maxWaitMs: z.number().int().positive(),
-      checkIntervalMs: z.number().int().min(10_000),
-    }),
+    thresholds: z
+      .object({
+        session: z.number().min(0).max(100).default(90),
+        weekly: z.number().min(0).max(100).default(98),
+      })
+      .prefault({}),
+    claudeBin: z.string().default(""),
+    codexBin: z.string().default(""),
+    policy: z
+      .object({
+        projectionMargin: z.number().min(0).max(100).default(0),
+        switchModels: z
+          .array(z.string())
+          .default(["fable"])
+          .transform((models) => models.map((model) => model.toLowerCase())),
+        usagePollTtlMs: z.number().int().positive().default(90_000),
+        maxWaitMs: z.number().int().positive().default(3_600_000),
+        checkIntervalMs: z.number().int().min(10_000).default(60_000),
+      })
+      .prefault({}),
   })
   .refine((cfg) => cfg.policy.projectionMargin < Math.min(cfg.thresholds.session, cfg.thresholds.weekly), {
-    message: "policy.projectionMargin must be strictly below both thresholds (the bars would hit zero and every account would read as exhausted)",
+    path: ["policy", "projectionMargin"],
+    message: "must be strictly below both thresholds (the bars would hit zero and every account would read as exhausted)",
   });
 export type Config = z.infer<typeof ConfigSchema>;
 

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,
 };
@@ -237,26 +230,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 +290,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 +310,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 +336,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++) {

package/src/main.ts

@@ -46,7 +46,7 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing auth")} [sel | --all]  reauthenticate a pooled account in place (bare = pick from a list; --all = every needs-reauth account, one by one)
   ${c.cyan("tokenmaxxing switch --codex")} [sel]  switch the codex pool (takes effect on next codex start)
   ${c.cyan("tokenmaxxing status")} [--cached]  accounts with 5h / weekly / per-model usage bars (--cached: the stored figures, no sampling)
-  ${c.cyan("tokenmaxxing config")} [get|set|unset|tidy]  inspect and edit config.json (bare = effective config with sources)
+  ${c.cyan("tokenmaxxing config")}     print the config path and the effective values (edit the file in an editor)
   ${c.cyan("tokenmaxxing doctor")}     verify the install is intact
   ${c.cyan("tokenmaxxing rename")} [--codex] <sel> <label>
   ${c.cyan("tokenmaxxing rm")} [--codex] <sel>