tokenmaxxing 1.57.0 → 1.58.0

package/src/entries/codexsupervisor.ts

@@ -1,17 +1,18 @@
 import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
-import { codexPaths, codexPool, paths } from "../lib/paths.ts";
+import { codexPaths, codexPool } from "../lib/paths.ts";
 import { withLock } from "../lib/lock.ts";
-import { LOOP_DIAGNOSIS, MAX_WRAP_DEPTH, UNMANAGED_ENV, WRAP_DEPTH_ENV, WRAP_RATE_MAX, WRAP_RATE_WINDOW_MS, wrapDepth, wrapperEntryRateTripped } from "../lib/claudebin.ts";
+import { UNMANAGED_ENV, WRAP_DEPTH_ENV, wrapDepth } from "../lib/claudebin.ts";
 import { resolveRealCodex } from "../lib/codexbin.ts";
 import { ensureCodexStoreHome } from "../lib/codexauth.ts";
 import { pickCodexSeat } from "../lib/codex.ts";
-import { clearPresence, writePresence } from "../lib/presence.ts";
-import { saveTermios, restoreTermios } from "../lib/tty.ts";
+import { clearPresence } from "../lib/presence.ts";
+import { exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, runPassthrough } from "../lib/supervise.ts";
+import { saveTermios } from "../lib/tty.ts";
 import { loadAccounts } from "../lib/state.ts";
 import { CodexRespawnMarkerSchema } from "../lib/types.ts";
-import { log } from "../lib/log.ts";
+import { errorMessage, log } from "../lib/log.ts";
 
 export const CODEX_SUPERVISOR_ID_ENV = "TOKENMAXXING_CODEX_SUPERVISOR_ID";
 
@@ -27,7 +28,7 @@ function readCodexMarker(marker: string): z.infer<typeof CodexRespawnMarkerSchem
   try {
     return CodexRespawnMarkerSchema.parse(JSON.parse(readFileSync(marker, "utf8")));
   } catch (e) {
-    log("codexsupervisor.marker_invalid", { err: e instanceof Error ? e.message : String(e) });
+    log("codexsupervisor.marker_invalid", { err: errorMessage(e) });
     throw new Error(
       `${marker} is corrupt (unparsable JSON or off-schema) - the codex session was stopped instead of resumed on a stale target; inspect and remove the marker, then run \`codex resume\``,
     );
@@ -54,52 +55,17 @@ export function shouldManageCodex(input: { argv: string[] }): boolean {
   return firstPositional === null || !NONINTERACTIVE_SUBCMDS.has(firstPositional);
 }
 
-async function recordCodexPresence(child: { pid: number; exitCode: number | null; signalCode: string | null; kill: () => void; exited: Promise<unknown> }, supervisorId: string, seat: { id: string }, savedTermios: string | null): Promise<void> {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      writePresence({ dir: codexPaths.presenceDir, id: supervisorId, accountId: seat.id, pid: child.pid });
-      return;
-    } catch (e) {
-      if (child.exitCode !== null || child.signalCode !== null) return;
-      if (attempt >= 9) {
-        log("codexsupervisor.presence_failed", { err: e instanceof Error ? e.message : String(e) });
-        child.kill();
-        await child.exited;
-        restoreTermios(savedTermios);
-        throw new Error("could not write the codex presence file - refusing to run an unprotected session (its account would look like a swap target)");
-      }
-      await Bun.sleep(100);
-    }
-  }
-}
-
 export async function runCodexSupervisor(input: { argv: string[] }): Promise<number> {
   const { argv } = input;
-  const depth = wrapDepth();
-  if (depth >= MAX_WRAP_DEPTH) {
-    console.error(
-      `tokenmaxxing: ${LOOP_DIAGNOSIS} (depth ${depth}) - codexBin in ${paths.configJson} does not launch the real codex binary. Fix codexBin, then run \`tokenmaxxing doctor\`.`,
-    );
-    log("codexsupervisor.loop_abort", { depth });
-    return 1;
-  }
-  if (wrapperEntryRateTripped(Date.now())) {
-    console.error(
-      `tokenmaxxing: ${LOOP_DIAGNOSIS} (over ${WRAP_RATE_MAX} wrapper entries in ${WRAP_RATE_WINDOW_MS / 1000}s) - codexBin in ${paths.configJson} does not launch the real codex binary. Fix codexBin, then run \`tokenmaxxing doctor\`.`,
-    );
-    log("codexsupervisor.rate_abort", { max: WRAP_RATE_MAX });
-    return 1;
-  }
+  if (loopGuardTripped("codex")) return 1;
 
   const real = resolveRealCodex();
-  const childEnv = { ...process.env, [WRAP_DEPTH_ENV]: String(depth + 1) };
+  const childEnv = { ...process.env, [WRAP_DEPTH_ENV]: String(wrapDepth() + 1) };
 
   if (!shouldManageCodex({ argv }) || process.env[UNMANAGED_ENV]) {
     const passthroughEnv: Record<string, string | undefined> = { ...childEnv };
     delete passthroughEnv[CODEX_SUPERVISOR_ID_ENV];
-    const p = Bun.spawn([real, ...argv], { stdin: "inherit", stdout: "inherit", stderr: "inherit", env: passthroughEnv });
-    await p.exited;
-    return p.exitCode ?? (p.signalCode ? 1 : 0);
+    return runPassthrough({ real, argv, env: passthroughEnv });
   }
 
   const supervisorId = crypto.randomUUID();
@@ -131,37 +97,29 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
           ...(store ? { CODEX_HOME: store } : {}),
         },
       });
