tokenmaxxing 1.56.0 → 1.58.0

package/src/lib/opencodego.ts

@@ -1,12 +1,12 @@
-import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { mkdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import { opencodeGoAuthJsonFor, opencodeGoPaths, opencodeGoPool, opencodeGoStoreDirFor } from "./paths.ts";
-import type { Observation, Provider, SampleReport } from "./provider.ts";
-import { loadConfig, pinBinOverride, type Harvest } from "./state.ts";
-import type { Account } from "./types.ts";
+import type { Provider } from "./provider.ts";
+import { type Harvest } from "./state.ts";
+import { statusOnlyProvider, type AuthEntry } from "./statusonly.ts";
 import { c } from "../cli/render.ts";
 
 const OpencodeAuthEntrySchema = z.looseObject({ type: z.string(), key: z.string().optional() });
@@ -20,77 +20,12 @@ function liveAuthPath(): string {
   return join(dataHome(), "opencode", "auth.json");
 }
 
-function parseAuthFile(path: string): { provider: string; key: string } | null {
-  let raw: unknown;
-  try {
-    raw = JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return null;
-  }
-  const map = OpencodeAuthFileSchema.safeParse(raw);
-  if (!map.success) return null;
-  const entry = OpencodeAuthEntrySchema.safeParse(map.data["opencode-go"]);
-  if (!entry.success || entry.data.type !== "api" || !entry.data.key) return null;
-  return { provider: "opencode-go", key: entry.data.key };
-}
-
 function idOfKey(key: string): string {
   const h = new Bun.CryptoHasher("sha256");
   h.update(`opencode-go:${key}`);
   return `opencode-go-${h.digest("hex")}`;
 }
 
-function resolveRealOpencode(): string {
-  const cfg = loadConfig();
-  if (cfg.opencodeBin) {
-    if (!existsSync(cfg.opencodeBin)) throw new Error(`configured opencodeBin does not exist: ${cfg.opencodeBin} - fix config.json`);
-    return cfg.opencodeBin;
-  }
-  for (const d of (process.env.PATH ?? "").split(":")) {
-    if (!d) continue;
-    const cand = join(d, "opencode");
-    try {
-      if (existsSync(cand)) return cand;
-    } catch {
-      continue;
-    }
-  }
-  throw new Error("could not locate the real `opencode` binary (set opencodeBin in config.json)");
-}
-
-function liveId(): string | null {
-  return null;
-}
-
-function presence(): Map<string, number> {
-  return new Map();
-}
-
-async function observeLive(account: Account): Promise<Observation | null> {
-  return account.lastUsageAt != null ? { windows: account.windows, at: account.lastUsageAt } : null;
-}
-
-async function samplePool(accounts: Account[]): Promise<Map<string, SampleReport>> {
-  const reports = new Map<string, SampleReport>();
-  for (const a of accounts) {
-    reports.set(a.id, (await storeUsable(a)) ? { ok: true, source: "probe" } : { ok: false, reason: "no usable credential in this account's store - run `tokenmaxxing auth --opencode-go`" });
-  }
-  return reports;
-}
-
-async function storeUsable(a: Account): Promise<boolean> {
-  try {
-    const found = parseAuthFile(opencodeGoAuthJsonFor(a.id));
-    return found != null && idOfKey(found.key) === a.id;
-  } catch {
-    return false;
-  }
-}
-
-async function removeCredentials(a: Account): Promise<void> {
-  rmSync(opencodeGoStoreDirFor(a.id), { recursive: true, force: true });
-}
-
 function harvestOf(key: string): Harvest {
   const id = idOfKey(key);
   return {
@@ -105,82 +40,38 @@ function harvestOf(key: string): Harvest {
   };
 }
 
-async function login(): Promise<Harvest | null> {
-  const real = resolveRealOpencode();
-  const onboardDir = opencodeGoPaths.onboardDir;
-  rmSync(onboardDir, { recursive: true, force: true });
-  mkdirSync(onboardDir, { recursive: true });
-  const p = Bun.spawn([real, "providers", "login", "-p", "opencode-go"], {
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-    env: { ...process.env, XDG_DATA_HOME: onboardDir, TOKENMAXXING_PROBE: "1" },
-  });
-  await p.exited;
+function readAuth(path: string): AuthEntry[] {
+  let raw: unknown;
   try {
-    if (p.exitCode !== 0) {
-      console.error(c.red("no opencode-go login landed in the isolated home - nothing added."));
-      return null;
-    }
-    const found = parseAuthFile(join(onboardDir, "opencode", "auth.json"));
-    if (!found) {
-      console.error(c.red("no opencode-go login landed in the isolated home - nothing added."));
-      return null;
-    }
-    return harvestOf(found.key);
-  } finally {
-    rmSync(onboardDir, { recursive: true, force: true });
-  }
-}
-
-async function importLive(): Promise<Harvest | null> {
-  console.log(c.cyan("Pooling your opencode-go API key - your existing opencode auth stays as it is."));
-  console.log();
-  const found = parseAuthFile(liveAuthPath());
-  if (found) {
-    console.log(c.dim(`found an opencode-go credential in ${liveAuthPath()} - pooling it; use \`tokenmaxxing add --opencode-go\` for more keys.`));
-    return harvestOf(found.key);
-  }
-  return login();
-}
-
-function preflight(): void {
-  const real = resolveRealOpencode();
-  const p = Bun.spawnSync([real, "--version"], { stdout: "pipe", stderr: "pipe", timeout: 15_000 });
-  const out = (p.stdout?.toString() ?? "").trim();
-  if (p.exitCode !== 0 || out === "") {
-    throw new Error(`opencode binary failed verification: ${real}`);
+    raw = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return [];
   }
-  pinBinOverride({ key: "opencodeBin", bin: real });
-}
-
-function install(): void {
-  console.log(c.dim("opencode-go pool is status-only: no supervisor or hooks installed. Use `tokenmaxxing status` to view pooled keys."));
+  const map = OpencodeAuthFileSchema.safeParse(raw);
+  if (!map.success) return [];
+  const entry = OpencodeAuthEntrySchema.safeParse(map.data["opencode-go"]);
+  if (!entry.success || entry.data.type !== "api" || !entry.data.key) return [];
+  return [{ id: idOfKey(entry.data.key), usable: true, harvest: harvestOf(entry.data.key) }];
 }
 
-export const opencodeGo: Provider = {
+export const opencodeGo: Provider = statusOnlyProvider({
   name: "opencode-go",
   flag: " --opencode-go",
   pool: opencodeGoPool,
-  seats: "live",
-  waitsWhenDepleted: false,
-  statusOnly: true,
-  liveId,
-  presence,
-  gatedFamilies: () => null,
-  observeLive,
-  samplePool,
-  mergeWindows: (next) => next,
-  swap: async () => {
-    throw new Error("opencode-go moves are not supported yet (status-only pool)");
-  },
-  classifySwapError: () => "fatal",
-  removeCredentials,
-  storeUsable,
-  login,
-  importLive,
-  preflight,
-  install,
+  binName: "opencode",
+  binKey: "opencodeBin",
+  storeDirFor: opencodeGoStoreDirFor,
+  authJsonFor: opencodeGoAuthJsonFor,
+  onboardDir: opencodeGoPaths.onboardDir,
+  homeEnv: "XDG_DATA_HOME",
+  loginArgs: ["providers", "login", "-p", "opencode-go"],
+  onboardAuthRel: join("opencode", "auth.json"),
+  liveAuthPath,
+  readAuth,
+  liveId: () => null,
+  versionOk: (out) => out.trim() !== "",
+  importIntro: "Pooling your opencode-go API key - your existing opencode auth stays as it is.",
+  foundLive: () => `found an opencode-go credential in ${liveAuthPath()} - pooling it; use \`tokenmaxxing add --opencode-go\` for more keys.`,
+  installNotice: "opencode-go pool is status-only: no supervisor or hooks installed. Use `tokenmaxxing status` to view pooled keys.",
   loginStep: () => `Paste the opencode-go API key from ${c.bold("opencode.ai/zen")} when opencode asks for it.`,
-  windowLabel: (name) => name.toLowerCase(),
-};
+});

package/src/lib/paths.ts

@@ -6,8 +6,12 @@ const HOME = homedir();
 
 const EnvOverrideSchema = z.string().min(1).optional().catch(undefined);
 
+export function optionalEnv(name: string, source: Record<string, string | undefined> = process.env): string | undefined {
+  return EnvOverrideSchema.parse(source[name]);
+}
+
 export function env(name: string, fallback: string): string {
-  return EnvOverrideSchema.parse(process.env[name]) ?? fallback;
+  return optionalEnv(name) ?? fallback;
 }
 
 const TM_HOME = env("TOKENMAXXING_HOME", join(HOME, ".config", "tokenmaxxing"));
@@ -42,29 +46,25 @@ export const paths = {
 
 export const claudePool = {
   accountsJson: join(TM_HOME, "accounts.json"),
-  lastSwapJson: null,
   lockFile: join(TM_HOME, "lock"),
 } as const;
 
 export const codexPool = {
   accountsJson: join(TM_HOME, "codex-accounts.json"),
-  lastSwapJson: null,
   lockFile: join(TM_HOME, "codex-lock"),
 } as const;
 
 export const grokPool = {
   accountsJson: join(TM_HOME, "grok-accounts.json"),
-  lastSwapJson: null,
   lockFile: join(TM_HOME, "grok-lock"),
 } as const;
 
 export const opencodeGoPool = {
   accountsJson: join(TM_HOME, "opencode-go-accounts.json"),
-  lastSwapJson: null,
   lockFile: join(TM_HOME, "opencode-go-lock"),
 } as const;
 
-export type PoolPaths = { accountsJson: string; lastSwapJson: string | null; lockFile: string };
+export type PoolPaths = { accountsJson: string; lockFile: string };
 
 const CODEX_HOME = env("TOKENMAXXING_CODEX_HOME", env("CODEX_HOME", join(HOME, ".codex")));
 
@@ -159,20 +159,4 @@ export function namespacedCredService(configDirRaw: string): string {
   return `Claude Code-credentials-${h.digest("hex").slice(0, 8)}`;
 }
 
-export function realClaudeBinFromEnv(): string | undefined {
-  return EnvOverrideSchema.parse(process.env.TOKENMAXXING_CLAUDE_BIN);
-}
-
-export function realCodexBinFromEnv(): string | undefined {
-  return EnvOverrideSchema.parse(process.env.TOKENMAXXING_CODEX_BIN);
-}
-
-export function realGrokBinFromEnv(): string | undefined {
-  return EnvOverrideSchema.parse(process.env.TOKENMAXXING_GROK_BIN);
-}
-
-export function realOpencodeBinFromEnv(): string | undefined {
-  return EnvOverrideSchema.parse(process.env.TOKENMAXXING_OPENCODE_BIN);
-}
-
 export { HOME };

package/src/lib/picker.ts

@@ -1,7 +1,6 @@
 import { maxBy, minBy, sortBy } from "es-toolkit";
-import { z } from "zod";
 import { familyTokens } from "./usage.ts";
-import { AccountSchema, ThresholdsSchema, type Account, type Config, type Thresholds, type Window } from "./types.ts";
+import type { Account, Config, Thresholds, Window } from "./types.ts";
 
 export function thresholdBars(cfg: Config): Thresholds {
   return {
@@ -10,14 +9,13 @@ export function thresholdBars(cfg: Config): Thresholds {
   };
 }
 
-const PickCtxSchema = z.object({
-  now: z.number(),
-  thresholds: ThresholdsSchema,
-  currentId: z.string().nullable(),
-  families: z.array(z.string()).nullable(),
-  seats: z.map(z.string(), z.number()).nullable(),
-});
-export type PickCtx = z.infer<typeof PickCtxSchema>;
+export type PickCtx = {
+  now: number;
+  thresholds: Thresholds;
+  currentId: string | null;
+  families: string[] | null;
+  seats: Map<string, number> | null;
+};
 
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 const SESSION_WINDOW_MAX_S = 6 * 3600;
@@ -123,21 +121,12 @@ export function pickBest(accounts: Account[], ctx: PickCtx): Account | null {
   return sortBy(usable, swapPreference(ctx))[0] ?? null;
 }
 
-export function currentWins(active: Account | null, accounts: Account[], ctx: PickCtx, margin = 1): boolean {
-  if (!active || active.needsReauth || isExhausted(active, ctx)) return false;
-  const best = pickBest(accounts, { ...ctx, currentId: null });
-  if (best == null || best.id === active.id) return true;
-  if (margin > 1) return pacePressure(best, ctx) <= pacePressure(active, ctx) * margin;
-  return swapPreference(ctx).every((k) => k(active) === k(best));
-}
-
 export function usableAt(a: Account, ctx: PickCtx): number {
   const blocking = blockingUntil(a, ctx).filter((t) => t > ctx.now);
   return blocking.length ? Math.max(...blocking) : ctx.now;
 }
 
-const EarliestResetSchema = z.object({ account: AccountSchema, availableAt: z.number() });
-export type EarliestReset = z.infer<typeof EarliestResetSchema>;
+export type EarliestReset = { account: Account; availableAt: number };
 
 export function pickEarliestReset(accounts: Account[], ctx: PickCtx): EarliestReset | null {
   const mapped = accounts

package/src/lib/presence.ts

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import { pidExists, pidStartTime } from "./proc.ts";
+import { ErrnoSchema } from "./types.ts";
 
 const PresenceSchema = z.object({
   accountId: z.string(),
@@ -21,8 +22,7 @@ export function clearPresence(input: { dir: string; id: string }): void {
   rmSync(join(input.dir, input.id), { force: true });
 }
 
-const LivingPresenceSchema = z.object({ id: z.string(), accountId: z.string() });
-export type LivingPresence = z.infer<typeof LivingPresenceSchema>;
+export type LivingPresence = { id: string; accountId: string };
 
 export function livingPresences(dir: string): LivingPresence[] {
   const living: LivingPresence[] = [];
@@ -33,8 +33,7 @@ export function livingPresences(dir: string): LivingPresence[] {
     try {
       raw = readFileSync(file, "utf8");
     } catch (e) {
-      const errno = z.object({ code: z.string() }).safeParse(e);
-      if (errno.success && errno.data.code === "ENOENT") continue;
+      if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") continue;
       throw e;
     }
     const parsed = PresenceSchema.safeParse((() => {
@@ -55,7 +54,7 @@ export function livingPresences(dir: string): LivingPresence[] {
       rmSync(file, { force: true });
       continue;
     }
-    living.push(LivingPresenceSchema.parse({ id: name, accountId: parsed.data.accountId }));
+    living.push({ id: name, accountId: parsed.data.accountId });
   }
   return living;
 }

package/src/lib/proc.ts

@@ -7,6 +7,28 @@ export function pidStartTime(pid: number): string | null {
   return lstart === "" ? null : lstart;
 }
 
+export async function readStdin(): Promise<string> {
+  const chunks: Uint8Array[] = [];
+  for await (const chunk of Bun.stdin.stream()) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+export async function* readLines(stream: ReadableStream<Uint8Array>): AsyncGenerator<string> {
+  const decoder = new TextDecoder();
+  let pending = "";
+  for await (const chunk of stream) {
+    pending += decoder.decode(chunk, { stream: true });
+    let nl = pending.indexOf("\n");
+    while (nl !== -1) {
+      yield pending.slice(0, nl);
+      pending = pending.slice(nl + 1);
+      nl = pending.indexOf("\n");
+    }
+  }
+  pending += decoder.decode();
+  if (pending.length > 0) yield pending;
+}
+
 export function pidExists(pid: number): boolean {
   try {
     process.kill(pid, 0);

package/src/lib/sample.ts

@@ -1,29 +1,20 @@
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import { readStore } from "./credstore.ts";
 import { withLock } from "./lock.ts";
-import { log } from "./log.ts";
+import { errorMessage, log } from "./log.ts";
 import { claudeTierLabel, isAccessTokenExpiring, isDeadCredential } from "./oauth.ts";
 import { claudePool, paths, sampleDirFor, storeDirFor } from "./paths.ts";
 import { seatCounts } from "./presence.ts";
 import type { Observation } from "./provider.ts";
 import { loadAccounts, loadUsageSnapshot, saveAccounts } from "./state.ts";
-import { fetchUsageDirect, mergeWindows, probeUsage, windowsOf } from "./usage.ts";
-import { UsageWindowsSchema, type Account, type Config } from "./types.ts";
+import { fetchUsageDirect, mergeWindows, refreshViaProbe, windowsOf } from "./usage.ts";
+import type { Account, Config, UsageWindows } from "./types.ts";
 
-const SampleOutcomeSchema = z.discriminatedUnion("ok", [
-  z.object({ ok: z.literal(true), usage: UsageWindowsSchema, via: z.enum(["get", "probe"]) }),
-  z.object({ ok: z.literal(false), reason: z.string() }),
-]);
-export type SampleOutcome = z.infer<typeof SampleOutcomeSchema>;
+export type SampleOutcome = { ok: true; usage: UsageWindows; via: "get" | "probe" } | { ok: false; reason: string };
 
-const PreparedSampleSchema = z.discriminatedUnion("ok", [
-  z.object({ ok: z.literal(true), token: z.string().nullable() }),
-  z.object({ ok: z.literal(false), reason: z.string() }),
-]);
-type PreparedSample = z.infer<typeof PreparedSampleSchema>;
+type PreparedSample = { ok: true; token: string | null } | { ok: false; reason: string };
 
 export function teeObservation(account: Account): Observation | null {
   const stored = account.lastUsageAt != null ? { windows: account.windows, at: account.lastUsageAt } : null;
@@ -48,7 +39,7 @@ export async function prepareSample(account: Account): Promise<PreparedSample> {
   try {
     creds = await readStore(account.id);
   } catch (e) {
-    return { ok: false, reason: `store credential unreadable (${(e instanceof Error ? e.message : String(e)).slice(0, 80)}) - run \`tokenmaxxing auth\`` };
+    return { ok: false, reason: `store credential unreadable (${errorMessage(e).slice(0, 80)}) - run \`tokenmaxxing auth\`` };
   }
   if (!creds) return { ok: false, reason: "no credential in this account's store - run `tokenmaxxing auth`" };
   if (isDeadCredential(creds)) {
@@ -60,25 +51,29 @@ export async function prepareSample(account: Account): Promise<PreparedSample> {
   return { ok: true, token: isAccessTokenExpiring(creds) ? null : creds.accessToken };
 }
 
-async function runProbe(account: Account, suffix: string, retries: number | undefined): Promise<SampleOutcome> {
+async function refreshedToken(account: Account, suffix: string): Promise<string | null> {
   const dir = sampleDirFor(account.id, suffix);
   mkdirSync(dir, { recursive: true });
   writeFileAtomic(join(dir, ".claude.json"), JSON.stringify({ oauthAccount: account.oauthAccount, hasCompletedOnboarding: true }));
-  const usage = await probeUsage({ configDir: dir, store: storeDirFor(account.id) }, Date.now(), { retries });
-  return usage ? { ok: true, usage, via: "probe" } : { ok: false, reason: "`/usage` returned no limit data (see log)" };
+  if (!(await refreshViaProbe({ configDir: dir, store: storeDirFor(account.id) }))) return null;
+  const prepared = await prepareSample(account);
+  return prepared.ok ? prepared.token : null;
 }
 
-export async function runSample(account: Account, token: string | null, opts: { retries?: number; suffix?: string }): Promise<SampleOutcome> {
+export async function runSample(account: Account, token: string | null, suffix = ""): Promise<SampleOutcome> {
   if (token) {
     const usage = await fetchUsageDirect(token);
     if (usage) return { ok: true, usage, via: "get" };
   }
-  return runProbe(account, opts.suffix ?? "", opts.retries);
+  const fresh = await refreshedToken(account, suffix);
+  if (!fresh) return { ok: false, reason: "the `/usage` probe left no usable access token in the store (see log)" };
+  const usage = await fetchUsageDirect(fresh);
+  return usage ? { ok: true, usage, via: "probe" } : { ok: false, reason: "usage read failed after the `/usage` probe (see log)" };
 }
 
-export async function sampleAccountUsage(account: Account, opts: { retries?: number } = {}): Promise<SampleOutcome> {
+export async function sampleAccountUsage(account: Account): Promise<SampleOutcome> {
   const prepared = await prepareSample(account);
-  return prepared.ok ? runSample(account, prepared.token, opts) : prepared;
+  return prepared.ok ? runSample(account, prepared.token) : prepared;
 }
 
 const SAMPLE_BATCH = 3;
@@ -119,15 +114,21 @@ export async function sampleOldest(cfg: Config): Promise<void> {
   await Promise.all(
     reserved.map(async ({ account, token }) => {
       const startedAt = Date.now();
-      const outcome = await runSample(account, token, { retries: 0, suffix: "-tick" });
+      const outcome = await runSample(account, token, "-tick");
       await withLock(claudePool.lockFile, () => {
         const idx = loadAccounts(claudePool);
         const stored = idx.accounts.find((a) => a.id === account.id);
+        let dirty = false;
+        if (stored && account.needsReauth === true && stored.needsReauth !== true) {
+          stored.needsReauth = true;
+          dirty = true;
+        }
         if (stored && outcome.ok && (stored.lastUsageAt == null || startedAt > stored.lastUsageAt)) {
           stored.windows = mergeWindows(windowsOf(outcome.usage, startedAt), stored.windows);
           stored.lastUsageAt = startedAt;
-          saveAccounts(claudePool, idx);
+          dirty = true;
         }
+        if (dirty) saveAccounts(claudePool, idx);
         log(outcome.ok ? "sample.ok" : "sample.failed", {
           account: account.id.slice(0, 8),
           ...(outcome.ok ? { via: outcome.via } : { reason: outcome.reason.slice(0, 200) }),

package/src/lib/sessions.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { z } from "zod";
 import { paths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
-import { RespawnMarkerSchema } from "./types.ts";
+import type { RespawnMarkerSchema } from "./types.ts";
 
 const SessionSchema = z.object({ flags: z.array(z.string()), cwd: z.string() });
 
@@ -36,8 +36,7 @@ export function pruneStaleSessions(now: number): void {
   }
 }
 
-const SupervisedSessionSchema = z.object({ sid: z.string().min(1), launchedAt: z.number().finite().nullable() });
-export type SupervisedSession = z.infer<typeof SupervisedSessionSchema>;
+export type SupervisedSession = { sid: string; launchedAt: number | null };
 
 const LaunchedAtSchema = z.coerce.number().finite().optional().catch(undefined);
 
@@ -45,18 +44,18 @@ export function supervisedSession(env: Record<string, string | undefined> = proc
   if (env.TOKENMAXXING_SUPERVISED !== "1") return null;
   const sid = env.TOKENMAXXING_SESSION_ID;
   if (sid == null || sid === "") return null;
-  return SupervisedSessionSchema.parse({ sid, launchedAt: LaunchedAtSchema.parse(env.TOKENMAXXING_LAUNCHED_AT) ?? null });
+  return { sid, launchedAt: LaunchedAtSchema.parse(env.TOKENMAXXING_LAUNCHED_AT) ?? null };
 }
 
 export function writeRespawnMarker(input: { session: SupervisedSession; sessionId: string; accountId: string; waitUntil: number; compact: boolean }): void {
   mkdirSync(paths.respawnDir, { recursive: true });
-  const payload = RespawnMarkerSchema.parse({
+  const payload: z.infer<typeof RespawnMarkerSchema> = {
     accountId: input.accountId,
     ts: Date.now(),
     waitUntil: input.waitUntil,
     sessionId: input.sessionId,
     compact: input.compact,
     ...(input.session.launchedAt != null ? { launchedAt: input.session.launchedAt } : {}),
-  });
+  };
   writeFileAtomic(join(paths.respawnDir, input.session.sid), JSON.stringify(payload));
 }

package/src/lib/settings.ts

@@ -112,14 +112,7 @@ export function uninstallSettings(): void {
   writeSettings(s);
 }
 
-const SettingsCheckSchema = z.object({
-  statusLineOk: z.boolean(),
-  subagentStatusLineOk: z.boolean(),
-  stopOk: z.boolean(),
-  stopFailureOk: z.boolean(),
-  sessionStartOk: z.boolean(),
-});
-export type SettingsCheck = z.infer<typeof SettingsCheckSchema>;
+export type SettingsCheck = Record<"statusLineOk" | "subagentStatusLineOk" | "stopOk" | "stopFailureOk" | "sessionStartOk", boolean>;
 
 export function checkSettings(): SettingsCheck {
   const s = readSettings();

package/src/lib/state.ts

@@ -1,13 +1,12 @@
 import { closeSync, existsSync, fstatSync, openSync, readFileSync, rmSync, utimesSync } from "node:fs";
 import { isEqual } from "es-toolkit";
 import { z } from "zod";
-import { paths, realClaudeBinFromEnv, realCodexBinFromEnv, realGrokBinFromEnv, realOpencodeBinFromEnv, usageJsonFor, type PoolPaths } from "./paths.ts";
+import { optionalEnv, paths, usageJsonFor, type PoolPaths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
 import {
   AccountsIndexSchema,
   ConfigSchema,
   ErrnoSchema,
-  LastSwapSchema,
   UsageStateSchema,
   type Account,
   type AccountsIndex,
@@ -31,14 +30,10 @@ export function loadConfig(): Config {
     throw new Error(`${paths.configJson} is invalid (${fields}) - fix or remove the offending values`);
   }
   const cfg = parsed.data;
-  const envBin = realClaudeBinFromEnv();
-  if (envBin) cfg.claudeBin = envBin;
-  const envCodexBin = realCodexBinFromEnv();
-  if (envCodexBin) cfg.codexBin = envCodexBin;
-  const envGrokBin = realGrokBinFromEnv();
-  if (envGrokBin) cfg.grokBin = envGrokBin;
-  const envOpencodeBin = realOpencodeBinFromEnv();
-  if (envOpencodeBin) cfg.opencodeBin = envOpencodeBin;
+  cfg.claudeBin = optionalEnv("TOKENMAXXING_CLAUDE_BIN") ?? cfg.claudeBin;
+  cfg.codexBin = optionalEnv("TOKENMAXXING_CODEX_BIN") ?? cfg.codexBin;
+  cfg.grokBin = optionalEnv("TOKENMAXXING_GROK_BIN") ?? cfg.grokBin;
+  cfg.opencodeBin = optionalEnv("TOKENMAXXING_OPENCODE_BIN") ?? cfg.opencodeBin;
   return cfg;
 }
 
@@ -51,7 +46,7 @@ export function pinBinOverride(input: { key: "claudeBin" | "codexBin" | "grokBin
   writeFileAtomic(paths.configJson, JSON.stringify(raw, null, 2) + "\n");
 }
 
-const emptyIndex = (): AccountsIndex => ({ version: 2, activeId: null, accounts: [] });
+const emptyIndex = (): AccountsIndex => ({ version: 2, accounts: [] });
 
 export function loadAccounts(pool: PoolPaths): AccountsIndex {
   if (!existsSync(pool.accountsJson)) return emptyIndex();
@@ -127,24 +122,6 @@ export function clearUsageSnapshot(accountId: string): void {
   rmSync(usageJsonFor(accountId), { force: true });
 }
 
-export function loadLastSwapAt(pool: PoolPaths): number | null {
-  if (pool.lastSwapJson == null || !existsSync(pool.lastSwapJson)) return null;
-  let json: unknown;
-  try {
-    json = JSON.parse(readFileSync(pool.lastSwapJson, "utf8"));
-  } catch {
-    throw new Error(`${pool.lastSwapJson} is corrupt (unparsable JSON) - refusing to treat a damaged swap clock as never-swapped; repair or remove the file`);
-  }
-  return LastSwapSchema.parse(json).ts;
-}
-
-export function saveLastSwapAt(pool: PoolPaths, ts: number): void {
-  if (pool.lastSwapJson == null) throw new Error("this pool keeps no swap clock");
-  writeFileAtomic(pool.lastSwapJson, JSON.stringify(LastSwapSchema.parse({ ts })));
-}
-
-export const POST_SWAP_COOLDOWN_MS = 45_000;
-
 const USAGE_TS_REFRESH_MS = 10 * 60_000;
 const SAMPLED_AT_REFRESH_MS = 30_000;