letmecode 0.1.9 → 0.1.11

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,20 @@ 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));
+            const matchingEvents = file.events.filter((event) => matchesClaudeProviderEvent(event, file, this.entrypoints, this.usageCommandKind));
+            traceClaude(options.traceLogger, this.usageCommandKind, [
+                `Session file ${describeSessionFilePath(sessionsRoot, file.filePath)}:`,
+                `lines=${file.linesRead}`,
+                `malformed=${file.malformedLines}`,
+                `assistantUsageEvents=${file.events.length}`,
+                `matchingEvents=${matchingEvents.length}`,
+                `source=${file.sourceKind}`,
+                `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,6 +103,16 @@ 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;
@@ -141,6 +163,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 +275,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,28 +379,38 @@ 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));
+            files.push(await parseSessionFile(filePath, sessionsRoot));
         }
+        inferClaudeSessionFileSources(files);
+        traceClaude(traceLogger, usageCommandKind, `Completed session file scan under ${sessionsRoot}: ${files.length} file(s) parsed.`);
         return files;
     })();
     parsedClaudeSessionFilesCache.set(cacheKey, pending);
     return pending;
 }
-async function parseSessionFile(filePath) {
+async function parseSessionFile(filePath, sessionsRoot) {
     const stream = fs.createReadStream(filePath, { encoding: "utf8" });
     const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let linesRead = 0;
     let malformedLines = 0;
     const events = [];
+    const assistantEntryPoints = new Set();
+    let hasIdeOpenedFileAttachment = false;
+    let hasIdeOpenedFileMarker = false;
+    let hasIdeTooling = false;
+    let hasQueueOperations = false;
     for await (const line of lineReader) {
         linesRead += 1;
         if (!line.trim()) {
@@ -373,6 +424,19 @@ async function parseSessionFile(filePath) {
             malformedLines += 1;
             continue;
         }
+        if (payloadObject.type === "queue-operation") {
+            hasQueueOperations = true;
+        }
+        if (messageContainsIdeOpenedFileMarker(asRecord(payloadObject.message))) {
+            hasIdeOpenedFileMarker = true;
+        }
+        const attachment = asRecord(payloadObject.attachment);
+        if (attachment?.type === "opened_file_in_ide") {
+            hasIdeOpenedFileAttachment = true;
+        }
+        if (attachmentHasIdeTooling(attachment)) {
+            hasIdeTooling = true;
+        }
         if (payloadObject.type !== "assistant") {
             continue;
         }
@@ -383,12 +447,14 @@ async function parseSessionFile(filePath) {
         }
         const modelId = String(message?.model ?? "unknown");
         const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));
+        const entrypoint = typeof payloadObject.entrypoint === "string" ? payloadObject.entrypoint : "";
         const rateLimits = extractRateLimits(payloadObject, message);
         const normalizedUsage = normalizeUsage(usage);
         const usageKey = buildUsageEventKey(payloadObject, message);
         const usageSignature = buildUsageSignature(payloadObject, modelId, normalizedUsage);
+        assistantEntryPoints.add(entrypoint);
         events.push({
-            entrypoint: typeof payloadObject.entrypoint === "string" ? payloadObject.entrypoint : "",
+            entrypoint,
             usageKey,
             usageSignature,
             timestampMs: eventTimeMs,
@@ -397,7 +463,101 @@ async function parseSessionFile(filePath) {
             rateLimits
         });
     }
-    return { linesRead, malformedLines, events };
+    return {
+        filePath,
+        sessionGroupKey: buildClaudeSessionGroupKey(sessionsRoot, filePath),
+        linesRead,
+        malformedLines,
+        sourceKind: "unknown",
+        sourceReason: "unclassified",
+        signals: {
+            assistantEntryPoints: [...assistantEntryPoints].sort(),
+            hasIdeOpenedFileAttachment,
+            hasIdeOpenedFileMarker,
+            hasIdeTooling,
+            hasQueueOperations
+        },
+        events
+    };
+}
+function buildClaudeSessionGroupKey(sessionsRoot, filePath) {
+    const relativePath = path.relative(sessionsRoot, filePath);
+    if (!relativePath || relativePath.startsWith("..")) {
+        return filePath;
+    }
+    const normalizedRelativePath = relativePath.split(path.sep).join("/");
+    const subagentMatch = normalizedRelativePath.match(/^(.*\/[^/]+)\/subagents\/[^/]+\.jsonl$/);
+    if (subagentMatch?.[1]) {
+        return subagentMatch[1];
+    }
+    return normalizedRelativePath.replace(/\.jsonl$/i, "");
+}
+function inferClaudeSessionFileSources(files) {
+    const groups = new Map();
+    for (const file of files) {
+        const group = groups.get(file.sessionGroupKey) ?? {
+            assistantEntryPoints: new Set(),
+            hasIdeHints: false
+        };
+        for (const entrypoint of file.signals.assistantEntryPoints) {
+            group.assistantEntryPoints.add(entrypoint);
+        }
+        group.hasIdeHints =
+            group.hasIdeHints ||
+                file.signals.hasIdeOpenedFileAttachment ||
+                file.signals.hasIdeOpenedFileMarker ||
+                file.signals.hasIdeTooling ||
+                file.signals.hasQueueOperations;
+        groups.set(file.sessionGroupKey, group);
+    }
+    for (const file of files) {
+        const group = groups.get(file.sessionGroupKey);
+        const { kind, reason } = classifyClaudeSessionGroup(group);
+        file.sourceKind = kind;
+        file.sourceReason = reason;
+    }
+}
+function classifyClaudeSessionGroup(group) {
+    if (!group) {
+        return { kind: "unknown", reason: "missing session group signals" };
+    }
+    if (group.assistantEntryPoints.has("claude-vscode")) {
+        return { kind: "vscode", reason: "explicit claude-vscode entrypoint" };
+    }
+    if (group.assistantEntryPoints.has("sdk-cli") || group.assistantEntryPoints.has("claude")) {
+        return { kind: "cli", reason: "explicit sdk-cli/claude entrypoint" };
+    }
+    if (group.assistantEntryPoints.has("cli")) {
+        return group.hasIdeHints
+            ? { kind: "vscode", reason: "generic cli entrypoint with IDE session hints" }
+            : { kind: "cli", reason: "generic cli entrypoint without IDE session hints" };
+    }
+    return { kind: "unknown", reason: "no assistant entrypoints" };
+}
+function attachmentHasIdeTooling(attachment) {
+    if (attachment?.type !== "deferred_tools_delta") {
+        return false;
+    }
+    return extractStringArray(attachment.addedNames).some((name) => name.startsWith("mcp__ide__"));
+}
+function messageContainsIdeOpenedFileMarker(message) {
+    const content = message?.content;
+    if (typeof content === "string") {
+        return content.includes("<ide_opened_file>");
+    }
+    if (!Array.isArray(content)) {
+        return false;
+    }
+    return content.some((item) => {
+        const contentItem = asRecord(item);
+        return typeof contentItem?.text === "string" && contentItem.text.includes("<ide_opened_file>");
+    });
+}
+function extractStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "string");
 }
 function buildUsageEventKey(payloadObject, message) {
     const sessionId = String(payloadObject.sessionId ?? "");
@@ -465,6 +625,18 @@ function shouldReplaceUsageEvent(previous, next) {
     }
     return false;
 }
+function matchesClaudeProviderEvent(event, file, entrypoints, usageCommandKind) {
+    if (entrypoints.has(event.entrypoint)) {
+        return true;
+    }
+    if (event.entrypoint !== "cli") {
+        return false;
+    }
+    if (usageCommandKind === "vscode") {
+        return file.sourceKind === "vscode";
+    }
+    return file.sourceKind === "cli";
+}
 function normalizeTimestamp(value) {
     return Number.isFinite(value) ? value : Number.NEGATIVE_INFINITY;
 }
@@ -493,6 +665,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 +713,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 +837,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]);

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/package.json

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