-      if (picked) await recordCodexPresence(spawned, supervisorId, picked, savedTermios);
+      if (picked) {
+        await recordPresenceOrStop({
+          child: spawned,
+          dir: codexPaths.presenceDir,
+          id: supervisorId,
+          accountId: picked.id,
+          event: "codexsupervisor.presence_failed",
+          message: "could not write the codex presence file - refusing to run an unprotected session (its account would look like a swap target)",
+          savedTermios,
+        });
+      }
       return { child: spawned, seat: picked };
     });
 
-    let done = false;
-    const markerWatch = (async () => {
-      while (!done) {
-        if (existsSync(marker)) {
-          readCodexMarker(marker);
-          return true;
-        }
-        await Bun.sleep(150);
-      }
-      return false;
-    })();
-    const exited = child.exited.then(() => {
-      done = true;
-      return "exit";
+    await raceMarkerOrExit({
+      child,
+      tick: () => {
+        if (!existsSync(marker)) return false;
+        readCodexMarker(marker);
+        return true;
+      },
+      savedTermios,
     });
-    try {
-      const winner = await Promise.race([exited, markerWatch.then((found) => (found ? "marker" : "exit"))]);
-      if (winner === "marker") child.kill();
-    } catch (e) {
-      child.kill();
-      throw e;
-    } finally {
-      await child.exited;
-      done = true;
-      await markerWatch.catch(() => false);
-      restoreTermios(savedTermios);
-    }
 
     const payload = existsSync(marker) ? readCodexMarker(marker) : null;
     if (payload) {
@@ -175,6 +133,6 @@ export async function runCodexSupervisor(input: { argv: string[] }): Promise<num
     }
     clearPresence({ dir: codexPaths.presenceDir, id: supervisorId });
     log("codexsupervisor.exit", { supervisorId: supervisorId.slice(0, 8), respawns, code: child.exitCode, signal: child.signalCode });
-    return child.exitCode ?? (child.signalCode ? 1 : 0);
+    return exitStatus(child);
   }
 }

package/src/entries/statusline.ts

@@ -1,39 +1,32 @@
 import { sortBy } from "es-toolkit";
-import { z } from "zod";
 import { claudePool, seatFromEnv } from "../lib/paths.ts";
+import { errorMessage } from "../lib/log.ts";
 import { loadAccounts, loadConfig, writeUsage } from "../lib/state.ts";
 import { familyTokens, matchedFamily, parseStatusLineStdin, parseStatusLineModel } from "../lib/usage.ts";
 import { earliestReset, limitWindows, weeklyExpiry, weeklyWindow } from "../lib/picker.ts";
