tokenmaxxing 1.62.0 → 1.64.0

package/DESIGN.md

@@ -59,7 +59,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, compacts the conversation when the marker asks for it (`compact: true` from the Stop and SessionStart hooks and from the supervisor's own seat watch, `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 relaunch submits a first prompt that names the move (and the compaction, when it landed) and asks Claude to continue the task, so the conversation goes on without a keystroke: in a terminal session it is the positional prompt after the session id; in a stream-json session (`--input-format stream-json`, where the binary ignores a positional prompt) the supervisor owns stdin, relays the harness's lines to the child through a pipe, and writes the prompt as the first `user` line of the new process. In a terminal session the supervisor's own notices go to stderr. In a stream-json session (`--output-format stream-json`, read from the effective flags like the relay) there is no terminal and no statusline, so the supervisor writes each notice (the compaction and its failure, the move, the depleted-pool wait with its resume time, the resume) to stdout as a `system` line of subtype `informational` and level `warning`, the shape Claude Code emits for its own print-mode notices, which the harness renders in the conversation while the stream stays parseable; the per-second countdown ticks stay terminal-only, and the supervisor writes only while no child is running. The `SessionStart` hook (every source) 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. The supervisor also watches its own seat every ten seconds while the child runs (account record plus tee, the same bars) and writes the marker itself when the seat is at or over a bar, so a move never depends on a hook firing: a harness session between turns whose background workflow burns the window, or a subagent refusal that stamped the wall, is moved within seconds. SIGTERM to the supervisor is forwarded to the child and the supervisor exits after it, so a harness that stops the wrapper (the Agent SDK does) never leaves an orphaned claude on the old seat. A marker whose `launchedAt` does not match the running child is discarded, and after a Ctrl-C on the countdown a later marker whose `waitUntil` falls inside the skipped wait is ignored. A marker that fails to parse is never deleted and never treated as absent: the supervisor stops the child, restores the terminal, and exits naming the marker path. In a stream-json session that fatal, the wrap-depth abort, the wrap-rate abort, and a failed presence write also go to stdout as the same `informational`/`warning` line.
+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 and from the supervisor's own seat watch, `false` from StopFailure: it runs `claude -p --resume <live-id> /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 <live-id>` (`--session-id <live-id>` when that id has no transcript yet, because `--resume` exits with `No conversation found` for it) with `CLAUDE_SECURESTORAGE_CONFIG_DIR` set to the target's store and rewrites the session's presence. The marker file is keyed by the launch id `<sid>`; the live id inside it is the session id the supervised process runs now, which `/clear` and an in-session `/resume` change. A hook adopts a differing stdin id as the live id (`current` in `sessions/<sid>.json`) only when its own process descends, through shell processes alone, from the presence record's pid; any other differing id is a nested session and writes nothing. The resumed process reads that store cold → runs on the target account, same conversation. The `--session-id` path is the exception: the cleared conversation has no prior turn, so it starts empty with no compaction and no first prompt. On the `--resume` path the relaunch submits a first prompt that names the move (and the compaction, when it landed) and asks Claude to continue the task, so the conversation goes on without a keystroke: in a terminal session it is the positional prompt after the session id; in a stream-json session (`--input-format stream-json`, where the binary ignores a positional prompt) the supervisor owns stdin, relays the harness's lines to the child through a pipe, and writes the prompt as the first `user` line of the new process. In a terminal session the supervisor's own notices go to stderr. In a stream-json session (`--output-format stream-json`, read from the effective flags like the relay) there is no terminal and no statusline, so the supervisor writes each notice (the compaction and its failure, the move, the depleted-pool wait with its resume time, the resume) to stdout as a `system` line of subtype `informational` and level `warning`, the shape Claude Code emits for its own print-mode notices, which the harness renders in the conversation while the stream stays parseable; the per-second countdown ticks stay terminal-only, and the supervisor writes only while no child is running. The `SessionStart` hook (every source) 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. The supervisor also watches its own seat every ten seconds while the child runs (account record plus tee, the same bars) and writes the marker itself when the seat is at or over a bar, so a move never depends on a hook firing: a harness session between turns whose background workflow burns the window, or a subagent refusal that stamped the wall, is moved within seconds. SIGTERM to the supervisor is forwarded to the child and the supervisor exits after it, so a harness that stops the wrapper (the Agent SDK does) never leaves an orphaned claude on the old seat. A marker whose `launchedAt` does not match the running child is discarded, and after a Ctrl-C on the countdown a later marker whose `waitUntil` falls inside the skipped wait is ignored. A marker that fails to parse is never deleted and never treated as absent: the supervisor stops the child, restores the terminal, and exits naming the marker path. In a stream-json session that fatal, the wrap-depth abort, the wrap-rate abort, and a failed presence write also go to stdout as the same `informational`/`warning` line.
 
 ### 3.4 Placement (supervisor, under the pool lock)
 1. Fold every account's tee into the index.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.62.0",
+  "version": "1.64.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/stopfailurehook.ts

@@ -2,7 +2,7 @@ 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 { adoptLiveSession, 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";
@@ -39,15 +39,16 @@ export async function runStopFailureHook(): Promise<number> {
   if (stdin.error !== undefined && stdin.error !== "rate_limit") return 0;
 
   const stdinSid = stdin.session_id;
-  const session = supervisedSession();
   const mainLoop = stdin.agent_id === undefined;
-  if (stdinSid != null && session != null && stdinSid !== session.sid) {
-    log("stopfailure.nested_session", { stdin: stdinSid.slice(0, 8), supervised: session.sid.slice(0, 8) });
-    return 0;
-  }
-  const canRespawn = session != null && mainLoop;
 
   try {
+    const supervised = supervisedSession();
+    const session = supervised == null ? null : adoptLiveSession(supervised, stdinSid);
+    if (supervised != null && session == null) {
+      log("stopfailure.nested_session", { stdin: stdinSid?.slice(0, 8), supervised: supervised.live.slice(0, 8) });
+      return 0;
+    }
+    const canRespawn = session != null && mainLoop;
     const cfg = loadConfig();
     const row = stdin.transcript_path
       ? await awaitEnforcedRow({ transcriptPath: stdin.transcript_path, lastAssistantMessage: stdin.last_assistant_message, now })
@@ -81,8 +82,8 @@ 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, compact: false });
-      log("stopfailure.marker", { session: session.sid.slice(0, 8), account: decision.account.id.slice(0, 8), waitUntil: decision.waitUntil ?? now });
+      writeRespawnMarker({ session, accountId: decision.account.id, waitUntil: decision.waitUntil ?? now, compact: false });
+      log("stopfailure.marker", { session: session.sid.slice(0, 8), live: session.live.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

@@ -2,7 +2,7 @@ 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 { adoptLiveSession, supervisedSession, writeRespawnMarker } from "../lib/sessions.ts";
 import { JsonTextSchema } from "../lib/types.ts";
 import { errorMessage, log } from "../lib/log.ts";
 
@@ -16,18 +16,18 @@ export async function runBoundaryHook(event: "stop" | "sessionstart"): Promise<n
 
   const parsed = BoundaryStdin.safeParse(JsonTextSchema.safeParse(await readStdin()).data);
   const stdin = parsed.success ? parsed.data : {};
-  const session = supervisedSession();
-  const nested = stdin.session_id != null && session != null && stdin.session_id !== session.sid;
-  if (nested) {
-    log(`${event}.nested_session`, { stdin: stdin.session_id?.slice(0, 8), supervised: session?.sid.slice(0, 8) });
-    return 0;
-  }
 
   try {
+    const supervised = supervisedSession();
+    const session = supervised == null ? null : adoptLiveSession(supervised, stdin.session_id);
+    if (supervised != null && session == null) {
+      log(`${event}.nested_session`, { stdin: stdin.session_id?.slice(0, 8), supervised: supervised.live.slice(0, 8), source: stdin.source });
+      return 0;
+    }
     const decision = await evaluateAndMaybeSwap(claude, Date.now(), session != null);
     if (session && decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
-      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) });
+      writeRespawnMarker({ session, 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), live: session.live.slice(0, 8) });
     }
   } catch (e) {
     log(`${event}.error`, { err: errorMessage(e) });

package/src/entries/supervisor.ts

@@ -15,7 +15,7 @@ import { readLines } from "../lib/proc.ts";
 import { teeObservation } from "../lib/sample.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 { liveSessionId, loadSessionFlags, pruneStaleSessions, saveSessionFlags, writeRespawnMarker } from "../lib/sessions.ts";
 import { loadAccounts, loadConfig } from "../lib/state.ts";
 import { gatedFamilies, modelFromFlag } from "../lib/usage.ts";
 import { RespawnMarkerSchema, type Account, type Config, type ModelInfo } from "../lib/types.ts";
@@ -225,7 +225,7 @@ async function moveExhaustedSeat(seat: Account, sid: string, gate: MarkerGate, m
     const decision = await evaluateAndMaybeSwap(claude, now, true, null, seat.id, families);
     log("supervisor.seat_exhausted", { seat: seat.id.slice(0, 8), until, reason: decision.reason, account: decision.account?.id.slice(0, 8), waitUntil: decision.waitUntil });
     if (decision.account && (decision.swapped || decision.waitUntil !== undefined)) {
-      writeRespawnMarker({ session: { sid, launchedAt: gate.launchedAt }, sessionId: sid, accountId: decision.account.id, waitUntil: decision.waitUntil ?? now, compact: true });
+      writeRespawnMarker({ session: { sid, launchedAt: gate.launchedAt, live: liveSessionId(sid) }, accountId: decision.account.id, waitUntil: decision.waitUntil ?? now, compact: true });
     }
   } catch (e) {
     log("supervisor.seat_watch_error", { err: errorMessage(e) });
@@ -508,7 +508,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
       saveSessionFlags(m.sessionId, persistable, process.cwd());
       const prompt = resumable ? resumePrompt(compacted) : null;
       firstLine = relay !== null && prompt !== null ? userLine(prompt) : null;
-      launchArgs = ["--resume", m.sessionId, ...(relay === null && prompt !== null ? [prompt] : []), ...persistable];
+      launchArgs = [resumable ? "--resume" : "--session-id", m.sessionId, ...(relay === null && prompt !== null ? [prompt] : []), ...persistable];
       continue;
     }
     clearPresence({ dir: paths.presenceDir, id: sid });

package/src/lib/claude.ts

@@ -8,7 +8,7 @@ import { ensurePathInRc, installSupervisor, managedShellRcSkipLines, shellRcPath
 import { withLock } from "./lock.ts";
 import { errorMessage, log } from "./log.ts";
 import { claudeTierLabel, describeIdentity, fetchTokenIdentity, isDeadCredential, InvalidGrantError } from "./oauth.ts";
-import { claudePool, env, paths, sampleDirFor, seatFromEnv, storeDirFor } from "./paths.ts";
+import { claudePool, env, paths, seatFromEnv, storeDirFor } from "./paths.ts";
 import { pickBest, pickEarliestReset, thresholdBars, type PickCtx } from "./picker.ts";
 import { seatCounts } from "./presence.ts";
 import type { Observation, Provider, SampleReport } from "./provider.ts";
@@ -138,7 +138,6 @@ async function removeCredentials(a: Account): Promise<void> {
   await deleteItem(storeTarget(a.id));
   rmSync(storeDirFor(a.id), { recursive: true, force: true });
   rmSync(`${storeDirFor(a.id)}.lock`, { recursive: true, force: true });
-  for (const dir of [sampleDirFor(a.id), sampleDirFor(a.id, "-tick")]) rmSync(dir, { recursive: true, force: true });
   clearUsageSnapshot(a.id);
   const setupTokens = loadSetupTokens();
   if (setupTokens.tokens.some((t) => t.accountUuid === a.id)) {

package/src/lib/paths.ts

@@ -26,10 +26,10 @@ export const paths = {
   supervisorLink: join(TM_HOME, "bin", "claude"),
   logFile: join(TM_HOME, "tokenmaxxing.log"),
   onboardDir: join(TM_HOME, "onboard"),
-  sampleDir: join(TM_HOME, "sample"),
   storesDir: join(TM_HOME, "stores"),
   setupTokensJson: join(TM_HOME, "setup-tokens.json"),
   setupTokenDir: join(TM_HOME, "setup-token"),
+  cloudDir: join(TM_HOME, "cloud"),
   cloudSessionsJson: join(TM_HOME, "cloud", "sessions.json"),
   cloudWalledJson: join(TM_HOME, "cloud", "walled.json"),
   cloudLockFile: join(TM_HOME, "cloud", "lock"),
@@ -139,10 +139,6 @@ export function storeDirFor(accountId: string): string {
   return join(paths.storesDir, shortId(accountId));
 }
 
-export function sampleDirFor(accountId: string, suffix = ""): string {
-  return join(paths.sampleDir, `${shortId(accountId)}${suffix}`);
-}
-
 export function usageJsonFor(accountId: string): string {
   return join(paths.usageDir, `${shortId(accountId)}.json`);
 }

package/src/lib/presence.ts

@@ -18,6 +18,17 @@ export function writePresence(input: { dir: string; id: string; accountId: strin
   writeFileAtomic(join(input.dir, input.id), JSON.stringify(PresenceSchema.parse({ accountId: input.accountId, pid: input.pid, startedAt })));
 }
 
+export function presencePid(input: { dir: string; id: string }): number | null {
+  let raw: string;
+  try {
+    raw = readFileSync(join(input.dir, input.id), "utf8");
+  } catch (e) {
+    if (ErrnoSchema.safeParse(e).data?.code === "ENOENT") return null;
+    throw e;
+  }
+  return PresenceSchema.parse(JSON.parse(raw)).pid;
+}
+
 export function clearPresence(input: { dir: string; id: string }): void {
   rmSync(join(input.dir, input.id), { force: true });
 }

package/src/lib/proc.ts

@@ -1,5 +1,30 @@
+import { basename } from "node:path";
 import { ErrnoSchema } from "./types.ts";
 
+const SHELLS = new Set(["sh", "bash", "dash", "zsh", "ksh", "fish"]);
+const MAX_SHELL_HOPS = 4;
+
+function parentAndName(pid: number): { ppid: number; comm: string } | null {
+  const res = Bun.spawnSync(["ps", "-p", String(pid), "-o", "ppid=", "-o", "comm="], { env: { ...process.env, LC_ALL: "C" } });
+  if (res.exitCode !== 0) return null;
+  const row = res.stdout.toString().trim();
+  const cut = row.indexOf(" ");
+  if (cut === -1) return null;
+  const ppid = Number(row.slice(0, cut));
+  return Number.isInteger(ppid) ? { ppid, comm: row.slice(cut).trim() } : null;
+}
+
+export function spawnedThroughShellsBy(ancestor: number): boolean {
+  let cur = process.ppid;
+  for (let hop = 0; hop <= MAX_SHELL_HOPS; hop++) {
+    if (cur === ancestor) return true;
+    const proc = parentAndName(cur);
+    if (proc == null || !SHELLS.has(basename(proc.comm))) return false;
+    cur = proc.ppid;
+  }
+  return false;
+}
+
 export function pidStartTime(pid: number): string | null {
   const res = Bun.spawnSync(["ps", "-p", String(pid), "-o", "lstart="], { env: { ...process.env, LC_ALL: "C" } });
   if (res.exitCode !== 0) return null;

package/src/lib/sessions.ts

@@ -1,54 +1,130 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, type Dirent } from "node:fs";
+import { basename, join, sep } from "node:path";
 import { z } from "zod";
-import { paths } from "./paths.ts";
+import { errorMessage, log } from "./log.ts";
+import { codexPaths, grokPaths, opencodeGoPaths, paths } from "./paths.ts";
 import { writeFileAtomic } from "./atomic.ts";
+import { presencePid } from "./presence.ts";
+import { spawnedThroughShellsBy } from "./proc.ts";
 import type { RespawnMarkerSchema } from "./types.ts";
 
-const SessionSchema = z.object({ flags: z.array(z.string()), cwd: z.string() });
+const SessionSchema = z.object({ flags: z.array(z.string()), cwd: z.string(), current: z.uuid().optional() });
 
 const SESSION_RETENTION_MS = 30 * 24 * 3600 * 1000;
 
+const sessionsDir = (): string => join(paths.home, "sessions");
+
 function sessionFile(sid: string): string {
-  return join(paths.home, "sessions", `${sid}.json`);
+  return join(sessionsDir(), `${sid}.json`);
 }
 
 export function saveSessionFlags(sid: string, flags: string[], cwd: string): void {
-  mkdirSync(join(paths.home, "sessions"), { recursive: true });
+  mkdirSync(sessionsDir(), { recursive: true });
   writeFileAtomic(sessionFile(sid), JSON.stringify({ flags, cwd }));
 }
 
-export function loadSessionFlags(sid: string): string[] | null {
+function loadSession(sid: string): z.infer<typeof SessionSchema> | null {
   const f = sessionFile(sid);
   if (!existsSync(f)) return null;
-  return SessionSchema.parse(JSON.parse(readFileSync(f, "utf8"))).flags;
+  return SessionSchema.parse(JSON.parse(readFileSync(f, "utf8")));
 }
 
-const DEAD_STATE_FILES = ["model-usage.json", "accounts.json.v1-backup", "codex-accounts.json.v1-backup"];
+export function loadSessionFlags(sid: string): string[] | null {
+  return loadSession(sid)?.flags ?? null;
+}
 
-function pruneDeadState(): void {
-  for (const name of DEAD_STATE_FILES) {
+export function liveSessionId(sid: string): string {
+  return loadSession(sid)?.current ?? sid;
+}
+
+function recordLiveSession(sid: string, current: string): void {
+  const session = loadSession(sid);
+  mkdirSync(sessionsDir(), { recursive: true });
+  writeFileAtomic(sessionFile(sid), JSON.stringify({ flags: session?.flags ?? [], cwd: session?.cwd ?? process.cwd(), current }));
+}
+
+const DEAD_STATE_ENTRIES = [
+  "model-usage.json",
+  "accounts.json.v1-backup",
+  "codex-accounts.json.v1-backup",
+  "nextcheck.json",
+  "usage.json",
+  "lastswap.json",
+  "depleted.json",
+  "codex-lastswap.json",
+  "creds",
+  "codex-creds",
+  "codex-reconcile",
+  "sample",
+];
+
+const TMP_MARKER = ".tmp.";
+const TMP_GRACE_MS = 3600 * 1000;
+
+const STORE_PARENTS = [paths.storesDir, codexPaths.storesDir, grokPaths.storesDir, opencodeGoPaths.storesDir];
+
+function listDir(dir: string, root: string): Dirent[] {
+  if (!existsSync(dir)) return [];
+  try {
+    const resolved = realpathSync(dir);
+    if (resolved !== root && !resolved.startsWith(root + sep)) return [];
+    return readdirSync(dir, { withFileTypes: true });
+  } catch (e) {
+    log("state.sweep_unreadable", { dir, err: errorMessage(e) });
+    return [];
+  }
+}
+
+function tmpSweepDirs(root: string): string[] {
+  const dirs = [paths.home, paths.usageDir, paths.presenceDir, paths.respawnDir, sessionsDir(), paths.binDir, paths.cloudDir, codexPaths.presenceDir, codexPaths.respawnDir, codexPaths.onboardDir];
+  for (const parent of STORE_PARENTS) {
+    for (const child of listDir(parent, root)) {
+      if (child.isDirectory()) dirs.push(join(parent, child.name));
+    }
+  }
+  return dirs;
+}
+
+function pruneDeadState(now: number, root: string): void {
+  for (const name of DEAD_STATE_ENTRIES) {
     try {
-      rmSync(join(paths.home, name), { force: true });
-    } catch {
+      rmSync(join(paths.home, name), { recursive: true, force: true });
+    } catch (e) {
+      log("state.dead_entry_failed", { name, err: errorMessage(e) });
+    }
+  }
+  for (const dir of tmpSweepDirs(root)) {
+    for (const f of listDir(dir, root)) {
+      if (!f.isFile() || !f.name.includes(TMP_MARKER)) continue;
+      const p = join(dir, f.name);
+      try {
+        if (now - statSync(p).mtimeMs > TMP_GRACE_MS) rmSync(p, { force: true });
+      } catch {
+      }
     }
   }
 }
 
 export function pruneStaleSessions(now: number): void {
-  pruneDeadState();
-  const dir = join(paths.home, "sessions");
-  if (!existsSync(dir)) return;
-  for (const f of readdirSync(dir)) {
-    const p = join(dir, f);
+  let root: string;
+  try {
+    root = realpathSync(paths.home);
+  } catch {
+    return;
+  }
+  pruneDeadState(now, root);
+  const dir = sessionsDir();
+  for (const f of listDir(dir, root)) {
+    const p = join(dir, f.name);
     try {
+      if (existsSync(join(paths.presenceDir, basename(f.name, ".json")))) continue;
       if (now - statSync(p).mtimeMs > SESSION_RETENTION_MS) rmSync(p, { force: true });
     } catch {
     }
   }
 }
 
-export type SupervisedSession = { sid: string; launchedAt: number | null };
+export type SupervisedSession = { sid: string; launchedAt: number | null; live: string };
 
 const LaunchedAtSchema = z.coerce.number().finite().optional().catch(undefined);
 
@@ -56,16 +132,28 @@ export function supervisedSession(env: Record<string, string | undefined> = proc
   if (env.TOKENMAXXING_SUPERVISED !== "1") return null;
   const sid = env.TOKENMAXXING_SESSION_ID;
   if (sid == null || sid === "") return null;
-  return { sid, launchedAt: LaunchedAtSchema.parse(env.TOKENMAXXING_LAUNCHED_AT) ?? null };
+  return { sid, launchedAt: LaunchedAtSchema.parse(env.TOKENMAXXING_LAUNCHED_AT) ?? null, live: liveSessionId(sid) };
+}
+
+export function adoptLiveSession(session: SupervisedSession, stdinSid: string | undefined): SupervisedSession | null {
+  if (stdinSid == null || stdinSid === session.live) return session;
+  const child = presencePid({ dir: paths.presenceDir, id: session.sid });
+  if (child == null || !spawnedThroughShellsBy(child)) {
+    log("session.live_id_refused", { reason: child == null ? "no-presence" : "not-descendant", stdin: stdinSid.slice(0, 8), live: session.live.slice(0, 8), session: session.sid.slice(0, 8) });
+    return null;
+  }
+  recordLiveSession(session.sid, stdinSid);
+  log("session.live_id", { from: session.live.slice(0, 8), to: stdinSid.slice(0, 8), session: session.sid.slice(0, 8) });
+  return { ...session, live: stdinSid };
 }
 
-export function writeRespawnMarker(input: { session: SupervisedSession; sessionId: string; accountId: string; waitUntil: number; compact: boolean }): void {
+export function writeRespawnMarker(input: { session: SupervisedSession; accountId: string; waitUntil: number; compact: boolean }): void {
   mkdirSync(paths.respawnDir, { recursive: true });
   const payload: z.infer<typeof RespawnMarkerSchema> = {
     accountId: input.accountId,
     ts: Date.now(),
     waitUntil: input.waitUntil,
-    sessionId: input.sessionId,
+    sessionId: input.session.live,
     compact: input.compact,
     ...(input.session.launchedAt != null ? { launchedAt: input.session.launchedAt } : {}),
   };