tokenmaxxing 1.13.0 → 1.13.1

package/agent-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "tokenmaxxing",
-  "version": "1.13.0",
+  "version": "1.13.1",
   "description": "Pool Claude Code and Codex logins, switch on pace pressure, and expose safe ops tools to agent clients.",
   "author": {
     "name": "anaclumos",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmaxxing",
-  "version": "1.13.0",
+  "version": "1.13.1",
   "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/status.ts

@@ -1,6 +1,6 @@
 import { sortBy } from "es-toolkit";
 import { z } from "zod";
-import { loadAccounts, loadConfig, loadUsage, loadModelUsage, saveAccounts } from "../lib/state.ts";
+import { loadAccounts, loadConfig, loadUsage, loadUsageSnapshot, loadModelUsage, saveAccounts } from "../lib/state.ts";
 import { readOAuthAccount } from "../lib/claudejson.ts";
 import { ensureLiveTokenFresh, probeActiveUsage, probeParkedUsage, type SampleOutcome } from "../lib/sample.ts";
 import { withLock } from "../lib/lock.ts";
@@ -33,6 +33,7 @@ const ClaudeStatusAccountSchema = z.object({
   usageAt: z.number().nullable(),
   sample: SampleReportSchema,
   pingError: z.string().nullable(),
+  pingRejected: z.boolean(),
   pinged: z.boolean(),
 });
 type ClaudeStatusAccount = z.infer<typeof ClaudeStatusAccountSchema>;
@@ -93,15 +94,18 @@ async function collectClaude(input: { cfg: Config; force: boolean; now: number }
     console.error(c.dim(force ? "pinging every account (starts each 5h session timer) + sampling live usage..." : "sampling live usage..."));
     await withLock(paths.lockFile, async () => {
       idx = loadAccounts();
-      const live = loadUsage();
+      const tee = loadUsageSnapshot();
+      const live = tee?.state ?? null;
+      const teeAt = tee?.at ?? null;
       const modelUsage = loadModelUsage();
       const liveOAuth = readOAuthAccount();
       const activeOrg = liveOAuth?.organizationUuid ?? null;
       const probeOne = async (a: Account) => {
         const isActive = activeOrg != null && activeOrg === a.organizationUuid;
         if (isActive && liveOAuth?.organizationRateLimitTier != null) a.rateLimitTier = liveOAuth.organizationRateLimitTier;
+        const teeCurrent = teeAt != null && (a.lastUsageAt == null || teeAt >= a.lastUsageAt);
         const fromStatusLine: FullUsage | null =
-          isActive && live && live.org === a.organizationUuid
+          isActive && live && teeCurrent && live.org === a.organizationUuid
             ? {
                 session: live.fiveHour,
                 weekAll: live.sevenDay,
@@ -115,7 +119,10 @@ async function collectClaude(input: { cfg: Config; force: boolean; now: number }
           if (!outcome.ok && fromStatusLine && outcome.reason.includes("no limit data")) {
             const failed = outcome;
             outcome = { ok: true, usage: fromStatusLine };
-            if (failed.pingError != null) outcome.pingError = failed.pingError;
+            if (failed.pingError != null) {
+              outcome.pingError = failed.pingError;
+              outcome.pingRejected = failed.pingRejected;
+            }
             viaTee = true;
           }
         } else {
@@ -129,7 +136,7 @@ async function collectClaude(input: { cfg: Config; force: boolean; now: number }
         samples.set(a.accountUuid, { outcome, viaTee });
         if (!outcome.ok) return;
         a.lastUsage = { fiveHour: outcome.usage.session, sevenDay: outcome.usage.weekAll };
-        a.lastUsageAt = viaTee && live ? live.ts : Date.now();
+        a.lastUsageAt = viaTee && teeAt != null ? teeAt : Date.now();
         if (Object.keys(outcome.usage.perModel).length > 0) {
           a.lastPerModel = outcome.usage.perModel;
           a.lastPerModelAt = viaTee && modelUsage ? (modelUsage.sampledAt ?? modelUsage.ts) : a.lastUsageAt;
@@ -169,6 +176,7 @@ async function collectClaude(input: { cfg: Config; force: boolean; now: number }
       usageAt: a.lastUsageAt ?? null,
       sample: sampled.outcome.ok ? { ok: true, source: sampled.viaTee ? "statusline" : "probe" } : { ok: false, reason: sampled.outcome.reason },
       pingError: sampled.outcome.pingError ?? null,
+      pingRejected: sampled.outcome.pingRejected === true,
       pinged: force && sampled.outcome.ok && sampled.outcome.pingError == null && aggregate != null && aggregate.fiveHour.resetsAt == null,
     };
   });
@@ -277,8 +285,14 @@ function rowPrinter(now: number): (name: string, w: UsageWindow) => void {
   };
 }
 
-function renderClaude(input: { claude: StatusReport["claude"]; codexPooled: boolean; now: number; row: (name: string, w: UsageWindow) => void }): void {
-  const { claude, codexPooled, now, row } = input;
+function renderClaude(input: {
+  claude: StatusReport["claude"];
+  codexPooled: boolean;
+  now: number;
+  staleAfterMs: number;
+  row: (name: string, w: UsageWindow) => void;
+}): void {
+  const { claude, codexPooled, now, staleAfterMs, row } = input;
   if (claude.accounts.length === 0) {
     if (!codexPooled) {
       console.log(c.dim("no accounts yet, run `tokenmaxxing init` (or `tokenmaxxing init --codex`)"));
@@ -303,11 +317,21 @@ function renderClaude(input: { claude: StatusReport["claude"]; codexPooled: bool
       row("week", a.usage.week);
     }
     for (const [name, w] of Object.entries(a.perModel)) row(name.toLowerCase(), w);
+    if (a.sample.ok && a.sample.source === "statusline") {
+      const stale = a.usageAt == null || now - a.usageAt > staleAfterMs;
+      const age = a.usageAt != null ? fmtAgo(a.usageAt, now) : "age unknown";
+      console.log(`    ${(stale ? c.yellow : c.dim)(`statusline tee ${age}${stale ? " (stale)" : ""}`)}`);
+    }
     if (!a.sample.ok) {
       const cached = a.usage || Object.keys(a.perModel).length > 0 ? `cached${a.usageAt != null ? ` ${fmtAgo(a.usageAt, now)}` : ""}, ` : "";
       console.log(`    ${c.yellow(`${cached}live sample failed`)}: ${c.dim(a.sample.reason)}`);
     }
-    if (a.pingError != null) {
+    if (a.pingError != null && a.pingRejected) {
+      const at = a.pingError.indexOf(": ");
+      const head = at >= 0 ? a.pingError.slice(0, at) : a.pingError;
+      const tail = at >= 0 ? a.pingError.slice(at + 2) : "";
+      console.log(`    ${c.yellow(`ping ${head}`)}${tail ? `: ${c.dim(tail)}` : ""}`);
+    } else if (a.pingError != null) {
       console.log(`    ${c.yellow("ping failed (5h timer may not have started)")}: ${c.dim(a.pingError)}`);
     }
     if (a.pinged) {
@@ -321,11 +345,11 @@ export async function cmdStatus(opts: { force?: boolean; json?: boolean; preRend
   const { force = false, json = false } = opts;
   const cfg = loadConfig();
   const now = Date.now();
-  const row = rowPrinter(now);
   const claude = await collectClaude({ cfg, force, now });
   if (!json) {
     opts.preRender?.();
-    renderClaude({ claude, codexPooled: loadCodexAccounts().accounts.length > 0, now, row });
+    const at = Date.now();
+    renderClaude({ claude, codexPooled: loadCodexAccounts().accounts.length > 0, now: at, staleAfterMs: cfg.policy.usagePollTtlMs, row: rowPrinter(at) });
   }
   const codex = await collectCodex({ cfg, now });
   if (json) {
@@ -333,6 +357,7 @@ export async function cmdStatus(opts: { force?: boolean; json?: boolean; preRend
     emitJson({ ok: true, ...report });
     return 0;
   }
-  renderCodex({ codex, now, row });
+  const at = Date.now();
+  renderCodex({ codex, now: at, row: rowPrinter(at) });
   return 0;
 }

package/src/lib/decide.ts

@@ -2,7 +2,7 @@ import { maxBy } from "es-toolkit";
 import { z } from "zod";
 import { withLock } from "./lock.ts";
 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 { MAX_CHECK_DELAY_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, loadUsage, loadUsageSnapshot, loadModelUsage, saveAccounts, saveDepletedWait, saveModelUsage, writeUsage } from "./state.ts";
 import { readOAuthAccount } from "./claudejson.ts";
 import { chooseAndSwap, performSwap } from "./swap.ts";
 import { currentWins, effectiveBars, hardBars, isExhausted, nextWeeklyReset, pickBest, pickEarliestReset, sessionLadder, usableAt } from "./picker.ts";
@@ -72,31 +72,43 @@ function isEngaged(u: UsageState | null, mu: ModelUsageState | null, org: string
 const SnapshotsSchema = z.object({
   u: UsageStateSchema.nullable(),
   mu: ModelUsageStateSchema.nullable(),
+  uAt: z.number().nullable(),
 });
 type Snapshots = z.infer<typeof SnapshotsSchema>;
 
-function usageFresh(u: UsageState | null, org: string | null, ttl: number, now: number): boolean {
-  if (u == null || u.org !== org) return false;
-  const teeAt = usageTeeAt();
-  return teeAt != null && now - teeAt <= ttl;
+function usageFresh(u: UsageState | null, uAt: number | null, org: string | null, ttl: number, now: number): boolean {
+  return u != null && u.org === org && uAt != null && now - uAt <= ttl;
+}
+
+function freshest(u: UsageState | null, uAt: number | null, account: Account | undefined): UsageState | null {
+  if (!u || uAt == null) return u;
+  const stored = account?.lastUsage;
+  if (stored && account.lastUsageAt != null && u.org === account.organizationUuid && uAt < account.lastUsageAt) {
+    return { ...u, fiveHour: stored.fiveHour, sevenDay: stored.sevenDay, ts: account.lastUsageAt };
+  }
+  return { ...u, ts: uAt };
 }
 
 async function loadFreshSnapshots(cfg: Config, org: string | null, now: number): Promise<Snapshots> {
-  let u = loadUsage();
+  const snap = loadUsageSnapshot();
+  let u = snap?.state ?? null;
+  let uAt = snap?.at ?? null;
   let mu = loadModelUsage();
   const ttl = cfg.policy.usagePollTtlMs;
   const probeAttempted = mu != null && mu.org === org && now - mu.ts <= ttl;
-  if (org && !probeAttempted && (!usageFresh(u, org, ttl, now) || needsPerModel(u, cfg))) {
+  if (org && !probeAttempted && (!usageFresh(u, uAt, org, ttl, now) || needsPerModel(u, cfg))) {
     const full = await probeUsage();
     const ts = Date.now();
     if (readOAuthAccount()?.organizationUuid === org) {
       if (full) {
-        const teed = loadUsage();
-        if (usageFresh(teed, org, ttl, ts)) {
-          u = teed;
+        const teed = loadUsageSnapshot();
+        if (teed && usageFresh(teed.state, teed.at, org, ttl, ts)) {
+          u = teed.state;
+          uAt = teed.at;
         } else {
           u = { fiveHour: full.session, sevenDay: full.weekAll, org, ts, model: null };
           writeUsage(u);
+          uAt = ts;
         }
         mu = { perModel: full.perModel, org, ts, sampledAt: ts };
         saveModelUsage(mu);
@@ -111,7 +123,7 @@ async function loadFreshSnapshots(cfg: Config, org: string | null, now: number):
       }
     }
   }
-  return { u, mu };
+  return { u, mu, uAt };
 }
 
 export const POST_SWAP_COOLDOWN_MS = 45_000;
@@ -127,9 +139,11 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
 
   const cfg = loadConfig();
 
-  const { u: usage, mu } = await loadFreshSnapshots(cfg, activeOrg, now);
+  const { u: teeUsage, mu, uAt } = await loadFreshSnapshots(cfg, activeOrg, now);
+  const pool = loadAccounts();
+  const usage = freshest(teeUsage, uAt, pool.accounts.find((a) => a.organizationUuid === activeOrg));
   const bars0 = effectiveBars(cfg, {
-    accounts: overlayLive(loadAccounts().accounts, usage, mu, activeOrg),
+    accounts: overlayLive(pool.accounts, usage, mu, activeOrg),
     now,
     switchFamilies: gatedFamilies(usage?.model ?? null, cfg.policy.switchModels),
   });
@@ -147,19 +161,20 @@ export async function evaluateAndMaybeSwap(now = Date.now(), anticipatory = fals
     const idx = loadAccounts();
     const org2 = readOAuthAccount()?.organizationUuid ?? null;
     const enforced2 = enforced0 && enforced0.org === org2 ? enforced0 : null;
-    const u2 = loadUsage() ?? usage;
+    const tee = loadUsageSnapshot();
+    const active = org2 ? idx.accounts.find((a) => a.organizationUuid === org2) : undefined;
+    const u2 = tee ? freshest(tee.state, tee.at, active) : usage;
     const mu2 = needsPerModel(u2, cfg) || enforced2?.family ? loadModelUsage() ?? mu : null;
 
-    if (org2 != null && !idx.accounts.some((a) => a.organizationUuid === org2)) {
+    if (org2 != null && !active) {
       return { swapped: false, account: null, reason: "live-credential-not-in-pool" };
     }
 
-    const active = org2 ? idx.accounts.find((a) => a.organizationUuid === org2) : undefined;
     if (active) {
       let sampled = false;
-      if (u2 && u2.org === org2) {
-        active.lastUsage = { fiveHour: u2.fiveHour, sevenDay: u2.sevenDay };
-        active.lastUsageAt = u2.ts;
+      if (tee && tee.state.org === org2 && (active.lastUsageAt == null || tee.at >= active.lastUsageAt)) {
+        active.lastUsage = { fiveHour: tee.state.fiveHour, sevenDay: tee.state.sevenDay };
+        active.lastUsageAt = tee.at;
         sampled = true;
       }
       if (mu2 && mu2.org === org2 && Object.keys(mu2.perModel).length > 0) {
@@ -351,12 +366,14 @@ export function checkDelayMs(input: { cfg: Config; org: string | null; now: numb
   if (decision.waitUntil !== undefined) return Math.min(MAX_CHECK_DELAY_MS, Math.max(CHECK_DELAY_FLOOR_MS, decision.waitUntil - now));
   const swapAt = loadLastSwapAt();
   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 snap = loadUsageSnapshot();
+  if (!org || !snap || !usageFresh(snap.state, snap.at, org, cfg.policy.usagePollTtlMs, now)) return CHECK_DELAY_UNKNOWN_MS;
+  const accounts = loadAccounts().accounts;
+  const u = freshest(snap.state, snap.at, accounts.find((a) => a.organizationUuid === org)) ?? { ...snap.state, ts: snap.at };
   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 bars = effectiveBars(cfg, { accounts: overlayLive(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 }),

package/src/lib/sample.ts

@@ -9,8 +9,8 @@ import { FullUsageSchema, pingSession, probeUsage } from "./usage.ts";
 import { CredentialBlobSchema, type Account, type OAuthCreds, type RolesResponse } from "./types.ts";
 
 const SampleOutcomeSchema = z.discriminatedUnion("ok", [
-  z.object({ ok: z.literal(true), usage: FullUsageSchema, pingError: z.string().optional() }),
-  z.object({ ok: z.literal(false), reason: z.string(), pingError: z.string().optional() }),
+  z.object({ ok: z.literal(true), usage: FullUsageSchema, pingError: z.string().optional(), pingRejected: z.boolean().optional() }),
+  z.object({ ok: z.literal(false), reason: z.string(), pingError: z.string().optional(), pingRejected: z.boolean().optional() }),
 ]);
 export type SampleOutcome = z.infer<typeof SampleOutcomeSchema>;
 
@@ -95,12 +95,15 @@ export async function probeParkedUsage(account: Account, opts: { ping?: boolean
   try {
     await writeItem(isoTarget, installed);
     writeFileSync(join(dir, ".claude.json"), JSON.stringify({ oauthAccount: account.oauthAccount, hasCompletedOnboarding: true }));
-    const pingError = opts.ping ? await pingSession(dir) : null;
+    const ping = opts.ping ? await pingSession(dir) : null;
     const usage = await probeUsage(dir);
     const outcome: SampleOutcome = usage
       ? { ok: true, usage }
       : { ok: false, reason: "`/usage` returned no limit data (see log)" };
-    if (pingError != null) outcome.pingError = pingError;
+    if (ping != null) {
+      outcome.pingError = ping.reason;
+      outcome.pingRejected = ping.rejected;
+    }
     return outcome;
   } finally {
     const afterIso = await readItem(isoTarget);
@@ -152,9 +155,12 @@ export async function probeActiveUsage(account: Account, opts: { ping?: boolean
   if (identity.status === "unavailable") return { ok: false, reason: identity.reason };
   refreshPlanFields(account, creds);
 
-  const pingError = opts.ping ? await pingSession() : null;
+  const ping = opts.ping ? await pingSession() : null;
   const usage = await probeUsage();
   const outcome: SampleOutcome = usage ? { ok: true, usage } : { ok: false, reason: "`/usage` returned no limit data (see log)" };
-  if (pingError != null) outcome.pingError = pingError;
+  if (ping != null) {
+    outcome.pingError = ping.reason;
+    outcome.pingRejected = ping.rejected;
+  }
   return outcome;
 }

package/src/lib/state.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, rmSync, statSync, utimesSync } from "node:fs";
+import { closeSync, existsSync, fstatSync, openSync, readFileSync, rmSync, utimesSync } from "node:fs";
 import { isEqual } from "es-toolkit";
 import { z } from "zod";
 import { paths, realClaudeBinFromEnv, realCodexBinFromEnv } from "./paths.ts";
@@ -135,16 +135,28 @@ export function saveAccounts(idx: AccountsIndex): void {
   writeFileAtomic(paths.accountsJson, JSON.stringify(AccountsIndexSchema.parse(idx), null, 2) + "\n");
 }
 
-export function loadUsage(): UsageState | null {
-  if (!existsSync(paths.usageJson)) return null;
+export function loadUsageSnapshot(): { state: UsageState; at: number } | null {
+  let fd: number;
   try {
-    const parsed = UsageStateSchema.safeParse(JSON.parse(readFileSync(paths.usageJson, "utf8")));
-    return parsed.success ? parsed.data : null;
+    fd = openSync(paths.usageJson, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const at = fstatSync(fd).mtimeMs;
+    const parsed = UsageStateSchema.safeParse(JSON.parse(readFileSync(fd, "utf8")));
+    return parsed.success ? { state: parsed.data, at } : null;
   } catch {
     return null;
+  } finally {
+    closeSync(fd);
   }
 }
 
+export function loadUsage(): UsageState | null {
+  return loadUsageSnapshot()?.state ?? null;
+}
+
 export function clearUsageSnapshots(): void {
   rmSync(paths.usageJson, { force: true });
   rmSync(paths.modelUsageJson, { force: true });
@@ -226,14 +238,6 @@ export function writeUsage(next: UsageState): boolean {
   return true;
 }
 
-export function usageTeeAt(): number | null {
-  try {
-    return statSync(paths.usageJson).mtimeMs;
-  } catch {
-    return null;
-  }
-}
-
 export function loadModelUsage(): ModelUsageState | null {
   if (!existsSync(paths.modelUsageJson)) return null;
   try {

package/src/lib/usage.ts

@@ -1,4 +1,4 @@
-import { closeSync, fstatSync, mkdirSync, openSync, readSync } from "node:fs";
+import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readSync } from "node:fs";
 import { join } from "node:path";
 import { delay } from "es-toolkit";
 import { z } from "zod";
@@ -366,13 +366,36 @@ const PING_ARGS = [
   "--output-format", "json",
 ];
 
-const PingResultSchema = z.looseObject({ is_error: z.boolean(), result: z.string().optional() });
+const PingResultSchema = z.looseObject({ is_error: z.boolean().optional(), result: z.string().optional(), session_id: z.string().optional() });
 
-export async function pingSession(configDir?: string): Promise<string | null> {
+export const PingFailureSchema = z.object({ reason: z.string(), rejected: z.boolean() });
+export type PingFailure = z.infer<typeof PingFailureSchema>;
+
+export function transcriptSlug(cwd: string): string {
+  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+
+export function pingTranscriptPath(input: { configDir: string; cwd: string; sessionId: string }): string {
+  return join(input.configDir, "projects", transcriptSlug(input.cwd), `${input.sessionId}.jsonl`);
+}
+
+const LIMIT_LABELS: Record<string, string> = { five_hour: "5h", seven_day: "weekly" };
+
+export function pingRejection(rows: TranscriptRow[]): string | null {
+  const row = rows.findLast((r) => r.isApiErrorMessage === true);
+  if (!row || row.error !== "rate_limit" || row.apiErrorIsTransient === true) return null;
+  const type = row.quotaLimits?.rateLimitType ?? "";
+  if (type === "" && parseErrorBody(row.errorDetails)?.error?.type !== "rate_limit_error") return null;
+  const label = LIMIT_LABELS[type] ?? (type !== "" ? type.replace(/_/g, " ") : "usage");
+  const text = transcriptRowText(row);
+  return `${label} limit${text ? `: ${text}` : ""}`;
+}
+
+export async function pingSession(configDir?: string): Promise<PingFailure | null> {
   const cwd = join(paths.sampleDir, "ping-cwd");
-  const fail = (reason: string): string => {
-    log("usage.ping_failed", { dir: configDir ?? "live", reason: reason.slice(0, 200) });
-    return reason;
+  const fail = (reason: string, rejected = false): PingFailure => {
+    log("usage.ping_failed", { dir: configDir ?? "live", rejected, reason: reason.slice(0, 200) });
+    return { reason, rejected };
   };
   let r: SpawnResult | null;
   try {
@@ -382,10 +405,21 @@ export async function pingSession(configDir?: string): Promise<string | null> {
     return fail(e instanceof Error ? e.message : String(e));
   }
   if (r === null) return fail("output pipes still open after child exit (leaked descendant)");
-  if (r.exitCode !== 0) return fail(`claude exited ${r.exitCode ?? "on signal"}: ${(r.stderr.trim() || r.stdout.trim()).slice(0, 160)}`);
   const parsed = PingResultSchema.safeParse((() => { try { return JSON.parse(r.stdout); } catch { return null; } })());
-  if (!parsed.success) return fail(`unrecognized ping output: ${r.stdout.trim().slice(0, 120)}`);
-  if (parsed.data.is_error) return fail((parsed.data.result?.trim() || "request errored").slice(0, 160));
-  log("usage.ping_ok", { dir: configDir ?? "live" });
-  return null;
+  const result = parsed.success ? parsed.data : null;
+  if (r.exitCode === 0 && result?.is_error === false) {
+    log("usage.ping_ok", { dir: configDir ?? "live" });
+    return null;
+  }
+  if (result?.session_id) {
+    const transcript = pingTranscriptPath({ configDir: configDir ?? paths.claudeDir, cwd, sessionId: result.session_id });
+    const rejection = existsSync(transcript) ? pingRejection(readTranscriptTail(transcript)) : null;
+    if (rejection) return fail(`rejected at the ${rejection}`.slice(0, 200), true);
+  }
+  if (r.exitCode !== 0) {
+    const detail = result?.result?.trim() || r.stderr.trim() || r.stdout.trim();
+    return fail(`claude exited ${r.exitCode ?? "on signal"}: ${detail.slice(0, 160)}`);
+  }
+  if (result?.is_error === true) return fail((result.result?.trim() || "request errored").slice(0, 160));
+  return fail(`unrecognized ping output: ${r.stdout.trim().slice(0, 120)}`);
 }