+import { readStdin } from "../lib/proc.ts";
 import { worktreeName } from "../lib/worktree.ts";
-import { makeColors, makeUsagePaint } from "../cli/render.ts";
-import { fmtResetShort } from "../lib/usage.ts";
+import { fmtResetShort, makeColors, makeUsagePaint, statuslineColor } from "../cli/render.ts";
 import {
-  AccountsIndexSchema,
   JsonTextSchema,
   StatusLineStdinSchema,
-  WindowSchema,
   type Account,
+  type AccountsIndex,
   type UsageState,
   type UsageWindow,
+  type Window,
 } from "../lib/types.ts";
 
-const RenderCtxSchema = z.object({
-  accounts: AccountsIndexSchema,
-  perModel: z.record(z.string(), WindowSchema),
-  switchModels: z.array(z.string()),
-  worktree: z.string().nullable(),
-  liveAccount: z.string().nullable(),
-  now: z.number(),
-  color: z.boolean(),
-  truecolor: z.boolean(),
-});
-export type RenderCtx = z.infer<typeof RenderCtxSchema>;
-
-export async function readStdin(): Promise<string> {
-  const chunks: Uint8Array[] = [];
-  for await (const c of Bun.stdin.stream()) chunks.push(c);
-  return Buffer.concat(chunks).toString("utf8");
-}
+export type RenderCtx = {
+  accounts: AccountsIndex;
+  perModel: Record<string, Window>;
+  switchModels: string[];
+  worktree: string | null;
+  liveAccount: string | null;
+  now: number;
+  color: boolean;
+  truecolor: boolean;
+};
 
 export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
   const col = makeColors(ctx.color);
