tokenmaxxing 1.43.0 → 1.45.0

package/src/lib/install.ts

@@ -2,7 +2,7 @@ import { accessSync, appendFileSync, constants, existsSync, mkdirSync, readFileS
 import { basename, dirname, join } from "node:path";
 import { escape } from "es-toolkit";
 import { z } from "zod";
-import { codexPaths, HOME, paths } from "./paths.ts";
+import { codexPaths, codexStoreDirFor, HOME, paths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
 import { installedBin, installSettings, isOurHookCommand, uninstallSettings } from "./settings.ts";
 import { resolveRealClaude } from "./claudebin.ts";
@@ -165,6 +165,40 @@ export function uninstallCodexStopHook(): void {
   writeFileAtomic(codexPaths.hooksJson, JSON.stringify(next, null, 2) + "\n");
 }
 
+export function codexStopHookGroupIndex(): number | null {
+  if (!existsSync(codexPaths.hooksJson)) return null;
+  let parsed: z.infer<typeof CodexHooksFileSchema>;
+  try {
+    parsed = CodexHooksFileSchema.parse(JSON.parse(readFileSync(codexPaths.hooksJson, "utf8")));
+  } catch {
+    return null;
+  }
+  const idx = parsed.hooks.Stop.findIndex((group) => group.hooks.some((hook) => (hook.command ?? "").includes(CODEX_STOP_HOOK_SUBCOMMAND)));
+  return idx >= 0 ? idx : null;
+}
+
+export function codexStoreHookTrust(accountId: string): "trusted" | "untrusted" | "unknown" {
+  const group = codexStopHookGroupIndex();
+  if (group == null) return "unknown";
+  const key = `${join(codexStoreDirFor(accountId), "hooks.json")}:stop:${group}:0`;
+  let text: string;
+  try {
+    text = readFileSync(join(codexPaths.home, "config.toml"), "utf8");
+  } catch {
+    return "unknown";
+  }
+  let inBlock = false;
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("[")) {
+      inBlock = trimmed.startsWith("[hooks.state.") && trimmed.includes(key);
+    } else if (inBlock && trimmed.startsWith("trusted_hash")) {
+      return "trusted";
+    }
+  }
+  return "untrusted";
+}
+
 export function codexSupervisorLink(): string {
   return join(paths.binDir, "codex");
 }

package/src/lib/opencodego.ts

