letmecode 0.1.8 → 0.1.10

package/README.md

@@ -8,6 +8,8 @@ npx -y letmecode -- -h
 npx -y letmecode -- --log-to log.txt
 ```
 
+`--log-to` now records Claude binary discovery, session-root selection, parsed transcript file summaries, entrypoint matching, raw `/usage` output, and live-window event matching so zero-token windows are diagnosable.
+
 <img width="2308" height="1491" alt="image" src="https://github.com/user-attachments/assets/f3f52d79-00e3-4ff5-bf2f-65f8be632aaa" />
 
 ## Controls

package/ink-app/dist/cli-options.js

@@ -62,8 +62,9 @@ export function buildHelpText() {
         "",
         "Trace logging:",
         "  --log-to PATH writes Claude CLI SDK and Claude VSCode detection details,",
+        "  session root selection, parsed session file summaries, entrypoint matching,",
         "  every candidate binary path check, the final found/not-found result,",
-        "  and the raw /usage command output."
+        "  and the raw /usage command output plus live window matching details."
     ].join("\n");
 }
 export function createFileTraceLogger(logPath) {

package/ink-app/dist/providers/antigravity.js

@@ -1,4 +1,5 @@
 import { execFile } from "node:child_process";
+import https from "node:https";
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import os from "node:os";
@@ -66,6 +67,21 @@ const RATE_CARD = {
 const UNPRICED_MODELS = new Set([
     "gpt-oss-120b"
 ]);
+const ANTIGRAVITY_PRIMARY_WINDOW_MINUTES = 5 * 60;
+const ANTIGRAVITY_WEEKLY_WINDOW_MINUTES = 7 * 24 * 60;
+const ANTIGRAVITY_QUOTA_SUMMARY_PATH = "/exa.language_server_pb.LanguageServerService/RetrieveUserQuotaSummary";
+const ANTIGRAVITY_DEBUG_LOG_PATH = process.env.LETMECODE_ANTIGRAVITY_DEBUG_LOG ??
+    path.join(os.tmpdir(), "letmecode-antigravity-debug.jsonl");
+const GEMINI_QUOTA_MODELS = [
+    "gemini-3.5-flash",
+    "gemini-3.1-pro",
+    "gemini-3-flash"
+];
+const THIRD_PARTY_QUOTA_MODELS = [
+    "claude-opus-4-6",
+    "claude-sonnet-4-6",
+    "gpt-oss-120b"
+];
 const MODEL_ALIASES = {
     "gemini-3-flash-a": "gemini-3-flash",
     "gemini-3-flash-preview": "gemini-3-flash",
@@ -80,15 +96,33 @@ export class AntigravityUsageProvider extends UsageProviderBase {
         this.collectUsage =
             options.collectUsage ??
                 collectAntigravityUsageFromTokscale;
+        this.collectQuota =
+            options.collectQuota ??
+                collectAntigravityQuotaFromLocalRpc;
     }
     async getStats(_options = {}) {
         const warnings = [];
-        let records = [];
-        try {
-            records = await this.collectUsage();
+        const [usageResult, quotaResult] = await Promise.allSettled([
+            this.collectUsage(),
+            this.collectQuota()
+        ]);
+        const records = usageResult.status === "fulfilled"
+            ? usageResult.value
+            : [];
+        const quotaSnapshot = quotaResult.status === "fulfilled"
+            ? quotaResult.value
+            : null;
+        if (usageResult.status === "rejected") {
+            warnings.push("Could not synchronize Antigravity token usage through Tokscale.");
+        }
+        if (quotaResult.status === "rejected") {
+            warnings.push("Live Antigravity quota is unavailable. Ensure the Antigravity IDE is running.");
         }
-        catch {
-            warnings.push("Open Antigravity IDE before running LetMeCode so token usage can be synchronized.");
+        else if (quotaResult.value.entries.length === 0) {
+            warnings.push("Antigravity local quota RPC responded, but no recognized model quota windows were found.");
+        }
+        if (isAntigravityDebugEnabled()) {
+            warnings.push(`Antigravity debug log: ${ANTIGRAVITY_DEBUG_LOG_PATH}`);
         }
         const selectedRecords = deduplicateRecords(records);
         const duplicateEvents = records.length - selectedRecords.length;
@@ -116,6 +150,7 @@ export class AntigravityUsageProvider extends UsageProviderBase {
         if (unknownPricedModels.length > 0) {
             warnings.push(`No Antigravity estimated API-equivalent rate configured for: ${unknownPricedModels.join(", ")}.`);
         }
+        const limitWindows = quotaSnapshot?.entries.map((quota) => buildAntigravityLimitWindow(quota, selectedRecords, quotaSnapshot.fetchedAt)) ?? [];
         return {
             providerId: this.id,
             providerLabel: this.label,
@@ -125,14 +160,16 @@ export class AntigravityUsageProvider extends UsageProviderBase {
                 tokenEvents: selectedRecords.length,
                 totals: sumUsageTotals(modelUsage.map((row) => row.totals)),
                 distinctModels: modelUsage.map((row) => row.modelId),
-                distinctPlanTypes: [],
-                rootLabel: "Antigravity IDE sync",
-                rootPath: "antigravity-ide-rpc"
+                distinctPlanTypes: [
+                    ...new Set(limitWindows.map((window) => window.planType))
+                ],
+                rootLabel: "Tokscale usage + Antigravity local quota",
+                rootPath: getAntigravityCacheRoot()
             },
             modelUsage,
             dayUsage: buildDailyUsageRows(byDay),
-            primaryLimitWindows: [],
-            secondaryLimitWindows: [],
+            primaryLimitWindows: limitWindows.filter((window) => window.scope === "primary"),
+            secondaryLimitWindows: limitWindows.filter((window) => window.scope === "secondary"),
             warnings
         };
     }
@@ -140,6 +177,9 @@ export class AntigravityUsageProvider extends UsageProviderBase {
 export async function collectAntigravityUsage() {
     return collectAntigravityUsageFromTokscale();
 }
+export async function collectAntigravityQuota() {
+    return collectAntigravityQuotaFromLocalRpc();
+}
 async function collectAntigravityUsageFromTokscale() {
     await runTokscale([
         "antigravity",
@@ -153,11 +193,459 @@ async function runTokscale(args) {
         maxBuffer: 32 * 1024 * 1024
     });
 }
+async function collectAntigravityQuotaFromLocalRpc() {
+    const server = await findAntigravityLocalServer();
+    if (!server) {
+        throw new Error("Antigravity local language server was not found.");
+    }
+    const fetchedAt = Date.now();
+    const payload = await readAntigravityQuotaSummary(server);
+    const entries = parseAntigravityQuotaEntries(payload);
+    await writeAntigravityDebugEvent("quota-rpc-response", {
+        port: server.port,
+        path: ANTIGRAVITY_QUOTA_SUMMARY_PATH,
+        entries: entries.map((entry) => ({
+            limitId: entry.limitId,
+            remainingFraction: entry.remainingFraction,
+            resetAt: new Date(entry.resetAt).toISOString(),
+            windowMinutes: entry.windowMinutes,
+            scope: entry.scope,
+            modelIds: entry.modelIds
+        })),
+        ...(isAntigravityRawDebugEnabled() ? { payload } : {})
+    });
+    return {
+        entries,
+        fetchedAt
+    };
+}
+function recordsForQuotaWindow(quota, records) {
+    if (quota.modelIds.length === 0) {
+        return [];
+    }
+    const endMs = quota.resetAt;
+    const startMs = endMs - quota.windowMinutes * 60000;
+    const modelIds = new Set(quota.modelIds.map(resolveModelId));
+    return records.filter((record) => {
+        const modelId = resolveModelId(record.modelId);
+        return (record.timestamp >= startMs &&
+            record.timestamp < endMs &&
+            modelIds.has(modelId));
+    });
+}
+function buildAntigravityLimitWindow(quota, records, fetchedAt) {
+    const matchingRecords = recordsForQuotaWindow(quota, records);
+    const byModel = new Map();
+    for (const record of matchingRecords) {
+        const modelId = resolveModelId(record.modelId);
+        addModelUsage(byModel, modelId, usageRecordToTotals(modelId, record));
+    }
+    const modelUsage = [...byModel.entries()]
+        .map(([modelId, totals]) => ({
+        modelId,
+        totals
+    }))
+        .sort((left, right) => right.totals.estimatedCredits -
+        left.totals.estimatedCredits);
+    const totals = sumUsageTotals(modelUsage.map((row) => row.totals));
+    const usedPercent = clampPercent((1 - quota.remainingFraction) * 100);
+    // Quota percentage is authoritative from Antigravity RPC. Token totals are
+    // reconstructed from locally available Tokscale events inside the same time
+    // window and may not match Antigravity's internal quota accounting exactly.
+    return {
+        scope: quota.scope,
+        planType: quota.planType,
+        limitId: quota.limitId,
+        windowMinutes: quota.windowMinutes,
+        startTimeUtcIso: new Date(quota.resetAt - quota.windowMinutes * 60000).toISOString(),
+        endTimeUtcIso: new Date(quota.resetAt).toISOString(),
+        firstSeenUtcIso: new Date(fetchedAt).toISOString(),
+        lastSeenUtcIso: new Date(fetchedAt).toISOString(),
+        minUsedPercent: usedPercent,
+        maxUsedPercent: usedPercent,
+        totals,
+        modelUsage,
+        eventCount: totals.eventCount
+    };
+}
+const antigravityHttpsAgent = new https.Agent({
+    rejectUnauthorized: false
+});
+async function findAntigravityLocalServer() {
+    const process = await findAntigravityProcess();
+    if (!process) {
+        await writeAntigravityDebugEvent("process-not-found", {});
+        return null;
+    }
+    const ports = await findListeningLoopbackPorts(process.pid);
+    await writeAntigravityDebugEvent("process-found", {
+        pid: process.pid,
+        ports
+    });
+    return probeAntigravityPorts(ports, process.csrfToken);
+}
+async function findAntigravityProcess() {
+    const fromProc = await findAntigravityProcessFromProc();
+    if (fromProc) {
+        return fromProc;
+    }
+    return findAntigravityProcessFromPs();
+}
+async function findAntigravityProcessFromProc() {
+    let entries;
+    try {
+        entries = await fs.promises.readdir("/proc", { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !/^\d+$/.test(entry.name)) {
+            continue;
+        }
+        const pid = Number(entry.name);
+        const cmdline = await readProcCmdline(path.join("/proc", entry.name, "cmdline"));
+        const process = parseAntigravityProcessFromArgs(pid, cmdline);
+        if (process) {
+            return process;
+        }
+    }
+    return null;
+}
+async function readProcCmdline(filePath) {
+    try {
+        const content = await fs.promises.readFile(filePath);
+        return content
+            .toString("utf8")
+            .split("\0")
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+async function findAntigravityProcessFromPs() {
+    try {
+        const { stdout } = await execFileAsync("ps", ["-eo", "pid=,args="], {
+            encoding: "utf8",
+            maxBuffer: 4 * 1024 * 1024,
+            timeout: 5000
+        });
+        for (const line of stdout.split(/\r?\n/)) {
+            const match = line.match(/^\s*(\d+)\s+(.+)$/);
+            if (!match) {
+                continue;
+            }
+            const process = parseAntigravityProcessFromArgs(Number(match[1]), splitCommandLineForDiscovery(match[2]));
+            if (process) {
+                return process;
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function splitCommandLineForDiscovery(value) {
+    return value.match(/"[^"]*"|'[^']*'|\S+/g)?.map((part) => part.replace(/^['"]|['"]$/g, "")) ?? [];
+}
+function parseAntigravityProcessFromArgs(pid, args) {
+    if (!Number.isInteger(pid) || pid <= 0 || !isAntigravityLanguageServerCommand(args)) {
+        return null;
+    }
+    const csrfToken = readNamedArg(args, "--csrf_token")?.trim();
+    if (!csrfToken) {
+        return null;
+    }
+    return { pid, csrfToken };
+}
+function isAntigravityLanguageServerCommand(args) {
+    const normalized = args.join(" ").toLowerCase();
+    return (normalized.includes("antigravity") &&
+        (normalized.includes("language-server") ||
+            normalized.includes("language_server") ||
+            normalized.includes("extension-server") ||
+            normalized.includes("extension_server")));
+}
+function readNamedArg(args, name) {
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === name) {
+            return args[index + 1] ?? null;
+        }
+        if (arg.startsWith(`${name}=`)) {
+            return arg.slice(name.length + 1);
+        }
+    }
+    return null;
+}
+async function findListeningLoopbackPorts(pid) {
+    const parsers = [
+        () => findListeningLoopbackPortsWithSs(pid),
+        () => findListeningLoopbackPortsWithLsof(pid)
+    ];
+    for (const parse of parsers) {
+        const ports = await parse();
+        if (ports.length > 0) {
+            return ports;
+        }
+    }
+    return [];
+}
+async function findListeningLoopbackPortsWithSs(pid) {
+    try {
+        const { stdout } = await execFileAsync("ss", ["-H", "-ltnp"], {
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024,
+            timeout: 5000
+        });
+        return uniquePorts(stdout
+            .split(/\r?\n/)
+            .filter((line) => line.includes(`pid=${pid},`) && isLoopbackListenLine(line))
+            .map(extractPortFromListenLine));
+    }
+    catch {
+        return [];
+    }
+}
+async function findListeningLoopbackPortsWithLsof(pid) {
+    try {
+        const { stdout } = await execFileAsync("lsof", ["-Pan", "-p", String(pid), "-iTCP", "-sTCP:LISTEN"], {
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024,
+            timeout: 5000
+        });
+        return uniquePorts(stdout
+            .split(/\r?\n/)
+            .filter(isLoopbackListenLine)
+            .map(extractPortFromListenLine));
+    }
+    catch {
+        return [];
+    }
+}
+function isLoopbackListenLine(line) {
+    return /(?:127\.0\.0\.1|localhost|\[::1\]|::1):\d+\b/.test(line);
+}
+function extractPortFromListenLine(line) {
+    const matches = [...line.matchAll(/(?:127\.0\.0\.1|localhost|\[::1\]|::1):(\d+)/g)];
+    const value = matches.at(-1)?.[1];
+    const port = value ? Number(value) : NaN;
+    return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : null;
+}
+function uniquePorts(ports) {
+    return [...new Set(ports.filter((port) => port !== null))];
+}
+async function probeAntigravityPorts(ports, csrfToken) {
+    for (const port of ports) {
+        const server = { port, csrfToken };
+        try {
+            await readAntigravityQuotaSummary(server);
+            await writeAntigravityDebugEvent("port-probe-ok", { port });
+            return server;
+        }
+        catch (error) {
+            await writeAntigravityDebugEvent("port-probe-failed", {
+                port,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            // Try the next loopback listener owned by the same Antigravity process.
+        }
+    }
+    return null;
+}
+async function readAntigravityQuotaSummary(server) {
+    return requestAntigravityQuotaSummary(server);
+}
+function requestAntigravityQuotaSummary(server) {
+    const body = "{}";
+    return new Promise((resolve, reject) => {
+        const request = https.request({
+            hostname: "127.0.0.1",
+            port: server.port,
+            path: ANTIGRAVITY_QUOTA_SUMMARY_PATH,
+            method: "POST",
+            timeout: 5000,
+            agent: antigravityHttpsAgent,
+            headers: {
+                "X-Codeium-Csrf-Token": server.csrfToken,
+                "Content-Type": "application/json",
+                "Connect-Protocol-Version": "1",
+                Accept: "application/json",
+                "Content-Length": Buffer.byteLength(body)
+            }
+        }, (response) => {
+            const chunks = [];
+            response.on("data", (chunk) => chunks.push(chunk));
+            response.on("end", () => {
+                const responseBody = Buffer.concat(chunks).toString("utf8");
+                if (!response.statusCode || response.statusCode < 200 || response.statusCode >= 300) {
+                    reject(new Error(`Unexpected Antigravity quota summary response: ${response.statusCode ?? "unknown"}`));
+                    return;
+                }
+                try {
+                    resolve(responseBody ? JSON.parse(responseBody) : {});
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+        request.on("timeout", () => {
+            request.destroy(new Error("Timed out reading Antigravity quota summary."));
+        });
+        request.on("error", reject);
+        request.end(body);
+    });
+}
+export function parseAntigravityQuotaEntries(payload) {
+    const root = asRecord(payload);
+    const response = asRecord(root?.response);
+    const groups = asArray(response?.groups);
+    const entries = [];
+    for (const groupValue of groups) {
+        const group = asRecord(groupValue);
+        if (!group) {
+            continue;
+        }
+        const displayName = asString(group.displayName) ?? "";
+        const description = asString(group.description) ?? "";
+        const modelIds = resolveQuotaGroupModelIds(displayName, description);
+        if (modelIds.length === 0) {
+            void writeAntigravityDebugEvent("quota-group-skipped", {
+                displayName,
+                description
+            });
+            continue;
+        }
+        for (const bucketValue of asArray(group.buckets)) {
+            const bucket = asRecord(bucketValue);
+            if (!bucket) {
+                continue;
+            }
+            const bucketId = asString(bucket.bucketId);
+            const windowConfig = resolveQuotaWindow(asString(bucket.window));
+            const remainingFraction = asFiniteNumber(bucket.remainingFraction);
+            const resetTime = asString(bucket.resetTime);
+            const resetAt = resetTime === null ? NaN : Date.parse(resetTime);
+            if (!bucketId ||
+                remainingFraction === null ||
+                remainingFraction < 0 ||
+                remainingFraction > 1 ||
+                !Number.isFinite(resetAt) ||
+                !windowConfig) {
+                continue;
+            }
+            entries.push({
+                limitId: bucketId,
+                modelIds,
+                remainingFraction,
+                resetAt,
+                windowMinutes: windowConfig.windowMinutes,
+                scope: windowConfig.scope,
+                planType: "unknown"
+            });
+        }
+    }
+    return entries;
+}
+function resolveQuotaWindow(window) {
+    switch (window) {
+        case "5h":
+            return {
+                scope: "primary",
+                windowMinutes: ANTIGRAVITY_PRIMARY_WINDOW_MINUTES
+            };
+        case "weekly":
+            return {
+                scope: "secondary",
+                windowMinutes: ANTIGRAVITY_WEEKLY_WINDOW_MINUTES
+            };
+        default:
+            return null;
+    }
+}
+function resolveQuotaGroupModelIds(displayName, description) {
+    const text = `${displayName} ${description}`.toLowerCase();
+    if (text.includes("gemini")) {
+        return GEMINI_QUOTA_MODELS;
+    }
+    if (text.includes("claude") || text.includes("gpt")) {
+        return THIRD_PARTY_QUOTA_MODELS;
+    }
+    return [];
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function asFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isAntigravityDebugEnabled() {
+    const value = process.env.LETMECODE_DEBUG_ANTIGRAVITY;
+    return value === "1" || value === "true" || value === "yes";
+}
+function isAntigravityRawDebugEnabled() {
+    const value = process.env.LETMECODE_DEBUG_ANTIGRAVITY_RAW;
+    return value === "1" || value === "true" || value === "yes";
+}
+async function writeAntigravityDebugEvent(event, data) {
+    if (!isAntigravityDebugEnabled()) {
+        return;
+    }
+    const line = JSON.stringify({
+        timestamp: new Date().toISOString(),
+        event,
+        data: redactDebugValue(data)
+    });
+    try {
+        await fs.promises.mkdir(path.dirname(ANTIGRAVITY_DEBUG_LOG_PATH), {
+            recursive: true
+        });
+        await fs.promises.appendFile(ANTIGRAVITY_DEBUG_LOG_PATH, `${line}\n`, "utf8");
+    }
+    catch {
+        // Debug logging must never break provider stats collection.
+    }
+}
+function redactDebugValue(value, key = "") {
+    if (isSensitiveDebugKey(key)) {
+        return "[redacted]";
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactDebugValue(item));
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [
+        entryKey,
+        redactDebugValue(entryValue, entryKey)
+    ]));
+}
+function isSensitiveDebugKey(key) {
+    return /token|csrf|authorization|cookie|email/i.test(key);
+}
 function numberOrZero(value) {
     return typeof value === "number" && Number.isFinite(value)
         ? value
         : 0;
 }
+function clampPercent(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.min(100, Math.max(0, value));
+}
 async function readAntigravityUsageCache(cacheRoot) {
     const sessionsRoot = path.join(cacheRoot, "sessions");
     const records = [];

package/ink-app/dist/providers/claude.js

@@ -58,7 +58,8 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         this.now = options.now ?? (() => new Date());
     }
     async getStats(options = {}) {
-        const resolvedSessionsRoot = await resolveClaudeSessionsRoot(this.root);
+        traceClaude(options.traceLogger, this.usageCommandKind, `Starting stats collection with root=${this.root} entrypoints=[${[...this.entrypoints].join(", ")}].`);
+        const resolvedSessionsRoot = await resolveClaudeSessionsRoot(this.root, this.usageCommandKind, options.traceLogger);
         const sessionsRoot = resolvedSessionsRoot.rootPath;
         const agentName = normalizeAnalyticsAgentName(this.label);
         const userIdHash = await readClaudeUserIdHash(this.root, this.usageCommandKind, this.readAuthStatusOutput, agentName, options.traceLogger);
@@ -74,9 +75,19 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             tokenEvents: 0,
             malformedLines: 0
         };
-        const parsedSessionFiles = await loadParsedClaudeSessionFiles(sessionsRoot);
+        const parsedSessionFiles = await loadParsedClaudeSessionFiles(sessionsRoot, this.usageCommandKind, options.traceLogger);
+        traceClaude(options.traceLogger, this.usageCommandKind, `Loaded ${parsedSessionFiles.length} parsed session file(s) from ${sessionsRoot}.`);
         for (const file of parsedSessionFiles) {
             const matchingEvents = file.events.filter((event) => this.entrypoints.has(event.entrypoint));
+            traceClaude(options.traceLogger, this.usageCommandKind, [
+                `Session file ${describeSessionFilePath(sessionsRoot, file.filePath)}:`,
+                `lines=${file.linesRead}`,
+                `malformed=${file.malformedLines}`,
+                `assistantUsageEvents=${file.events.length}`,
+                `matchingEvents=${matchingEvents.length}`,
+                `entrypoints=${summarizeEventCounts(file.events.map((event) => event.entrypoint || "<empty>"))}`,
+                `models=${summarizeDistinctValues(file.events.map((event) => event.modelId || "unknown"))}`
+            ].join(" "));
             if (matchingEvents.length === 0) {
                 continue;
             }
@@ -91,12 +102,22 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             ...parsedEvents.keyedEvents.values(),
             ...parsedEvents.unkeyedEvents.values()
         ];
+        traceClaude(options.traceLogger, this.usageCommandKind, [
+            `Transcript selection summary: filesWithMatches=${parseTotals.filesScanned}/${parsedSessionFiles.length}`,
+            `selectedEvents=${selectedEvents.length}`,
+            `duplicateUsageKeys=${parsedEvents.duplicateUsageKeys}`,
+            `duplicateUsageKeyCollisions=${parsedEvents.duplicateUsageKeyCollisions}`,
+            `duplicateUnkeyedEvents=${parsedEvents.duplicateUnkeyedEvents}`
+        ].join(" "));
+        if (selectedEvents.length === 0 && parsedSessionFiles.length > 0) {
+            traceClaude(options.traceLogger, this.usageCommandKind, `No transcript usage matched entrypoints [${[...this.entrypoints].join(", ")}]. Observed entrypoints=${summarizeEventCounts(collectEntryPoints(parsedSessionFiles))}.`);
+        }
         for (const event of selectedEvents) {
             addModelUsage(byModel, event.modelId, event.totals);
             const planType = typeof event.rateLimits?.plan_type === "string" ? event.rateLimits.plan_type : undefined;
             const safeEventTimeMs = Number.isFinite(event.timestampMs) ? event.timestampMs : 0;
             addDailyUsage(byDay, event.timestampMs, event.modelId, planType, event.totals);
-            applyRateLimits(windows, event.rateLimits, safeEventTimeMs, event.totals, planTypes);
+            applyRateLimits(windows, event.rateLimits, safeEventTimeMs, event.modelId, event.totals, planTypes);
         }
         parseTotals.tokenEvents = selectedEvents.length;
         if (parseTotals.malformedLines > 0) {
@@ -141,6 +162,19 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         const secondaryLimitWindows = liveLimitWindows.secondaryLimitWindows.length > 0
             ? liveLimitWindows.secondaryLimitWindows
             : fallbackSecondaryLimitWindows;
+        traceClaude(options.traceLogger, this.usageCommandKind, [
+            `Finished stats collection:`,
+            `filesScanned=${parseTotals.filesScanned}`,
+            `linesRead=${parseTotals.linesRead}`,
+            `tokenEvents=${parseTotals.tokenEvents}`,
+            `models=${modelUsage.length}`,
+            `primaryWindows=${primaryLimitWindows.length}`,
+            `secondaryWindows=${secondaryLimitWindows.length}`,
+            `input=${summaryTotals.inputTokens}`,
+            `output=${summaryTotals.outputTokens}`,
+            `cacheRead=${summaryTotals.cacheReadInputTokens}`,
+            `cacheWrite=${summaryTotals.cacheWriteInputTokens}`
+        ].join(" "));
         return {
             providerId: this.id,
             providerLabel: this.label,
@@ -240,17 +274,23 @@ function resolveClaudeCacheWriteBreakdown(usage) {
 function isSessionFile(filePath) {
     return filePath.endsWith(".jsonl");
 }
-async function resolveClaudeSessionsRoot(root) {
+async function resolveClaudeSessionsRoot(root, usageCommandKind, traceLogger) {
     const candidates = buildClaudeSessionsRootCandidates(root);
+    traceClaude(traceLogger, usageCommandKind, `Checking ${candidates.length} Claude session root candidate(s).`);
     for (const candidate of candidates) {
-        if (await isDirectory(candidate.rootPath)) {
+        const exists = await isDirectory(candidate.rootPath);
+        traceClaude(traceLogger, usageCommandKind, `Session root candidate ${candidate.rootLabel} -> ${candidate.rootPath} (${exists ? "exists" : "missing"}).`);
+        if (exists) {
+            traceClaude(traceLogger, usageCommandKind, `Selected session root ${candidate.rootLabel} -> ${candidate.rootPath}.`);
             return candidate;
         }
     }
-    return candidates[0] ?? {
+    const fallbackCandidate = candidates[0] ?? {
         rootLabel: "~/.claude/projects",
         rootPath: path.join(path.resolve(root), ".claude", "projects")
     };
+    traceClaude(traceLogger, usageCommandKind, `No session root candidate exists yet; defaulting to ${fallbackCandidate.rootLabel} -> ${fallbackCandidate.rootPath}.`);
+    return fallbackCandidate;
 }
 function buildClaudeSessionsRootCandidates(root) {
     const resolvedRoot = path.resolve(root);
@@ -338,17 +378,21 @@ async function* walkSessionFiles(directory) {
         }
     }
 }
-async function loadParsedClaudeSessionFiles(sessionsRoot) {
+async function loadParsedClaudeSessionFiles(sessionsRoot, usageCommandKind, traceLogger) {
     const cacheKey = path.resolve(sessionsRoot);
     const cached = parsedClaudeSessionFilesCache.get(cacheKey);
     if (cached) {
-        return cached;
+        const files = await cached;
+        traceClaude(traceLogger, usageCommandKind, `Session parse cache hit for ${sessionsRoot} (${files.length} file(s)).`);
+        return files;
     }
     const pending = (async () => {
         const files = [];
+        traceClaude(traceLogger, usageCommandKind, `Scanning session files under ${sessionsRoot}.`);
         for await (const filePath of walkSessionFiles(sessionsRoot)) {
             files.push(await parseSessionFile(filePath));
         }
+        traceClaude(traceLogger, usageCommandKind, `Completed session file scan under ${sessionsRoot}: ${files.length} file(s) parsed.`);
         return files;
     })();
     parsedClaudeSessionFilesCache.set(cacheKey, pending);
@@ -397,7 +441,7 @@ async function parseSessionFile(filePath) {
             rateLimits
         });
     }
-    return { linesRead, malformedLines, events };
+    return { filePath, linesRead, malformedLines, events };
 }
 function buildUsageEventKey(payloadObject, message) {
     const sessionId = String(payloadObject.sessionId ?? "");
@@ -493,6 +537,41 @@ function describeUsageOutput(output) {
     }
     return output.trim() ? output : "<empty>";
 }
+function describeSessionFilePath(sessionsRoot, filePath) {
+    const relativePath = path.relative(sessionsRoot, filePath);
+    if (!relativePath || relativePath.startsWith("..")) {
+        return filePath;
+    }
+    return relativePath;
+}
+function summarizeEventCounts(values) {
+    const counts = new Map();
+    for (const value of values) {
+        const normalizedValue = value || "<empty>";
+        counts.set(normalizedValue, (counts.get(normalizedValue) ?? 0) + 1);
+    }
+    if (counts.size === 0) {
+        return "<none>";
+    }
+    return [...counts.entries()]
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+        .map(([value, count]) => `${value}:${count}`)
+        .join(", ");
+}
+function summarizeDistinctValues(values, limit = 5) {
+    const distinctValues = [...new Set([...values].filter(Boolean))].sort();
+    if (distinctValues.length === 0) {
+        return "<none>";
+    }
+    const visibleValues = distinctValues.slice(0, limit);
+    const remainder = distinctValues.length - visibleValues.length;
+    return remainder > 0
+        ? `${visibleValues.join(", ")} (+${remainder} more)`
+        : visibleValues.join(", ");
+}
+function collectEntryPoints(files) {
+    return files.flatMap((file) => file.events.map((event) => event.entrypoint || "<empty>"));
+}
 function buildClaudeCommandEnvironment() {
     return {
         ...process.env,
@@ -506,19 +585,47 @@ async function buildLiveLimitWindows(options) {
     ]);
     const snapshots = parseLiveUsageWindowSnapshots(usageOutput, options.now);
     traceClaude(options.traceLogger, options.usageCommandKind, `Parsed ${snapshots.length} live usage snapshot(s) from /usage output.`);
+    if (snapshots.length === 0) {
+        traceClaude(options.traceLogger, options.usageCommandKind, "No live usage snapshots matched the expected /usage format.");
+    }
     const resolvedPlanType = subscriptionType || "live";
+    traceClaude(options.traceLogger, options.usageCommandKind, `Resolved live plan type ${resolvedPlanType}.`);
+    const primaryLimitWindows = snapshots
+        .filter((snapshot) => snapshot.scope === "primary")
+        .map((snapshot) => buildLiveLimitWindowRow(snapshot, resolvedPlanType, options.selectedEvents, options.now));
+    const secondaryLimitWindows = snapshots
+        .filter((snapshot) => snapshot.scope === "secondary")
+        .map((snapshot) => buildLiveLimitWindowRow(snapshot, resolvedPlanType, options.selectedEvents, options.now));
+    for (let index = 0; index < snapshots.length; index += 1) {
+        const snapshot = snapshots[index];
+        const row = snapshot.scope === "primary"
+            ? primaryLimitWindows.filter((window) => window.limitId === `current-${snapshot.label}`)[0]
+            : secondaryLimitWindows.filter((window) => window.limitId === `current-${snapshot.label}`)[0];
+        if (!row) {
+            continue;
+        }
+        traceClaude(options.traceLogger, options.usageCommandKind, [
+            `Live window ${snapshot.scope}/${snapshot.label}:`,
+            `used=${snapshot.usedPercent}%`,
+            `range=${row.startTimeUtcIso}->${row.endTimeUtcIso}`,
+            `matchedEvents=${row.eventCount}`,
+            `input=${row.totals.inputTokens}`,
+            `output=${row.totals.outputTokens}`,
+            `cacheRead=${row.totals.cacheReadInputTokens}`,
+            `cacheWrite=${row.totals.cacheWriteInputTokens}`
+        ].join(" "));
+    }
     return {
-        primaryLimitWindows: snapshots
-            .filter((snapshot) => snapshot.scope === "primary")
-            .map((snapshot) => buildLiveLimitWindowRow(snapshot, resolvedPlanType, options.selectedEvents, options.now)),
-        secondaryLimitWindows: snapshots
-            .filter((snapshot) => snapshot.scope === "secondary")
-            .map((snapshot) => buildLiveLimitWindowRow(snapshot, resolvedPlanType, options.selectedEvents, options.now))
+        primaryLimitWindows,
+        secondaryLimitWindows
     };
 }
 async function readClaudeSubscriptionType(root, usageCommandKind, override, traceLogger) {
     const output = await readClaudeAuthStatusOutput(root, usageCommandKind, override, traceLogger);
     const subscriptionType = parseClaudeSubscriptionType(output);
+    if (output && !subscriptionType) {
+        traceClaude(traceLogger, usageCommandKind, "Could not parse subscription type from auth status output.");
+    }
     traceClaude(traceLogger, usageCommandKind, `Subscription type result: ${subscriptionType ?? "<none>"}.`);
     return subscriptionType;
 }
@@ -602,6 +709,7 @@ async function readClaudeUserIdHash(root, usageCommandKind, override, agentName,
     const authStatusOutput = await readClaudeAuthStatusOutput(root, usageCommandKind, override, traceLogger);
     const snapshot = parseClaudeAuthStatusSnapshot(authStatusOutput);
     if (!snapshot) {
+        traceClaude(traceLogger, usageCommandKind, "Auth status output did not yield an analytics identity snapshot.");
         return null;
     }
     return buildUserIdHash([agentName, snapshot.email, snapshot.orgId, snapshot.orgName]);
@@ -872,9 +980,19 @@ function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
         minUsedPercent: snapshot.usedPercent,
         maxUsedPercent: snapshot.usedPercent,
         totals,
+        modelUsage: buildModelUsageRowsForEvents(inWindowEvents),
         eventCount: totals.eventCount
     };
 }
+function buildModelUsageRowsForEvents(events) {
+    const byModel = new Map();
+    for (const event of events) {
+        addModelUsage(byModel, event.modelId, event.totals);
+    }
+    return [...byModel.entries()]
+        .map(([modelId, totals]) => ({ modelId, totals }))
+        .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
+}
 function toUtcIso(value) {
     return new Date(value).toISOString().replace(".000Z", "Z");
 }

package/ink-app/dist/providers/codex.js

@@ -349,7 +349,7 @@ async function parseSessionFile(filePath, byModel, byDay, windows, planTypes, kn
         const rateLimits = asRecord(payload.rate_limits);
         const planType = typeof rateLimits?.plan_type === "string" ? rateLimits.plan_type : undefined;
         addDailyUsage(byDay, eventTimeMs, resolvedModelId, planType, deltaTotals);
-        applyRateLimits(windows, rateLimits, safeEventTimeMs, deltaTotals, planTypes);
+        applyRateLimits(windows, rateLimits, safeEventTimeMs, resolvedModelId, deltaTotals, planTypes);
     }
     return { linesRead, tokenEvents, malformedLines };
 }

package/ink-app/dist/providers/index.js

@@ -16,7 +16,7 @@ export function createProviders() {
         new AntigravityUsageProvider()
     ];
 }
-export { AntigravityUsageProvider } from "./antigravity.js";
+export { AntigravityUsageProvider, collectAntigravityQuota, collectAntigravityUsage } from "./antigravity.js";
 export { ClaudeUsageProvider } from "./claude.js";
 export { CodexUsageProvider } from "./codex.js";
 export { CopilotUsageProvider, configureCopilotVsCodeLogging } from "./copilot.js";

package/ink-app/dist/providers/limits.js

@@ -8,31 +8,35 @@ export function numberOrZero(value) {
 export function asRecord(value) {
     return value && typeof value === "object" ? value : null;
 }
-export function applyRateLimits(windows, rateLimits, eventTimeMs, deltaTotals, planTypes) {
+export function applyRateLimits(windows, rateLimits, eventTimeMs, modelId, deltaTotals, planTypes) {
     if (!rateLimits) {
         return;
     }
     if (typeof rateLimits.plan_type === "string") {
         planTypes.add(rateLimits.plan_type);
     }
-    upsertWindow(windows, "primary", rateLimits, asRecord(rateLimits.primary), eventTimeMs, deltaTotals);
-    upsertWindow(windows, "secondary", rateLimits, asRecord(rateLimits.secondary), eventTimeMs, deltaTotals);
+    upsertWindow(windows, "primary", rateLimits, asRecord(rateLimits.primary), eventTimeMs, modelId, deltaTotals);
+    upsertWindow(windows, "secondary", rateLimits, asRecord(rateLimits.secondary), eventTimeMs, modelId, deltaTotals);
 }
 export function buildWindowLists(windows) {
-    const rows = collapseNearbyWindows([...windows.values()].map((window) => ({
-        scope: window.scope,
-        planType: window.planType,
-        limitId: window.limitId,
-        windowMinutes: window.windowMinutes,
-        startTimeUtcIso: formatIsoFromSeconds(window.minStartsAt),
-        endTimeUtcIso: formatIsoFromSeconds(window.maxResetsAt),
-        firstSeenUtcIso: formatIsoFromMilliseconds(window.firstSeenMs),
-        lastSeenUtcIso: formatIsoFromMilliseconds(window.lastSeenMs),
-        minUsedPercent: window.minUsedPercent,
-        maxUsedPercent: window.maxUsedPercent,
-        totals: computeWindowTotals(window.events),
-        eventCount: 0
-    })))
+    const rows = collapseNearbyWindows([...windows.values()].map((window) => {
+        const usage = computeWindowUsage(window.events);
+        return {
+            scope: window.scope,
+            planType: window.planType,
+            limitId: window.limitId,
+            windowMinutes: window.windowMinutes,
+            startTimeUtcIso: formatIsoFromSeconds(window.minStartsAt),
+            endTimeUtcIso: formatIsoFromSeconds(window.maxResetsAt),
+            firstSeenUtcIso: formatIsoFromMilliseconds(window.firstSeenMs),
+            lastSeenUtcIso: formatIsoFromMilliseconds(window.lastSeenMs),
+            minUsedPercent: window.minUsedPercent,
+            maxUsedPercent: window.maxUsedPercent,
+            totals: usage.totals,
+            modelUsage: usage.modelUsage,
+            eventCount: 0
+        };
+    }))
         .map((row) => ({
         ...row,
         eventCount: row.totals.eventCount
@@ -71,7 +75,11 @@ function collapseNearbyWindows(rows) {
         if (!existing) {
             collapsed.set(key, {
                 ...row,
-                totals: cloneUsageTotals(row.totals)
+                totals: cloneUsageTotals(row.totals),
+                modelUsage: row.modelUsage.map((entry) => ({
+                    modelId: entry.modelId,
+                    totals: cloneUsageTotals(entry.totals)
+                }))
             });
             continue;
         }
@@ -86,28 +94,34 @@ function collapseNearbyWindows(rows) {
         existing.minUsedPercent = Math.min(existing.minUsedPercent, row.minUsedPercent);
         existing.maxUsedPercent = Math.max(existing.maxUsedPercent, row.maxUsedPercent);
         addUsageTotals(existing.totals, row.totals);
+        existing.modelUsage = mergeModelUsageRows(existing.modelUsage, row.modelUsage);
         existing.eventCount = existing.totals.eventCount;
     }
     return [...collapsed.values()];
 }
-function computeWindowTotals(events) {
+function computeWindowUsage(events) {
     // Session files are not guaranteed to be parsed in timestamp order, so
     // saturation has to be applied after we sort the captured window events.
     const totals = createEmptyUsageTotals();
+    const byModel = new Map();
     let sawBelowCap = false;
     let isExhausted = false;
     for (const event of [...events].sort((left, right) => left.eventTimeMs - right.eventTimeMs)) {
         sawBelowCap || (sawBelowCap = event.usedPercent < 100);
         if (!isExhausted) {
             addUsageTotals(totals, event.totals);
+            addWindowModelUsage(byModel, event.modelId, event.totals);
             if (sawBelowCap && event.usedPercent >= 100) {
                 isExhausted = true;
             }
         }
     }
-    return totals;
+    return {
+        totals,
+        modelUsage: buildModelUsageRows(byModel)
+    };
 }
-function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, deltaTotals) {
+function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, modelId, deltaTotals) {
     if (!window) {
         return;
     }
@@ -132,7 +146,7 @@ function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, deltaTota
             lastSeenMs: eventTimeMs,
             minUsedPercent: usedPercent,
             maxUsedPercent: usedPercent,
-            events: [{ eventTimeMs, usedPercent, totals: cloneUsageTotals(deltaTotals) }]
+            events: [{ eventTimeMs, modelId, usedPercent, totals: cloneUsageTotals(deltaTotals) }]
         });
         return;
     }
@@ -142,5 +156,25 @@ function upsertWindow(windows, scope, rateLimits, window, eventTimeMs, deltaTota
     existing.lastSeenMs = Math.max(existing.lastSeenMs, eventTimeMs);
     existing.minUsedPercent = Math.min(existing.minUsedPercent, usedPercent);
     existing.maxUsedPercent = Math.max(existing.maxUsedPercent, usedPercent);
-    existing.events.push({ eventTimeMs, usedPercent, totals: cloneUsageTotals(deltaTotals) });
+    existing.events.push({ eventTimeMs, modelId, usedPercent, totals: cloneUsageTotals(deltaTotals) });
+}
+function addWindowModelUsage(byModel, modelId, totals) {
+    const existing = byModel.get(modelId);
+    if (!existing) {
+        byModel.set(modelId, cloneUsageTotals(totals));
+        return;
+    }
+    addUsageTotals(existing, totals);
+}
+function buildModelUsageRows(byModel) {
+    return [...byModel.entries()]
+        .map(([modelId, totals]) => ({ modelId, totals }))
+        .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
+}
+function mergeModelUsageRows(left, right) {
+    const byModel = new Map();
+    for (const row of [...left, ...right]) {
+        addWindowModelUsage(byModel, row.modelId, row.totals);
+    }
+    return buildModelUsageRows(byModel);
 }

package/ink-app/dist/reporting.js

@@ -37,25 +37,23 @@ function buildAnonymousUsageReport(stats, window, letmecodeVersion) {
         used_percents: resolveReportedUsedPercents(window),
         used_exhausted: window.maxUsedPercent >= 100,
         value_dollars: roundDollars(window.totals.estimatedCredits * CREDIT_TO_DOLLARS),
-        usage_raw: buildUsageRaw(stats.providerId, window),
+        usage_raw: buildUsageRaw(window.modelUsage),
         letmecode_version: letmecodeVersion
     };
 }
-function buildUsageRaw(providerId, window) {
-    const usageRaw = {
-        output: window.totals.outputTokens,
-        input_non_cache: window.totals.inputTokens,
-        input_cache_read: window.totals.cacheReadInputTokens
-    };
-    if (isAnthropicProvider(providerId)) {
-        usageRaw.input_cache_w5m = window.totals.cacheWrite5mInputTokens;
-        usageRaw.input_cache_w1h = window.totals.cacheWrite1hInputTokens;
+function buildUsageRaw(modelUsage) {
+    const usageRaw = {};
+    for (const row of modelUsage) {
+        usageRaw[row.modelId] = {
+            output: row.totals.outputTokens,
+            input_non_cache: row.totals.inputTokens,
+            input_cache_w5m: row.totals.cacheWrite5mInputTokens,
+            input_cache_w1h: row.totals.cacheWrite1hInputTokens,
+            input_cache_read: row.totals.cacheReadInputTokens
+        };
     }
     return usageRaw;
 }
-function isAnthropicProvider(providerId) {
-    return providerId === "claude" || providerId === "claude-vscode";
-}
 function resolveReportedUsedPercents(window) {
     if (window.minUsedPercent === window.maxUsedPercent) {
         return clampPercent(window.maxUsedPercent);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letmecode",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Provider-based terminal usage dashboard for LetMeCode.",
   "author": "devforth.io",
   "license": "MIT",