tokenmaxxing 1.48.0 → 1.50.0

package/DESIGN.md

@@ -21,7 +21,7 @@ supervisor (you type `claude`)  →  real claude, CLAUDE_SECURESTORAGE_CONFIG_DI
         ▲______________ relaunch --resume <sid> under another store ______________|
 ```
 
-It is a process manager only - spawn with inherited stdio plus saved `stty -g` termios (not a PTY copy), wait, restore the terminal, relaunch. It never proxies API traffic and never handles tokens. Everything else about `claude` is unchanged.
+It is a process manager only - spawn with inherited stdio (stdin through a relay pipe for a stream-json session, see §3.3) plus saved `stty -g` termios (not a PTY copy), wait, restore the terminal, relaunch. It never proxies API traffic and never handles tokens. Everything else about `claude` is unchanged.
 
 ---
 
@@ -58,7 +58,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, `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.
+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 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. The supervisor's own notices go to stderr, so a stream-json stdout stays parseable. 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.
@@ -95,7 +95,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). 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. The static session-bar margin (`policy.projectionMargin`, default 3) reduces this.
+- **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 relaunch continues the conversation on the fresh account from the supervisor's resume prompt. The static session-bar margin (`policy.projectionMargin`, default 3) 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.
 - **Dead stores.** A refresh Claude Code cannot complete dead-clears the store; the sampler and the decision recognize the empty tokens without a request, flag the account, and `auth` repairs it in place.
@@ -123,7 +123,7 @@ The [profile](docs/content/docs/switching-profile.mdx) records observed cache re
 ---
 
 ## 8. Stack
-TypeScript on Bun, shipped as source: one multi-call entry (`src/main.ts`, `#!/usr/bin/env bun`) serves the CLI, the `claude` supervisor, the statusLine shim, and the hooks; `init` installs a 2-line shim that `exec`s bun on the installed package's entry (the Stop path runs every turn; bun's start-up stays low-millisecond). Published to npm as `tokenmaxxing` (source, platform-independent - a compiled binary was tried and shipped one architecture's Mach-O to every platform). Shipping is PR-based since 2026-07-18: work reaches main only through a pull request (branch, PR, CI green, a 10-minute review wait, every review handled, merge, teardown), and a release is a PR-landed version bump followed by `gh release create` (details in AGENTS.md "Release and CI"). The supervisor spawns claude with inherited stdio and restores saved `stty -g` termios between runs - no PTY layer; resize and signals flow through the shared foreground process group.
+TypeScript on Bun, shipped as source: one multi-call entry (`src/main.ts`, `#!/usr/bin/env bun`) serves the CLI, the `claude` supervisor, the statusLine shim, and the hooks; `init` installs a 2-line shim that `exec`s bun on the installed package's entry (the Stop path runs every turn; bun's start-up stays low-millisecond). Published to npm as `tokenmaxxing` (source, platform-independent - a compiled binary was tried and shipped one architecture's Mach-O to every platform). Shipping is PR-based since 2026-07-18: work reaches main only through a pull request (branch, PR, CI green, a 10-minute review wait, every review handled, merge, teardown), and a release is a PR-landed version bump followed by `gh release create` (details in AGENTS.md "Release and CI"). The supervisor spawns claude with inherited stdio (a relay pipe on stdin for a stream-json session) and restores saved `stty -g` termios between runs - no PTY layer; resize and signals flow through the shared foreground process group.
 
 ---
 

package/README.md

@@ -133,7 +133,7 @@ A Cursor Cloud Agent can hand substantial work to Claude Code running on your ow
 
 ## Honest limitations
 
-- **A move restarts the process.** The session resumes the same transcript under the new account, but the process restarts and the first turn on the new account re-uploads context once (prompt cache is org-scoped).
+- **A move restarts the process.** The session resumes the same transcript under the new account and continues on its own from a first prompt the supervisor submits, but the process restarts and the first turn on the new account re-uploads context once (prompt cache is org-scoped).
 - **Depleted-pause hiccup.** When the whole pool is at its limit, `claude` stops for the countdown; anything typed in that split second is lost.
 - **Unsupervised sessions are not moved.** A claude started outside the supervisor runs on Claude Code's own login, which tokenmaxxing never writes.
 - **One shared identity file.** `~/.claude.json` holds one `oauthAccount` that Claude Code rewrites after whichever session refreshed last, so `/status` can show another session's email; the statusline's `◆` marks the account a session actually uses.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.48.0",
+  "version": "1.50.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

@@ -4,6 +4,7 @@ import { evaluateAndMaybeSwap } from "../lib/decide.ts";
 import { supervisedSession, writeRespawnMarker } from "../lib/sessions.ts";
 import { loadConfig } from "../lib/state.ts";
 import { classifyEnforcedLimit, findEnforcedRow, parseErrorBody, readTranscriptTail } 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";
@@ -52,6 +53,16 @@ export async function runStopFailureHook(): Promise<number> {
       });
     }
 