@@ -134,7 +127,6 @@ export async function runStatusline(): Promise<number> {
     const accounts = loadAccounts(claudePool);
     const stdin = StatusLineStdinSchema.safeParse(obj);
     const dir = stdin.success ? (stdin.data.workspace?.current_dir ?? stdin.data.workspace?.project_dir ?? null) : null;
-    const colorterm = z.string().optional().parse(process.env.COLORTERM);
     const live = accounts.accounts.find((a) => a.id === account);
     const ctx: RenderCtx = {
       accounts,
@@ -143,12 +135,11 @@ export async function runStatusline(): Promise<number> {
       worktree: dir == null ? null : worktreeName(dir),
       liveAccount: account,
       now,
-      color: !process.env.NO_COLOR,
-      truecolor: colorterm != null && (colorterm.includes("truecolor") || colorterm.includes("24bit")),
+      ...statuslineColor(),
     };
     line = renderStatusline(obj, ctx);
   } catch (e) {
-    line = `tokenmaxxing: ${e instanceof Error ? e.message : String(e)}`;
+    line = `tokenmaxxing: ${errorMessage(e)}`;
   }
   process.stdout.write(line + "\n");
   return 0;

package/src/entries/stopfailurehook.ts

@@ -1,13 +1,13 @@
 import { z } from "zod";
 import { claude } from "../lib/claude.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
+import { readStdin } from "../lib/proc.ts";
 import { supervisedSession, writeRespawnMarker } from "../lib/sessions.ts";
 import { loadConfig } from "../lib/state.ts";
 import { classifyEnforcedLimit, findEnforcedRow, parseErrorBody, readTranscriptTail, type TranscriptRow } from "../lib/usage.ts";
 import { paths } from "../lib/paths.ts";
 import { JsonTextSchema, type EnforcedLimit } from "../lib/types.ts";
-import { log } from "../lib/log.ts";
-import { readStdin } from "./statusline.ts";
+import { errorMessage, log } from "../lib/log.ts";
 
 const StopFailureStdin = z.looseObject({
   session_id: z.uuid().optional().catch(undefined),
@@ -34,8 +34,7 @@ export async function runStopFailureHook(): Promise<number> {
 
   const account = claude.liveId();
   const now = Date.now();
-  const raw = await readStdin();
-  const parsed = StopFailureStdin.safeParse(JsonTextSchema.safeParse(raw).data);
+  const parsed = StopFailureStdin.safeParse(JsonTextSchema.safeParse(await readStdin()).data);
   const stdin = parsed.success ? parsed.data : {};
   if (stdin.error !== undefined && stdin.error !== "rate_limit") return 0;
 
@@ -84,7 +83,7 @@ export async function runStopFailureHook(): Promise<number> {
       log("stopfailure.decision", { reason: decision.reason, swapped: decision.swapped, account: decision.account?.id.slice(0, 8), waitUntil: decision.waitUntil });
     }
   } catch (e) {
-    log("stopfailure.error", { err: e instanceof Error ? e.message : String(e) });
+    log("stopfailure.error", { err: errorMessage(e) });
   }
   return 0;
 }

package/src/entries/stophook.ts

@@ -1,29 +1,31 @@
 import { z } from "zod";
 import { claude } from "../lib/claude.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
+import { readStdin } from "../lib/proc.ts";
 import { supervisedSession, writeRespawnMarker } from "../lib/sessions.ts";
 import { JsonTextSchema } from "../lib/types.ts";
-import { log } from "../lib/log.ts";
-import { readStdin } from "./statusline.ts";
+import { errorMessage, log } from "../lib/log.ts";
 
-const StopStdin = z.looseObject({ session_id: z.uuid().optional().catch(undefined) });
+const BoundaryStdin = z.looseObject({
+  source: z.string().optional(),
+  session_id: z.uuid().optional().catch(undefined),
+});
 
-export async function runStopHook(): Promise<number> {
+export async function runBoundaryHook(event: "stop" | "sessionstart"): Promise<number> {
   if (process.env.TOKENMAXXING_PROBE) return 0;
 
-  const raw = await readStdin();
-  const parsed = StopStdin.safeParse(JsonTextSchema.safeParse(raw).data);
-  const stdinSid = parsed.success ? parsed.data.session_id : undefined;
+  const parsed = BoundaryStdin.safeParse(JsonTextSchema.safeParse(await readStdin()).data);
+  const stdin = parsed.success ? parsed.data : {};
   const session = supervisedSession();
 
   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(), 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) });
+      writeRespawnMarker({ session, sessionId: stdin.session_id ?? session.sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? Date.now(), compact: true });
+      log(`${event}.${decision.waitUntil !== undefined ? "wait" : "move"}`, { source: stdin.source, account: decision.account.id.slice(0, 8), waitUntil: decision.waitUntil, session: session.sid.slice(0, 8) });
     }
   } catch (e) {
-    log("stop.error", { err: e instanceof Error ? e.message : String(e) });
+    log(`${event}.error`, { err: errorMessage(e) });
   }
   return 0;
 }

package/src/entries/subagentstatusline.ts

@@ -1,10 +1,8 @@
-import { z } from "zod";
-import { makeColors, makeUsagePaint } from "../cli/render.ts";
-import { readStdin } from "./statusline.ts";
+import { makeColors, makeUsagePaint, statuslineColor } from "../cli/render.ts";
+import { readStdin } from "../lib/proc.ts";
 import { JsonTextSchema, SubagentStatusLineStdinSchema } from "../lib/types.ts";
 
