letmecode 0.1.19 → 0.1.21

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

@@ -82,7 +82,6 @@ export class ClaudeUsageProvider extends UsageProviderBase {
                 `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(" "));
@@ -125,7 +124,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             warnings.push(`Collapsed ${parsedEvents.duplicateUsageKeys} duplicate Claude usage event(s) by request/message key.`);
         }
         if (options.verbose && parsedEvents.duplicateUsageKeyCollisions > 0) {
-            warnings.push(`Detected ${parsedEvents.duplicateUsageKeyCollisions} Claude usage key collision(s) with different token usage; merged same-key rows by per-field maxima to avoid double-counting cumulative snapshots.`);
+            warnings.push(`Detected ${parsedEvents.duplicateUsageKeyCollisions} Claude usage key collision(s) with different token usage; kept the most complete same-key snapshot to avoid double-counting cumulative snapshots.`);
         }
         if (options.verbose && parsedEvents.duplicateUnkeyedEvents > 0) {
             warnings.push(`Collapsed ${parsedEvents.duplicateUnkeyedEvents} adjacent duplicate unkeyed Claude usage event(s) by usage signature.`);
@@ -387,26 +386,20 @@ async function loadParsedClaudeSessionFiles(sessionsRoot, traceLogger) {
         const files = [];
         traceClaude(traceLogger, `Scanning session files under ${sessionsRoot}.`);
         for await (const filePath of walkSessionFiles(sessionsRoot)) {
-            files.push(await parseSessionFile(filePath, sessionsRoot));
+            files.push(await parseSessionFile(filePath));
         }
-        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, sessionsRoot) {
+async function parseSessionFile(filePath) {
     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()) {
@@ -420,19 +413,6 @@ async function parseSessionFile(filePath, sessionsRoot) {
             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;
         }
@@ -448,7 +428,6 @@ async function parseSessionFile(filePath, sessionsRoot) {
         const normalizedUsage = normalizeUsage(usage);
         const usageKeys = buildUsageEventKeys(payloadObject, message);
         const usageSignature = buildUsageSignature(payloadObject, modelId, normalizedUsage);
-        assistantEntryPoints.add(entrypoint);
         events.push({
             entrypoint,
             filePath,
@@ -464,100 +443,11 @@ async function parseSessionFile(filePath, sessionsRoot) {
     }
     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 buildUsageEventKeys(payloadObject, message) {
     const sessionId = String(payloadObject.sessionId ?? "");
     const requestId = typeof payloadObject.requestId === "string" ? payloadObject.requestId : "";
@@ -637,8 +527,14 @@ function recordParsedUsageEvent(parsedEvents, event) {
     }
 }
 function mergeParsedUsageEvents(previous, next) {
-    const mergedUsage = mergeClaudeUsage(previous.usage, next.usage);
-    const modelId = selectMergedEventModelId(previous, next);
+    // Same-key events are repeated/streamed snapshots of one logical request. Rather than
+    // synthesizing a field-wise maximum (which can fabricate token totals when a snapshot
+    // splits cache-write tokens across the 5m/1h buckets differently), keep the single most
+    // complete real snapshot and discard the rest.
+    const primaryEvent = selectMergedSnapshotEvent(previous, next);
+    const otherEvent = primaryEvent === previous ? next : previous;
+    const usage = primaryEvent.usage;
+    const modelId = selectMergedEventModelId(primaryEvent, otherEvent);
     const latestEvent = normalizeTimestamp(next.timestampMs) >= normalizeTimestamp(previous.timestampMs) ? next : previous;
     const sessionId = extractUsageKeySessionId(previous.usageKeys) || extractUsageKeySessionId(next.usageKeys);
     return {
@@ -646,38 +542,34 @@ function mergeParsedUsageEvents(previous, next) {
         filePath: latestEvent.filePath,
         lineNumber: latestEvent.lineNumber,
         usageKeys: [...new Set([...previous.usageKeys, ...next.usageKeys])],
-        usageSignature: buildUsageSignatureFromParts(sessionId, modelId, mergedUsage),
+        usageSignature: buildUsageSignatureFromParts(sessionId, modelId, usage),
         timestampMs: Math.max(normalizeTimestamp(previous.timestampMs), normalizeTimestamp(next.timestampMs)),
         modelId,
-        usage: mergedUsage,
-        totals: usageToTotals(modelId, mergedUsage),
+        usage,
+        totals: usageToTotals(modelId, usage),
         rateLimits: latestEvent.rateLimits ?? previous.rateLimits ?? next.rateLimits
     };
 }
-function mergeClaudeUsage(previous, next) {
-    return {
-        inputTokens: Math.max(previous.inputTokens, next.inputTokens),
-        cacheReadInputTokens: Math.max(previous.cacheReadInputTokens, next.cacheReadInputTokens),
-        cacheCreationInputTokens: Math.max(previous.cacheCreationInputTokens, next.cacheCreationInputTokens),
-        cacheCreation5mInputTokens: Math.max(previous.cacheCreation5mInputTokens, next.cacheCreation5mInputTokens),
-        cacheCreation1hInputTokens: Math.max(previous.cacheCreation1hInputTokens, next.cacheCreation1hInputTokens),
-        outputTokens: Math.max(previous.outputTokens, next.outputTokens),
-        inferenceGeo: next.inferenceGeo || previous.inferenceGeo
-    };
-}
-function selectMergedEventModelId(previous, next) {
-    if (previous.modelId === next.modelId) {
-        return previous.modelId;
+// Pick the snapshot that carries the most usage. Cumulative snapshots are monotonic, so the
+// largest total is the final state; this also keeps a real synthetic-followup row (0 tokens)
+// from clobbering the real usage it follows. Ties fall back to the later, then the earlier-seen
+// event for deterministic output.
+function selectMergedSnapshotEvent(previous, next) {
+    if (next.totals.totalTokens !== previous.totals.totalTokens) {
+        return next.totals.totalTokens > previous.totals.totalTokens ? next : previous;
     }
-    if (isInternalClaudeModel(previous.modelId) && !isInternalClaudeModel(next.modelId)) {
-        return next.modelId;
+    return normalizeTimestamp(next.timestampMs) > normalizeTimestamp(previous.timestampMs) ? next : previous;
+}
+function selectMergedEventModelId(primary, other) {
+    if (primary.modelId === other.modelId) {
+        return primary.modelId;
     }
-    if (isInternalClaudeModel(next.modelId) && !isInternalClaudeModel(previous.modelId)) {
-        return previous.modelId;
+    // The chosen snapshot's own model is authoritative, except when it is the internal
+    // <synthetic> placeholder and the other event names a real, priceable model.
+    if (isInternalClaudeModel(primary.modelId) && !isInternalClaudeModel(other.modelId)) {
+        return other.modelId;
     }
-    return next.totals.estimatedCredits >= previous.totals.estimatedCredits
-        ? next.modelId
-        : previous.modelId;
+    return primary.modelId;
 }
 function canCollapseAdjacentUnkeyedUsageEvents(previous, next) {
     return previous.filePath === next.filePath && next.lineNumber === previous.lineNumber + 1;
@@ -1063,34 +955,58 @@ function parseLiveUsageWindowSnapshots(usageOutput, now) {
     if (!usageOutput) {
         return [];
     }
-    const snapshots = new Map();
     const normalizedOutput = usageOutput.replace(ANSI_ESCAPE_SEQUENCE, "");
+    const parsedLines = [];
     for (const line of normalizedOutput.split(/\r?\n/)) {
         const match = line
             .trim()
-            .match(/^Current\s+(session|week)(?:\s+\(([^)]+)\))?:\s+(\d+)%\s+used\b.*?\bresets\s+(.+)$/i);
+            .match(/^Current\s+(session|week)(?:\s+\(([^)]+)\))?:\s+(\d+)%\s+used\b(?:.*?\bresets\s+(.+))?$/i);
         if (!match) {
             continue;
         }
-        const label = match[1].toLowerCase() === "session" ? "session" : "week";
-        const windowQualifier = (match[2] ?? "").trim().toLowerCase();
         const usedPercent = Number(match[3]);
-        const windowMinutes = label === "session" ? CLAUDE_SESSION_WINDOW_MINUTES : CLAUDE_WEEK_WINDOW_MINUTES;
-        const resetsAtMs = parseResetTimestampUtc(match[4], now.getTime(), windowMinutes);
-        if (!Number.isFinite(usedPercent) || !resetsAtMs) {
+        if (!Number.isFinite(usedPercent)) {
             continue;
         }
-        const isSonnetOnlyWeek = label === "week" && windowQualifier === "sonnet only";
-        const limitId = isSonnetOnlyWeek ? "current-week-sonnet-only" : `current-${label}`;
-        snapshots.set(limitId, {
-            scope: label === "session" ? "primary" : "secondary",
+        const label = match[1].toLowerCase() === "session" ? "session" : "week";
+        parsedLines.push({
             label,
+            windowQualifier: (match[2] ?? "").trim().toLowerCase(),
+            usedPercent,
+            windowMinutes: label === "session" ? CLAUDE_SESSION_WINDOW_MINUTES : CLAUDE_WEEK_WINDOW_MINUTES,
+            resetString: match[4]?.trim() || null
+        });
+    }
+    // Per-scope reset times printed by Claude. Lines like "Current week (Sonnet
+    // only)" omit the reset because it is identical to the "all models" week, so
+    // a missing reset inherits the resolved reset of the same scope.
+    const resetMsByLabel = new Map();
+    for (const parsed of parsedLines) {
+        if (!parsed.resetString || resetMsByLabel.has(parsed.label)) {
+            continue;
+        }
+        const resetsAtMs = parseResetTimestampUtc(parsed.resetString, now.getTime(), parsed.windowMinutes);
+        if (resetsAtMs) {
+            resetMsByLabel.set(parsed.label, resetsAtMs);
+        }
+    }
+    const snapshots = new Map();
+    for (const parsed of parsedLines) {
+        const resetsAtMs = resetMsByLabel.get(parsed.label) ?? null;
+        if (!resetsAtMs) {
+            continue;
+        }
+        const isSonnetOnlyWeek = parsed.label === "week" && parsed.windowQualifier === "sonnet only";
+        const limitId = isSonnetOnlyWeek ? "current-week-sonnet-only" : `current-${parsed.label}`;
+        snapshots.set(limitId, {
+            scope: parsed.label === "session" ? "primary" : "secondary",
+            label: parsed.label,
             limitId,
             modelScope: isSonnetOnlyWeek ? "sonnet-only" : "all-models",
             modelType: isSonnetOnlyWeek ? "sonnet only" : undefined,
-            usedPercent,
+            usedPercent: parsed.usedPercent,
             resetsAtMs,
-            windowMinutes
+            windowMinutes: parsed.windowMinutes
         });
     }
     return [...snapshots.values()].sort((left, right) => left.windowMinutes - right.windowMinutes || left.limitId.localeCompare(right.limitId));
@@ -1147,6 +1063,9 @@ function buildLiveLimitWindowRow(snapshot, planType, selectedEvents, now) {
         event.timestampMs < snapshot.resetsAtMs &&
         matchesClaudeLiveSnapshotModelScope(snapshot, event.modelId));
     const totals = sumUsageTotals(inWindowEvents.map((event) => event.totals));
+    if (snapshot.usedPercent > 0 && totals.eventCount === 0) {
+        totals.estimatedCreditsStatus = "unavailable";
+    }
     const fallbackLastSeenMs = Math.min(now.getTime(), snapshot.resetsAtMs);
     const firstSeenMs = inWindowEvents.reduce((minimum, event) => Math.min(minimum, event.timestampMs), Number.POSITIVE_INFINITY);
     const lastSeenMs = inWindowEvents.reduce((maximum, event) => Math.max(maximum, event.timestampMs), Number.NEGATIVE_INFINITY);

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

@@ -32,8 +32,11 @@ export function addUsageTotals(target, source) {
     target.totalTokens += source.totalTokens;
     target.estimatedCredits += source.estimatedCredits;
     target.eventCount += source.eventCount;
-    if (source.cacheStatus === "unavailable") {
-        target.cacheStatus = "unavailable";
+    if (source.cacheReadStatus === "unavailable") {
+        target.cacheReadStatus = "unavailable";
+    }
+    if (source.cacheWriteStatus === "unavailable") {
+        target.cacheWriteStatus = "unavailable";
     }
     if (source.estimatedCreditsStatus === "unavailable") {
         target.estimatedCreditsStatus = "unavailable";

package/ink-app/dist/providers/copilot/models.js

@@ -0,0 +1,55 @@
+import { resolveUsageRate } from "../pricing.js";
+/**
+ * Copilot-specific estimated API-equivalent rate card (micro-credits per
+ * million tokens). This is intentionally separate from the Codex and
+ * Antigravity rate cards — Copilot bills the same model families at different
+ * effective rates, so there is no single shared source of truth to reuse.
+ */
+export const RATE_CARD = {
+    "gpt-5-mini": { input: 25, cacheRead: 2.5, cacheWrite: 25, cacheWrite5m: 25, cacheWrite1h: 25, output: 200 },
+    "gpt-5.3-codex": { input: 175, cacheRead: 17.5, cacheWrite: 175, cacheWrite5m: 175, cacheWrite1h: 175, output: 1400 },
+    "gpt-5.4": { input: 250, cacheRead: 25, cacheWrite: 250, cacheWrite5m: 250, cacheWrite1h: 250, output: 1500, longContext: { thresholdTokens: 272000, rate: { input: 500, cacheRead: 50, cacheWrite: 500, cacheWrite5m: 500, cacheWrite1h: 500, output: 2250 } } },
+    "gpt-5.4-mini": { input: 75, cacheRead: 7.5, cacheWrite: 75, cacheWrite5m: 75, cacheWrite1h: 75, output: 450 },
+    "gpt-5.4-nano": { input: 20, cacheRead: 2, cacheWrite: 20, cacheWrite5m: 20, cacheWrite1h: 20, output: 125 },
+    "gpt-5.5": { input: 500, cacheRead: 50, cacheWrite: 500, cacheWrite5m: 500, cacheWrite1h: 500, output: 3000, longContext: { thresholdTokens: 272000, rate: { input: 1000, cacheRead: 100, cacheWrite: 1000, cacheWrite5m: 1000, cacheWrite1h: 1000, output: 4500 } } },
+    "claude-haiku-4-5": { input: 100, cacheRead: 10, cacheWrite: 125, cacheWrite5m: 125, cacheWrite1h: 200, output: 500 },
+    "claude-sonnet-4-5": { input: 300, cacheRead: 30, cacheWrite: 375, cacheWrite5m: 375, cacheWrite1h: 600, output: 1500 },
+    "claude-sonnet-4-6": { input: 300, cacheRead: 30, cacheWrite: 375, cacheWrite5m: 375, cacheWrite1h: 600, output: 1500 },
+    "claude-opus-4-5": { input: 500, cacheRead: 50, cacheWrite: 625, cacheWrite5m: 625, cacheWrite1h: 1000, output: 2500 },
+    "claude-opus-4-6": { input: 500, cacheRead: 50, cacheWrite: 625, cacheWrite5m: 625, cacheWrite1h: 1000, output: 2500 },
+    "claude-opus-4-7": { input: 500, cacheRead: 50, cacheWrite: 625, cacheWrite5m: 625, cacheWrite1h: 1000, output: 2500 },
+    "claude-opus-4-8": { input: 500, cacheRead: 50, cacheWrite: 625, cacheWrite5m: 625, cacheWrite1h: 1000, output: 2500 },
+    "claude-fable-5": { input: 1000, cacheRead: 100, cacheWrite: 1250, cacheWrite5m: 1250, cacheWrite1h: 2000, output: 5000 },
+    "gemini-2.5-pro": { input: 125, cacheRead: 12.5, cacheWrite: 125, cacheWrite5m: 125, cacheWrite1h: 125, output: 1000 },
+    "gemini-3-flash": { input: 50, cacheRead: 5, cacheWrite: 50, cacheWrite5m: 50, cacheWrite1h: 50, output: 300 },
+    "gemini-3.1-pro": { input: 200, cacheRead: 20, cacheWrite: 200, cacheWrite5m: 200, cacheWrite1h: 200, output: 1200, longContext: { thresholdTokens: 200000, rate: { input: 400, cacheRead: 40, cacheWrite: 400, cacheWrite5m: 400, cacheWrite1h: 400, output: 1800 } } },
+    "gemini-3.5-flash": { input: 150, cacheRead: 15, cacheWrite: 150, cacheWrite5m: 150, cacheWrite1h: 150, output: 900 },
+    "mai-code-1-flash": { input: 75, cacheRead: 7.5, cacheWrite: 75, cacheWrite5m: 75, cacheWrite1h: 75, output: 450 },
+    "raptor-mini": { input: 25, cacheRead: 2.5, cacheWrite: 25, cacheWrite5m: 25, cacheWrite1h: 25, output: 200 }
+};
+/**
+ * Model id prefixes that Copilot does not bill (inline completions / next-edit
+ * suggestions). These are zero-rated rather than "unknown" so they never turn
+ * aggregate credit totals unknown.
+ */
+export const NON_BILLABLE_MODEL_PREFIXES = [
+    "copilot-nes",
+    "copilot-suggestion",
+    "copilot-suggestions"
+];
+/**
+ * Canonicalize a Copilot model id. The exporter already emits stable,
+ * human-readable ids (including dated suffixes like `gpt-5.4-2026-03-01`), and
+ * the dashboard surfaces those verbatim, so this only guards the empty case.
+ * Prefix-based rate resolution (see {@link rateForCopilotModel}) handles dated
+ * suffixes without collapsing the displayed id.
+ */
+export function normalizeCopilotModelId(modelId) {
+    return modelId || "unknown";
+}
+export function rateForCopilotModel(modelId, inputTokens) {
+    return resolveUsageRate(RATE_CARD, modelId, inputTokens, { prefixMatch: true });
+}
+export function isNonBillableCopilotModel(modelId) {
+    return NON_BILLABLE_MODEL_PREFIXES.some((prefix) => modelId === prefix || modelId.startsWith(`${prefix}-`));
+}

package/ink-app/dist/providers/copilot/otel/configure.js

@@ -0,0 +1,134 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { applyEdits, modify, parse } from "jsonc-parser";
+import { asRecord } from "../../limits.js";
+const VSCODE_OTEL_SETTINGS = {
+    "github.copilot.chat.otel.enabled": true,
+    "github.copilot.chat.otel.exporterType": "file",
+    "github.copilot.chat.otel.captureContent": false
+};
+export async function configureCopilotVsCodeLogging(options = {}) {
+    const root = path.resolve(options.root ?? os.homedir());
+    const outfile = getCopilotOtelPath(root);
+    const settingsPath = options.settingsPath ?? (await getVsCodeSettingsPath(root));
+    const settingsText = await readTextFileOrEmpty(settingsPath);
+    const { text, changed } = updateJsoncSettings(settingsText, {
+        ...VSCODE_OTEL_SETTINGS,
+        "github.copilot.chat.otel.outfile": toVsCodeOutfilePath(outfile)
+    });
+    await fs.promises.mkdir(path.dirname(settingsPath), { recursive: true });
+    await fs.promises.mkdir(path.dirname(outfile), { recursive: true });
+    if (changed) {
+        await fs.promises.writeFile(settingsPath, text, "utf8");
+    }
+    return { settingsPath, outfile, changed };
+}
+export function getCopilotOtelPath(root) {
+    return path.join(root, ".copilot", "otel", "vscode.jsonl");
+}
+export function toVsCodeOutfilePath(filePath) {
+    return process.platform === "win32" ? filePath.replace(/\\/g, "/") : filePath;
+}
+export function getCopilotCliOtelEnv(outfile) {
+    return {
+        COPILOT_OTEL_ENABLED: "true",
+        COPILOT_OTEL_FILE_EXPORTER_PATH: outfile
+    };
+}
+export async function getVsCodeSettingsPath(root) {
+    const userRoots = getVsCodeUserRoots(root);
+    for (const userRoot of userRoots) {
+        if (await isDirectory(userRoot)) {
+            return path.join(userRoot, "settings.json");
+        }
+    }
+    return path.join(userRoots[0], "settings.json");
+}
+export function getVsCodeUserRoots(root) {
+    if (process.platform === "darwin") {
+        const applicationSupport = path.join(root, "Library", "Application Support");
+        return [
+            path.join(applicationSupport, "Code", "User"),
+            path.join(applicationSupport, "Code - Insiders", "User")
+        ];
+    }
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA ?? path.join(root, "AppData", "Roaming");
+        return [path.join(appData, "Code", "User"), path.join(appData, "Code - Insiders", "User")];
+    }
+    const configRoot = path.join(root, ".config");
+    return [path.join(configRoot, "Code", "User"), path.join(configRoot, "Code - Insiders", "User")];
+}
+/**
+ * For each VS Code user root (stable + Insiders), read settings.json and report
+ * the configured Copilot OTEL outfile when file export is enabled. Used by the
+ * provider to detect "logging configured but the file has not been created yet".
+ */
+export async function getConfiguredCopilotOutfiles(root) {
+    const results = [];
+    for (const userRoot of getVsCodeUserRoots(root)) {
+        const settings = await readJsonSettings(path.join(userRoot, "settings.json"));
+        const enabled = settings["github.copilot.chat.otel.enabled"] === true;
+        const exporterType = settings["github.copilot.chat.otel.exporterType"];
+        const outfile = settings["github.copilot.chat.otel.outfile"];
+        if (enabled && exporterType === "file" && typeof outfile === "string") {
+            results.push({ path: path.resolve(outfile), enabled: true });
+        }
+    }
+    return results;
+}
+async function isDirectory(filePath) {
+    try {
+        const stat = await fs.promises.stat(filePath);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function readJsonSettings(filePath) {
+    return parseJsoncSettings(await readTextFileOrEmpty(filePath));
+}
+async function readTextFileOrEmpty(filePath) {
+    try {
+        return await fs.promises.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+function parseJsoncSettings(raw) {
+    if (!raw.trim()) {
+        return {};
+    }
+    const parsed = parse(raw);
+    return asRecord(parsed) ?? {};
+}
+function updateJsoncSettings(raw, values) {
+    let text = raw.trim() ? raw : "{\n}";
+    let changed = false;
+    for (const [key, value] of Object.entries(values)) {
+        if (parseJsoncSettings(text)[key] === value) {
+            continue;
+        }
+        const edits = modify(text, [key], value, {
+            formattingOptions: {
+                eol: "\n",
+                insertSpaces: true,
+                tabSize: 4
+            }
+        });
+        if (edits.length > 0) {
+            text = applyEdits(text, edits);
+            changed = true;
+        }
+    }
+    if (changed && !text.endsWith("\n")) {
+        text += "\n";
+    }
+    return { text, changed };
+}

package/ink-app/dist/providers/copilot/otel/discover.js

@@ -0,0 +1,94 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { getConfiguredCopilotOutfiles, getCopilotOtelPath } from "./configure.js";
+function dedupKey(resolvedPath) {
+    return process.platform === "win32" ? resolvedPath.toLowerCase() : resolvedPath;
+}
+function isPermissionError(error) {
+    const code = error instanceof Error ? error.code : undefined;
+    return code === "EACCES" || code === "EPERM";
+}
+/**
+ * Discover the Copilot OTEL JSONL files to read, from three sources:
+ *   1. the `COPILOT_OTEL_FILE_EXPORTER_PATH` env var (Copilot CLI),
+ *   2. the `outfile` configured in VS Code / Insiders settings, and
+ *   3. every `*.jsonl` in `<root>/.copilot/otel/`.
+ * This covers the VS Code extension, a standalone Copilot CLI, and the CLI run
+ * from VS Code, on Linux/Windows/macOS. Paths are resolved and de-duplicated
+ * (case-insensitively on Windows); the first occurrence wins.
+ */
+export async function discoverCopilotOtelFiles(options) {
+    const root = options?.root ?? process.cwd();
+    const env = options?.env ?? process.env;
+    const warnings = [];
+    const candidatePaths = [];
+    // 1. Environment exporter path.
+    const envPath = env.COPILOT_OTEL_FILE_EXPORTER_PATH;
+    if (typeof envPath === "string" && envPath.length > 0) {
+        candidatePaths.push(envPath);
+    }
+    // 2. VS Code / Insiders configured outfiles.
+    try {
+        for (const entry of await getConfiguredCopilotOutfiles(root)) {
+            candidatePaths.push(entry.path);
+        }
+    }
+    catch (error) {
+        if (isPermissionError(error)) {
+            warnings.push("Failed to read VS Code Copilot settings: permission denied.");
+        }
+        // Missing settings or any other read issue is not an error here.
+    }
+    // 3. Directory scan of <root>/.copilot/otel/*.jsonl.
+    const otelDir = path.dirname(getCopilotOtelPath(root));
+    try {
+        const entries = await fs.readdir(otelDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile() && !entry.isSymbolicLink()) {
+                continue;
+            }
+            if (entry.name.toLowerCase().endsWith(".jsonl")) {
+                candidatePaths.push(path.join(otelDir, entry.name));
+            }
+        }
+    }
+    catch (error) {
+        if (isPermissionError(error)) {
+            warnings.push(`Failed to read Copilot OTEL directory ${otelDir}: permission denied.`);
+        }
+        // ENOENT (missing directory) and similar are not errors — skip.
+    }
+    // Resolve, de-dup by path (first wins), and keep readable regular files.
+    const seen = new Set();
+    const files = [];
+    for (const candidate of candidatePaths) {
+        const resolved = path.resolve(candidate);
+        const key = dedupKey(resolved);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        try {
+            const stats = await fs.stat(resolved);
+            if (!stats.isFile()) {
+                continue;
+            }
+            await fs.access(resolved, fs.constants.R_OK);
+            files.push({ path: resolved, modifiedAtMs: stats.mtimeMs });
+        }
+        catch (error) {
+            if (isPermissionError(error)) {
+                warnings.push(`Failed to read Copilot OTEL file ${resolved}: permission denied.`);
+            }
+            // Missing file or other failures simply drop the candidate.
+        }
+    }
+    // Stable sort by modifiedAtMs ASC, then path ASC.
+    files.sort((a, b) => {
+        if (a.modifiedAtMs !== b.modifiedAtMs) {
+            return a.modifiedAtMs - b.modifiedAtMs;
+        }
+        return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+    });
+    return { files, warnings };
+}