letmecode 0.1.10 → 0.1.12

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

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

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

@@ -1,4 +1,5 @@
 import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
 import https from "node:https";
 import { createRequire } from "node:module";
 import fs from "node:fs";
@@ -70,6 +71,7 @@ const UNPRICED_MODELS = new Set([
 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_USER_STATUS_PATH = "/exa.language_server_pb.LanguageServerService/GetUserStatus";
 const ANTIGRAVITY_DEBUG_LOG_PATH = process.env.LETMECODE_ANTIGRAVITY_DEBUG_LOG ??
     path.join(os.tmpdir(), "letmecode-antigravity-debug.jsonl");
 const GEMINI_QUOTA_MODELS = [
@@ -170,7 +172,13 @@ export class AntigravityUsageProvider extends UsageProviderBase {
             dayUsage: buildDailyUsageRows(byDay),
             primaryLimitWindows: limitWindows.filter((window) => window.scope === "primary"),
             secondaryLimitWindows: limitWindows.filter((window) => window.scope === "secondary"),
-            warnings
+            warnings,
+            analytics: quotaSnapshot?.userIdHash
+                ? {
+                    agentName: normalizeAnalyticsAgentName(this.label),
+                    userIdHash: quotaSnapshot.userIdHash
+                }
+                : undefined
         };
     }
 }
@@ -199,11 +207,29 @@ async function collectAntigravityQuotaFromLocalRpc() {
         throw new Error("Antigravity local language server was not found.");
     }
     const fetchedAt = Date.now();
-    const payload = await readAntigravityQuotaSummary(server);
-    const entries = parseAntigravityQuotaEntries(payload);
+    const [quotaResult, statusResult] = await Promise.allSettled([
+        readAntigravityQuotaSummary(server),
+        readAntigravityUserStatus(server)
+    ]);
+    printAntigravityUserStatusResponse(statusResult);
+    if (quotaResult.status === "rejected") {
+        throw quotaResult.reason;
+    }
+    const entries = parseAntigravityQuotaEntries(quotaResult.value);
+    const planType = statusResult.status === "fulfilled"
+        ? parseAntigravityPlanType(statusResult.value)
+        : "unknown";
+    const userIdHash = statusResult.status === "fulfilled"
+        ? parseAntigravityUserIdHash(statusResult.value, normalizeAnalyticsAgentName("Antigravity"))
+        : null;
+    for (const entry of entries) {
+        entry.planType = planType;
+    }
     await writeAntigravityDebugEvent("quota-rpc-response", {
         port: server.port,
-        path: ANTIGRAVITY_QUOTA_SUMMARY_PATH,
+        quotaPath: ANTIGRAVITY_QUOTA_SUMMARY_PATH,
+        userStatusPath: ANTIGRAVITY_USER_STATUS_PATH,
+        planType,
         entries: entries.map((entry) => ({
             limitId: entry.limitId,
             remainingFraction: entry.remainingFraction,
@@ -212,13 +238,39 @@ async function collectAntigravityQuotaFromLocalRpc() {
             scope: entry.scope,
             modelIds: entry.modelIds
         })),
-        ...(isAntigravityRawDebugEnabled() ? { payload } : {})
+        ...(isAntigravityRawDebugEnabled()
+            ? {
+                quotaPayload: quotaResult.value,
+                userStatusPayload: statusResult.status === "fulfilled"
+                    ? statusResult.value
+                    : {
+                        error: statusResult.reason instanceof Error
+                            ? statusResult.reason.message
+                            : String(statusResult.reason)
+                    }
+            }
+            : {})
     });
     return {
         entries,
-        fetchedAt
+        fetchedAt,
+        userIdHash
     };
 }
+function printAntigravityUserStatusResponse(statusResult) {
+    try {
+        if (statusResult.status === "fulfilled") {
+            console.error("Antigravity user status response:", JSON.stringify(statusResult.value, null, 2));
+            return;
+        }
+        console.error("Antigravity user status response error:", statusResult.reason instanceof Error
+            ? statusResult.reason.message
+            : String(statusResult.reason));
+    }
+    catch {
+        // Debug printing must never disturb usage collection.
+    }
+}
 function recordsForQuotaWindow(quota, records) {
     if (quota.modelIds.length === 0) {
         return [];
@@ -458,13 +510,29 @@ async function probeAntigravityPorts(ports, csrfToken) {
 async function readAntigravityQuotaSummary(server) {
     return requestAntigravityQuotaSummary(server);
 }
+async function readAntigravityUserStatus(server) {
+    return requestAntigravityUserStatus(server);
+}
 function requestAntigravityQuotaSummary(server) {
-    const body = "{}";
+    return requestAntigravityRpc(server, ANTIGRAVITY_QUOTA_SUMMARY_PATH, {});
+}
+function requestAntigravityUserStatus(server) {
+    return requestAntigravityRpc(server, ANTIGRAVITY_USER_STATUS_PATH, {
+        metadata: {
+            ideName: "antigravity",
+            extensionName: "antigravity",
+            ideVersion: "unknown",
+            locale: "en"
+        }
+    });
+}
+function requestAntigravityRpc(server, rpcPath, payload) {
+    const body = JSON.stringify(payload);
     return new Promise((resolve, reject) => {
         const request = https.request({
             hostname: "127.0.0.1",
             port: server.port,
-            path: ANTIGRAVITY_QUOTA_SUMMARY_PATH,
+            path: rpcPath,
             method: "POST",
             timeout: 5000,
             agent: antigravityHttpsAgent,
@@ -481,7 +549,7 @@ function requestAntigravityQuotaSummary(server) {
             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"}`));
+                    reject(new Error(`Unexpected Antigravity RPC response from ${rpcPath}: ${response.statusCode ?? "unknown"}`));
                     return;
                 }
                 try {
@@ -493,7 +561,7 @@ function requestAntigravityQuotaSummary(server) {
             });
         });
         request.on("timeout", () => {
-            request.destroy(new Error("Timed out reading Antigravity quota summary."));
+            request.destroy(new Error(`Timed out reading Antigravity RPC ${rpcPath}.`));
         });
         request.on("error", reject);
         request.end(body);
@@ -550,6 +618,112 @@ export function parseAntigravityQuotaEntries(payload) {
     }
     return entries;
 }
+export function parseAntigravityPlanType(payload) {
+    const root = asRecord(payload);
+    const response = asRecord(root?.response);
+    const candidates = [
+        readNestedString(root, [
+            "userStatus",
+            "planStatus",
+            "planInfo",
+            "planName"
+        ]),
+        readNestedString(root, [
+            "userStatus",
+            "planStatus",
+            "planInfo",
+            "planDisplayName"
+        ]),
+        readNestedString(root, [
+            "userStatus",
+            "planStatus",
+            "planName"
+        ]),
+        readNestedString(root, [
+            "userStatus",
+            "planName"
+        ]),
+        readNestedString(response, [
+            "userStatus",
+            "planStatus",
+            "planInfo",
+            "planName"
+        ]),
+        readNestedString(response, [
+            "userStatus",
+            "planStatus",
+            "planInfo",
+            "planDisplayName"
+        ]),
+        readNestedString(response, [
+            "userStatus",
+            "planStatus",
+            "planName"
+        ]),
+        readNestedString(response, [
+            "userStatus",
+            "planName"
+        ]),
+        readNestedString(response, [
+            "planStatus",
+            "planInfo",
+            "planName"
+        ]),
+        readNestedString(response, [
+            "planInfo",
+            "planName"
+        ]),
+        readNestedString(response, ["planName"]),
+        readNestedString(root, ["planName"])
+    ];
+    const rawPlan = candidates.find((value) => Boolean(value));
+    return normalizeAntigravityPlanType(rawPlan ?? null);
+}
+export function parseAntigravityUserIdHash(payload, agentName) {
+    const root = asRecord(payload);
+    const response = asRecord(root?.response);
+    const email = readNestedString(root, ["userStatus", "email"]) ??
+        readNestedString(response, ["userStatus", "email"]) ??
+        readNestedString(root, ["email"]) ??
+        readNestedString(response, ["email"]);
+    return buildUserIdHash([agentName, email ?? ""]);
+}
+function readNestedString(value, pathParts) {
+    let current = value;
+    for (const part of pathParts) {
+        const record = asRecord(current);
+        if (!record) {
+            return null;
+        }
+        current = record[part];
+    }
+    return asString(current);
+}
+function normalizeAntigravityPlanType(value) {
+    if (!value) {
+        return "unknown";
+    }
+    const normalized = value.toLowerCase();
+    if (normalized.includes("ultra")) {
+        return "ultra";
+    }
+    if (normalized.includes("pro") || normalized.includes("premium")) {
+        return "pro";
+    }
+    if (normalized.includes("free") || normalized.includes("standard")) {
+        return "free";
+    }
+    return value;
+}
+function normalizeAnalyticsAgentName(label) {
+    return label.replace(/\s+/g, "");
+}
+function buildUserIdHash(parts) {
+    if (parts.some((part) => !part)) {
+        return null;
+    }
+    return createHash("md5").update(parts.join("-")).digest("hex");
+}
 function resolveQuotaWindow(window) {
     switch (window) {
         case "5h":

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

@@ -28,7 +28,6 @@ const VSCODE_CLAUDE_EXTENSION_PREFIX = "anthropic.claude-code-";
 const CLAUDE_SESSION_WINDOW_MINUTES = 5 * 60;
 const CLAUDE_WEEK_WINDOW_MINUTES = 7 * 24 * 60;
 const ANSI_ESCAPE_SEQUENCE = /\u001B\[[0-9;]*[A-Za-z]/g;
-const DEFAULT_CLAUDE_ENTRYPOINTS = ["sdk-cli", "claude"];
 const MONTH_INDEX_BY_LABEL = {
     jan: 0,
     feb: 1,
@@ -51,18 +50,16 @@ export class ClaudeUsageProvider extends UsageProviderBase {
     constructor(options = {}) {
         super(options.id ?? "claude", options.label ?? "Claude");
         this.root = path.resolve(options.root ?? os.homedir());
-        this.entrypoints = new Set(options.entrypoints ?? DEFAULT_CLAUDE_ENTRYPOINTS);
-        this.usageCommandKind = options.usageCommandKind ?? "cli";
         this.readUsageCommandOutput = options.readUsageCommandOutput;
         this.readAuthStatusOutput = options.readAuthStatusOutput;
         this.now = options.now ?? (() => new Date());
     }
     async getStats(options = {}) {
-        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);
+        traceClaude(options.traceLogger, `Starting stats collection with root=${this.root} (aggregating all Claude entrypoints).`);
+        const resolvedSessionsRoot = await resolveClaudeSessionsRoot(this.root, options.traceLogger);
         const sessionsRoot = resolvedSessionsRoot.rootPath;
         const agentName = normalizeAnalyticsAgentName(this.label);
-        const userIdHash = await readClaudeUserIdHash(this.root, this.usageCommandKind, this.readAuthStatusOutput, agentName, options.traceLogger);
+        const userIdHash = await readClaudeUserIdHash(this.root, this.readAuthStatusOutput, agentName, options.traceLogger);
         const byModel = new Map();
         const byDay = createDailyUsageAggregates();
         const windows = createLimitWindowAggregates();
@@ -75,16 +72,17 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             tokenEvents: 0,
             malformedLines: 0
         };
-        const parsedSessionFiles = await loadParsedClaudeSessionFiles(sessionsRoot, this.usageCommandKind, options.traceLogger);
-        traceClaude(options.traceLogger, this.usageCommandKind, `Loaded ${parsedSessionFiles.length} parsed session file(s) from ${sessionsRoot}.`);
+        const parsedSessionFiles = await loadParsedClaudeSessionFiles(sessionsRoot, options.traceLogger);
+        traceClaude(options.traceLogger, `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, [
+            const matchingEvents = file.events;
+            traceClaude(options.traceLogger, [
                 `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(" "));
@@ -102,7 +100,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             ...parsedEvents.keyedEvents.values(),
             ...parsedEvents.unkeyedEvents.values()
         ];
-        traceClaude(options.traceLogger, this.usageCommandKind, [
+        traceClaude(options.traceLogger, [
             `Transcript selection summary: filesWithMatches=${parseTotals.filesScanned}/${parsedSessionFiles.length}`,
             `selectedEvents=${selectedEvents.length}`,
             `duplicateUsageKeys=${parsedEvents.duplicateUsageKeys}`,
@@ -110,7 +108,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             `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))}.`);
+            traceClaude(options.traceLogger, "No assistant usage events were found in the parsed Claude session files.");
         }
         for (const event of selectedEvents) {
             addModelUsage(byModel, event.modelId, event.totals);
@@ -149,7 +147,6 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         const [fallbackPrimaryLimitWindows, fallbackSecondaryLimitWindows] = buildWindowLists(windows);
         const liveLimitWindows = await buildLiveLimitWindows({
             root: this.root,
-            usageCommandKind: this.usageCommandKind,
             readUsageCommandOutput: this.readUsageCommandOutput,
             readAuthStatusOutput: this.readAuthStatusOutput,
             traceLogger: options.traceLogger,
@@ -162,7 +159,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         const secondaryLimitWindows = liveLimitWindows.secondaryLimitWindows.length > 0
             ? liveLimitWindows.secondaryLimitWindows
             : fallbackSecondaryLimitWindows;
-        traceClaude(options.traceLogger, this.usageCommandKind, [
+        traceClaude(options.traceLogger, [
             `Finished stats collection:`,
             `filesScanned=${parseTotals.filesScanned}`,
             `linesRead=${parseTotals.linesRead}`,
@@ -274,14 +271,14 @@ function resolveClaudeCacheWriteBreakdown(usage) {
 function isSessionFile(filePath) {
     return filePath.endsWith(".jsonl");
 }
-async function resolveClaudeSessionsRoot(root, usageCommandKind, traceLogger) {
+async function resolveClaudeSessionsRoot(root, traceLogger) {
     const candidates = buildClaudeSessionsRootCandidates(root);
-    traceClaude(traceLogger, usageCommandKind, `Checking ${candidates.length} Claude session root candidate(s).`);
+    traceClaude(traceLogger, `Checking ${candidates.length} Claude session root candidate(s).`);
     for (const candidate of candidates) {
         const exists = await isDirectory(candidate.rootPath);
-        traceClaude(traceLogger, usageCommandKind, `Session root candidate ${candidate.rootLabel} -> ${candidate.rootPath} (${exists ? "exists" : "missing"}).`);
+        traceClaude(traceLogger, `Session root candidate ${candidate.rootLabel} -> ${candidate.rootPath} (${exists ? "exists" : "missing"}).`);
         if (exists) {
-            traceClaude(traceLogger, usageCommandKind, `Selected session root ${candidate.rootLabel} -> ${candidate.rootPath}.`);
+            traceClaude(traceLogger, `Selected session root ${candidate.rootLabel} -> ${candidate.rootPath}.`);
             return candidate;
         }
     }
@@ -289,7 +286,7 @@ async function resolveClaudeSessionsRoot(root, usageCommandKind, traceLogger) {
         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}.`);
+    traceClaude(traceLogger, `No session root candidate exists yet; defaulting to ${fallbackCandidate.rootLabel} -> ${fallbackCandidate.rootPath}.`);
     return fallbackCandidate;
 }
 function buildClaudeSessionsRootCandidates(root) {
@@ -378,32 +375,38 @@ async function* walkSessionFiles(directory) {
         }
     }
 }
-async function loadParsedClaudeSessionFiles(sessionsRoot, usageCommandKind, traceLogger) {
+async function loadParsedClaudeSessionFiles(sessionsRoot, traceLogger) {
     const cacheKey = path.resolve(sessionsRoot);
     const cached = parsedClaudeSessionFilesCache.get(cacheKey);
     if (cached) {
         const files = await cached;
-        traceClaude(traceLogger, usageCommandKind, `Session parse cache hit for ${sessionsRoot} (${files.length} file(s)).`);
+        traceClaude(traceLogger, `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}.`);
+        traceClaude(traceLogger, `Scanning session files under ${sessionsRoot}.`);
         for await (const filePath of walkSessionFiles(sessionsRoot)) {
-            files.push(await parseSessionFile(filePath));
+            files.push(await parseSessionFile(filePath, sessionsRoot));
         }
-        traceClaude(traceLogger, usageCommandKind, `Completed session file scan under ${sessionsRoot}: ${files.length} file(s) parsed.`);
+        inferClaudeSessionFileSources(files);
+        traceClaude(traceLogger, `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()) {
@@ -417,6 +420,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;
         }
@@ -427,12 +443,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,
@@ -441,7 +459,101 @@ async function parseSessionFile(filePath) {
             rateLimits
         });
     }
-    return { filePath, 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 ?? "");
@@ -515,12 +627,11 @@ function normalizeTimestamp(value) {
 function extractRateLimits(payloadObject, message) {
     return asRecord(payloadObject.rate_limits) ?? asRecord(message?.rate_limits);
 }
-function traceClaude(traceLogger, usageCommandKind, message) {
+function traceClaude(traceLogger, message) {
     if (!traceLogger) {
         return;
     }
-    const targetLabel = usageCommandKind === "vscode" ? "Claude VSCode" : "Claude";
-    traceLogger.log(`[${targetLabel}] ${message}`);
+    traceLogger.log(`[Claude] ${message}`);
 }
 function formatErrorMessage(error) {
     if (!error) {
@@ -569,9 +680,6 @@ function summarizeDistinctValues(values, limit = 5) {
         ? `${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,
@@ -580,16 +688,16 @@ function buildClaudeCommandEnvironment() {
 }
 async function buildLiveLimitWindows(options) {
     const [usageOutput, subscriptionType] = await Promise.all([
-        readClaudeUsageCommandOutput(options.root, options.usageCommandKind, options.readUsageCommandOutput, options.traceLogger),
-        readClaudeSubscriptionType(options.root, options.usageCommandKind, options.readAuthStatusOutput, options.traceLogger)
+        readClaudeUsageCommandOutput(options.root, options.readUsageCommandOutput, options.traceLogger),
+        readClaudeSubscriptionType(options.root, options.readAuthStatusOutput, options.traceLogger)
     ]);
     const snapshots = parseLiveUsageWindowSnapshots(usageOutput, options.now);
-    traceClaude(options.traceLogger, options.usageCommandKind, `Parsed ${snapshots.length} live usage snapshot(s) from /usage output.`);
+    traceClaude(options.traceLogger, `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.");
+        traceClaude(options.traceLogger, "No live usage snapshots matched the expected /usage format.");
     }
     const resolvedPlanType = subscriptionType || "live";
-    traceClaude(options.traceLogger, options.usageCommandKind, `Resolved live plan type ${resolvedPlanType}.`);
+    traceClaude(options.traceLogger, `Resolved live plan type ${resolvedPlanType}.`);
     const primaryLimitWindows = snapshots
         .filter((snapshot) => snapshot.scope === "primary")
         .map((snapshot) => buildLiveLimitWindowRow(snapshot, resolvedPlanType, options.selectedEvents, options.now));
@@ -604,7 +712,7 @@ async function buildLiveLimitWindows(options) {
         if (!row) {
             continue;
         }
-        traceClaude(options.traceLogger, options.usageCommandKind, [
+        traceClaude(options.traceLogger, [
             `Live window ${snapshot.scope}/${snapshot.label}:`,
             `used=${snapshot.usedPercent}%`,
             `range=${row.startTimeUtcIso}->${row.endTimeUtcIso}`,
@@ -620,41 +728,41 @@ async function buildLiveLimitWindows(options) {
         secondaryLimitWindows
     };
 }
-async function readClaudeSubscriptionType(root, usageCommandKind, override, traceLogger) {
-    const output = await readClaudeAuthStatusOutput(root, usageCommandKind, override, traceLogger);
+async function readClaudeSubscriptionType(root, override, traceLogger) {
+    const output = await readClaudeAuthStatusOutput(root, override, traceLogger);
     const subscriptionType = parseClaudeSubscriptionType(output);
     if (output && !subscriptionType) {
-        traceClaude(traceLogger, usageCommandKind, "Could not parse subscription type from auth status output.");
+        traceClaude(traceLogger, "Could not parse subscription type from auth status output.");
     }
-    traceClaude(traceLogger, usageCommandKind, `Subscription type result: ${subscriptionType ?? "<none>"}.`);
+    traceClaude(traceLogger, `Subscription type result: ${subscriptionType ?? "<none>"}.`);
     return subscriptionType;
 }
-async function readClaudeAuthStatusOutput(root, usageCommandKind, override, traceLogger) {
+async function readClaudeAuthStatusOutput(root, override, traceLogger) {
     if (override) {
         try {
             const output = await override();
-            traceClaude(traceLogger, usageCommandKind, "Using injected auth status output override.");
+            traceClaude(traceLogger, "Using injected auth status output override.");
             return output;
         }
         catch {
-            traceClaude(traceLogger, usageCommandKind, "Injected auth status output override failed.");
+            traceClaude(traceLogger, "Injected auth status output override failed.");
             return null;
         }
     }
-    const cacheKey = `${usageCommandKind}:${path.resolve(root)}`;
+    const cacheKey = path.resolve(root);
     const cached = claudeAuthStatusOutputCache.get(cacheKey);
     if (cached) {
-        traceClaude(traceLogger, usageCommandKind, "Auth status output cache hit.");
+        traceClaude(traceLogger, "Auth status output cache hit.");
         return cached;
     }
     const pending = (async () => {
-        const binaryPath = await resolveClaudeBinaryPath(root, usageCommandKind, traceLogger);
+        const binaryPath = await resolveClaudeBinaryPath(root, traceLogger);
         if (!binaryPath) {
-            traceClaude(traceLogger, usageCommandKind, "Skipping auth status command because no Claude binary was found.");
+            traceClaude(traceLogger, "Skipping auth status command because no Claude binary was found.");
             return null;
         }
         try {
-            traceClaude(traceLogger, usageCommandKind, `Running auth status command with ${binaryPath} (TZ=UTC).`);
+            traceClaude(traceLogger, `Running auth status command with ${binaryPath} (TZ=UTC).`);
             const { stdout, stderr } = await execFileAsync(binaryPath, ["auth", "status"], {
                 encoding: "utf8",
                 env: buildClaudeCommandEnvironment(),
@@ -663,12 +771,12 @@ async function readClaudeAuthStatusOutput(root, usageCommandKind, override, trac
                 windowsHide: true
             });
             const combined = [stdout, stderr].filter(Boolean).join("\n").trim();
-            traceClaude(traceLogger, usageCommandKind, "Auth status command completed successfully.");
+            traceClaude(traceLogger, "Auth status command completed successfully.");
             return combined || null;
         }
         catch (error) {
             const combined = extractExecOutput(error);
-            traceClaude(traceLogger, usageCommandKind, `Auth status command failed: ${formatErrorMessage(error)}.`);
+            traceClaude(traceLogger, `Auth status command failed: ${formatErrorMessage(error)}.`);
             return combined || null;
         }
     })();
@@ -705,43 +813,43 @@ function parseClaudeAuthStatusSnapshot(output) {
         return null;
     }
 }
-async function readClaudeUserIdHash(root, usageCommandKind, override, agentName, traceLogger) {
-    const authStatusOutput = await readClaudeAuthStatusOutput(root, usageCommandKind, override, traceLogger);
+async function readClaudeUserIdHash(root, override, agentName, traceLogger) {
+    const authStatusOutput = await readClaudeAuthStatusOutput(root, override, traceLogger);
     const snapshot = parseClaudeAuthStatusSnapshot(authStatusOutput);
     if (!snapshot) {
-        traceClaude(traceLogger, usageCommandKind, "Auth status output did not yield an analytics identity snapshot.");
+        traceClaude(traceLogger, "Auth status output did not yield an analytics identity snapshot.");
         return null;
     }
     return buildUserIdHash([agentName, snapshot.email, snapshot.orgId, snapshot.orgName]);
 }
-async function readClaudeUsageCommandOutput(root, usageCommandKind, override, traceLogger) {
+async function readClaudeUsageCommandOutput(root, override, traceLogger) {
     if (override) {
         try {
             const output = await override();
-            traceClaude(traceLogger, usageCommandKind, "Using injected /usage output override.");
-            traceClaude(traceLogger, usageCommandKind, `Usage returned:\n${describeUsageOutput(output)}`);
+            traceClaude(traceLogger, "Using injected /usage output override.");
+            traceClaude(traceLogger, `Usage returned:\n${describeUsageOutput(output)}`);
             return output;
         }
         catch {
-            traceClaude(traceLogger, usageCommandKind, "Injected /usage output override failed.");
+            traceClaude(traceLogger, "Injected /usage output override failed.");
             return null;
         }
     }
-    const cacheKey = `${usageCommandKind}:${path.resolve(root)}`;
+    const cacheKey = path.resolve(root);
     const cached = claudeUsageOutputCache.get(cacheKey);
     if (cached) {
-        traceClaude(traceLogger, usageCommandKind, "Usage output cache hit.");
+        traceClaude(traceLogger, "Usage output cache hit.");
         return cached;
     }
     const pending = (async () => {
-        const binaryPath = await resolveClaudeBinaryPath(root, usageCommandKind, traceLogger);
+        const binaryPath = await resolveClaudeBinaryPath(root, traceLogger);
         if (!binaryPath) {
-            traceClaude(traceLogger, usageCommandKind, "Skipping /usage command because no Claude binary was found.");
-            traceClaude(traceLogger, usageCommandKind, "Usage returned:\n<not available>");
+            traceClaude(traceLogger, "Skipping /usage command because no Claude binary was found.");
+            traceClaude(traceLogger, "Usage returned:\n<not available>");
             return null;
         }
         try {
-            traceClaude(traceLogger, usageCommandKind, `Running /usage command with ${binaryPath} (TZ=UTC).`);
+            traceClaude(traceLogger, `Running /usage command with ${binaryPath} (TZ=UTC).`);
             const { stdout, stderr } = await execFileAsync(binaryPath, ["-p", "/usage"], {
                 encoding: "utf8",
                 env: buildClaudeCommandEnvironment(),
@@ -750,14 +858,14 @@ async function readClaudeUsageCommandOutput(root, usageCommandKind, override, tr
                 windowsHide: true
             });
             const combined = [stdout, stderr].filter(Boolean).join("\n").trim();
-            traceClaude(traceLogger, usageCommandKind, "Usage command completed successfully.");
-            traceClaude(traceLogger, usageCommandKind, `Usage returned:\n${describeUsageOutput(combined || null)}`);
+            traceClaude(traceLogger, "Usage command completed successfully.");
+            traceClaude(traceLogger, `Usage returned:\n${describeUsageOutput(combined || null)}`);
             return combined || null;
         }
         catch (error) {
             const combined = extractExecOutput(error);
-            traceClaude(traceLogger, usageCommandKind, `Usage command failed: ${formatErrorMessage(error)}.`);
-            traceClaude(traceLogger, usageCommandKind, `Usage returned:\n${describeUsageOutput(combined || null)}`);
+            traceClaude(traceLogger, `Usage command failed: ${formatErrorMessage(error)}.`);
+            traceClaude(traceLogger, `Usage returned:\n${describeUsageOutput(combined || null)}`);
             return combined || null;
         }
     })();
@@ -772,68 +880,68 @@ function extractExecOutput(error) {
     const stderr = typeof error.stderr === "string" ? error.stderr : "";
     return [stdout, stderr].filter(Boolean).join("\n").trim();
 }
-async function resolveClaudeBinaryPath(root, usageCommandKind, traceLogger) {
-    const cacheKey = `${usageCommandKind}:${path.resolve(root)}`;
+async function resolveClaudeBinaryPath(root, traceLogger) {
+    const cacheKey = path.resolve(root);
     const cached = claudeBinaryPathCache.get(cacheKey);
     if (cached) {
         const binaryPath = await cached;
-        traceClaude(traceLogger, usageCommandKind, `Binary detection cache hit: ${binaryPath ? `found ${binaryPath}` : "not found"}.`);
+        traceClaude(traceLogger, `Binary detection cache hit: ${binaryPath ? `found ${binaryPath}` : "not found"}.`);
         return binaryPath;
     }
     const pending = (async () => {
-        traceClaude(traceLogger, usageCommandKind, `Starting binary detection under ${root}.`);
-        const binaryPath = usageCommandKind === "vscode"
-            ? await resolveVsCodeClaudeBinaryPath(root, traceLogger)
-            : await resolveCliClaudeBinaryPath(root, traceLogger);
-        traceClaude(traceLogger, usageCommandKind, `Binary detection result: ${binaryPath ? `found ${binaryPath}` : "not found"}.`);
+        traceClaude(traceLogger, `Starting binary detection under ${root}.`);
+        const binaryPath = await resolveMergedClaudeBinaryPath(root, traceLogger);
+        traceClaude(traceLogger, `Binary detection result: ${binaryPath ? `found ${binaryPath}` : "not found"}.`);
         return binaryPath;
     })();
     claudeBinaryPathCache.set(cacheKey, pending);
     return pending;
 }
-async function resolveVsCodeClaudeBinaryPath(root, traceLogger) {
+async function resolveMergedClaudeBinaryPath(root, traceLogger) {
+    const candidates = [
+        ...(await resolveVsCodeClaudeBinaryCandidates(root, traceLogger)),
+        ...resolveDirectClaudeBinaryCandidates(root)
+    ];
+    for (const candidate of candidates) {
+        const accessCheck = await checkReadableExecutableFile(candidate);
+        traceClaude(traceLogger, `Checked ${candidate} -> ${accessCheck.ok ? "success" : `failure (${accessCheck.errorMessage ?? "unknown"})`}.`);
+        if (accessCheck.ok) {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function resolveVsCodeClaudeBinaryCandidates(root, traceLogger) {
     const boosterDirectories = [
         path.join(root, ".vscode", "extensions"),
         path.join(root, ".vscode-server", "extensions"),
         path.join(root, ".vscode-server-insiders", "extensions")
     ];
-    let firstFoundPath = null;
+    const candidates = [];
     for (const directory of boosterDirectories) {
-        const binaryPath = await resolveClaudeBinaryFromExtensionDirectory(directory, traceLogger);
-        if (!firstFoundPath && binaryPath) {
-            firstFoundPath = binaryPath;
-        }
+        candidates.push(...(await resolveClaudeBinaryCandidatesFromExtensionDirectory(directory, traceLogger)));
     }
-    return firstFoundPath;
+    return candidates;
 }
-async function resolveClaudeBinaryFromExtensionDirectory(directory, traceLogger) {
+async function resolveClaudeBinaryCandidatesFromExtensionDirectory(directory, traceLogger) {
     let entries;
-    traceClaude(traceLogger, "vscode", `Scanning extension directory ${directory}.`);
+    traceClaude(traceLogger, `Scanning extension directory ${directory}.`);
     try {
         entries = await fs.promises.readdir(directory, { withFileTypes: true });
     }
     catch (error) {
-        traceClaude(traceLogger, "vscode", `Could not read ${directory}: ${formatErrorMessage(error)}.`);
-        return null;
+        traceClaude(traceLogger, `Could not read ${directory}: ${formatErrorMessage(error)}.`);
+        return [];
     }
     const candidates = entries
         .filter((entry) => entry.isDirectory() && entry.name.startsWith(VSCODE_CLAUDE_EXTENSION_PREFIX))
         .map((entry) => entry.name)
         .sort(compareClaudeExtensionDirectoryNames);
     if (candidates.length === 0) {
-        traceClaude(traceLogger, "vscode", `No Claude VSCode extension candidates found in ${directory}.`);
-        return null;
-    }
-    let firstFoundPath = null;
-    for (const candidate of candidates) {
-        const binaryPath = path.join(directory, candidate, "resources", "native-binary", "claude");
-        const accessCheck = await checkReadableExecutableFile(binaryPath);
-        traceClaude(traceLogger, "vscode", `Checked ${binaryPath} -> ${accessCheck.ok ? "success" : `failure (${accessCheck.errorMessage ?? "unknown"})`}.`);
-        if (!firstFoundPath && accessCheck.ok) {
-            firstFoundPath = binaryPath;
-        }
+        traceClaude(traceLogger, `No Claude VSCode extension candidates found in ${directory}.`);
+        return [];
     }
-    return firstFoundPath;
+    return candidates.map((candidate) => path.join(directory, candidate, "resources", "native-binary", "claude"));
 }
 function compareClaudeExtensionDirectoryNames(left, right) {
     const leftVersion = extractClaudeExtensionVersion(left);
@@ -857,20 +965,11 @@ function extractClaudeExtensionVersion(directoryName) {
         .map((part) => Number(part))
         .filter((part) => Number.isFinite(part));
 }
-async function resolveCliClaudeBinaryPath(root, traceLogger) {
-    const directCandidates = [
+function resolveDirectClaudeBinaryCandidates(root) {
+    return [
         path.join(root, ".local", "bin", "claude"),
         path.join(root, "bin", "claude")
     ];
-    let firstFoundPath = null;
-    for (const candidate of directCandidates) {
-        const accessCheck = await checkReadableExecutableFile(candidate);
-        traceClaude(traceLogger, "cli", `Checked ${candidate} -> ${accessCheck.ok ? "success" : `failure (${accessCheck.errorMessage ?? "unknown"})`}.`);
-        if (!firstFoundPath && accessCheck.ok) {
-            firstFoundPath = candidate;
-        }
-    }
-    return firstFoundPath;
 }
 async function checkReadableExecutableFile(filePath) {
     try {

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

@@ -6,12 +6,6 @@ export function createProviders() {
     return [
         new CodexUsageProvider(),
         new ClaudeUsageProvider(),
-        new ClaudeUsageProvider({
-            id: "claude-vscode",
-            label: "Claude VSCode",
-            entrypoints: ["claude-vscode"],
-            usageCommandKind: "vscode"
-        }),
         new CopilotUsageProvider(),
         new AntigravityUsageProvider()
     ];

package/ink-app/dist/reporting.js

@@ -29,6 +29,7 @@ export async function buildAnonymousUsagePayload(statsList) {
 function buildAnonymousUsageReport(stats, window, letmecodeVersion) {
     return {
         agent: stats.analytics?.agentName ?? stats.providerLabel.replace(/\s+/g, ""),
+        model_type: resolveReportModelType(stats, window),
         userid_hash: stats.analytics?.userIdHash ?? "",
         plan_id: window.planType,
         window_duration_seconds: window.windowMinutes * 60,
@@ -41,6 +42,31 @@ function buildAnonymousUsageReport(stats, window, letmecodeVersion) {
         letmecode_version: letmecodeVersion
     };
 }
+function resolveReportModelType(stats, window) {
+    if (stats.providerId === "antigravity") {
+        return resolveAntigravityReportModelType(stats, window);
+    }
+    if (window.limitId && window.limitId !== "unknown") {
+        return truncateSchemaString(window.limitId, 128);
+    }
+    if (window.modelUsage.length === 1) {
+        return truncateSchemaString(window.modelUsage[0]?.modelId ?? stats.providerId, 128);
+    }
+    return truncateSchemaString(stats.providerId, 128);
+}
+function resolveAntigravityReportModelType(stats, window) {
+    const limitId = window.limitId.toLowerCase();
+    if (limitId.includes("gemini")) {
+        return "gemini";
+    }
+    if (limitId.startsWith("3p") || limitId.includes("third-party")) {
+        return "third-party";
+    }
+    return truncateSchemaString(window.limitId || stats.providerId, 128);
+}
+function truncateSchemaString(value, maxLength) {
+    return value.length > maxLength ? value.slice(0, maxLength) : value;
+}
 function buildUsageRaw(modelUsage) {
     const usageRaw = {};
     for (const row of modelUsage) {
@@ -61,7 +87,10 @@ function resolveReportedUsedPercents(window) {
     return clampPercent(window.maxUsedPercent - window.minUsedPercent);
 }
 function clampPercent(value) {
-    return Math.max(0, Math.min(100, Math.round(value)));
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.min(100, value));
 }
 function roundDollars(value) {
     return Number(value.toFixed(6));

package/package.json

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