tokenmaxxing 1.10.0 → 1.11.0

package/src/cli/rename.ts

@@ -2,7 +2,7 @@ import { withLock } from "../lib/lock.ts";
 import { codexPaths, paths } from "../lib/paths.ts";
 import { loadAccounts, saveAccounts } from "../lib/state.ts";
 import { loadCodexAccounts, saveCodexAccounts } from "../lib/codexstate.ts";
-import { c } from "./render.ts";
+import { c, emitError, emitJson, plain } from "./render.ts";
 import type { Account, CodexAccount } from "../lib/types.ts";
 
 export function findAccount(accounts: Account[], selector: string): Account | undefined {
@@ -23,51 +23,54 @@ export function findCodexAccount(accounts: CodexAccount[], selector: string): Co
   );
 }
 
-async function renameCodexAccount(input: { selector: string; newLabel: string }): Promise<number> {
+async function renameCodexAccount(input: { selector: string; newLabel: string; json: boolean }): Promise<number> {
+  const { selector, newLabel, json } = input;
   return withLock(codexPaths.lockFile, async () => {
     const index = loadCodexAccounts();
-    const account = findCodexAccount(index.accounts, input.selector);
+    const account = findCodexAccount(index.accounts, selector);
     if (!account) {
-      console.error(c.red(`no codex account matches "${input.selector}"`));
+      emitError({ json, message: `no codex account matches "${selector}"` });
       return 1;
     }
-    const taken = index.accounts.find((x) => x.accountId !== account.accountId && x.label.toLowerCase() === input.newLabel.toLowerCase());
+    const taken = index.accounts.find((x) => x.accountId !== account.accountId && x.label.toLowerCase() === newLabel.toLowerCase());
     if (taken) {
-      console.error(c.red(`label "${input.newLabel}" is already used by ${taken.accountId.slice(0, 8)} - labels must be unique within the pool`));
+      emitError({ json, message: `label "${newLabel}" is already used by ${taken.accountId.slice(0, 8)} - labels must be unique within the pool` });
       return 1;
     }
     const old = account.label;
-    account.label = input.newLabel;
+    account.label = newLabel;
     saveCodexAccounts({ index });
-    console.log(`renamed codex account ${c.dim(old)} → ${c.bold(input.newLabel)}`);
+    if (json) emitJson({ ok: true, pool: "codex", from: old, to: newLabel });
+    else console.log(`renamed codex account ${c.dim(old)} → ${c.bold(newLabel)}`);
     return 0;
   });
 }
 
-export async function cmdRename(argv: string[]): Promise<number> {
+export async function cmdRename(argv: string[], json = false): Promise<number> {
   const codex = argv.includes("--codex");
   const [selector, newLabel] = argv.filter((a) => a !== "--codex");
   if (!selector || !newLabel) {
-    console.error("usage: tokenmaxxing rename [--codex] <email|label|id> <new-label>");
+    emitError({ json, message: "usage: tokenmaxxing rename [--codex] <email|label|id> <new-label>", paint: plain });
     return 2;
   }
-  if (codex) return renameCodexAccount({ selector, newLabel });
+  if (codex) return renameCodexAccount({ selector, newLabel, json });
   return withLock(paths.lockFile, async () => {
     const idx = loadAccounts();
     const a = findAccount(idx.accounts, selector);
     if (!a) {
-      console.error(c.red(`no claude account matches "${selector}" (codex accounts rename via --codex)`));
+      emitError({ json, message: `no claude account matches "${selector}" (codex accounts rename via --codex)` });
       return 1;
     }
     const taken = idx.accounts.find((x) => x.accountUuid !== a.accountUuid && x.label.toLowerCase() === newLabel.toLowerCase());
     if (taken) {
-      console.error(c.red(`label "${newLabel}" is already used by ${taken.email} - labels must be unique within the pool`));
+      emitError({ json, message: `label "${newLabel}" is already used by ${taken.email} - labels must be unique within the pool` });
       return 1;
     }
     const old = a.label;
     a.label = newLabel;
     saveAccounts(idx);
-    console.log(`renamed ${c.dim(old)} → ${c.bold(newLabel)}`);
+    if (json) emitJson({ ok: true, pool: "claude", from: old, to: newLabel });
+    else console.log(`renamed ${c.dim(old)} → ${c.bold(newLabel)}`);
     return 0;
   });
 }

package/src/cli/render.ts

@@ -75,3 +75,23 @@ export function fmtAgo(epochMs: number, now = Date.now()): string {
   return `${m}m ago`;
 }
 
+export const plain = (s: string): string => s;
+
+export function emitJson(value: unknown): void {
+  console.log(JSON.stringify(value, null, 2));
+}
+
+export function emitError(input: {
+  json: boolean;
+  message: string;
+  notes?: string[];
+  extra?: Record<string, unknown>;
+  paint?: (s: string) => string;
+}): void {
+  if (input.json) {
+    emitJson({ ok: false, error: input.message, ...input.extra });
+    return;
+  }
+  console.error((input.paint ?? c.red)(input.message));
+  for (const note of input.notes ?? []) console.error(c.dim(note));
+}

package/src/cli/rm.ts

@@ -7,22 +7,22 @@ import { credItemFor, paths } from "../lib/paths.ts";
 import { loadAccounts, saveAccounts } from "../lib/state.ts";
 import { CredentialBlobSchema } from "../lib/types.ts";
 import { findAccount } from "./rename.ts";
-import { c } from "./render.ts";
+import { c, emitError, emitJson, plain } from "./render.ts";
 
-export async function cmdRm(selector?: string): Promise<number> {
+export async function cmdRm(selector?: string, json = false): Promise<number> {
   if (!selector) {
-    console.error("usage: tokenmaxxing rm <email|label|uuid>");
+    emitError({ json, message: "usage: tokenmaxxing rm <email|label|uuid>", paint: plain });
     return 2;
   }
   return withLock(paths.lockFile, async () => {
     const idx = loadAccounts();
     const a = findAccount(idx.accounts, selector);
     if (!a) {
-      console.error(c.red(`no account matches "${selector}"`));
+      emitError({ json, message: `no account matches "${selector}"` });
       return 1;
     }
     if (a.accountUuid === idx.activeAccountUuid) {
-      console.error(c.red(`${a.email} is the ACTIVE account - switch away before removing it.`));
+      emitError({ json, message: `${a.email} is the ACTIVE account - switch away before removing it.` });
       return 1;
     }
     const live = await readItem(liveTarget());
@@ -32,11 +32,14 @@ export async function cmdRm(selector?: string): Promise<number> {
         const liveCreds = CredentialBlobSchema.parse(JSON.parse(live)).claudeAiOauth;
         liveOrg = (await fetchTokenOrg(liveCreds.accessToken)).organization_uuid;
       } catch (e) {
-        console.error(c.red(`cannot verify which account the LIVE credential belongs to (${e instanceof Error ? e.message : String(e)}) - refusing to remove while the live owner is unknown; repair the live credential or retry once the roles endpoint is reachable.`));
+        emitError({
+          json,
+          message: `cannot verify which account the LIVE credential belongs to (${e instanceof Error ? e.message : String(e)}) - refusing to remove while the live owner is unknown; repair the live credential or retry once the roles endpoint is reachable.`,
+        });
         return 1;
       }
       if (liveOrg === a.organizationUuid) {
-        console.error(c.red(`${a.email}'s credential is currently LIVE (the active label is stale - a manual /login drifted it); run \`tokenmaxxing switch\` to move off it first.`));
+        emitError({ json, message: `${a.email}'s credential is currently LIVE (the active label is stale - a manual /login drifted it); run \`tokenmaxxing switch\` to move off it first.` });
         return 1;
       }
     }
@@ -46,7 +49,8 @@ export async function cmdRm(selector?: string): Promise<number> {
     rmSync(sampleDir, { recursive: true, force: true });
     idx.accounts = idx.accounts.filter((x) => x.accountUuid !== a.accountUuid);
     saveAccounts(idx);
-    console.log(`removed ${c.bold(a.label)} from the pool (${idx.accounts.length} left)`);
+    if (json) emitJson({ ok: true, pool: "claude", removed: a.label, remaining: idx.accounts.length });
+    else console.log(`removed ${c.bold(a.label)} from the pool (${idx.accounts.length} left)`);
     return 0;
   });
 }

package/src/cli/status.ts

@@ -1,4 +1,5 @@
 import { sortBy } from "es-toolkit";
+import { z } from "zod";
 import { loadAccounts, loadConfig, loadUsage, loadModelUsage, saveAccounts } from "../lib/state.ts";
 import { readOAuthAccount } from "../lib/claudejson.ts";
 import { ensureLiveTokenFresh, probeActiveUsage, probeParkedUsage, type SampleOutcome } from "../lib/sample.ts";
@@ -9,42 +10,94 @@ import { loadCodexAccounts, saveCodexAccounts } from "../lib/codexstate.ts";
 import { liveCodexAccountId, sampleCodexAccount, type CodexSampleOutcome } from "../lib/codexsample.ts";
 import { isCodexExhausted } from "../lib/codexpick.ts";
 import { codexLimitLabel, isSessionWindow } from "../lib/codexusage.ts";
-import { bar, c, claudeTierLabel, count, fmtAgo, fmtReset } from "./render.ts";
+import { bar, c, claudeTierLabel, count, emitJson, fmtAgo, fmtReset } from "./render.ts";
 import { gatedFamilies, type FullUsage } from "../lib/usage.ts";
-import type { Account, Config, CodexWindow, UsageWindow } from "../lib/types.ts";
+import { ThresholdsSchema, UsageWindowSchema, type Account, type CodexWindow, type Config, type UsageWindow } from "../lib/types.ts";
 
-export async function cmdStatus(force = false, preRender?: () => void): Promise<number> {
-  let idx = loadAccounts();
-  const cfg = loadConfig();
-  const now = Date.now();
+const SampleReportSchema = z.discriminatedUnion("ok", [
+  z.object({ ok: z.literal(true), source: z.enum(["statusline", "probe"]) }),
+  z.object({ ok: z.literal(false), reason: z.string() }),
+]);
+
+const ClaudeStatusAccountSchema = z.object({
+  label: z.string(),
+  email: z.string(),
+  accountUuid: z.string(),
+  organizationUuid: z.string(),
+  tier: z.string().nullable(),
+  active: z.boolean(),
+  needsReauth: z.boolean(),
+  exhausted: z.boolean(),
+  usage: z.object({ fiveHour: UsageWindowSchema, week: UsageWindowSchema }).nullable(),
+  perModel: z.record(z.string(), UsageWindowSchema),
+  usageAt: z.number().nullable(),
+  sample: SampleReportSchema,
+  pingError: z.string().nullable(),
+  pinged: z.boolean(),
+});
+type ClaudeStatusAccount = z.infer<typeof ClaudeStatusAccountSchema>;
+
+const CodexWindowReportSchema = UsageWindowSchema.extend({ windowSeconds: z.number().nullable() });
 
-  const row = (name: string, w: UsageWindow, weekly: boolean) => {
-    const passed = w.resetsAt != null && w.resetsAt <= now;
-    const pct = passed ? 0 : w.usedPercentage;
-    const resetsAt = weekly ? nextWeeklyReset(w.resetsAt, now) : passed ? null : w.resetsAt;
-    console.log(`    ${name.padEnd(5)} ${bar(pct)}  ${c.dim(fmtReset(resetsAt, now))}`);
+const CodexStatusAccountSchema = z.object({
+  label: z.string(),
+  email: z.string().nullable(),
+  accountId: z.string(),
+  planType: z.string().nullable(),
+  active: z.boolean(),
+  needsReauth: z.boolean(),
+  exhausted: z.boolean(),
+  usage: z
+    .object({
+      aggregate: z.array(CodexWindowReportSchema),
+      perLimit: z.record(z.string(), z.array(CodexWindowReportSchema)),
+    })
+    .nullable(),
+  usageAt: z.number().nullable(),
+  sample: SampleReportSchema,
+});
+type CodexStatusAccount = z.infer<typeof CodexStatusAccountSchema>;
+
+const StatusReportSchema = z.object({
+  now: z.number(),
+  claude: z.object({
+    thresholds: z.object({ session: z.array(z.number()), weekly: z.number() }),
+    bars: ThresholdsSchema,
+    projectionMargin: z.number(),
+    accounts: z.array(ClaudeStatusAccountSchema),
+  }),
+  codex: z.object({
+    bars: ThresholdsSchema,
+    accounts: z.array(CodexStatusAccountSchema),
+  }),
+});
+export type StatusReport = z.infer<typeof StatusReportSchema>;
+
+function currentWindow(w: UsageWindow, weekly: boolean, now: number): UsageWindow {
+  const passed = w.resetsAt != null && w.resetsAt <= now;
+  return {
+    usedPercentage: passed ? 0 : w.usedPercentage,
+    resetsAt: weekly ? nextWeeklyReset(w.resetsAt, now) : passed ? null : w.resetsAt,
   };
+}
 
-  if (idx.accounts.length === 0) {
-    if (loadCodexAccounts().accounts.length > 0) {
-      console.log(c.dim("no claude accounts (run `tokenmaxxing init` to pool claude too)"));
-      console.log();
-      await renderCodexSection({ cfg, now, row });
-      return 0;
-    }
-    console.log(c.dim("no accounts yet, run `tokenmaxxing init` (or `tokenmaxxing init --codex`)"));
-    return 0;
-  }
+function currentCodexWindow(w: CodexWindow, now: number): CodexWindow {
+  return { ...currentWindow(w, !isSessionWindow({ window: w }), now), windowSeconds: w.windowSeconds };
+}
 
-  console.error(c.dim(force ? "pinging every account (starts each 5h session timer) + sampling live usage..." : "sampling live usage..."));
-  const outcomes = new Map<string, SampleOutcome>();
-  await withLock(paths.lockFile, async () => {
-    idx = loadAccounts();
-    const live = loadUsage();
-    const modelUsage = loadModelUsage();
-    const liveOAuth = readOAuthAccount();
-    const activeOrg = liveOAuth?.organizationUuid ?? null;
-    const probeOne = async (a: Account) => {
+async function collectClaude(input: { cfg: Config; force: boolean; now: number }): Promise<StatusReport["claude"]> {
+  const { cfg, force, now } = input;
+  let idx = loadAccounts();
+  const samples = new Map<string, { outcome: SampleOutcome; viaTee: boolean }>();
+  if (idx.accounts.length > 0) {
+    console.error(c.dim(force ? "pinging every account (starts each 5h session timer) + sampling live usage..." : "sampling live usage..."));
+    await withLock(paths.lockFile, async () => {
+      idx = loadAccounts();
+      const live = loadUsage();
+      const modelUsage = loadModelUsage();
+      const liveOAuth = readOAuthAccount();
+      const activeOrg = liveOAuth?.organizationUuid ?? null;
+      const probeOne = async (a: Account) => {
         const isActive = activeOrg != null && activeOrg === a.organizationUuid;
         if (isActive && liveOAuth?.organizationRateLimitTier != null) a.rateLimitTier = liveOAuth.organizationRateLimitTier;
         const fromStatusLine: FullUsage | null =
@@ -73,7 +126,7 @@ export async function cmdStatus(force = false, preRender?: () => void): Promise<
               ? await probeActiveUsage(a)
               : await probeParkedUsage(a);
         }
-        outcomes.set(a.accountUuid, outcome);
+        samples.set(a.accountUuid, { outcome, viaTee });
         if (!outcome.ok) return;
         a.lastUsage = { fiveHour: outcome.usage.session, sevenDay: outcome.usage.weekAll };
         a.lastUsageAt = viaTee && live ? live.ts : Date.now();
@@ -81,72 +134,57 @@ export async function cmdStatus(force = false, preRender?: () => void): Promise<
           a.lastPerModel = outcome.usage.perModel;
           a.lastPerModelAt = viaTee && modelUsage ? (modelUsage.sampledAt ?? modelUsage.ts) : a.lastUsageAt;
         }
-    };
-    const activeAccount = idx.accounts.find((a) => activeOrg != null && activeOrg === a.organizationUuid) ?? null;
-    if (activeAccount) await probeOne(activeAccount);
-    try {
-      await ensureLiveTokenFresh();
-    } catch {
-    }
-    await Promise.all(idx.accounts.filter((a) => a !== activeAccount).map(probeOne));
-    saveAccounts(idx);
-  });
+      };
+      const activeAccount = idx.accounts.find((a) => activeOrg != null && activeOrg === a.organizationUuid) ?? null;
+      if (activeAccount) await probeOne(activeAccount);
+      try {
+        await ensureLiveTokenFresh();
+      } catch {
+      }
+      await Promise.all(idx.accounts.filter((a) => a !== activeAccount).map(probeOne));
+      saveAccounts(idx);
+    });
+  }
 
-  preRender?.();
   const families = gatedFamilies(loadUsage()?.model ?? null, cfg.policy.switchModels);
   const bars = effectiveBars(cfg, { accounts: idx.accounts, now, switchFamilies: families });
-  console.log(c.dim(`thresholds 5h ${cfg.thresholds.session.join("/")}% (at ${bars.session + cfg.policy.projectionMargin}%) weekly ${cfg.thresholds.weekly}%  (${count({ n: idx.accounts.length, noun: "claude account" })})`));
-  console.log();
-
-  const displayAccounts = sortBy(idx.accounts, [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, now)]);
-  const displayActiveOrg = readOAuthAccount()?.organizationUuid ?? null;
-  for (const a of displayAccounts) {
-    const active = displayActiveOrg != null && a.organizationUuid === displayActiveOrg;
-    const outcome = outcomes.get(a.accountUuid);
-    const failed = outcome ? !outcome.ok : false;
-    const usage = outcome?.ok ? outcome.usage : undefined;
+  const activeOrg = readOAuthAccount()?.organizationUuid ?? null;
+  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) ?? { outcome: { ok: false, reason: "not sampled" }, viaTee: false };
+    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 marker = active ? c.green("●") : c.dim("○");
-    const badges: string[] = [];
-    if (active) badges.push(c.green("active"));
-    if (a.needsReauth) badges.push(c.red("needs-reauth"));
-    if (isExhausted(a, { now, thresholds: bars, currentAccountUuid: idx.activeAccountUuid, switchFamilies: families }))
-      badges.push(c.yellow("exhausted"));
-
-    const tier = claudeTierLabel(a);
-    console.log(`${marker} ${c.bold(a.label || a.email)}${tier ? ` ${c.dim(tier)}` : ""}${badges.length ? ` ${badges.join(" ")}` : ""}`);
-    if (aggregate) {
-      row("5h", aggregate.fiveHour, false);
-      row("week", aggregate.sevenDay, true);
-    }
-    if (perModel) for (const [name, w] of Object.entries(perModel)) row(name.toLowerCase(), w, true);
-    if (failed && outcome && !outcome.ok) {
-      const cached = aggregate || perModel ? `cached${a.lastUsageAt != null ? ` ${fmtAgo(a.lastUsageAt, now)}` : ""}, ` : "";
-      console.log(`    ${c.yellow(`${cached}live sample failed`)}: ${c.dim(outcome.reason)}`);
-    }
-    if (outcome?.pingError != null) {
-      console.log(`    ${c.yellow("ping failed (5h timer may not have started)")}: ${c.dim(outcome.pingError)}`);
-    }
-    if (force && outcome?.ok && outcome.pingError == null && aggregate && aggregate.fiveHour.resetsAt == null) {
-      console.log(`    ${c.dim("pinged - 5h timer started this run; the usage feed lags, re-run status shortly for the fresh window")}`);
-    }
-    console.log();
-  }
-
-  await renderCodexSection({ cfg, now, row });
-  return 0;
+    const perModel = usage ? usage.perModel : (a.lastPerModel ?? {});
+    return {
+      label: a.label,
+      email: a.email,
+      accountUuid: a.accountUuid,
+      organizationUuid: a.organizationUuid,
+      tier: claudeTierLabel(a),
+      active: activeOrg != null && a.organizationUuid === activeOrg,
+      needsReauth: a.needsReauth === true,
+      exhausted: isExhausted(a, { now, thresholds: bars, currentAccountUuid: idx.activeAccountUuid, switchFamilies: families }),
+      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,
+      sample: sampled.outcome.ok ? { ok: true, source: sampled.viaTee ? "statusline" : "probe" } : { ok: false, reason: sampled.outcome.reason },
+      pingError: sampled.outcome.pingError ?? null,
+      pinged: force && sampled.outcome.ok && sampled.outcome.pingError == null && aggregate != null && aggregate.fiveHour.resetsAt == null,
+    };
+  });
+  return {
+    thresholds: { session: cfg.thresholds.session, weekly: cfg.thresholds.weekly },
+    bars,
+    projectionMargin: cfg.policy.projectionMargin,
+    accounts,
+  };
 }
 
