tokenmaxxing 1.126.0 → 1.127.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.126.0",
+  "version": "1.127.0",
   "description": "Automatic Claude Code account switching: pool multiple accounts, start each session on its own account, and resume a session on a fresher account when quota fills.",
   "type": "module",
   "license": "MIT",

package/src/cli/add.ts

@@ -1,14 +1,18 @@
 import { withLock } from "../lib/lock.ts";
 import type { Provider } from "../lib/provider.ts";
-import { loadAccounts, saveAccounts, upsertAccount } from "../lib/state.ts";
-import { sessionWindow, weeklyWindow } from "../lib/picker.ts";
+import { loadAccounts, loadConfig, saveAccounts, upsertAccount } from "../lib/state.ts";
+import { bufferedUsed, liveUsed, sessionWindow, thresholdBars, weeklyWindow } from "../lib/picker.ts";
 import { c, count } from "./render.ts";
-import type { Account } from "../lib/types.ts";
+import type { Account, Window } from "../lib/types.ts";
 
-export function usageNote(account: Account): string {
+export function usageNote(p: Provider, account: Account): string {
   const session = sessionWindow(account);
   const week = weeklyWindow(account);
-  return session && week ? ` (session ${session.usedPercentage}% / week ${week.usedPercentage}%)` : "";
+  if (!session || !week) return "";
+  const bars = thresholdBars(loadConfig());
+  const now = Date.now();
+  const pct = (w: Window) => Math.round(p.statusOnly ? liveUsed(w, now) : bufferedUsed(account, w, bars, now));
+  return ` (session ${pct(session)}% / week ${pct(week)}%)`;
 }
 
 export async function cmdAdd(p: Provider): Promise<number> {
@@ -28,7 +32,7 @@ export async function cmdAdd(p: Provider): Promise<number> {
   });
 
   console.log();
-  const note = harvested.sample ? usageNote(account) : "";
+  const note = harvested.sample ? usageNote(p, account) : "";
   console.log(`${c.green("✓")} added ${c.bold(account.label)} (${account.tier ?? "?"})${note} → pool now has ${count({ n: poolSize, noun: "account" })}`);
   return 0;
 }

package/src/cli/auth.ts

@@ -91,7 +91,7 @@ async function reauthOne(p: Provider, target: Account): Promise<boolean> {
   });
   if (account === null) return false;
 
-  const note = harvested.sample ? usageNote(account) : "";
+  const note = harvested.sample ? usageNote(p, account) : "";
   console.log(`${c.green("✓")} reauthed ${c.bold(account.email ?? account.label)} (${account.tier ?? "?"})${note}`);
   return true;
 }

package/src/cli/serve.ts

@@ -34,11 +34,11 @@ function iso(epochMs: number | null): string | null {
 }
 
 function claudeBody(usage: UsageReport): unknown {
-  const win = (w: WindowReport | null) => (w ? { utilization: w.usedPercentage, resets_at: iso(w.resetsAt) } : null);
+  const win = (w: WindowReport | null) => (w ? { utilization: w.bufferedPercentage, resets_at: iso(w.resetsAt) } : null);
   return {
     five_hour: win(usage.fiveHour),
     seven_day: win(usage.week),
-    limits: usage.limits.map((w) => ({ kind: "weekly_scoped", percent: w.usedPercentage, resets_at: iso(w.resetsAt), scope: { model: { display_name: w.name } } })),
+    limits: usage.limits.map((w) => ({ kind: "weekly_scoped", percent: w.bufferedPercentage, resets_at: iso(w.resetsAt), scope: { model: { display_name: w.name } } })),
   };
 }
 
