tokenmaxxing 1.14.0 → 1.16.0

package/README.md

@@ -70,7 +70,7 @@ claude                  # use claude as always
 | `tokenmaxxing switch --codex [sel]` | switch the codex pool (takes effect on the next codex start) |
 | `tokenmaxxing ls` | list pooled accounts |
 | `tokenmaxxing status` | accounts with 5h / weekly usage bars, active + exhausted-until-reset |
-| `tokenmaxxing status --force` | additionally ping every account (one tiny haiku request each) so all 5h session timers start now, then sample fresh |
+| `tokenmaxxing status --ping [--count N]` | additionally ping every account (one tiny haiku request each) so all 5h session timers start now, then sample fresh; `--count N` pings N randomly picked accounts instead, to stagger the resets |
 | `tokenmaxxing watch [seconds]` | live status: re-render every N seconds (default 120, floor 30; never pings) |
 | `tokenmaxxing config` | effective config with sources; `get`/`set`/`unset` dotted keys, `tidy` prunes unknown keys |
 | `tokenmaxxing doctor` | verify the supervisor + settings entries survived |

package/agent-plugin/plugin.json

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

package/agent-plugin/skills/pool-status/SKILL.md

@@ -10,18 +10,18 @@ description: Read the Claude and Codex account pool safely (list, usage bars, wa
 - `pool_ls` for labels, active marker, needs-reauth
 - `pool_status` for 5h / weekly / per-model bars (free `/usage` path)
 
-If MCP is unavailable, run `tokenmaxxing ls --json` or `tokenmaxxing status --json` (alias `xx`) and parse the document. Never add `--force`.
+If MCP is unavailable, run `tokenmaxxing ls --json` or `tokenmaxxing status --json` (alias `xx`) and parse the document. Never add `--ping`.
 
 ## Hard stops
 
-- Do not run `status --force` or bare `xx --force`. That pings every account with a real request and opens each 5h window.
+- Do not run `status --ping` or bare `xx --ping`. That pings every account with a real request and opens each 5h window.
 - Do not print credential files, keychain blobs, or OAuth tokens. Labels and status only.
 - Do not kill sessions or supervisors to "free" an account.
 
 ## Notes
 
 - Active Claude usage often comes from the statusLine tee; parked accounts are probed in isolation.
-- `watch` re-renders status on an interval and never force-pings.
+- `watch` re-renders status on an interval and never pings.
 - Hermetic agents: set `TOKENMAXXING_HOME` to a throwaway directory. That isolates state files only: `init`, `uninstall`, and the codex hook install still write settings.json, codex `hooks.json`, the shell rc, and the timer unit under `HOME`, so never run them from an agent.
 
 See [references/commands.md](references/commands.md).

package/agent-plugin/skills/pool-status/references/commands.md

@@ -1,9 +1,9 @@
 # Status and list commands
 
 - `tokenmaxxing` / `tokenmaxxing status`: sample and show bars; persists cached usage for the picker.
-- `tokenmaxxing status --force`: DENIED for agents without explicit user approval. Meters every account.
+- `tokenmaxxing status --ping [--count N]`: DENIED for agents without explicit user approval. Meters every account, or N random ones under `--count`.
 - `tokenmaxxing ls`: compact list.
-- `tokenmaxxing watch [seconds]`: live re-render (default 120), never `--force`.
+- `tokenmaxxing watch [seconds]`: live re-render (default 120), never `--ping`.
 - `--json` on any of these: one JSON document on stdout (`ok` mirrors the exit code); parse it instead of scraping the bars. `watch --json` prints one document per tick and never exits on its own.
 
 Docs: `docs/content/docs/commands.mdx`.

package/agent-plugin/skills/safe-contribution/SKILL.md

@@ -9,11 +9,11 @@ description: Safely change and ship tokenmaxxing (verification without a test su
 
 - The repo carries no test code and no comments (owner ruling 2026-09-02). Never add tests, a test script, or comments.
 - Verify with `bun run typecheck`, then hermetic CLI runs: `TOKENMAXXING_HOME=/tmp/xx-test bun run src/main.ts ...` (for decision-path changes, write accounts.json, usage.json, config.json, and a claude.json under that root and run `check`; point `TOKENMAXXING_KEYCHAIN_SERVICE` and `TOKENMAXXING_KEYCHAIN_ACCOUNT` at throwaway names and `TOKENMAXXING_CLAUDE_JSON` at that claude.json, because the CLI resolves claude.json from HOME, not from `TOKENMAXXING_HOME`).
-- Ask before any run that meters real quota (`status --force`, live-pool inference). Free `/usage` / plain status is fine.
+- Ask before any run that meters real quota (`status --ping`, live-pool inference). Free `/usage` / plain status is fine.
 
 ## Ship
 
-- Work on a branch; bump `package.json` in the same PR; open PR; wait the full review window; handle every review; merge; `gh release create v<version>`; verify npm publish.
+- Work on a branch; bump `package.json` and `agent-plugin/plugin.json` to the same version in the same PR; open PR; wait the full review window; handle every review; merge; `gh release create v<version>`; verify npm publish.
 - Never push directly to main. npm trusted publishing is bound to workflow filename `ci.yml`.
 
 ## Machine gotchas

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.14.0",
+  "version": "1.16.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/init.ts

@@ -37,7 +37,7 @@ export function printUsage(): void {
   console.log(`  ${c.bold("how to use")} - ${c.cyan("xx")} is shorthand for ${c.cyan("tokenmaxxing")}:`);
   console.log(`    ${c.cyan("claude")}             use claude as always; it switches accounts near quota automatically`);
   console.log(`    ${c.cyan("xx")}                 show the pool with usage bars (same as ${c.cyan("xx status")})`);
-  console.log(`    ${c.cyan("xx status --force")}  ping every account (one tiny haiku request each) so all 5h timers start now, then sample fresh`);
+  console.log(`    ${c.cyan("xx status --ping")}   ping every account (one tiny haiku request each) so all 5h timers start now, then sample fresh; ${c.cyan("--count N")} pings N random accounts instead`);
   console.log(`    ${c.cyan("xx add")}             log in and pool another account`);
   console.log(`    ${c.cyan("xx switch")}          hop to the best account right now (the automatic switching needs no command)`);
   console.log(`    ${c.cyan("xx help")}            everything else`);

package/src/cli/status.ts

@@ -1,4 +1,4 @@
-import { sortBy } from "es-toolkit";
+import { chunk, sampleSize, sortBy } from "es-toolkit";
 import { z } from "zod";
 import { loadAccounts, loadConfig, loadUsage, loadUsageSnapshot, loadModelUsage, saveAccounts } from "../lib/state.ts";
 import { readOAuthAccount } from "../lib/claudejson.ts";
@@ -10,7 +10,7 @@ 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, emitJson, fmtAgo, fmtReset } from "./render.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";
 
@@ -86,14 +86,31 @@ function currentCodexWindow(w: CodexWindow, now: number): CodexWindow {
   return { ...currentWindow(w, !isSessionWindow({ window: w }), now), windowSeconds: w.windowSeconds };
 }
 
-async function collectClaude(input: { cfg: Config; force: boolean; now: number }): Promise<StatusReport["claude"]> {
-  const { cfg, force, now } = input;
+function pickForPing(accounts: Account[], pingCount: number | undefined): Account[] {
+  if (pingCount == null) return accounts;
+  const usable = accounts.filter((a) => a.needsReauth !== true);
+  return sampleSize(usable, Math.min(pingCount, usable.length));
+}
+
+function progressNote(input: { ping: boolean; pingCount: number | undefined; picked: Account[]; total: number }): string {
+  const { ping, pingCount, picked, total } = input;
+  if (!ping) return "sampling live usage...";
+  if (pingCount == null) return "pinging every account (starts each 5h session timer) + sampling live usage...";
+  if (picked.length === 0) return "no account to ping (every account needs reauth), sampling live usage...";
+  return `pinging ${picked.length} of ${count({ n: total, noun: "account" })} (${picked.map((a) => a.label || a.email).join(", ")}) so their 5h session timers start now + sampling live usage...`;
+}
+
+async function collectClaude(input: { cfg: Config; ping: boolean; pingCount: number | undefined; now: number }): Promise<StatusReport["claude"]> {
+  const { cfg, ping, pingCount, now } = input;
   let idx = loadAccounts();
   const samples = new Map<string, { outcome: SampleOutcome; viaTee: boolean }>();
+  let pings = new Set<string>();
   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 picked = ping ? pickForPing(idx.accounts, pingCount) : [];
+      pings = new Set(picked.map((a) => a.accountUuid));
+      console.error(c.dim(progressNote({ ping, pingCount, picked, total: idx.accounts.length })));
       const tee = loadUsageSnapshot();
       const live = tee?.state ?? null;
       const teeAt = tee?.at ?? null;
@@ -114,7 +131,7 @@ async function collectClaude(input: { cfg: Config; force: boolean; now: number }
             : null;
         let viaTee = false;
         let outcome: SampleOutcome;
-        if (force) {
+        if (pings.has(a.accountUuid)) {
           outcome = isActive ? await probeActiveUsage(a, { ping: true }) : await probeParkedUsage(a, { ping: true });
           if (!outcome.ok && fromStatusLine && outcome.reason.includes("no limit data")) {
             const failed = outcome;
@@ -177,7 +194,7 @@ async function collectClaude(input: { cfg: Config; force: boolean; now: number }
       sample: sampled.outcome.ok ? { ok: true, source: sampled.viaTee ? "statusline" : "probe" } : { ok: false, reason: sampled.outcome.reason },
       pingError: sampled.outcome.pingError ?? null,
       pingRejected: sampled.outcome.pingRejected === true,
-      pinged: force && sampled.outcome.ok && sampled.outcome.pingError == null && aggregate != null && aggregate.fiveHour.resetsAt == null,
+      pinged: pings.has(a.accountUuid) && sampled.outcome.ok && sampled.outcome.pingError == null && aggregate != null && aggregate.fiveHour.resetsAt == null,
     };
   });
   return {
@@ -251,48 +268,138 @@ async function collectCodex(input: { cfg: Config; now: number }): Promise<Status
   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 (account.active) badges.push(c.green("active"));
-    if (account.needsReauth) badges.push(c.red("needs-reauth"));
-    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(" ")}` : ""}`);
-    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 CARD_GAP = 3;
+const NOTE_INDENT = "    ";
+
+type Note = { paint: (s: string) => string; text: string };
+type Card = { lines: string[]; notes: Note[] };
+
+function splitToWidth(token: string, width: number): string[] {
+  const parts: string[] = [];
+  let part = "";
+  for (const ch of token) {
+    if (part !== "" && Bun.stringWidth(part + ch) > width) {
+      parts.push(part);
+      part = "";
     }
-    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)}`);
+    part += ch;
+  }
+  if (part !== "") parts.push(part);
+  return parts;
+}
+
+function wrapWords(text: string, width: number): string[] {
+  const out: string[] = [];
+  let line = "";
+  for (const word of text.split(" ").flatMap((token) => splitToWidth(token, width))) {
+    if (line !== "" && Bun.stringWidth(`${line} ${word}`) > width) {
+      out.push(line);
+      line = word;
+    } else {
+      line = line === "" ? word : `${line} ${word}`;
+    }
+  }
+  if (line !== "") out.push(line);
+  return out;
+}
+
+function renderGrid(cards: Card[]): void {
+  const bodyWidth = Math.max(...cards.flatMap((card) => card.lines.map((line) => Bun.stringWidth(line))));
+  const termWidth = process.stdout.isTTY ? process.stdout.columns : Number.POSITIVE_INFINITY;
+  const columns = process.stdout.isTTY ? Math.min(cards.length, Math.max(1, Math.floor((termWidth + CARD_GAP) / (bodyWidth + CARD_GAP)))) : 1;
+  const cellWidth = columns === 1 ? termWidth : Math.floor((termWidth + CARD_GAP) / columns) - CARD_GAP;
+  const blocks = cards.map((card) => [
+    ...card.lines,
+    ...card.notes.flatMap((note) => wrapWords(note.text, cellWidth - NOTE_INDENT.length).map((line) => `${NOTE_INDENT}${note.paint(line)}`)),
+  ]);
+  const width = Math.max(...blocks.flat().map((line) => Bun.stringWidth(line)));
+  for (const rowBlocks of chunk(blocks, columns)) {
+    const height = Math.max(...rowBlocks.map((block) => block.length));
+    for (let i = 0; i < height; i++) {
+      const cells = rowBlocks.map((block) => block[i] ?? "");
+      const padded = cells.map((cell, col) => (col === cells.length - 1 ? cell : cell + " ".repeat(Math.max(0, width + CARD_GAP - Bun.stringWidth(cell)))));
+      console.log(padded.join("").trimEnd());
     }
     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 usageRow(name: string, w: UsageWindow): string {
+  return `${NOTE_INDENT}${name.padEnd(5)} ${bar(w.usedPercentage)}`;
+}
+
+function sampleFailedNotes(input: { cached: boolean; usageAt: number | null; reason: string; now: number }): Note[] {
+  const cached = input.cached ? `cached${input.usageAt != null ? ` ${fmtAgo(input.usageAt, input.now)}` : ""}, ` : "";
+  return [
+    { paint: c.yellow, text: `${cached}live sample failed:` },
+    { paint: c.dim, text: input.reason },
+  ];
+}
+
+function headerLine(input: { active: boolean; needsReauth: boolean; exhausted: boolean; name: string; tier: string | null }): string {
+  const marker = input.active ? c.green("●") : c.dim("○");
+  const badges: string[] = [];
+  if (input.active) badges.push(c.green("active"));
+  if (input.needsReauth) badges.push(c.red("needs-reauth"));
+  if (input.exhausted) badges.push(c.yellow("exhausted"));
+  return `${marker} ${c.bold(input.name)}${input.tier ? ` ${c.dim(input.tier)}` : ""}${badges.length ? ` ${badges.join(" ")}` : ""}`;
 }
 
-function renderClaude(input: {
-  claude: StatusReport["claude"];
-  codexPooled: boolean;
-  now: number;
-  staleAfterMs: number;
-  row: (name: string, w: UsageWindow) => void;
-}): void {
-  const { claude, codexPooled, now, staleAfterMs, row } = input;
+function codexCard(account: CodexStatusAccount, now: number): Card {
+  const windowLabel = (window: CodexWindow) =>
+    isSessionWindow({ window }) ? `${Math.round((window.windowSeconds ?? 0) / 3600)}h` : "week";
+  const lines = [headerLine({ ...account, name: account.label, tier: account.planType })];
+  if (account.usage) {
+    for (const window of account.usage.aggregate) lines.push(usageRow(windowLabel(window), window));
+    for (const [name, windows] of Object.entries(account.usage.perLimit)) {
+      for (const window of windows) lines.push(usageRow(codexLimitLabel({ limitName: name }), window));
+    }
+  }
+  const notes = account.sample.ok ? [] : sampleFailedNotes({ cached: account.usage != null, usageAt: account.usageAt, reason: account.sample.reason, now });
+  return { lines, notes };
+}
+
+function renderCodex(input: { codex: StatusReport["codex"]; now: number }): void {
+  const { codex, now } = input;
+  if (codex.accounts.length === 0) return;
+  console.log(c.dim(`codex  (${count({ n: codex.accounts.length, noun: "account" })})`));
+  console.log();
+  renderGrid(codex.accounts.map((account) => codexCard(account, now)));
+}
+
+function claudeCard(a: ClaudeStatusAccount, now: number, staleAfterMs: number): Card {
+  const lines = [headerLine({ ...a, name: a.label || a.email })];
+  if (a.usage) {
+    lines.push(usageRow("5h", a.usage.fiveHour));
+    lines.push(usageRow("week", a.usage.week));
+  }
+  for (const [name, w] of Object.entries(a.perModel)) lines.push(usageRow(name.toLowerCase(), w));
+  const notes: Note[] = [];
+  if (a.sample.ok && a.sample.source === "statusline") {
+    const stale = a.usageAt == null || now - a.usageAt > staleAfterMs;
+    const age = a.usageAt != null ? fmtAgo(a.usageAt, now) : "age unknown";
+    notes.push({ paint: stale ? c.yellow : c.dim, text: `statusline tee ${age}${stale ? " (stale)" : ""}` });
+  }
+  if (!a.sample.ok) {
+    notes.push(...sampleFailedNotes({ cached: a.usage != null || Object.keys(a.perModel).length > 0, usageAt: a.usageAt, reason: a.sample.reason, now }));
+  }
+  if (a.pingError != null && a.pingRejected) {
+    const at = a.pingError.indexOf(": ");
+    const head = at >= 0 ? a.pingError.slice(0, at) : a.pingError;
+    const tail = at >= 0 ? a.pingError.slice(at + 2) : "";
+    notes.push({ paint: c.yellow, text: `ping ${head}${tail ? ":" : ""}` });
+    if (tail) notes.push({ paint: c.dim, text: tail });
+  } else if (a.pingError != null) {
+    notes.push({ paint: c.yellow, text: "ping failed (5h timer may not have started):" }, { paint: c.dim, text: a.pingError });
+  }
+  if (a.pinged) {
+    notes.push({ paint: c.dim, text: "pinged - 5h timer started this run; the usage feed lags, re-run status shortly for the fresh window" });
+  }
+  return { lines, notes };
+}
+
+function renderClaude(input: { claude: StatusReport["claude"]; codexPooled: boolean; now: number; staleAfterMs: number }): void {
+  const { claude, codexPooled, now, staleAfterMs } = input;
   if (claude.accounts.length === 0) {
     if (!codexPooled) {
       console.log(c.dim("no accounts yet, run `tokenmaxxing init` (or `tokenmaxxing init --codex`)"));
@@ -305,51 +412,18 @@ function renderClaude(input: {
 
   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 && a.sample.source === "statusline") {
-      const stale = a.usageAt == null || now - a.usageAt > staleAfterMs;
-      const age = a.usageAt != null ? fmtAgo(a.usageAt, now) : "age unknown";
-      console.log(`    ${(stale ? c.yellow : c.dim)(`statusline tee ${age}${stale ? " (stale)" : ""}`)}`);
-    }
-    if (!a.sample.ok) {
-      const cached = a.usage || Object.keys(a.perModel).length > 0 ? `cached${a.usageAt != null ? ` ${fmtAgo(a.usageAt, now)}` : ""}, ` : "";
-      console.log(`    ${c.yellow(`${cached}live sample failed`)}: ${c.dim(a.sample.reason)}`);
-    }
-    if (a.pingError != null && a.pingRejected) {
-      const at = a.pingError.indexOf(": ");
-      const head = at >= 0 ? a.pingError.slice(0, at) : a.pingError;
-      const tail = at >= 0 ? a.pingError.slice(at + 2) : "";
-      console.log(`    ${c.yellow(`ping ${head}`)}${tail ? `: ${c.dim(tail)}` : ""}`);
-    } else if (a.pingError != null) {
-      console.log(`    ${c.yellow("ping failed (5h timer may not have started)")}: ${c.dim(a.pingError)}`);
-    }
-    if (a.pinged) {
-      console.log(`    ${c.dim("pinged - 5h timer started this run; the usage feed lags, re-run status shortly for the fresh window")}`);
-    }
-    console.log();
-  }
+  renderGrid(claude.accounts.map((a) => claudeCard(a, now, staleAfterMs)));
 }
 
-export async function cmdStatus(opts: { force?: boolean; json?: boolean; preRender?: () => void } = {}): Promise<number> {
-  const { force = false, json = false } = opts;
+export async function cmdStatus(opts: { ping?: boolean; pingCount?: number; json?: boolean; preRender?: () => void } = {}): Promise<number> {
+  const { ping = false, pingCount, json = false } = opts;
   const cfg = loadConfig();
   const now = Date.now();
-  const claude = await collectClaude({ cfg, force, now });
+  const claude = await collectClaude({ cfg, ping, pingCount, now });
   if (!json) {
     opts.preRender?.();
     const at = Date.now();
-    renderClaude({ claude, codexPooled: loadCodexAccounts().accounts.length > 0, now: at, staleAfterMs: cfg.policy.usagePollTtlMs, row: rowPrinter(at) });
+    renderClaude({ claude, codexPooled: loadCodexAccounts().accounts.length > 0, now: at, staleAfterMs: cfg.policy.usagePollTtlMs });
   }
   const codex = await collectCodex({ cfg, now });
   if (json) {
@@ -357,7 +431,6 @@ export async function cmdStatus(opts: { force?: boolean; json?: boolean; preRend
     emitJson({ ok: true, ...report });
     return 0;
   }
-  const at = Date.now();
-  renderCodex({ codex, now: at, row: rowPrinter(at) });
+  renderCodex({ codex, now: Date.now() });
   return 0;
 }

package/src/entries/mcp.ts

@@ -97,7 +97,7 @@ const HELP_TEXT = `tokenmaxxing agent MCP
 
 Read tools (always available):
   pool_ls       list pooled Claude and Codex accounts (labels/status only)
-  pool_status   sample usage bars (free /usage path; never --force)
+  pool_status   sample usage bars (free /usage path; never --ping)
   doctor        verify install health (labels/status only)
   config_get    read effective config, or one key when provided
   help          this catalog
@@ -109,7 +109,7 @@ Mutating tools (confirm=true AND ${MUTATIONS_ENV}=1):
   config_unset  remove a config.json override
 
 Hard deny (no tools):
-  status --force / metered pings
+  status --ping / metered pings
   init / add / auth / rm / uninstall
   credential blobs or token values
   killing sessions or supervisors
@@ -147,7 +147,7 @@ export function createTokenmaxxingMcpServer(): McpServer {
   server.registerTool(
     "pool_status",
     {
-      description: "Show pool usage bars via the free /usage path. Never opens 5h windows. Do not request --force; that tool does not exist.",
+      description: "Show pool usage bars via the free /usage path. Never opens 5h windows. Do not request --ping; that tool does not exist.",
       inputSchema: {},
     },
     async () => {

package/src/main.ts

@@ -45,7 +45,7 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing switch --codex")} [sel]  switch the codex pool (takes effect on next codex start)
   ${c.cyan("tokenmaxxing ls")}         list pooled accounts
   ${c.cyan("tokenmaxxing status")}     accounts with 5h / weekly / per-model usage bars
-  ${c.cyan("tokenmaxxing status --force")}  ping every account (one tiny haiku request each) so all 5h session timers start now, then sample fresh; ${c.cyan("xx --force")} works too
+  ${c.cyan("tokenmaxxing status --ping")} [--count N]  ping every account (one tiny haiku request each) so all 5h session timers start now, then sample fresh; ${c.cyan("--count N")} pings N randomly picked accounts instead, to stagger the resets; ${c.cyan("xx --ping")} works too
   ${c.cyan("tokenmaxxing watch")} [seconds]  live status: re-render every N seconds (default 120, never pings)
   ${c.cyan("tokenmaxxing config")} [get|set|unset|tidy]  inspect and edit config.json (bare = effective config with sources)
   ${c.cyan("tokenmaxxing doctor")}     verify the install is intact
@@ -60,6 +60,28 @@ function printHelp(): void {
 
 let jsonMode = false;
 
+function statusFlags(rest: string[]): { ping: boolean; pingCount: number | undefined } | { error: string } {
+  let ping = false;
+  let pingCount: number | undefined;
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i]!;
+    if (arg === "--ping") {
+      ping = true;
+      continue;
+    }
+    if (arg === "--count") {
+      if (pingCount != null) return { error: "--count may only be given once" };
+      const raw = rest[++i];
+      pingCount = Number(raw);
+      if (!Number.isInteger(pingCount) || pingCount < 1) return { error: `--count needs a positive whole number of accounts, got: ${raw ?? "nothing"}` };
+      continue;
+    }
+    return { error: `unknown status option: ${arg} (status takes --ping and --count N)` };
+  }
+  if (pingCount != null && !ping) return { error: "--count only applies together with --ping" };
+  return { ping, pingCount };
+}
+
 async function main(): Promise<number> {
   if (process.platform !== "darwin" && process.platform !== "linux") {
     console.error(`tokenmaxxing supports macOS and Linux only (this is ${process.platform})`);
@@ -103,8 +125,17 @@ async function main(): Promise<number> {
     case "__stop-failure-hook": return runStopFailureHook();
     case "__session-start": return runSessionStart();
     case "__codex-stop-hook": return runCodexStopHook();
-    case undefined: return cmdStatus({ json });
-    case "--force": return cmdStatus({ force: true, json });
+    case undefined:
+    case "status":
+    case "--ping":
+    case "--count": {
+      const flags = statusFlags(sub === "status" ? args.slice(1) : args);
+      if ("error" in flags) {
+        emitError({ json, message: flags.error });
+        return 2;
+      }
+      return cmdStatus({ ...flags, json });
+    }
     case "switch": {
       const rest = args.slice(1).filter((a) => a !== "--codex");
       return args.includes("--codex") ? cmdCodexSwitch(rest[0], json) : cmdSwitch(rest[0], json);
@@ -115,7 +146,6 @@ async function main(): Promise<number> {
     case "add": return args.includes("--codex") ? cmdCodexAdd() : cmdAdd();
     case "auth": return cmdAuth(args.slice(1));
     case "ls": return cmdLs(json);
-    case "status": return cmdStatus({ force: args.includes("--force"), json });
     case "watch": return cmdWatch(args[1], json);
     case "doctor": return cmdDoctor(json);
     case "rm": {