-async function renderCodexSection(input: {
-  cfg: Config;
-  now: number;
-  row: (name: string, w: UsageWindow, weekly: boolean) => void;
-}): Promise<void> {
-  const { cfg, now, row } = input;
+async function collectCodex(input: { cfg: Config; now: number }): Promise<StatusReport["codex"]> {
+  const { cfg, now } = input;
+  const bars = terminalBars(cfg);
   let index = loadCodexAccounts();
-  if (index.accounts.length === 0) return;
+  if (index.accounts.length === 0) return { bars, accounts: [] };
 
   console.error(c.dim("sampling codex usage..."));
   const outcomes = new Map<string, CodexSampleOutcome>();
@@ -171,11 +209,7 @@ async function renderCodexSection(input: {
     saveCodexAccounts({ index });
   });
 
-  console.log(c.dim(`codex  (${count({ n: index.accounts.length, noun: "account" })})`));
-  console.log();
-  const windowLabel = (window: CodexWindow) =>
-    isSessionWindow({ window }) ? `${Math.round((window.windowSeconds ?? 0) / 3600)}h` : "week";
-  const displayAccounts = sortBy(index.accounts, [
+  const ordered = sortBy(index.accounts, [
     (a) => (a.needsReauth ? 1 : 0),
     (a) => {
       const windows = [...(a.lastUsage?.aggregate ?? []), ...Object.values(a.lastUsage?.perLimit ?? {}).flat()];
@@ -183,27 +217,122 @@ async function renderCodexSection(input: {
       return resets.length > 0 ? Math.min(...resets) : Number.POSITIVE_INFINITY;
     },
   ]);
-  for (const account of displayAccounts) {
-    const active = account.accountId === liveId;
-    const marker = active ? c.green("●") : c.dim("○");
+  const accounts = ordered.map((account): CodexStatusAccount => {
+    const outcome = outcomes.get(account.accountId) ?? { ok: false, reason: "not sampled", deadGrant: false };
+    const usage = account.lastUsage;
+    return {
+      label: account.label,
+      email: account.email,
+      accountId: account.accountId,
+      planType: account.planType,
+      active: account.accountId === liveId,
+      needsReauth: account.needsReauth === true,
+      exhausted: isCodexExhausted({ account, thresholds: bars, now }),
+      usage: usage
+        ? {
+            aggregate: usage.aggregate.map((w) => currentCodexWindow(w, now)),
+            perLimit: Object.fromEntries(
+              Object.entries(usage.perLimit).map(([name, windows]) => [name, windows.map((w) => currentCodexWindow(w, now))]),
+            ),
+          }
+        : null,
+      usageAt: account.lastUsageAt ?? null,
+      sample: outcome.ok ? { ok: true, source: "probe" } : { ok: false, reason: outcome.reason },
+    };
+  });
+  return { bars, accounts };
+}
+
+function renderCodex(input: { codex: StatusReport["codex"]; now: number; row: (name: string, w: UsageWindow) => void }): void {
+  const { codex, now, row } = input;
+  if (codex.accounts.length === 0) return;
+  console.log(c.dim(`codex  (${count({ n: codex.accounts.length, noun: "account" })})`));
+  console.log();
+  const windowLabel = (window: CodexWindow) =>
+    isSessionWindow({ window }) ? `${Math.round((window.windowSeconds ?? 0) / 3600)}h` : "week";
+  for (const account of codex.accounts) {
+    const marker = account.active ? c.green("●") : c.dim("○");
     const badges: string[] = [];
-    if (active) badges.push(c.green("active"));
+    if (account.active) badges.push(c.green("active"));
     if (account.needsReauth) badges.push(c.red("needs-reauth"));
-    if (isCodexExhausted({ account, thresholds: terminalBars(cfg), now })) badges.push(c.yellow("exhausted"));
+    if (account.exhausted) badges.push(c.yellow("exhausted"));
     console.log(`${marker} ${c.bold(account.label)}${account.planType ? ` ${c.dim(account.planType)}` : ""}${badges.length ? ` ${badges.join(" ")}` : ""}`);
-
-    const usage = account.lastUsage;
-    if (usage) {
-      for (const window of usage.aggregate) row(windowLabel(window), window, !isSessionWindow({ window }));
-      for (const [name, windows] of Object.entries(usage.perLimit)) {
-        for (const window of windows) row(codexLimitLabel({ limitName: name }), window, !isSessionWindow({ window }));
+    if (account.usage) {
+      for (const window of account.usage.aggregate) row(windowLabel(window), window);
+      for (const [name, windows] of Object.entries(account.usage.perLimit)) {
+        for (const window of windows) row(codexLimitLabel({ limitName: name }), window);
       }
     }
-    const outcome = outcomes.get(account.accountId);
-    if (outcome && !outcome.ok) {
-      const cached = usage ? `cached${account.lastUsageAt != null ? ` ${fmtAgo(account.lastUsageAt, now)}` : ""}, ` : "";
-      console.log(`    ${c.yellow(`${cached}live sample failed`)}: ${c.dim(outcome.reason)}`);
+    if (!account.sample.ok) {
+      const cached = account.usage ? `cached${account.usageAt != null ? ` ${fmtAgo(account.usageAt, now)}` : ""}, ` : "";
+      console.log(`    ${c.yellow(`${cached}live sample failed`)}: ${c.dim(account.sample.reason)}`);
+    }
+    console.log();
+  }
+}
+
+function rowPrinter(now: number): (name: string, w: UsageWindow) => void {
+  return (name, w) => {
+    console.log(`    ${name.padEnd(5)} ${bar(w.usedPercentage)}  ${c.dim(fmtReset(w.resetsAt, now))}`);
+  };
+}
+
+function renderClaude(input: { claude: StatusReport["claude"]; codexPooled: boolean; now: number; row: (name: string, w: UsageWindow) => void }): void {
+  const { claude, codexPooled, now, row } = input;
+  if (claude.accounts.length === 0) {
+    if (!codexPooled) {
+      console.log(c.dim("no accounts yet, run `tokenmaxxing init` (or `tokenmaxxing init --codex`)"));
+      return;
+    }
+    console.log(c.dim("no claude accounts (run `tokenmaxxing init` to pool claude too)"));
+    console.log();
+    return;
+  }
+
+  console.log(c.dim(`thresholds 5h ${claude.thresholds.session.join("/")}% (at ${claude.bars.session + claude.projectionMargin}%) weekly ${claude.thresholds.weekly}%  (${count({ n: claude.accounts.length, noun: "claude account" })})`));
+  console.log();
+  for (const a of claude.accounts) {
+    const marker = a.active ? c.green("●") : c.dim("○");
+    const badges: string[] = [];
+    if (a.active) badges.push(c.green("active"));
+    if (a.needsReauth) badges.push(c.red("needs-reauth"));
+    if (a.exhausted) badges.push(c.yellow("exhausted"));
+    console.log(`${marker} ${c.bold(a.label || a.email)}${a.tier ? ` ${c.dim(a.tier)}` : ""}${badges.length ? ` ${badges.join(" ")}` : ""}`);
+    if (a.usage) {
+      row("5h", a.usage.fiveHour);
+      row("week", a.usage.week);
+    }
+    for (const [name, w] of Object.entries(a.perModel)) row(name.toLowerCase(), w);
+    if (!a.sample.ok) {
+      const cached = a.usage || Object.keys(a.perModel).length > 0 ? `cached${a.usageAt != null ? ` ${fmtAgo(a.usageAt, now)}` : ""}, ` : "";
+      console.log(`    ${c.yellow(`${cached}live sample failed`)}: ${c.dim(a.sample.reason)}`);
+    }
+    if (a.pingError != null) {
+      console.log(`    ${c.yellow("ping failed (5h timer may not have started)")}: ${c.dim(a.pingError)}`);
+    }
+    if (a.pinged) {
+      console.log(`    ${c.dim("pinged - 5h timer started this run; the usage feed lags, re-run status shortly for the fresh window")}`);
     }
     console.log();
   }
 }
+
+export async function cmdStatus(opts: { force?: boolean; json?: boolean; preRender?: () => void } = {}): Promise<number> {
+  const { force = false, json = false } = opts;
+  const cfg = loadConfig();
+  const now = Date.now();
+  const row = rowPrinter(now);
+  const claude = await collectClaude({ cfg, force, now });
+  if (!json) {
+    opts.preRender?.();
+    renderClaude({ claude, codexPooled: loadCodexAccounts().accounts.length > 0, now, row });
+  }
+  const codex = await collectCodex({ cfg, now });
+  if (json) {
+    const report: StatusReport = { now, claude, codex };
+    emitJson({ ok: true, ...report });
+    return 0;
+  }
+  renderCodex({ codex, now, row });
+  return 0;
+}