tokenmaxxing 1.109.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.109.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/seat.ts

@@ -11,8 +11,8 @@ const POOLS = {
   },
   codex: {
     borrow: borrowCodexSeat,
-    usage: "usage: tokenmaxxing seat --codex <pid> - print the CODEX_HOME of one pooled account, reserved to <pid> alone until it exits, because one codex auth.json serves one machine or one serialized job stream (https://learn.chatgpt.com/docs/auth/ci-cd-auth)",
-    none: "no usable codex account (pool empty, every account live in another session, or every account at a limit) - use the ambient codex login",
+    usage: "usage: tokenmaxxing seat --codex <pid> - print the CODEX_HOME of one pooled account, lent to <pid> until it exits and shared with codex sessions and other borrowers; codex processes that share one auth.json can lose a refresh race that signs the account out until `tokenmaxxing auth --codex` runs again",
+    none: "no usable codex account (pool empty, or every account at a limit, flagged for reauthentication, held by a pi session, or held by the supervised codex session this runs in) - use the ambient codex login",
   },
   "opencode-go": {
     borrow: borrowOpencodeGoSeat,

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/entries/codexstophook.ts

@@ -4,14 +4,13 @@ import type { z } from "zod";
 import { codexPaths, optionalEnv } from "../lib/paths.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
 import { CODEX_BIN, MAX_WRAP_DEPTH, WRAP_DEPTH_ENV, resolveRealBin } from "../lib/claudebin.ts";
-import { codex, codexPickCtx } from "../lib/codex.ts";
+import { CODEX_SUPERVISOR_ID_ENV, codex, codexPickCtx } from "../lib/codex.ts";
 import { compactCodexThread } from "../lib/compact.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
 import { isExhausted } from "../lib/picker.ts";
 import { livingPresences } from "../lib/presence.ts";
 import { readStdin } from "../lib/proc.ts";
 import { loadAccounts, loadConfig } from "../lib/state.ts";
-import { CODEX_SUPERVISOR_ID_ENV } from "./codexsupervisor.ts";
 import { CodexRespawnMarkerSchema, CodexStopStdinSchema, JsonTextSchema } from "../lib/types.ts";
 import { errorMessage, log } from "../lib/log.ts";
 

package/src/entries/codexsupervisor.ts

@@ -7,7 +7,7 @@ import { codexPaths, codexPool } from "../lib/paths.ts";
 import { withLock } from "../lib/lock.ts";
 import { CODEX_BIN, UNMANAGED_ENV, WRAP_DEPTH_ENV, resolveRealBin, wrapDepth } from "../lib/claudebin.ts";
 import { codexStoreUsable, ensureCodexStoreHome } from "../lib/codexauth.ts";
-import { borrowCodexSeat, codexPickCtx, pickCodexSeat } from "../lib/codex.ts";
+import { CODEX_SUPERVISOR_ID_ENV, borrowCodexSeat, codexPickCtx, pickCodexSeat } from "../lib/codex.ts";
 import { clearPresence, livingPresences } from "../lib/presence.ts";
 import { isExhausted } from "../lib/picker.ts";
 import { exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, runPassthrough } from "../lib/supervise.ts";
@@ -16,8 +16,6 @@ import { loadAccounts, readJsonFile } from "../lib/state.ts";
 import { CodexRespawnMarkerSchema, type Account } from "../lib/types.ts";
 import { errorMessage, log } from "../lib/log.ts";
 
-export const CODEX_SUPERVISOR_ID_ENV = "TOKENMAXXING_CODEX_SUPERVISOR_ID";
-
 const NONINTERACTIVE_SUBCMDS = new Set([
   "exec", "e", "review", "login", "logout", "mcp", "plugin", "mcp-server", "app-server",
   "remote-control", "app", "completion", "update", "doctor", "sandbox", "debug",

package/src/entries/pisupervisor.ts

@@ -12,7 +12,7 @@ import { claudePool, codexPaths, expandTilde, optionalEnv, paths, piPaths, type
 import { pickPiSeat, piMovers } from "../lib/pi.ts";
 import { ensurePiStoreHome, piStoreUsable } from "../lib/piauth.ts";
 import { thresholdBars, usableAt } from "../lib/picker.ts";
-import { clearPresence, livingPresences } from "../lib/presence.ts";
+import { PI_PRESENCE_PREFIX, clearPresence, livingPresences } from "../lib/presence.ts";
 import { teeObservation } from "../lib/sample.ts";
 import { countdownWait, exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, runPassthrough, SEAT_POLL_MS, SEAT_RETRY_MS } from "../lib/supervise.ts";
 import { saveTermios } from "../lib/tty.ts";
@@ -327,7 +327,7 @@ export async function runPiSupervisor(argv: string[]): Promise<number> {
   if (launch == null) return runPassthrough({ real, argv, env: childEnv, onSpawn: (p) => { child = p; } });
   const { args, pool, dirs, sid } = launch;
 
-  const id = `pi-${crypto.randomUUID()}`;
+  const id = `${PI_PRESENCE_PREFIX}${crypto.randomUUID()}`;
   const mover = piMovers[pool];
   const presenceDir = pool === "claude" ? paths.presenceDir : codexPaths.presenceDir;
   const releaseClaim = async (): Promise<void> => {

package/src/lib/codex.ts

@@ -1,17 +1,18 @@
 import { existsSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { countBy } from "es-toolkit";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import { CODEX_BIN, MAX_WRAP_DEPTH, WRAP_DEPTH_ENV, resolveRealBin, verifyRealBin } from "./claudebin.ts";
 import { codexIdentityOf, codexStoreUsable, deleteCodexStoreAuth, ensureCodexStoreHome, isCodexAccessExpiring, readCodexAuthAt, readCodexStoreAuth, writeCodexStoreAuth } from "./codexauth.ts";
 import { CodexInvalidGrantError, CodexRefreshFailedError, refreshCodexAuth } from "./codexoauth.ts";
 import { deletePiStore } from "./piauth.ts";
-import { livingPresences, seatCounts, writePresence } from "./presence.ts";
+import { PI_PRESENCE_PREFIX, livingPresences, seatCounts, writePresence } from "./presence.ts";
 import { CodexUsageReadError, codexLimitLabel, fetchCodexUsage } from "./codexusage.ts";
 import { codexSupervisorLink, ensurePathInRc, installCodexSupervisor, managedShellRcSkipLines, shellRcPath } from "./install.ts";
 import { withLock } from "./lock.ts";
 import { errorMessage, log } from "./log.ts";
-import { codexPaths, codexPool, codexSeatFromEnv } from "./paths.ts";
+import { codexPaths, codexPool, codexSeatFromEnv, optionalEnv } from "./paths.ts";
 import { isExhausted, pickBest, pickEarliestReset, thresholdBars, type PickCtx } from "./picker.ts";
 import { StoreUnusableError, type Observation, type Provider, type SampleReport, type SeatBorrow } from "./provider.ts";
 import { loadAccounts, loadConfig, pinBinOverride, saveAccounts, type Harvest } from "./state.ts";
@@ -19,6 +20,8 @@ import { restoreTermios, saveTermios } from "./tty.ts";
 import type { Account, CodexAuthJson, CodexUsage, Config } from "./types.ts";
 import { c } from "../cli/render.ts";
 
+export const CODEX_SUPERVISOR_ID_ENV = "TOKENMAXXING_CODEX_SUPERVISOR_ID";
+
 function liveId(): string | null {
   return codexSeatFromEnv(loadAccounts(codexPool).accounts.map((a) => a.id));
 }
@@ -251,7 +254,8 @@ export async function borrowCodexSeat(pid: number): Promise<SeatBorrow> {
   const granted = await withLock(codexPool.lockFile, (): SeatBorrow => {
     const ctx = codexPickCtx(now, null);
     const idx = loadAccounts(codexPool);
-    const held = livingPresences(codexPaths.presenceDir).find((p) => p.id === seatId);
+    const living = livingPresences(codexPaths.presenceDir);
+    const held = living.find((p) => p.id === seatId);
     const heldAccount = held ? (idx.accounts.find((x) => x.id === held.accountId) ?? null) : null;
     if (heldAccount) {
       if (heldAccount.needsReauth === true) {
@@ -262,11 +266,14 @@ export async function borrowCodexSeat(pid: number): Promise<SeatBorrow> {
       }
       return { store: ensureCodexStoreHome(heldAccount.id), id: heldAccount.id, reused: true };
     }
-    const present = seatCounts(codexPaths.presenceDir);
+    const parent = optionalEnv(CODEX_SUPERVISOR_ID_ENV);
+    const closed = new Set(living.filter((p) => p.id === parent || p.id.startsWith(PI_PRESENCE_PREFIX)).map((p) => p.accountId));
+    const lent = countBy(living, (p) => p.accountId);
     const usable = idx.accounts.filter(
-      (a) => a.needsReauth !== true && !isExhausted(a, ctx) && !present.has(a.id) && codexStoreUsable(a.id)
+      (a) => !closed.has(a.id) && a.needsReauth !== true && !isExhausted(a, ctx) && codexStoreUsable(a.id)
     );
-    const picked = pickBest(usable, ctx);
+    const fewest = Math.min(...usable.map((a) => lent[a.id] ?? 0));
+    const picked = pickBest(usable.filter((a) => (lent[a.id] ?? 0) === fewest), ctx);
     if (!picked) return null;
     const store = ensureCodexStoreHome(picked.id);
     writePresence({ dir: codexPaths.presenceDir, id: seatId, accountId: picked.id, pid });

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/presence.ts

@@ -7,6 +7,8 @@ import { pidExists, pidStartTime } from "./proc.ts";
 import { readJsonFile } from "./state.ts";
 import { ErrnoSchema, JsonTextSchema } from "./types.ts";
 
+export const PI_PRESENCE_PREFIX = "pi-";
+
 const PresenceSchema = z.object({
   accountId: z.string(),
   pid: z.number(),

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>;
 

package/src/main.ts

@@ -61,7 +61,7 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing rename")} [--codex | --grok | --opencode-go] <sel> <label>
   ${c.cyan("tokenmaxxing rm")} [--codex | --grok | --opencode-go] <sel>
   ${c.cyan("tokenmaxxing seat")} <pid>  lend one pooled Claude account to an unattended consumer until <pid> exits: prints the store directory to set as CLAUDE_SECURESTORAGE_CONFIG_DIR (the directory itself, as its owner, never a copy of its credential); host sessions and other borrowers share the account; exit 1 = none usable
-  ${c.cyan("tokenmaxxing seat --codex")} <pid>  borrow one pooled codex account for an unattended consumer (plugin, script): prints the CODEX_HOME to set, reserved to <pid> alone until it exits because one auth.json serves one serialized job stream; exit 1 = none usable, fall back to the ambient login
+  ${c.cyan("tokenmaxxing seat --codex")} <pid>  borrow one pooled codex account for an unattended consumer (plugin, script): prints the CODEX_HOME to set, lent to <pid> until it exits; codex sessions and other borrowers share the account, and a refresh race between them can sign it out until auth --codex runs again; exit 1 = none usable, fall back to the ambient login
   ${c.cyan("tokenmaxxing seat --opencode-go")} <pid>  lend one pooled opencode-go key to an unattended consumer until <pid> exits: prints the store directory, whose auth.json is an opencode auth file (mount it at $XDG_DATA_HOME/opencode/auth.json, then run a model such as opencode-go/mimo-v2.6-pro); other borrowers share the key; exit 1 = none usable
   ${c.cyan("tokenmaxxing serve")}      serve the CLIProxyAPI-compatible usage API on http://localhost:<hub.port> (default 8317) so a dashboard such as T3 Code's "Add a CLIProxyAPI hub" shows every pooled Claude and Codex account's quota; the management key is the contents of hub-key in the state directory
   ${c.cyan("tokenmaxxing uninstall")} [--yes]  print the targets, then remove supervisor + settings entries (refused without ${c.cyan("--yes")} when HOME is the login home)