+    if (session == null && limit != null) {
+      const shim = `${paths.binDir}/claude`;
+      log("stopfailure.unsupervised_hint", { sid: stdinSid });
+      process.stdout.write(
+        `${JSON.stringify({
+          systemMessage: `tokenmaxxing: this session runs outside the supervisor, so it cannot move to another account at the limit. Move it yourself: ${stdinSid ? `${shim} --resume ${stdinSid}` : `resume it through ${shim}`}`,
+        })}\n`,
+      );
+    }
+
     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 });

package/src/entries/supervisor.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, readdirSync, statSync } from "node:fs";
 import { basename, join } from "node:path";
-import type { Subprocess } from "bun";
+import type { FileSink, Subprocess } from "bun";
 import { maxBy } from "es-toolkit";
 import { z } from "zod";
 import { claudePool, paths, storeDirFor } from "../lib/paths.ts";
@@ -22,18 +22,21 @@ const NONINTERACTIVE_SUBCMDS = new Set([
 
 const VALUE_TAKING_ROOT_FLAGS = new Set([
   "--agent", "--agents", "--append-system-prompt", "--append-system-prompt-file",
-  "--debug-file", "--effort", "--fallback-model", "--input-format",
-  "--json-schema", "--max-budget-usd", "--model", "-n", "--name",
-  "--output-format", "--permission-mode", "--plugin-dir", "--plugin-url",
-  "--remote-control-session-name-prefix", "--setting-sources", "--settings",
-  "--system-prompt",
+  "--autocompact", "--debug-file", "--effort", "--environment", "--fallback-model",
+  "--input-format", "--json-schema", "--managed-settings", "--max-budget-usd",
+  "--max-thinking-tokens", "--max-turns", "--model", "-n", "--name",
+  "--output-format", "--permission-mode", "--permission-prompt-tool", "--permission-prompts",
+  "--plugin-dir", "--plugin-dir-no-mcp", "--plugin-url", "--remote-control-session-name-prefix",
+  "--setting-sources", "--settings", "--system-prompt", "--system-prompt-snapshot",
+  "--task-budget", "--thinking", "--thinking-display",
 ]);
 const VARIADIC_ROOT_FLAGS = new Set([
   "--add-dir", "--allowedTools", "--allowed-tools", "--betas",
   "--disallowedTools", "--disallowed-tools", "--file", "--mcp-config", "--tools",
 ]);
 const OPTIONAL_VALUE_ROOT_FLAGS = new Set([
-  "-d", "--debug", "--from-pr", "--prompt-suggestions", "--remote-control", "-w", "--worktree",
+  "--cloud", "-d", "--debug", "--from-pr", "--prompt-suggestions", "--remote-control",
+  "--teleport", "-w", "--worktree",
 ]);
 
 const isUuid = (s: string) => z.uuid().safeParse(s).success;
@@ -43,6 +46,7 @@ const AnalysisSchema = z.object({
   sessionId: z.string().nullable(),
   resumeId: z.string().nullable(),
   continueLatest: z.boolean(),
+  streamInput: z.boolean(),
 });
 type Analysis = z.infer<typeof AnalysisSchema>;
 
@@ -50,6 +54,7 @@ export function analyzeArgs(argv: string[]): Analysis {
   let sessionId: string | null = null;
   let resumeId: string | null = null;
   let continueLatest = false;
+  let streamInput = false;
   let printMode = false;
   let invalidSessionArg = false;
   let pickerResume = false;
@@ -82,6 +87,8 @@ export function analyzeArgs(argv: string[]): Analysis {
       if (isUuid(value)) resumeId = value;
       else pickerResume = true;
     }
+    else if (a === "--input-format") streamInput = argv[++i] === "stream-json";
+    else if (a.startsWith("--input-format=")) streamInput = a.slice("--input-format=".length) === "stream-json";
     else if (VALUE_TAKING_ROOT_FLAGS.has(a)) i++;
     else if (VARIADIC_ROOT_FLAGS.has(a)) {
       while (i + 1 < argv.length && !argv[i + 1]!.startsWith("-")) i++;
@@ -97,7 +104,7 @@ export function analyzeArgs(argv: string[]): Analysis {
   const isSubcmd = firstPositional !== null && NONINTERACTIVE_SUBCMDS.has(firstPositional);
   const forkResume = forkSession && (resumeId !== null || continueLatest);
   const manage = !printMode && !isSubcmd && !invalidSessionArg && !pickerResume && !forkResume && !process.env.TOKENMAXXING_PROBE;
-  return { manage, sessionId, resumeId, continueLatest };
+  return { manage, sessionId, resumeId, continueLatest, streamInput };
 }
 
 export function stripSessionFlags(argv: string[]): string[] {
@@ -187,19 +194,97 @@ async function countdownWait(acct: string, until: number): Promise<boolean> {
   let aborted = false;
   const onInt = () => { aborted = true; };
   process.on("SIGINT", onInt);
-  process.stdout.write(`\n\x1b[36m⏳ tokenmaxxing: all accounts at their limit. Resuming on ${acct} when it resets (Ctrl-C to resume now).\x1b[0m\n`);
+  process.stderr.write(`\n\x1b[36m⏳ tokenmaxxing: all accounts at their limit. Resuming on ${acct} when it resets (Ctrl-C to resume now).\x1b[0m\n`);
   while (!aborted && Date.now() < until) {
     const left = until - Date.now();
     const m = Math.floor(left / 60000);
     const s = Math.floor((left % 60000) / 1000);
-    process.stdout.write(`\r\x1b[36m   resuming in ${m}m ${String(s).padStart(2, "0")}s \x1b[0m`);
+    process.stderr.write(`\r\x1b[36m   resuming in ${m}m ${String(s).padStart(2, "0")}s \x1b[0m`);
     await Bun.sleep(1000);
   }
   process.removeListener("SIGINT", onInt);
-  process.stdout.write(`\n\x1b[36m↻ resuming on ${acct}...\x1b[0m\n`);
+  process.stderr.write(`\n\x1b[36m↻ resuming on ${acct}...\x1b[0m\n`);
   return aborted;
 }
 
+function resumePrompt(compacted: boolean): string {
+  const moved = compacted
+    ? "tokenmaxxing compacted this conversation and resumed the session on an account with quota headroom."
+    : "tokenmaxxing resumed this session on an account with quota headroom.";
+  return `${moved} Continue the task from where the previous turn left off. If the previous turn ended waiting on the user, restate what you need and wait.`;
+}
+
+function userLine(text: string): string {
+  return `${JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text }] } })}\n`;
+}
+
+class StdinRelay {
+  private sink: FileSink | null = null;
+  private queue: string[] = [];
+  private ended = false;
+
+  constructor() {
+    this.pump()
+      .catch((e: unknown) => log("supervisor.relay_read_failed", { err: e instanceof Error ? e.message : String(e) }))
+      .finally(() => {
+        this.ended = true;
+        this.close();
+      });
+  }
+
+  attach(sink: FileSink, first: string | null): void {
+    this.sink = sink;
+    const lines = first === null ? this.queue : [first, ...this.queue];
+    this.queue = [];
+    for (const line of lines) this.forward(line);
+    if (this.ended) this.close();
+  }
+
+  detach(): void {
+    this.sink = null;
+  }
+
+  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`);
+  }
+
+  private forward(line: string): void {
+    if (this.sink !== null) {
+      try {
+        this.sink.write(line);
+        this.sink.flush();
+        return;
+      } catch (e) {
+        log("supervisor.relay_write_failed", { err: e instanceof Error ? e.message : String(e) });
+        this.sink = null;
+      }
+    }
+    this.queue.push(line);
+  }
+
+  private close(): void {
+    if (this.sink === null) return;
+    try {
+      this.sink.end();
+    } catch (e) {
+      log("supervisor.relay_end_failed", { err: e instanceof Error ? e.message : String(e) });
+    }
+    this.sink = null;
+  }
+}
+
 async function recordPresence(child: Subprocess, sid: string, seat: Account, savedTermios: string | null): Promise<void> {
   for (let attempt = 0; ; attempt++) {
     try {
@@ -280,6 +365,8 @@ export async function runSupervisor(argv: string[]): Promise<number> {
   process.on("SIGINT", () => {});
   process.on("SIGHUP", () => {});
 
+  const relay = analyzeArgs(base).streamInput ? new StdinRelay() : null;
+  let firstLine: string | null = null;
   let respawns = 0;
   let overriddenUntil = 0;
   let wanted: string | null = null;
@@ -289,9 +376,9 @@ export async function runSupervisor(argv: string[]): Promise<number> {
     const gate: MarkerGate = { launchedAt: Date.now(), overriddenUntil };
     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(" ") });
+      log("supervisor.launch", { sid, respawns, seat: picked?.id.slice(0, 8) ?? null, args: launchArgs.join(" "), injected: firstLine !== null });
       const spawned = Bun.spawn([real, ...launchArgs], {
-        stdin: "inherit",
+        stdin: relay === null ? "inherit" : "pipe",
         stdout: "inherit",
         stderr: "inherit",
         env: {
@@ -302,6 +389,8 @@ export async function runSupervisor(argv: string[]): Promise<number> {
           ...(picked ? { CLAUDE_SECURESTORAGE_CONFIG_DIR: storeDirFor(picked.id) } : {}),
         },
       });
+      if (relay !== null) relay.attach(spawned.stdin!, firstLine);
+      firstLine = null;
       if (picked) await recordPresence(spawned, sid, picked, savedTermios);
       return { child: spawned, seat: picked };
     });
@@ -317,13 +406,18 @@ export async function runSupervisor(argv: string[]): Promise<number> {
     const exited = child.exited.then(() => { done = true; return "exit" as const; });
     try {
       const winner = await Promise.race([exited, markerWatch.then((m) => (m ? "marker" : "exit"))]);
-      if (winner === "marker") child.kill();
+      if (winner === "marker") {
+        relay?.detach();
+        child.kill();
+      }
     } catch (e) {
+      relay?.detach();
       child.kill();
       clearPresence({ dir: paths.presenceDir, id: sid });
       throw e;
     } finally {
       await child.exited;
+      relay?.detach();
       done = true;
       await markerWatch.catch(() => {});
       restoreTermios(savedTermios);
@@ -334,22 +428,27 @@ 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 resumable = existsSync(transcriptPath(m.sessionId));
+      let compacted = false;
+      if (m.compact && seat && resumable) {
+        process.stderr.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 (!outcome.ok) process.stderr.write(`\x1b[33m   compaction did not land (${outcome.reason}) - resuming with the full context\x1b[0m\n`);
+        compacted = outcome.ok;
       }
       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`);
+      } else process.stderr.write(`\n\x1b[36m↻ tokenmaxxing: moving to ${label} - resuming...\x1b[0m\n`);
       wanted = m.accountId;
       saveSessionFlags(m.sessionId, persistable, process.cwd());
-      launchArgs = ["--resume", m.sessionId, ...persistable];
+      const prompt = resumable ? resumePrompt(compacted) : null;
+      firstLine = relay !== null && prompt !== null ? userLine(prompt) : null;
+      launchArgs = ["--resume", m.sessionId, ...(relay === null && prompt !== null ? [prompt] : []), ...persistable];
       continue;
     }
     clearPresence({ dir: paths.presenceDir, id: sid });