tokenmaxxing 1.34.0 → 1.38.0

package/src/entries/codexstophook.ts

@@ -1,18 +1,17 @@
 import { join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { z } from "zod";
-import { codexPaths } from "../lib/paths.ts";
+import { codexPaths, codexPool } from "../lib/paths.ts";
 import { withLock } from "../lib/lock.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
-import { evaluateAndMaybeSwapCodex } from "../lib/codexdecide.ts";
-import { isCodexExhausted } from "../lib/codexpick.ts";
+import { codex, codexPickCtx, reconcileSiblings } from "../lib/codex.ts";
+import { liveCodexAccountId } from "../lib/codexauth.ts";
+import { evaluateAndMaybeSwap } from "../lib/decide.ts";
+import { isExhausted } from "../lib/picker.ts";
 import { livingCodexPresences } from "../lib/codexpresence.ts";
-import { liveCodexAccountId } from "../lib/codexsample.ts";
-import { loadCodexAccounts } from "../lib/codexstate.ts";
-import { loadConfig } from "../lib/state.ts";
-import { thresholdBars } from "../lib/picker.ts";
+import { loadAccounts } from "../lib/state.ts";
 import { CODEX_SUPERVISOR_ID_ENV } from "./codexsupervisor.ts";
-import { CodexReconcileMarkerSchema, CodexRespawnMarkerSchema, CodexStopStdinSchema, type CodexAccount } from "../lib/types.ts";
+import { CodexReconcileMarkerSchema, CodexRespawnMarkerSchema, CodexStopStdinSchema, JsonTextSchema } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
 
 const SupervisorIdSchema = z.string().min(1).optional().catch(undefined);
@@ -20,7 +19,7 @@ const SupervisorIdSchema = z.string().min(1).optional().catch(undefined);
 async function promoteReconcile(input: { supervisorId: string; sessionId: string | null }): Promise<boolean> {
   const markerPath = join(codexPaths.reconcileDir, input.supervisorId);
   if (!existsSync(markerPath)) return false;
-  return withLock(codexPaths.lockFile, async () => promoteReconcileLocked(input));
+  return withLock(codexPool.lockFile, async () => promoteReconcileLocked(input));
 }
 
 function promoteReconcileLocked(input: { supervisorId: string; sessionId: string | null }): boolean {
@@ -51,12 +50,8 @@ function promoteReconcileLocked(input: { supervisorId: string; sessionId: string
     return false;
   }
   const now = Date.now();
-  const bars = thresholdBars(loadConfig());
-  const index = loadCodexAccounts();
-  const unusable = (account: CodexAccount): boolean =>
-    account.needsReauth === true || isCodexExhausted({ account, thresholds: bars, now });
-  const liveAccount = index.accounts.find((a) => a.accountId === liveId);
-  if (!liveAccount || unusable(liveAccount)) {
+  const liveAccount = loadAccounts(codexPool).accounts.find((a) => a.id === liveId);
+  if (!liveAccount || liveAccount.needsReauth === true || isExhausted(liveAccount, codexPickCtx(now, liveId))) {
     rmSync(markerPath, { force: true });
     log("codexstop.reconcile_blocked_target", {});
     return false;
@@ -75,6 +70,14 @@ function promoteReconcileLocked(input: { supervisorId: string; sessionId: string
   return true;
 }
 
+async function sweepSiblings(now: number): Promise<void> {
+  try {
+    await withLock(codexPool.lockFile, () => reconcileSiblings(now));
+  } catch (e) {
+    log("codexstop.resweep_failed", { err: e instanceof Error ? e.message : String(e) });
+  }
+}
+
 async function readStdin(): Promise<string> {
   const chunks: Uint8Array[] = [];
   for await (const chunk of Bun.stdin.stream()) chunks.push(chunk);
@@ -82,13 +85,7 @@ async function readStdin(): Promise<string> {
 }
 
 export async function handleCodexStop(input: { rawStdin: string }): Promise<void> {
-  const parsed = CodexStopStdinSchema.safeParse((() => {
-    try {
-      return JSON.parse(input.rawStdin);
-    } catch {
-      return {};
-    }
-  })());
+  const parsed = CodexStopStdinSchema.safeParse(JsonTextSchema.safeParse(input.rawStdin).data);
   const sessionId = parsed.success ? (parsed.data.session_id ?? null) : null;
 
   try {
@@ -98,8 +95,11 @@ export async function handleCodexStop(input: { rawStdin: string }): Promise<void
       return;
     }
     if (await promoteReconcile({ supervisorId, sessionId })) return;
-    const decision = await evaluateAndMaybeSwapCodex({});
+    const now = Date.now();
+    await withLock(codexPool.lockFile, () => reconcileSiblings(now));
+    const decision = await evaluateAndMaybeSwap(codex, now);
     if (decision.swapped && decision.account) {
+      await sweepSiblings(now);
       mkdirSync(codexPaths.respawnDir, { recursive: true });
       const payload = CodexRespawnMarkerSchema.parse({
         account: decision.account.label,

package/src/entries/codexsupervisor.ts

@@ -1,12 +1,12 @@
 import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
-import { codexPaths, paths } from "../lib/paths.ts";
+import { codexPaths, codexPool, paths } from "../lib/paths.ts";
 import { withLock } from "../lib/lock.ts";
 import { LOOP_DIAGNOSIS, MAX_WRAP_DEPTH, UNMANAGED_ENV, WRAP_DEPTH_ENV, WRAP_RATE_MAX, WRAP_RATE_WINDOW_MS, wrapDepth, wrapperEntryRateTripped } from "../lib/claudebin.ts";
 import { resolveRealCodex } from "../lib/codexbin.ts";
 import { clearCodexPresence, writeCodexPresence } from "../lib/codexpresence.ts";
-import { liveCodexAccountId } from "../lib/codexsample.ts";
+import { liveCodexAccountId } from "../lib/codexauth.ts";
 import { saveTermios, restoreTermios } from "../lib/tty.ts";
 import { CodexRespawnMarkerSchema } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
@@ -95,7 +95,7 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
     if (existsSync(marker)) rmSync(marker, { force: true });
     log("codexsupervisor.launch", { supervisorId: supervisorId.slice(0, 8), respawns, args: launchArgs.join(" ") });
 
-    const child = await withLock(codexPaths.lockFile, async () => {
+    const child = await withLock(codexPool.lockFile, async () => {
       const spawnAccountId = liveCodexAccountId();
       const spawned = Bun.spawn([real, ...launchArgs], {
         stdin: "inherit",

package/src/entries/sessionstart.ts

@@ -1,6 +1,8 @@
 import { z } from "zod";
+import { claude } from "../lib/claude.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
 import { log } from "../lib/log.ts";
+import { JsonTextSchema } from "../lib/types.ts";
 
 const SessionStartStdin = z.looseObject({
   source: z.string().optional(),
@@ -17,13 +19,13 @@ export async function runSessionStart(): Promise<number> {
   if (process.env.TOKENMAXXING_PROBE) return 0;
 
   const raw = await readStdin();
-  const parsed = SessionStartStdin.safeParse((() => { try { return JSON.parse(raw); } catch { return {}; } })());
+  const parsed = SessionStartStdin.safeParse(JsonTextSchema.safeParse(raw).data);
   const source = parsed.success ? parsed.data.source : undefined;
 
   try {
-    const decision = await evaluateAndMaybeSwap();
+    const decision = await evaluateAndMaybeSwap(claude);
     if (decision.swapped && decision.account) {
-      log("sessionstart.swapped", { source, account: decision.account.accountUuid.slice(0, 8) });
+      log("sessionstart.swapped", { source, account: decision.account.id.slice(0, 8) });
     }
   } catch (e) {
     log("sessionstart.error", { err: e instanceof Error ? e.message : String(e) });

package/src/entries/statusline.ts

@@ -1,16 +1,18 @@
 import { sortBy } from "es-toolkit";
 import { z } from "zod";
 import { readOAuthAccount } from "../lib/claudejson.ts";
+import { claudePool } from "../lib/paths.ts";
 import { loadAccounts, loadConfig, loadLastSwapAt, writeUsage } from "../lib/state.ts";
 import { familyTokens, matchedFamily, parseStatusLineStdin, parseStatusLineModel } from "../lib/usage.ts";
-import { earliestReset, weeklyExpiry } from "../lib/picker.ts";
+import { earliestReset, limitWindows, weeklyExpiry, weeklyWindow } from "../lib/picker.ts";
 import { worktreeName } from "../lib/worktree.ts";
 import { makeColors, makeUsagePaint } from "../cli/render.ts";
 import { fmtResetShort } from "../lib/usage.ts";
 import {
   AccountsIndexSchema,
+  JsonTextSchema,
   StatusLineStdinSchema,
-  UsageWindowSchema,
+  WindowSchema,
   type Account,
   type UsageState,
   type UsageWindow,
@@ -20,7 +22,7 @@ const ADOPTION_GRACE_MS = 45_000;
 
 const RenderCtxSchema = z.object({
   accounts: AccountsIndexSchema,
-  perModel: z.record(z.string(), UsageWindowSchema),
+  perModel: z.record(z.string(), WindowSchema),
   switchModels: z.array(z.string()),
   worktree: z.string().nullable(),
   liveAccount: z.string().nullable(),
@@ -78,11 +80,11 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
     windows.push(seg("", wins.sevenDay, wins.sevenDay.resetsAt));
   }
   const seatUuid =
-    (ctx.liveAccount != null && ctx.accounts.accounts.some((a) => a.accountUuid === ctx.liveAccount) ? ctx.liveAccount : null) ??
-    ctx.accounts.activeAccountUuid;
+    (ctx.liveAccount != null && ctx.accounts.accounts.some((a) => a.id === ctx.liveAccount) ? ctx.liveAccount : null) ??
+    ctx.accounts.activeId;
   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);
+  const seat = ctx.accounts.accounts.find((a) => a.id === seatUuid);
   if (seat?.enforcedUntil != null && walled(seat)) windows.push(wallSeg(seat.enforcedUntil));
   const seatMarker = seat && walled(seat) ? paint(100)("◆") : col.green("◆");
   const active =
@@ -93,20 +95,20 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
         : "";
 
   const parked = sortBy(
-    ctx.accounts.accounts.filter((a) => a.accountUuid !== seatUuid),
+    ctx.accounts.accounts.filter((a) => a.id !== seatUuid),
     [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, ctx.now)],
   );
   const poolSeg = (a: Account): string => {
     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;
+    const week = weeklyWindow(a);
     if (week == null) return `${marker} ?`;
     const weekUsed = used(week);
     if (Math.round(weekUsed) <= 0) return `${marker} ${paint(0)("full")}`;
 
     const parts: string[] = [];
-    for (const [name, w] of Object.entries(a.lastUsage?.perModel ?? {})) {
-      if (used(w) > weekUsed) parts.push(seg(initial(name), w, null));
+    for (const w of limitWindows(a)) {
+      if (used(w) > weekUsed) parts.push(seg(initial(w.name ?? ""), w, null));
     }
     const expiry = weeklyExpiry(a, ctx.now);
     parts.push(seg("", week, Number.isFinite(expiry) ? expiry : null));
@@ -117,19 +119,14 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
 }
 
 export async function runStatusline(): Promise<number> {
-  const raw = await readStdin();
-  let obj: unknown = null;
-  try {
-    obj = JSON.parse(raw);
-  } catch {
-  }
+  const obj = JsonTextSchema.safeParse(await readStdin()).data ?? null;
   const now = Date.now();
 
   let account: string | null = null;
   try {
     account = readOAuthAccount()?.accountUuid ?? null;
     const windows = obj == null ? null : parseStatusLineStdin(obj);
-    const lastSwapAt = loadLastSwapAt();
+    const lastSwapAt = loadLastSwapAt(claudePool);
     if (windows && (lastSwapAt == null || now - lastSwapAt >= ADOPTION_GRACE_MS)) {
       const state: UsageState = { fiveHour: windows.fiveHour, sevenDay: windows.sevenDay, account, ts: now, model: parseStatusLineModel(obj) };
       writeUsage(state);
@@ -140,13 +137,14 @@ export async function runStatusline(): Promise<number> {
   let line: string;
   try {
     const cfg = loadConfig();
-    const accounts = loadAccounts();
+    const accounts = loadAccounts(claudePool);
     const stdin = StatusLineStdinSchema.safeParse(obj);
     const dir = stdin.success ? (stdin.data.workspace?.current_dir ?? stdin.data.workspace?.project_dir ?? null) : null;
     const colorterm = z.string().optional().parse(process.env.COLORTERM);
+    const live = accounts.accounts.find((a) => a.id === account);
     const ctx: RenderCtx = {
       accounts,
-      perModel: accounts.accounts.find((a) => a.accountUuid === account)?.lastUsage?.perModel ?? {},
+      perModel: Object.fromEntries((live ? limitWindows(live) : []).map((w) => [w.name ?? "", w])),
       switchModels: cfg.policy.switchModels,
       worktree: dir == null ? null : worktreeName(dir),
       liveAccount: account,

package/src/entries/stopfailurehook.ts

@@ -2,12 +2,14 @@ import { join } from "node:path";
 import { z } from "zod";
 import { paths } from "../lib/paths.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
+import { claude } from "../lib/claude.ts";
 import { readOAuthAccount } from "../lib/claudejson.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
 import { withLock } from "../lib/lock.ts";
+import { claudePool } from "../lib/paths.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 { JsonTextSchema, RespawnMarkerSchema, type EnforcedLimit } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
 
 const StopFailureStdin = z.looseObject({
@@ -29,11 +31,11 @@ async function readStdin(): Promise<string> {
 export async function runStopFailureHook(): Promise<number> {
   if (process.env.TOKENMAXXING_PROBE) return 0;
 
-  const entry = await withLock(paths.lockFile, () => ({ swapClock: loadLastSwapAt(), account: readOAuthAccount()?.accountUuid ?? null }));
+  const entry = await withLock(claudePool.lockFile, () => ({ swapClock: loadLastSwapAt(claudePool), 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 {}; } })());
+  const parsed = StopFailureStdin.safeParse(JsonTextSchema.safeParse(raw).data);
   const stdin = parsed.success ? parsed.data : {};
   if (stdin.error !== undefined && stdin.error !== "rate_limit") return 0;
 
@@ -44,7 +46,7 @@ export async function runStopFailureHook(): Promise<number> {
   const canPause = process.env.TOKENMAXXING_SUPERVISED === "1" && pinnedSid != null && mainLoop;
 
   try {
-    const lastSwapAt = loadLastSwapAt();
+    const lastSwapAt = loadLastSwapAt(claudePool);
     if (lastSwapAt != null && lastSwapAt === entry.swapClock && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
       log("stopfailure.cooldown", { sinceSwapMs: now - lastSwapAt });
       return 0;
@@ -68,7 +70,7 @@ export async function runStopFailureHook(): Promise<number> {
       });
     }
 
-    const decision = await evaluateAndMaybeSwap(now, canPause && enforced != null, enforced);
+    const decision = await evaluateAndMaybeSwap(claude, now, canPause && enforced != null, enforced);
     if (enforced && canPause && pinnedSid && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
       const marker = join(paths.respawnDir, pinnedSid);
       const payload = RespawnMarkerSchema.parse({
@@ -79,9 +81,9 @@ export async function runStopFailureHook(): Promise<number> {
         ...(launchedAt != null ? { launchedAt } : {}),
       });
       writeFileAtomic(marker, JSON.stringify(payload));
-      log("stopfailure.marker", { session: (stdinSid ?? pinnedSid).slice(0, 8), account: decision.account.accountUuid.slice(0, 8), waitUntil: payload.waitUntil });
+      log("stopfailure.marker", { session: (stdinSid ?? pinnedSid).slice(0, 8), account: decision.account.id.slice(0, 8), waitUntil: payload.waitUntil });
     } else {
-      log("stopfailure.decision", { reason: decision.reason, swapped: decision.swapped, account: decision.account?.accountUuid.slice(0, 8), waitUntil: decision.waitUntil });
+      log("stopfailure.decision", { reason: decision.reason, swapped: decision.swapped, account: decision.account?.id.slice(0, 8), waitUntil: decision.waitUntil });
     }
   } catch (e) {
     log("stopfailure.error", { err: e instanceof Error ? e.message : String(e) });

package/src/entries/stophook.ts

@@ -2,8 +2,9 @@ import { join } from "node:path";
 import { z } from "zod";
 import { paths } from "../lib/paths.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
+import { claude } from "../lib/claude.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
-import { RespawnMarkerSchema } from "../lib/types.ts";
+import { JsonTextSchema, RespawnMarkerSchema } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
 
 const StopStdin = z.looseObject({ session_id: z.uuid().optional().catch(undefined) });
@@ -18,15 +19,15 @@ export async function runStopHook(): Promise<number> {
   if (process.env.TOKENMAXXING_PROBE) return 0;
 
   const raw = await readStdin();
-  const parsed = StopStdin.safeParse((() => { try { return JSON.parse(raw); } catch { return {}; } })());
+  const parsed = StopStdin.safeParse(JsonTextSchema.safeParse(raw).data);
   const stdinSid = parsed.success ? parsed.data.session_id : undefined;
   const pinnedSid = process.env.TOKENMAXXING_SESSION_ID;
 
   try {
     const canPause = process.env.TOKENMAXXING_SUPERVISED === "1" && pinnedSid != null;
-    const decision = await evaluateAndMaybeSwap(Date.now(), canPause);
+    const decision = await evaluateAndMaybeSwap(claude, Date.now(), canPause);
     if (decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
-      log(decision.swapped ? "stop.swapped" : "stop.wait", { account: decision.account.accountUuid.slice(0, 8), waitUntil: decision.waitUntil });
+      log(decision.swapped ? "stop.swapped" : "stop.wait", { account: decision.account.id.slice(0, 8), waitUntil: decision.waitUntil });
       if (decision.waitUntil !== undefined && canPause && pinnedSid) {
         const marker = join(paths.respawnDir, pinnedSid);
         const launchedAt = z.coerce.number().finite().optional().catch(undefined).parse(process.env.TOKENMAXXING_LAUNCHED_AT);

package/src/entries/subagentstatusline.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { makeColors, makeUsagePaint } from "../cli/render.ts";
 import { readStdin } from "./statusline.ts";
-import { SubagentStatusLineStdinSchema } from "../lib/types.ts";
+import { JsonTextSchema, SubagentStatusLineStdinSchema } from "../lib/types.ts";
 
 const RowCtxSchema = z.object({ color: z.boolean(), truecolor: z.boolean() });
 export type RowCtx = z.infer<typeof RowCtxSchema>;
@@ -43,12 +43,7 @@ export function renderSubagentRows(stdinObj: unknown, ctx: RowCtx): string[] {
 }
 
 export async function runSubagentStatusline(): Promise<number> {
-  const raw = await readStdin();
-  let obj: unknown = null;
-  try {
-    obj = JSON.parse(raw);
-  } catch {
-  }
+  const obj = JsonTextSchema.safeParse(await readStdin()).data ?? null;
   const colorterm = z.string().optional().parse(process.env.COLORTERM);
   const rows = renderSubagentRows(obj, {
     color: !process.env.NO_COLOR,

package/src/lib/atomic.ts

@@ -1,20 +1,14 @@
-import { closeSync, mkdirSync, openSync, renameSync, rmSync, writeSync, fsyncSync } from "node:fs";
+import { closeSync, mkdirSync, openSync, renameSync, rmSync, writeFileSync, fsyncSync } from "node:fs";
 import { dirname } from "node:path";
 
 export function writeFileAtomic(file: string, data: string | Uint8Array, mode = 0o600): void {
   const dir = dirname(file);
   mkdirSync(dir, { recursive: true });
   const tmp = `${file}.tmp.${process.pid}.${Math.floor(Math.random() * 1e9).toString(36)}`;
-  const bytes = data instanceof Uint8Array ? data : new TextEncoder().encode(data);
   const fd = openSync(tmp, "wx", mode);
   try {
     try {
-      let offset = 0;
-      while (offset < bytes.length) {
-        const written = writeSync(fd, bytes, offset);
-        if (written <= 0) throw new Error(`short write on ${tmp}: ${offset}/${bytes.length} bytes (disk full?)`);
-        offset += written;
-      }
+      writeFileSync(fd, data);
       fsyncSync(fd);
     } finally {
       closeSync(fd);