@@ -46,7 +46,7 @@ function codexBody(usage: UsageReport, account: Account): unknown {
   const win = (w: WindowReport | undefined) =>
     w
       ? {
-          used_percent: w.usedPercentage,
+          used_percent: w.bufferedPercentage,
           reset_at: w.resetsAt == null ? null : Math.round(w.resetsAt / 1000),
           ...(w.windowSeconds == null ? {} : { limit_window_seconds: w.windowSeconds }),
         }
@@ -142,8 +142,9 @@ async function apiCall(req: Request): Promise<Response> {
   const now = Date.now();
   const cfg = loadConfig();
   const current = await pool.read(account, cfg, now);
-  pool.fold(current, thresholdBars(cfg));
-  const usage = usageReport({ ...current, windows: current.windows.filter((w) => now - w.sampledAt <= STALE_AFTER_MS) }, now);
+  const bars = thresholdBars(cfg);
+  pool.fold(current, bars);
+  const usage = usageReport({ ...current, windows: current.windows.filter((w) => now - w.sampledAt <= STALE_AFTER_MS) }, bars, now);
   if (!usage || (!usage.fiveHour && !usage.week)) return json({ error: `no usage figure newer than ${STALE_AFTER_MS / 3_600_000}h for this account` }, 502);
   return json({ status_code: 200, header: { "Content-Type": ["application/json"] }, body: JSON.stringify(pool.body(usage, current)) });
 }

package/src/cli/status.ts

@@ -6,12 +6,12 @@ import { opencodeGo } from "../lib/opencodego.ts";
 import { loadAccounts, loadConfig, saveAccounts } from "../lib/state.ts";
 import { withLock } from "../lib/lock.ts";
 import { codexPool, grokPool, opencodeGoPool } from "../lib/paths.ts";
-import { barFor, earliestReset, gatedWindows, landGrant, landWindows, isExhausted, isSessionWindow, limitWindows, liveUsed, nextWeeklyReset, sessionWindow, thresholdBars, weeklyWindow } from "../lib/picker.ts";
+import { barFor, bufferedUsed, earliestReset, gatedWindows, landGrant, landWindows, isExhausted, isSessionWindow, limitWindows, liveUsed, nextWeeklyReset, sessionWindow, thresholdBars, weeklyWindow } from "../lib/picker.ts";
 import type { Provider, SampleReport } from "../lib/provider.ts";
 import { bar, c, count, emitJson, fmtAgo } from "./render.ts";
 import type { Account, AccountThresholds, Bars, Config, Thresholds, Window } from "../lib/types.ts";
 
-export type WindowReport = { usedPercentage: number; resetsAt: number | null; windowSeconds: number | null };
+export type WindowReport = { usedPercentage: number; bufferedPercentage: number; resetsAt: number | null; windowSeconds: number | null };
 
 export type UsageReport = { fiveHour: WindowReport | null; week: WindowReport | null; limits: (WindowReport & { name: string })[] };
 
@@ -41,23 +41,24 @@ type PoolReport = {
 
 export type StatusReport = { now: number; claude: PoolReport; codex: PoolReport; grok: PoolReport; opencodeGo: PoolReport };
 
-function currentWindow(w: Window, now: number): WindowReport {
+function currentWindow(a: Account, w: Window, bars: Bars | null, now: number): WindowReport {
   const passed = w.resetsAt != null && w.resetsAt <= now;
   return {
-    usedPercentage: passed ? 0 : w.usedPercentage,
+    usedPercentage: liveUsed(w, now),
+    bufferedPercentage: bars == null ? liveUsed(w, now) : bufferedUsed(a, w, bars, now),
     resetsAt: isSessionWindow(w) ? (passed ? null : w.resetsAt) : nextWeeklyReset(w.resetsAt, now),
     windowSeconds: w.windowSeconds,
   };
 }
 
-export function usageReport(a: Account, now: number): UsageReport | null {
+export function usageReport(a: Account, bars: Bars | null, now: number): UsageReport | null {
   if (a.lastUsageAt == null) return null;
   const session = sessionWindow(a);
   const week = weeklyWindow(a);
   return {
-    fiveHour: session ? currentWindow(session, now) : null,
-    week: week ? currentWindow(week, now) : null,
-    limits: limitWindows(a).map((w) => ({ name: w.name ?? "", ...currentWindow(w, now) })),
+    fiveHour: session ? currentWindow(a, session, bars, now) : null,
+    week: week ? currentWindow(a, week, bars, now) : null,
+    limits: limitWindows(a).map((w) => ({ name: w.name ?? "", ...currentWindow(a, w, bars, now) })),
   };
 }
 
@@ -151,7 +152,7 @@ async function collect(p: Provider, cfg: Config, now: number, cached: boolean):
       needsReauth: a.needsReauth === true,
       exhausted: isExhausted(a, ctx),
       thresholds: own.get(a.label) ?? null,
-      usage: usageReport(a, now),
+      usage: usageReport(a, p.statusOnly ? null : bars, now),
       usageAt: a.lastUsageAt ?? null,
       limitsAt: limits.length > 0 ? Math.max(...limits.map((w) => w.sampledAt)) : null,
       sample: reports.get(a.id) ?? (cached ? { ok: true, source: "cached" } : { ok: false, reason: "not sampled" }),
@@ -194,7 +195,7 @@ function renderGrid(cards: Card[]): void {
 }
 
 function usageRow(name: string, w: WindowReport): string {
-  return `${NOTE_INDENT}${name.padEnd(5)} ${bar(w.usedPercentage)}`;
+  return `${NOTE_INDENT}${name.padEnd(5)} ${bar(w.bufferedPercentage)}`;
 }
 
 function sampleFailedNotes(input: { cached: boolean; usageAt: number | null; reason: string; now: number }): Note[] {
@@ -245,6 +246,7 @@ function card(p: Provider, a: StatusAccount, now: number, staleAfterMs: number):
 
 function renderPool(p: Provider, pool: PoolReport, header: string, now: number, staleAfterMs: number): void {
   console.log(c.dim(header));
+  if (!p.statusOnly) console.log(c.dim("buffered usage quota: percent of each account's switch threshold, so it reads higher than the usage Claude or Codex reports"));
   console.log();
   renderGrid(pool.accounts.map((a) => card(p, a, now, staleAfterMs)));
   if (pool.gatedNote) {

package/src/entries/statusline.ts

@@ -3,7 +3,7 @@ import { claudePool, seatFromEnv } from "../lib/paths.ts";
 import { errorMessage } from "../lib/log.ts";
 import { loadAccounts, loadConfig, writeUsage } from "../lib/state.ts";
 import { familyTokens, matchedFamily, parseStatusLineStdin, parseStatusLineModel } from "../lib/usage.ts";
-import { earliestReset, limitWindows, weeklyExpiry, weeklyWindow } from "../lib/picker.ts";
+import { bufferedUsed, earliestReset, limitWindows, liveUsed, thresholdBars, weeklyExpiry, weeklyWindow } from "../lib/picker.ts";
 import { readStdin } from "../lib/proc.ts";
 import { worktreeName } from "../lib/worktree.ts";
 import { fmtResetShort, makeColors, makeUsagePaint, statuslineColor } from "../cli/render.ts";
@@ -12,13 +12,18 @@ import {
   StatusLineStdinSchema,
   type Account,
   type AccountsIndex,
+  type Bars,
   type UsageState,
   type UsageWindow,
   type Window,
 } from "../lib/types.ts";
 
+const FIVE_HOUR_S = 5 * 3600;
+const SEVEN_DAY_S = 7 * 24 * 3600;
+
 export type RenderCtx = {
   accounts: AccountsIndex;
+  bars: Bars;
   perModel: Record<string, Window>;
   switchModels: string[];
   worktree: string | null;
@@ -31,7 +36,7 @@ export type RenderCtx = {
 export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
   const col = makeColors(ctx.color);
   const paint = makeUsagePaint({ enabled: ctx.color, truecolor: ctx.truecolor });
-  const used = (w: UsageWindow) => (w.resetsAt != null && w.resetsAt <= ctx.now ? 0 : w.usedPercentage);
+  const used = (a: Account, w: Window) => bufferedUsed(a, w, ctx.bars, ctx.now);
   const reset = (epochMs: number | null) => fmtResetShort(epochMs, ctx.now);
 
   const parsed = StatusLineStdinSchema.safeParse(stdinObj);
@@ -51,8 +56,7 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
   const removed = d?.cost?.total_lines_removed ?? 0;
   if (added > 0 || removed > 0) info.push(`${col.green(`+${added}`)}/-${removed}`);
 
-  const seg = (label: string, w: UsageWindow, resetAt: number | null) => {
-    const u = used(w);
+  const seg = (label: string, u: number, resetAt: number | null) => {
     if (!ctx.color) return `${label}${reset(resetAt)}${Math.round(u)}`;
     const body = label !== "" ? label : reset(resetAt);
     return col.bold(paint(u)(body !== "" ? body : u > 0 ? "?" : "0"));
@@ -64,15 +68,17 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
   if (family && !Object.keys(ctx.perModel).some((k) => familyTokens(k).includes(family))) {
     windows.push(`${initial(family)}?`);
   }
-  for (const [name, w] of Object.entries(ctx.perModel)) windows.push(seg(initial(name), w, null));
+  const seatUuid = ctx.liveAccount;
+  const seat = ctx.accounts.accounts.find((a) => a.id === seatUuid);
+  const seatUsed = (w: Window) => (seat ? used(seat, w) : liveUsed(w, ctx.now));
+  const stdinWindow = (w: UsageWindow, windowSeconds: number): Window => ({ name: null, ...w, windowSeconds, sampledAt: ctx.now });
+  for (const [name, w] of Object.entries(ctx.perModel)) windows.push(seg(initial(name), seatUsed(w), null));
   if (wins) {
-    windows.push(seg("", wins.fiveHour, wins.fiveHour.resetsAt));
-    windows.push(seg("", wins.sevenDay, wins.sevenDay.resetsAt));
+    windows.push(seg("", seatUsed(stdinWindow(wins.fiveHour, FIVE_HOUR_S)), wins.fiveHour.resetsAt));
+    windows.push(seg("", seatUsed(stdinWindow(wins.sevenDay, SEVEN_DAY_S)), wins.sevenDay.resetsAt));
   }
-  const seatUuid = ctx.liveAccount;
   const walled = (a: Account) => a.enforcedUntil != null && a.enforcedUntil > ctx.now;
-  const wallSeg = (wall: number) => seg("", { usedPercentage: 100, resetsAt: wall }, wall);
-  const seat = ctx.accounts.accounts.find((a) => a.id === seatUuid);
+  const wallSeg = (wall: number) => seg("", 100, wall);
   if (seat?.enforcedUntil != null && walled(seat)) windows.push(wallSeg(seat.enforcedUntil));
   const seatMarker = seat && walled(seat) ? paint(100)("◆") : col.green("◆");
   const active =
@@ -91,15 +97,16 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
     if (a.enforcedUntil != null && walled(a)) return `${marker} ${wallSeg(a.enforcedUntil)}`;
     const week = weeklyWindow(a);
     if (week == null) return `${marker} ?`;
-    const weekUsed = used(week);
+    const weekUsed = used(a, week);
     if (Math.round(weekUsed) <= 0) return `${marker} ${paint(0)("full")}`;
 
     const parts: string[] = [];
     for (const w of limitWindows(a)) {
-      if (used(w) > weekUsed) parts.push(seg(initial(w.name ?? ""), w, null));
+      const u = used(a, w);
+      if (u > weekUsed) parts.push(seg(initial(w.name ?? ""), u, null));
     }
     const expiry = weeklyExpiry(a, ctx.now);
-    parts.push(seg("", week, Number.isFinite(expiry) ? expiry : null));
+    parts.push(seg("", weekUsed, Number.isFinite(expiry) ? expiry : null));
     return `${marker} ${parts.join(" ")}`;
   };
 
@@ -130,6 +137,7 @@ export async function runStatusline(): Promise<number> {
     const live = accounts.accounts.find((a) => a.id === account);
     const ctx: RenderCtx = {
       accounts,
+      bars: thresholdBars(cfg),
       perModel: Object.fromEntries((live ? limitWindows(live) : []).map((w) => [w.name ?? "", w])),
       switchModels: cfg.policy.switchModels,
       worktree: dir == null ? null : worktreeName(dir),

package/src/lib/picker.ts

@@ -64,6 +64,13 @@ export function barFor(a: Account, w: Window, bars: Bars, now: number): number {
   return released ? Math.max(pick(own), pick(bars)) : pick(own);
 }
 
+export function bufferedUsed(a: Account, w: Window, bars: Bars, now: number): number {
+  const used = liveUsed(w, now);
+  const bar = barFor(a, w, bars, now);
+  if (bar <= 0) return used > 0 ? 100 : 0;
+  return Math.min(100, (used / bar) * 100);
+}
+
 function windowEnd(w: Window): number {
   return w.resetsAt ?? w.sampledAt + (w.windowSeconds ?? 0) * 1000;
 }