@efoo/ccprofile 0.1.3 → 0.2.0

package/README.md

@@ -73,7 +73,7 @@ Repeat with `ccprofile add personal` etc. Different terminals in different direc
 | `ccprofile unlink [dir]` | Remove the managed block (deletes `.envrc` if nothing else remains) |
 | `ccprofile token <name>` | Print the stored token to stdout (for scripting — handle with care) |
 | `ccprofile remove <name>` | Delete the profile and its Keychain entry |
-| `ccprofile doctor [dir]` | Diagnose provider overrides, stale/missing active token env, expiry, token liveness, broken links. `--offline` skips the server probe |
+| `ccprofile doctor [dir]` | Diagnose provider overrides, stale/missing active token env, expiry, token liveness, usage limits (a minimal real inference per profile — fable first, haiku fallback), broken links. `--model <alias>` pins the probe model; `--offline` skips all server probes |
 | `ccprofile completion <shell>` | Print a completion script for fish, zsh, or bash |
 
 ## Shell completion
@@ -120,7 +120,7 @@ ccprofile is built on `claude setup-token`, whose long-lived tokens are **delibe
 
 - **No account identity introspection.** The token cannot answer "whose token is this?" — the OAuth profile endpoint rejects it (`user:profile` scope missing, see [#11985](https://github.com/anthropics/claude-code/issues/11985)). The `--email` you record is a self-declared label, not verified.
   *Verify identity once, at registration time:* make sure the browser is logged into the intended claude.ai account before `claude setup-token`, then send a couple of prompts from a linked directory and confirm on claude.ai (web) that the intended account's usage moved.
-- **`/status` → Usage tab shows no plan utilization** in token-authenticated sessions (same scope restriction). Check usage on claude.ai instead.
+- **`/status` → Usage tab shows no plan utilization** in token-authenticated sessions (same scope restriction — the usage endpoint also requires `user:profile`). Check usage on claude.ai, or run `ccprofile doctor`: it detects exhausted usage limits the only way these tokens allow, by sending one minimal real inference per profile (fable first; on a fable limit it retries with haiku to tell "fable's separate budget exhausted" from "subscription window exhausted"). The probe consumes a negligible amount of quota and starts the 5-hour window of an idle profile; use `--offline` if you don't want that.
 - **Remote Control is unavailable** in linked directories. Claude Code treats `ANTHROPIC_AUTH_TOKEN` sessions as API-key authentication, while Remote Control requires claude.ai subscription authentication.
 - **Tokens last up to 1 year but can die earlier** (password change, logout-all). The recorded expiry is a hint, not a guarantee — `ccprofile doctor` probes the server and tells live tokens apart from revoked ones.
 - **Routing only applies to shell-launched processes.** direnv activates the token when a hooked shell enters the directory; apps launched outside a hooked shell (GUI launchers) bypass it.

package/dist/commands/doctor.js

@@ -7,22 +7,16 @@ import { daysRemaining, loadConfig } from "../lib/config.js";
 import { parseLinkedProfile } from "../lib/envrc.js";
 import { Keychain } from "../lib/keychain.js";
 import { probeToken } from "../lib/probe.js";
-import { bold, fail, ok, warn } from "../lib/format.js";
-/**
- * Env vars that outrank ccprofile's managed ANTHROPIC_AUTH_TOKEN in Claude
- * Code's documented authentication precedence. If any is set, ccprofile
- * routing is bypassed before the token is considered.
- */
-const OVERRIDING_ENV_VARS = [
-    "CLAUDE_CODE_USE_BEDROCK",
-    "CLAUDE_CODE_USE_VERTEX",
-    "CLAUDE_CODE_USE_FOUNDRY",
-];
+import { DEFAULT_PROBE_MODEL, FALLBACK_PROBE_MODEL, OVERRIDING_ENV_VARS, probeUsage, } from "../lib/usage.js";
+import { bold, dim, fail, green, ok, red, stripAnsi, warn, yellow } from "../lib/format.js";
 export async function doctorCommand(argv) {
     const { values, positionals } = parseArgs({
         args: argv,
         allowPositionals: true,
-        options: { offline: { type: "boolean", default: false } },
+        options: {
+            offline: { type: "boolean", default: false },
+            model: { type: "string" },
+        },
     });
     const dir = resolve(positionals[0] ?? process.cwd());
     let problems = 0;
@@ -31,23 +25,31 @@ export async function doctorCommand(argv) {
         console.log(fail("Not macOS: ccprofile's Keychain backend is unavailable on this platform."));
         return 1;
     }
-    console.log(ok("Platform: macOS (Keychain backend available)"));
     const claude = spawnSync("claude", ["--version"], { stdio: "pipe" });
-    if (claude.error || claude.status !== 0) {
-        console.log(warn("`claude` CLI not found. `ccprofile add` cannot launch setup-token for you."));
-        warnings += 1;
-    }
-    else {
-        console.log(ok(`Claude Code: ${claude.stdout.toString().trim()}`));
-    }
+    const claudeAvailable = !claude.error && claude.status === 0;
     const direnv = spawnSync("direnv", ["version"], { stdio: "pipe" });
-    if (direnv.error || direnv.status !== 0) {
-        console.log(fail("direnv not found. Linked directories will not activate tokens automatically."));
-        console.log("  Install: brew install direnv  /  fish hook: direnv hook fish | source");
-        problems += 1;
+    const direnvAvailable = !direnv.error && direnv.status === 0;
+    if (claudeAvailable && direnvAvailable) {
+        const claudeVersion = claude.stdout.toString().trim().split(" ")[0] ?? "";
+        console.log(ok(`macOS Keychain · Claude Code ${claudeVersion} · direnv ${direnv.stdout.toString().trim()}`));
     }
     else {
-        console.log(ok(`direnv: ${direnv.stdout.toString().trim()}`));
+        console.log(ok("Platform: macOS (Keychain backend available)"));
+        if (claudeAvailable) {
+            console.log(ok(`Claude Code: ${claude.stdout.toString().trim()}`));
+        }
+        else {
+            console.log(warn("`claude` CLI not found. `ccprofile add` cannot launch setup-token for you."));
+            warnings += 1;
+        }
+        if (direnvAvailable) {
+            console.log(ok(`direnv: ${direnv.stdout.toString().trim()}`));
+        }
+        else {
+            console.log(fail("direnv not found. Linked directories will not activate tokens automatically."));
+            console.log("  Install: brew install direnv  /  fish hook: direnv hook fish | source");
+            problems += 1;
+        }
     }
     for (const envVar of OVERRIDING_ENV_VARS) {
         if (process.env[envVar] !== undefined) {
@@ -72,72 +74,66 @@ export async function doctorCommand(argv) {
     }
     const config = loadConfig();
     const keychain = new Keychain();
-    for (const [name, profile] of Object.entries(config.profiles)) {
-        const present = await keychain.hasEntry(profile.keychain.service, profile.keychain.account);
-        if (!present) {
-            console.log(fail(`Profile "${name}": Keychain entry missing. Re-run: ccprofile add ${name} --force`));
-            problems += 1;
-            continue;
-        }
-        const days = daysRemaining(profile.expiresAt);
-        if (days < 0) {
-            console.log(fail(`Profile "${name}": token recorded as expired ${-days}d ago. Re-issue with claude setup-token.`));
-            problems += 1;
-        }
-        else if (days <= config.settings.expiryWarningDays) {
-            console.log(warn(`Profile "${name}": token expires in ${days}d.`));
-            warnings += 1;
-        }
-        else {
-            console.log(ok(`Profile "${name}": token stored, expires in ${days}d.`));
-        }
-        if (values.offline)
-            continue;
-        const token = await keychain.getToken(profile.keychain.service, profile.keychain.account);
-        if (token === null)
-            continue;
-        const live = await probeToken(token);
-        if (live.status === "alive") {
-            if (live.email !== undefined && profile.email !== undefined && live.email !== profile.email) {
-                console.log(fail(`Profile "${name}": server says the token belongs to ${live.email}, but config records ${profile.email}.`));
-                problems += 1;
-            }
-            else {
-                console.log(ok(`Profile "${name}": token is live on the server${live.email ? ` (account: ${live.email})` : ""}.`));
+    const profiles = Object.entries(config.profiles);
+    if (profiles.length > 0) {
+        const ctx = {
+            keychain,
+            expiryWarningDays: config.settings.expiryWarningDays,
+            offline: values.offline,
+            claudeAvailable,
+            probeModel: values.model ?? DEFAULT_PROBE_MODEL,
+        };
+        // All profiles are checked concurrently (each profile's own steps stay
+        // sequential so the fable→haiku cascade works); rows print in config
+        // order as they resolve, making wall time the slowest profile, not the sum.
+        const running = profiles.map(([name, profile]) => checkProfile(name, profile, ctx));
+        const widths = columnWidths(profiles.map(([name]) => name));
+        console.log();
+        console.log(dim(renderCells(HEADER, widths)));
+        const spinner = startSpinner(values.offline || !claudeAvailable
+            ? "checking profiles…"
+            : `probing ${profiles.length} profile(s) — one tiny real request each…`);
+        for (const pending of running) {
+            const row = await pending;
+            spinner.clear();
+            console.log(renderCells([bold(row.name), row.token, row.expires, row.fable, row.others, row.note], widths));
+            for (const detail of row.details) {
+                console.log(`  ${dim("↳")} ${detail}`);
             }
+            problems += row.problems;
+            warnings += row.warnings;
         }
-        else if (live.status === "invalid") {
-            console.log(fail(`Profile "${name}": token rejected by the server (revoked or expired early). Re-issue with: ccprofile add ${name} --force`));
-            problems += 1;
-        }
-        else {
-            console.log(warn(`Profile "${name}": liveness check inconclusive (${live.detail}). Use --offline to skip.`));
-            warnings += 1;
-        }
+        spinner.stop();
     }
     const envrcPath = join(dir, ".envrc");
     if (existsSync(envrcPath)) {
+        console.log();
         const linked = parseLinkedProfile(readFileSync(envrcPath, "utf8"));
         if (linked === null) {
             console.log(ok(`${envrcPath} exists but has no ccprofile block (not managed here).`));
         }
         else if (config.profiles[linked]) {
-            console.log(ok(`${bold(dir)} is linked to profile "${linked}".`));
-            if (dir === resolve(process.cwd())) {
+            if (dir !== resolve(process.cwd())) {
+                console.log(ok(`${bold(dir)} → profile "${linked}"`));
+            }
+            else {
                 const linkedProfile = config.profiles[linked];
                 const exportedToken = process.env.ANTHROPIC_AUTH_TOKEN;
                 if (exportedToken === undefined) {
-                    console.log(fail("Current shell does not export ANTHROPIC_AUTH_TOKEN. Run: direnv reload"));
+                    console.log(fail(`This directory → profile "${linked}", but ANTHROPIC_AUTH_TOKEN is not exported in this shell. Run: direnv reload`));
                     problems += 1;
                 }
                 else {
                     const linkedToken = await keychain.getToken(linkedProfile.keychain.service, linkedProfile.keychain.account);
                     if (linkedToken !== null && exportedToken !== linkedToken) {
-                        console.log(fail(`Current shell exports a different ANTHROPIC_AUTH_TOKEN than profile "${linked}". Run: direnv reload, then restart Claude Code.`));
+                        console.log(fail(`This directory → profile "${linked}", but this shell exports a different ANTHROPIC_AUTH_TOKEN. Run: direnv reload, then restart Claude Code.`));
                         problems += 1;
                     }
                     else if (linkedToken !== null) {
-                        console.log(ok(`Current shell exports profile "${linked}" token via ANTHROPIC_AUTH_TOKEN.`));
+                        console.log(ok(`This directory → profile "${linked}" (ANTHROPIC_AUTH_TOKEN exported)`));
+                    }
+                    else {
+                        console.log(ok(`This directory → profile "${linked}"`));
                     }
                 }
             }
@@ -155,3 +151,220 @@ export async function doctorCommand(argv) {
     console.log(ok(`No problems found (${warnings} warning(s)).`));
     return 0;
 }
+const HEADER = ["PROFILE", "TOKEN", "EXPIRES", "FABLE", "OTHERS", "NOTE"];
+// The cell vocabulary is fixed, so column widths are known before any check
+// resolves — rows can stream in as profiles finish, without a barrier.
+const TOKEN_CELLS = {
+    stored: green("✓ stored"),
+    live: green("✓ live"),
+    missing: red("✗ missing"),
+    revoked: red("✗ revoked"),
+    mismatch: red("✗ mismatch"),
+    unknown: yellow("? unknown"),
+};
+const PROBE_CELLS = {
+    ok: green("✓ ok"),
+    limit: yellow("⚠ limit"),
+    rejected: red("✗"),
+    unknown: yellow("?"),
+    none: dim("-"),
+};
+function columnWidths(names) {
+    const vocab = (cells) => Object.values(cells).map((c) => stripAnsi(c).length);
+    return [
+        Math.max("PROFILE".length, ...names.map((n) => n.length)),
+        Math.max("TOKEN".length, ...vocab(TOKEN_CELLS)),
+        "EXPIRES".length,
+        Math.max("FABLE".length, ...vocab(PROBE_CELLS)),
+        Math.max("OTHERS".length, ...vocab(PROBE_CELLS)),
+        0, // NOTE is last and stays unpadded
+    ];
+}
+function renderCells(cells, widths) {
+    return cells
+        .map((cell, i) => {
+        const width = widths[i] ?? 0;
+        return cell + " ".repeat(Math.max(0, width - stripAnsi(cell).length));
+    })
+        .join("  ")
+        .trimEnd();
+}
+function expiresCell(days, warningDays) {
+    const text = `${days}d`;
+    if (days < 0)
+        return red(text);
+    if (days <= warningDays)
+        return yellow(text);
+    return text;
+}
+/**
+ * Minimal dependency-free progress indicator for the parallel probe wait.
+ * Renders only on a TTY (piped/CI output stays clean). clear() erases the
+ * spinner line so a result row can print; the interval repaints it below.
+ */
+function startSpinner(text) {
+    if (!process.stdout.isTTY) {
+        return { clear: () => { }, stop: () => { } };
+    }
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    let i = 0;
+    const paint = () => {
+        process.stdout.write(`\r\u001B[2K${dim(`${frames[i % frames.length] ?? ""} ${text}`)}`);
+        i += 1;
+    };
+    paint();
+    const timer = setInterval(paint, 100);
+    const clear = () => {
+        process.stdout.write("\r\u001B[2K");
+    };
+    return {
+        clear,
+        stop: () => {
+            clearInterval(timer);
+            clear();
+        },
+    };
+}
+/**
+ * Runs every check for one profile and returns a table row instead of
+ * printing, so all profiles can run concurrently without interleaving
+ * output. Detail lines carry remediation/diagnostic text that does not fit
+ * a cell. Must never reject: doctor prints rows in config order while later
+ * profiles are still running, so a rejection before its turn would be an
+ * unhandled promise rejection.
+ */
+async function checkProfile(name, profile, ctx) {
+    const row = {
+        name,
+        token: PROBE_CELLS.none,
+        expires: PROBE_CELLS.none,
+        fable: PROBE_CELLS.none,
+        others: PROBE_CELLS.none,
+        note: "",
+        details: [],
+        problems: 0,
+        warnings: 0,
+    };
+    try {
+        const present = await ctx.keychain.hasEntry(profile.keychain.service, profile.keychain.account);
+        if (!present) {
+            row.token = TOKEN_CELLS.missing;
+            row.problems += 1;
+            row.details.push(`Keychain entry missing. Re-run: ccprofile add ${name} --force`);
+            return row;
+        }
+        row.token = TOKEN_CELLS.stored;
+        const days = daysRemaining(profile.expiresAt);
+        row.expires = expiresCell(days, ctx.expiryWarningDays);
+        if (days < 0) {
+            row.problems += 1;
+            row.details.push(`Token recorded as expired ${-days}d ago. Re-issue with claude setup-token.`);
+        }
+        else if (days <= ctx.expiryWarningDays) {
+            row.warnings += 1;
+        }
+        if (ctx.offline)
+            return row;
+        const token = await ctx.keychain.getToken(profile.keychain.service, profile.keychain.account);
+        if (token === null)
+            return row;
+        const live = await probeToken(token);
+        if (live.status === "alive") {
+            if (live.email !== undefined && profile.email !== undefined && live.email !== profile.email) {
+                row.token = TOKEN_CELLS.mismatch;
+                row.problems += 1;
+                row.details.push(`Server says the token belongs to ${live.email}, but config records ${profile.email}.`);
+            }
+            else {
+                row.token = TOKEN_CELLS.live;
+            }
+            if (ctx.claudeAvailable) {
+                await appendUsageProbe(row, token, ctx.probeModel);
+            }
+        }
+        else if (live.status === "invalid") {
+            row.token = TOKEN_CELLS.revoked;
+            row.problems += 1;
+            row.details.push(`Token rejected by the server (revoked or expired early). Re-issue with: ccprofile add ${name} --force`);
+        }
+        else {
+            row.token = TOKEN_CELLS.unknown;
+            row.warnings += 1;
+            row.details.push(`Liveness check inconclusive (${live.detail}). Use --offline to skip.`);
+        }
+    }
+    catch (error) {
+        row.problems += 1;
+        row.details.push(`Check failed (${error instanceof Error ? error.message : String(error)}).`);
+    }
+    return row;
+}
+/**
+ * Fills the FABLE/OTHERS cells via real inference. fable is probed first by
+ * default; on a fable limit, a haiku probe distinguishes "fable's separate
+ * budget is exhausted" from "the whole subscription window is exhausted".
+ * The two probes stay sequential within a profile (the cascade depends on
+ * the first result); concurrency happens across profiles. Limits count as
+ * warnings, not problems: doctor's exit code reflects configuration health,
+ * and a rate-limited profile is configured correctly.
+ */
+async function appendUsageProbe(row, token, model) {
+    const pinnedIsFable = /fable/i.test(model);
+    const setProbedCell = (cell) => {
+        if (pinnedIsFable)
+            row.fable = cell;
+        else
+            row.others = cell;
+    };
+    const usage = await probeUsage(token, model);
+    if (usage.status === "usable") {
+        if (pinnedIsFable) {
+            row.fable = PROBE_CELLS.ok;
+            // fable draws from the shared pool too, so fable OK implies the rest.
+            row.others = PROBE_CELLS.ok;
+        }
+        else {
+            row.others = PROBE_CELLS.ok;
+            row.note = `probed ${model}`;
+        }
+        return;
+    }
+    if (usage.status === "limited") {
+        row.warnings += 1;
+        const resets = usage.resetsAt === undefined ? "" : ` (resets ${usage.resetsAt.toLocaleString()})`;
+        if (!pinnedIsFable) {
+            row.others = PROBE_CELLS.limit;
+            row.note = `${model} usage limit reached${resets}`;
+            return;
+        }
+        row.fable = PROBE_CELLS.limit;
+        const fallback = await probeUsage(token, FALLBACK_PROBE_MODEL);
+        if (fallback.status === "usable") {
+            row.others = PROBE_CELLS.ok;
+            row.note = `${FALLBACK_PROBE_MODEL}/sonnet/opus available${resets}`;
+        }
+        else if (fallback.status === "limited") {
+            row.others = PROBE_CELLS.limit;
+            row.note =
+                fallback.resetsAt === undefined
+                    ? `subscription window exhausted${resets}`
+                    : `subscription window exhausted (resets ${fallback.resetsAt.toLocaleString()})`;
+        }
+        else {
+            row.others = PROBE_CELLS.unknown;
+            row.note = `${FALLBACK_PROBE_MODEL} probe inconclusive`;
+            row.details.push(`${FALLBACK_PROBE_MODEL} probe: ${fallback.detail}`);
+        }
+        return;
+    }
+    if (usage.status === "invalid") {
+        setProbedCell(PROBE_CELLS.rejected);
+        row.problems += 1;
+        row.details.push(`Inference probe rejected the token (${usage.detail}). Re-issue with: ccprofile add ${row.name} --force`);
+        return;
+    }
+    setProbedCell(PROBE_CELLS.unknown);
+    row.warnings += 1;
+    row.note = "usage probe inconclusive";
+    row.details.push(`Usage probe (${model}): ${usage.detail}`);
+}

package/dist/index.js

@@ -23,7 +23,9 @@ ${bold("Commands")}
   token <name>            Print the stored token (for scripting; handle with care)
   remove <name> [--force] Delete a profile and its Keychain entry
   doctor [dir]            Diagnose overriding env vars, expiry, token liveness,
-      --offline           and broken links; --offline skips the server probe
+      --offline           usage limits (real inference probe), and broken links
+      --model <alias>     --offline skips probes; --model pins the probe model
+                          (default: fable, then haiku to isolate fable limits)
   completion <shell>      Print a completion script (fish, zsh, bash)
 
 ${bold("Typical flow")}

package/dist/lib/format.js

@@ -12,7 +12,7 @@ export const cyan = (s) => paint("36", s);
 export const ok = (s) => `${green("✓")} ${s}`;
 export const warn = (s) => `${yellow("⚠")} ${s}`;
 export const fail = (s) => `${red("✗")} ${s}`;
-function stripAnsi(s) {
+export function stripAnsi(s) {
     return s.replaceAll(new RegExp(`${ESC}\\[[0-9;]*m`, "g"), "");
 }
 export function table(rows) {

package/dist/lib/usage.js

@@ -0,0 +1,156 @@
+import { spawn } from "node:child_process";
+import { tmpdir } from "node:os";
+/**
+ * fable has its own budget (~50% of the plan, 5h/1-week windows) separate
+ * from the pool shared by haiku/sonnet/opus, and fable usage also counts
+ * against the shared pool. Probing fable first therefore answers for
+ * everything: fable OK ⇒ all models OK; fable limited ⇒ probe the cheapest
+ * shared-pool model to tell "fable-only exhausted" from "window exhausted".
+ */
+export const DEFAULT_PROBE_MODEL = "fable";
+export const FALLBACK_PROBE_MODEL = "haiku";
+const PROBE_TIMEOUT_MS = 120_000;
+/**
+ * Env vars that outrank ANTHROPIC_AUTH_TOKEN in Claude Code's documented
+ * authentication precedence. doctor flags them; the probe strips them so the
+ * spawned `claude -p` authenticates as the profile under test.
+ */
+export const OVERRIDING_ENV_VARS = [
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_VERTEX",
+    "CLAUDE_CODE_USE_FOUNDRY",
+];
+export const defaultProbeRunner = (cmd, args, opts) => new Promise((resolve) => {
+    const child = spawn(cmd, args, {
+        env: opts.env,
+        cwd: opts.cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGKILL");
+    }, opts.timeoutMs);
+    child.stdout.on("data", (d) => (stdout += d.toString()));
+    child.stderr.on("data", (d) => (stderr += d.toString()));
+    child.on("error", (error) => {
+        clearTimeout(timer);
+        resolve({ code: null, stdout, stderr, timedOut, spawnError: error.message });
+    });
+    child.on("close", (code) => {
+        clearTimeout(timer);
+        resolve({ code, stdout, stderr, timedOut });
+    });
+});
+/**
+ * Everything here trims the request to near-zero cost and isolates it from
+ * the invoking user's Claude Code customizations: a one-word turn with a
+ * replacement system prompt, no tools, no MCP servers, no settings (hooks,
+ * plugins, apiKeyHelper), no session file, run from tmpdir so no project
+ * CLAUDE.md is discovered. --fallback-model must never be added: it would
+ * silently succeed on another model and mask the limit being probed for.
+ */
+function probeArgs(model) {
+    return [
+        "--print", "ping",
+        "--model", model,
+        "--effort", "low",
+        "--system-prompt", 'Reply with exactly "ok".',
+        "--tools", "",
+        "--setting-sources", "",
+        "--strict-mcp-config",
+        "--no-session-persistence",
+        "--output-format", "json",
+    ];
+}
+function probeEnv(token) {
+    const env = { ...process.env, ANTHROPIC_AUTH_TOKEN: token };
+    delete env.ANTHROPIC_API_KEY;
+    delete env.CLAUDE_CODE_OAUTH_TOKEN;
+    delete env.ANTHROPIC_MODEL;
+    for (const name of OVERRIDING_ENV_VARS)
+        delete env[name];
+    return env;
+}
+// Claude Code's error strings are not a stable API; match loosely and fall
+// back to "unknown" rather than misclassifying. Checked against the legacy
+// print-mode message ("Claude AI usage limit reached|<epoch>"), the current
+// prose ("You've reached your usage limit..."), and API rate_limit_error.
+const LIMIT_RE = /usage limit|rate.?limit|limit (?:reached|exceeded|resets|will reset)|exceeded.*limit|out of (?:usage|credits)|hit your.*limit|\b429\b/i;
+const AUTH_RE = /authentication_error|invalid (?:bearer|oauth|api key)|oauth token|\b401\b|\/login\b/i;
+/** Legacy print-mode limit messages carry a reset time as "|<unix epoch>". */
+function parseResetEpoch(text) {
+    const digits = /\|(\d{10,13})\b/.exec(text)?.[1];
+    if (digits === undefined)
+        return undefined;
+    const n = Number(digits);
+    return new Date(digits.length >= 13 ? n : n * 1000);
+}
+function summarize(text) {
+    const line = text
+        .replaceAll(/\u001B\[[0-9;]*m/g, "")
+        .split("\n")
+        .map((l) => l.trim())
+        .find((l) => l.length > 0);
+    return (line ?? "").slice(0, 200);
+}
+function isRecord(v) {
+    return typeof v === "object" && v !== null;
+}
+/**
+ * `--output-format json` emits a single result object in some Claude Code
+ * versions and an array of messages (init/assistant/result) in others
+ * (observed with 2.1.201). The result message carries `is_error`, the final
+ * text, and — on API rejections — a structured `api_error_status` (e.g. 429),
+ * which beats string matching.
+ */
+function extractResultMessage(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        // Startup failures print plain text before any JSON is emitted.
+        return {};
+    }
+    const items = Array.isArray(parsed) ? parsed : [parsed];
+    const message = items.find((i) => isRecord(i) && i.type === "result") ??
+        items.find((i) => isRecord(i) && "is_error" in i);
+    if (message === undefined)
+        return {};
+    return {
+        isError: typeof message.is_error === "boolean" ? message.is_error : undefined,
+        resultText: typeof message.result === "string" ? message.result : undefined,
+        apiErrorStatus: typeof message.api_error_status === "number" ? message.api_error_status : undefined,
+    };
+}
+export function classifyProbeOutput(exec) {
+    if (exec.spawnError !== undefined) {
+        return { status: "unknown", detail: exec.spawnError };
+    }
+    if (exec.timedOut) {
+        return { status: "unknown", detail: `probe timed out after ${PROBE_TIMEOUT_MS / 1000}s` };
+    }
+    const { isError, resultText, apiErrorStatus } = extractResultMessage(exec.stdout);
+    if (exec.code === 0 && isError !== true)
+        return { status: "usable" };
+    const combined = [resultText ?? exec.stdout, exec.stderr].join("\n");
+    const detail = summarize(combined) || `claude exited with code ${exec.code}`;
+    if (apiErrorStatus === 429 || LIMIT_RE.test(combined)) {
+        return { status: "limited", detail, resetsAt: parseResetEpoch(combined) };
+    }
+    if (apiErrorStatus === 401 || AUTH_RE.test(combined)) {
+        return { status: "invalid", detail };
+    }
+    return { status: "unknown", detail };
+}
+export async function probeUsage(token, model, run = defaultProbeRunner) {
+    const exec = await run("claude", probeArgs(model), {
+        env: probeEnv(token),
+        cwd: tmpdir(),
+        timeoutMs: PROBE_TIMEOUT_MS,
+    });
+    return classifyProbeOutput(exec);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@efoo/ccprofile",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Per-directory Claude Code account routing via ANTHROPIC_AUTH_TOKEN, direnv, and macOS Keychain",
   "type": "module",
   "packageManager": "pnpm@10.33.4",