tokenmaxxing 1.156.0 → 1.157.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.156.0",
+  "version": "1.157.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/entries/pisupervisor.ts

@@ -371,8 +371,10 @@ export async function runPiSupervisor(argv: string[]): Promise<number> {
       const launched = await withLock(mover.pool.lockFile, async () => {
         clearPresence({ dir: presenceDir, id });
         if (terminating) return null;
-        const picked = validWanted(pool, wanted, id) ?? pickPiSeat(pool, launchedAt, model);
-        log("pisupervisor.launch", { id, pool, respawns, seat: picked?.id.slice(0, 8) ?? null, args: launchArgs.join(" ") });
+        const kept = validWanted(pool, wanted, id);
+        const target = kept ? { account: kept } : pickPiSeat(pool, launchedAt, model);
+        const picked = target?.account ?? null;
+        log("pisupervisor.launch", { id, pool, respawns, seat: picked?.id.slice(0, 8) ?? null, depletedUntil: target?.depletedUntil, args: launchArgs.join(" ") });
         const spawned = Bun.spawn([real, ...launchArgs], {
           stdin: "inherit",
           stdout: "inherit",
@@ -398,21 +400,21 @@ export async function runPiSupervisor(argv: string[]): Promise<number> {
             log("pisupervisor.claim_release_failed", { err: errorMessage(e) });
           }
         }
-        return { proc: spawned, seat: picked };
+        return { proc: spawned, seat: picked, overriddenUntil: Math.max(overriddenUntil, target?.depletedUntil ?? 0) };
       });
       if (launched == null) {
         await releaseClaim();
         return 143;
       }
 
-      const { proc, seat } = launched;
+      const { proc, seat, overriddenUntil: gateUntil } = launched;
       const pending: { move: SwapDecision | null; killed: boolean } = { move: null, killed: false };
       let seatCheckAt = 0;
       await raceMarkerOrExit({
         child: proc,
         tick: async () => {
           if (!seat || terminating || Date.now() < seatCheckAt) return false;
-          const watched = await watchSeat({ pool, seatId: seat.id, id, families, overriddenUntil });
+          const watched = await watchSeat({ pool, seatId: seat.id, id, families, overriddenUntil: gateUntil });
           seatCheckAt = Date.now() + (watched.decided ? SEAT_RETRY_MS : SEAT_POLL_MS);
           pending.move = watched.move;
           return watched.move !== null;

package/src/lib/claude.ts

@@ -10,7 +10,7 @@ import { withLock } from "./lock.ts";
 import { errorMessage, log } from "./log.ts";
 import { claudeTierLabel, describeIdentity, fetchTokenIdentity, isDeadCredential, InvalidGrantError } from "./oauth.ts";
 import { claudePool, env, paths, seatFromEnv, shortId, storeDirFor } from "./paths.ts";
-import { MAX_WAITERS_PER_ACCOUNT, pickBest, pickEarliestReset, pickWaitTarget, thresholdBars, type EarliestReset, type PickCtx } from "./picker.ts";
+import { MAX_WAITERS_PER_ACCOUNT, pickBest, pickEarliestReset, pickWaitTarget, thresholdBars, type PickCtx } from "./picker.ts";
 import { deletePiStore } from "./piauth.ts";
 import { livingPresences, writePresence } from "./presence.ts";
 import { StoreUnusableError, type Observation, type Provider, type ResetClaim, type SampleReport, type SeatBorrow } from "./provider.ts";
@@ -139,7 +139,9 @@ async function storeUsable(a: Account): Promise<boolean> {
   }
 }
 
-function seatContext(now: number, model: ModelInfo | null, eligible: (a: Account) => boolean): { candidates: Account[]; ctx: PickCtx; fallback: () => EarliestReset | null } {
+export type Seat = { account: Account; depletedUntil?: number };
+
+export function pickSeat(now: number, model: ModelInfo | null, eligible: (a: Account) => boolean = () => true): Seat | null {
   const cfg = loadConfig();
   const bars = thresholdBars(cfg);
   const idx = loadAccounts(claudePool);
@@ -149,27 +151,22 @@ function seatContext(now: number, model: ModelInfo | null, eligible: (a: Account
   const seats = presence();
   const ctx: PickCtx = { now, thresholds: bars, currentId: null, families: gatedFamilies(model, cfg.policy.switchModels), seats };
   const candidates = idx.accounts.filter(eligible);
-  const fallback = () =>
+  const best = pickBest(candidates, ctx);
+  if (best) return { account: best };
+  const wait =
     pickWaitTarget(candidates, ctx, seats, MAX_WAITERS_PER_ACCOUNT, now + cfg.policy.maxWaitMs, now + 2 * cfg.policy.maxWaitMs) ??
     pickEarliestReset(candidates, ctx);
-  return { candidates, ctx, fallback };
+  return wait ? { account: wait.account, depletedUntil: wait.availableAt } : null;
 }
 
-export function pickSeat(now: number, model: ModelInfo | null, eligible: (a: Account) => boolean = () => true): Account | null {
-  const { candidates, ctx, fallback } = seatContext(now, model, eligible);
-  return pickBest(candidates, ctx) ?? fallback()?.account ?? null;
-}
-
-export type LaunchTarget = { account: Account; apiKey: null; depletedUntil?: number } | { account: null; apiKey: ApiKey };
+export type LaunchTarget = (Seat & { apiKey: null }) | { account: null; apiKey: ApiKey };
 
 export function pickLaunch(now: number, model: ModelInfo | null, refused: readonly string[] = []): LaunchTarget | null {
-  const { candidates, ctx, fallback } = seatContext(now, model, (a) => !refused.includes(a.id));
-  const best = pickBest(candidates, ctx);
-  if (best) return { account: best, apiKey: null };
+  const seat = pickSeat(now, model, (a) => !refused.includes(a.id));
+  if (seat && seat.depletedUntil === undefined) return { ...seat, apiKey: null };
   const key = launchApiKey();
   if (key) return { account: null, apiKey: key };
-  const wait = fallback();
-  return wait ? { account: wait.account, apiKey: null, depletedUntil: wait.availableAt } : null;
+  return seat ? { ...seat, apiKey: null } : null;
 }
 
 export async function borrowClaudeSeat(pid: number, named?: string): Promise<SeatBorrow | { invalid: string }> {

package/src/lib/pi.ts

@@ -1,6 +1,6 @@
 import { rmSync } from "node:fs";
 import { join } from "node:path";
-import { claude, ensurePathAhead, pickSeat } from "./claude.ts";
+import { claude, ensurePathAhead, pickSeat, type Seat } from "./claude.ts";
 import { MAX_WRAP_DEPTH, PI_BIN, WRAP_DEPTH_ENV, resolveRealBin, verifyRealBin } from "./claudebin.ts";
 import { codex, pickCodexSeat } from "./codex.ts";
 import { codexSeatIdOf } from "./codexauth.ts";
@@ -111,9 +111,11 @@ function piMover(base: Provider, pool: PiPool): Provider {
 
 export const piMovers: Record<PiPool, Provider> = { claude: piMover(claude, "claude"), codex: piMover(codex, "codex") };
 
-export function pickPiSeat(pool: PiPool, now: number, model: ModelInfo | null): Account | null {
+export function pickPiSeat(pool: PiPool, now: number, model: ModelInfo | null): Seat | null {
   const eligible = (a: Account) => piStoreUsable(pool, a.id);
-  return pool === "claude" ? pickSeat(now, model, eligible) : pickCodexSeat(now, eligible);
+  if (pool === "claude") return pickSeat(now, model, eligible);
+  const account = pickCodexSeat(now, eligible);
+  return account ? { account } : null;
 }
 
 export function piPreflight(): void {