tokenmaxxing 1.81.0 → 1.83.0

package/src/entries/pisupervisor.ts

@@ -0,0 +1,442 @@
+import { closeSync, openSync, readdirSync, readFileSync, readSync, realpathSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import type { Subprocess } from "bun";
+import { sortBy, uniq } from "es-toolkit";
+import { z } from "zod";
+import { PI_BIN, UNMANAGED_ENV, WRAP_DEPTH_ENV, resolveRealBin, wrapDepth } from "../lib/claudebin.ts";
+import { observeCodex } from "../lib/codex.ts";
+import { evaluateAndMaybeSwap, type SwapDecision } from "../lib/decide.ts";
+import { withLock } from "../lib/lock.ts";
+import { errorMessage, log } from "../lib/log.ts";
+import { claudePool, codexPaths, expandTilde, optionalEnv, paths, piPaths, type PiPool } from "../lib/paths.ts";
+import { pickPiSeat, piMovers } from "../lib/pi.ts";
+import { ensurePiStoreHome, piStoreUsable } from "../lib/piauth.ts";
+import { thresholdBars, usableAt } from "../lib/picker.ts";
+import { clearPresence, livingPresences } from "../lib/presence.ts";
+import { teeObservation } from "../lib/sample.ts";
+import { countdownWait, exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, runPassthrough, SEAT_POLL_MS, SEAT_RETRY_MS } from "../lib/supervise.ts";
+import { saveTermios } from "../lib/tty.ts";
+import { loadAccounts, loadConfig, releaseWaitClaim } from "../lib/state.ts";
+import { gatedFamilies, modelFromFlag } from "../lib/usage.ts";
+import { ErrnoSchema, JsonTextSchema, type Account, type ModelInfo } from "../lib/types.ts";
+
+const SUBCOMMANDS = new Set(["install", "remove", "uninstall", "update", "list", "config", "auth"]);
+
+const UNMANAGED_FLAGS = new Set(["-h", "--help", "-v", "--version", "-p", "--print", "-r", "--resume", "--no-session", "--api-key", "--export", "--list-models"]);
+
+const VALUE_FLAGS = new Set([
+  "--provider", "--model", "--system-prompt", "--append-system-prompt", "-n", "--name", "--session-dir",
+  "--models", "-t", "--tools", "-xt", "--exclude-tools", "--thinking", "-e", "--extension", "--skill",
+  "--prompt-template", "--theme", "--use-theme", "--mode", "--tui-mode",
+]);
+
+const BOOLEAN_FLAGS = new Set([
+  "-nt", "--no-tools", "-nbt", "--no-builtin-tools", "-ne", "--no-extensions", "-ns", "--no-skills",
+  "-np", "--no-prompt-templates", "--no-themes", "-nc", "--no-context-files", "--verbose",
+  "-a", "--approve", "-na", "--no-approve", "--offline",
+]);
+
+type PiArgs = {
+  provider: string | null;
+  model: string | null;
+  sessionDir: string | null;
+  sessionId: string | null;
+  session: string | null;
+  fork: boolean;
+  continueLatest: boolean;
+  approve: boolean | null;
+  rest: string[];
+  flags: string[];
+};
+
+export function analyzePiArgs(argv: string[]): PiArgs | null {
+  if (argv[0] !== undefined && SUBCOMMANDS.has(argv[0])) return null;
+  const out: PiArgs = { provider: null, model: null, sessionDir: null, sessionId: null, session: null, fork: false, continueLatest: false, approve: null, rest: [], flags: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!;
+    if (a === "--") {
+      out.rest.push(...argv.slice(i));
+      break;
+    }
+    if (UNMANAGED_FLAGS.has(a)) return null;
+    if (a === "-c" || a === "--continue") {
+      out.continueLatest = true;
+      continue;
+    }
+    if (a === "--session-id" || a === "--session") {
+      const value = argv[++i];
+      if (value === undefined) return null;
+      if (a === "--session-id") out.sessionId = value;
+      else out.session = value;
+      continue;
+    }
+    out.rest.push(a);
+    if (a === "--fork") {
+      const value = argv[++i];
+      if (value === undefined) return null;
+      out.rest.push(value);
+      out.fork = true;
+      continue;
+    }
+    if (VALUE_FLAGS.has(a)) {
+      const value = argv[i + 1];
+      if (value === undefined) return null;
+      i++;
+      out.rest.push(value);
+      out.flags.push(a, value);
+      if (a === "--mode" && value !== "text") return null;
+      if (a === "--provider") out.provider = value;
+      else if (a === "--model") out.model = value;
+      else if (a === "--session-dir") out.sessionDir = value;
+      continue;
+    }
+    if (BOOLEAN_FLAGS.has(a)) {
+      out.flags.push(a);
+      if (a === "-a" || a === "--approve") out.approve = true;
+      else if (a === "-na" || a === "--no-approve") out.approve = false;
+      continue;
+    }
+    if (a.startsWith("--")) {
+      const next = argv[i + 1];
+      if (!a.includes("=") && next !== undefined && !next.startsWith("-") && !next.startsWith("@")) {
+        i++;
+        out.rest.push(next);
+        out.flags.push(a, next);
+      } else out.flags.push(a);
+      continue;
+    }
+    if (a.startsWith("-")) return null;
+  }
+  const selectors = [out.session != null, out.continueLatest, out.sessionId != null || out.fork].filter(Boolean).length;
+  return selectors > 1 ? null : out;
+}
+
+const PiSettingsSchema = z.looseObject({
+  defaultProvider: z.string().optional().catch(undefined),
+  sessionDir: z.string().optional().catch(undefined),
+  defaultProjectTrust: z.string().optional().catch(undefined),
+});
+type PiSettings = z.infer<typeof PiSettingsSchema>;
+type PiSettingsScopes = { global: PiSettings; project: PiSettings; projectTrusted: boolean };
+
+const PiTrustSchema = z.record(z.string(), z.unknown());
+
+function readPiJson<T extends z.ZodType>(file: string, schema: T): z.output<T> | null {
+  let text: string;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch (e) {
+    if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return null;
+    throw e;
+  }
+  const parsed = schema.safeParse(JsonTextSchema.safeParse(text.startsWith("") ? text.slice(1) : text).data);
+  if (!parsed.success) log("pisupervisor.pi_file_unreadable", { file });
+  return parsed.success ? parsed.data : null;
+}
+
+function projectTrusted(args: PiArgs, global: PiSettings): boolean {
+  if (args.approve != null) return args.approve;
+  const trust = readPiJson(join(piPaths.home, "trust.json"), PiTrustSchema) ?? {};
+  let dir = realpathSync(process.cwd());
+  while (true) {
+    const decision = trust[dir];
+    if (decision === true || decision === false) return decision;
+    const parent = dirname(dir);
+    if (parent === dir) return global.defaultProjectTrust === "always";
+    dir = parent;
+  }
+}
+
+function piSettings(args: PiArgs): PiSettingsScopes {
+  const global = readPiJson(join(piPaths.home, "settings.json"), PiSettingsSchema) ?? {};
+  return {
+    global,
+    project: readPiJson(join(process.cwd(), ".pi", "settings.json"), PiSettingsSchema) ?? {},
+    projectTrusted: projectTrusted(args, global),
+  };
+}
+
+function poolOf(args: PiArgs, settings: PiSettingsScopes): PiPool | null {
+  const slash = args.model?.indexOf("/") ?? -1;
+  const defaultProvider = (settings.projectTrusted ? settings.project.defaultProvider : undefined) ?? settings.global.defaultProvider;
+  const modelProvider = args.model == null ? defaultProvider : slash > 0 ? args.model.slice(0, slash) : undefined;
+  const provider = (args.provider ?? modelProvider)?.toLowerCase();
+  return provider === "anthropic" ? "claude" : provider === "openai-codex" ? "codex" : null;
+}
+
+function sessionModel(args: PiArgs): ModelInfo | null {
+  const id = args.model?.split(":")[0] ?? null;
+  return modelFromFlag(id == null ? null : id.slice(id.indexOf("/") + 1));
+}
+
+function sessionDirs(args: PiArgs, settings: PiSettingsScopes): string[] {
+  const custom = [args.sessionDir, optionalEnv("PI_CODING_AGENT_SESSION_DIR"), settings.project.sessionDir, settings.global.sessionDir]
+    .filter((d): d is string => d != null && d !== "")
+    .map((d) => resolve(expandTilde(d)));
+  const cwd = process.cwd();
+  const trimmed = cwd.startsWith("/") || cwd.startsWith("\\") ? cwd.slice(1) : cwd;
+  return uniq([...custom, join(piPaths.home, "sessions", `--${trimmed.replaceAll("/", "-").replaceAll("\\", "-").replaceAll(":", "-")}--`)]);
+}
+
+const SessionHeaderSchema = z.looseObject({ type: z.literal("session"), id: z.string(), cwd: z.string() });
+
+function sessionHeader(path: string): z.infer<typeof SessionHeaderSchema> | null {
+  let fd: number;
+  try {
+    fd = openSync(path, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const buf = Buffer.alloc(16 * 1024);
+    const text = buf.subarray(0, readSync(fd, buf, 0, buf.length, 0)).toString("utf8");
+    const end = text.indexOf("\n");
+    return SessionHeaderSchema.safeParse(JsonTextSchema.safeParse(end === -1 ? text : text.slice(0, end)).data).data ?? null;
+  } finally {
+    closeSync(fd);
+  }
+}
+
+function sessionFiles(dir: string): string[] {
+  try {
+    return readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return [];
+  }
+}
+
+function localSessions(dir: string): string[] {
+  const cwd = resolve(process.cwd());
+  const dated = sessionFiles(dir).flatMap((f) => {
+    try {
+      return [{ path: join(dir, f), mtime: statSync(join(dir, f)).mtimeMs }];
+    } catch {
+      return [];
+    }
+  });
+  return sortBy(dated, [(x) => -x.mtime]).flatMap(({ path }) => {
+    const header = sessionHeader(path);
+    return header != null && resolve(header.cwd) === cwd ? [header.id] : [];
+  });
+}
+
+function sessionIdFor(args: PiArgs, dir: string): string | null {
+  if (args.sessionId != null) return args.sessionId;
+  if (args.continueLatest) return localSessions(dir)[0] ?? crypto.randomUUID();
+  if (args.session == null) return crypto.randomUUID();
+  const arg = args.session;
+  if (arg.includes("/") || arg.includes("\\") || arg.endsWith(".jsonl")) return null;
+  const ids = localSessions(dir);
+  if (ids.includes(arg)) return arg;
+  const matches = ids.filter((s) => s.startsWith(arg));
+  return matches.length === 1 ? matches[0]! : null;
+}
+
+function sessionExists(dirs: string[], sid: string): boolean {
+  return dirs.some((dir) => sessionFiles(dir).some((f) => f.endsWith(`_${sid}.jsonl`)));
+}
+
+type Launch = { args: PiArgs; pool: PiPool; dirs: string[]; sid: string };
+
+function managedLaunch(argv: string[]): Launch | null {
+  if (process.stdin.isTTY !== true || process.stdout.isTTY !== true || process.env.TOKENMAXXING_PROBE || process.env[UNMANAGED_ENV]) return null;
+  const args = analyzePiArgs(argv);
+  if (args == null) return null;
+  const settings = piSettings(args);
+  const pool = poolOf(args, settings);
+  if (pool == null) {
+    log("pisupervisor.unpooled", {
+      provider: args.provider,
+      model: args.model,
+      projectTrusted: settings.projectTrusted,
+      defaultProvider: (settings.projectTrusted ? settings.project.defaultProvider : undefined) ?? settings.global.defaultProvider,
+    });
+    return null;
+  }
+  const dirs = sessionDirs(args, settings);
+  const sid = sessionIdFor(args, dirs[0]!);
+  if (sid == null) {
+    log("pisupervisor.session_unresolved", { session: args.session });
+    return null;
+  }
+  return { args, pool, dirs, sid };
+}
+
+const RESUME_PROMPT =
+  "tokenmaxxing resumed this session on an account with quota headroom. Continue the task from where the previous turn left off. If the previous turn ended waiting on the user, restate what you need and wait. The move restarted pi, which ended every command this session was still running. Relaunch what the task still needs.";
+
+function validWanted(pool: PiPool, wanted: string | null, id: string): Account | null {
+  if (wanted == null) return null;
+  const a = loadAccounts(piMovers[pool].pool).accounts.find((x) => x.id === wanted);
+  if (!a || a.needsReauth === true || !piStoreUsable(pool, a.id)) return null;
+  if (pool === "codex" && livingPresences(codexPaths.presenceDir).some((p) => p.accountId === a.id && p.id !== id)) return null;
+  return a;
+}
+
+type Watch = { decided: boolean; move: SwapDecision | null };
+
+async function watchSeat(input: { pool: PiPool; seatId: string; id: string; families: string[] | null; overriddenUntil: number }): Promise<Watch> {
+  try {
+    const now = Date.now();
+    const cfg = loadConfig();
+    const mover = piMovers[input.pool];
+    const account = loadAccounts(mover.pool).accounts.find((a) => a.id === input.seatId);
+    if (!account) return { decided: false, move: null };
+    const observed = input.pool === "claude" ? teeObservation(account) : await observeCodex(account, cfg, now, { probe: true, refresh: true, holder: input.id });
+    const unmeasured = input.pool === "codex" && (observed == null || now - observed.at > cfg.policy.usagePollTtlMs);
+    if (unmeasured) log("pisupervisor.seat_unmeasured", { seat: account.id.slice(0, 8), usageAt: observed?.at });
+    const current = observed ? { ...account, windows: observed.windows } : account;
+    const until = usableAt(current, { now, thresholds: thresholdBars(cfg), currentId: account.id, families: input.families, seats: null });
+    if (until <= now || until <= input.overriddenUntil) return { decided: unmeasured, move: null };
+    const decision = await evaluateAndMaybeSwap(mover, now, true, null, { seatId: account.id, ...(input.families ? { sessionFamilies: input.families } : {}), waiterId: input.id });
+    log("pisupervisor.seat_exhausted", { pool: input.pool, seat: account.id.slice(0, 8), until, reason: decision.reason, account: decision.account?.id.slice(0, 8), waitUntil: decision.waitUntil });
+    return { decided: true, move: decision.account && (decision.swapped || decision.waitUntil !== undefined) ? decision : null };
+  } catch (e) {
+    log("pisupervisor.seat_watch_error", { err: errorMessage(e) });
+    return { decided: true, move: null };
+  }
+}
+
+export async function runPiSupervisor(argv: string[]): Promise<number> {
+  if (loopGuardTripped("pi")) return 1;
+  let real: string;
+  try {
+    real = resolveRealBin(PI_BIN);
+  } catch (e) {
+    log("pisupervisor.resolve_failed", { err: errorMessage(e) });
+    throw e;
+  }
+  const childEnv = { ...process.env, [WRAP_DEPTH_ENV]: String(wrapDepth() + 1) };
+
+  let child: Subprocess | null = null;
+  let terminating = false;
+  let cleanup = async (): Promise<void> => {};
+  process.on("SIGTERM", () => {
+    terminating = true;
+    if (child) {
+      child.kill("SIGTERM");
+      return;
+    }
+    cleanup().finally(() => {
+      if (child) child.kill("SIGTERM");
+      else process.exit(143);
+    });
+  });
+
+  const launch = managedLaunch(argv);
+  if (launch == null) return runPassthrough({ real, argv, env: childEnv, onSpawn: (p) => { child = p; } });
+  const { args, pool, dirs, sid } = launch;
+
+  const id = `pi-${crypto.randomUUID()}`;
+  const mover = piMovers[pool];
+  const presenceDir = pool === "claude" ? paths.presenceDir : codexPaths.presenceDir;
+  const releaseClaim = async (): Promise<void> => {
+    if (pool !== "claude") return;
+    try {
+      await withLock(claudePool.lockFile, () => {
+        releaseWaitClaim(id);
+      });
+    } catch (e) {
+      log("pisupervisor.claim_release_failed", { err: errorMessage(e) });
+    }
+  };
+  cleanup = async () => {
+    clearPresence({ dir: presenceDir, id });
+    await releaseClaim();
+  };
+
+  const model = sessionModel(args);
+  const families = pool === "claude" ? gatedFamilies(model, loadConfig().policy.switchModels) : null;
+  const firstArgs = ["--session-id", sid, ...args.rest];
+  let launchArgs = firstArgs;
+
+  const savedTermios = saveTermios();
+  process.on("SIGINT", () => {});
+  process.on("SIGHUP", () => {});
+  const say = (terminal: string) => {
+    process.stderr.write(terminal);
+  };
+
+  let respawns = 0;
+  let wanted: string | null = null;
+  let overriddenUntil = 0;
+  try {
+    while (true) {
+      const launchedAt = Date.now();
+      const launched = await withLock(mover.pool.lockFile, async () => {
+        clearPresence({ dir: presenceDir, id });
+        if (terminating) return null;
+        const picked = validWanted(pool, wanted, id) ?? pickPiSeat(pool, launchedAt, model);
+        log("pisupervisor.launch", { id, pool, respawns, seat: picked?.id.slice(0, 8) ?? null, args: launchArgs.join(" ") });
+        const spawned = Bun.spawn([real, ...launchArgs], {
+          stdin: "inherit",
+          stdout: "inherit",
+          stderr: "inherit",
+          env: { ...childEnv, ...(picked ? { PI_CODING_AGENT_DIR: ensurePiStoreHome(pool, picked.id) } : {}) },
+        });
+        child = spawned;
+        if (picked) {
+          await recordPresenceOrStop({
+            child: spawned,
+            dir: presenceDir,
+            id,
+            accountId: picked.id,
+            event: "pisupervisor.presence_failed",
+            message: "could not write the pi session's presence file - refusing to run a session whose seat placement cannot see",
+            savedTermios,
+          });
+        }
+        return { proc: spawned, seat: picked };
+      });
+      if (launched == null) {
+        await releaseClaim();
+        return 143;
+      }
+
+      const { proc, seat } = launched;
+      const pending: { move: SwapDecision | null; killed: boolean } = { move: null, killed: false };
+      let seatCheckAt = 0;
+      await raceMarkerOrExit({
+        child: proc,
+        tick: async () => {
+          if (!seat || terminating || Date.now() < seatCheckAt) return false;
+          const watched = await watchSeat({ pool, seatId: seat.id, id, families, overriddenUntil });
+          seatCheckAt = Date.now() + (watched.decided ? SEAT_RETRY_MS : SEAT_POLL_MS);
+          pending.move = watched.move;
+          return watched.move !== null;
+        },
+        savedTermios,
+        onKill: () => {
+          pending.killed = true;
+        },
+        onError: () => clearPresence({ dir: presenceDir, id }),
+        onExited: () => {
+          child = null;
+        },
+      });
+
+      const target = pending.killed && !terminating ? (pending.move?.account ?? null) : null;
+      if (target) {
+        respawns++;
+        const waitUntil = pending.move?.waitUntil ?? 0;
+        if (waitUntil > Date.now()) {
+          if (await countdownWait(target.label, waitUntil, { stream: false, say })) overriddenUntil = waitUntil;
+        } else say(`\n\x1b[36m↻ tokenmaxxing: moving pi to ${target.label} - resuming...\x1b[0m\n`);
+        await releaseClaim();
+        wanted = target.id;
+        launchArgs = sessionExists(dirs, sid) ? ["--session-id", sid, ...args.flags, "--", RESUME_PROMPT] : firstArgs;
+        continue;
+      }
+      clearPresence({ dir: presenceDir, id });
+      await releaseClaim();
+      log("pisupervisor.exit", { id, respawns, code: proc.exitCode, signal: proc.signalCode, terminated: terminating || undefined });
+      return exitStatus(proc);
+    }
+  } catch (e) {
+    const msg = errorMessage(e);
+    say(`\n\x1b[31m${msg.startsWith("tokenmaxxing:") ? msg : `tokenmaxxing: ${msg}`}\x1b[0m\n`);
+    log("pisupervisor.fatal", { err: msg });
+    await releaseClaim();
+    return 1;
+  }
+}

package/src/entries/supervisor.ts

@@ -13,7 +13,7 @@ import { thresholdBars, usableAt } from "../lib/picker.ts";
 import { clearPresence } from "../lib/presence.ts";
 import { readLines } from "../lib/proc.ts";
 import { teeObservation } from "../lib/sample.ts";
-import { exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, runPassthrough } from "../lib/supervise.ts";
+import { countdownWait, exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, runPassthrough, SEAT_POLL_MS, SEAT_RETRY_MS, type Say } from "../lib/supervise.ts";
 import { saveTermios } from "../lib/tty.ts";
 import { liveSessionId, loadSessionFlags, pruneStaleSessions, saveSessionFlags, writeRespawnMarker } from "../lib/sessions.ts";
 import { loadAccounts, loadConfig, readJsonFile, releaseWaitClaim } from "../lib/state.ts";
@@ -203,9 +203,6 @@ function consumableMarker(marker: string, gate: MarkerGate): z.infer<typeof Resp
   return m;
 }
 
-const SEAT_POLL_MS = 10_000;
-const SEAT_RETRY_MS = 60_000;
-
 function seatBlockedUntil(seatId: string, now: number, families: string[], cfg: Config): number | null {
   const account = loadAccounts(claudePool).accounts.find((a) => a.id === seatId);
   if (!account) return null;
@@ -233,37 +230,10 @@ async function moveExhaustedSeat(seat: Account, sid: string, gate: MarkerGate, m
   return true;
 }
 
-type Say = (terminal: string, text: string) => void;
-
 function systemLine(sid: string, text: string): string {
   return `${JSON.stringify({ type: "system", subtype: "informational", content: text, level: "warning", uuid: crypto.randomUUID(), session_id: sid })}\n`;
 }
 
-const clockFmt = new Intl.DateTimeFormat("en-US", { hour: "2-digit", minute: "2-digit", hourCycle: "h23", timeZoneName: "short" });
-
-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;
-}
-
 function resumePrompt(input: { compacted: boolean; origin: z.infer<typeof RespawnMarkerSchema>["origin"] }): string {
   const moved = input.compacted
     ? "tokenmaxxing compacted this conversation and resumed the session on an account with quota headroom."
@@ -509,11 +479,13 @@ export async function runSupervisor(argv: string[]): Promise<number> {
       noticeSid = m.sessionId;
       const accounts = loadAccounts(claudePool).accounts;
       const label = accounts.find((a) => a.id === m.accountId)?.label ?? m.accountId.slice(0, 8);
-      const walled = accounts.some((a) => a.id === seat?.id && a.enforcedUntil != null && a.enforcedUntil > Date.now());
+      const walledUntil = accounts.find((a) => a.id === seat?.id)?.enforcedUntil ?? 0;
       const transcript = transcriptPath(m.sessionId);
       const resumable = existsSync(transcript);
       let compacted = false;
-      if (m.compact && seat && resumable && !walled) {
+      if (m.compact && seat && resumable && walledUntil > Date.now()) {
+        log("supervisor.compact_skipped", { sid: m.sessionId.slice(0, 8), seat: seat.id.slice(0, 8), until: walledUntil });
+      } else if (m.compact && seat && resumable) {
         say(`\n\x1b[36m↻ tokenmaxxing: compacting the conversation on ${seat.label} before the move...\x1b[0m\n`, `tokenmaxxing: compacting the conversation on ${seat.label} before the move.`);
         const compactEnv: Record<string, string | undefined> = { ...childEnv, TOKENMAXXING_PROBE: "1", CLAUDE_SECURESTORAGE_CONFIG_DIR: storeDirFor(seat.id) };
         delete compactEnv.TOKENMAXXING_SUPERVISED;

package/src/lib/claude.ts

@@ -9,6 +9,7 @@ import { errorMessage, log } from "./log.ts";
 import { claudeTierLabel, describeIdentity, fetchTokenIdentity, isDeadCredential, InvalidGrantError } from "./oauth.ts";
 import { claudePool, env, paths, seatFromEnv, storeDirFor } from "./paths.ts";
 import { pickBest, pickEarliestReset, thresholdBars, type PickCtx } from "./picker.ts";
+import { deletePiStore } from "./piauth.ts";
 import { seatCounts } from "./presence.ts";
 import { StoreUnusableError, type Observation, type Provider, type SampleReport } from "./provider.ts";
 import { foldTee, sampleAccountUsage, teeObservation, usageBlockedUntil } from "./sample.ts";
@@ -117,20 +118,22 @@ async function storeUsable(a: Account): Promise<boolean> {
   }
 }
 
-export function pickSeat(now: number, model: ModelInfo | null): Account | null {
+export function pickSeat(now: number, model: ModelInfo | null, eligible: (a: Account) => boolean = () => true): Account | null {
   const cfg = loadConfig();
   const idx = loadAccounts(claudePool);
   let dirty = false;
   for (const a of idx.accounts) dirty = foldTee(a) || dirty;
   if (dirty) saveAccounts(claudePool, idx);
   const ctx: PickCtx = { now, thresholds: thresholdBars(cfg), currentId: null, families: gatedFamilies(model, cfg.policy.switchModels), seats: presence() };
-  return pickBest(idx.accounts, ctx) ?? pickEarliestReset(idx.accounts, ctx)?.account ?? null;
+  const candidates = idx.accounts.filter(eligible);
+  return pickBest(candidates, ctx) ?? pickEarliestReset(candidates, ctx)?.account ?? null;
 }
 
 async function removeCredentials(a: Account): Promise<void> {
   await deleteItem(storeTarget(a.id));
   rmSync(storeDirFor(a.id), { recursive: true, force: true });
   rmSync(`${storeDirFor(a.id)}.lock`, { recursive: true, force: true });
+  deletePiStore("claude", a.id);
   clearUsageSnapshot(a.id);
 }
 
@@ -236,7 +239,7 @@ async function importLive(): Promise<Harvest | null> {
   return login();
 }
 
-function ensurePathAhead(): void {
+export function ensurePathAhead(): void {
   const rc = shellRcPath();
   if (!rc) {
     console.log(c.yellow(`⚠ add to your shell rc: export PATH="${paths.binDir}:$PATH"`));

package/src/lib/claudebin.ts

@@ -102,6 +102,15 @@ export function verifyRealBin(input: { bin: string; name: string; versionOk: (ve
 
 export const CLAUDE_BIN = { name: "claude", key: "claudeBin", versionOk: (out: string) => out.toLowerCase().includes("claude") } as const;
 export const CODEX_BIN = { name: "codex", key: "codexBin", versionOk: (out: string) => out.toLowerCase().includes("codex") } as const;
+function isBareVersion(out: string): boolean {
+  try {
+    return Bun.semver.order(out, "0.0.0") >= 0;
+  } catch {
+    return false;
+  }
+}
+
+export const PI_BIN = { name: "pi", key: "piBin", versionOk: isBareVersion } as const;
 
 export function resolveVerifiedClaude(): string {
   const candidates: string[] = [];

package/src/lib/codex.ts

@@ -4,7 +4,8 @@ import { writeFileAtomic } from "./atomic.ts";
 import { CODEX_BIN, MAX_WRAP_DEPTH, WRAP_DEPTH_ENV, resolveRealBin, verifyRealBin } from "./claudebin.ts";
 import { codexIdentityOf, codexStoreUsable, deleteCodexStoreAuth, isCodexAccessExpiring, readCodexAuthAt, readCodexStoreAuth, writeCodexStoreAuth } from "./codexauth.ts";
 import { CodexInvalidGrantError, CodexRefreshFailedError, refreshCodexAuth } from "./codexoauth.ts";
-import { seatCounts } from "./presence.ts";
+import { deletePiStore } from "./piauth.ts";
+import { livingPresences, seatCounts } from "./presence.ts";
 import { CodexUsageReadError, codexLimitLabel, fetchCodexUsage } from "./codexusage.ts";
 import { codexSupervisorLink, ensurePathInRc, installCodexSupervisor, managedShellRcSkipLines, shellRcPath } from "./install.ts";
 import { withLock } from "./lock.ts";
@@ -34,7 +35,7 @@ function applyUsage(account: Account, usage: CodexUsage, at: number): void {
 
 type CodexReadOutcome = { ok: true; usage: CodexUsage; at: number } | { ok: false; reason: string; deadGrant: boolean };
 
-async function readCodexUsage(account: Account, now: number, refresh: boolean): Promise<CodexReadOutcome> {
+async function readCodexUsage(account: Account, now: number, refresh: boolean, holder?: string): Promise<CodexReadOutcome> {
   let auth: CodexAuthJson | null;
   try {
     auth = readCodexStoreAuth(account.id);
@@ -47,7 +48,7 @@ async function readCodexUsage(account: Account, now: number, refresh: boolean):
       if (!refresh) {
         return { ok: false, reason: "stored access token is expiring and this read never refreshes a store", deadGrant: false };
       }
-      if (seatCounts(codexPaths.presenceDir).has(account.id)) {
+      if (livingPresences(codexPaths.presenceDir).some((p) => p.accountId === account.id && p.id !== holder)) {
         return { ok: false, reason: "running in a live codex session (store refresh unsafe)", deadGrant: false };
       }
       auth = await refreshCodexAuth({ auth, now });
@@ -62,9 +63,9 @@ async function readCodexUsage(account: Account, now: number, refresh: boolean):
   }
 }
 
-export async function observeCodex(account: Account, cfg: Config, now: number, opts: { probe: boolean; refresh: boolean }): Promise<Observation | null> {
+export async function observeCodex(account: Account, cfg: Config, now: number, opts: { probe: boolean; refresh: boolean; holder?: string }): Promise<Observation | null> {
   if (opts.probe && (account.lastUsageAt == null || now - account.lastUsageAt > cfg.policy.usagePollTtlMs)) {
-    const outcome = await readCodexUsage(account, now, opts.refresh);
+    const outcome = await readCodexUsage(account, now, opts.refresh, opts.holder);
     await withLock(codexPool.lockFile, () => {
       const idx = loadAccounts(codexPool);
       const a = idx.accounts.find((x) => x.id === account.id);
@@ -210,10 +211,10 @@ export function codexPickCtx(now: number, currentId: string | null): PickCtx {
   return { now, thresholds: thresholdBars(loadConfig()), currentId, families: null, seats: null };
 }
 
-export function pickCodexSeat(now: number): Account | null {
+export function pickCodexSeat(now: number, eligible: (a: Account) => boolean = (a) => codexStoreUsable(a.id)): Account | null {
   const ctx = codexPickCtx(now, null);
   const present = seatCounts(codexPaths.presenceDir);
-  const open = loadAccounts(codexPool).accounts.filter((a) => a.needsReauth !== true && !present.has(a.id) && codexStoreUsable(a.id));
+  const open = loadAccounts(codexPool).accounts.filter((a) => a.needsReauth !== true && !present.has(a.id) && eligible(a));
   return pickBest(open.filter((a) => !isExhausted(a, ctx)), ctx) ?? pickEarliestReset(open, ctx)?.account ?? null;
 }
 
@@ -232,7 +233,10 @@ export const codex: Provider = {
   mergeWindows: (next) => next,
   swap: prepareMove,
   classifySwapError: (e) => (e instanceof CodexInvalidGrantError ? "dead-grant" : e instanceof StoreUnusableError ? "skip" : "fatal"),
-  removeCredentials: async (a) => deleteCodexStoreAuth(a.id),
+  removeCredentials: async (a) => {
+    deleteCodexStoreAuth(a.id);
+    deletePiStore("codex", a.id);
+  },
   storeUsable: async (a) => codexStoreUsable(a.id),
   login,
   importLive,

package/src/lib/codexauth.ts

@@ -78,6 +78,14 @@ function decodeJwtPayload(input: { jwt: string }): unknown {
   return JSON.parse(payload);
 }
 
+export function chatgptAccountIdOf(input: { jwt: string }): string | null {
+  try {
+    return IdClaimsSchema.parse(decodeJwtPayload(input))["https://api.openai.com/auth"]?.chatgpt_account_id ?? null;
+  } catch {
+    return null;
+  }
+}
+
 export type CodexIdentity = { accountId: string; email: string | null; planType: string | null };
 
 export function codexIdentityOf(input: { auth: CodexAuthJson }): CodexIdentity {