-const RowCtxSchema = z.object({ color: z.boolean(), truecolor: z.boolean() });
-export type RowCtx = z.infer<typeof RowCtxSchema>;
+export type RowCtx = { color: boolean; truecolor: boolean };
 
 function modelFamily(id: string): string {
   const [head, family] = id.split("-");
@@ -44,11 +42,7 @@ export function renderSubagentRows(stdinObj: unknown, ctx: RowCtx): string[] {
 
 export async function runSubagentStatusline(): Promise<number> {
   const obj = JsonTextSchema.safeParse(await readStdin()).data ?? null;
-  const colorterm = z.string().optional().parse(process.env.COLORTERM);
-  const rows = renderSubagentRows(obj, {
-    color: !process.env.NO_COLOR,
-    truecolor: colorterm != null && (colorterm.includes("truecolor") || colorterm.includes("24bit")),
-  });
+  const rows = renderSubagentRows(obj, statuslineColor());
   if (rows.length > 0) process.stdout.write(rows.join("\n") + "\n");
   return 0;
 }

package/src/entries/supervisor.ts

@@ -4,19 +4,21 @@ import type { FileSink, Subprocess } from "bun";
 import { maxBy } from "es-toolkit";
 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 { UNMANAGED_ENV, WRAP_DEPTH_ENV, resolveRealClaude, wrapDepth } from "../lib/claudebin.ts";
 import { claude, pickSeat } from "../lib/claude.ts";
 import { compactClaudeSession } from "../lib/compact.ts";
 import { evaluateAndMaybeSwap } from "../lib/decide.ts";
 import { withLock } from "../lib/lock.ts";
 import { thresholdBars, usableAt } from "../lib/picker.ts";
-import { clearPresence, writePresence } from "../lib/presence.ts";
+import { clearPresence } from "../lib/presence.ts";
+import { readLines } from "../lib/proc.ts";
 import { teeObservation } from "../lib/sample.ts";
-import { saveTermios, restoreTermios } from "../lib/tty.ts";
+import { exitStatus, loopGuardTripped, raceMarkerOrExit, recordPresenceOrStop, runPassthrough } from "../lib/supervise.ts";
+import { saveTermios } from "../lib/tty.ts";
 import { loadSessionFlags, pruneStaleSessions, saveSessionFlags, writeRespawnMarker } from "../lib/sessions.ts";
 import { loadAccounts, loadConfig } from "../lib/state.ts";
 import { RespawnMarkerSchema, type Account } from "../lib/types.ts";
-import { log } from "../lib/log.ts";
+import { errorMessage, log } from "../lib/log.ts";
 
 const NONINTERACTIVE_SUBCMDS = new Set([
   "mcp", "config", "doctor", "update", "install", "migrate-installer",
@@ -44,15 +46,14 @@ const OPTIONAL_VALUE_ROOT_FLAGS = new Set([
 
 const isUuid = (s: string) => z.uuid().safeParse(s).success;
 
-const AnalysisSchema = z.object({
-  manage: z.boolean(),
-  sessionId: z.string().nullable(),
-  resumeId: z.string().nullable(),
-  continueLatest: z.boolean(),
-  streamInput: z.boolean(),
-  streamOutput: z.boolean(),
-});
-type Analysis = z.infer<typeof AnalysisSchema>;
+type Analysis = {
+  manage: boolean;
+  sessionId: string | null;
+  resumeId: string | null;
+  continueLatest: boolean;
+  streamInput: boolean;
+  streamOutput: boolean;
+};
 
 export function analyzeArgs(argv: string[]): Analysis {
   let sessionId: string | null = null;
@@ -169,18 +170,17 @@ function latestSessionForCwd(): string | null {
   }
 }
 
-const MarkerGateSchema = z.object({
-  launchedAt: z.number(),
-  overriddenUntil: z.number(),
-});
-type MarkerGate = z.infer<typeof MarkerGateSchema>;
+type MarkerGate = {
+  launchedAt: number;
+  overriddenUntil: number;
+};
 
 function consumableMarker(marker: string, gate: MarkerGate): z.infer<typeof RespawnMarkerSchema> | null {
   let m: z.infer<typeof RespawnMarkerSchema>;
   try {
     m = RespawnMarkerSchema.parse(JSON.parse(readFileSync(marker, "utf8")));
   } catch (e) {
-    log("supervisor.marker_invalid", { err: e instanceof Error ? e.message : String(e) });
+    log("supervisor.marker_invalid", { err: errorMessage(e) });
     throw new Error(
       `${marker} is corrupt (unparsable JSON or off-schema) - the session was stopped instead of guessing whether the pool is depleted; inspect the marker, then run \`claude --resume ${basename(marker)}\` (a fresh launch clears it)`,
     );
@@ -222,7 +222,7 @@ async function moveExhaustedSeat(seat: Account, sid: string, gate: MarkerGate):
       writeRespawnMarker({ session: { sid, launchedAt: gate.launchedAt }, sessionId: sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? now, compact: true });
     }
   } catch (e) {
-    log("supervisor.seat_watch_error", { err: e instanceof Error ? e.message : String(e) });
+    log("supervisor.seat_watch_error", { err: errorMessage(e) });
   }
   return true;
 }
@@ -276,7 +276,7 @@ class StdinRelay {
 
   constructor() {
     this.pump()
-      .catch((e: unknown) => log("supervisor.relay_read_failed", { err: e instanceof Error ? e.message : String(e) }))
+      .catch((e: unknown) => log("supervisor.relay_read_failed", { err: errorMessage(e) }))
       .finally(() => {
         this.ended = true;
         this.close();
@@ -296,19 +296,7 @@ class StdinRelay {
   }
 
   private async pump(): Promise<void> {
-    const decoder = new TextDecoder();
-    let pending = "";
-    for await (const chunk of Bun.stdin.stream()) {
-      pending += decoder.decode(chunk, { stream: true });
-      let nl = pending.indexOf("\n");
-      while (nl !== -1) {
-        this.forward(pending.slice(0, nl + 1));
-        pending = pending.slice(nl + 1);
-        nl = pending.indexOf("\n");
-      }
-    }
-    pending += decoder.decode();
-    if (pending.length > 0) this.forward(`${pending}\n`);
+    for await (const line of readLines(Bun.stdin.stream())) this.forward(`${line}\n`);
   }
 
   private forward(line: string): void {
@@ -318,7 +306,7 @@ class StdinRelay {
         this.sink.flush();
         return;
       } catch (e) {
-        log("supervisor.relay_write_failed", { err: e instanceof Error ? e.message : String(e) });
+        log("supervisor.relay_write_failed", { err: errorMessage(e) });
         this.sink = null;
       }
     }
@@ -330,50 +318,17 @@ class StdinRelay {
     try {
       this.sink.end();
     } catch (e) {
-      log("supervisor.relay_end_failed", { err: e instanceof Error ? e.message : String(e) });
+      log("supervisor.relay_end_failed", { err: errorMessage(e) });
     }
     this.sink = null;
   }
 }
 
-async function recordPresence(child: Subprocess, sid: string, seat: Account, savedTermios: string | null): Promise<void> {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      writePresence({ dir: paths.presenceDir, id: sid, accountId: seat.id, pid: child.pid });
-      return;
-    } catch (e) {
-      if (child.exitCode !== null || child.signalCode !== null) return;
-      if (attempt >= 9) {
-        log("supervisor.presence_failed", { err: e instanceof Error ? e.message : String(e) });
-        child.kill();
-        await child.exited;
-        restoreTermios(savedTermios);
-        throw new Error("could not write the session presence file - refusing to run a session whose seat placement cannot see");
-      }
-      await Bun.sleep(100);
-    }
-  }
-}
-
 export async function runSupervisor(argv: string[]): Promise<number> {
-  const depth = wrapDepth();
-  if (depth >= MAX_WRAP_DEPTH) {
-    console.error(
-      `tokenmaxxing: ${LOOP_DIAGNOSIS} (depth ${depth}) - claudeBin in ${paths.configJson} does not launch the real Claude binary. Fix claudeBin, then run \`tokenmaxxing doctor\`.`,
-    );
-    log("supervisor.loop_abort", { depth });
-    return 1;
-  }
-  if (wrapperEntryRateTripped(Date.now())) {
-    console.error(
-      `tokenmaxxing: ${LOOP_DIAGNOSIS} (over ${WRAP_RATE_MAX} wrapper entries in ${WRAP_RATE_WINDOW_MS / 1000}s) - claudeBin in ${paths.configJson} does not launch the real Claude binary. Fix claudeBin, then run \`tokenmaxxing doctor\`.`,
-    );
-    log("supervisor.rate_abort", { max: WRAP_RATE_MAX });
-    return 1;
-  }
+  if (loopGuardTripped("claude")) return 1;
   const real = resolveRealClaude();
   const info = analyzeArgs(argv);
-  const childEnv = { ...process.env, [WRAP_DEPTH_ENV]: String(depth + 1) };
+  const childEnv = { ...process.env, [WRAP_DEPTH_ENV]: String(wrapDepth() + 1) };
 
   let child: Subprocess | null = null;
   let terminating = false;
@@ -387,10 +342,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
     const passthroughEnv: Record<string, string | undefined> = { ...childEnv };
     delete passthroughEnv.TOKENMAXXING_SUPERVISED;
     delete passthroughEnv.TOKENMAXXING_SESSION_ID;
-    const p = Bun.spawn([real, ...argv], { stdin: "inherit", stdout: "inherit", stderr: "inherit", env: passthroughEnv });
-    child = p;
-    await p.exited;
-    return p.exitCode ?? (p.signalCode ? 1 : 0);
+    return runPassthrough({ real, argv, env: passthroughEnv, onSpawn: (p) => { child = p; } });
   }
 
   let base = stripSessionFlags(argv);
@@ -458,44 +410,40 @@ export async function runSupervisor(argv: string[]): Promise<number> {
       });
       if (relay !== null) relay.attach(spawned.stdin!, firstLine);
       firstLine = null;
-      if (picked) await recordPresence(spawned, sid, picked, savedTermios);
+      if (picked) {
+        await recordPresenceOrStop({
+          child: spawned,
+          dir: paths.presenceDir,
+          id: sid,
+          accountId: picked.id,
+          event: "supervisor.presence_failed",
+          message: "could not write the session presence file - refusing to run a session whose seat placement cannot see",
+          savedTermios,
+        });
+      }
       return { child: spawned, seat: picked };
     });
 
     child = proc;
-    let done = false;
     let seatCheckAt = 0;
-    const markerWatch = (async () => {
-      while (!done) {
+    await raceMarkerOrExit({
+      child: proc,
+      tick: async () => {
         if (existsSync(marker) && consumableMarker(marker, gate) != null) return true;
         if (seat && !terminating && Date.now() >= seatCheckAt) {
           const decided = await moveExhaustedSeat(seat, sid, gate);
           seatCheckAt = Date.now() + (decided ? SEAT_RETRY_MS : SEAT_POLL_MS);
         }
-        await Bun.sleep(150);
-      }
-      return false;
-    })();
-    const exited = proc.exited.then(() => { done = true; return "exit" as const; });
-    try {
-      const winner = await Promise.race([exited, markerWatch.then((m) => (m ? "marker" : "exit"))]);
-      if (winner === "marker") {
+        return false;
+      },
+      savedTermios,
+      onKill: () => relay?.detach(),
+      onError: () => clearPresence({ dir: paths.presenceDir, id: sid }),
+      onExited: () => {
+        child = null;
         relay?.detach();
-        proc.kill();
-      }
-    } catch (e) {
-      relay?.detach();
-      proc.kill();
-      clearPresence({ dir: paths.presenceDir, id: sid });
-      throw e;
-    } finally {
-      await proc.exited;
-      child = null;
-      relay?.detach();
-      done = true;
-      await markerWatch.catch(() => {});
-      restoreTermios(savedTermios);
-    }
+      },
+    });
 
     const m = !terminating && existsSync(marker) ? consumableMarker(marker, gate) : null;
     if (m) {
@@ -528,6 +476,6 @@ export async function runSupervisor(argv: string[]): Promise<number> {
     }
     clearPresence({ dir: paths.presenceDir, id: sid });
     log("supervisor.exit", { sid, respawns, code: proc.exitCode, signal: proc.signalCode, terminated: terminating || undefined });
-    return proc.exitCode ?? (proc.signalCode ? 1 : 0);
+    return exitStatus(proc);
   }
 }