tokenmaxxing 1.42.0 → 1.43.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.43.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/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/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/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/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/types.ts

@@ -134,6 +134,7 @@ export const RespawnMarkerSchema = z.object({
   ts: z.number(),
   waitUntil: z.number(),
   sessionId: z.string(),
+  compact: z.boolean(),
   launchedAt: z.number().optional(),
 });