@@ -0,0 +1,186 @@
+import { existsSync, mkdirSync, readFileSync, rmSync } 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 { c } from "../cli/render.ts";
+
+const OpencodeAuthEntrySchema = z.looseObject({ type: z.string(), key: z.string().optional() });
+const OpencodeAuthFileSchema = z.record(z.string(), z.unknown());
+
+function dataHome(): string {
+  return process.env.XDG_DATA_HOME && process.env.XDG_DATA_HOME.length > 0 ? process.env.XDG_DATA_HOME : join(homedir(), ".local", "share");
+}
+
+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 {
+    id,
+    email: null,
+    tier: "go",
+    sample: null,
+    park: async () => {
+      mkdirSync(opencodeGoStoreDirFor(id), { recursive: true });
+      writeFileAtomic(opencodeGoAuthJsonFor(id), JSON.stringify({ "opencode-go": { type: "api", key } }, null, 2), 0o600);
+    },
+  };
+}
+
+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;
+  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}`);
+  }
+  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."));
+}
+
+export const opencodeGo: Provider = {
+  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,
+  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

@@ -48,10 +48,22 @@ export const claudePool = {
 
 export const codexPool = {
   accountsJson: join(TM_HOME, "codex-accounts.json"),
-  lastSwapJson: join(TM_HOME, "codex-lastswap.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 };
 
 const CODEX_HOME = env("TOKENMAXXING_CODEX_HOME", env("CODEX_HOME", join(HOME, ".codex")));
@@ -60,15 +72,59 @@ export const codexPaths = {
   home: CODEX_HOME,
   authJson: join(CODEX_HOME, "auth.json"),
   hooksJson: join(CODEX_HOME, "hooks.json"),
-  credsDir: join(TM_HOME, "codex-creds"),
+  storesDir: join(TM_HOME, "codex-stores"),
   onboardDir: join(TM_HOME, "codex-onboard"),
   respawnDir: join(TM_HOME, "codex-respawn"),
   presenceDir: join(TM_HOME, "codex-live"),
-  reconcileDir: join(TM_HOME, "codex-reconcile"),
 } as const;
 
-export function codexCredItemFor(accountId: string): string {
-  return `tokenmaxxing-codex-${accountId.slice(0, 8)}`;
+export function codexStoreDirFor(accountId: string): string {
+  return join(codexPaths.storesDir, shortId(accountId));
+}
+
+export function codexAuthJsonFor(accountId: string): string {
+  return join(codexStoreDirFor(accountId), "auth.json");
+}
+
+export function codexSeatFromEnv(accountIds: string[], env: Record<string, string | undefined> = process.env): string | null {
+  const home = env.CODEX_HOME;
+  if (home == null || home === "") return null;
+  return accountIds.find((id) => codexStoreDirFor(id) === home) ?? null;
+}
+
+const GROK_HOME_DEFAULT = join(HOME, ".grok");
+
+export const grokPaths = {
+  home: env("GROK_HOME", GROK_HOME_DEFAULT),
+  storesDir: join(TM_HOME, "grok-stores"),
+  onboardDir: join(TM_HOME, "grok-onboard"),
+} as const;
+
+export function grokStoreDirFor(accountId: string): string {
+  return join(grokPaths.storesDir, shortId(accountId));
+}
+
+export function grokAuthJsonFor(accountId: string): string {
+  return join(grokStoreDirFor(accountId), "auth.json");
+}
+
+export function grokSeatFromEnv(accountIds: string[], env: Record<string, string | undefined> = process.env): string | null {
+  const home = env.GROK_HOME;
+  if (home == null || home === "") return null;
+  return accountIds.find((id) => grokStoreDirFor(id) === home) ?? null;
+}
+
+export const opencodeGoPaths = {
+  storesDir: join(TM_HOME, "opencode-go-stores"),
+  onboardDir: join(TM_HOME, "opencode-go-onboard"),
+} as const;
+
+export function opencodeGoStoreDirFor(accountId: string): string {
+  return join(opencodeGoPaths.storesDir, shortId(accountId));
+}
+
+export function opencodeGoAuthJsonFor(accountId: string): string {
+  return join(opencodeGoStoreDirFor(accountId), "auth.json");
 }
 
 export const keychain = {
@@ -111,4 +167,12 @@ 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/provider.ts

@@ -9,11 +9,12 @@ export type SampleReport = { ok: true; source: "statusline" | "probe" } | { ok:
 export type SwapFailure = "dead-grant" | "skip" | "fatal";
 
 export type Provider = {
-  name: "claude" | "codex";
+  name: "claude" | "codex" | "grok" | "opencode-go";
   flag: string;
   pool: PoolPaths;
   seats: "shared" | "live";
   waitsWhenDepleted: boolean;
+  statusOnly: boolean;
   liveId(): string | null;
   presence(): Map<string, number>;
   gatedFamilies(cfg: Config): string[] | null;

package/src/lib/state.ts

@@ -1,7 +1,7 @@
 import { closeSync, existsSync, fstatSync, openSync, readFileSync, rmSync, utimesSync } from "node:fs";
 import { isEqual } from "es-toolkit";
 import { z } from "zod";
-import { paths, realClaudeBinFromEnv, realCodexBinFromEnv, usageJsonFor, type PoolPaths } from "./paths.ts";
+import { paths, realClaudeBinFromEnv, realCodexBinFromEnv, realGrokBinFromEnv, realOpencodeBinFromEnv, usageJsonFor, type PoolPaths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
 import {
   AccountsIndexSchema,
@@ -35,10 +35,14 @@ export function loadConfig(): Config {
   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;
   return cfg;
 }
 
-export function pinBinOverride(input: { key: "claudeBin" | "codexBin"; bin: string }): void {
+export function pinBinOverride(input: { key: "claudeBin" | "codexBin" | "grokBin" | "opencodeBin"; bin: string }): void {
   let raw: Record<string, unknown> = {};
   if (existsSync(paths.configJson)) {
     raw = z.record(z.string(), z.unknown()).parse(JSON.parse(readFileSync(paths.configJson, "utf8")));

package/src/lib/types.ts

@@ -110,6 +110,8 @@ export const ConfigSchema = z
       .prefault({}),
     claudeBin: z.string().default(""),
     codexBin: z.string().default(""),
+    grokBin: z.string().default(""),
+    opencodeBin: z.string().default(""),
     policy: z
       .object({
         projectionMargin: z.number().min(0).max(100).default(0),
@@ -227,13 +229,8 @@ export const CodexStopStdinSchema = z.looseObject({
 });
 
 export const CodexRespawnMarkerSchema = z.object({
-  account: z.string(),
-  sessionId: z.string().nullable(),
-  ts: z.number(),
-});
-
-export const CodexReconcileMarkerSchema = z.object({
   accountId: z.string(),
+  sessionId: z.string().nullable(),
   ts: z.number(),
 });
 

package/src/main.ts

@@ -11,6 +11,8 @@ import { runCodexSupervisor } from "./entries/codexsupervisor.ts";
 import { runCodexStopHook } from "./entries/codexstophook.ts";
 import { claude } from "./lib/claude.ts";
 import { codex } from "./lib/codex.ts";
+import { grok } from "./lib/grok.ts";
+import { opencodeGo } from "./lib/opencodego.ts";
 import { cmdInit } from "./cli/init.ts";
 import { cmdAdd } from "./cli/add.ts";
 import { cmdAuth } from "./cli/auth.ts";
@@ -18,7 +20,6 @@ import { cmdStatus } from "./cli/status.ts";
 import { cmdDoctor } from "./cli/doctor.ts";
 import { cmdRm } from "./cli/rm.ts";
 import { cmdRename } from "./cli/rename.ts";
-import { cmdSwitch } from "./cli/switch.ts";
 import { cmdCheck } from "./cli/check.ts";
 import { cmdConfig } from "./cli/config.ts";
 import { cmdSetupToken } from "./cli/setuptoken.ts";
@@ -30,8 +31,11 @@ import { c, emitError } from "./cli/render.ts";
 const JSON_FLAG = "--json";
 const CACHED_FLAG = "--cached";
 const CODEX_FLAG = "--codex";
-const JSON_COMMANDS = new Set(["status", "config", "check", "switch"]);
-const CODEX_COMMANDS = new Set(["init", "add", "auth", "switch", "rm", "rename"]);
+const GROK_FLAG = "--grok";
+const OPENCODE_GO_FLAG = "--opencode-go";
+const JSON_COMMANDS = new Set(["status", "config", "check"]);
+const CODEX_COMMANDS = new Set(["init", "add", "auth", "rm", "rename"]);
+const STATUS_ONLY_COMMANDS = new Set(["init", "add", "auth", "rm", "rename"]);
 
 function printHelp(): void {
   console.log(`${c.bold("tokenmaxxing")} - automatic Claude Code account switching
