tokenmaxxing 1.32.0 → 1.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.32.0",
+  "version": "1.33.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/entries/statusline.ts

@@ -80,11 +80,16 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
   const seatUuid =
     (ctx.liveAccount != null && ctx.accounts.accounts.some((a) => a.accountUuid === ctx.liveAccount) ? ctx.liveAccount : null) ??
     ctx.accounts.activeAccountUuid;
+  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.accountUuid === seatUuid);
+  if (seat?.enforcedUntil != null && walled(seat)) windows.push(wallSeg(seat.enforcedUntil));
+  const seatMarker = seat && walled(seat) ? paint(100)("◆") : col.green("◆");
   const active =
     windows.length > 0
-      ? `${col.green("◆")} ${windows.join(" ")}`
+      ? `${seatMarker} ${windows.join(" ")}`
       : seatUuid != null
-        ? `${col.green("◆")} ?`
+        ? `${seatMarker} ?`
         : "";
 
   const parked = sortBy(
@@ -92,7 +97,8 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
     [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, ctx.now)],
   );
   const poolSeg = (a: Account): string => {
-    const marker = a.needsReauth ? col.red("✗") : col.cyan("◇");
+    const marker = a.needsReauth ? col.red("✗") : walled(a) ? paint(100)("◇") : col.cyan("◇");
+    if (a.enforcedUntil != null && walled(a)) return `${marker} ${wallSeg(a.enforcedUntil)}`;
     const week = a.lastUsage?.sevenDay;
     if (week == null) return `${marker} ?`;
     const weekUsed = used(week);

package/src/entries/stopfailurehook.ts

@@ -3,14 +3,13 @@ import { z } from "zod";
 import { paths } from "../lib/paths.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
 import { readOAuthAccount } from "../lib/claudejson.ts";
-import { enforcedWindowMs, evaluateAndMaybeSwap, postSwapProof, recordEnforcedLimit } from "../lib/decide.ts";
-import { loadConfig, loadLastSwapAt } from "../lib/state.ts";
+import { evaluateAndMaybeSwap } from "../lib/decide.ts";
+import { withLock } from "../lib/lock.ts";
+import { POST_SWAP_COOLDOWN_MS, loadConfig, loadLastSwapAt } from "../lib/state.ts";
 import { classifyEnforcedLimit, findEnforcedRow, parseErrorBody, readTranscriptTail } from "../lib/usage.ts";
 import { RespawnMarkerSchema, type EnforcedLimit } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
 
-export const RETRIGGER_PROMPT = "Continue where the previous turn left off; it was interrupted by a usage limit and tokenmaxxing switched accounts.";
-
 const StopFailureStdin = z.looseObject({
   session_id: z.uuid().optional().catch(undefined),
   transcript_path: z.string().optional().catch(undefined),
@@ -30,7 +29,8 @@ async function readStdin(): Promise<string> {
 export async function runStopFailureHook(): Promise<number> {
   if (process.env.TOKENMAXXING_PROBE) return 0;
 
-  const account = readOAuthAccount()?.accountUuid ?? null;
+  const entry = await withLock(paths.lockFile, () => ({ swapClock: loadLastSwapAt(), account: readOAuthAccount()?.accountUuid ?? null }));
+  const account = entry.account;
   const now = Date.now();
   const raw = await readStdin();
   const parsed = StopFailureStdin.safeParse((() => { try { return JSON.parse(raw); } catch { return {}; } })());
@@ -44,29 +44,27 @@ export async function runStopFailureHook(): Promise<number> {
   const canPause = process.env.TOKENMAXXING_SUPERVISED === "1" && pinnedSid != null && mainLoop;
 
   try {
+    const lastSwapAt = loadLastSwapAt();
+    if (lastSwapAt != null && lastSwapAt === entry.swapClock && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
+      log("stopfailure.cooldown", { sinceSwapMs: now - lastSwapAt });
+      return 0;
+    }
     const cfg = loadConfig();
-    const found = stdin.transcript_path
+    const row = stdin.transcript_path
       ? findEnforcedRow({ rows: readTranscriptTail(stdin.transcript_path), lastAssistantMessage: stdin.last_assistant_message, now })
       : null;
-    const limit = found ? classifyEnforcedLimit(found.row, cfg.policy.switchModels) : null;
+    const limit = row ? classifyEnforcedLimit(row, cfg.policy.switchModels) : null;
 
     let enforced: EnforcedLimit | null = null;
-    if (limit && found && account) {
-      if (postSwapProof({ swapAt: loadLastSwapAt(), launchedAt, errorAt: found.errorAt, now })) {
-        const stamp = await recordEnforcedLimit({ limit, account, now });
-        log("stopfailure.enforced", { kind: limit.kind, family: limit.kind === "model" ? limit.family : undefined, outcome: stamp.outcome, resetsAt: stamp.resetsAt, subagent: !mainLoop });
-        if (stamp.outcome !== "account-moved") {
-          enforced = { account, family: limit.kind === "model" ? limit.family : null, resetsAt: stamp.resetsAt, windowMs: enforcedWindowMs(limit) };
-        }
-      } else {
-        log("stopfailure.unproven", { kind: limit.kind });
-      }
+    if (limit && account) {
+      enforced = { account, kind: limit.kind, family: limit.kind === "model" ? limit.family : null, resetsAt: limit.resetsAt, blind: !mainLoop && limit.kind !== "model" };
+      log("stopfailure.enforced", { kind: limit.kind, family: enforced.family ?? undefined, resetsAt: limit.resetsAt, subagent: !mainLoop });
     } else {
       log("stopfailure.unclassified", {
-        row: found != null,
-        type: found?.row.quotaLimits?.rateLimitType,
-        transient: found?.row.apiErrorIsTransient,
-        body: found ? parseErrorBody(found.row.errorDetails)?.error?.type : undefined,
+        row: row != null,
+        type: row?.quotaLimits?.rateLimitType,
+        transient: row?.apiErrorIsTransient,
+        body: row ? parseErrorBody(row.errorDetails)?.error?.type : undefined,
       });
     }
 
@@ -78,7 +76,6 @@ export async function runStopFailureHook(): Promise<number> {
         ts: Date.now(),
         waitUntil: decision.waitUntil ?? now,
         sessionId: stdinSid ?? pinnedSid,
-        prompt: RETRIGGER_PROMPT,
         ...(launchedAt != null ? { launchedAt } : {}),
       });
       writeFileAtomic(marker, JSON.stringify(payload));

package/src/entries/supervisor.ts

@@ -292,7 +292,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
         if (await countdownWait(m.account, m.waitUntil)) overriddenUntil = m.waitUntil;
       } else process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: switched to ${m.account} - resuming...\x1b[0m\n`);
       saveSessionFlags(m.sessionId, persistable, process.cwd());
-      launchArgs = ["--resume", m.sessionId, ...persistable, ...(m.prompt ? ["--", m.prompt] : [])];
+      launchArgs = ["--resume", m.sessionId, ...persistable];
       continue;
     }
     log("supervisor.exit", { sid, respawns, code: child.exitCode, signal: child.signalCode });

package/src/lib/decide.ts

@@ -2,11 +2,11 @@ import { maxBy } from "es-toolkit";
 import { z } from "zod";
 import { withLock } from "./lock.ts";
 import { paths } from "./paths.ts";
-import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsage, loadUsageSnapshot, saveAccounts, saveDepletedWait, writeUsage } from "./state.ts";
+import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsageSnapshot, saveAccounts, saveDepletedWait, writeUsage } from "./state.ts";
 import { readOAuthAccount } from "./claudejson.ts";
 import { isSkippableSwapError, performSwap } from "./swap.ts";
-import { nextWeeklyReset, pickBest, pickEarliestReset, thresholdBars, usableAt } from "./picker.ts";
-import { familyTokens, gatedFamilies, keepRows, probeUsage, type EnforcedClass } from "./usage.ts";
+import { isExhausted, nextWeeklyReset, pickBest, pickEarliestReset, thresholdBars, usableAt } from "./picker.ts";
+import { familyTokens, gatedFamilies, keepRows, probeUsage } from "./usage.ts";
 import { log } from "./log.ts";
 import { AccountSchema, UsageStateSchema, type Account, type Config, type EnforcedLimit, type Thresholds, type UsageState, type UsageWindow } from "./types.ts";
 
@@ -40,7 +40,9 @@ function capForFamily(account: Account, family: string, now: number): UsageWindo
 }
 
 function isOver(u: UsageState | null, account: Account | undefined, bars: Thresholds, cfg: Config, now: number): boolean {
-  if (!u || !account || u.account !== account.accountUuid) return false;
+  if (!account) return false;
+  if (account.enforcedUntil != null && account.enforcedUntil > now) return true;
+  if (!u || u.account !== account.accountUuid) return false;
   if (
     liveUsed({ window: u.fiveHour, windowMs: FIVE_HOURS_MS, sampledAt: u.ts, now }) >= bars.session ||
     liveUsed({ window: u.sevenDay, windowMs: WEEK_MS, sampledAt: u.ts, now }) >= bars.weekly
@@ -75,14 +77,15 @@ function freshest(u: UsageState | null, uAt: number | null, account: Account | u
   return { ...u, ts: uAt };
 }
 
-async function loadFreshSnapshots(cfg: Config, account: string | null, now: number): Promise<Snapshots> {
+async function loadFreshSnapshots(cfg: Config, account: string | null, now: number, probe: boolean): Promise<Snapshots> {
   const snap = loadUsageSnapshot();
   let u = snap?.state ?? null;
   let uAt = snap?.at ?? null;
   const ttl = cfg.policy.usagePollTtlMs;
   const stored = loadAccounts().accounts.find((a) => a.accountUuid === account);
   const probeAttempted = stored?.lastProbeAt != null && now - stored.lastProbeAt <= ttl;
-  if (account && stored && !probeAttempted && (!usageFresh(u, uAt, account, ttl, now) || needsPerModel(u, cfg))) {
+  const walled = stored?.enforcedUntil != null && stored.enforcedUntil > now;
+  if (probe && account && stored && !walled && !probeAttempted && (!usageFresh(u, uAt, account, ttl, now) || needsPerModel(u, cfg))) {
     const startedAt = Date.now();
     const full = await probeUsage();
     const ts = Date.now();
@@ -121,21 +124,20 @@ async function loadFreshSnapshots(cfg: Config, account: string | null, now: numb
 
 export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = false, enforced: EnforcedLimit | null = null): Promise<SwapDecision> {
   const activeAccount = readOAuthAccount()?.accountUuid ?? null;
-  const enforced0 = enforced && enforced.account === activeAccount ? enforced : null;
 
   const lastSwapAt = loadLastSwapAt();
-  if (!enforced0 && lastSwapAt != null && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
+  if (!enforced && lastSwapAt != null && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
     return depletedReplay(now) ?? { swapped: false, account: null, reason: "post-swap-cooldown" };
   }
 
   const cfg = loadConfig();
   const bars = thresholdBars(cfg);
 
-  const { u: teeUsage, uAt } = await loadFreshSnapshots(cfg, activeAccount, now);
+  const { u: teeUsage, uAt } = await loadFreshSnapshots(cfg, activeAccount, now, enforced == null);
   const stored = loadAccounts().accounts.find((a) => a.accountUuid === activeAccount);
   const usage = freshest(teeUsage, uAt, stored);
 
-  if (!enforced0 && !isOver(usage, stored, bars, cfg, now)) {
+  if (!enforced && !isOver(usage, stored, bars, cfg, now)) {
     const measured = usage != null && activeAccount != null && usage.account === activeAccount;
     if (!measured) {
       const replay = depletedReplay(now);
@@ -147,11 +149,20 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
   return withLock(paths.lockFile, async () => {
     const idx = loadAccounts();
     const account2 = readOAuthAccount()?.accountUuid ?? null;
-    const enforced2 = enforced0 && enforced0.account === account2 ? enforced0 : null;
     const tee = loadUsageSnapshot();
     const active = account2 ? idx.accounts.find((a) => a.accountUuid === account2) : undefined;
     const u2 = tee ? freshest(tee.state, tee.at, active) : usage;
 
+    const origin = enforced ? idx.accounts.find((a) => a.accountUuid === enforced.account) : undefined;
+    const prior = origin?.enforcedUntil != null && origin.enforcedUntil > now;
+    if (enforced && origin) {
+      origin.enforcedUntil = Math.max(origin.enforcedUntil ?? 0, enforcedWall(enforced, origin, now));
+      origin.lastProbeAt = now;
+      saveAccounts(idx);
+      log("usage.enforced_limit", { kind: enforced.kind, family: enforced.family ?? undefined, resetsAt: origin.enforcedUntil, blind: prior || enforced.blind, live: origin === active });
+    }
+    const enforced2 = enforced && origin && origin === active ? enforced : null;
+
     if (account2 != null && !active) {
       return { swapped: false, account: null, reason: "live-credential-not-in-pool" };
     }
@@ -162,10 +173,14 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
       saveAccounts(idx);
     }
 
-    const gated = gatedFamilies(u2?.model ?? null, cfg.policy.switchModels);
-    const switchFamilies = enforced2?.family && !gated.includes(enforced2.family) ? [...gated, enforced2.family] : gated;
+    const walled = active?.enforcedUntil != null && active.enforcedUntil > now;
+    const blindScreen = (enforced != null && (prior || enforced.blind)) || (walled && !enforced2);
+    const gated = blindScreen ? cfg.policy.switchModels : gatedFamilies(u2?.model ?? null, cfg.policy.switchModels);
+    const family = enforced?.family ?? null;
+    const switchFamilies = family != null && !gated.includes(family) ? [...gated, family] : gated;
 
-    if (!enforced2 && !isOver(u2, active, bars, cfg, now)) {
+    const seatExhausted = active != null && isExhausted(active, { now, thresholds: bars, currentAccountUuid: account2, switchFamilies });
+    if (!enforced2 && !isOver(u2, active, bars, cfg, now) && !(enforced && seatExhausted)) {
       return depletedReplay(now) ?? { swapped: false, account: null, reason: "raced-already-swapped" };
     }
 
@@ -201,8 +216,7 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
       const fresh = loadAccounts();
       const current = seatOf(fresh);
       const ctx = { now, thresholds: bars, currentAccountUuid: current?.accountUuid ?? null, switchFamilies };
-      const enforcedUntil = enforced2 && current && current.accountUuid === enforced2.account ? (enforced2.resetsAt ?? now + enforced2.windowMs) : 0;
-      const currentAt = current ? Math.max(usableAt(current, ctx), enforcedUntil) : Number.POSITIVE_INFINITY;
+      const currentAt = current ? usableAt(current, ctx) : Number.POSITIVE_INFINITY;
       const other = pickEarliestReset(usable(fresh.accounts), ctx);
 
       let target: Account | null = null;
@@ -245,63 +259,19 @@ function depletedReplay(now: number): SwapDecision | null {
   return { swapped: false, account, reason: "depleted-wait", waitUntil: rec.waitUntil };
 }
 
-export function enforcedWindowMs(limit: EnforcedClass): number {
-  return limit.kind === "session" ? FIVE_HOURS_MS : WEEK_MS;
-}
-
-export function postSwapProof(input: { swapAt: number | null; launchedAt: number | null; errorAt: number | null; now: number }): boolean {
-  const { swapAt, launchedAt, errorAt, now } = input;
-  if (swapAt == null) return true;
-  if (launchedAt != null && launchedAt > swapAt) return true;
-  return (errorAt ?? now) - swapAt >= POST_SWAP_COOLDOWN_MS;
-}
-
-const StampSchema = z.object({ outcome: z.enum(["stamped", "account-moved", "no-carrier"]), resetsAt: z.number().nullable() });
-export type Stamp = z.infer<typeof StampSchema>;
-
-export async function recordEnforcedLimit(input: { limit: EnforcedClass; account: string; now: number }): Promise<Stamp> {
-  const { limit, account: accountUuid, now } = input;
-  return withLock(paths.lockFile, () => {
-    if ((readOAuthAccount()?.accountUuid ?? null) !== accountUuid) return { outcome: "account-moved", resetsAt: limit.resetsAt };
-    const prior = loadUsage();
-    const priorSame = prior && prior.account === accountUuid ? prior : null;
-    const idx = loadAccounts();
-    const account = idx.accounts.find((a) => a.accountUuid === accountUuid);
-    if (limit.kind === "model") {
-      const rows = account?.lastUsage?.perModel ?? {};
-      const knownReset = Object.entries(rows).filter(([k]) => familyTokens(k).includes(limit.family)).map(([, w]) => w.resetsAt).find((r): r is number => r != null) ?? null;
-      const weeklyReset = priorSame?.sevenDay.resetsAt ?? account?.lastUsage?.sevenDay.resetsAt ?? null;
-      const resetsAt = limit.resetsAt ?? nextWeeklyReset(knownReset ?? weeklyReset, now);
-      if (!account) return { outcome: "no-carrier", resetsAt };
-      if (account.lastUsage) {
-        const others = Object.fromEntries(Object.entries(rows).filter(([k]) => !familyTokens(k).includes(limit.family)));
-        account.lastUsage = { ...account.lastUsage, perModel: { ...others, [limit.family]: { usedPercentage: 100, resetsAt } }, ...(resetsAt == null ? { rowsAt: now } : {}) };
-      } else {
-        account.enforcedUntil = resetsAt ?? now + WEEK_MS;
-      }
-      account.lastProbeAt = now;
-      saveAccounts(idx);
-      log("usage.enforced_limit", { kind: limit.kind, family: limit.family, resetsAt });
-      return { outcome: "stamped", resetsAt };
-    }
-    if (account) {
-      account.lastProbeAt = now;
-      if (limit.resetsAt != null) account.enforcedUntil = limit.resetsAt;
-      saveAccounts(idx);
-    }
-    const carrier = priorSame ?? (account?.lastUsage ? { ...account.lastUsage, model: null } : null);
-    if (!carrier) return { outcome: "no-carrier", resetsAt: limit.resetsAt };
-    const window: UsageWindow = { usedPercentage: 100, resetsAt: limit.resetsAt };
-    writeUsage({
-      ...(priorSame ?? {}),
-      ...(priorSame == null && account?.lastUsageAt != null ? { sampledAt: account.lastUsageAt } : {}),
-      fiveHour: limit.kind === "session" ? window : carrier.fiveHour,
-      sevenDay: limit.kind === "weekly" ? window : carrier.sevenDay,
-      account: accountUuid,
-      ts: now,
-      model: carrier.model,
-    }, { stamp: true });
-    log("usage.enforced_limit", { kind: limit.kind, resetsAt: limit.resetsAt });
-    return { outcome: "stamped", resetsAt: limit.resetsAt };
-  });
+function enforcedWall(limit: EnforcedLimit, account: Account, now: number): number {
+  const cached = account.lastUsage;
+  const { family } = limit;
+  const familyReset =
+    family == null
+      ? null
+      : Object.entries(cached?.perModel ?? {})
+          .filter(([k]) => familyTokens(k).includes(family))
+          .map(([, w]) => w.resetsAt)
+          .find((r): r is number => r != null) ?? null;
+  const cachedReset =
+    limit.kind === "session"
+      ? cached?.fiveHour.resetsAt != null && cached.fiveHour.resetsAt > now ? cached.fiveHour.resetsAt : null
+      : nextWeeklyReset(familyReset ?? cached?.sevenDay.resetsAt ?? null, now);
+  return limit.resetsAt ?? cachedReset ?? now + (limit.kind === "session" ? FIVE_HOURS_MS : WEEK_MS);
 }

package/src/lib/types.ts

@@ -82,9 +82,10 @@ export type AccountsIndex = z.infer<typeof AccountsIndexSchema>;
 
 export const EnforcedLimitSchema = z.object({
   account: z.string(),
+  kind: z.enum(["session", "weekly", "model"]),
   family: z.string().nullable(),
   resetsAt: z.number().nullable(),
-  windowMs: z.number(),
+  blind: z.boolean(),
 });
 export type EnforcedLimit = z.infer<typeof EnforcedLimitSchema>;
 
@@ -128,7 +129,6 @@ export const RespawnMarkerSchema = z.object({
   ts: z.number(),
   waitUntil: z.number(),
   sessionId: z.string(),
-  prompt: z.string().optional(),
   launchedAt: z.number().optional(),
 });
 

package/src/lib/usage.ts

@@ -169,13 +169,7 @@ export function transcriptRowText(row: TranscriptRow): string {
 
 const ROW_RECENCY_MS = 60_000;
 
-const EnforcedRowSchema = z.object({
-  row: TranscriptRowSchema,
-  errorAt: z.number().nullable(),
-});
-export type EnforcedRow = z.infer<typeof EnforcedRowSchema>;
-
-export function findEnforcedRow(input: { rows: TranscriptRow[]; lastAssistantMessage: string | undefined; now: number }): EnforcedRow | null {
+export function findEnforcedRow(input: { rows: TranscriptRow[]; lastAssistantMessage: string | undefined; now: number }): TranscriptRow | null {
   const { rows, lastAssistantMessage, now } = input;
   for (let i = rows.length - 1; i >= 0; i--) {
     const row = rows[i]!;
@@ -183,8 +177,7 @@ export function findEnforcedRow(input: { rows: TranscriptRow[]; lastAssistantMes
     const ts = row.timestamp ? Date.parse(row.timestamp) : Number.NaN;
     const byContent = lastAssistantMessage != null && lastAssistantMessage !== "" && transcriptRowText(row) === lastAssistantMessage;
     const byRecency = Number.isFinite(ts) && Math.abs(now - ts) <= ROW_RECENCY_MS;
-    if (!byContent && !byRecency) continue;
-    return { row, errorAt: Number.isFinite(ts) ? ts : null };
+    if (byContent || byRecency) return row;
   }
   return null;
 }