tokenmaxxing 1.39.0 → 1.41.0

package/src/cli/check.ts

@@ -1,6 +1,6 @@
 import { claude } from "../lib/claude.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
-import { sampleOldestParked } from "../lib/sample.ts";
+import { sampleOldest } from "../lib/sample.ts";
 import { loadConfig } from "../lib/state.ts";
 import { maybeAutoUpdate } from "../lib/update.ts";
 import { log } from "../lib/log.ts";
@@ -11,7 +11,7 @@ export async function cmdCheck(json = false): Promise<number> {
   let d;
   try {
     d = await evaluateAndMaybeSwap(claude, now);
-    await sampleOldestParked(loadConfig());
+    await sampleOldest(loadConfig());
     await maybeAutoUpdate();
   } catch (e) {
     const detail = e instanceof Error ? e.message : String(e);

package/src/cli/doctor.ts

@@ -2,20 +2,13 @@ import { existsSync, readFileSync } from "node:fs";
 import { verifyRealClaude } from "../lib/claudebin.ts";
 import { checkSettings, installedBin } from "../lib/settings.ts";
 import { checkTimerHealthy, findClaudeShadowers, isBinDirAhead, shellRcPath, timerActivationHint } from "../lib/install.ts";
-import { claudePool, credItemFor, paths } from "../lib/paths.ts";
+import { claudePool, paths } from "../lib/paths.ts";
 import { loadAccounts, loadConfig } from "../lib/state.ts";
-import { readItem, liveTarget, parkedTarget } from "../lib/credstore.ts";
-import { isAccessTokenExpiring, fetchTokenIdentity, describeIdentity } from "../lib/oauth.ts";
-import { CredentialBlobSchema, type TokenIdentity } from "../lib/types.ts";
+import { readStore } from "../lib/credstore.ts";
+import { isAccessTokenExpiring, isDeadCredential, fetchTokenIdentity, describeIdentity } from "../lib/oauth.ts";
 import { SETUP_TOKEN_STALE_MS, loadSetupTokens } from "../lib/setuptokens.ts";
 import { c, fmtAgo } from "./render.ts";
 
-async function blobIdentity(raw: string): Promise<TokenIdentity | null> {
-  const creds = CredentialBlobSchema.parse(JSON.parse(raw)).claudeAiOauth;
-  if (isAccessTokenExpiring(creds)) return null;
-  return fetchTokenIdentity(creds.accessToken);
-}
-
 export async function cmdDoctor(): Promise<number> {
   let failed = 0;
   const check = (cond: boolean, label: string, hint?: string) => {
@@ -39,32 +32,26 @@ export async function cmdDoctor(): Promise<number> {
 
   const idx = loadAccounts(claudePool);
   check(idx.accounts.length > 0, "at least one account in the pool", "run `tokenmaxxing init`");
-  check(!!idx.activeId, "an active account is set");
 
-  const live = await readItem(liveTarget());
-  check(!!live, "live credential readable");
-
-  const active = idx.accounts.find((a) => a.id === idx.activeId);
-  if (live && active) {
+  for (const a of idx.accounts) {
+    let creds;
     try {
-      const identity = await blobIdentity(live);
-      if (identity) check(identity.accountUuid === active.id, `live credential identity matches active (${active.label})`, `token belongs to ${describeIdentity(identity)} - run \`tokenmaxxing switch\``);
-      else note("live credential identity unverifiable (access token expired)");
+      creds = await readStore(a.id);
     } catch (e) {
-      check(false, `live credential identity matches active (${active.label})`, (e instanceof Error ? e.message : String(e)).slice(0, 100));
+      check(false, `store credential readable for ${a.label}`, (e instanceof Error ? e.message : String(e)).slice(0, 100));
+      continue;
     }
-  }
-
-  for (const a of idx.accounts) {
-    const parked = await readItem(parkedTarget(credItemFor(a.id)));
-    check(!!parked, `parked credential present for ${a.label}`, `run \`tokenmaxxing auth ${a.label}\``);
-    if (parked) {
-      try {
-        const identity = await blobIdentity(parked);
-        if (identity) check(identity.accountUuid === a.id, `parked credential identity matches ${a.label}`, `token belongs to ${describeIdentity(identity)} - run \`tokenmaxxing auth ${a.label}\``);
-        else note(`${a.label} identity unverifiable (access token expired)`);
-      } catch (e) {
-        check(false, `parked credential identity matches ${a.label}`, (e instanceof Error ? e.message : String(e)).slice(0, 100));
+    check(creds != null, `store credential present for ${a.label}`, `run \`tokenmaxxing auth ${a.label}\``);
+    if (creds) {
+      if (isDeadCredential(creds)) check(false, `${a.label}'s store credential is usable`, `cleared after a failed refresh - run \`tokenmaxxing auth ${a.label}\``);
+      else if (isAccessTokenExpiring(creds)) note(`${a.label} identity unverifiable (access token expired)`);
+      else {
+        try {
+          const identity = await fetchTokenIdentity(creds.accessToken);
+          check(identity.accountUuid === a.id, `store credential identity matches ${a.label}`, `token belongs to ${describeIdentity(identity)} - run \`tokenmaxxing auth ${a.label}\``);
+        } catch (e) {
+          check(false, `store credential identity matches ${a.label}`, (e instanceof Error ? e.message : String(e)).slice(0, 100));
+        }
       }
     }
     if (a.needsReauth) check(false, `${a.label} needs re-auth`, `run \`tokenmaxxing auth ${a.label}\` to re-login`);

package/src/cli/init.ts

@@ -25,7 +25,7 @@ export async function cmdInit(p: Provider): Promise<number> {
     p.install();
     const active = existing.accounts.find((a) => a.id === existing.activeId);
     console.log(`${c.green("✓")} re-installed (pool already has ${count({ n: existing.accounts.length, noun: "account" })} - not re-importing)`);
-    console.log(`  active: ${c.bold(active?.label ?? "unknown")}`);
+    if (active && p.seats === "live") console.log(`  active: ${c.bold(active.label)}`);
     printUsage(p);
     return 0;
   }
@@ -37,7 +37,7 @@ export async function cmdInit(p: Provider): Promise<number> {
     await harvested.park();
     const idx = loadAccounts(p.pool);
     const imported = upsertAccount(idx, harvested, p.mergeWindows);
-    idx.activeId = harvested.id;
+    idx.activeId = p.seats === "live" ? harvested.id : null;
     saveAccounts(p.pool, idx);
     return imported;
   });

package/src/cli/rm.ts

@@ -20,20 +20,11 @@ export async function cmdRm(p: Provider, selector?: string): Promise<number> {
       emitError({ message: `${a.label} is the ACTIVE account - switch away before removing it.` });
       return 1;
     }
-    let liveOwner: string | null;
-    try {
-      liveOwner = await p.liveOwner();
-    } catch (e) {
-      emitError({
-        message: `cannot verify which account the LIVE credential belongs to (${e instanceof Error ? e.message : String(e)}) - refusing to remove while the live owner is unknown; repair the live credential or retry once the profile endpoint is reachable.`,
-      });
+    if (p.liveId() === a.id) {
+      emitError({ message: `${a.label} is the ${p.name} login this command runs under - remove it from a session on another account.` });
       return 1;
     }
-    if (liveOwner === a.id) {
-      emitError({ message: `${a.label}'s credential is currently LIVE (the active label is stale - a manual login drifted it); run \`tokenmaxxing switch${p.flag}\` to move off it first.` });
-      return 1;
-    }
-    if (p.presentIds().has(a.id)) {
+    if (p.presence().has(a.id)) {
       emitError({ message: `${a.label} is running in a live ${p.name} session - close that session before removing it.` });
       return 1;
     }

package/src/cli/setuptoken.ts

@@ -2,7 +2,7 @@ import { mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { resolveRealClaude } from "../lib/claudebin.ts";
 import { withLock } from "../lib/lock.ts";
-import { claudePool, credItemFor, paths } from "../lib/paths.ts";
+import { claudePool, paths, shortId } from "../lib/paths.ts";
 import { loadAccounts } from "../lib/state.ts";
 import { scrubCredentialEnv } from "../lib/usage.ts";
 import { CURSOR_SECRET_VALUE_CAP_BYTES, cursorSecretValue, loadSetupTokens, saveSetupTokens, type SetupToken } from "../lib/setuptokens.ts";
@@ -102,7 +102,7 @@ export async function cmdSetupToken(args: string[]): Promise<number> {
     for (const a of missing) {
       console.log();
       console.log(`${c.bold(a.label)} - sign into this account in the browser (${a.email ?? a.label})`);
-      const token = await mint({ real, item: credItemFor(a.id) });
+      const token = await mint({ real, item: shortId(a.id) });
       if (!token) return 1;
       const stored = await withLock(claudePool.lockFile, async () => {
         if (!loadAccounts(claudePool).accounts.some((x) => x.id === a.id)) return false;

package/src/cli/status.ts

@@ -28,6 +28,7 @@ const StatusAccountSchema = z.object({
   id: z.string(),
   tier: z.string().nullable(),
   active: z.boolean(),
+  sessions: z.number(),
   needsReauth: z.boolean(),
   exhausted: z.boolean(),
   usage: z
@@ -77,7 +78,7 @@ function usageReport(a: Account, now: number): StatusAccount["usage"] {
 async function collect(p: Provider, cfg: Config, now: number, cached: boolean): Promise<PoolReport> {
   let idx = loadAccounts(p.pool);
   let reports = new Map<string, SampleReport>();
-  let liveId: string | null = idx.activeId;
+  let liveId: string | null = p.seats === "live" ? idx.activeId : null;
   if (!cached) {
     liveId = null;
     if (idx.accounts.length > 0) {
@@ -92,7 +93,8 @@ async function collect(p: Provider, cfg: Config, now: number, cached: boolean):
   }
 
   const bars = thresholdBars(cfg);
-  const ctx = { now, thresholds: bars, currentId: idx.activeId, families: p.gatedFamilies(cfg) };
+  const present = p.presence();
+  const ctx = { now, thresholds: bars, currentId: idx.activeId, families: p.gatedFamilies(cfg), seats: null };
   const ordered = sortBy(idx.accounts, [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, now)]);
   const accounts = ordered.map((a): StatusAccount => {
     const limits = limitWindows(a);
@@ -101,7 +103,8 @@ async function collect(p: Provider, cfg: Config, now: number, cached: boolean):
       email: a.email,
       id: a.id,
       tier: a.tier,
-      active: liveId != null && a.id === liveId,
+      active: (liveId != null && a.id === liveId) || present.has(a.id),
+      sessions: present.get(a.id) ?? 0,
       needsReauth: a.needsReauth === true,
       exhausted: isExhausted(a, ctx),
       usage: usageReport(a, now),
@@ -190,10 +193,11 @@ function cachedNote(usageAt: number | null, now: number): Note {
   return { paint: c.dim, text: usageAt != null ? `cached ${fmtAgo(usageAt, now)}` : "never sampled" };
 }
 
-function headerLine(input: { active: boolean; needsReauth: boolean; exhausted: boolean; name: string; tier: string | null }): string {
+function headerLine(input: { active: boolean; sessions: number; needsReauth: boolean; exhausted: boolean; name: string; tier: string | null }): string {
   const marker = input.active ? c.green("●") : c.dim("○");
   const badges: string[] = [];
   if (input.active) badges.push(c.green("active"));
+  if (input.sessions > 0) badges.push(c.green(count({ n: input.sessions, noun: "session" })));
   if (input.needsReauth) badges.push(c.red("needs-reauth"));
   if (input.exhausted) badges.push(c.yellow("exhausted"));
   return `${marker} ${c.bold(input.name)}${input.tier ? ` ${c.dim(input.tier)}` : ""}${badges.length ? ` ${badges.join(" ")}` : ""}`;

package/src/cli/switch.ts

@@ -1,13 +1,16 @@
 import { withLock } from "../lib/lock.ts";
-import type { Provider } from "../lib/provider.ts";
+import { codex } from "../lib/codex.ts";
 import { loadAccounts, loadConfig } from "../lib/state.ts";
-import { currentWins, pickBest, pickEarliestReset, thresholdBars, weeklyExpiry, type PickCtx } from "../lib/picker.ts";
+import { currentWins, pickBest, thresholdBars, weeklyExpiry, type PickCtx } from "../lib/picker.ts";
 import { findAccount } from "./rename.ts";
 import { log } from "../lib/log.ts";
 import { c, emitError, emitJson, fmtReset } from "./render.ts";
 import type { Account } from "../lib/types.ts";
 
-export async function cmdSwitch(p: Provider, selector?: string, json = false): Promise<number> {
+const SWITCH_MARGIN = 1.2;
+
+export async function cmdSwitch(selector?: string, json = false): Promise<number> {
+  const p = codex;
   const deadGrants: string[] = [];
   const withDeadGrants = (report: Record<string, unknown>) => (deadGrants.length > 0 ? { ...report, deadGrants } : report);
   const emit = (text: string, report: Record<string, unknown>): void => {
@@ -20,7 +23,7 @@ export async function cmdSwitch(p: Provider, selector?: string, json = false): P
   };
   const reauthHint = (a: Account) => `run \`tokenmaxxing auth${p.flag} ${a.label}\``;
   const deadGrantMessage = (a: Account) => `${a.label}'s refresh token is dead - ${reauthHint(a)}`;
-  const switched = (target: Account) => `${c.green("↻")} switched to ${c.bold(target.label)}${p.switchNote}`;
+  const switched = (target: Account) => `${c.green("↻")} switched to ${c.bold(target.label)} (takes effect on the next codex start)`;
 
   const idx0 = loadAccounts(p.pool);
   if (idx0.accounts.length < 2) return fail(`need at least 2 accounts to switch - add one with \`tokenmaxxing add${p.flag}\``, { paint: c.yellow });
@@ -31,7 +34,7 @@ export async function cmdSwitch(p: Provider, selector?: string, json = false): P
     const idx = loadAccounts(p.pool);
     const claimed = p.liveId();
     const drifted = claimed != null && claimed !== idx.activeId;
-    const present = p.presentIds();
+    const present = p.presence();
 
     const swapTo = async (target: Account, reason: string, extra: Record<string, unknown> = {}): Promise<number> => {
       try {
@@ -62,7 +65,7 @@ export async function cmdSwitch(p: Provider, selector?: string, json = false): P
       return swapTo(target, "selected");
     }
 
-    const everyone: PickCtx = { now, thresholds: thresholdBars(cfg), currentId: null, families: p.gatedFamilies(cfg) };
+    const everyone: PickCtx = { now, thresholds: thresholdBars(cfg), currentId: null, families: p.gatedFamilies(cfg), seats: null };
     const rejected = new Set<string>();
     const candidatesOf = (accounts: Account[]): Account[] => accounts.filter((a) => !rejected.has(a.id) && (a.id === claimed || !present.has(a.id)));
     while (true) {
@@ -72,7 +75,7 @@ export async function cmdSwitch(p: Provider, selector?: string, json = false): P
         (claimed != null ? cur.accounts.find((a) => a.id === claimed) : null) ??
         cur.accounts.find((a) => a.id === cur.activeId) ??
         null;
-      if (active != null && currentWins(active, pool, everyone, p.switchMargin)) {
+      if (active != null && currentWins(active, pool, everyone, SWITCH_MARGIN)) {
         if (drifted) return swapTo(active, "drift-reconciled");
         const expiry = weeklyExpiry(active, now);
         const why = Number.isFinite(expiry) ? ` (weekly ${fmtReset(expiry, now)})` : "";
@@ -107,69 +110,7 @@ export async function cmdSwitch(p: Provider, selector?: string, json = false): P
       return 0;
     }
 
-    if (!p.waitsWhenDepleted) {
-      const reauth = loadAccounts(p.pool).accounts.filter((a) => a.needsReauth).map((a) => a.label);
-      return fail(`no usable ${p.name} switch target (all at their bars, unmeasured, or needing reauth)`, { paint: c.yellow, extra: { reauthNeeded: reauth } });
-    }
-
-    while (true) {
-      const fresh = loadAccounts(p.pool);
-      const pool = candidatesOf(fresh.accounts);
-      const earliest = pickEarliestReset(pool, everyone);
-      const reauth = fresh.accounts.filter((a) => a.needsReauth).map((a) => a.label);
-      if (!earliest) {
-        if (reauth.length > 0) {
-          return fail(`no switchable account - reauth needed (run \`tokenmaxxing auth${p.flag} --all\`): ${reauth.join(", ")}`, {
-            paint: c.yellow,
-            extra: { reauthNeeded: reauth },
-          });
-        }
-        const freshActive = fresh.accounts.find((a) => a.id === fresh.activeId) ?? null;
-        if (drifted && freshActive) return swapTo(freshActive, "drift-reconciled");
-        emit(c.yellow("all accounts at their limit with unknown reset times (unparsed reset clocks? see tokenmaxxing.log) - staying put"), {
-          switched: false,
-          account: freshActive?.label ?? null,
-          reason: "unknown-resets",
-        });
-        return 0;
-      }
-      const reauthNote = reauth.length ? ` - re-auth needed: ${reauth.join(", ")}` : "";
-      const availableAt = earliest.availableAt > now ? earliest.availableAt : null;
-      if (earliest.account.id === fresh.activeId && !drifted) {
-        const msg = availableAt == null
-          ? `staying on ${c.bold(earliest.account.label)} - no usable switch target${reauthNote}`
-          : `all accounts at limit - staying on ${c.bold(earliest.account.label)} (${fmtReset(availableAt, now)})${reauthNote}`;
-        emit(c.yellow(msg), {
-          switched: false,
-          account: earliest.account.label,
-          reason: availableAt == null ? "no-target" : "all-at-limit",
-          availableAt,
-          reauthNeeded: reauth,
-        });
-        return 0;
-      }
-      try {
-        await p.swap(earliest.account);
-      } catch (e) {
-        rejected.add(earliest.account.id);
-        const kind = p.classifySwapError(e);
-        if (kind === "dead-grant") {
-          deadGrants.push(earliest.account.label);
-          if (!json) console.error(c.red(deadGrantMessage(earliest.account)));
-          continue;
-        }
-        if (kind === "skip") {
-          if (!json) console.error(c.yellow(`${earliest.account.label}: ${e instanceof Error ? e.message : String(e)} - skipped for this run`));
-          continue;
-        }
-        throw e;
-      }
-      log("switch.manual", { account: earliest.account.id.slice(0, 8), reason: "earliest-reset" });
-      emit(switched(earliest.account), { switched: true, account: earliest.account.label, reason: "earliest-reset", availableAt, reauthNeeded: reauth });
-      if (availableAt != null && !json) {
-        console.log(c.yellow(`all accounts at limit - ${c.bold(earliest.account.label)} recovers soonest (${fmtReset(availableAt, now)})${reauthNote}`));
-      }
-      return 0;
-    }
+    const reauth = loadAccounts(p.pool).accounts.filter((a) => a.needsReauth).map((a) => a.label);
+    return fail(`no usable ${p.name} switch target (all at their bars, unmeasured, or needing reauth)`, { paint: c.yellow, extra: { reauthNeeded: reauth } });
   });
 }

package/src/entries/codexstophook.ts

@@ -8,7 +8,7 @@ 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 { livingPresences } from "../lib/presence.ts";
 import { loadAccounts } from "../lib/state.ts";
 import { CODEX_SUPERVISOR_ID_ENV } from "./codexsupervisor.ts";
 import { CodexReconcileMarkerSchema, CodexRespawnMarkerSchema, CodexStopStdinSchema, JsonTextSchema } from "../lib/types.ts";
@@ -37,7 +37,7 @@ function promoteReconcileLocked(input: { supervisorId: string; sessionId: string
     log("codexstop.reconcile_unparsable", {});
     return false;
   }
-  const presence = livingCodexPresences().find((p) => p.supervisorId === input.supervisorId) ?? null;
+  const presence = livingPresences(codexPaths.presenceDir).find((p) => p.id === input.supervisorId) ?? null;
   if (presence == null || presence.accountId !== parsed.data.accountId) {
     rmSync(markerPath, { force: true });
     log("codexstop.reconcile_stale", {});

package/src/entries/codexsupervisor.ts

@@ -5,7 +5,7 @@ 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 { clearPresence, writePresence } from "../lib/presence.ts";
 import { liveCodexAccountId } from "../lib/codexauth.ts";
 import { saveTermios, restoreTermios } from "../lib/tty.ts";
 import { CodexRespawnMarkerSchema } from "../lib/types.ts";
@@ -106,7 +106,7 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
       if (spawnAccountId) {
         for (let attempt = 0; attempt < 10; attempt++) {
           try {
-            writeCodexPresence({ supervisorId, accountId: spawnAccountId, pid: spawned.pid });
+            writePresence({ dir: codexPaths.presenceDir, id: supervisorId, accountId: spawnAccountId, pid: spawned.pid });
             break;
           } catch (e) {
             if (spawned.exitCode !== null || spawned.signalCode !== null) break;
@@ -160,7 +160,7 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
       launchArgs = payload.sessionId ? ["resume", payload.sessionId] : ["resume", "--last"];
       continue;
     }
-    clearCodexPresence({ supervisorId });
+    clearPresence({ dir: codexPaths.presenceDir, id: supervisorId });
     rmSync(join(codexPaths.reconcileDir, supervisorId), { force: true });
     log("codexsupervisor.exit", { supervisorId: supervisorId.slice(0, 8), respawns, code: child.exitCode, signal: child.signalCode });
     return child.exitCode ?? (child.signalCode ? 1 : 0);

package/src/entries/sessionstart.ts

@@ -1,31 +1,30 @@
 import { z } from "zod";
 import { claude } from "../lib/claude.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
+import { supervisedSession, writeRespawnMarker } from "../lib/sessions.ts";
 import { log } from "../lib/log.ts";
+import { readStdin } from "./statusline.ts";
 import { JsonTextSchema } from "../lib/types.ts";
 
 const SessionStartStdin = z.looseObject({
   source: z.string().optional(),
-  session_id: z.string().optional(),
+  session_id: z.uuid().optional().catch(undefined),
 });
 
-async function readStdin(): Promise<string> {
-  const chunks: Uint8Array[] = [];
-  for await (const c of Bun.stdin.stream()) chunks.push(c);
-  return Buffer.concat(chunks).toString("utf8");
-}
-
 export async function runSessionStart(): Promise<number> {
   if (process.env.TOKENMAXXING_PROBE) return 0;
 
   const raw = await readStdin();
   const parsed = SessionStartStdin.safeParse(JsonTextSchema.safeParse(raw).data);
   const source = parsed.success ? parsed.data.source : undefined;
+  const stdinSid = parsed.success ? parsed.data.session_id : undefined;
+  const session = supervisedSession();
 
   try {
-    const decision = await evaluateAndMaybeSwap(claude);
-    if (decision.swapped && decision.account) {
-      log("sessionstart.swapped", { source, account: decision.account.id.slice(0, 8) });
+    const decision = await evaluateAndMaybeSwap(claude, Date.now(), session != null);
+    if (session && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
+      writeRespawnMarker({ session, sessionId: stdinSid ?? session.sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? Date.now() });
+      log("sessionstart.marker", { source, account: decision.account.id.slice(0, 8), waitUntil: decision.waitUntil });
     }
   } catch (e) {
     log("sessionstart.error", { err: e instanceof Error ? e.message : String(e) });

package/src/entries/statusline.ts

@@ -1,8 +1,7 @@
 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 { claudePool, seatFromEnv } from "../lib/paths.ts";
+import { loadAccounts, loadConfig, writeUsage } from "../lib/state.ts";
 import { familyTokens, matchedFamily, parseStatusLineStdin, parseStatusLineModel } from "../lib/usage.ts";
 import { earliestReset, limitWindows, weeklyExpiry, weeklyWindow } from "../lib/picker.ts";
 import { worktreeName } from "../lib/worktree.ts";
@@ -18,8 +17,6 @@ import {
   type UsageWindow,
 } from "../lib/types.ts";
 
-const ADOPTION_GRACE_MS = 45_000;
-
 const RenderCtxSchema = z.object({
   accounts: AccountsIndexSchema,
   perModel: z.record(z.string(), WindowSchema),
@@ -79,9 +76,7 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
     windows.push(seg("", wins.fiveHour, wins.fiveHour.resetsAt));
     windows.push(seg("", wins.sevenDay, wins.sevenDay.resetsAt));
   }
-  const seatUuid =
-    (ctx.liveAccount != null && ctx.accounts.accounts.some((a) => a.id === ctx.liveAccount) ? ctx.liveAccount : null) ??
-    ctx.accounts.activeId;
+  const seatUuid = ctx.liveAccount;
   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.id === seatUuid);
@@ -124,10 +119,9 @@ export async function runStatusline(): Promise<number> {
 
   let account: string | null = null;
   try {
-    account = readOAuthAccount()?.accountUuid ?? null;
+    account = seatFromEnv(loadAccounts(claudePool).accounts.map((a) => a.id));
     const windows = obj == null ? null : parseStatusLineStdin(obj);
-    const lastSwapAt = loadLastSwapAt(claudePool);
-    if (windows && (lastSwapAt == null || now - lastSwapAt >= ADOPTION_GRACE_MS)) {
+    if (windows && account != null) {
       const state: UsageState = { fiveHour: windows.fiveHour, sevenDay: windows.sevenDay, account, ts: now, model: parseStatusLineModel(obj) };
       writeUsage(state);
     }

package/src/entries/stopfailurehook.ts

@@ -1,16 +1,12 @@
-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 { supervisedSession, writeRespawnMarker } from "../lib/sessions.ts";
+import { loadConfig } from "../lib/state.ts";
 import { classifyEnforcedLimit, findEnforcedRow, parseErrorBody, readTranscriptTail } from "../lib/usage.ts";
-import { JsonTextSchema, RespawnMarkerSchema, type EnforcedLimit } from "../lib/types.ts";
+import { JsonTextSchema, type EnforcedLimit } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
+import { readStdin } from "./statusline.ts";
 
 const StopFailureStdin = z.looseObject({
   session_id: z.uuid().optional().catch(undefined),
@@ -20,19 +16,10 @@ const StopFailureStdin = z.looseObject({
   last_assistant_message: z.string().optional().catch(undefined),
 });
 
-const LaunchedAtSchema = z.coerce.number().finite().optional().catch(undefined);
-
-async function readStdin(): Promise<string> {
-  const chunks: Uint8Array[] = [];
-  for await (const c of Bun.stdin.stream()) chunks.push(c);
-  return Buffer.concat(chunks).toString("utf8");
-}
-
 export async function runStopFailureHook(): Promise<number> {
   if (process.env.TOKENMAXXING_PROBE) return 0;
 
-  const entry = await withLock(claudePool.lockFile, () => ({ swapClock: loadLastSwapAt(claudePool), account: readOAuthAccount()?.accountUuid ?? null }));
-  const account = entry.account;
+  const account = claude.liveId();
   const now = Date.now();
   const raw = await readStdin();
   const parsed = StopFailureStdin.safeParse(JsonTextSchema.safeParse(raw).data);
@@ -40,17 +27,11 @@ export async function runStopFailureHook(): Promise<number> {
   if (stdin.error !== undefined && stdin.error !== "rate_limit") return 0;
 
   const stdinSid = stdin.session_id;
-  const pinnedSid = process.env.TOKENMAXXING_SESSION_ID;
-  const launchedAt = LaunchedAtSchema.parse(process.env.TOKENMAXXING_LAUNCHED_AT) ?? null;
+  const session = supervisedSession();
   const mainLoop = stdin.agent_id === undefined;
-  const canPause = process.env.TOKENMAXXING_SUPERVISED === "1" && pinnedSid != null && mainLoop;
+  const canRespawn = session != null && mainLoop;
 
   try {
-    const lastSwapAt = loadLastSwapAt(claudePool);
-    if (lastSwapAt != null && lastSwapAt === entry.swapClock && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
-      log("stopfailure.cooldown", { sinceSwapMs: now - lastSwapAt });
-      return 0;
-    }
     const cfg = loadConfig();
     const row = stdin.transcript_path
       ? findEnforcedRow({ rows: readTranscriptTail(stdin.transcript_path), lastAssistantMessage: stdin.last_assistant_message, now })
@@ -63,6 +44,7 @@ export async function runStopFailureHook(): Promise<number> {
       log("stopfailure.enforced", { kind: limit.kind, family: enforced.family ?? undefined, resetsAt: limit.resetsAt, subagent: !mainLoop });
     } else {
       log("stopfailure.unclassified", {
+        seat: account != null,
         row: row != null,
         type: row?.quotaLimits?.rateLimitType,
         transient: row?.apiErrorIsTransient,
@@ -70,18 +52,10 @@ export async function runStopFailureHook(): Promise<number> {
       });
     }
 
-    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({
-        account: decision.account.label,
-        ts: Date.now(),
-        waitUntil: decision.waitUntil ?? now,
-        sessionId: stdinSid ?? pinnedSid,
-        ...(launchedAt != null ? { launchedAt } : {}),
-      });
-      writeFileAtomic(marker, JSON.stringify(payload));
-      log("stopfailure.marker", { session: (stdinSid ?? pinnedSid).slice(0, 8), account: decision.account.id.slice(0, 8), waitUntil: payload.waitUntil });
+    const decision = await evaluateAndMaybeSwap(claude, now, canRespawn && enforced != null, enforced);
+    if (enforced && session && canRespawn && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
+      writeRespawnMarker({ session, sessionId: stdinSid ?? session.sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? now });
+      log("stopfailure.marker", { session: session.sid.slice(0, 8), account: decision.account.id.slice(0, 8), waitUntil: decision.waitUntil ?? now });
     } else {
       log("stopfailure.decision", { reason: decision.reason, swapped: decision.swapped, account: decision.account?.id.slice(0, 8), waitUntil: decision.waitUntil });
     }

package/src/entries/stophook.ts

@@ -1,46 +1,26 @@
-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 { JsonTextSchema, RespawnMarkerSchema } from "../lib/types.ts";
+import { supervisedSession, writeRespawnMarker } from "../lib/sessions.ts";
+import { JsonTextSchema } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
+import { readStdin } from "./statusline.ts";
 
 const StopStdin = z.looseObject({ session_id: z.uuid().optional().catch(undefined) });
 
-async function readStdin(): Promise<string> {
-  const chunks: Uint8Array[] = [];
-  for await (const c of Bun.stdin.stream()) chunks.push(c);
-  return Buffer.concat(chunks).toString("utf8");
-}
-
 export async function runStopHook(): Promise<number> {
   if (process.env.TOKENMAXXING_PROBE) return 0;
 
   const raw = await readStdin();
   const parsed = StopStdin.safeParse(JsonTextSchema.safeParse(raw).data);
   const stdinSid = parsed.success ? parsed.data.session_id : undefined;
-  const pinnedSid = process.env.TOKENMAXXING_SESSION_ID;
+  const session = supervisedSession();
 
   try {
-    const canPause = process.env.TOKENMAXXING_SUPERVISED === "1" && pinnedSid != null;
-    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.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);
-        const payload = RespawnMarkerSchema.parse({
-          account: decision.account.label,
-          ts: Date.now(),
-          waitUntil: decision.waitUntil,
-          sessionId: stdinSid ?? pinnedSid,
-          ...(launchedAt != null ? { launchedAt } : {}),
-        });
-        writeFileAtomic(marker, JSON.stringify(payload));
-        log("stop.marker", { session: (stdinSid ?? pinnedSid).slice(0, 8) });
-      }
+    const decision = await evaluateAndMaybeSwap(claude, Date.now(), session != null);
+    if (session && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
+      writeRespawnMarker({ session, sessionId: stdinSid ?? session.sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? Date.now() });
+      log(decision.waitUntil !== undefined ? "stop.wait" : "stop.move", { account: decision.account.id.slice(0, 8), waitUntil: decision.waitUntil, session: session.sid.slice(0, 8) });
     }
   } catch (e) {
     log("stop.error", { err: e instanceof Error ? e.message : String(e) });