@@ -39,22 +43,23 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing")}            show the pool with usage bars (alias of ${c.cyan("status")})
   ${c.cyan("tokenmaxxing check")}      sample the account whose usage figure is oldest (run by the periodic timer)
   ${c.cyan("tokenmaxxing init")}       log in the first account (isolated) + install supervisor & hooks
-  ${c.cyan("tokenmaxxing init --codex")}  same for codex: import login, install codex supervisor + Stop hook (trust it via /hooks)
+  ${c.cyan("tokenmaxxing init --codex")}  same for codex: log in the first account, isolated, install codex supervisor + Stop hook
+  ${c.cyan("tokenmaxxing init --grok")}   pool grok Build logins (status-only: no supervisor yet)
+  ${c.cyan("tokenmaxxing init --opencode-go")}  pool opencode-go API keys (status-only: no supervisor yet)
   ${c.cyan("tokenmaxxing add")}        register an additional account (isolated login)
   ${c.cyan("tokenmaxxing add --codex")}   register an additional codex account (isolated login)
-  ${c.cyan("tokenmaxxing auth")} [--codex] [sel | --all]  reauthenticate a pooled account in place (bare = pick from a list; --all = every account that is flagged or has no usable credential in its store, one by one)
-  ${c.cyan("tokenmaxxing switch --codex")} [sel]  switch the codex pool (takes effect on next codex start)
+  ${c.cyan("tokenmaxxing auth")} [--codex | --grok | --opencode-go] [sel | --all]  reauthenticate a pooled account in place (bare = pick from a list; --all = every account that is flagged or has no usable credential in its store, one by one)
   ${c.cyan("tokenmaxxing status")} [--cached]  accounts with 5h / weekly / per-model usage bars (--cached: the stored figures, no sampling)
   ${c.cyan("tokenmaxxing config")}     print the config path and the effective values (edit the file in an editor)
   ${c.cyan("tokenmaxxing doctor")}     verify the install is intact
