tokenmaxxing 1.110.0 → 1.111.0

package/DESIGN.md

@@ -30,7 +30,7 @@ It is a process manager only - spawn with inherited stdio (stdin through a relay
 - A `claude` **supervisor** on your PATH ahead of the real binary (`~/.config/tokenmaxxing/bin/claude`) - you invoke it identically; a `claude` shell function or alias would shadow it, and `doctor` warns about one.
 - Five `~/.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 `StopFailure` hook, a `SessionStart` hook.
 - **`~/.config/tokenmaxxing/`** - the single home for config and state:
-  - `config.json` - SPARSE overrides only (thresholds.session/weekly, claudeBin/codexBin/grokBin/opencodeBin/piBin pins, policy.*); defaults apply at read time, `xx config` prints the path and the effective values, and edits happen in an editor.
+  - `config.json` - SPARSE overrides only (thresholds.session/weekly/accounts, claudeBin/codexBin/grokBin/opencodeBin/piBin 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 `{id, label, email, tier, addedAt, windows, lastUsageAt, lastProbeAt, probeFails, storeFails, usageRetryAt, enforcedUntil, needsReauth, oauthAccount}` (each cached window carries its name, duration, reset, and sample time; the same shape serves the Codex pool as `codex-accounts.json`). Neither index names an active account: the schema is `{version, accounts}`, and an older file that still carries `activeId` loads and drops the key on the next save.
   - `stores/<uuid8>/` - one Claude Code credential store per pooled account (see below).
   - `codex-stores/<uuid8>/` - one Codex credential store per pooled account: its `auth.json`, with everything else symlinked to the shared `~/.codex` so sessions, history, and config stay shared and `codex resume` works across stores.

package/README.md

@@ -112,7 +112,7 @@ See [How switching decides](docs/content/docs/switching.mdx) for the policy and
 }
 ```
 
-`thresholds.session` and `thresholds.weekly` are the two bars, one number each (an array `thresholds.session`, the former ladder, fails config loading with a message naming the field); `projectionMargin` is a fixed safety margin subtracted from the session bar only (default 3), so a large turn is less likely to blow past the 5-hour bar between checks; the weekly bar takes no margin because one turn cannot overshoot a week; `switchModels` names the models whose per-model cap triggers a move; `usagePollTtlMs` is the shortest sample interval, the one an account near a bar gets, for a seat's own sample, for `status`, and for the accounts each check tick samples; `maxWaitMs` bounds the depleted-pool countdown - a reset further out than this does not pause the session (no respawn marker is written and the session simply keeps hitting its limit until an account recovers); `checkIntervalMs` is the periodic check tick (default 60s), which `init` writes into the timer - re-run `tokenmaxxing init` after changing it so the timer unit picks up the new tick. `claudeBin`, `codexBin`, `grokBin`, `opencodeBin`, and `piBin` pin the real binaries; `init` writes them, and `TOKENMAXXING_CLAUDE_BIN`, `TOKENMAXXING_CODEX_BIN`, `TOKENMAXXING_GROK_BIN`, `TOKENMAXXING_OPENCODE_BIN`, and `TOKENMAXXING_PI_BIN` override them for one process, except that `init` pins the binary it resolved into `config.json`.
+`thresholds.session` and `thresholds.weekly` are the two bars, one number each (an array `thresholds.session`, the former ladder, fails config loading with a message naming the field); `projectionMargin` is a fixed safety margin subtracted from the session bar only (default 3), so a large turn is less likely to blow past the 5-hour bar between checks; the weekly bar takes no margin because one turn cannot overshoot a week; `thresholds.accounts` gives one account its own pair, keyed by label (`{"shared-seat": {"session": 75, "weekly": 75}}`), and `policy.accountReleaseMs` (30 minutes for the session window, 5 hours for a weekly window by default) lifts each of its windows to the higher of its own and the global bar that close to the window's reset; `switchModels` names the models whose per-model cap triggers a move; `usagePollTtlMs` is the shortest sample interval, the one an account near a bar gets, for a seat's own sample, for `status`, and for the accounts each check tick samples; `maxWaitMs` bounds the depleted-pool countdown - a reset further out than this does not pause the session (no respawn marker is written and the session simply keeps hitting its limit until an account recovers); `checkIntervalMs` is the periodic check tick (default 60s), which `init` writes into the timer - re-run `tokenmaxxing init` after changing it so the timer unit picks up the new tick. `claudeBin`, `codexBin`, `grokBin`, `opencodeBin`, and `piBin` pin the real binaries; `init` writes them, and `TOKENMAXXING_CLAUDE_BIN`, `TOKENMAXXING_CODEX_BIN`, `TOKENMAXXING_GROK_BIN`, `TOKENMAXXING_OPENCODE_BIN`, and `TOKENMAXXING_PI_BIN` override them for one process, except that `init` pins the binary it resolved into `config.json`.
 
 State lives in `~/.config/tokenmaxxing/`; outside it the install touches Claude Code's `settings.json`, codex's `hooks.json`, the timer and usage hub units, and your shell rc. Each account's credential store is `stores/<uuid8>/`, which Claude Code reads and refreshes as its own: on macOS the credential is a login-keychain item keyed by the store path (never plaintext on disk), on Linux a 0600 `.credentials.json` inside the store (the same plaintext model claude itself uses for `~/.claude/.credentials.json`).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.110.0",
+  "version": "1.111.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/serve.ts

@@ -14,7 +14,7 @@ import type { Provider } from "../lib/provider.ts";
 import { foldTee } from "../lib/sample.ts";
 import { loadAccounts, loadConfig } from "../lib/state.ts";
 import { OAUTH_USAGE_URL } from "../lib/usage.ts";
-import type { Account, Config, Thresholds } from "../lib/types.ts";
+import type { Account, Bars, Config } from "../lib/types.ts";
 import { c, emitError } from "./render.ts";
 import { usageReport, type UsageReport, type WindowReport } from "./status.ts";
 
@@ -24,7 +24,7 @@ const STALE_AFTER_MS = 2 * 60 * 60_000;
 type HubPool = {
   provider: Provider;
   usageUrl: string;
-  fold: (account: Account, thresholds: Thresholds) => void;
+  fold: (account: Account, thresholds: Bars) => void;
   read: (account: Account, cfg: Config, now: number) => Promise<Account>;
   body: (usage: UsageReport, account: Account) => unknown;
 };

package/src/cli/status.ts

@@ -6,10 +6,10 @@ 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 { earliestReset, gatedWindows, landWindows, isExhausted, isSessionWindow, limitWindows, liveUsed, nextWeeklyReset, sessionWindow, thresholdBars, weeklyWindow } from "../lib/picker.ts";
+import { barFor, earliestReset, gatedWindows, 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, Config, Thresholds, Window } from "../lib/types.ts";
+import type { Account, Bars, Config, Thresholds, Window } from "../lib/types.ts";
 
 export type WindowReport = { usedPercentage: number; resetsAt: number | null; windowSeconds: number | null };
 
@@ -24,6 +24,7 @@ type StatusAccount = {
   sessions: number;
   needsReauth: boolean;
   exhausted: boolean;
+  thresholds: Thresholds | null;
   usage: UsageReport | null;
   usageAt: number | null;
   limitsAt: number | null;
@@ -60,7 +61,7 @@ export function usageReport(a: Account, now: number): UsageReport | null {
   };
 }
 
-function gatedNote(accounts: Account[], families: string[] | null, weeklyBar: number, now: number): string | null {
+function gatedNote(accounts: Account[], families: string[] | null, bars: Bars, now: number): string | null {
   const groups = new Map<string, { carriers: number; capped: number }>();
   for (const a of accounts) {
     if (a.needsReauth === true) continue;
@@ -68,7 +69,7 @@ function gatedNote(accounts: Account[], families: string[] | null, weeklyBar: nu
       const key = (w.name ?? "").toLowerCase();
       const g = groups.get(key) ?? { carriers: 0, capped: 0 };
       g.carriers++;
-      if (liveUsed(w, now) >= weeklyBar) g.capped++;
+      if (liveUsed(w, now) >= barFor(a, w, bars, now)) g.capped++;
       groups.set(key, g);
     }
   }
@@ -77,7 +78,7 @@ function gatedNote(accounts: Account[], families: string[] | null, weeklyBar: nu
   const headroom = accounts.filter((a) => {
     if (a.needsReauth === true) return false;
     const w = weeklyWindow(a);
-    return w != null && liveUsed(w, now) < weeklyBar;
+    return w != null && liveUsed(w, now) < barFor(a, w, bars, now);
   }).length;
   if (headroom === 0) return null;
   return `every ${capped.join(", ")} cap is at the weekly bar, but ${count({ n: headroom, noun: "account" })} still ha${headroom === 1 ? "s" : "ve"} weekly aggregate headroom for other models`;
@@ -130,6 +131,7 @@ async function collect(p: Provider, cfg: Config, now: number, cached: boolean):
 
   const present = p.presence();
   const ctx = { now, thresholds: bars, currentId: null, families: p.gatedFamilies(cfg), seats: null };
+  const own = new Map(Object.entries(cfg.thresholds.accounts));
   const ordered = sortBy(idx.accounts, [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, now)]);
   const accounts = ordered.map((a): StatusAccount => {
     const limits = limitWindows(a);
@@ -142,6 +144,7 @@ async function collect(p: Provider, cfg: Config, now: number, cached: boolean):
       sessions: present.get(a.id) ?? 0,
       needsReauth: a.needsReauth === true,
       exhausted: isExhausted(a, ctx),
+      thresholds: own.get(a.label) ?? null,
       usage: usageReport(a, now),
       usageAt: a.lastUsageAt ?? null,
       limitsAt: limits.length > 0 ? Math.max(...limits.map((w) => w.sampledAt)) : null,
@@ -150,9 +153,9 @@ async function collect(p: Provider, cfg: Config, now: number, cached: boolean):
   });
   return {
     thresholds: { session: cfg.thresholds.session, weekly: cfg.thresholds.weekly },
-    bars,
+    bars: { session: bars.session, weekly: bars.weekly },
     projectionMargin: cfg.policy.projectionMargin,
-    gatedNote: gatedNote(idx.accounts, ctx.families, bars.weekly, now),
+    gatedNote: gatedNote(idx.accounts, ctx.families, bars, now),
     accounts,
   };
 }
@@ -218,6 +221,7 @@ function card(p: Provider, a: StatusAccount, now: number, staleAfterMs: number):
     for (const w of a.usage.limits) lines.push(usageRow(p.windowLabel(w.name), w));
   }
   const notes: Note[] = [];
+  if (a.thresholds) notes.push({ paint: c.dim, text: `thresholds 5h ${a.thresholds.session}% weekly ${a.thresholds.weekly}%` });
   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";

package/src/lib/decide.ts

@@ -2,11 +2,11 @@ import { countBy } from "es-toolkit";
 import { CLAUDE_COMPACT_KILL_MS } from "./compact.ts";
 import { withLock } from "./lock.ts";
 import { loadAccounts, loadConfig, liveWaitClaims, releaseWaitClaim, replaceWaitClaim, saveAccounts } from "./state.ts";
-import { isExhausted, landWindows, limitWindows, liveUsed, nextWeeklyReset, pickBest, pickWaitTarget, sessionWindow, thresholdBars, weeklyWindow, type PickCtx } from "./picker.ts";
+import { isExhausted, landWindows, limitWindows, nextWeeklyReset, pickBest, pickWaitTarget, screensUntilReset, sessionWindow, thresholdBars, weeklyWindow, type PickCtx } from "./picker.ts";
 import { familyTokens } from "./usage.ts";
 import { errorMessage, log } from "./log.ts";
 import type { Observation, Provider } from "./provider.ts";
-import type { Account, EnforcedLimit } from "./types.ts";
+import type { Account, Bars, EnforcedLimit } from "./types.ts";
 
 export type SwapDecision = { swapped: boolean; account: Account | null; reason: string; waitUntil?: number };
 
@@ -31,10 +31,10 @@ function isOver(account: Account | undefined, observed: Observation | null, ctx:
   return isExhausted({ ...account, windows: observed.windows }, ctx);
 }
 
-function modelKindCovered(limit: EnforcedLimit, account: Account, now: number, weeklyBar: number): boolean {
+function modelKindCovered(limit: EnforcedLimit, account: Account, now: number, bars: Bars): boolean {
   if (limit.kind !== "model" || limit.family == null) return false;
   const family = limit.family;
-  return limitWindows(account).some((w) => familyTokens(w.name ?? "").includes(family) && liveUsed(w, now) >= weeklyBar);
+  return limitWindows(account).some((w) => familyTokens(w.name ?? "").includes(family) && screensUntilReset(account, w, bars, now));
 }
 
 function enforcedWall(limit: EnforcedLimit, account: Account, now: number): number {
@@ -86,7 +86,7 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), canRes
     let stamped = false;
     const credits = enforced?.kind === "credits";
     if (enforced && origin && !credits) {
-      const covered = modelKindCovered(enforced, origin, now, bars.weekly);
+      const covered = modelKindCovered(enforced, origin, now, bars);
       if (!covered || prior) {
         origin.enforcedUntil = Math.max(origin.enforcedUntil ?? 0, enforcedWall(enforced, origin, now));
         stamped = true;

package/src/lib/picker.ts

@@ -1,17 +1,19 @@
 import { maxBy, minBy, sortBy } from "es-toolkit";
 import { familyTokens } from "./usage.ts";
-import type { Account, Config, Thresholds, Window } from "./types.ts";
+import type { Account, Bars, Config, Thresholds, Window } from "./types.ts";
 
-export function thresholdBars(cfg: Config): Thresholds {
+export function thresholdBars(cfg: Config): Bars {
+  const bars = (t: Thresholds): Thresholds => ({ session: t.session - cfg.policy.projectionMargin, weekly: t.weekly });
   return {
-    session: cfg.thresholds.session - cfg.policy.projectionMargin,
-    weekly: cfg.thresholds.weekly,
+    ...bars(cfg.thresholds),
+    accounts: new Map(Object.entries(cfg.thresholds.accounts).map(([label, t]) => [label, bars(t)])),
+    accountReleaseMs: cfg.policy.accountReleaseMs,
   };
 }
 
 export type PickCtx = {
   now: number;
-  thresholds: Thresholds;
+  thresholds: Bars;
   currentId: string | null;
   families: string[] | null;
   seats: Map<string, number> | null;
@@ -49,20 +51,40 @@ export function liveUsed(w: Window, now: number): number {
   return w.usedPercentage;
 }
 
-export function barFor(w: Window, thresholds: Thresholds): number {
-  return isSessionWindow(w) ? thresholds.session : thresholds.weekly;
+function releaseMs(w: Window, bars: Bars): number {
+  return isSessionWindow(w) ? bars.accountReleaseMs.session : bars.accountReleaseMs.weekly;
 }
 
-function blockedUntil(w: Window, bar: number, now: number): number {
-  if (liveUsed(w, now) < bar) return 0;
-  if (w.resetsAt != null) return w.resetsAt;
-  return w.sampledAt + (w.windowSeconds ?? 0) * 1000;
+export function barFor(a: Account, w: Window, bars: Bars, now: number): number {
+  const pick = (t: Thresholds) => (isSessionWindow(w) ? t.session : t.weekly);
+  const own = bars.accounts.get(a.label);
+  if (own == null) return pick(bars);
+  const reset = windowResetAt(w, now);
+  const released = reset != null && reset > now && reset - now <= releaseMs(w, bars);
+  return released ? Math.max(pick(own), pick(bars)) : pick(own);
+}
+
+function windowEnd(w: Window): number {
+  return w.resetsAt ?? w.sampledAt + (w.windowSeconds ?? 0) * 1000;
+}
+
+function blockedUntil(a: Account, w: Window, bars: Bars, now: number): number {
+  const used = liveUsed(w, now);
+  if (used < barFor(a, w, bars, now)) return 0;
+  const reset = windowEnd(w);
+  const release = reset - releaseMs(w, bars);
+  return release > now && used < barFor(a, w, bars, release) ? release : reset;
+}
+
+export function screensUntilReset(a: Account, w: Window, bars: Bars, now: number): boolean {
+  const reset = windowEnd(w);
+  return reset > now && blockedUntil(a, w, bars, now) === reset;
 }
 
 function blockingUntil(a: Account, ctx: PickCtx): number[] {
   return [
-    ...a.windows.filter((w) => w.name == null).map((w) => blockedUntil(w, barFor(w, ctx.thresholds), ctx.now)),
-    ...gatedWindows(a, ctx.families).map((w) => blockedUntil(w, barFor(w, ctx.thresholds), ctx.now)),
+    ...a.windows.filter((w) => w.name == null).map((w) => blockedUntil(a, w, ctx.thresholds, ctx.now)),
+    ...gatedWindows(a, ctx.families).map((w) => blockedUntil(a, w, ctx.thresholds, ctx.now)),
     ...(a.enforcedUntil != null ? [a.enforcedUntil] : []),
   ];
 }
@@ -71,7 +93,7 @@ export function isExhausted(a: Account, ctx: PickCtx): boolean {
   return blockingUntil(a, ctx).some((t) => t > ctx.now);
 }
 
-export function landWindows(a: Account, windows: Window[], at: number, thresholds: Thresholds): void {
+export function landWindows(a: Account, windows: Window[], at: number, thresholds: Bars): void {
   const ctx: PickCtx = { now: at, thresholds, currentId: null, families: [], seats: null };
   const blocked = a.enforcedUntil != null && isExhausted({ ...a, enforcedUntil: undefined }, ctx);
   a.windows = windows;
@@ -114,7 +136,7 @@ export function pacePressure(a: Account, ctx: PickCtx): number {
 export function seatHeadroom(a: Account, ctx: PickCtx): number {
   const session = sessionWindow(a);
   if (session == null) return Number.NEGATIVE_INFINITY;
-  return (ctx.thresholds.session - liveUsed(session, ctx.now)) / ((ctx.seats?.get(a.id) ?? 0) + 1);
+  return (barFor(a, session, ctx.thresholds, ctx.now) - liveUsed(session, ctx.now)) / ((ctx.seats?.get(a.id) ?? 0) + 1);
 }
 
 const swapPreference = (ctx: PickCtx) => [

package/src/lib/sample.ts

@@ -12,7 +12,7 @@ import { seatCounts } from "./presence.ts";
 import type { Observation } from "./provider.ts";
 import { loadAccounts, loadUsageSnapshot, saveAccounts } from "./state.ts";
 import { fetchUsageDirect, mergeWindows, scrubCredEnv, windowsOf } from "./usage.ts";
-import type { Account, Config, Thresholds, UsageWindows, Window } from "./types.ts";
+import type { Account, Bars, Config, UsageWindows, Window } from "./types.ts";
 
 export type SampleOutcome = { ok: true; usage: UsageWindows; via: "get" } | { ok: false; reason: string; retryAt?: number };
 
@@ -25,10 +25,10 @@ export function sampleIntervalMs(account: Account, cfg: Config, now: number): nu
   const bars = thresholdBars(cfg);
   const aggregates = account.windows.filter((w) => w.name == null);
   if (aggregates.length === 0) return floor;
-  const blocked = (w: Window) => liveUsed(w, now) >= barFor(w, bars);
+  const blocked = (w: Window) => liveUsed(w, now) >= barFor(account, w, bars, now);
   if (aggregates.some(blocked)) return Math.max(floor, SAMPLE_INTERVAL_MAX_MS);
   const open = [...aggregates, ...gatedWindows(account, cfg.policy.switchModels).filter((w) => !blocked(w))];
-  const spare = Math.min(...open.map((w) => 1 - liveUsed(w, now) / barFor(w, bars)));
+  const spare = Math.min(...open.map((w) => 1 - liveUsed(w, now) / barFor(account, w, bars, now)));
   return Math.max(floor, SAMPLE_INTERVAL_MAX_MS * spare);
 }
 
@@ -48,7 +48,7 @@ export function teeObservation(account: Account): Observation | null {
   return { windows: mergeWindows(aggregate, account.windows), at };
 }
 
-export function foldTee(account: Account, thresholds: Thresholds): boolean {
+export function foldTee(account: Account, thresholds: Bars): boolean {
   const observed = teeObservation(account);
   if (!observed || (account.lastUsageAt != null && observed.at <= account.lastUsageAt)) return false;
   landWindows(account, observed.windows, observed.at, thresholds);

package/src/lib/types.ts

@@ -92,12 +92,17 @@ export type EnforcedLimit = {
 
 export type Thresholds = { session: number; weekly: number };
 
+export type Bars = Thresholds & { accounts: Map<string, Thresholds>; accountReleaseMs: Thresholds };
+
+const PercentSchema = z.number().min(0).max(100);
+
 export const ConfigSchema = z
   .object({
     thresholds: z
       .object({
-        session: z.number().min(0).max(100).default(90),
-        weekly: z.number().min(0).max(100).default(98),
+        session: PercentSchema.default(90),
+        weekly: PercentSchema.default(98),
+        accounts: z.record(z.string(), z.object({ session: PercentSchema, weekly: PercentSchema })).default({}),
       })
       .prefault({}),
     claudeBin: z.string().default(""),
@@ -115,6 +120,12 @@ export const ConfigSchema = z
         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),
+        accountReleaseMs: z
+          .object({
+            session: z.number().int().min(0).default(1_800_000),
+            weekly: z.number().int().min(0).default(18_000_000),
+          })
+          .prefault({}),
       })
       .prefault({}),
     hub: z
@@ -123,9 +134,9 @@ export const ConfigSchema = z
       })
       .prefault({}),
   })
-  .refine((cfg) => cfg.policy.projectionMargin < cfg.thresholds.session, {
+  .refine((cfg) => [cfg.thresholds, ...Object.values(cfg.thresholds.accounts)].every((t) => cfg.policy.projectionMargin < t.session), {
     path: ["policy", "projectionMargin"],
-    message: "must be strictly below the session threshold (the session bar would hit zero and every account would read as exhausted)",
+    message: "must be strictly below every session threshold (the session bar would hit zero and every account it covers would read as exhausted)",
   });
 export type Config = z.infer<typeof ConfigSchema>;