tokenmaxxing 1.32.0 → 1.34.0

package/README.md

@@ -76,7 +76,7 @@ claude                  # use claude as always
 | `tokenmaxxing setup-token [--print \| rm <label\|uuid>]` | Cursor Cloud only: mint one `claude setup-token` per pooled account (a browser sign-in each) and print the `TOKENMAXXING_TOKENS` secret value; `--print` prints the stored set, `rm` drops one |
 | `tokenmaxxing cursor init [dir]` | write the Claude relay subagent and `.cursor/environment.json` into a repo |
 | `tokenmaxxing cloud run [--session <id>] [--max-turns <n>] "<prompt>"` | on a Cursor Cloud VM: run `claude -p` on a setup token, rotate to the next token on a usage limit |
-| `--json` | machine-readable output: one JSON document on stdout for `status`, `config`, `doctor`, `check`, `switch`, `rename`, `rm`, `uninstall`, `setup-token --print`, `cursor init`, and `cloud run` (`ok` mirrors the exit code, failures add `error`) |
+| `--json` | machine-readable output: one JSON document on stdout for `status`, `config`, `check`, and `switch` (`ok` mirrors the exit code, failures add `error`) |
 
 ## How switching decides
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.32.0",
+  "version": "1.34.0",
   "description": "Automatic Claude Code account switching: pool multiple accounts and hot-swap when quota fills, resuming your session on the fresh account.",
   "type": "module",
   "license": "MIT",

package/src/cli/cloudrun.ts

@@ -12,7 +12,7 @@ import {
   spawnCloudClaude,
   transcriptBytes,
 } from "../lib/cloud.ts";
-import { c, emitError, emitJson, fmtReset } from "./render.ts";
+import { c, emitError, fmtReset } from "./render.ts";
 
 const USAGE = "usage: tokenmaxxing cloud run [--session <id>] [--max-turns <n>] \"<prompt>\" (the prompt is also read from stdin)";
 
@@ -39,15 +39,15 @@ function parseFlags(args: string[]): { session: string | null; maxTurns: number
   return { session, maxTurns, prompt: positional.length > 0 ? positional.join(" ") : null };
 }
 
-export async function cmdCloudRun(args: string[], json = false): Promise<number> {
+export async function cmdCloudRun(args: string[]): Promise<number> {
   const flags = parseFlags(args);
   if ("error" in flags) {
-    emitError({ json, message: `${flags.error} - ${USAGE}` });
+    emitError({ message: `${flags.error} - ${USAGE}` });
     return 2;
   }
   const prompt = flags.prompt ?? (process.stdin.isTTY ? null : await Bun.stdin.text());
   if (prompt == null || prompt.trim() === "") {
-    emitError({ json, message: USAGE });
+    emitError({ message: USAGE });
     return 2;
   }
   const tokens = readCloudTokens();
@@ -61,11 +61,7 @@ export async function cmdCloudRun(args: string[], json = false): Promise<number>
       return picked;
     });
     if (!pick.ok) {
-      emitError({
-        json,
-        message: `every token is at its limit - earliest ${fmtReset(pick.earliestReset)}`,
-        extra: { earliestReset: pick.earliestReset, session_id: sessionId },
-      });
+      emitError({ message: `every token is at its limit - earliest ${fmtReset(pick.earliestReset)}` });
       return 1;
     }
     const label = pick.token.label;
@@ -99,17 +95,11 @@ export async function cmdCloudRun(args: string[], json = false): Promise<number>
       }
       const errors = result.subtype === "success" ? [result.result] : result.errors;
       emitError({
-        json,
         message: `claude exited ${exitCode ?? "on signal"} (${result.subtype}): ${errors.join("; ")}`,
         notes: [`session ${result.session_id}`],
-        extra: { session_id: result.session_id, subtype: result.subtype, errors },
       });
       return 1;
     }
-    if (json) {
-      emitJson({ ok: true, session_id: result.session_id, result: result.result, num_turns: result.num_turns, total_cost_usd: result.total_cost_usd });
-      return 0;
-    }
     console.log(result.result);
     console.log(`session ${result.session_id}`);
     return 0;

package/src/cli/codexrm.ts

@@ -5,33 +5,32 @@ import { deleteParkedCodexAuth } from "../lib/codexauth.ts";
 import { liveCodexAccountId } from "../lib/codexsample.ts";
 import { presentCodexAccountIds } from "../lib/codexpresence.ts";
 import { findCodexAccount } from "./rename.ts";
-import { c, emitError, emitJson, plain } from "./render.ts";
+import { c, emitError, plain } from "./render.ts";
 