-  ${c.cyan("tokenmaxxing rename")} [--codex] <sel> <label>
-  ${c.cyan("tokenmaxxing rm")} [--codex] <sel>
+  ${c.cyan("tokenmaxxing rename")} [--codex | --grok | --opencode-go] <sel> <label>
+  ${c.cyan("tokenmaxxing rm")} [--codex | --grok | --opencode-go] <sel>
   ${c.cyan("tokenmaxxing uninstall")}  remove supervisor + settings entries
   ${c.cyan("tokenmaxxing setup-token")} [--print | rm <label|uuid>]  Cursor Cloud only: mint one \`claude setup-token\` per pooled account (browser sign-in each) and print the TOKENMAXXING_TOKENS secret value; ${c.cyan("--print")} prints the stored set, ${c.cyan("rm")} drops one
   ${c.cyan("tokenmaxxing cursor init")} [dir]  write the Claude relay subagent (.cursor/agents/claude.md) and .cursor/environment.json into a repo
   ${c.cyan("tokenmaxxing cloud run")} [--session <id>] [--max-turns <n>] "<prompt>"  on a Cursor Cloud VM: run claude -p on a setup token from TOKENMAXXING_TOKENS, rotate to the next token on a usage limit
 
-  ${c.cyan("--json")}                  print one JSON document on stdout instead of text (status, config, check, switch); every document carries ${c.bold("ok")}, failures add ${c.bold("error")}
+  ${c.cyan("--json")}                  print one JSON document on stdout instead of text (status, config, check); every document carries ${c.bold("ok")}, failures add ${c.bold("error")}
 
   ${c.dim("(aliased as")} ${c.cyan("xx")}${c.dim(")")} - then just run ${c.bold("claude")} as always; it switches accounts near quota automatically.`);
 }
