tokenmaxxing 1.42.0 → 1.44.0

package/DESIGN.md

@@ -57,7 +57,7 @@ The Stop hook's stdin has no usage data, but the **statusLine does** (`rate_limi
 4. Write `respawn/<session-id>` (atomic temp+rename) naming the target, with `waitUntil` now for a plain move or the soonest reset when the pool is depleted. No credential is written.
 
 ### 3.3 Move and depleted-pool pause (supervisor)
-The supervisor sees `respawn/<sid>`, SIGTERMs its child at the already-committed turn boundary, deletes the marker, resets the terminal, and (when `waitUntil` is in the future) shows an interruptible countdown to the reset; then it relaunches `claude --resume <sid>` with `CLAUDE_SECURESTORAGE_CONFIG_DIR` set to the target's store and rewrites the session's presence. The resumed process reads that store cold → runs on the target account, same conversation. The `SessionStart` hook (source `resume`) re-runs the decision before the first turn and writes the same marker if the seat is already over its bar or the pool is depleted. A marker that fails to parse is never deleted and treated as absent: the supervisor stops the child, restores the terminal, and exits naming the marker path.
+The supervisor sees `respawn/<sid>`, SIGTERMs its child at the already-committed turn boundary, deletes the marker, resets the terminal, compacts the conversation when the marker asks for it (`compact: true` from the Stop and SessionStart hooks, `false` from StopFailure: it runs `claude -p --resume <sid> /compact` under the old seat's store, bounded at five minutes, and a failure only prints why), and (when `waitUntil` is in the future) shows an interruptible countdown to the reset; then it relaunches `claude --resume <sid>` with `CLAUDE_SECURESTORAGE_CONFIG_DIR` set to the target's store and rewrites the session's presence. The resumed process reads that store cold → runs on the target account, same conversation. The `SessionStart` hook (source `resume`) re-runs the decision before the first turn and writes the same marker if the seat is already over its bar or the pool is depleted. A marker that fails to parse is never deleted and treated as absent: the supervisor stops the child, restores the terminal, and exits naming the marker path.
 
 ### 3.4 Placement (supervisor, under the pool lock)
 1. Fold every account's tee into the index.
@@ -93,7 +93,7 @@ The [profile](docs/content/docs/switching-profile.mdx) records observed cache re
 ---
 
 ## 6. Honest papercuts
-- **A move restarts the process.** Every move is a `claude` stop and `--resume`; anything typed in the split second before the SIGTERM is lost, the supervisor resets terminal mode so nothing is left garbled, and the first turn on the new account re-uploads context once (prompt cache is org-scoped; bigger on long transcripts).
+- **A move restarts the process.** Every move is a `claude` stop and `--resume`; anything typed in the split second before the SIGTERM is lost, the supervisor resets terminal mode so nothing is left garbled, and the first turn on the new account re-uploads context once (prompt cache is org-scoped). A bar-triggered move compacts on the old account first so that upload is the summary, not the transcript; a move after a refusal cannot, and re-uploads the full context.
 - **Single-turn overshoot.** If one turn jumps from under the threshold straight past the wall, that turn ends rate-limited; the StopFailure hook walls the seat and moves the session, and the next prompt continues the conversation on the fresh account. Projected threshold reduces this.
 - **Unsupervised sessions are not moved.** A claude started outside the supervisor runs on whatever login its environment names, by default Claude Code's default store, which tokenmaxxing never writes.
 - **One shared identity file.** `~/.claude.json` keeps a single `oauthAccount`, which Claude Code rewrites after whichever session refreshed last, so `/status` can show another session's email. The store decides which credential a session uses.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.42.0",
+  "version": "1.44.0",
   "description": "Automatic Claude Code account switching: pool multiple accounts, start each session on its own account, and resume a session on a fresher account when quota fills.",
   "type": "module",
   "license": "MIT",

package/src/cli/auth.ts

@@ -8,7 +8,7 @@ import { usageNote } from "./add.ts";
 import { c, count } from "./render.ts";
 import type { Account, AccountsIndex } from "../lib/types.ts";
 
-const AUTH_USAGE = "usage: tokenmaxxing auth [--codex] [<email|label|id> | --all]";
+const AUTH_USAGE = "usage: tokenmaxxing auth [--codex | --grok | --opencode-go] [<email|label|id> | --all]";
 
 const AuthPlanSchema = z.discriminatedUnion("kind", [
   z.object({ kind: z.literal("usage") }),

package/src/cli/init.ts

@@ -8,7 +8,11 @@ import { c, count } from "./render.ts";
 export function printUsage(p: Provider): void {
   console.log();
   console.log(`  ${c.bold("how to use")} - ${c.cyan("xx")} is shorthand for ${c.cyan("tokenmaxxing")}:`);
-  console.log(`    ${c.cyan(p.name)}             use ${p.name} as always; it switches accounts near quota automatically`);
+  if (p.statusOnly) {
+    console.log(`    ${c.cyan(`xx status`)}         view pooled ${p.name} accounts (status-only pool: no automatic switching yet)`);
+  } else {
+    console.log(`    ${c.cyan(p.name)}             use ${p.name} as always; it switches accounts near quota automatically`);
+  }
   console.log(`    ${c.cyan("xx")}                 show the pool with usage bars (same as ${c.cyan("xx status")})`);
   console.log(`    ${c.cyan(`xx add${p.flag}`)}             log in and pool another account`);
   console.log(`    ${c.cyan(`xx switch${p.flag}`)}          hop to the best account right now (the automatic switching needs no command)`);
@@ -37,7 +41,7 @@ export async function cmdInit(p: Provider): Promise<number> {
     await harvested.park();
     const idx = loadAccounts(p.pool);
     const imported = upsertAccount(idx, harvested, p.mergeWindows);
-    idx.activeId = p.seats === "live" ? harvested.id : null;
+    idx.activeId = !p.statusOnly && p.seats === "live" ? harvested.id : null;
     saveAccounts(p.pool, idx);
     return imported;
   });

package/src/cli/status.ts

@@ -2,9 +2,11 @@ import { chunk, sortBy } from "es-toolkit";
 import { z } from "zod";
 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 { loadAccounts, loadConfig, saveAccounts } from "../lib/state.ts";
 import { withLock } from "../lib/lock.ts";
-import { codexPool } from "../lib/paths.ts";
+import { codexPool, grokPool, opencodeGoPool } from "../lib/paths.ts";
 import { earliestReset, isExhausted, isSessionWindow, limitWindows, nextWeeklyReset, sessionWindow, thresholdBars, weeklyWindow } from "../lib/picker.ts";
 import type { Provider, SampleReport } from "../lib/provider.ts";
 import { bar, c, count, emitJson, fmtAgo } from "./render.ts";
@@ -52,7 +54,7 @@ const PoolReportSchema = z.object({
 });
 type PoolReport = z.infer<typeof PoolReportSchema>;
 
-const StatusReportSchema = z.object({ now: z.number(), claude: PoolReportSchema, codex: PoolReportSchema });
+const StatusReportSchema = z.object({ now: z.number(), claude: PoolReportSchema, codex: PoolReportSchema, grok: PoolReportSchema, opencodeGo: PoolReportSchema });
 export type StatusReport = z.infer<typeof StatusReportSchema>;
 
 function currentWindow(w: Window, now: number): WindowReport {
@@ -239,9 +241,11 @@ export async function cmdStatus(opts: { json?: boolean; cached?: boolean } = {})
   const claudeReport = await collect(claude, cfg, now, cached);
   if (!json) {
     const codexPooled = loadAccounts(codexPool).accounts.length > 0;
+    const grokPooled = loadAccounts(grokPool).accounts.length > 0;
+    const opencodeGoPooled = loadAccounts(opencodeGoPool).accounts.length > 0;
     if (claudeReport.accounts.length === 0) {
-      if (!codexPooled) {
-        console.log(c.dim("no accounts yet, run `tokenmaxxing init` (or `tokenmaxxing init --codex`)"));
+      if (!codexPooled && !grokPooled && !opencodeGoPooled) {
+        console.log(c.dim("no accounts yet, run `tokenmaxxing init` (or `tokenmaxxing init --codex`, `--grok`, `--opencode-go`)"));
         return 0;
       }
       console.log(c.dim("no claude accounts (run `tokenmaxxing init` to pool claude too)"));
@@ -252,13 +256,21 @@ export async function cmdStatus(opts: { json?: boolean; cached?: boolean } = {})
     }
   }
   const codexReport = await collect(codex, cfg, now, cached);
+  const grokReport = await collect(grok, cfg, now, cached);
+  const opencodeGoReport = await collect(opencodeGo, cfg, now, cached);
   if (json) {
-    const report: StatusReport = { now, claude: claudeReport, codex: codexReport };
+    const report: StatusReport = { now, claude: claudeReport, codex: codexReport, grok: grokReport, opencodeGo: opencodeGoReport };
     emitJson({ ok: true, ...report });
     return 0;
   }
   if (codexReport.accounts.length > 0) {
     renderPool(codex, codexReport, `codex  (${count({ n: codexReport.accounts.length, noun: "account" })})`, Date.now(), cfg.policy.usagePollTtlMs);
   }
+  if (grokReport.accounts.length > 0) {
+    renderPool(grok, grokReport, `grok  (${count({ n: grokReport.accounts.length, noun: "account" })}, status-only)`, Date.now(), cfg.policy.usagePollTtlMs);
+  }
+  if (opencodeGoReport.accounts.length > 0) {
+    renderPool(opencodeGo, opencodeGoReport, `opencode-go  (${count({ n: opencodeGoReport.accounts.length, noun: "account" })}, status-only)`, Date.now(), cfg.policy.usagePollTtlMs);
+  }
   return 0;
 }

package/src/entries/codexstophook.ts

@@ -4,12 +4,15 @@ import { z } from "zod";
 import { codexPaths, codexPool } from "../lib/paths.ts";
 import { withLock } from "../lib/lock.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
+import { MAX_WRAP_DEPTH, WRAP_DEPTH_ENV } from "../lib/claudebin.ts";
 import { codex, codexPickCtx, reconcileSiblings } from "../lib/codex.ts";
 import { liveCodexAccountId } from "../lib/codexauth.ts";
+import { resolveRealCodex } from "../lib/codexbin.ts";
+import { compactCodexThread } from "../lib/compact.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
 import { isExhausted } from "../lib/picker.ts";
 import { livingPresences } from "../lib/presence.ts";
-import { loadAccounts } from "../lib/state.ts";
+import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadConfig, loadLastSwapAt } from "../lib/state.ts";
 import { CODEX_SUPERVISOR_ID_ENV } from "./codexsupervisor.ts";
 import { CodexReconcileMarkerSchema, CodexRespawnMarkerSchema, CodexStopStdinSchema, JsonTextSchema } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
@@ -78,6 +81,22 @@ async function sweepSiblings(now: number): Promise<void> {
   }
 }
 
+async function compactBeforeMove(input: { sessionId: string | null; now: number }): Promise<void> {
+  const { sessionId, now } = input;
+  if (sessionId == null || sessionId.trim() === "") return;
+  const lastSwapAt = loadLastSwapAt(codexPool);
+  if (lastSwapAt != null && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) return;
+  const liveId = codex.liveId();
+  const live = loadAccounts(codexPool).accounts.find((a) => a.id === liveId);
+  if (!live || live.needsReauth === true || (live.enforcedUntil != null && live.enforcedUntil > now)) return;
+  const observed = await codex.observeLive(live, loadConfig(), now, { probe: true });
+  if (!observed || !isExhausted({ ...live, windows: observed.windows }, codexPickCtx(now, live.id))) return;
+  const env: Record<string, string | undefined> = { ...process.env, TOKENMAXXING_PROBE: "1", [WRAP_DEPTH_ENV]: String(MAX_WRAP_DEPTH) };
+  delete env[CODEX_SUPERVISOR_ID_ENV];
+  log("codexstop.compact_start", { thread: sessionId.slice(0, 8), account: live.id.slice(0, 8) });
+  await compactCodexThread({ real: resolveRealCodex(), threadId: sessionId, env });
+}
+
 async function readStdin(): Promise<string> {
   const chunks: Uint8Array[] = [];
   for await (const chunk of Bun.stdin.stream()) chunks.push(chunk);
@@ -97,6 +116,7 @@ export async function handleCodexStop(input: { rawStdin: string }): Promise<void
     if (await promoteReconcile({ supervisorId, sessionId })) return;
     const now = Date.now();
     await withLock(codexPool.lockFile, () => reconcileSiblings(now));
+    await compactBeforeMove({ sessionId, now });
     const decision = await evaluateAndMaybeSwap(codex, now);
     if (decision.swapped && decision.account) {
       await sweepSiblings(now);

package/src/entries/sessionstart.ts

@@ -23,7 +23,7 @@ export async function runSessionStart(): Promise<number> {
   try {
     const decision = await evaluateAndMaybeSwap(claude, Date.now(), session != null);
     if (session && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
-      writeRespawnMarker({ session, sessionId: stdinSid ?? session.sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? Date.now() });
+      writeRespawnMarker({ session, sessionId: stdinSid ?? session.sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? Date.now(), compact: true });
       log("sessionstart.marker", { source, account: decision.account.id.slice(0, 8), waitUntil: decision.waitUntil });
     }
   } catch (e) {

package/src/entries/stopfailurehook.ts

@@ -54,7 +54,7 @@ export async function runStopFailureHook(): Promise<number> {
 
     const decision = await evaluateAndMaybeSwap(claude, now, canRespawn && enforced != null, enforced);
     if (enforced && session && canRespawn && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
-      writeRespawnMarker({ session, sessionId: stdinSid ?? session.sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? now });
+      writeRespawnMarker({ session, sessionId: stdinSid ?? session.sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? now, compact: false });
       log("stopfailure.marker", { session: session.sid.slice(0, 8), account: decision.account.id.slice(0, 8), waitUntil: decision.waitUntil ?? now });
     } else {
       log("stopfailure.decision", { reason: decision.reason, swapped: decision.swapped, account: decision.account?.id.slice(0, 8), waitUntil: decision.waitUntil });

package/src/entries/stophook.ts

@@ -19,7 +19,7 @@ export async function runStopHook(): Promise<number> {
   try {
     const decision = await evaluateAndMaybeSwap(claude, Date.now(), session != null);
     if (session && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
-      writeRespawnMarker({ session, sessionId: stdinSid ?? session.sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? Date.now() });
+      writeRespawnMarker({ session, sessionId: stdinSid ?? session.sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? Date.now(), compact: true });
       log(decision.waitUntil !== undefined ? "stop.wait" : "stop.move", { account: decision.account.id.slice(0, 8), waitUntil: decision.waitUntil, session: session.sid.slice(0, 8) });
     }
   } catch (e) {

package/src/entries/supervisor.ts

@@ -6,6 +6,7 @@ import { z } from "zod";
 import { claudePool, paths, storeDirFor } from "../lib/paths.ts";
 import { LOOP_DIAGNOSIS, MAX_WRAP_DEPTH, UNMANAGED_ENV, WRAP_DEPTH_ENV, WRAP_RATE_MAX, WRAP_RATE_WINDOW_MS, resolveRealClaude, wrapDepth, wrapperEntryRateTripped } from "../lib/claudebin.ts";
 import { pickSeat } from "../lib/claude.ts";
+import { compactClaudeSession } from "../lib/compact.ts";
 import { withLock } from "../lib/lock.ts";
 import { clearPresence, writePresence } from "../lib/presence.ts";
 import { saveTermios, restoreTermios } from "../lib/tty.ts";
@@ -131,9 +132,16 @@ export function stripPositionals(argv: string[]): string[] {
   return out;
 }
 
+function projectDirForCwd(): string {
+  return join(paths.claudeDir, "projects", process.cwd().replace(/[^a-zA-Z0-9]/g, "-"));
+}
+
+function transcriptPath(sessionId: string): string {
+  return join(projectDirForCwd(), `${sessionId}.jsonl`);
+}
+
 function latestSessionForCwd(): string | null {
-  const slug = process.cwd().replace(/[^a-zA-Z0-9]/g, "-");
-  const projDir = join(paths.claudeDir, "projects", slug);
+  const projDir = projectDirForCwd();
   if (!existsSync(projDir)) return null;
   try {
     const files = readdirSync(projDir)
@@ -279,9 +287,9 @@ export async function runSupervisor(argv: string[]): Promise<number> {
     if (existsSync(marker)) rmSync(marker, { force: true });
 
     const gate: MarkerGate = { launchedAt: Date.now(), overriddenUntil };
-    const child = await withLock(claudePool.lockFile, async () => {
-      const seat = (wanted == null ? null : (loadAccounts(claudePool).accounts.find((a) => a.id === wanted) ?? null)) ?? pickSeat(gate.launchedAt);
-      log("supervisor.launch", { sid, respawns, seat: seat?.id.slice(0, 8) ?? null, args: launchArgs.join(" ") });
+    const { child, seat } = await withLock(claudePool.lockFile, async () => {
+      const picked = (wanted == null ? null : (loadAccounts(claudePool).accounts.find((a) => a.id === wanted) ?? null)) ?? pickSeat(gate.launchedAt);
+      log("supervisor.launch", { sid, respawns, seat: picked?.id.slice(0, 8) ?? null, args: launchArgs.join(" ") });
       const spawned = Bun.spawn([real, ...launchArgs], {
         stdin: "inherit",
         stdout: "inherit",
@@ -291,11 +299,11 @@ export async function runSupervisor(argv: string[]): Promise<number> {
           TOKENMAXXING_SUPERVISED: "1",
           TOKENMAXXING_SESSION_ID: sid,
           TOKENMAXXING_LAUNCHED_AT: String(gate.launchedAt),
-          ...(seat ? { CLAUDE_SECURESTORAGE_CONFIG_DIR: storeDirFor(seat.id) } : {}),
+          ...(picked ? { CLAUDE_SECURESTORAGE_CONFIG_DIR: storeDirFor(picked.id) } : {}),
         },
       });
-      if (seat) await recordPresence(spawned, sid, seat, savedTermios);
-      return spawned;
+      if (picked) await recordPresence(spawned, sid, picked, savedTermios);
+      return { child: spawned, seat: picked };
     });
 
     let done = false;
@@ -326,6 +334,16 @@ export async function runSupervisor(argv: string[]): Promise<number> {
       rmSync(marker, { force: true });
       respawns++;
       const label = loadAccounts(claudePool).accounts.find((a) => a.id === m.accountId)?.label ?? m.accountId.slice(0, 8);
+      if (m.compact && seat && existsSync(transcriptPath(m.sessionId))) {
+        process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: compacting the conversation on ${seat.label} before the move...\x1b[0m\n`);
+        const compactEnv: Record<string, string | undefined> = { ...childEnv, TOKENMAXXING_PROBE: "1", CLAUDE_SECURESTORAGE_CONFIG_DIR: storeDirFor(seat.id) };
+        delete compactEnv.TOKENMAXXING_SUPERVISED;
+        delete compactEnv.TOKENMAXXING_SESSION_ID;
+        delete compactEnv.TOKENMAXXING_LAUNCHED_AT;
+        const outcome = await compactClaudeSession({ real, sid: m.sessionId, env: compactEnv });
+        log("supervisor.compact", { sid: m.sessionId.slice(0, 8), seat: seat.id.slice(0, 8), ok: outcome.ok, reason: outcome.ok ? undefined : outcome.reason });
+        if (!outcome.ok) process.stdout.write(`\x1b[33m   compaction did not land (${outcome.reason}) - resuming with the full context\x1b[0m\n`);
+      }
       if (m.waitUntil > Date.now()) {
         if (await countdownWait(label, m.waitUntil)) overriddenUntil = m.waitUntil;
       } else process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: moving to ${label} - resuming...\x1b[0m\n`);

package/src/lib/claude.ts

@@ -274,6 +274,7 @@ export const claude: Provider = {
   pool: claudePool,
   seats: "shared",
   waitsWhenDepleted: true,
+  statusOnly: false,
   liveId,
   presence,
   gatedFamilies: (cfg) => {

package/src/lib/codex.ts

@@ -325,6 +325,7 @@ export const codex: Provider = {
   pool: codexPool,
   seats: "live",
   waitsWhenDepleted: false,
+  statusOnly: false,
   liveId: liveCodexAccountId,
   presence: () => seatCounts(codexPaths.presenceDir),
   gatedFamilies: () => null,

package/src/lib/compact.ts

@@ -0,0 +1,136 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { delay } from "es-toolkit";
+import { z } from "zod";
+import { log } from "./log.ts";
+import { JsonTextSchema } from "./types.ts";
+
+const CompactOutcomeSchema = z.discriminatedUnion("ok", [
+  z.object({ ok: z.literal(true) }),
+  z.object({ ok: z.literal(false), reason: z.string() }),
+]);
+export type CompactOutcome = z.infer<typeof CompactOutcomeSchema>;
+
+export const CLAUDE_COMPACT_KILL_MS = 300_000;
+const PIPE_GRACE_MS = 2_000;
+
+export async function compactClaudeSession(input: { real: string; sid: string; env: Record<string, string | undefined> }): Promise<CompactOutcome> {
+  const p = Bun.spawn([input.real, "-p", "--resume", input.sid, "/compact"], {
+    env: input.env,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    timeout: CLAUDE_COMPACT_KILL_MS,
+    killSignal: "SIGKILL",
+  });
+  const reads = Promise.all([new Response(p.stdout).text(), new Response(p.stderr).text()]);
+  const settled = await Promise.race([reads, p.exited.then(() => delay(PIPE_GRACE_MS)).then(() => null)]);
+  await p.exited;
+  if (settled === null) return { ok: false, reason: "output pipes still open after child exit (leaked descendant)" };
+  const [stdout, stderr] = settled;
+  if (p.exitCode === 0) return { ok: true };
+  if (p.exitCode === null) return { ok: false, reason: `killed after ${CLAUDE_COMPACT_KILL_MS / 1000}s` };
+  return { ok: false, reason: `exit ${p.exitCode}: ${(stderr.trim() || stdout.trim()).slice(0, 200)}` };
+}
+
+export const CODEX_COMPACT_KILL_MS = 180_000;
+
+const RpcLineSchema = z.looseObject({
+  id: z.union([z.number(), z.string()]).optional(),
+  method: z.string().optional(),
+  error: z.looseObject({ message: z.string().optional() }).optional(),
+  params: z.unknown().optional(),
+});
+const TurnCompletedSchema = z.looseObject({
+  threadId: z.string(),
+  turn: z.looseObject({ status: z.string(), error: z.looseObject({ message: z.string() }).nullable().optional() }),
+});
+const ErrorNotificationSchema = z.looseObject({ threadId: z.string().nullable().optional(), error: z.looseObject({ message: z.string().optional() }).optional() });
+
+const INIT_ID = 1;
+const RESUME_ID = 2;
+const COMPACT_ID = 3;
+
+const packageVersion = (): string =>
+  z.object({ version: z.string().min(1) }).parse(JSON.parse(readFileSync(join(import.meta.dir, "..", "..", "package.json"), "utf8"))).version;
+
+export async function compactCodexThread(input: { real: string; threadId: string; env: Record<string, string | undefined> }): Promise<CompactOutcome> {
+  const p = Bun.spawn([input.real, "app-server"], {
+    env: input.env,
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+    timeout: CODEX_COMPACT_KILL_MS,
+    killSignal: "SIGKILL",
+  });
+  const send = (msg: Record<string, unknown>): void => {
+    p.stdin.write(`${JSON.stringify(msg)}\n`);
+    p.stdin.flush();
+  };
+  const stderrText = new Response(p.stderr).text();
+
+  const outcome = await new Promise<CompactOutcome>((resolve) => {
+    let finished = false;
+    const finish = (o: CompactOutcome): void => {
+      if (finished) return;
+      finished = true;
+      resolve(o);
+    };
+    const onLine = (line: string): void => {
+      const parsed = RpcLineSchema.safeParse(JsonTextSchema.safeParse(line).data);
+      if (!parsed.success) return;
+      const msg = parsed.data;
+      if (msg.id === INIT_ID) {
+        if (msg.error) return finish({ ok: false, reason: `initialize failed: ${msg.error.message ?? "unknown error"}` });
+        send({ method: "initialized" });
+        send({ id: RESUME_ID, method: "thread/resume", params: { threadId: input.threadId } });
+        return;
+      }
+      if (msg.id === RESUME_ID) {
+        if (msg.error) return finish({ ok: false, reason: `thread/resume failed: ${msg.error.message ?? "unknown error"}` });
+        send({ id: COMPACT_ID, method: "thread/compact/start", params: { threadId: input.threadId } });
+        return;
+      }
+      if (msg.id === COMPACT_ID) {
+        if (msg.error) return finish({ ok: false, reason: `thread/compact/start failed: ${msg.error.message ?? "unknown error"}` });
+        return;
+      }
+      if (msg.method === "turn/completed") {
+        const turn = TurnCompletedSchema.safeParse(msg.params);
+        if (!turn.success || turn.data.threadId !== input.threadId) return;
+        if (turn.data.turn.status === "completed") return finish({ ok: true });
+        return finish({ ok: false, reason: `compaction turn ${turn.data.turn.status}: ${turn.data.turn.error?.message ?? "no error message"}` });
+      }
+      if (msg.method === "error") {
+        const err = ErrorNotificationSchema.safeParse(msg.params);
+        if (err.success && err.data.threadId != null && err.data.threadId !== input.threadId) return;
+        return finish({ ok: false, reason: `app-server error: ${err.success ? (err.data.error?.message ?? "unknown error") : "unparsable error notification"}` });
+      }
+    };
+    (async () => {
+      let buffered = "";
+      for await (const chunk of p.stdout) {
+        buffered += Buffer.from(chunk).toString("utf8");
+        let nl = buffered.indexOf("\n");
+        while (nl >= 0) {
+          onLine(buffered.slice(0, nl));
+          buffered = buffered.slice(nl + 1);
+          nl = buffered.indexOf("\n");
+        }
+      }
+      if (buffered.trim() !== "") onLine(buffered);
+      const err = (await stderrText).trim().slice(0, 200);
+      finish({ ok: false, reason: p.exitCode === null ? `app-server killed after ${CODEX_COMPACT_KILL_MS / 1000}s` : `app-server exited ${p.exitCode}: ${err}` });
+    })().catch((e) => finish({ ok: false, reason: e instanceof Error ? e.message : String(e) }));
+    send({ id: INIT_ID, method: "initialize", params: { clientInfo: { name: "tokenmaxxing", version: packageVersion() } } });
+  });
+
+  try {
+    p.stdin.end();
+  } catch {
+  }
+  p.kill();
+  await p.exited;
+  log("compact.codex", { thread: input.threadId.slice(0, 8), ok: outcome.ok, reason: outcome.ok ? undefined : outcome.reason });
+  return outcome;
+}

package/src/lib/grok.ts

@@ -0,0 +1,188 @@
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { writeFileAtomic } from "./atomic.ts";
+import { grokAuthJsonFor, grokPaths, grokPool, grokSeatFromEnv, grokStoreDirFor } from "./paths.ts";
+import type { Observation, Provider, SampleReport } from "./provider.ts";
+import { loadAccounts, loadConfig, pinBinOverride, type Harvest } from "./state.ts";
+import type { Account } from "./types.ts";
+import { c } from "../cli/render.ts";
+
+const GrokAuthEntrySchema = z.looseObject({
+  user_id: z.string().optional(),
+  principal_id: z.string().optional(),
+  email: z.string().nullish(),
+  first_name: z.string().nullish(),
+  refresh_token: z.string().optional(),
+  expires_at: z.string().nullish(),
+});
+type GrokAuthEntry = z.infer<typeof GrokAuthEntrySchema>;
+
+function parseGrokAuthFile(path: string): { key: string; entry: GrokAuthEntry }[] {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return [];
+  }
+  const map = z.record(z.string(), z.unknown()).safeParse(raw);
+  if (!map.success) return [];
+  const out: { key: string; entry: GrokAuthEntry }[] = [];
+  for (const [key, value] of Object.entries(map.data)) {
+    const parsed = GrokAuthEntrySchema.safeParse(value);
+    if (parsed.success) out.push({ key, entry: parsed.data });
+  }
+  return out;
+}
+
+function identityOf(key: string, entry: GrokAuthEntry): { id: string; email: string | null } {
+  const id = entry.user_id ?? entry.principal_id ?? key;
+  return { id, email: entry.email ?? null };
+}
+
+function resolveRealGrok(): string {
+  const cfg = loadConfig();
+  if (cfg.grokBin) {
+    if (!existsSync(cfg.grokBin)) throw new Error(`configured grokBin does not exist: ${cfg.grokBin} - fix config.json`);
+    return cfg.grokBin;
+  }
+  for (const d of (process.env.PATH ?? "").split(":")) {
+    if (!d) continue;
+    const cand = join(d, "grok");
+    try {
+      if (existsSync(cand)) return cand;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("could not locate the real `grok` binary (set grokBin in config.json)");
+}
+
+function liveId(): string | null {
+  return grokSeatFromEnv(loadAccounts(grokPool).accounts.map((a) => a.id));
+}
+
+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 --grok`" });
+  }
+  return reports;
+}
+
+async function storeUsable(a: Account): Promise<boolean> {
+  try {
+    const entries = parseGrokAuthFile(grokAuthJsonFor(a.id));
+    return entries.some((e) => identityOf(e.key, e.entry).id === a.id && (e.entry.refresh_token ?? "") !== "");
+  } catch {
+    return false;
+  }
+}
+
+async function removeCredentials(a: Account): Promise<void> {
+  rmSync(grokStoreDirFor(a.id), { recursive: true, force: true });
+}
+
+function harvestOf(key: string, entry: GrokAuthEntry): Harvest | null {
+  const { id, email } = identityOf(key, entry);
+  if (!id) return null;
+  return {
+    id,
+    email,
+    tier: null,
+    sample: null,
+    park: async () => {
+      mkdirSync(grokStoreDirFor(id), { recursive: true });
+      writeFileAtomic(grokAuthJsonFor(id), JSON.stringify({ [key]: entry }, null, 2), 0o600);
+    },
+  };
+}
+
+async function login(): Promise<Harvest | null> {
+  const real = resolveRealGrok();
+  const onboardDir = grokPaths.onboardDir;
+  rmSync(onboardDir, { recursive: true, force: true });
+  mkdirSync(onboardDir, { recursive: true });
+  const p = Bun.spawn([real, "login"], {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    env: { ...process.env, GROK_HOME: onboardDir, TOKENMAXXING_PROBE: "1" },
+  });
+  await p.exited;
+  try {
+    if (p.exitCode !== 0) {
+      console.error(c.red("no grok login landed in the isolated home - nothing added."));
+      return null;
+    }
+    const entries = parseGrokAuthFile(join(onboardDir, "auth.json"));
+    if (entries.length === 0) {
+      console.error(c.red("no grok login landed in the isolated home - nothing added."));
+      return null;
+    }
+    return harvestOf(entries[0]!.key, entries[0]!.entry);
+  } finally {
+    rmSync(onboardDir, { recursive: true, force: true });
+  }
+}
+
+async function importLive(): Promise<Harvest | null> {
+  console.log(c.cyan("Opening an isolated grok login for your first pooled account - the login you already have stays as it is."));
+  console.log();
+  const live = parseGrokAuthFile(join(grokPaths.home, "auth.json"));
+  if (live.length > 0) {
+    console.log(c.dim(`found ${live.length} grok login(s) in ${grokPaths.home} - pooling the first; use \`tokenmaxxing add --grok\` for the rest.`));
+    const h = harvestOf(live[0]!.key, live[0]!.entry);
+    if (h) return h;
+  }
+  return login();
+}
+
+function preflight(): void {
+  const real = resolveRealGrok();
+  const p = Bun.spawnSync([real, "--version"], { stdout: "pipe", stderr: "pipe", timeout: 15_000 });
+  const out = (p.stdout?.toString() ?? "").trim().toLowerCase();
+  if (p.exitCode !== 0 || !out.includes("grok")) {
+    throw new Error(`grok binary failed verification: ${real}`);
+  }
+  pinBinOverride({ key: "grokBin", bin: real });
+}
+
+function install(): void {
+  console.log(c.dim("grok pool is status-only: no supervisor or hooks installed. Use `tokenmaxxing status` to view pooled grok accounts."));
+}
+
+export const grok: Provider = {
+  name: "grok",
+  flag: " --grok",
+  pool: grokPool,
+  seats: "live",
+  waitsWhenDepleted: false,
+  statusOnly: true,
+  liveId,
+  presence,
+  gatedFamilies: () => null,
+  observeLive,
+  samplePool,
+  mergeWindows: (next) => next,
+  swap: async () => {
+    throw new Error("grok moves are not supported yet (status-only pool)");
+  },
+  classifySwapError: () => "fatal",
+  removeCredentials,
+  storeUsable,
+  login,
+  importLive,
+  preflight,
+  install,
+  loginStep: () => `Sign in in the browser session that opens (or run ${c.bold("grok login --device-auth")} on headless hosts first).`,
+  windowLabel: (name) => name.toLowerCase(),
+};

package/src/lib/install.ts

@@ -144,7 +144,7 @@ export function installCodexStopHook(): void {
       ...current.hooks,
       Stop: [
         ...withoutOurCodexStopHooks(current.hooks.Stop),
-        { hooks: [{ type: "command", command: codexStopHookCommand(), timeout: 120, statusMessage: "tokenmaxxing switch check" }] },
+        { hooks: [{ type: "command", command: codexStopHookCommand(), timeout: 300, statusMessage: "tokenmaxxing switch check" }] },
       ],
     },
   };

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

@@ -52,6 +52,18 @@ export const codexPool = {
   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")));
@@ -71,6 +83,41 @@ export function codexCredItemFor(accountId: string): string {
   return `tokenmaxxing-codex-${accountId.slice(0, 8)}`;
 }
 
+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 = {
   account: env("TOKENMAXXING_KEYCHAIN_ACCOUNT", process.env.USER ?? "unknown"),
 } as const;
@@ -111,4 +158,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/sessions.ts

@@ -48,13 +48,14 @@ export function supervisedSession(env: Record<string, string | undefined> = proc
   return SupervisedSessionSchema.parse({ sid, launchedAt: LaunchedAtSchema.parse(env.TOKENMAXXING_LAUNCHED_AT) ?? null });
 }
 
-export function writeRespawnMarker(input: { session: SupervisedSession; sessionId: string; accountId: string; waitUntil: number }): void {
+export function writeRespawnMarker(input: { session: SupervisedSession; sessionId: string; accountId: string; waitUntil: number; compact: boolean }): void {
   mkdirSync(paths.respawnDir, { recursive: true });
   const payload = RespawnMarkerSchema.parse({
     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/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),
@@ -134,6 +136,7 @@ export const RespawnMarkerSchema = z.object({
   ts: z.number(),
   waitUntil: z.number(),
   sessionId: z.string(),
+  compact: z.boolean(),
   launchedAt: z.number().optional(),
 });
 

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";
@@ -30,8 +32,11 @@ import { c, emitError } from "./cli/render.ts";
 const JSON_FLAG = "--json";
 const CACHED_FLAG = "--cached";
 const CODEX_FLAG = "--codex";
+const GROK_FLAG = "--grok";
+const OPENCODE_GO_FLAG = "--opencode-go";
 const JSON_COMMANDS = new Set(["status", "config", "check", "switch"]);
 const CODEX_COMMANDS = new Set(["init", "add", "auth", "switch", "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
@@ -40,15 +45,17 @@ function printHelp(): void {
   ${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 --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 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 switch --codex")} [sel]  switch the codex pool (takes effect on next codex start)
   ${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
@@ -79,8 +86,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 +105,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;