tokenmaxxing 1.81.0 → 1.83.0

package/src/lib/install.ts

@@ -7,17 +7,17 @@ import { codexPaths, codexStoreDirFor, HOME, optionalEnv, paths } from "./paths.
 import { writeFileAtomic } from "./atomic.ts";
 import { installedBin, installSettings, isOurHookCommand, uninstallSettings } from "./settings.ts";
 import { CLAUDE_BIN, resolveRealBin } from "./claudebin.ts";
-import { loadConfig, readJsonFile } from "./state.ts";
+import { loadConfig, readJsonFile, type BinKey } from "./state.ts";
 import { ErrnoSchema } from "./types.ts";
 
 export type InstallOutcome = { claudeWrapper: string; installedBin: string; pathAhead: boolean; timerLoaded: boolean; hubLoaded: boolean; checkIntervalS: number };
 
-export function isBinDirAhead(): boolean {
+export function isBinDirAhead(bin: { name: string; key: BinKey } = CLAUDE_BIN): boolean {
   const dirs = (process.env.PATH ?? "").split(":");
   const ourIdx = dirs.indexOf(paths.binDir);
   if (ourIdx < 0) return false;
   try {
-    const realDir = dirname(resolveRealBin(CLAUDE_BIN));
+    const realDir = dirname(resolveRealBin(bin));
     const realIdx = dirs.indexOf(realDir);
     return realIdx < 0 || ourIdx < realIdx;
   } catch {
@@ -88,7 +88,7 @@ exec ${JSON.stringify(bun)} --no-env-file run ${JSON.stringify(entry)} "$@"
 `;
 }
 
-export function installSupervisor(): InstallOutcome {
+function installEntryPoints(): string {
   const target = installedBin();
   const entry = realpathSync(Bun.main);
   if (isNixPackaged()) {
@@ -96,9 +96,13 @@ export function installSupervisor(): InstallOutcome {
   } else {
     writeFileAtomic(target, `#!/bin/sh\nexec ${JSON.stringify(process.execPath)} --no-env-file run ${JSON.stringify(entry)} "$@"\n`, 0o755);
   }
+  writeFileAtomic(join(paths.binDir, "xx"), `#!/bin/sh\nexec ${JSON.stringify(target)} "$@"\n`, 0o755);
+  return target;
+}
 
+export function installSupervisor(): InstallOutcome {
+  const target = installEntryPoints();
   writeFileAtomic(paths.supervisorLink, `#!/bin/sh\nexec ${JSON.stringify(target)} __supervise "$@"\n`, 0o755);
-  writeFileAtomic(join(paths.binDir, "xx"), `#!/bin/sh\nexec ${JSON.stringify(target)} "$@"\n`, 0o755);
 
   installSettings();
   const checkIntervalS = Math.ceil(loadConfig().policy.checkIntervalMs / 1000);
@@ -205,6 +209,14 @@ export function uninstallCodexSupervisor(): void {
   if (existsSync(codexSupervisorLink())) rmSync(codexSupervisorLink(), { force: true });
 }
 
+export function piSupervisorLink(): string {
+  return join(paths.binDir, "pi");
+}
+
+export function installPiSupervisor(): void {
+  writeFileAtomic(piSupervisorLink(), `#!/bin/sh\nexec ${JSON.stringify(installEntryPoints())} __supervise-pi "$@"\n`, 0o755);
+}
+
 export type UnitJob = {
   label: string;
   arg: string;
@@ -508,6 +520,7 @@ export function uninstallTargets(live: boolean): string[] {
     ...[CHECK_JOB, HUB_JOB].filter((job) => !job.skip()).map((job) => uninstallTarget(job, live)),
     paths.supervisorLink,
     codexSupervisorLink(),
+    piSupervisorLink(),
     join(paths.binDir, "xx"),
     installedBin(),
     ...(rc == null ? [] : [`${rc}: the ${PATH_LINE_MARK} line`]),
@@ -519,7 +532,7 @@ export function uninstallSupervisor(input: { live: boolean }): UninstallOutcome
   const timer = uninstallJob(CHECK_JOB, input.live);
   const hub = uninstallJob(HUB_JOB, input.live);
   uninstallCodexSupervisor();
-  for (const f of [paths.supervisorLink, join(paths.binDir, "xx"), installedBin()]) {
+  for (const f of [paths.supervisorLink, piSupervisorLink(), join(paths.binDir, "xx"), installedBin()]) {
     if (existsSync(f)) rmSync(f, { force: true });
   }
   const rc = shellRcPath();

package/src/lib/paths.ts

@@ -1,5 +1,5 @@
 import { homedir, userInfo } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { z } from "zod";
 
 const HOME = homedir();
@@ -88,6 +88,26 @@ export function codexSeatFromEnv(accountIds: string[], env: Record<string, strin
   return accountIds.find((id) => codexStoreDirFor(id) === home) ?? null;
 }
 
+export type PiPool = "claude" | "codex";
+
+export function expandTilde(p: string): string {
+  return p === "~" ? HOME : p.startsWith("~/") ? join(HOME, p.slice(2)) : p;
+}
+
+export const piPaths = {
+  home: resolve(expandTilde(env("PI_CODING_AGENT_DIR", join(HOME, ".pi", "agent")))),
+  storesDir: join(TM_HOME, "pi-stores"),
+  onboardDir: join(TM_HOME, "pi-onboard"),
+} as const;
+
+export function piStoreDirFor(pool: PiPool, accountId: string): string {
+  return join(piPaths.storesDir, pool, shortId(accountId));
+}
+
+export function piAuthJsonFor(pool: PiPool, accountId: string): string {
+  return join(piStoreDirFor(pool, accountId), "auth.json");
+}
+
 const GROK_HOME_DEFAULT = join(HOME, ".grok");
 
 export const grokPaths = {

package/src/lib/pi.ts

@@ -0,0 +1,132 @@
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+import { claude, ensurePathAhead, pickSeat } from "./claude.ts";
+import { MAX_WRAP_DEPTH, PI_BIN, WRAP_DEPTH_ENV, resolveRealBin, verifyRealBin } from "./claudebin.ts";
+import { codex, pickCodexSeat } from "./codex.ts";
+import { chatgptAccountIdOf } from "./codexauth.ts";
+import { CHECK_JOB, installPiSupervisor, isBinDirAhead, jobHealthy, piSupervisorLink } from "./install.ts";
+import { errorMessage, log } from "./log.ts";
+import { fetchTokenIdentity } from "./oauth.ts";
+import { claudePool, piPaths, type PiPool } from "./paths.ts";
+import { linkSharedPiHome, piStoreUsable, readPiAuthAt, type PiOAuth } from "./piauth.ts";
+import { StoreUnusableError, type Provider } from "./provider.ts";
+import { loadAccounts, pinBinOverride } from "./state.ts";
+import { restoreTermios, saveTermios } from "./tty.ts";
+import type { Account, ModelInfo } from "./types.ts";
+import { c } from "../cli/render.ts";
+
+const PROVIDER_TITLE: Record<PiPool, string> = { claude: "Anthropic (Claude Pro/Max)", codex: "OpenAI (ChatGPT Plus/Pro)" };
+
+export function piLoginStep(pool: PiPool): string {
+  return `In the pi session that opens, run  ${c.bold("/login")} , pick ${c.bold(PROVIDER_TITLE[pool])}, and sign in with that account. It closes itself once you're in.`;
+}
+
+export type PiLogin = { id: string; email: string | null; cred: PiOAuth };
+
+function landed(path: string, pool: PiPool): PiOAuth | null {
+  try {
+    return readPiAuthAt({ path, pool });
+  } catch {
+    return null;
+  }
+}
+
+async function identityOf(pool: PiPool, cred: PiOAuth): Promise<{ id: string; email: string | null } | null> {
+  if (pool === "codex") {
+    const id = chatgptAccountIdOf({ jwt: cred.access });
+    if (id == null) {
+      console.error(c.red("the pi login's access token carries no ChatGPT account id - nothing changed."));
+      return null;
+    }
+    return { id, email: null };
+  }
+  try {
+    const identity = await fetchTokenIdentity(cred.access);
+    return { id: identity.accountUuid, email: identity.email };
+  } catch (e) {
+    console.error(c.red(`could not verify which account the pi login belongs to (${errorMessage(e)}) - nothing changed.`));
+    return null;
+  }
+}
+
+export async function piLogin(pool: PiPool): Promise<PiLogin | null> {
+  const real = resolveRealBin(PI_BIN);
+  const onboardDir = piPaths.onboardDir;
+  rmSync(onboardDir, { recursive: true, force: true });
+  linkSharedPiHome(onboardDir);
+  const authPath = join(onboardDir, "auth.json");
+
+  const savedTermios = saveTermios();
+  const p = Bun.spawn([real, "--no-session", "--no-approve"], {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    env: { ...process.env, PI_CODING_AGENT_DIR: onboardDir, TOKENMAXXING_PROBE: "1", [WRAP_DEPTH_ENV]: String(MAX_WRAP_DEPTH) },
+  });
+
+  try {
+    let cred: PiOAuth | null = null;
+    let exited = false;
+    const onExit = p.exited.then(() => { exited = true; });
+    while (!exited) {
+      await Bun.sleep(400);
+      cred = landed(authPath, pool);
+      if (cred) {
+        p.kill();
+        break;
+      }
+    }
+    await onExit;
+    restoreTermios(savedTermios);
+    cred ??= landed(authPath, pool);
+    if (!cred) {
+      console.error(c.red(`no ${PROVIDER_TITLE[pool]} login landed in the isolated pi home - nothing changed.`));
+      return null;
+    }
+    const identity = await identityOf(pool, cred);
+    return identity ? { ...identity, cred } : null;
+  } finally {
+    if (p.exitCode === null) {
+      p.kill();
+      await p.exited;
+    }
+    restoreTermios(savedTermios);
+    rmSync(onboardDir, { recursive: true, force: true });
+  }
+}
+
+function piMover(base: Provider, pool: PiPool): Provider {
+  return {
+    ...base,
+    swap: async (target) => {
+      if (!piStoreUsable(pool, target.id)) {
+        throw new StoreUnusableError(`${target.label} has no pi login - run \`tokenmaxxing auth --pi${base.flag} ${target.label}\``);
+      }
+      log("move.prepared", { account: target.id.slice(0, 8), label: target.label, pi: true });
+    },
+    classifySwapError: (e) => (e instanceof StoreUnusableError ? "skip" : "fatal"),
+  };
+}
+
+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 {
+  const eligible = (a: Account) => piStoreUsable(pool, a.id);
+  return pool === "claude" ? pickSeat(now, model, eligible) : pickCodexSeat(now, eligible);
+}
+
+export function piPreflight(): void {
+  const real = resolveRealBin(PI_BIN);
+  const fail = verifyRealBin({ ...PI_BIN, bin: real });
+  if (fail !== null) throw new Error(`pi binary failed verification: ${real}: ${fail}`);
+  pinBinOverride({ key: "piBin", bin: real });
+}
+
+export function piInstall(): void {
+  installPiSupervisor();
+  console.log(`${c.green("✓")} pi supervisor installed at ${piSupervisorLink()}`);
+  if (!isBinDirAhead(PI_BIN)) ensurePathAhead();
+  if (loadAccounts(claudePool).accounts.length > 0 && !jobHealthy(CHECK_JOB)) {
+    console.log(c.yellow("⚠ the check timer is not active, so pi seats on Claude accounts get no fresh usage - run `tokenmaxxing init`"));
+  }
+}

package/src/lib/piauth.ts

@@ -0,0 +1,85 @@
+import { existsSync, mkdirSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { writeFileAtomic } from "./atomic.ts";
+import { piAuthJsonFor, piPaths, piStoreDirFor, type PiPool } from "./paths.ts";
+import { readJsonFile } from "./state.ts";
+import { ErrnoSchema } from "./types.ts";
+
+export const PI_PROVIDER: Record<PiPool, string> = { claude: "anthropic", codex: "openai-codex" };
+
+const PiOAuthSchema = z.looseObject({
+  type: z.literal("oauth"),
+  access: z.string().min(1),
+  refresh: z.string().min(1),
+  expires: z.number(),
+});
+export type PiOAuth = z.infer<typeof PiOAuthSchema>;
+
+const PiAuthFileSchema = z.record(z.string(), z.unknown());
+
+export function readPiAuthAt(input: { path: string; pool: PiPool }): PiOAuth | null {
+  let file: z.infer<typeof PiAuthFileSchema>;
+  try {
+    file = readJsonFile(input.path, PiAuthFileSchema);
+  } catch (e) {
+    if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return null;
+    throw e;
+  }
+  const entry = file[PI_PROVIDER[input.pool]];
+  if (entry === undefined) return null;
+  const parsed = PiOAuthSchema.safeParse(entry);
+  if (!parsed.success) throw new Error(`${input.path}: the ${PI_PROVIDER[input.pool]} entry is not a pi OAuth credential`);
+  return parsed.data;
+}
+
+export function readPiStore(pool: PiPool, accountId: string): PiOAuth | null {
+  return readPiAuthAt({ path: piAuthJsonFor(pool, accountId), pool });
+}
+
+export function piStoreUsable(pool: PiPool, accountId: string): boolean {
+  try {
+    return readPiStore(pool, accountId) != null;
+  } catch {
+    return false;
+  }
+}
+
+export function writePiStore(pool: PiPool, accountId: string, cred: PiOAuth): void {
+  writeFileAtomic(piAuthJsonFor(pool, accountId), JSON.stringify({ [PI_PROVIDER[pool]]: cred }, null, 2), 0o600);
+}
+
+export function deletePiStore(pool: PiPool, accountId: string): void {
+  rmSync(piStoreDirFor(pool, accountId), { recursive: true, force: true });
+}
+
+const SHARED_DIRS = ["sessions", "bin"];
+const SHARED_FILES = ["settings.json", "models-store.json", "trust.json"];
+
+export function linkSharedPiHome(dir: string): void {
+  mkdirSync(dir, { recursive: true });
+  for (const name of SHARED_DIRS) mkdirSync(join(piPaths.home, name), { recursive: true });
+  for (const name of SHARED_FILES) {
+    try {
+      writeFileSync(join(piPaths.home, name), "{}", { flag: "wx", mode: 0o600 });
+    } catch (e) {
+      if (ErrnoSchema.safeParse(e).data?.code !== "EEXIST") throw e;
+    }
+  }
+  for (const name of readdirSync(piPaths.home)) {
+    if (name.startsWith("auth.json") || name.endsWith(".lock")) continue;
+    const link = join(dir, name);
+    if (existsSync(link)) continue;
+    try {
+      symlinkSync(join(piPaths.home, name), link);
+    } catch (e) {
+      if (ErrnoSchema.safeParse(e).data?.code !== "EEXIST") throw e;
+    }
+  }
+}
+
+export function ensurePiStoreHome(pool: PiPool, accountId: string): string {
+  const store = piStoreDirFor(pool, accountId);
+  linkSharedPiHome(store);
+  return store;
+}

package/src/lib/sessions.ts

@@ -2,7 +2,7 @@ import { existsSync, readdirSync, realpathSync, rmSync, statSync, type Dirent }
 import { basename, join, sep } from "node:path";
 import { z } from "zod";
 import { errorMessage, log } from "./log.ts";
-import { codexPaths, grokPaths, opencodeGoPaths, paths } from "./paths.ts";
+import { codexPaths, grokPaths, opencodeGoPaths, paths, piPaths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
 import { presencePid } from "./presence.ts";
 import { readJsonFile } from "./state.ts";
@@ -45,7 +45,7 @@ function recordLiveSession(sid: string, current: string): void {
 const TMP_MARKER = ".tmp.";
 const TMP_GRACE_MS = 3600 * 1000;
 
-const STORE_PARENTS = [paths.storesDir, codexPaths.storesDir, grokPaths.storesDir, opencodeGoPaths.storesDir];
+const STORE_PARENTS = [paths.storesDir, codexPaths.storesDir, grokPaths.storesDir, opencodeGoPaths.storesDir, join(piPaths.storesDir, "claude"), join(piPaths.storesDir, "codex")];
 
 function listDir(dir: string, root: string): Dirent[] {
   if (!existsSync(dir)) return [];

package/src/lib/state.ts

@@ -35,10 +35,11 @@ export function loadConfig(): Config {
   cfg.codexBin = optionalEnv("TOKENMAXXING_CODEX_BIN") ?? cfg.codexBin;
   cfg.grokBin = optionalEnv("TOKENMAXXING_GROK_BIN") ?? cfg.grokBin;
   cfg.opencodeBin = optionalEnv("TOKENMAXXING_OPENCODE_BIN") ?? cfg.opencodeBin;
+  cfg.piBin = optionalEnv("TOKENMAXXING_PI_BIN") ?? cfg.piBin;
   return cfg;
 }
 
-export type BinKey = "claudeBin" | "codexBin" | "grokBin" | "opencodeBin";
+export type BinKey = "claudeBin" | "codexBin" | "grokBin" | "opencodeBin" | "piBin";
 
 export function pinBinOverride(input: { key: BinKey; bin: string }): void {
   const raw: Record<string, unknown> = existsSync(paths.configJson) ? readJsonFile(paths.configJson, z.record(z.string(), z.unknown())) : {};

package/src/lib/supervise.ts

@@ -5,7 +5,37 @@ import { paths } from "./paths.ts";
 import { writePresence } from "./presence.ts";
 import { restoreTermios } from "./tty.ts";
 
-export type WrappedProduct = "claude" | "codex";
+export type WrappedProduct = "claude" | "codex" | "pi";
+
+export const SEAT_POLL_MS = 10_000;
+export const SEAT_RETRY_MS = 60_000;
+
+export type Say = (terminal: string, text: string) => void;
+
+const clockFmt = new Intl.DateTimeFormat("en-US", { hour: "2-digit", minute: "2-digit", hourCycle: "h23", timeZoneName: "short" });
+
+export async function countdownWait(acct: string, until: number, out: { stream: boolean; say: Say }): Promise<boolean> {
+  let aborted = false;
+  const onInt = () => { aborted = true; };
+  process.on("SIGINT", onInt);
+  const minutes = Math.max(1, Math.ceil((until - Date.now()) / 60000));
+  out.say(
+    `\n\x1b[36m⏳ tokenmaxxing: all accounts at their limit. Resuming on ${acct} when it resets (Ctrl-C to resume now).\x1b[0m\n`,
+    `tokenmaxxing: all accounts at their limit. Resuming at ${clockFmt.format(until)} (in ${minutes} min) on ${acct}.`,
+  );
+  while (!aborted && Date.now() < until) {
+    if (!out.stream) {
+      const left = until - Date.now();
+      const m = Math.floor(left / 60000);
+      const s = Math.floor((left % 60000) / 1000);
+      process.stderr.write(`\r\x1b[36m   resuming in ${m}m ${String(s).padStart(2, "0")}s \x1b[0m`);
+    }
+    await Bun.sleep(1000);
+  }
+  process.removeListener("SIGINT", onInt);
+  out.say(`\n\x1b[36m↻ resuming on ${acct}...\x1b[0m\n`, `tokenmaxxing: resuming on ${acct}.`);
+  return aborted;
+}
 
 type ChildHandle = {
   pid: number;
@@ -18,6 +48,7 @@ type ChildHandle = {
 const WRAPPED: Record<WrappedProduct, { setting: string; binary: string; events: string }> = {
   claude: { setting: "claudeBin", binary: "Claude", events: "supervisor" },
   codex: { setting: "codexBin", binary: "codex", events: "codexsupervisor" },
+  pi: { setting: "piBin", binary: "pi", events: "pisupervisor" },
 };
 
 export function exitStatus(child: { exitCode: number | null; signalCode: string | null }): number {

package/src/lib/types.ts

@@ -104,6 +104,7 @@ export const ConfigSchema = z
     codexBin: z.string().default(""),
     grokBin: z.string().default(""),
     opencodeBin: z.string().default(""),
+    piBin: z.string().default(""),
     policy: z
       .object({
         projectionMargin: z.number().min(0).max(100).default(3),

package/src/main.ts

@@ -8,11 +8,12 @@ import { runBoundaryHook } from "./entries/stophook.ts";
 import { runStopFailureHook } from "./entries/stopfailurehook.ts";
 import { runCodexSupervisor } from "./entries/codexsupervisor.ts";
 import { runCodexStopHook } from "./entries/codexstophook.ts";
+import { runPiSupervisor } from "./entries/pisupervisor.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 { cmdInit, cmdInitPi } from "./cli/init.ts";
 import { cmdAdd } from "./cli/add.ts";
 import { cmdAuth } from "./cli/auth.ts";
 import { cmdStatus } from "./cli/status.ts";
@@ -34,6 +35,7 @@ const YES_FLAG = "--yes";
 const CODEX_FLAG = "--codex";
 const GROK_FLAG = "--grok";
 const OPENCODE_GO_FLAG = "--opencode-go";
+const PI_FLAG = "--pi";
 const JSON_COMMANDS = new Set(["status", "config", "check"]);
 const CODEX_COMMANDS = new Set(["init", "add", "auth", "rm", "rename", "seat"]);
 const STATUS_ONLY_COMMANDS = new Set(["init", "add", "auth", "rm", "rename"]);
@@ -45,11 +47,13 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing check")}      sample up to three accounts whose last usage attempts are 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: log in the first account, isolated, install codex supervisor + Stop hook
+  ${c.cyan("tokenmaxxing init --pi")}     install the pi supervisor: pi sessions run on pooled Claude or ChatGPT accounts that are logged into pi
   ${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 | --grok | --opencode-go   same for the codex, grok, or opencode-go pool
   ${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 auth --pi")} [--codex] [sel | --all]  log a pooled Claude account (or a codex account with --codex) into pi, isolated (bare = pick from a list; --all = every account without a pi login)
   ${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
@@ -80,6 +84,9 @@ async function main(): Promise<number> {
   if (argv0 === "codex" || argv[0] === "__supervise-codex") {
     return runCodexSupervisor({ argv: argv[0] === "__supervise-codex" ? argv.slice(1) : argv });
   }
+  if (argv0 === "pi" || argv[0] === "__supervise-pi") {
+    return runPiSupervisor(argv[0] === "__supervise-pi" ? argv.slice(1) : argv);
+  }
 
   jsonMode = argv.includes(JSON_FLAG);
   const json = jsonMode;
@@ -91,9 +98,20 @@ async function main(): Promise<number> {
     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 !== YES_FLAG && a !== CODEX_FLAG && a !== GROK_FLAG && a !== OPENCODE_GO_FLAG);
+  const pi = argv.includes(PI_FLAG);
+  const args = argv.filter((a) => a !== JSON_FLAG && a !== CACHED_FLAG && a !== YES_FLAG && a !== CODEX_FLAG && a !== GROK_FLAG && a !== OPENCODE_GO_FLAG && a !== PI_FLAG);
   const sub = args[0];
 
+  if (pi && sub !== "init" && sub !== "auth") {
+    emitError({ json, message: `${PI_FLAG} applies to init and auth, not ${sub ?? "status"}` });
+    return 2;
+  }
+
+  if (pi && (sub === "init" ? provider !== claude : provider !== claude && provider !== codex)) {
+    emitError({ json, message: sub === "init" ? `init ${PI_FLAG} takes no pool flag` : `auth ${PI_FLAG} logs a Claude account (no pool flag) or a codex account (${CODEX_FLAG}) into pi` });
+    return 2;
+  }
+
   if (cached && sub != null && sub !== "status") {
     emitError({ json, message: `${CACHED_FLAG} applies to status only, not ${sub}` });
     return 2;
@@ -143,9 +161,9 @@ async function main(): Promise<number> {
       return cmdCheck(json);
     }
     case "config": return cmdConfig(args.slice(1), json);
-    case "init": return cmdInit(provider);
+    case "init": return pi ? cmdInitPi() : cmdInit(provider);
     case "add": return cmdAdd(provider);
-    case "auth": return cmdAuth(provider, args.slice(1));
+    case "auth": return cmdAuth(provider, args.slice(1), pi ? (provider === codex ? "codex" : "claude") : null);
     case "doctor": return cmdDoctor();
     case "rm": return cmdRm(provider, args[1]);
     case "rename": return cmdRename(provider, args.slice(1));
@@ -180,7 +198,7 @@ async function main(): Promise<number> {
       if (out.timer === "still-loaded") console.log(c.yellow(`⚠ the check job may still be loaded - run: ${deactivationHint(CHECK_JOB)}`));
       if (out.hub === "still-loaded") console.log(c.yellow(`⚠ the usage hub job may still be loaded - run: ${deactivationHint(HUB_JOB)}`));
       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-stores/; grok: grok-stores/; opencode-go: opencode-go-stores/) - 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/; pi: pi-stores/; grok: grok-stores/; opencode-go: opencode-go-stores/) - remove accounts with \`xx rm\` to delete their credentials`);
       return 0;
     }
     case "help":