@@ -79,8 +84,13 @@ async function main(): Promise<number> {
   jsonMode = argv.includes(JSON_FLAG);
   const json = jsonMode;
   const cached = argv.includes(CACHED_FLAG);
-  const provider = argv.includes(CODEX_FLAG) ? codex : claude;
-  const args = argv.filter((a) => a !== JSON_FLAG && a !== CACHED_FLAG && a !== CODEX_FLAG);
+  const providerFlags = [CODEX_FLAG, GROK_FLAG, OPENCODE_GO_FLAG].filter((f) => argv.includes(f));
+  if (providerFlags.length > 1) {
+    emitError({ json, message: `${providerFlags.join(" and ")} are mutually exclusive - pick one pool` });
+    return 2;
+  }
+  const provider = argv.includes(CODEX_FLAG) ? codex : argv.includes(GROK_FLAG) ? grok : argv.includes(OPENCODE_GO_FLAG) ? opencodeGo : claude;
+  const args = argv.filter((a) => a !== JSON_FLAG && a !== CACHED_FLAG && a !== CODEX_FLAG && a !== GROK_FLAG && a !== OPENCODE_GO_FLAG);
   const sub = args[0];
 
   if (cached && sub != null && sub !== "status") {
@@ -93,6 +103,12 @@ async function main(): Promise<number> {
     return 2;
   }
 
+  if ((provider === grok || provider === opencodeGo) && (sub == null || !STATUS_ONLY_COMMANDS.has(sub))) {
+    const flag = provider === grok ? GROK_FLAG : OPENCODE_GO_FLAG;
+    emitError({ json, message: `${flag} applies to ${[...STATUS_ONLY_COMMANDS].join(", ")}, not ${sub ?? "status"}` });
+    return 2;
+  }
+
   if (json && sub != null && !JSON_COMMANDS.has(sub)) {
     emitError({ json, message: `${sub} has no ${JSON_FLAG} form (${JSON_FLAG} applies to ${[...JSON_COMMANDS].join(", ")})` });
     return 2;
@@ -113,13 +129,6 @@ async function main(): Promise<number> {
       }
       return cmdStatus({ json, cached });
     }
-    case "switch": {
-      if (provider !== codex) {
-        emitError({ json, message: "Claude account placement is per session at launch; manual switching is available with `tokenmaxxing switch --codex`." });
-        return 2;
-      }
-      return cmdSwitch(args[1], json);
-    }
     case "check": {
       if (args.length > 1) {
         emitError({ json, message: `unknown check option: ${args[1]} (check takes no options; the timer runs a plain check every tick)` });
@@ -156,7 +165,7 @@ async function main(): Promise<number> {
       console.log(`removed ${removed.join(", ")}`);
       if (!out.timerDeactivated) console.log(c.yellow(`⚠ the check job may still be loaded - run: ${timerDeactivationHint()}`));
       if (!out.pathLineRemoved) console.log(c.dim("(no tokenmaxxing PATH line found in the shell rc)"));
-      console.log(`kept: accounts.json, config.json, and every account credential store (claude: stores/ and its keychain items on macOS; codex: codex-creds/) - remove accounts with \`xx rm\` to delete their credentials`);
+      console.log(`kept: accounts.json, config.json, and every account credential store (claude: stores/ and its keychain items on macOS; codex: codex-stores/) - remove accounts with \`xx rm\` to delete their credentials`);
       return 0;
     }
     case "help":

package/src/cli/switch.ts

@@ -1,116 +0,0 @@
-import { withLock } from "../lib/lock.ts";
-import { codex } from "../lib/codex.ts";
-import { loadAccounts, loadConfig } from "../lib/state.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";
-
-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 => {
-    if (json) emitJson({ ok: true, ...withDeadGrants(report) });
-    else console.log(text);
-  };
-  const fail = (message: string, opts: { paint?: (s: string) => string; extra?: Record<string, unknown> } = {}): number => {
-    emitError({ json, message, paint: opts.paint, extra: withDeadGrants(opts.extra ?? {}) });
-    return 1;
-  };
-  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)} (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 });
-  const cfg = loadConfig();
-  const now = Date.now();
-
-  return withLock(p.pool.lockFile, async () => {
-    const idx = loadAccounts(p.pool);
-    const claimed = p.liveId();
-    const drifted = claimed != null && claimed !== idx.activeId;
-    const present = p.presence();
-
-    const swapTo = async (target: Account, reason: string, extra: Record<string, unknown> = {}): Promise<number> => {
-      try {
-        await p.swap(target);
-      } catch (e) {
-        if (p.classifySwapError(e) === "dead-grant") {
-          deadGrants.push(target.label);
-          return fail(deadGrantMessage(target));
-        }
-        throw e;
-      }
-      log("switch.manual", { account: target.id.slice(0, 8), reason });
-      emit(switched(target), { switched: true, account: target.label, reason, ...extra });
-      return 0;
-    };
-
-    if (selector) {
-      const target = findAccount(idx.accounts, selector);
-      if (!target) return fail(`no account matches "${selector}"`);
-      if (target.id === idx.activeId && !drifted) {
-        emit(`already on ${c.bold(target.label)}`, { switched: false, account: target.label, reason: "already-on" });
-        return 0;
-      }
-      if (target.id !== claimed && present.has(target.id)) {
-        return fail(`${target.label} is running in a live ${p.name} session - swapping onto it would break that session's credential`);
-      }
-      if (target.needsReauth) return fail(`${target.label} needs re-auth - ${reauthHint(target)}`);
-      return swapTo(target, "selected");
-    }
-
-    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) {
-      const cur = loadAccounts(p.pool);
-      const pool = candidatesOf(cur.accounts);
-      const active =
-        (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, SWITCH_MARGIN)) {
-        if (drifted) return swapTo(active, "drift-reconciled");
-        const expiry = weeklyExpiry(active, now);
-        const why = Number.isFinite(expiry) ? ` (weekly ${fmtReset(expiry, now)})` : "";
-        emit(`already on the best account: ${c.bold(active.label)}${why}`, {
-          switched: false,
-          account: active.label,
-          reason: "current-wins",
-          weeklyResetsAt: Number.isFinite(expiry) ? expiry : null,
-        });
-        return 0;
-      }
-      const best = pickBest(pool, { ...everyone, currentId: active?.id ?? null });
-      if (!best) break;
-      try {
-        await p.swap(best);
-      } catch (e) {
-        rejected.add(best.id);
-        const kind = p.classifySwapError(e);
-        if (kind === "dead-grant") {
-          deadGrants.push(best.label);
-          if (!json) console.error(c.red(deadGrantMessage(best)));
-          continue;
-        }
-        if (kind === "skip") {
-          if (!json) console.error(c.yellow(`${best.label}: ${e instanceof Error ? e.message : String(e)} - skipped for this run`));
-          continue;
-        }
-        throw e;
-      }
-      log("switch.manual", { account: best.id.slice(0, 8), reason: "best" });
-      emit(switched(best), { switched: true, account: best.label, reason: "best" });
-      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 } });
-  });
-}