-export async function cmdCodexRm(selector?: string, json = false): Promise<number> {
+export async function cmdCodexRm(selector?: string): Promise<number> {
   if (!selector) {
-    emitError({ json, message: "usage: tokenmaxxing rm --codex <email|label|id>", paint: plain });
+    emitError({ message: "usage: tokenmaxxing rm --codex <email|label|id>", paint: plain });
     return 2;
   }
   return withLock(codexPaths.lockFile, async () => {
     const index = loadCodexAccounts();
     const account = findCodexAccount(index.accounts, selector);
     if (!account) {
-      emitError({ json, message: `no codex account matches "${selector}"` });
+      emitError({ message: `no codex account matches "${selector}"` });
       return 1;
     }
     if (liveCodexAccountId() === account.accountId) {
-      emitError({ json, message: `${account.label} is the LIVE codex account - run \`tokenmaxxing switch --codex\` to move off it first.` });
+      emitError({ message: `${account.label} is the LIVE codex account - run \`tokenmaxxing switch --codex\` to move off it first.` });
       return 1;
     }
     if (presentCodexAccountIds().has(account.accountId)) {
-      emitError({ json, message: `${account.label} is running in a live codex session - close that session before removing it.` });
+      emitError({ message: `${account.label} is running in a live codex session - close that session before removing it.` });
       return 1;
     }
     deleteParkedCodexAuth({ credFile: account.credFile });
     index.accounts = index.accounts.filter((x) => x.accountId !== account.accountId);
     saveCodexAccounts({ index });
-    if (json) emitJson({ ok: true, pool: "codex", removed: account.label, remaining: index.accounts.length });
-    else console.log(`removed codex account ${c.bold(account.label)} from the pool (${index.accounts.length} left)`);
+    console.log(`removed codex account ${c.bold(account.label)} from the pool (${index.accounts.length} left)`);
     return 0;
   });
 }

package/src/cli/cursorinit.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "../lib/atomic.ts";
-import { c, emitError, emitJson } from "./render.ts";
+import { c, emitError } from "./render.ts";
 
 export const CLOUD_INSTALL_LINE =
   'curl -fsSL https://bun.sh/install | bash && curl -fsSL https://claude.ai/install.sh | bash && "$HOME/.bun/bin/bun" add -g tokenmaxxing && test -x "$HOME/.bun/bin/bun" && test -x "$HOME/.local/bin/claude" && test -e "$HOME/.bun/bin/tokenmaxxing"';
@@ -42,14 +42,14 @@ const ExistingEnvironmentSchema = z.looseObject({ user: z.string().optional() })
 const REPO_FILE_MODE = 0o644;
 const USAGE = "usage: tokenmaxxing cursor init [dir]";
 
-export function cmdCursorInit(args: string[], json = false): number {
+export function cmdCursorInit(args: string[]): number {
   if (args.length > 1) {
-    emitError({ json, message: USAGE });
+    emitError({ message: USAGE });
     return 2;
   }
   const dir = resolve(args[0] ?? ".");
   if (!existsSync(dir)) {
-    emitError({ json, message: `no such directory: ${dir}` });
+    emitError({ message: `no such directory: ${dir}` });
     return 1;
   }
   const agentFile = join(dir, ".cursor", "agents", "claude.md");
@@ -64,10 +64,6 @@ export function cmdCursorInit(args: string[], json = false): number {
   } else if (existing.user === "root" || existing.user === "0") {
     warnings.push(".cursor/environment.json sets user to root; Claude Code refuses --dangerously-skip-permissions under root, so every relay call fails until user is a non-root account");
   }
-  if (json) {
-    emitJson({ ok: true, dir, agent, environment, install: CLOUD_INSTALL_LINE, warnings });
-    return 0;
-  }
   console.log(`${c.green("✓")} .cursor/agents/claude.md ${agent}`);
   if (environment === "written") {
     console.log(`${c.green("✓")} .cursor/environment.json written`);

package/src/cli/doctor.ts

@@ -8,7 +8,7 @@ import { readItem, liveTarget, parkedTarget } from "../lib/credstore.ts";
 import { isAccessTokenExpiring, fetchTokenIdentity, describeIdentity } from "../lib/oauth.ts";
 import { CredentialBlobSchema, type TokenIdentity } from "../lib/types.ts";
 import { SETUP_TOKEN_STALE_MS, loadSetupTokens } from "../lib/setuptokens.ts";
-import { c, emitJson, fmtAgo } from "./render.ts";
+import { c, fmtAgo } from "./render.ts";
 
 async function blobIdentity(raw: string): Promise<TokenIdentity | null> {
   const creds = CredentialBlobSchema.parse(JSON.parse(raw)).claudeAiOauth;
@@ -16,22 +16,14 @@ async function blobIdentity(raw: string): Promise<TokenIdentity | null> {
   return fetchTokenIdentity(creds.accessToken);
 }
 
-export async function cmdDoctor(json = false): Promise<number> {
-  const checks: { ok: boolean; label: string; hint: string | null }[] = [];
-  const notes: string[] = [];
-  const warnings: string[] = [];
+export async function cmdDoctor(): Promise<number> {
+  let failed = 0;
   const check = (cond: boolean, label: string, hint?: string) => {
-    checks.push({ ok: cond, label, hint: cond ? null : (hint ?? null) });
-    if (!json) console.log(`${cond ? c.green("✓") : c.red("✗")} ${label}${!cond && hint ? c.dim(`  - ${hint}`) : ""}`);
-  };
-  const note = (text: string) => {
-    notes.push(text);
-    if (!json) console.log(c.dim(`  - ${text}`));
-  };
-  const warn = (text: string) => {
-    warnings.push(text);
-    if (!json) console.log(c.yellow(`⚠ ${text}`));
+    if (!cond) failed++;
+    console.log(`${cond ? c.green("✓") : c.red("✗")} ${label}${!cond && hint ? c.dim(`  - ${hint}`) : ""}`);
   };
+  const note = (text: string) => console.log(c.dim(`  - ${text}`));
+  const warn = (text: string) => console.log(c.yellow(`⚠ ${text}`));
 
   check(existsSync(paths.supervisorLink), "claude supervisor wrapper present", "run `tokenmaxxing init`");
   check(existsSync(installedBin()), "tokenmaxxing binary installed", "run `tokenmaxxing init`");
@@ -102,13 +94,7 @@ export async function cmdDoctor(json = false): Promise<number> {
     }
   }
 
-  const failed = checks.filter((entry) => !entry.ok).length;
-  const ok = failed === 0;
-  if (json) {
-    emitJson(ok ? { ok, checks, notes, warnings } : { ok, error: `issues found - ${failed} of ${checks.length} checks failed`, checks, notes, warnings });
-    return ok ? 0 : 1;
-  }
   console.log();
-  console.log(ok ? c.green("all good ✓") : c.yellow("issues found - see above"));
-  return ok ? 0 : 1;
+  console.log(failed === 0 ? c.green("all good ✓") : c.yellow("issues found - see above"));
+  return failed === 0 ? 0 : 1;
 }

package/src/cli/rename.ts

@@ -2,7 +2,7 @@ import { withLock } from "../lib/lock.ts";
 import { codexPaths, paths } from "../lib/paths.ts";
 import { loadAccounts, saveAccounts } from "../lib/state.ts";
 import { loadCodexAccounts, saveCodexAccounts } from "../lib/codexstate.ts";
-import { c, emitError, emitJson, plain } from "./render.ts";
+import { c, emitError, plain } from "./render.ts";
 import type { Account, CodexAccount } from "../lib/types.ts";
 
 export function findAccount(accounts: Account[], selector: string): Account | undefined {
@@ -23,54 +23,52 @@ export function findCodexAccount(accounts: CodexAccount[], selector: string): Co
   );
 }
 
-async function renameCodexAccount(input: { selector: string; newLabel: string; json: boolean }): Promise<number> {
-  const { selector, newLabel, json } = input;
+async function renameCodexAccount(input: { selector: string; newLabel: string }): Promise<number> {
+  const { selector, newLabel } = input;
   return withLock(codexPaths.lockFile, async () => {
     const index = loadCodexAccounts();
     const account = findCodexAccount(index.accounts, selector);
     if (!account) {
-      emitError({ json, message: `no codex account matches "${selector}"` });
+      emitError({ message: `no codex account matches "${selector}"` });
       return 1;
     }
     const taken = index.accounts.find((x) => x.accountId !== account.accountId && x.label.toLowerCase() === newLabel.toLowerCase());
     if (taken) {
-      emitError({ json, message: `label "${newLabel}" is already used by ${taken.accountId.slice(0, 8)} - labels must be unique within the pool` });
+      emitError({ message: `label "${newLabel}" is already used by ${taken.accountId.slice(0, 8)} - labels must be unique within the pool` });
       return 1;
     }
     const old = account.label;
     account.label = newLabel;
     saveCodexAccounts({ index });
-    if (json) emitJson({ ok: true, pool: "codex", from: old, to: newLabel });
-    else console.log(`renamed codex account ${c.dim(old)} → ${c.bold(newLabel)}`);
+    console.log(`renamed codex account ${c.dim(old)} → ${c.bold(newLabel)}`);
     return 0;
   });
 }
 
-export async function cmdRename(argv: string[], json = false): Promise<number> {
+export async function cmdRename(argv: string[]): Promise<number> {
   const codex = argv.includes("--codex");
   const [selector, newLabel] = argv.filter((a) => a !== "--codex");
   if (!selector || !newLabel) {
-    emitError({ json, message: "usage: tokenmaxxing rename [--codex] <email|label|id> <new-label>", paint: plain });
+    emitError({ message: "usage: tokenmaxxing rename [--codex] <email|label|id> <new-label>", paint: plain });
     return 2;
   }
-  if (codex) return renameCodexAccount({ selector, newLabel, json });
+  if (codex) return renameCodexAccount({ selector, newLabel });
   return withLock(paths.lockFile, async () => {
     const idx = loadAccounts();
     const a = findAccount(idx.accounts, selector);
     if (!a) {
-      emitError({ json, message: `no claude account matches "${selector}" (codex accounts rename via --codex)` });
+      emitError({ message: `no claude account matches "${selector}" (codex accounts rename via --codex)` });
       return 1;
     }
     const taken = idx.accounts.find((x) => x.accountUuid !== a.accountUuid && x.label.toLowerCase() === newLabel.toLowerCase());
     if (taken) {
-      emitError({ json, message: `label "${newLabel}" is already used by ${taken.email} - labels must be unique within the pool` });
+      emitError({ message: `label "${newLabel}" is already used by ${taken.email} - labels must be unique within the pool` });
       return 1;
     }
     const old = a.label;
     a.label = newLabel;
     saveAccounts(idx);
-    if (json) emitJson({ ok: true, pool: "claude", from: old, to: newLabel });
-    else console.log(`renamed ${c.dim(old)} → ${c.bold(newLabel)}`);
+    console.log(`renamed ${c.dim(old)} → ${c.bold(newLabel)}`);
     return 0;
   });
 }

package/src/cli/render.ts

@@ -82,7 +82,7 @@ export function emitJson(value: unknown): void {
 }
 
 export function emitError(input: {
-  json: boolean;
+  json?: boolean;
   message: string;
   notes?: string[];
   extra?: Record<string, unknown>;

package/src/cli/rm.ts

@@ -8,22 +8,22 @@ import { loadSetupTokens, saveSetupTokens } from "../lib/setuptokens.ts";
 import { loadAccounts, saveAccounts } from "../lib/state.ts";
 import { CredentialBlobSchema } from "../lib/types.ts";
 import { findAccount } from "./rename.ts";
-import { c, emitError, emitJson, plain } from "./render.ts";
+import { c, emitError, plain } from "./render.ts";
 
-export async function cmdRm(selector?: string, json = false): Promise<number> {
+export async function cmdRm(selector?: string): Promise<number> {
   if (!selector) {
-    emitError({ json, message: "usage: tokenmaxxing rm <email|label|uuid>", paint: plain });
+    emitError({ message: "usage: tokenmaxxing rm <email|label|uuid>", paint: plain });
     return 2;
   }
   return withLock(paths.lockFile, async () => {
     const idx = loadAccounts();
     const a = findAccount(idx.accounts, selector);
     if (!a) {
-      emitError({ json, message: `no account matches "${selector}"` });
+      emitError({ message: `no account matches "${selector}"` });
       return 1;
     }
     if (a.accountUuid === idx.activeAccountUuid) {
-      emitError({ json, message: `${a.email} is the ACTIVE account - switch away before removing it.` });
+      emitError({ message: `${a.email} is the ACTIVE account - switch away before removing it.` });
       return 1;
     }
     const live = await readItem(liveTarget());
@@ -34,13 +34,12 @@ export async function cmdRm(selector?: string, json = false): Promise<number> {
         liveAccount = (await fetchTokenIdentity(liveCreds.accessToken)).accountUuid;
       } catch (e) {
         emitError({
-          json,
           message: `cannot verify which account the LIVE credential belongs to (${e instanceof Error ? e.message : String(e)}) - refusing to remove while the live owner is unknown; repair the live credential or retry once the profile endpoint is reachable.`,
         });
         return 1;
       }
       if (liveAccount === a.accountUuid) {
-        emitError({ json, message: `${a.email}'s credential is currently LIVE (the active label is stale - a manual /login drifted it); run \`tokenmaxxing switch\` to move off it first.` });
+        emitError({ message: `${a.email}'s credential is currently LIVE (the active label is stale - a manual /login drifted it); run \`tokenmaxxing switch\` to move off it first.` });
         return 1;
       }
     }
@@ -56,8 +55,7 @@ export async function cmdRm(selector?: string, json = false): Promise<number> {
     if (setupTokens.tokens.some((t) => t.accountUuid === a.accountUuid)) {
       saveSetupTokens({ ...setupTokens, tokens: setupTokens.tokens.filter((t) => t.accountUuid !== a.accountUuid) });
     }
-    if (json) emitJson({ ok: true, pool: "claude", removed: a.label, remaining: idx.accounts.length });
-    else console.log(`removed ${c.bold(a.label)} from the pool (${idx.accounts.length} left)`);
+    console.log(`removed ${c.bold(a.label)} from the pool (${idx.accounts.length} left)`);
     return 0;
   });
 }

package/src/cli/setuptoken.ts

@@ -7,7 +7,7 @@ import { loadAccounts } from "../lib/state.ts";
 import { scrubCredentialEnv } from "../lib/usage.ts";
 import { CURSOR_SECRET_VALUE_CAP_BYTES, cursorSecretValue, loadSetupTokens, saveSetupTokens, type SetupToken } from "../lib/setuptokens.ts";
 import type { Account } from "../lib/types.ts";
-import { c, emitError, emitJson } from "./render.ts";
+import { c, emitError } from "./render.ts";
 
 const TOKEN_BEGIN_MARKER = "Your OAuth token (valid for";
 const TOKEN_END_MARKER = "Store this token securely";
@@ -58,7 +58,7 @@ function currentTokens(tokens: SetupToken[], accounts: Account[]): { label: stri
   });
 }
 
-async function rmToken(selector: string, json: boolean): Promise<number> {
+async function rmToken(selector: string): Promise<number> {
   const outcome = await withLock(paths.lockFile, async (): Promise<{ error: string } | { kept: SetupToken[] }> => {
     const store = loadSetupTokens();
     const accounts = loadAccounts().accounts;
@@ -74,35 +74,26 @@ async function rmToken(selector: string, json: boolean): Promise<number> {
     return { kept };
   });
   if ("error" in outcome) {
-    emitError({ json, message: outcome.error });
+    emitError({ message: outcome.error });
     return 1;
   }
-  const remaining = outcome.kept;
-  if (json) {
-    emitJson({ ok: true, removed: selector, remaining: remaining.map((t) => t.label) });
-    return 0;
-  }
   console.log(`removed the setup token for ${selector} (local only: Claude Code documents no revocation for setup tokens)`);
   return 0;
 }
 
-export async function cmdSetupToken(args: string[], json = false): Promise<number> {
+export async function cmdSetupToken(args: string[]): Promise<number> {
   const [sub, label] = args;
-  if (sub === "rm" && label !== undefined && args.length === 2) return rmToken(label, json);
+  if (sub === "rm" && label !== undefined && args.length === 2) return rmToken(label);
   const print = sub === "--print" && args.length === 1;
   if (args.length > 0 && !print) {
-    emitError({ json, message: USAGE });
-    return 2;
-  }
-  if (json && !print) {
-    emitError({ json, message: "setup-token mints through a browser login flow and has no --json form; `setup-token --print --json` prints the stored set" });
+    emitError({ message: USAGE });
     return 2;
   }
   let store = loadSetupTokens();
   let idx = loadAccounts();
   if (!print) {
     if (idx.accounts.length === 0) {
-      emitError({ json, message: "no accounts in the pool - run `tokenmaxxing init` first" });
+      emitError({ message: "no accounts in the pool - run `tokenmaxxing init` first" });
       return 1;
     }
     const real = resolveRealClaude();
@@ -130,7 +121,7 @@ export async function cmdSetupToken(args: string[], json = false): Promise<numbe
     idx = loadAccounts();
   }
   if (store.tokens.length === 0) {
-    emitError({ json, message: "no setup tokens stored - run `tokenmaxxing setup-token` to mint them" });
+    emitError({ message: "no setup tokens stored - run `tokenmaxxing setup-token` to mint them" });
     return 1;
   }
   const tokens = currentTokens(store.tokens, idx.accounts);
@@ -138,15 +129,11 @@ export async function cmdSetupToken(args: string[], json = false): Promise<numbe
     .filter((t) => !idx.accounts.some((a) => a.accountUuid === t.accountUuid))
     .map((t) => ({ label: t.label, accountUuid: t.accountUuid }));
   if (tokens.length === 0) {
-    emitError({ json, message: "no stored setup token belongs to a pooled account - run `tokenmaxxing setup-token` to mint them" });
+    emitError({ message: "no stored setup token belongs to a pooled account - run `tokenmaxxing setup-token` to mint them" });
     return 1;
   }
   const secret = cursorSecretValue(tokens);
   const bytes = Buffer.byteLength(secret);
-  if (json) {
-    emitJson({ ok: true, tokens, orphaned, bytes, cap: CURSOR_SECRET_VALUE_CAP_BYTES });
-    return 0;
-  }
   console.log();
   if (orphaned.length > 0) {
     console.log(c.dim(`left out of the secret (no longer in the pool): ${orphaned.map((t) => `${t.label} (${t.accountUuid})`).join(", ")}; \`setup-token rm <label|uuid>\` drops one`));

package/src/entries/statusline.ts

@@ -80,11 +80,16 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
   const seatUuid =
     (ctx.liveAccount != null && ctx.accounts.accounts.some((a) => a.accountUuid === ctx.liveAccount) ? ctx.liveAccount : null) ??
     ctx.accounts.activeAccountUuid;
+  const walled = (a: Account) => a.enforcedUntil != null && a.enforcedUntil > ctx.now;
+  const wallSeg = (wall: number) => seg("", { usedPercentage: 100, resetsAt: wall }, wall);
+  const seat = ctx.accounts.accounts.find((a) => a.accountUuid === seatUuid);
+  if (seat?.enforcedUntil != null && walled(seat)) windows.push(wallSeg(seat.enforcedUntil));
+  const seatMarker = seat && walled(seat) ? paint(100)("◆") : col.green("◆");
   const active =
     windows.length > 0
-      ? `${col.green("◆")} ${windows.join(" ")}`
+      ? `${seatMarker} ${windows.join(" ")}`
       : seatUuid != null
-        ? `${col.green("◆")} ?`
+        ? `${seatMarker} ?`
         : "";
 
   const parked = sortBy(
@@ -92,7 +97,8 @@ export function renderStatusline(stdinObj: unknown, ctx: RenderCtx): string {
     [(a) => (a.needsReauth ? 1 : 0), (a) => earliestReset(a, ctx.now)],
   );
   const poolSeg = (a: Account): string => {
-    const marker = a.needsReauth ? col.red("✗") : col.cyan("◇");
+    const marker = a.needsReauth ? col.red("✗") : walled(a) ? paint(100)("◇") : col.cyan("◇");
+    if (a.enforcedUntil != null && walled(a)) return `${marker} ${wallSeg(a.enforcedUntil)}`;
     const week = a.lastUsage?.sevenDay;
     if (week == null) return `${marker} ?`;
     const weekUsed = used(week);

package/src/entries/stopfailurehook.ts

@@ -3,14 +3,13 @@ import { z } from "zod";
 import { paths } from "../lib/paths.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
 import { readOAuthAccount } from "../lib/claudejson.ts";
-import { enforcedWindowMs, evaluateAndMaybeSwap, postSwapProof, recordEnforcedLimit } from "../lib/decide.ts";
-import { loadConfig, loadLastSwapAt } from "../lib/state.ts";
+import { evaluateAndMaybeSwap } from "../lib/decide.ts";
+import { withLock } from "../lib/lock.ts";
+import { POST_SWAP_COOLDOWN_MS, loadConfig, loadLastSwapAt } from "../lib/state.ts";
 import { classifyEnforcedLimit, findEnforcedRow, parseErrorBody, readTranscriptTail } from "../lib/usage.ts";
 import { RespawnMarkerSchema, type EnforcedLimit } from "../lib/types.ts";
 import { log } from "../lib/log.ts";
 
-export const RETRIGGER_PROMPT = "Continue where the previous turn left off; it was interrupted by a usage limit and tokenmaxxing switched accounts.";
-
 const StopFailureStdin = z.looseObject({
   session_id: z.uuid().optional().catch(undefined),
   transcript_path: z.string().optional().catch(undefined),
@@ -30,7 +29,8 @@ async function readStdin(): Promise<string> {
 export async function runStopFailureHook(): Promise<number> {
   if (process.env.TOKENMAXXING_PROBE) return 0;
 
-  const account = readOAuthAccount()?.accountUuid ?? null;
+  const entry = await withLock(paths.lockFile, () => ({ swapClock: loadLastSwapAt(), account: readOAuthAccount()?.accountUuid ?? null }));
+  const account = entry.account;
   const now = Date.now();
   const raw = await readStdin();
   const parsed = StopFailureStdin.safeParse((() => { try { return JSON.parse(raw); } catch { return {}; } })());
@@ -44,29 +44,27 @@ export async function runStopFailureHook(): Promise<number> {
   const canPause = process.env.TOKENMAXXING_SUPERVISED === "1" && pinnedSid != null && mainLoop;
 
   try {
+    const lastSwapAt = loadLastSwapAt();
+    if (lastSwapAt != null && lastSwapAt === entry.swapClock && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
+      log("stopfailure.cooldown", { sinceSwapMs: now - lastSwapAt });
+      return 0;
+    }
     const cfg = loadConfig();
-    const found = stdin.transcript_path
+    const row = stdin.transcript_path
       ? findEnforcedRow({ rows: readTranscriptTail(stdin.transcript_path), lastAssistantMessage: stdin.last_assistant_message, now })
       : null;
-    const limit = found ? classifyEnforcedLimit(found.row, cfg.policy.switchModels) : null;
+    const limit = row ? classifyEnforcedLimit(row, cfg.policy.switchModels) : null;
 
     let enforced: EnforcedLimit | null = null;
-    if (limit && found && account) {
-      if (postSwapProof({ swapAt: loadLastSwapAt(), launchedAt, errorAt: found.errorAt, now })) {
-        const stamp = await recordEnforcedLimit({ limit, account, now });
-        log("stopfailure.enforced", { kind: limit.kind, family: limit.kind === "model" ? limit.family : undefined, outcome: stamp.outcome, resetsAt: stamp.resetsAt, subagent: !mainLoop });
-        if (stamp.outcome !== "account-moved") {
-          enforced = { account, family: limit.kind === "model" ? limit.family : null, resetsAt: stamp.resetsAt, windowMs: enforcedWindowMs(limit) };
-        }
-      } else {
-        log("stopfailure.unproven", { kind: limit.kind });
-      }
+    if (limit && account) {
+      enforced = { account, kind: limit.kind, family: limit.kind === "model" ? limit.family : null, resetsAt: limit.resetsAt, blind: !mainLoop && limit.kind !== "model" };
+      log("stopfailure.enforced", { kind: limit.kind, family: enforced.family ?? undefined, resetsAt: limit.resetsAt, subagent: !mainLoop });
     } else {
       log("stopfailure.unclassified", {
-        row: found != null,
-        type: found?.row.quotaLimits?.rateLimitType,
-        transient: found?.row.apiErrorIsTransient,
-        body: found ? parseErrorBody(found.row.errorDetails)?.error?.type : undefined,
+        row: row != null,
+        type: row?.quotaLimits?.rateLimitType,
+        transient: row?.apiErrorIsTransient,
+        body: row ? parseErrorBody(row.errorDetails)?.error?.type : undefined,
       });
     }
 
@@ -78,7 +76,6 @@ export async function runStopFailureHook(): Promise<number> {
         ts: Date.now(),
         waitUntil: decision.waitUntil ?? now,
         sessionId: stdinSid ?? pinnedSid,
-        prompt: RETRIGGER_PROMPT,
         ...(launchedAt != null ? { launchedAt } : {}),
       });
       writeFileAtomic(marker, JSON.stringify(payload));

package/src/entries/supervisor.ts

@@ -292,7 +292,7 @@ export async function runSupervisor(argv: string[]): Promise<number> {
         if (await countdownWait(m.account, m.waitUntil)) overriddenUntil = m.waitUntil;
       } else process.stdout.write(`\n\x1b[36m↻ tokenmaxxing: switched to ${m.account} - resuming...\x1b[0m\n`);
       saveSessionFlags(m.sessionId, persistable, process.cwd());
-      launchArgs = ["--resume", m.sessionId, ...persistable, ...(m.prompt ? ["--", m.prompt] : [])];
+      launchArgs = ["--resume", m.sessionId, ...persistable];
       continue;
     }
     log("supervisor.exit", { sid, respawns, code: child.exitCode, signal: child.signalCode });

package/src/lib/decide.ts

@@ -2,11 +2,11 @@ import { maxBy } from "es-toolkit";
 import { z } from "zod";
 import { withLock } from "./lock.ts";
 import { paths } from "./paths.ts";
-import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsage, loadUsageSnapshot, saveAccounts, saveDepletedWait, writeUsage } from "./state.ts";
+import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsageSnapshot, saveAccounts, saveDepletedWait, writeUsage } from "./state.ts";
 import { readOAuthAccount } from "./claudejson.ts";
 import { isSkippableSwapError, performSwap } from "./swap.ts";
-import { nextWeeklyReset, pickBest, pickEarliestReset, thresholdBars, usableAt } from "./picker.ts";
-import { familyTokens, gatedFamilies, keepRows, probeUsage, type EnforcedClass } from "./usage.ts";
+import { isExhausted, nextWeeklyReset, pickBest, pickEarliestReset, thresholdBars, usableAt } from "./picker.ts";
+import { familyTokens, gatedFamilies, keepRows, probeUsage } from "./usage.ts";
 import { log } from "./log.ts";
 import { AccountSchema, UsageStateSchema, type Account, type Config, type EnforcedLimit, type Thresholds, type UsageState, type UsageWindow } from "./types.ts";
 
@@ -40,7 +40,9 @@ function capForFamily(account: Account, family: string, now: number): UsageWindo
 }
 
 function isOver(u: UsageState | null, account: Account | undefined, bars: Thresholds, cfg: Config, now: number): boolean {
-  if (!u || !account || u.account !== account.accountUuid) return false;
+  if (!account) return false;
+  if (account.enforcedUntil != null && account.enforcedUntil > now) return true;
+  if (!u || u.account !== account.accountUuid) return false;
   if (
     liveUsed({ window: u.fiveHour, windowMs: FIVE_HOURS_MS, sampledAt: u.ts, now }) >= bars.session ||
     liveUsed({ window: u.sevenDay, windowMs: WEEK_MS, sampledAt: u.ts, now }) >= bars.weekly
@@ -75,14 +77,15 @@ function freshest(u: UsageState | null, uAt: number | null, account: Account | u
   return { ...u, ts: uAt };
 }
 
-async function loadFreshSnapshots(cfg: Config, account: string | null, now: number): Promise<Snapshots> {
+async function loadFreshSnapshots(cfg: Config, account: string | null, now: number, probe: boolean): Promise<Snapshots> {
   const snap = loadUsageSnapshot();
   let u = snap?.state ?? null;
   let uAt = snap?.at ?? null;
   const ttl = cfg.policy.usagePollTtlMs;
   const stored = loadAccounts().accounts.find((a) => a.accountUuid === account);
   const probeAttempted = stored?.lastProbeAt != null && now - stored.lastProbeAt <= ttl;
-  if (account && stored && !probeAttempted && (!usageFresh(u, uAt, account, ttl, now) || needsPerModel(u, cfg))) {
+  const walled = stored?.enforcedUntil != null && stored.enforcedUntil > now;
+  if (probe && account && stored && !walled && !probeAttempted && (!usageFresh(u, uAt, account, ttl, now) || needsPerModel(u, cfg))) {
     const startedAt = Date.now();
     const full = await probeUsage();
     const ts = Date.now();
@@ -121,21 +124,20 @@ async function loadFreshSnapshots(cfg: Config, account: string | null, now: numb
 
 export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = false, enforced: EnforcedLimit | null = null): Promise<SwapDecision> {
   const activeAccount = readOAuthAccount()?.accountUuid ?? null;
-  const enforced0 = enforced && enforced.account === activeAccount ? enforced : null;
 
   const lastSwapAt = loadLastSwapAt();
-  if (!enforced0 && lastSwapAt != null && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
+  if (!enforced && lastSwapAt != null && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
     return depletedReplay(now) ?? { swapped: false, account: null, reason: "post-swap-cooldown" };
   }
 
   const cfg = loadConfig();
   const bars = thresholdBars(cfg);
 
-  const { u: teeUsage, uAt } = await loadFreshSnapshots(cfg, activeAccount, now);
+  const { u: teeUsage, uAt } = await loadFreshSnapshots(cfg, activeAccount, now, enforced == null);
   const stored = loadAccounts().accounts.find((a) => a.accountUuid === activeAccount);
   const usage = freshest(teeUsage, uAt, stored);
 
-  if (!enforced0 && !isOver(usage, stored, bars, cfg, now)) {
+  if (!enforced && !isOver(usage, stored, bars, cfg, now)) {
     const measured = usage != null && activeAccount != null && usage.account === activeAccount;
     if (!measured) {
       const replay = depletedReplay(now);
@@ -147,11 +149,20 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
   return withLock(paths.lockFile, async () => {
     const idx = loadAccounts();
     const account2 = readOAuthAccount()?.accountUuid ?? null;
-    const enforced2 = enforced0 && enforced0.account === account2 ? enforced0 : null;
     const tee = loadUsageSnapshot();
     const active = account2 ? idx.accounts.find((a) => a.accountUuid === account2) : undefined;
     const u2 = tee ? freshest(tee.state, tee.at, active) : usage;
 
+    const origin = enforced ? idx.accounts.find((a) => a.accountUuid === enforced.account) : undefined;
+    const prior = origin?.enforcedUntil != null && origin.enforcedUntil > now;
+    if (enforced && origin) {
+      origin.enforcedUntil = Math.max(origin.enforcedUntil ?? 0, enforcedWall(enforced, origin, now));
+      origin.lastProbeAt = now;
+      saveAccounts(idx);
+      log("usage.enforced_limit", { kind: enforced.kind, family: enforced.family ?? undefined, resetsAt: origin.enforcedUntil, blind: prior || enforced.blind, live: origin === active });
+    }
+    const enforced2 = enforced && origin && origin === active ? enforced : null;
+
     if (account2 != null && !active) {
       return { swapped: false, account: null, reason: "live-credential-not-in-pool" };
     }
@@ -162,10 +173,14 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
       saveAccounts(idx);
     }
 
-    const gated = gatedFamilies(u2?.model ?? null, cfg.policy.switchModels);
-    const switchFamilies = enforced2?.family && !gated.includes(enforced2.family) ? [...gated, enforced2.family] : gated;
+    const walled = active?.enforcedUntil != null && active.enforcedUntil > now;
+    const blindScreen = (enforced != null && (prior || enforced.blind)) || (walled && !enforced2);
+    const gated = blindScreen ? cfg.policy.switchModels : gatedFamilies(u2?.model ?? null, cfg.policy.switchModels);
+    const family = enforced?.family ?? null;
+    const switchFamilies = family != null && !gated.includes(family) ? [...gated, family] : gated;
 
-    if (!enforced2 && !isOver(u2, active, bars, cfg, now)) {
+    const seatExhausted = active != null && isExhausted(active, { now, thresholds: bars, currentAccountUuid: account2, switchFamilies });
+    if (!enforced2 && !isOver(u2, active, bars, cfg, now) && !(enforced && seatExhausted)) {
       return depletedReplay(now) ?? { swapped: false, account: null, reason: "raced-already-swapped" };
     }
 
@@ -201,8 +216,7 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
       const fresh = loadAccounts();
       const current = seatOf(fresh);
       const ctx = { now, thresholds: bars, currentAccountUuid: current?.accountUuid ?? null, switchFamilies };
-      const enforcedUntil = enforced2 && current && current.accountUuid === enforced2.account ? (enforced2.resetsAt ?? now + enforced2.windowMs) : 0;
-      const currentAt = current ? Math.max(usableAt(current, ctx), enforcedUntil) : Number.POSITIVE_INFINITY;
+      const currentAt = current ? usableAt(current, ctx) : Number.POSITIVE_INFINITY;
       const other = pickEarliestReset(usable(fresh.accounts), ctx);
 
       let target: Account | null = null;
@@ -245,63 +259,19 @@ function depletedReplay(now: number): SwapDecision | null {
   return { swapped: false, account, reason: "depleted-wait", waitUntil: rec.waitUntil };
 }
 
-export function enforcedWindowMs(limit: EnforcedClass): number {
-  return limit.kind === "session" ? FIVE_HOURS_MS : WEEK_MS;
-}
-
-export function postSwapProof(input: { swapAt: number | null; launchedAt: number | null; errorAt: number | null; now: number }): boolean {
-  const { swapAt, launchedAt, errorAt, now } = input;
-  if (swapAt == null) return true;
-  if (launchedAt != null && launchedAt > swapAt) return true;
-  return (errorAt ?? now) - swapAt >= POST_SWAP_COOLDOWN_MS;
-}
-
-const StampSchema = z.object({ outcome: z.enum(["stamped", "account-moved", "no-carrier"]), resetsAt: z.number().nullable() });
-export type Stamp = z.infer<typeof StampSchema>;
-
-export async function recordEnforcedLimit(input: { limit: EnforcedClass; account: string; now: number }): Promise<Stamp> {
-  const { limit, account: accountUuid, now } = input;
-  return withLock(paths.lockFile, () => {
-    if ((readOAuthAccount()?.accountUuid ?? null) !== accountUuid) return { outcome: "account-moved", resetsAt: limit.resetsAt };
-    const prior = loadUsage();
-    const priorSame = prior && prior.account === accountUuid ? prior : null;
-    const idx = loadAccounts();
-    const account = idx.accounts.find((a) => a.accountUuid === accountUuid);
-    if (limit.kind === "model") {
-      const rows = account?.lastUsage?.perModel ?? {};
-      const knownReset = Object.entries(rows).filter(([k]) => familyTokens(k).includes(limit.family)).map(([, w]) => w.resetsAt).find((r): r is number => r != null) ?? null;
-      const weeklyReset = priorSame?.sevenDay.resetsAt ?? account?.lastUsage?.sevenDay.resetsAt ?? null;
-      const resetsAt = limit.resetsAt ?? nextWeeklyReset(knownReset ?? weeklyReset, now);
-      if (!account) return { outcome: "no-carrier", resetsAt };
-      if (account.lastUsage) {
-        const others = Object.fromEntries(Object.entries(rows).filter(([k]) => !familyTokens(k).includes(limit.family)));
-        account.lastUsage = { ...account.lastUsage, perModel: { ...others, [limit.family]: { usedPercentage: 100, resetsAt } }, ...(resetsAt == null ? { rowsAt: now } : {}) };
-      } else {
-        account.enforcedUntil = resetsAt ?? now + WEEK_MS;
-      }
-      account.lastProbeAt = now;
-      saveAccounts(idx);
-      log("usage.enforced_limit", { kind: limit.kind, family: limit.family, resetsAt });
-      return { outcome: "stamped", resetsAt };
-    }
-    if (account) {
-      account.lastProbeAt = now;
-      if (limit.resetsAt != null) account.enforcedUntil = limit.resetsAt;
-      saveAccounts(idx);
-    }
-    const carrier = priorSame ?? (account?.lastUsage ? { ...account.lastUsage, model: null } : null);
-    if (!carrier) return { outcome: "no-carrier", resetsAt: limit.resetsAt };
-    const window: UsageWindow = { usedPercentage: 100, resetsAt: limit.resetsAt };
-    writeUsage({
-      ...(priorSame ?? {}),
-      ...(priorSame == null && account?.lastUsageAt != null ? { sampledAt: account.lastUsageAt } : {}),
-      fiveHour: limit.kind === "session" ? window : carrier.fiveHour,
-      sevenDay: limit.kind === "weekly" ? window : carrier.sevenDay,
-      account: accountUuid,
-      ts: now,
-      model: carrier.model,
-    }, { stamp: true });
-    log("usage.enforced_limit", { kind: limit.kind, resetsAt: limit.resetsAt });
-    return { outcome: "stamped", resetsAt: limit.resetsAt };
-  });
+function enforcedWall(limit: EnforcedLimit, account: Account, now: number): number {
+  const cached = account.lastUsage;
+  const { family } = limit;
+  const familyReset =
+    family == null
+      ? null
+      : Object.entries(cached?.perModel ?? {})
+          .filter(([k]) => familyTokens(k).includes(family))
+          .map(([, w]) => w.resetsAt)
+          .find((r): r is number => r != null) ?? null;
+  const cachedReset =
+    limit.kind === "session"
+      ? cached?.fiveHour.resetsAt != null && cached.fiveHour.resetsAt > now ? cached.fiveHour.resetsAt : null
+      : nextWeeklyReset(familyReset ?? cached?.sevenDay.resetsAt ?? null, now);
+  return limit.resetsAt ?? cachedReset ?? now + (limit.kind === "session" ? FIVE_HOURS_MS : WEEK_MS);
 }

package/src/lib/types.ts

@@ -82,9 +82,10 @@ export type AccountsIndex = z.infer<typeof AccountsIndexSchema>;
 
 export const EnforcedLimitSchema = z.object({
   account: z.string(),
+  kind: z.enum(["session", "weekly", "model"]),
   family: z.string().nullable(),
   resetsAt: z.number().nullable(),
-  windowMs: z.number(),
+  blind: z.boolean(),
 });
 export type EnforcedLimit = z.infer<typeof EnforcedLimitSchema>;
 
@@ -128,7 +129,6 @@ export const RespawnMarkerSchema = z.object({
   ts: z.number(),
   waitUntil: z.number(),
   sessionId: z.string(),
-  prompt: z.string().optional(),
   launchedAt: z.number().optional(),
 });
 

package/src/lib/usage.ts

@@ -169,13 +169,7 @@ export function transcriptRowText(row: TranscriptRow): string {
 
 const ROW_RECENCY_MS = 60_000;
 
-const EnforcedRowSchema = z.object({
-  row: TranscriptRowSchema,
-  errorAt: z.number().nullable(),
-});
-export type EnforcedRow = z.infer<typeof EnforcedRowSchema>;
-
-export function findEnforcedRow(input: { rows: TranscriptRow[]; lastAssistantMessage: string | undefined; now: number }): EnforcedRow | null {
+export function findEnforcedRow(input: { rows: TranscriptRow[]; lastAssistantMessage: string | undefined; now: number }): TranscriptRow | null {
   const { rows, lastAssistantMessage, now } = input;
   for (let i = rows.length - 1; i >= 0; i--) {
     const row = rows[i]!;
@@ -183,8 +177,7 @@ export function findEnforcedRow(input: { rows: TranscriptRow[]; lastAssistantMes
     const ts = row.timestamp ? Date.parse(row.timestamp) : Number.NaN;
     const byContent = lastAssistantMessage != null && lastAssistantMessage !== "" && transcriptRowText(row) === lastAssistantMessage;
     const byRecency = Number.isFinite(ts) && Math.abs(now - ts) <= ROW_RECENCY_MS;
-    if (!byContent && !byRecency) continue;
-    return { row, errorAt: Number.isFinite(ts) ? ts : null };
+    if (byContent || byRecency) return row;
   }
   return null;
 }

package/src/main.ts

@@ -27,11 +27,11 @@ import { cmdSetupToken } from "./cli/setuptoken.ts";
 import { cmdCloudRun } from "./cli/cloudrun.ts";
 import { cmdCursorInit } from "./cli/cursorinit.ts";
 import { timerDeactivationHint, uninstallSupervisor } from "./lib/install.ts";
-import { c, emitError, emitJson } from "./cli/render.ts";
+import { c, emitError } from "./cli/render.ts";
 
 const JSON_FLAG = "--json";
 const CACHED_FLAG = "--cached";
-const INTERACTIVE_COMMANDS = new Set(["init", "add", "auth"]);
+const JSON_COMMANDS = new Set(["status", "config", "check", "switch"]);
 
 function printHelp(): void {
   console.log(`${c.bold("tokenmaxxing")} - automatic Claude Code account switching
@@ -55,7 +55,7 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing cursor init")} [dir]  write the Claude relay subagent (.cursor/agents/claude.md) and .cursor/environment.json into a repo
   ${c.cyan("tokenmaxxing cloud run")} [--session <id>] [--max-turns <n>] "<prompt>"  on a Cursor Cloud VM: run claude -p on a setup token from TOKENMAXXING_TOKENS, rotate to the next token on a usage limit
 
-  ${c.cyan("--json")}                  print one JSON document on stdout instead of text (status, config, doctor, check, switch, rename, rm, uninstall, setup-token --print, cursor init, cloud run); every document carries ${c.bold("ok")}, failures add ${c.bold("error")}
+  ${c.cyan("--json")}                  print one JSON document on stdout instead of text (status, config, check, switch); every document carries ${c.bold("ok")}, failures add ${c.bold("error")}
 
   ${c.dim("(aliased as")} ${c.cyan("xx")}${c.dim(")")} - then just run ${c.bold("claude")} as always; it switches accounts near quota automatically.`);
 }
@@ -88,8 +88,8 @@ async function main(): Promise<number> {
     return 2;
   }
 
-  if (json && sub != null && INTERACTIVE_COMMANDS.has(sub)) {
-    emitError({ json, message: `${sub} is interactive (it runs a login flow) and has no --json form` });
+  if (json && sub != null && !JSON_COMMANDS.has(sub)) {
+    emitError({ json, message: `${sub} has no ${JSON_FLAG} form (${JSON_FLAG} applies to ${[...JSON_COMMANDS].join(", ")})` });
     return 2;
   }
   if (!(sub != null && sub.startsWith("__")) && !process.env.TOKENMAXXING_PROBE) {
@@ -135,21 +135,21 @@ async function main(): Promise<number> {
     case "init": return args.includes("--codex") ? cmdCodexInit() : cmdInit();
     case "add": return args.includes("--codex") ? cmdCodexAdd() : cmdAdd();
     case "auth": return cmdAuth(args.slice(1));
-    case "doctor": return cmdDoctor(json);
+    case "doctor": return cmdDoctor();
     case "rm": {
       const rest = args.slice(1).filter((a) => a !== "--codex");
-      return args.includes("--codex") ? cmdCodexRm(rest[0], json) : cmdRm(rest[0], json);
+      return args.includes("--codex") ? cmdCodexRm(rest[0]) : cmdRm(rest[0]);
     }
-    case "rename": return cmdRename(args.slice(1), json);
-    case "setup-token": return cmdSetupToken(args.slice(1), json);
+    case "rename": return cmdRename(args.slice(1));
+    case "setup-token": return cmdSetupToken(args.slice(1));
     case "cursor": {
-      if (args[1] === "init") return cmdCursorInit(args.slice(2), json);
-      emitError({ json, message: "usage: tokenmaxxing cursor init [dir]" });
+      if (args[1] === "init") return cmdCursorInit(args.slice(2));
+      emitError({ message: "usage: tokenmaxxing cursor init [dir]" });
       return 2;
     }
     case "cloud": {
-      if (args[1] === "run") return cmdCloudRun(args.slice(2), json);
-      emitError({ json, message: 'usage: tokenmaxxing cloud run [--session <id>] [--max-turns <n>] "<prompt>"' });
+      if (args[1] === "run") return cmdCloudRun(args.slice(2));
+      emitError({ message: 'usage: tokenmaxxing cloud run [--session <id>] [--max-turns <n>] "<prompt>"' });
       return 2;
     }
     case "uninstall": {
@@ -160,10 +160,6 @@ async function main(): Promise<number> {
         ...(out.timerDeactivated ? ["check timer"] : []),
         ...(out.pathLineRemoved ? ["rc PATH line"] : []),
       ];
-      if (json) {
-        emitJson({ ok: true, removed, timerDeactivated: out.timerDeactivated, pathLineRemoved: out.pathLineRemoved });
-        return 0;
-      }
       console.log(`removed ${removed.join(", ")}`);
       if (!out.timerDeactivated) console.log(c.yellow(`⚠ the check job may still be loaded - run: ${timerDeactivationHint()}`));
       if (!out.pathLineRemoved) console.log(c.dim("(no tokenmaxxing PATH line found in the shell rc)"));
@@ -176,8 +172,8 @@ async function main(): Promise<number> {
       printHelp();
       return 0;
     default:
-      emitError({ json, message: `unknown command: ${sub}` });
-      if (!json) printHelp();
+      emitError({ message: `unknown command: ${sub}` });
+      printHelp();
       return 2;
   }
 }