tokenmaxxing 1.9.1 → 1.11.0

package/src/cli/config.ts

@@ -5,7 +5,7 @@ import { z } from "zod";
 import { paths, realClaudeBinFromEnv, realCodexBinFromEnv } from "../lib/paths.ts";
 import { ConfigFileSchema, loadConfig, mergeConfigFile } from "../lib/state.ts";
 import { writeFileAtomic } from "../lib/atomic.ts";
-import { c } from "./render.ts";
+import { c, emitError, emitJson } from "./render.ts";
 
 export const KNOWN_KEYS = [
   "thresholds.session",
@@ -49,22 +49,53 @@ function unknownFileKeys(raw: Record<string, unknown>): string[] {
   return dottedKeys(raw).filter((key) => !known.has(key));
 }
 
+function isKnownKey(key: string): boolean {
+  return KNOWN_KEYS.some((known) => known === key);
+}
+
 function envSourceFor(key: string): string | null {
   if (key === "claudeBin" && realClaudeBinFromEnv()) return "TOKENMAXXING_CLAUDE_BIN";
   if (key === "codexBin" && realCodexBinFromEnv()) return "TOKENMAXXING_CODEX_BIN";
   return null;
 }
 
-function printEffective(): number {
+function sourceOf(input: { key: string; raw: Record<string, unknown> }): { source: "env" | "file" | "default"; env: string | null } {
+  const env = envSourceFor(input.key);
+  if (env) return { source: "env", env };
+  return { source: get(input.raw, input.key) !== undefined ? "file" : "default", env: null };
+}
+
+function unknownKey(input: { key: string; json: boolean }): number {
+  emitError({
+    json: input.json,
+    message: `unknown config key: ${input.key}`,
+    notes: [`known keys: ${KNOWN_KEYS.join(", ")}`],
+    extra: { knownKeys: KNOWN_KEYS },
+  });
+  return 1;
+}
+
+function printEffective(json: boolean): number {
   const effective = loadConfig();
   const raw = readRawFile();
+  const unknown = unknownFileKeys(raw);
+  if (json) {
+    const sources: Record<string, string> = {};
+    const envOverrides: Record<string, string> = {};
+    for (const key of KNOWN_KEYS) {
+      const { source, env } = sourceOf({ key, raw });
+      sources[key] = source;
+      if (env) envOverrides[key] = env;
+    }
+    emitJson({ ok: true, path: paths.configJson, config: effective, sources, envOverrides, unknownKeys: unknown });
+    return 0;
+  }
   console.log(c.dim(`config.json: ${paths.configJson}`));
   for (const key of KNOWN_KEYS) {
-    const env = envSourceFor(key);
-    const source = env ? c.yellow(`env ${env}`) : get(raw, key) !== undefined ? c.green("file") : c.dim("default");
-    console.log(`  ${key.padEnd(28)} ${JSON.stringify(get(effective, key))}  ${source}`);
+    const { source, env } = sourceOf({ key, raw });
+    const painted = source === "env" ? c.yellow(`env ${env}`) : source === "file" ? c.green("file") : c.dim("default");
+    console.log(`  ${key.padEnd(28)} ${JSON.stringify(get(effective, key))}  ${painted}`);
   }
-  const unknown = unknownFileKeys(raw);
   if (unknown.length > 0) {
     console.log();
     console.log(c.yellow(`unknown keys in the file (ignored by the loader): ${unknown.join(", ")}`));
@@ -73,13 +104,14 @@ function printEffective(): number {
   return 0;
 }
 
-function cmdGet(key: string): number {
-  if (!KNOWN_KEYS.some((known) => known === key)) {
-    console.error(c.red(`unknown config key: ${key}`));
-    console.error(c.dim(`known keys: ${KNOWN_KEYS.join(", ")}`));
-    return 1;
+function cmdGet(key: string, json: boolean): number {
+  if (!isKnownKey(key)) return unknownKey({ key, json });
+  const value = get(loadConfig(), key);
+  if (json) {
+    emitJson({ ok: true, key, value, source: sourceOf({ key, raw: readRawFile() }).source });
+    return 0;
   }
-  console.log(JSON.stringify(get(loadConfig(), key)));
+  console.log(JSON.stringify(value));
   return 0;
 }
 
@@ -91,31 +123,31 @@ function parseValue(text: string): unknown {
   }
 }
 
-function cmdSet(key: string, valueText: string): number {
-  if (!KNOWN_KEYS.some((known) => known === key)) {
-    console.error(c.red(`unknown config key: ${key}`));
-    console.error(c.dim(`known keys: ${KNOWN_KEYS.join(", ")}`));
-    return 1;
-  }
+function cmdSet(key: string, valueText: string, json: boolean): number {
+  if (!isKnownKey(key)) return unknownKey({ key, json });
   const raw = readRawFile();
   const next = structuredClone(raw);
   set(next, key, parseValue(valueText));
   const validated = ConfigFileSchema.safeParse(next);
   if (!validated.success) {
-    console.error(c.red(`rejected: ${validated.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`));
+    emitError({ json, message: `rejected: ${validated.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}` });
     return 1;
   }
   const mergedCheck = mergeConfigFile(validated.data);
   if (!mergedCheck.ok) {
-    console.error(c.red(`rejected: ${mergedCheck.detail}`));
+    emitError({ json, message: `rejected: ${mergedCheck.detail}` });
     return 1;
   }
   writeRawFile({ raw: next });
   const beforeFile = get(raw, key);
+  const env = envSourceFor(key);
+  if (json) {
+    emitJson({ ok: true, key, before: beforeFile === undefined ? null : beforeFile, after: get(next, key), envOverride: env });
+    return 0;
+  }
   console.log(
     `${key}: ${beforeFile === undefined ? "(default)" : JSON.stringify(beforeFile)} -> ${JSON.stringify(get(next, key))}`,
   );
-  const env = envSourceFor(key);
   if (env) console.log(c.yellow(`note: ${env} is set and overrides the file value in this environment`));
   return 0;
 }
@@ -128,14 +160,12 @@ function pruneEmptyParents(raw: Record<string, unknown>): void {
   }
 }
 
-function cmdUnset(key: string): number {
-  if (!KNOWN_KEYS.some((known) => known === key)) {
-    console.error(c.red(`unknown config key: ${key}`));
-    return 1;
-  }
+function cmdUnset(key: string, json: boolean): number {
+  if (!isKnownKey(key)) return unknownKey({ key, json });
   const raw = readRawFile();
   if (get(raw, key) === undefined) {
-    console.log(c.dim(`${key} has no file override (default already applies)`));
+    if (json) emitJson({ ok: true, key, unset: false, value: get(loadConfig(), key) });
+    else console.log(c.dim(`${key} has no file override (default already applies)`));
     return 0;
   }
   const next = structuredClone(raw);
@@ -143,20 +173,25 @@ function cmdUnset(key: string): number {
   pruneEmptyParents(next);
   const validated = ConfigFileSchema.safeParse(next);
   if (!validated.success) {
-    console.error(c.red(`rejected: ${validated.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`));
+    emitError({ json, message: `rejected: ${validated.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}` });
     return 1;
   }
   const mergedCheck = mergeConfigFile(validated.data);
   if (!mergedCheck.ok) {
-    console.error(c.red(`rejected: ${mergedCheck.detail} (adjust the conflicting override before unsetting ${key})`));
+    emitError({ json, message: `rejected: ${mergedCheck.detail} (adjust the conflicting override before unsetting ${key})` });
     return 1;
   }
   writeRawFile({ raw: next });
-  console.log(`${key} unset -> ${JSON.stringify(get(loadConfig(), key))} (default)`);
+  const value = get(loadConfig(), key);
+  if (json) {
+    emitJson({ ok: true, key, unset: true, value });
+    return 0;
+  }
+  console.log(`${key} unset -> ${JSON.stringify(value)} (default)`);
   return 0;
 }
 
-function cmdTidy(): number {
+function cmdTidy(json: boolean): number {
   const raw = readRawFile();
   const dropped = unknownFileKeys(raw);
   const parsed = ConfigFileSchema.parse(raw);
@@ -167,30 +202,39 @@ function cmdTidy(): number {
   if (normalized != null) set(next, "policy.switchModels", normalized);
   pruneEmptyParents(next);
 
-  if (JSON.stringify(next) === JSON.stringify(raw)) {
+  const changed = JSON.stringify(next) !== JSON.stringify(raw);
+  if (changed) writeRawFile({ raw: next });
+  if (json) {
+    emitJson({ ok: true, changed, droppedKeys: dropped, casingNormalized: casingChanged });
+    return 0;
+  }
+  if (!changed) {
     console.log(c.dim("nothing to tidy"));
     return 0;
   }
-  writeRawFile({ raw: next });
   if (dropped.length > 0) console.log(`dropped unknown keys: ${dropped.join(", ")}`);
   if (casingChanged) console.log("normalized switchModels casing");
   if (dropped.length === 0 && !casingChanged) console.log("canonicalized file layout (pruned empty sections / key order)");
   return 0;
 }
 
-export function cmdConfig(args: string[]): number {
+export function cmdConfig(args: string[], json = false): number {
   const [sub, key, value] = args;
   try {
-    if (sub === undefined) return printEffective();
-    if (sub === "get" && key !== undefined) return cmdGet(key);
-    if (sub === "set" && key !== undefined && value !== undefined) return cmdSet(key, value);
-    if (sub === "unset" && key !== undefined) return cmdUnset(key);
-    if (sub === "tidy") return cmdTidy();
+    if (sub === undefined) return printEffective(json);
+    if (sub === "get" && key !== undefined) return cmdGet(key, json);
+    if (sub === "set" && key !== undefined && value !== undefined) return cmdSet(key, value, json);
+    if (sub === "unset" && key !== undefined) return cmdUnset(key, json);
+    if (sub === "tidy") return cmdTidy(json);
   } catch (e) {
-    console.error(c.red(`config.json is unreadable: ${e instanceof Error ? e.message : String(e)}`));
-    console.error(c.dim(`fix or delete ${paths.configJson} (defaults apply when it is absent), then re-run`));
+    emitError({
+      json,
+      message: `config.json is unreadable: ${e instanceof Error ? e.message : String(e)}`,
+      notes: [`fix or delete ${paths.configJson} (defaults apply when it is absent), then re-run`],
+      extra: { path: paths.configJson },
+    });
     return 1;
   }
-  console.error(c.red("usage: tokenmaxxing config [get <key> | set <key> <value> | unset <key> | tidy]"));
+  emitError({ json, message: "usage: tokenmaxxing config [get <key> | set <key> <value> | unset <key> | tidy]" });
   return 2;
 }

package/src/cli/doctor.ts

@@ -7,7 +7,7 @@ import { loadAccounts, loadConfig } from "../lib/state.ts";
 import { readItem, liveTarget, parkedTarget } from "../lib/credstore.ts";
 import { isAccessTokenExpiring, fetchTokenOrg } from "../lib/oauth.ts";
 import { CredentialBlobSchema, type RolesResponse } from "../lib/types.ts";
-import { c } from "./render.ts";
+import { c, emitJson } from "./render.ts";
 
 async function blobOrg(raw: string): Promise<RolesResponse | null> {
   const creds = CredentialBlobSchema.parse(JSON.parse(raw)).claudeAiOauth;
@@ -15,11 +15,21 @@ async function blobOrg(raw: string): Promise<RolesResponse | null> {
   return fetchTokenOrg(creds.accessToken);
 }
 
-export async function cmdDoctor(): Promise<number> {
-  let ok = true;
+export async function cmdDoctor(json = false): Promise<number> {
+  const checks: { ok: boolean; label: string; hint: string | null }[] = [];
+  const notes: string[] = [];
+  const warnings: string[] = [];
   const check = (cond: boolean, label: string, hint?: string) => {
-    console.log(`${cond ? c.green("✓") : c.red("✗")} ${label}${!cond && hint ? c.dim(`  - ${hint}`) : ""}`);
-    if (!cond) ok = false;
+    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}`));
   };
 
   check(existsSync(paths.supervisorLink), "claude supervisor wrapper present", "run `tokenmaxxing init`");
@@ -46,7 +56,7 @@ export async function cmdDoctor(): Promise<number> {
     try {
       const org = await blobOrg(live);
       if (org) check(org.organization_uuid === active.organizationUuid, `live credential identity matches active (${active.email})`, `token belongs to ${org.organization_name} - run \`tokenmaxxing switch\``);
-      else console.log(c.dim(`  - live credential identity unverifiable (access token expired)`));
+      else note("live credential identity unverifiable (access token expired)");
     } catch (e) {
       check(false, `live credential identity matches active (${active.email})`, (e instanceof Error ? e.message : String(e)).slice(0, 100));
     }
@@ -59,7 +69,7 @@ export async function cmdDoctor(): Promise<number> {
       try {
         const org = await blobOrg(parked);
         if (org) check(org.organization_uuid === a.organizationUuid, `parked credential identity matches ${a.email}`, `token belongs to ${org.organization_name} - run \`tokenmaxxing auth ${a.label}\``);
-        else console.log(c.dim(`  - ${a.email} identity unverifiable (access token expired)`));
+        else note(`${a.email} identity unverifiable (access token expired)`);
       } catch (e) {
         check(false, `parked credential identity matches ${a.email}`, (e instanceof Error ? e.message : String(e)).slice(0, 100));
       }
@@ -77,11 +87,17 @@ export async function cmdDoctor(): Promise<number> {
   const rc = shellRcPath();
   if (rc && existsSync(rc)) {
     for (const s of findClaudeShadowers(readFileSync(rc, "utf8"))) {
-      if (s.kind === "shadow") console.log(c.yellow(`⚠ ${rc}: \`${s.line}\` shadows the supervised claude wrapper - launches through it skip tokenmaxxing`));
-      else console.log(c.yellow(`⚠ ${rc}: alias \`${s.name}\` hardcodes a claude path and bypasses the supervisor - use plain \`claude\` in its body instead`));
+      if (s.kind === "shadow") warn(`${rc}: ${s.line.startsWith("alias ") ? "alias" : "function"} \`claude\` shadows the supervised claude wrapper - launches through it skip tokenmaxxing`);
+      else warn(`${rc}: alias \`${s.name}\` hardcodes a claude path and bypasses the supervisor - use plain \`claude\` in its body instead`);
     }
   }
 
+  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;

package/src/cli/ls.ts

@@ -1,10 +1,45 @@
 import { loadAccounts } from "../lib/state.ts";
 import { loadCodexAccounts } from "../lib/codexstate.ts";
 import { liveCodexAccountId } from "../lib/codexsample.ts";
-import { c, claudeTierLabel } from "./render.ts";
+import { c, claudeTierLabel, emitJson } from "./render.ts";
 
-export function cmdLs(): number {
+export function cmdLs(json = false): number {
   const idx = loadAccounts();
+
+  if (json) {
+    const codex = loadCodexAccounts();
+    const liveId = codex.accounts.length > 0 ? liveCodexAccountId() : null;
+    emitJson({
+      ok: true,
+      claude: {
+        activeAccountUuid: idx.activeAccountUuid,
+        accounts: idx.accounts.map((a) => ({
+          label: a.label,
+          email: a.email,
+          accountUuid: a.accountUuid,
+          organizationUuid: a.organizationUuid,
+          tier: claudeTierLabel(a),
+          active: a.accountUuid === idx.activeAccountUuid,
+          needsReauth: a.needsReauth === true,
+          addedAt: a.addedAt,
+        })),
+      },
+      codex: {
+        activeAccountId: liveId,
+        accounts: codex.accounts.map((account) => ({
+          label: account.label,
+          email: account.email,
+          accountId: account.accountId,
+          planType: account.planType,
+          active: account.accountId === liveId,
+          needsReauth: account.needsReauth === true,
+          addedAt: account.addedAt,
+        })),
+      },
+    });
+    return 0;
+  }
+
   if (idx.accounts.length === 0) {
     console.log(c.dim("no accounts yet - run `tokenmaxxing init` then `tokenmaxxing add`"));
   }

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

package/src/cli/render.ts

@@ -75,3 +75,23 @@ export function fmtAgo(epochMs: number, now = Date.now()): string {
   return `${m}m ago`;
 }
 
+export const plain = (s: string): string => s;
+
+export function emitJson(value: unknown): void {
+  console.log(JSON.stringify(value, null, 2));
+}
+
+export function emitError(input: {
+  json: boolean;
+  message: string;
+  notes?: string[];
+  extra?: Record<string, unknown>;
+  paint?: (s: string) => string;
+}): void {
+  if (input.json) {
+    emitJson({ ok: false, error: input.message, ...input.extra });
+    return;
+  }
+  console.error((input.paint ?? c.red)(input.message));
+  for (const note of input.notes ?? []) console.error(c.dim(note));
+}

package/src/cli/rm.ts

@@ -7,22 +7,22 @@ import { credItemFor, paths } from "../lib/paths.ts";
 import { loadAccounts, saveAccounts } from "../lib/state.ts";
 import { CredentialBlobSchema } from "../lib/types.ts";
 import { findAccount } from "./rename.ts";
-import { c } from "./render.ts";
+import { c, emitError, emitJson, plain } from "./render.ts";
 
-export async function cmdRm(selector?: string): Promise<number> {
+export async function cmdRm(selector?: string, json = false): Promise<number> {
   if (!selector) {
-    console.error("usage: tokenmaxxing rm <email|label|uuid>");
+    emitError({ json, 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) {
-      console.error(c.red(`no account matches "${selector}"`));
+      emitError({ json, message: `no account matches "${selector}"` });
       return 1;
     }
     if (a.accountUuid === idx.activeAccountUuid) {
-      console.error(c.red(`${a.email} is the ACTIVE account - switch away before removing it.`));
+      emitError({ json, message: `${a.email} is the ACTIVE account - switch away before removing it.` });
       return 1;
     }
     const live = await readItem(liveTarget());
@@ -32,11 +32,14 @@ export async function cmdRm(selector?: string): Promise<number> {
         const liveCreds = CredentialBlobSchema.parse(JSON.parse(live)).claudeAiOauth;
         liveOrg = (await fetchTokenOrg(liveCreds.accessToken)).organization_uuid;
       } catch (e) {
-        console.error(c.red(`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 roles endpoint is reachable.`));
+        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 roles endpoint is reachable.`,
+        });
         return 1;
       }
       if (liveOrg === a.organizationUuid) {
-        console.error(c.red(`${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({ 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.` });
         return 1;
       }
     }
@@ -46,7 +49,8 @@ export async function cmdRm(selector?: string): Promise<number> {
     rmSync(sampleDir, { recursive: true, force: true });
     idx.accounts = idx.accounts.filter((x) => x.accountUuid !== a.accountUuid);
     saveAccounts(idx);
-    console.log(`removed ${c.bold(a.label)} from the pool (${idx.accounts.length} left)`);
+    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)`);
     return 0;
   });
 }