tokenmaxxing 1.9.1 → 1.11.0

package/src/entries/mcp.ts

@@ -151,7 +151,7 @@ export function createTokenmaxxingMcpServer(): McpServer {
       inputSchema: {},
     },
     async () => {
-      const cap = await captureCli(() => cmdStatus(false));
+      const cap = await captureCli(() => cmdStatus());
       return textResult({ text: formatCapture(cap), isError: cap.code !== 0 });
     },
   );

package/src/lib/codexdecide.ts

@@ -13,7 +13,7 @@ import { fetchCodexUsage } from "./codexusage.ts";
 import { codexIdentityOf, isCodexAccessExpiring, readLiveCodexAuth, writeLiveCodexAuth, writeParkedCodexAuth } from "./codexauth.ts";
 import { liveCodexAccountId } from "./codexsample.ts";
 import { livingCodexPresences, presentCodexAccountIds, targetableCodexAccounts } from "./codexpresence.ts";
-import { effectiveBars } from "./picker.ts";
+import { terminalBars } from "./picker.ts";
 import { log } from "./log.ts";
 import { CodexAccountSchema, CodexReconcileMarkerSchema, type CodexAccount } from "./types.ts";
 
@@ -100,7 +100,7 @@ function postSwapResweep(input: { liveAccountId: string; bars: { session: number
 export async function evaluateAndMaybeSwapCodex(input: { now?: number }): Promise<CodexSwapDecision> {
   const now = input.now ?? Date.now();
   const cfg = loadConfig();
-  const bars = effectiveBars(cfg);
+  const bars = terminalBars(cfg);
 
   return withLock(codexPaths.lockFile, async () => {
     let index = loadCodexAccounts();

package/src/lib/decide.ts

@@ -5,11 +5,11 @@ import { paths } from "./paths.ts";
 import { MAX_CHECK_DELAY_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsage, loadModelUsage, saveAccounts, saveDepletedWait, saveModelUsage, usageTeeAt, writeUsage } from "./state.ts";
 import { readOAuthAccount } from "./claudejson.ts";
 import { chooseAndSwap, performSwap } from "./swap.ts";
-import { currentWins, effectiveBars, hardBars, isExhausted, nextWeeklyReset, pickBest, pickEarliestReset, usableAt } from "./picker.ts";
+import { currentWins, effectiveBars, hardBars, isExhausted, nextWeeklyReset, pickBest, pickEarliestReset, sessionLadder, usableAt } from "./picker.ts";
 import { InvalidGrantError } from "./oauth.ts";
 import { familyTokens, gatedFamilies, probeUsage, type EnforcedClass } from "./usage.ts";
 import { log } from "./log.ts";
-import { AccountSchema, ModelUsageStateSchema, UsageStateSchema, type Account, type Config, type EnforcedLimit, type ModelUsageState, type UsageState, type UsageWindow } from "./types.ts";
+import { AccountSchema, ModelUsageStateSchema, UsageStateSchema, type Account, type Config, type EnforcedLimit, type ModelUsageState, type Thresholds, type UsageState, type UsageWindow } from "./types.ts";
 
 const SwapDecisionSchema = z.object({
   swapped: z.boolean(),
@@ -36,9 +36,17 @@ function capForFamily(mu: ModelUsageState, family: string, now: number): UsageWi
   return maxBy(rows, (w) => liveUsed({ window: w, windowMs: WEEK_MS, sampledAt: mu.sampledAt ?? mu.ts, now }));
 }
 
-function isOver(u: UsageState | null, mu: ModelUsageState | null, org: string | null, cfg: Config, now: number): boolean {
+function overlayLive(accounts: Account[], u: UsageState | null, mu: ModelUsageState | null, org: string | null): Account[] {
+  return accounts.map((a) => {
+    if (org == null || a.organizationUuid !== org) return a;
+    const live = u && u.org === org ? { lastUsage: { fiveHour: u.fiveHour, sevenDay: u.sevenDay }, lastUsageAt: u.ts } : {};
+    const perModel = mu && mu.org === org && Object.keys(mu.perModel).length > 0 ? { lastPerModel: mu.perModel, lastPerModelAt: mu.sampledAt ?? mu.ts } : {};
+    return { ...a, ...live, ...perModel };
+  });
+}
+
+function isOver(u: UsageState | null, mu: ModelUsageState | null, org: string | null, bars: Thresholds, cfg: Config, now: number): boolean {
   if (!u || !org || u.org !== org) return false;
-  const bars = effectiveBars(cfg);
   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
@@ -56,9 +64,9 @@ function needsPerModel(u: UsageState | null, cfg: Config): boolean {
   return u != null && gatedFamilies(u.model, cfg.policy.switchModels).length > 0;
 }
 
-function isEngaged(u: UsageState | null, mu: ModelUsageState | null, org: string | null, cfg: Config, now: number): boolean {
+function isEngaged(u: UsageState | null, mu: ModelUsageState | null, org: string | null, bars: Thresholds, cfg: Config, now: number): boolean {
   if (!u || !org || u.org !== org) return false;
-  return liveUsed({ window: u.fiveHour, windowMs: FIVE_HOURS_MS, sampledAt: u.ts, now }) >= cfg.policy.greedySessionFloor || isOver(u, mu, org, cfg, now);
+  return liveUsed({ window: u.fiveHour, windowMs: FIVE_HOURS_MS, sampledAt: u.ts, now }) >= cfg.policy.greedySessionFloor || isOver(u, mu, org, bars, cfg, now);
 }
 
 const SnapshotsSchema = z.object({
@@ -120,8 +128,13 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
   const cfg = loadConfig();
 
   const { u: usage, mu } = await loadFreshSnapshots(cfg, activeOrg, now);
+  const bars0 = effectiveBars(cfg, {
+    accounts: overlayLive(loadAccounts().accounts, usage, mu, activeOrg),
+    now,
+    switchFamilies: gatedFamilies(usage?.model ?? null, cfg.policy.switchModels),
+  });
 
-  if (!enforced0 && !isEngaged(usage, mu, activeOrg, cfg, now)) {
+  if (!enforced0 && !isEngaged(usage, mu, activeOrg, bars0, cfg, now)) {
     const measured = usage != null && activeOrg != null && usage.org === activeOrg;
     if (!measured) {
       const replay = depletedReplay(now);
@@ -157,7 +170,12 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
       if (sampled) saveAccounts(idx);
     }
 
-    if (!enforced2 && !isEngaged(u2, mu2, org2, cfg, now)) {
+    const gated = gatedFamilies(u2?.model ?? null, cfg.policy.switchModels);
+    const switchFamilies = enforced2?.family && !gated.includes(enforced2.family) ? [...gated, enforced2.family] : gated;
+    const barsOf = (accounts: Account[]): Thresholds => effectiveBars(cfg, { accounts, now, switchFamilies });
+    const bars = barsOf(idx.accounts);
+
+    if (!enforced2 && !isEngaged(u2, mu2, org2, bars, cfg, now)) {
       return depletedReplay(now) ?? { swapped: false, account: null, reason: "raced-already-swapped" };
     }
 
@@ -166,14 +184,11 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
       idx2.accounts.find((a) => a.accountUuid === idx2.activeAccountUuid) ??
       null;
 
-    const gated = gatedFamilies(u2?.model ?? null, cfg.policy.switchModels);
-    const switchFamilies = enforced2?.family && !gated.includes(enforced2.family) ? [...gated, enforced2.family] : gated;
-
-    if (!enforced2 && !isOver(u2, mu2, org2, cfg, now)) {
-      const ctxAll = { now, thresholds: effectiveBars(cfg), currentAccountUuid: null, switchFamilies };
+    const greedy = async (): Promise<SwapDecision> => {
       while (true) {
         const cur = loadAccounts();
         const active = seatOf(cur);
+        const ctxAll = { now, thresholds: barsOf(cur.accounts), currentAccountUuid: null, switchFamilies };
         if (currentWins(active, cur.accounts, ctxAll)) {
           return { swapped: false, account: null, reason: "current-best" };
         }
@@ -188,10 +203,24 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
         log("decide.greedy_swap", { account: best.accountUuid.slice(0, 8) });
         return { swapped: true, account: best, reason: "swapped" };
       }
-    }
+    };
+    if (!enforced2 && !isOver(u2, mu2, org2, bars, cfg, now)) return greedy();
 
-    const landed = await chooseAndSwap({ now, thresholds: effectiveBars(cfg), switchFamilies, currentAccountUuid: seatOf(loadAccounts())?.accountUuid ?? null });
-    if (landed) return { swapped: true, account: landed, reason: "swapped" };
+    while (true) {
+      const cur = loadAccounts();
+      const seat = seatOf(cur);
+      const thresholds = barsOf(cur.accounts);
+      if (!enforced2 && seat && !seat.needsReauth && !isExhausted(seat, { now, thresholds, currentAccountUuid: null, switchFamilies })) return greedy();
+      const best = pickBest(cur.accounts, { now, thresholds, currentAccountUuid: seat?.accountUuid ?? null, switchFamilies });
+      if (!best) break;
+      try {
+        await performSwap(best);
+      } catch (e) {
+        if (e instanceof InvalidGrantError) continue;
+        throw e;
+      }
+      return { swapped: true, account: best, reason: "swapped" };
+    }
 
     const hardCtx = { now, thresholds: hardBars(cfg), currentAccountUuid: null, switchFamilies };
     const seat = seatOf(loadAccounts());
@@ -315,6 +344,7 @@ export async function recordEnforcedLimit(input: { limit: EnforcedClass; org: st
 
 export const CHECK_DELAY_FLOOR_MS = 60_000;
 const CHECK_DELAY_UNKNOWN_MS = 180_000;
+const STAGE_CEILING_MS = [MAX_CHECK_DELAY_MS, 180_000, 120_000];
 
 export function checkDelayMs(input: { cfg: Config; org: string | null; now: number; decision: SwapDecision }): number {
   const { cfg, org, now, decision } = input;
@@ -323,21 +353,24 @@ export function checkDelayMs(input: { cfg: Config; org: string | null; now: numb
   if (swapAt != null && now - swapAt < POST_SWAP_COOLDOWN_MS) return swapAt + POST_SWAP_COOLDOWN_MS - now;
   const u = loadUsage();
   if (!org || !u || !usageFresh(u, org, cfg.policy.usagePollTtlMs, now)) return CHECK_DELAY_UNKNOWN_MS;
-  const bars = effectiveBars(cfg);
+  const mu = loadModelUsage();
+  const muSame = mu && mu.org === org ? mu : null;
+  const families = gatedFamilies(u.model, cfg.policy.switchModels);
+  const bars = effectiveBars(cfg, { accounts: overlayLive(loadAccounts().accounts, u, muSame, org), now, switchFamilies: families });
   const heads = [
     bars.session - liveUsed({ window: u.fiveHour, windowMs: FIVE_HOURS_MS, sampledAt: u.ts, now }),
     bars.weekly - liveUsed({ window: u.sevenDay, windowMs: WEEK_MS, sampledAt: u.ts, now }),
   ];
-  const mu = loadModelUsage();
-  const muSame = mu && mu.org === org ? mu : null;
   let capMissing = false;
   const capFresh = muSame != null && now - (muSame.sampledAt ?? muSame.ts) <= cfg.policy.usagePollTtlMs;
-  for (const family of gatedFamilies(u.model, cfg.policy.switchModels)) {
+  for (const family of families) {
     const cap = muSame && capFresh ? capForFamily(muSame, family, now) : undefined;
     if (cap && muSame) heads.push(bars.weekly - liveUsed({ window: cap, windowMs: WEEK_MS, sampledAt: muSame.sampledAt ?? muSame.ts, now }));
     else capMissing = true;
   }
   const headroom = Math.min(...heads);
   const banded = headroom >= 40 ? MAX_CHECK_DELAY_MS : headroom >= 20 ? 180_000 : headroom >= 8 ? 120_000 : CHECK_DELAY_FLOOR_MS;
-  return capMissing ? Math.min(banded, 120_000) : banded;
+  const stage = sessionLadder(cfg).indexOf(bars.session);
+  const staged = Math.min(banded, STAGE_CEILING_MS[stage] ?? CHECK_DELAY_FLOOR_MS);
+  return capMissing ? Math.min(staged, 120_000) : staged;
 }

package/src/lib/picker.ts

@@ -3,13 +3,26 @@ import { z } from "zod";
 import { familyTokens } from "./usage.ts";
 import { AccountSchema, ThresholdsSchema, type Account, type Config, type Thresholds, type UsageWindow } from "./types.ts";
 
-export function effectiveBars(cfg: Config): Thresholds {
+export function sessionLadder(cfg: Config): number[] {
+  return cfg.thresholds.session.map((rung) => rung - cfg.policy.projectionMargin);
+}
+
+export function terminalBars(cfg: Config): Thresholds {
   return {
-    session: cfg.thresholds.session - cfg.policy.projectionMargin,
+    session: Math.max(...sessionLadder(cfg)),
     weekly: cfg.thresholds.weekly - cfg.policy.projectionMargin,
   };
 }
 
+export function effectiveBars(cfg: Config, pool: { accounts: Account[]; now: number; switchFamilies: string[] }): Thresholds {
+  const top = terminalBars(cfg);
+  const holdsAt = (session: number) =>
+    pool.accounts.some(
+      (a) => !a.needsReauth && !isExhausted(a, { now: pool.now, thresholds: { session, weekly: top.weekly }, currentAccountUuid: null, switchFamilies: pool.switchFamilies }),
+    );
+  return { session: sessionLadder(cfg).find(holdsAt) ?? top.session, weekly: top.weekly };
+}
+
 export function hardBars(cfg: Config): Thresholds {
   return {
     session: cfg.hardThresholds.session - cfg.policy.projectionMargin,

package/src/lib/state.ts

@@ -9,6 +9,7 @@ import {
   LastSwapSchema,
   ModelUsageStateSchema,
   NextCheckSchema,
+  SessionLadderSchema,
   UsageStateSchema,
   type AccountsIndex,
   type Config,
@@ -17,7 +18,7 @@ import {
 } from "./types.ts";
 
 const DEFAULT_CONFIG: Config = {
-  thresholds: { session: 95, weekly: 98 },
+  thresholds: { session: [50, 80, 95], weekly: 98 },
   hardThresholds: { session: 100, weekly: 100 },
   claudeBin: "",
   codexBin: "",
@@ -28,7 +29,7 @@ const PercentSchema = z.number().min(0).max(100);
 
 export const ConfigFileSchema = z
   .object({
-    thresholds: z.object({ session: PercentSchema, weekly: PercentSchema }).partial(),
+    thresholds: z.object({ session: SessionLadderSchema, weekly: PercentSchema }).partial(),
     hardThresholds: z.object({ session: PercentSchema, weekly: PercentSchema }).partial(),
     claudeBin: z.string(),
     codexBin: z.string(),

package/src/lib/types.ts

@@ -1,3 +1,4 @@
+import { isEqual, uniq } from "es-toolkit";
 import { z } from "zod";
 
 const OAuthCredsSchema = z.looseObject({
@@ -99,9 +100,21 @@ export const ThresholdsSchema = z.object({
 });
 export type Thresholds = z.infer<typeof ThresholdsSchema>;
 
+export const SessionLadderSchema = z
+  .array(z.number().min(0).max(100))
+  .min(1)
+  .refine((rungs) => isEqual(rungs, uniq(rungs).toSorted((a, b) => a - b)), {
+    message: "thresholds.session rungs must be strictly ascending",
+  });
+
+export const ScreeningThresholdsSchema = z.object({
+  session: SessionLadderSchema,
+  weekly: z.number().min(0).max(100),
+});
+
 export const ConfigSchema = z
   .object({
-    thresholds: ThresholdsSchema,
+    thresholds: ScreeningThresholdsSchema,
     hardThresholds: ThresholdsSchema,
     claudeBin: z.string(),
     codexBin: z.string(),
@@ -113,11 +126,11 @@ export const ConfigSchema = z
       maxWaitMs: z.number().int().positive(),
     }),
   })
-  .refine((cfg) => cfg.policy.projectionMargin < Math.min(cfg.thresholds.session, cfg.thresholds.weekly), {
-    message: "policy.projectionMargin must be strictly below both thresholds (effectiveBars would hit zero and every account would read as exhausted)",
+  .refine((cfg) => cfg.policy.projectionMargin < Math.min(...cfg.thresholds.session, cfg.thresholds.weekly), {
+    message: "policy.projectionMargin must be strictly below every threshold (effectiveBars would hit zero and every account would read as exhausted)",
   })
-  .refine((cfg) => cfg.hardThresholds.session >= cfg.thresholds.session && cfg.hardThresholds.weekly >= cfg.thresholds.weekly, {
-    message: "hardThresholds (the Layer 2 wall) must be at or above thresholds (the Layer 1 screening bars) for both windows",
+  .refine((cfg) => cfg.hardThresholds.session >= Math.max(...cfg.thresholds.session) && cfg.hardThresholds.weekly >= cfg.thresholds.weekly, {
+    message: "hardThresholds (the Layer 2 wall) must be at or above thresholds (the Layer 1 screening bars, the top session rung) for both windows",
   });
 export type Config = z.infer<typeof ConfigSchema>;
 

package/src/main.ts

@@ -26,7 +26,10 @@ import { cmdSwitch } from "./cli/switch.ts";
 import { cmdCheck } from "./cli/check.ts";
 import { cmdConfig } from "./cli/config.ts";
 import { timerDeactivationHint, uninstallSupervisor } from "./lib/install.ts";
-import { c } from "./cli/render.ts";
+import { c, emitError, emitJson } from "./cli/render.ts";
+
+const JSON_FLAG = "--json";
+const INTERACTIVE_COMMANDS = new Set(["init", "add", "auth"]);
 
 function printHelp(): void {
   console.log(`${c.bold("tokenmaxxing")} - automatic Claude Code account switching
@@ -50,30 +53,45 @@ function printHelp(): void {
   ${c.cyan("tokenmaxxing rm")} [--codex] <sel>
   ${c.cyan("tokenmaxxing uninstall")}  remove supervisor + settings entries
 
+  ${c.cyan("--json")}                  print one JSON document on stdout instead of text (status, ls, config, doctor, check, switch, rename, rm, uninstall; one per tick for watch); 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.`);
 }
 
+let jsonMode = false;
+
 async function main(): Promise<number> {
   if (process.platform !== "darwin" && process.platform !== "linux") {
     console.error(`tokenmaxxing supports macOS and Linux only (this is ${process.platform})`);
     return 1;
   }
-  const args = process.argv.slice(2);
+  const argv = process.argv.slice(2);
   const argv0 = basename(process.argv0 || process.argv[0] || "");
-  const sub = args[0];
 
-  if (argv0 === "claude" || sub === "__supervise") {
-    return runSupervisor(sub === "__supervise" ? args.slice(1) : args);
+  if (argv0 === "claude" || argv[0] === "__supervise") {
+    return runSupervisor(argv[0] === "__supervise" ? argv.slice(1) : argv);
   }
-  if (argv0 === "codex" || sub === "__supervise-codex") {
-    return runCodexSupervisor({ argv: sub === "__supervise-codex" ? args.slice(1) : args });
+  if (argv0 === "codex" || argv[0] === "__supervise-codex") {
+    return runCodexSupervisor({ argv: argv[0] === "__supervise-codex" ? argv.slice(1) : argv });
   }
 
+  jsonMode = argv.includes(JSON_FLAG);
+  const json = jsonMode;
+  const args = argv.filter((a) => a !== JSON_FLAG);
+  const sub = args[0];
+
+  if (json && sub != null && INTERACTIVE_COMMANDS.has(sub)) {
+    emitError({ json, message: `${sub} is interactive (it runs a login flow) and has no --json form` });
+    return 2;
+  }
   if (!(sub != null && sub.startsWith("__")) && !process.env.TOKENMAXXING_PROBE) {
     const nonEmpty = (v: string | undefined) => (v != null && v !== "" ? v : null);
     const ambient = nonEmpty(process.env.CLAUDE_SECURESTORAGE_CONFIG_DIR) ?? nonEmpty(process.env.CLAUDE_CONFIG_DIR);
     if (ambient != null) {
-      console.error(c.red(`CLAUDE_CONFIG_DIR / CLAUDE_SECURESTORAGE_CONFIG_DIR is set (${ambient}): claude uses a namespaced credential store there that tokenmaxxing does not manage - unset it (or run from a clean shell) and retry.`));
+      emitError({
+        json,
+        message: `CLAUDE_CONFIG_DIR / CLAUDE_SECURESTORAGE_CONFIG_DIR is set (${ambient}): claude uses a namespaced credential store there that tokenmaxxing does not manage - unset it (or run from a clean shell) and retry.`,
+      });
       return 1;
     }
   }
@@ -85,26 +103,26 @@ async function main(): Promise<number> {
     case "__stop-failure-hook": return runStopFailureHook();
     case "__session-start": return runSessionStart();
     case "__codex-stop-hook": return runCodexStopHook();
-    case undefined: return cmdStatus();
-    case "--force": return cmdStatus(true);
+    case undefined: return cmdStatus({ json });
+    case "--force": return cmdStatus({ force: true, json });
     case "switch": {
       const rest = args.slice(1).filter((a) => a !== "--codex");
-      return args.includes("--codex") ? cmdCodexSwitch(rest[0]) : cmdSwitch(rest[0]);
+      return args.includes("--codex") ? cmdCodexSwitch(rest[0], json) : cmdSwitch(rest[0], json);
     }
-    case "check": return cmdCheck(args.slice(1));
-    case "config": return cmdConfig(args.slice(1));
+    case "check": return cmdCheck(args.slice(1), json);
+    case "config": return cmdConfig(args.slice(1), json);
     case "init": return args.includes("--codex") ? cmdCodexInit() : cmdInit();
     case "add": return args.includes("--codex") ? cmdCodexAdd() : cmdAdd();
     case "auth": return cmdAuth(args.slice(1));
-    case "ls": return cmdLs();
-    case "status": return cmdStatus(args.includes("--force"));
-    case "watch": return cmdWatch(args[1]);
-    case "doctor": return cmdDoctor();
+    case "ls": return cmdLs(json);
+    case "status": return cmdStatus({ force: args.includes("--force"), json });
+    case "watch": return cmdWatch(args[1], json);
+    case "doctor": return cmdDoctor(json);
     case "rm": {
       const rest = args.slice(1).filter((a) => a !== "--codex");
-      return args.includes("--codex") ? cmdCodexRm(rest[0]) : cmdRm(rest[0]);
+      return args.includes("--codex") ? cmdCodexRm(rest[0], json) : cmdRm(rest[0], json);
     }
-    case "rename": return cmdRename(args.slice(1));
+    case "rename": return cmdRename(args.slice(1), json);
     case "uninstall": {
       const out = uninstallSupervisor();
       const removed = [
@@ -113,6 +131,10 @@ 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)"));
@@ -125,8 +147,8 @@ async function main(): Promise<number> {
       printHelp();
       return 0;
     default:
-      console.error(c.red(`unknown command: ${sub}`));
-      printHelp();
+      emitError({ json, message: `unknown command: ${sub}` });
+      if (!json) printHelp();
       return 2;
   }
 }
@@ -134,6 +156,6 @@ async function main(): Promise<number> {
 try {
   process.exit(await main());
 } catch (e) {
-  console.error(c.red(e instanceof Error ? e.message : String(e)));
+  emitError({ json: jsonMode, message: e instanceof Error ? e.message : String(e) });
   process.exit(1);
 }