copilot-debugger 0.1.0

package/dist/server/sources/VsCodeTranscriptSource.js

@@ -0,0 +1,1093 @@
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import readline from 'node:readline';
+import chokidar from 'chokidar';
+import fg from 'fast-glob';
+// debugName values for internal Copilot side-requests that are not part of the actual
+// conversation (e.g. auto-generated chat tab titles). These are excluded from cost/model
+// stats so they don't pollute usage numbers with models the user never actually picked.
+const EXCLUDED_COST_DEBUG_NAMES = new Set(['title']);
+export class VsCodeTranscriptSource {
+    options;
+    watcher;
+    watchedDirsKey = '';
+    pollTimer;
+    refreshTimer;
+    sessions = new Map();
+    lastRefreshAt;
+    error;
+    refreshInFlight;
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        await this.refresh();
+        this.pollTimer = setInterval(() => this.scheduleRefresh(), this.options.pollIntervalMs);
+    }
+    async stop() {
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+        }
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+        }
+        await this.watcher?.close();
+    }
+    listSessions() {
+        return {
+            sessions: [...this.sessions.values()].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)),
+            lastRefreshAt: this.lastRefreshAt,
+            error: this.error
+        };
+    }
+    getSession(id) {
+        return this.sessions.get(id);
+    }
+    scheduleRefresh() {
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+        }
+        this.refreshTimer = setTimeout(() => {
+            void this.refresh();
+        }, 350);
+    }
+    async refresh() {
+        if (this.refreshInFlight) {
+            return this.refreshInFlight;
+        }
+        this.refreshInFlight = this.performRefresh().finally(() => {
+            this.refreshInFlight = undefined;
+        });
+        return this.refreshInFlight;
+    }
+    async performRefresh() {
+        try {
+            const candidates = await this.findCandidateFiles();
+            await this.updateWatcher(candidates);
+            const accumulators = new Map();
+            for (const transcriptPath of candidates.transcripts) {
+                const accumulator = await this.getOrCreateAccumulatorAsync(accumulators, transcriptPath, 'transcript');
+                accumulator.sourcePaths.transcript = transcriptPath;
+                await this.consumeFileStats(accumulator, transcriptPath);
+                await this.readJsonl(transcriptPath, (entry) => this.consumeEntry(accumulator, entry));
+            }
+            for (const debugLogPath of candidates.debugLogs) {
+                const accumulator = await this.getOrCreateAccumulatorAsync(accumulators, debugLogPath, 'debugLog');
+                accumulator.sourcePaths.debugLog = debugLogPath;
+                accumulator.hasDebugLog = true;
+                await this.consumeFileStats(accumulator, debugLogPath);
+                await this.readJsonl(debugLogPath, (entry) => this.consumeEntry(accumulator, entry));
+            }
+            this.sessions = new Map([...accumulators.values()].map((session) => {
+                const normalized = this.normalizeAccumulator(session);
+                return [normalized.id, normalized];
+            }));
+            this.lastRefreshAt = new Date().toISOString();
+            this.error = undefined;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+            this.lastRefreshAt = new Date().toISOString();
+        }
+    }
+    async findCandidateFiles() {
+        const roots = this.options.directCopilotSessionRoot
+            ? [this.options.directCopilotSessionRoot]
+            : [this.options.workspaceStorageRoot];
+        const toGlob = (p) => p.replace(/\\/g, '/');
+        const transcriptPatterns = roots.map((root) => toGlob(path.join(root, '**', 'GitHub.copilot-chat', 'transcripts', '*.jsonl')));
+        const debugPatterns = roots.flatMap((root) => [
+            toGlob(path.join(root, '**', 'GitHub.copilot-chat', 'debug-logs', '*', 'main.jsonl')),
+            toGlob(path.join(root, '**', 'GitHub.copilot-chat', 'debug-logs', '*', '*.jsonl'))
+        ]);
+        const [transcripts, debugLogs] = await Promise.all([
+            fg(transcriptPatterns, { onlyFiles: true, unique: true, dot: true, suppressErrors: true }),
+            fg(debugPatterns, { onlyFiles: true, unique: true, dot: true, suppressErrors: true })
+        ]);
+        return { transcripts, debugLogs };
+    }
+    async updateWatcher(candidates) {
+        const watchedDirs = [...new Set([...candidates.transcripts, ...candidates.debugLogs].map((filePath) => path.dirname(filePath)))].sort();
+        const nextKey = watchedDirs.join('\n');
+        if (nextKey === this.watchedDirsKey) {
+            return;
+        }
+        this.watchedDirsKey = nextKey;
+        await this.watcher?.close();
+        this.watcher = undefined;
+        if (watchedDirs.length === 0) {
+            return;
+        }
+        this.watcher = chokidar.watch(watchedDirs, {
+            ignoreInitial: true,
+            depth: 0,
+            awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 }
+        });
+        this.watcher.on('add', () => this.scheduleRefresh());
+        this.watcher.on('change', () => this.scheduleRefresh());
+        this.watcher.on('unlink', () => this.scheduleRefresh());
+        this.watcher.on('error', (error) => {
+            this.error = error instanceof Error ? error.message : String(error);
+            void this.watcher?.close().then(() => {
+                this.watcher = undefined;
+                this.watchedDirsKey = '';
+            });
+        });
+    }
+    async getOrCreateAccumulatorAsync(accumulators, filePath, kind) {
+        const id = this.extractSessionId(filePath, kind);
+        const existing = accumulators.get(id);
+        if (existing) {
+            return existing;
+        }
+        const workspaceStorageId = this.extractWorkspaceStorageId(filePath);
+        const workspaceName = await this.resolveWorkspaceName(workspaceStorageId);
+        const accumulator = {
+            id,
+            workspaceStorageId,
+            workspaceName,
+            sourcePaths: {},
+            producer: kind === 'debugLog' ? 'VS Code Copilot Chat debug log' : 'VS Code Copilot Chat transcript',
+            messageCount: 0,
+            userTurnCount: 0,
+            agents: new Set(),
+            tools: new Set(),
+            hasDebugLog: kind === 'debugLog',
+            cost: {
+                inputTokens: 0,
+                outputTokens: 0,
+                cachedTokens: 0,
+                requestCount: 0,
+                models: new Set(),
+                perModel: new Map()
+            }
+        };
+        accumulators.set(id, accumulator);
+        return accumulator;
+    }
+    extractSessionId(filePath, kind) {
+        const parts = filePath.split(path.sep);
+        const debugIndex = parts.lastIndexOf('debug-logs');
+        if (debugIndex >= 0 && parts[debugIndex + 1]) {
+            return parts[debugIndex + 1];
+        }
+        if (kind === 'transcript') {
+            return path.basename(filePath, '.jsonl');
+        }
+        return createHash('sha1').update(filePath).digest('hex').slice(0, 12);
+    }
+    extractWorkspaceStorageId(filePath) {
+        const relative = path.relative(this.options.workspaceStorageRoot, filePath);
+        if (!relative.startsWith('..')) {
+            return relative.split(path.sep)[0] ?? 'direct';
+        }
+        return 'direct';
+    }
+    async readJsonl(filePath, onEntry) {
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            return;
+        }
+        const stream = createReadStream(filePath, { encoding: 'utf8' });
+        const lines = readline.createInterface({ input: stream, crlfDelay: Infinity });
+        for await (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                onEntry(JSON.parse(trimmed));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    async consumeFileStats(accumulator, filePath) {
+        try {
+            const stats = await fs.stat(filePath);
+            const modifiedAt = stats.mtime.toISOString();
+            accumulator.startTime = minIso(accumulator.startTime, modifiedAt);
+            accumulator.updatedAt = maxIso(accumulator.updatedAt, modifiedAt);
+        }
+        catch {
+            return;
+        }
+    }
+    consumeEntry(accumulator, entry) {
+        if (!entry || typeof entry !== 'object') {
+            return;
+        }
+        const record = entry;
+        const attrs = this.asRecord(record.attrs);
+        const fields = { ...attrs, ...record };
+        const timestamp = this.findTimestamp(fields);
+        if (timestamp) {
+            accumulator.startTime = minIso(accumulator.startTime, timestamp);
+            accumulator.updatedAt = maxIso(accumulator.updatedAt, timestamp);
+        }
+        this.copyString(fields, ['producer', 'source', 'type'], (value) => {
+            if (value.includes('Copilot') || value.includes('transcript') || value.includes('debug')) {
+                accumulator.producer = value;
+            }
+        });
+        this.copyString(fields, ['copilotVersion', 'copilotChatVersion', 'extensionVersion'], (value) => {
+            accumulator.copilotVersion ??= value;
+        });
+        this.copyString(fields, ['vscodeVersion', 'vscode', 'appVersion'], (value) => {
+            accumulator.vscodeVersion ??= value;
+        });
+        const role = this.findString(fields, ['role', 'speaker', 'participant', 'from']) ?? this.inferRole(fields);
+        const text = this.findMessageText(fields);
+        if (text) {
+            accumulator.messageCount += 1;
+            if (!accumulator.firstUserMessage && role?.toLowerCase().includes('user')) {
+                accumulator.firstUserMessage = text;
+            }
+            if (role?.toLowerCase().includes('user')) {
+                accumulator.userTurnCount += 1;
+            }
+        }
+        const agent = this.findString(fields, ['agent', 'agentName', 'agent_name', 'mode']);
+        if (agent) {
+            accumulator.agents.add(agent);
+        }
+        const tool = this.findString(fields, ['tool', 'toolName', 'tool_name', 'functionName', 'name']);
+        if (tool && this.looksLikeTool(fields, tool)) {
+            accumulator.tools.add(tool);
+        }
+        this.consumeCost(accumulator, fields);
+    }
+    async resolveWorkspaceName(workspaceStorageId) {
+        if (workspaceStorageId === 'direct')
+            return undefined;
+        try {
+            const workspaceJsonPath = path.join(this.options.workspaceStorageRoot, workspaceStorageId, 'workspace.json');
+            const raw = await fs.readFile(workspaceJsonPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            const uri = (parsed.folder ?? parsed.workspace);
+            if (!uri)
+                return undefined;
+            let decoded = decodeURIComponent(uri.replace(/^file:\/\//, ''));
+            // Windows: file:///C:/... → /C:/... → C:/...
+            if (/^\/[A-Za-z]:\//.test(decoded))
+                decoded = decoded.slice(1);
+            return path.basename(decoded.replace(/\.code-workspace$/, ''));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    normalizeAccumulator(accumulator) {
+        const updatedAt = accumulator.updatedAt ?? new Date(0).toISOString();
+        return {
+            id: accumulator.id,
+            workspaceStorageId: accumulator.workspaceStorageId,
+            workspaceName: accumulator.workspaceName,
+            sourcePaths: accumulator.sourcePaths,
+            startTime: accumulator.startTime,
+            updatedAt,
+            producer: accumulator.producer,
+            copilotVersion: accumulator.copilotVersion,
+            vscodeVersion: accumulator.vscodeVersion,
+            firstUserMessage: accumulator.firstUserMessage,
+            messageCount: accumulator.messageCount,
+            userTurnCount: accumulator.userTurnCount,
+            agents: [...accumulator.agents].sort(),
+            tools: [...accumulator.tools].sort(),
+            hasDebugLog: accumulator.hasDebugLog,
+            cost: {
+                aiCredits: accumulator.cost.aiCredits,
+                aiCreditUnit: accumulator.cost.aiCredits === undefined ? undefined : 'AIC',
+                aiCreditSource: accumulator.cost.aiCreditSource,
+                inputTokens: accumulator.cost.inputTokens || undefined,
+                outputTokens: accumulator.cost.outputTokens || undefined,
+                cachedTokens: accumulator.cost.cachedTokens || undefined,
+                requestCount: accumulator.cost.requestCount || undefined,
+                models: [...accumulator.cost.models].sort(),
+                perModel: [...accumulator.cost.perModel.entries()]
+                    .map(([model, stats]) => ({
+                    model,
+                    aiCredits: stats.aiCredits || undefined,
+                    inputTokens: stats.inputTokens || undefined,
+                    outputTokens: stats.outputTokens || undefined,
+                    cachedTokens: stats.cachedTokens || undefined,
+                    requestCount: stats.requestCount || undefined
+                }))
+                    .sort((a, b) => (b.aiCredits ?? 0) - (a.aiCredits ?? 0) || a.model.localeCompare(b.model))
+            }
+        };
+    }
+    consumeCost(accumulator, fields) {
+        // Skip internal side-requests (e.g. title generation) entirely, so they never
+        // show up as tokens/credits/models in the session stats.
+        const debugName = this.findString(fields, ['debugName']);
+        if (debugName && EXCLUDED_COST_DEBUG_NAMES.has(debugName)) {
+            return;
+        }
+        const nanoAiu = this.findNumber(fields, ['copilotUsageNanoAiu', 'copilotUsageNanoAIU', 'copilot_usage_nano_aiu']);
+        if (nanoAiu !== undefined) {
+            accumulator.cost.aiCredits = (accumulator.cost.aiCredits ?? 0) + nanoAiu / 1_000_000_000;
+            accumulator.cost.aiCreditSource ??= 'copilotUsageNanoAiu';
+        }
+        const inputTokens = this.findNumber(fields, ['usage_input_tokens', 'inputTokens', 'input_tokens', 'promptTokens', 'prompt_tokens']);
+        const outputTokens = this.findNumber(fields, ['usage_output_tokens', 'outputTokens', 'output_tokens', 'completionTokens', 'completion_tokens']);
+        const cachedTokens = this.findNumber(fields, ['cachedTokens', 'cached_tokens', 'usage_cached_tokens']);
+        if (inputTokens !== undefined || outputTokens !== undefined || cachedTokens !== undefined) {
+            accumulator.cost.requestCount += 1;
+            accumulator.cost.inputTokens += inputTokens ?? 0;
+            accumulator.cost.outputTokens += outputTokens ?? 0;
+            accumulator.cost.cachedTokens += cachedTokens ?? 0;
+        }
+        const model = this.findString(fields, ['usage_model', 'model', 'modelName', 'model_name']);
+        if (model) {
+            accumulator.cost.models.add(model);
+            if (nanoAiu !== undefined || inputTokens !== undefined || outputTokens !== undefined || cachedTokens !== undefined) {
+                const modelStats = accumulator.cost.perModel.get(model) ?? {
+                    aiCredits: 0,
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    cachedTokens: 0,
+                    requestCount: 0
+                };
+                if (nanoAiu !== undefined) {
+                    modelStats.aiCredits += nanoAiu / 1_000_000_000;
+                }
+                if (inputTokens !== undefined || outputTokens !== undefined || cachedTokens !== undefined) {
+                    modelStats.requestCount += 1;
+                    modelStats.inputTokens += inputTokens ?? 0;
+                    modelStats.outputTokens += outputTokens ?? 0;
+                    modelStats.cachedTokens += cachedTokens ?? 0;
+                }
+                accumulator.cost.perModel.set(model, modelStats);
+            }
+        }
+    }
+    findTimestamp(record) {
+        for (const key of ['timestamp', 'time', 'createdAt', 'created_at', 'updatedAt', 'updated_at', 'date', 'ts']) {
+            const value = record[key];
+            const date = typeof value === 'number' ? new Date(value > 10_000_000_000 ? value : value * 1000) : new Date(String(value ?? ''));
+            if (!Number.isNaN(date.getTime())) {
+                return date.toISOString();
+            }
+        }
+        return undefined;
+    }
+    findMessageText(record) {
+        const direct = this.findString(record, ['text', 'message', 'content', 'userMessage', 'user_message', 'prompt']);
+        if (direct) {
+            return direct.slice(0, 280);
+        }
+        for (const value of Object.values(record)) {
+            if (value && typeof value === 'object') {
+                const nested = this.findMessageText(value);
+                if (nested) {
+                    return nested;
+                }
+            }
+        }
+        return undefined;
+    }
+    findString(record, keys) {
+        for (const key of keys) {
+            const value = record[key];
+            if (typeof value === 'string' && value.trim()) {
+                return value.trim();
+            }
+            if (typeof value === 'number' || typeof value === 'boolean') {
+                return String(value);
+            }
+        }
+        return undefined;
+    }
+    findNumber(record, keys) {
+        for (const key of keys) {
+            const value = record[key];
+            if (typeof value === 'number' && Number.isFinite(value)) {
+                return value;
+            }
+            if (typeof value === 'string' && value.trim()) {
+                const parsed = Number(value);
+                if (Number.isFinite(parsed)) {
+                    return parsed;
+                }
+            }
+        }
+        return undefined;
+    }
+    copyString(record, keys, onValue) {
+        const value = this.findString(record, keys);
+        if (value) {
+            onValue(value);
+        }
+    }
+    looksLikeTool(record, tool) {
+        const serialized = JSON.stringify(record).toLowerCase();
+        return serialized.includes('tool') || serialized.includes('function') || tool.includes('.');
+    }
+    inferRole(record) {
+        const type = this.findString(record, ['type', 'name'])?.toLowerCase();
+        if (type?.includes('user_message')) {
+            return 'user';
+        }
+        if (type?.includes('agent_response') || type?.includes('assistant')) {
+            return 'assistant';
+        }
+        return undefined;
+    }
+    asRecord(value) {
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    }
+    async getSessionTurns(id) {
+        const session = this.sessions.get(id);
+        if (!session) {
+            return [];
+        }
+        const debugLogPath = session.sourcePaths.debugLog;
+        const transcriptPath = session.sourcePaths.transcript;
+        // Prefer main.jsonl in the debug-logs session directory; fallback to stored path
+        if (debugLogPath) {
+            const dir = path.dirname(debugLogPath);
+            const mainPath = path.join(dir, 'main.jsonl');
+            try {
+                await fs.access(mainPath);
+                return this.parseTurns(mainPath);
+            }
+            catch {
+                return this.parseTurns(debugLogPath);
+            }
+        }
+        if (transcriptPath) {
+            return this.parseTurns(transcriptPath);
+        }
+        return [];
+    }
+    async getSessionOverview(id) {
+        const session = this.sessions.get(id);
+        if (!session?.sourcePaths.debugLog) {
+            return undefined;
+        }
+        const dir = path.dirname(session.sourcePaths.debugLog);
+        // Find system_prompt and tools files (use index 0 as the first turn's context)
+        const systemPromptFiles = await fg(path.join(dir, 'system_prompt_*.json').replace(/\\/g, '/'), {
+            onlyFiles: true,
+            suppressErrors: true
+        });
+        const toolsFiles = await fg(path.join(dir, 'tools_*.json').replace(/\\/g, '/'), {
+            onlyFiles: true,
+            suppressErrors: true
+        });
+        const systemPromptFile = systemPromptFiles.sort()[0];
+        const toolsFile = toolsFiles.sort()[0];
+        const skills = [];
+        const agents = [];
+        const attachments = [];
+        const toolsByName = new Map();
+        const addTool = (tool) => {
+            const name = getToolName(tool);
+            if (!name)
+                return;
+            const existing = toolsByName.get(name);
+            const isMcp = name.startsWith('mcp_');
+            const mcpServer = isMcp ? name.split('_').slice(1, -1).join('_') : undefined;
+            const description = getToolDescription(tool).slice(0, 120);
+            const deferred = isDeferredTool(tool);
+            const sizeBytes = JSON.stringify(tool).length;
+            toolsByName.set(name, {
+                name,
+                description: existing?.description || description,
+                isMcp,
+                deferred: existing?.deferred || deferred || undefined,
+                mcpServer,
+                sizeBytes: Math.max(existing?.sizeBytes ?? 0, sizeBytes)
+            });
+        };
+        let systemPromptTotalBytes = 0;
+        let systemPromptSkillsBytes = 0;
+        let systemPromptAgentsBytes = 0;
+        let systemPromptAttachmentsBytes = 0;
+        if (systemPromptFile) {
+            try {
+                const raw = await fs.readFile(systemPromptFile, 'utf8');
+                const outer = JSON.parse(raw);
+                const parts = JSON.parse(outer.content);
+                const text = parts.find((p) => p.type === 'text')?.content ?? '';
+                systemPromptTotalBytes = text.length;
+                // Parse <skills>
+                const skillsMatch = text.match(/<skills>([\s\S]*?)<\/skills>/);
+                if (skillsMatch) {
+                    systemPromptSkillsBytes = skillsMatch[0].length;
+                    const skillsText = skillsMatch[1];
+                    const skillEntries = skillsText.matchAll(/<skill>[\s\S]*?<name>([\s\S]*?)<\/name>[\s\S]*?<description>([\s\S]*?)<\/description>[\s\S]*?<\/skill>/g);
+                    for (const m of skillEntries) {
+                        skills.push({ name: m[1].trim(), description: m[2].trim(), sizeBytes: m[0].length });
+                    }
+                }
+                // Parse <agents>
+                const agentsMatch = text.match(/<agents>([\s\S]*?)<\/agents>/);
+                if (agentsMatch) {
+                    systemPromptAgentsBytes = agentsMatch[0].length;
+                    const agentsText = agentsMatch[1];
+                    const agentEntries = agentsText.matchAll(/<agent>[\s\S]*?<name>([\s\S]*?)<\/name>[\s\S]*?<description>([\s\S]*?)<\/description>[\s\S]*?<\/agent>/g);
+                    for (const m of agentEntries) {
+                        agents.push({ name: m[1].trim(), description: m[2].trim(), sizeBytes: m[0].length });
+                    }
+                }
+                // Parse standalone <attachment> blocks
+                const attachmentEntries = text.matchAll(/<attachment([^>]*)>([\s\S]*?)<\/attachment>/g);
+                for (const m of attachmentEntries) {
+                    const attrs = m[1];
+                    const idMatch = attrs.match(/\bid="([^"]*)"/);
+                    const filePathMatch = attrs.match(/\bfilePath="([^"]*)"/);
+                    const name = idMatch?.[1] ?? (filePathMatch ? filePathMatch[1].split('/').pop() ?? filePathMatch[1] : 'attachment');
+                    const description = m[2].trim().slice(0, 160).replace(/\s+/g, ' ');
+                    const sizeBytes = m[0].length;
+                    systemPromptAttachmentsBytes += sizeBytes;
+                    attachments.push({ name, description, sizeBytes });
+                }
+            }
+            catch {
+                // ignore parse errors
+            }
+        }
+        if (toolsFile) {
+            try {
+                const raw = await fs.readFile(toolsFile, 'utf8');
+                const outer = JSON.parse(raw);
+                const toolsArray = JSON.parse(outer.content);
+                for (const t of toolsArray) {
+                    addTool(t);
+                }
+            }
+            catch {
+                // ignore parse errors
+            }
+        }
+        try {
+            await this.consumeProviderRequestTools(path.join(dir, 'main.jsonl'), addTool);
+        }
+        catch {
+            // ignore parse errors
+        }
+        const deferredToolNames = await this.collectAvailableDeferredToolNames(path.join(dir, 'main.jsonl'));
+        for (const name of deferredToolNames) {
+            const tool = toolsByName.get(name);
+            if (tool) {
+                toolsByName.set(name, { ...tool, deferred: true });
+            }
+        }
+        const tools = [...toolsByName.values()];
+        const toolsBytesTotal = tools.reduce((s, t) => s + t.sizeBytes, 0);
+        const userPromptBytes = session.firstUserMessage?.length ?? 0;
+        let maxContextTokens;
+        let model = session.cost.models[0];
+        try {
+            const modelsRaw = await fs.readFile(path.join(dir, 'models.json'), 'utf8');
+            const modelsData = JSON.parse(modelsRaw);
+            const modelEntry = modelsData.find((m) => m.id === model);
+            maxContextTokens = modelEntry?.capabilities?.limits?.max_context_window_tokens;
+        }
+        catch {
+            // ignore — models.json may not exist
+        }
+        const contextSizes = {
+            systemPromptTotalBytes,
+            systemPromptSkillsBytes,
+            systemPromptAgentsBytes,
+            systemPromptAttachmentsBytes,
+            toolsBytes: toolsBytesTotal,
+            userPromptBytes,
+            maxContextTokens,
+            model,
+        };
+        skills.sort((a, b) => b.sizeBytes - a.sizeBytes || a.name.localeCompare(b.name));
+        agents.sort((a, b) => b.sizeBytes - a.sizeBytes || a.name.localeCompare(b.name));
+        attachments.sort((a, b) => b.sizeBytes - a.sizeBytes || a.name.localeCompare(b.name));
+        tools.sort((a, b) => b.sizeBytes - a.sizeBytes || a.name.localeCompare(b.name));
+        return { skills, agents, attachments, tools, contextSizes };
+    }
+    async consumeProviderRequestTools(filePath, onTool) {
+        await this.readJsonl(filePath, (entry) => {
+            if (!entry || typeof entry !== 'object')
+                return;
+            const record = entry;
+            if (record.type !== 'llm_request')
+                return;
+            const attrs = this.asRecord(record.attrs);
+            for (const key of ['tools', 'request', 'requestBody', 'requestPayload', 'requestJson', 'requestJSON', 'providerRequest', 'apiRequest', 'rawRequest', 'body', 'requestOptions', 'requestShape', 'inputMessages']) {
+                this.consumeToolDefinitions(record[key], onTool);
+                this.consumeToolDefinitions(attrs[key], onTool);
+            }
+        });
+    }
+    async collectAvailableDeferredToolNames(filePath) {
+        const names = new Set();
+        await this.readJsonl(filePath, (entry) => {
+            if (!entry || typeof entry !== 'object')
+                return;
+            const record = entry;
+            const attrs = this.asRecord(record.attrs);
+            for (const value of [...Object.values(record), ...Object.values(attrs)]) {
+                for (const name of extractAvailableDeferredToolNames(value)) {
+                    names.add(name);
+                }
+            }
+        });
+        return names;
+    }
+    consumeToolDefinitions(value, onTool, depth = 0) {
+        if (depth > 6)
+            return;
+        if (typeof value === 'string') {
+            const parsed = parseJsonValue(value);
+            if (parsed !== undefined) {
+                this.consumeToolDefinitions(parsed, onTool, depth + 1);
+                return;
+            }
+            for (const tool of extractToolDefinitionsFromText(value)) {
+                onTool(tool);
+            }
+            return;
+        }
+        const parsed = parseJsonValue(value);
+        if (Array.isArray(parsed)) {
+            for (const item of parsed) {
+                if (item && typeof item === 'object') {
+                    const tool = item;
+                    if (getToolName(tool)) {
+                        onTool(tool);
+                    }
+                    else {
+                        this.consumeToolDefinitions(item, onTool, depth + 1);
+                    }
+                }
+            }
+            return;
+        }
+        if (!parsed || typeof parsed !== 'object')
+            return;
+        const record = parsed;
+        const tools = record.tools;
+        if (!Array.isArray(tools)) {
+            for (const nested of Object.values(record)) {
+                this.consumeToolDefinitions(nested, onTool, depth + 1);
+            }
+            return;
+        }
+        for (const item of tools) {
+            if (item && typeof item === 'object') {
+                onTool(item);
+            }
+        }
+    }
+    // Finds sibling runSubagent-*.jsonl files next to the given debug-log file and parses
+    // each into its own list of agent turns, keyed by the parentSpanId that links back to
+    // the 'runSubagent' tool_call in the parent log (see the 'subagent' entry at the end
+    // of the subagent file).
+    async parseSubagentFiles(filePath) {
+        const result = new Map();
+        const dir = path.dirname(filePath);
+        let files = [];
+        try {
+            files = await fg(path.join(dir, 'runSubagent-*.jsonl').replace(/\\/g, '/'), {
+                onlyFiles: true,
+                suppressErrors: true
+            });
+        }
+        catch {
+            return result;
+        }
+        for (const file of files) {
+            const llmRequests = [];
+            const toolCalls = [];
+            let linkParentSpanId;
+            let agentName;
+            await this.readJsonl(file, (entry) => {
+                if (!entry || typeof entry !== 'object')
+                    return;
+                const rec = entry;
+                const type = typeof rec.type === 'string' ? rec.type : undefined;
+                const attrs = this.asRecord(rec.attrs);
+                const parentSpanId = typeof rec.parentSpanId === 'string' ? rec.parentSpanId : undefined;
+                const tsRaw = rec.ts;
+                const ts = typeof tsRaw === 'number' ? (tsRaw > 10_000_000_000 ? tsRaw : tsRaw * 1000) : Date.now();
+                if (type === 'llm_request') {
+                    const fields = { ...attrs };
+                    const model = typeof fields.model === 'string' ? fields.model : undefined;
+                    const inputTokens = typeof fields.inputTokens === 'number' ? fields.inputTokens : 0;
+                    const outputTokens = typeof fields.outputTokens === 'number' ? fields.outputTokens : 0;
+                    const cachedTokens = typeof fields.cachedTokens === 'number' ? fields.cachedTokens : 0;
+                    const nanoAiu = typeof fields.copilotUsageNanoAiu === 'number' ? fields.copilotUsageNanoAiu : 0;
+                    llmRequests.push({ ts, model, inputTokens, outputTokens, cachedTokens, nanoAiu });
+                }
+                if (type === 'tool_call') {
+                    const name = typeof rec.name === 'string' ? rec.name : undefined;
+                    if (name) {
+                        const argsRaw = serializeUnknown(attrs.args ?? {});
+                        const resultRaw = serializeUnknown(attrs.result ?? '');
+                        let args = {};
+                        try {
+                            args = JSON.parse(argsRaw);
+                        }
+                        catch { /* ignore */ }
+                        toolCalls.push({ ts, name, args, inputChars: resultRaw.length, outputChars: argsRaw.length });
+                    }
+                }
+                if (type === 'subagent') {
+                    linkParentSpanId = parentSpanId;
+                    agentName = typeof attrs.agentName === 'string' ? attrs.agentName : undefined;
+                }
+            });
+            if (!linkParentSpanId) {
+                continue;
+            }
+            const reqs = [...llmRequests].sort((a, b) => a.ts - b.ts);
+            const sortedTools = [...toolCalls].sort((a, b) => a.ts - b.ts);
+            const turns = reqs.map((r, turnIndex) => {
+                const nextTurnTs = reqs[turnIndex + 1]?.ts ?? Infinity;
+                const toolsForTurn = sortedTools.filter((tc) => tc.ts >= r.ts && tc.ts < nextTurnTs);
+                return {
+                    index: turnIndex,
+                    model: r.model,
+                    inputTokens: r.inputTokens,
+                    outputTokens: r.outputTokens,
+                    cachedTokens: r.cachedTokens,
+                    aiCredits: r.nanoAiu > 0 ? r.nanoAiu / 1_000_000_000 : undefined,
+                    timestamp: new Date(r.ts).toISOString(),
+                    toolCalls: toolsForTurn.map((tc) => ({
+                        name: tc.name,
+                        detail: extractToolDetail(tc.name, tc.args),
+                        inputChars: tc.inputChars,
+                        outputChars: tc.outputChars
+                    }))
+                };
+            });
+            result.set(linkParentSpanId, { agentName, turns });
+        }
+        return result;
+    }
+    async parseTurns(filePath) {
+        const userMessages = [];
+        const llmRequests = [];
+        const toolCalls = [];
+        const browserParents = new Set();
+        await this.readJsonl(filePath, (entry) => {
+            if (!entry || typeof entry !== 'object')
+                return;
+            const rec = entry;
+            const type = typeof rec.type === 'string' ? rec.type : undefined;
+            const attrs = this.asRecord(rec.attrs);
+            const spanId = typeof rec.spanId === 'string' ? rec.spanId : undefined;
+            const parentSpanId = typeof rec.parentSpanId === 'string' ? rec.parentSpanId : undefined;
+            const tsRaw = rec.ts;
+            const ts = typeof tsRaw === 'number' ? (tsRaw > 10_000_000_000 ? tsRaw : tsRaw * 1000) : Date.now();
+            if (type === 'user_message' && spanId) {
+                const content = typeof attrs.content === 'string' ? attrs.content : undefined;
+                userMessages.push({ spanId, ts, content });
+            }
+            if (type === 'llm_request' && parentSpanId) {
+                const fields = { ...attrs };
+                const model = typeof fields.model === 'string' ? fields.model : undefined;
+                const inputTokens = typeof fields.inputTokens === 'number' ? fields.inputTokens : 0;
+                const outputTokens = typeof fields.outputTokens === 'number' ? fields.outputTokens : 0;
+                const cachedTokens = typeof fields.cachedTokens === 'number' ? fields.cachedTokens : 0;
+                const nanoAiu = typeof fields.copilotUsageNanoAiu === 'number' ? fields.copilotUsageNanoAiu : 0;
+                llmRequests.push({ parentSpanId, ts, model, inputTokens, outputTokens, cachedTokens, nanoAiu });
+                const userRequest = typeof fields.userRequest === 'string' ? fields.userRequest : JSON.stringify(fields.userRequest ?? '');
+                if (userRequest.includes('Integrated Browser')) {
+                    browserParents.add(parentSpanId);
+                }
+            }
+            if (type === 'tool_call' && parentSpanId) {
+                const name = typeof rec.name === 'string' ? rec.name : undefined;
+                if (name) {
+                    const argsRaw = serializeUnknown(attrs.args ?? {});
+                    const resultRaw = serializeUnknown(attrs.result ?? '');
+                    let args = {};
+                    try {
+                        args = JSON.parse(argsRaw);
+                    }
+                    catch { /* ignore */ }
+                    toolCalls.push({
+                        parentSpanId,
+                        spanId,
+                        ts,
+                        name,
+                        args,
+                        inputChars: resultRaw.length,
+                        outputChars: argsRaw.length
+                    });
+                }
+            }
+        });
+        // A tool_call named 'runSubagent' can have its own log file (runSubagent-<label>_<id>.jsonl)
+        // sitting next to this one, containing the subagent's own llm_requests/tool_calls. That
+        // file links back via a 'subagent' entry whose parentSpanId equals this tool_call's spanId.
+        const subagentByToolSpanId = await this.parseSubagentFiles(filePath);
+        // Group llm_requests by parentSpanId
+        const llmByParent = new Map();
+        for (const req of llmRequests) {
+            const list = llmByParent.get(req.parentSpanId) ?? [];
+            list.push(req);
+            llmByParent.set(req.parentSpanId, list);
+        }
+        // Group tool_calls by parentSpanId (round), keeping ts so they can be bucketed into turns below
+        const toolsByParent = new Map();
+        for (const tc of toolCalls) {
+            const list = toolsByParent.get(tc.parentSpanId) ?? [];
+            list.push(tc);
+            toolsByParent.set(tc.parentSpanId, list);
+        }
+        const toToolCallInfo = (tc) => {
+            const subagent = tc.spanId ? subagentByToolSpanId.get(tc.spanId) : undefined;
+            return {
+                name: tc.name,
+                detail: extractToolDetail(tc.name, tc.args),
+                inputChars: tc.inputChars,
+                outputChars: tc.outputChars,
+                subagentName: subagent?.agentName,
+                subagentTurns: subagent?.turns
+            };
+        };
+        const turns = userMessages.map((msg, index) => {
+            const reqs = [...(llmByParent.get(msg.spanId) ?? [])].sort((a, b) => a.ts - b.ts);
+            const models = [...new Set(reqs.map((r) => r.model).filter((m) => !!m))].sort();
+            const inputTokens = reqs.reduce((sum, r) => sum + r.inputTokens, 0);
+            const outputTokens = reqs.reduce((sum, r) => sum + r.outputTokens, 0);
+            const cachedTokens = reqs.reduce((sum, r) => sum + r.cachedTokens, 0);
+            const totalNanoAiu = reqs.reduce((sum, r) => sum + r.nanoAiu, 0);
+            const aiCredits = totalNanoAiu > 0 ? totalNanoAiu / 1_000_000_000 : undefined;
+            const roundTools = [...(toolsByParent.get(msg.spanId) ?? [])].sort((a, b) => a.ts - b.ts);
+            // Each LLM request is one agent turn inside this round. Models can differ between
+            // turns within the same round (e.g. a subagent call runs on a different model),
+            // so expose them individually instead of only the deduped `models` summary.
+            // Tool calls are nested under the turn that triggered them: a tool call always
+            // happens after the turn that requested it and before the next turn starts, so
+            // bucket by "latest turn whose request started at or before the tool call".
+            const agentTurns = reqs.map((r, turnIndex) => {
+                const nextTurnTs = reqs[turnIndex + 1]?.ts ?? Infinity;
+                const toolsForTurn = roundTools.filter((tc) => tc.ts >= r.ts && tc.ts < nextTurnTs);
+                return {
+                    index: turnIndex,
+                    model: r.model,
+                    inputTokens: r.inputTokens,
+                    outputTokens: r.outputTokens,
+                    cachedTokens: r.cachedTokens,
+                    aiCredits: r.nanoAiu > 0 ? r.nanoAiu / 1_000_000_000 : undefined,
+                    timestamp: new Date(r.ts).toISOString(),
+                    toolCalls: toolsForTurn.map(toToolCallInfo)
+                };
+            });
+            const hasBrowserContext = browserParents.has(msg.spanId);
+            return {
+                index,
+                userMessage: msg.content,
+                timestamp: new Date(msg.ts).toISOString(),
+                models,
+                inputTokens,
+                outputTokens,
+                cachedTokens,
+                aiCredits,
+                llmRequestCount: reqs.length,
+                toolCalls: roundTools.map(toToolCallInfo),
+                turns: agentTurns,
+                hasBrowserContext
+            };
+        });
+        return turns;
+    }
+}
+function parseJsonValue(value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getToolName(tool) {
+    return (tool.name ?? tool.function?.name ?? '').trim();
+}
+function getToolDescription(tool) {
+    return tool.description ?? tool.function?.description ?? '';
+}
+function extractAvailableDeferredToolNames(value) {
+    if (typeof value !== 'string') {
+        const parsed = parseJsonValue(value);
+        if (!parsed || typeof parsed !== 'object')
+            return [];
+        return Object.values(parsed).flatMap(extractAvailableDeferredToolNames);
+    }
+    const text = value.replace(/\\r\\n|\\n|\\r/g, '\n');
+    const marker = 'Available deferred tools';
+    const markerIndex = text.indexOf(marker);
+    if (markerIndex < 0)
+        return [];
+    const blockStart = text.indexOf(':', markerIndex);
+    if (blockStart < 0)
+        return [];
+    const blockText = text.slice(blockStart + 1);
+    const names = [];
+    for (const rawLine of blockText.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line) {
+            if (names.length > 0)
+                break;
+            continue;
+        }
+        if (line.startsWith('<') || line.startsWith('{') || line.startsWith('['))
+            break;
+        if (/^[A-Za-z0-9_.-]+$/.test(line)) {
+            names.push(line);
+            continue;
+        }
+        if (names.length > 0)
+            break;
+    }
+    return names;
+}
+function extractToolDefinitionsFromText(text) {
+    if (!text.includes('defer_loading') || !text.includes('tools')) {
+        return [];
+    }
+    const tools = [];
+    const toolsKeyPattern = /"tools"\s*:\s*\[/g;
+    let match;
+    while ((match = toolsKeyPattern.exec(text))) {
+        const arrayStart = text.indexOf('[', match.index);
+        const arrayEnd = findJsonArrayEnd(text, arrayStart);
+        if (arrayStart < 0 || arrayEnd < 0)
+            continue;
+        try {
+            const parsed = JSON.parse(text.slice(arrayStart, arrayEnd + 1));
+            if (Array.isArray(parsed)) {
+                for (const item of parsed) {
+                    if (item && typeof item === 'object') {
+                        tools.push(item);
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore embedded non-JSON snippets
+        }
+        toolsKeyPattern.lastIndex = arrayEnd + 1;
+    }
+    return tools;
+}
+function findJsonArrayEnd(text, start) {
+    if (start < 0 || text[start] !== '[')
+        return -1;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = start; index < text.length; index += 1) {
+        const char = text[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (char === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (char === '[') {
+            depth += 1;
+        }
+        else if (char === ']') {
+            depth -= 1;
+            if (depth === 0) {
+                return index;
+            }
+        }
+    }
+    return -1;
+}
+function isDeferredTool(tool) {
+    return (isTruthyToolFlag(tool.defer_loading) ||
+        isTruthyToolFlag(tool.deferred) ||
+        isTruthyToolFlag(tool.isDeferred) ||
+        isTruthyToolFlag(tool.metadata?.defer_loading) ||
+        isTruthyToolFlag(tool.metadata?.deferred) ||
+        isTruthyToolFlag(tool.metadata?.isDeferred));
+}
+function isTruthyToolFlag(value) {
+    return value === true || value === 'true';
+}
+function extractToolDetail(name, args) {
+    const str = (key) => {
+        const v = args[key];
+        return typeof v === 'string' && v.trim() ? v.trim() : undefined;
+    };
+    const shortPath = (p) => p ? path.basename(p) : undefined;
+    switch (name) {
+        case 'read_file': {
+            const file = shortPath(str('filePath'));
+            const start = args['startLine'];
+            const end = args['endLine'];
+            return file ? `${file}:${start}-${end}` : undefined;
+        }
+        case 'grep_search':
+        case 'semantic_search':
+            return str('query');
+        case 'file_search':
+            return str('query') ?? str('pattern');
+        case 'list_dir':
+            return shortPath(str('path'));
+        case 'run_in_terminal': {
+            const goal = str('goal');
+            if (goal)
+                return goal;
+            const cmd = str('command');
+            return cmd ? cmd.slice(0, 80) : undefined;
+        }
+        case 'replace_string_in_file':
+        case 'create_file':
+            return shortPath(str('filePath'));
+        case 'multi_replace_string_in_file':
+            return str('explanation');
+        case 'fetch_webpage': {
+            const urls = args['urls'];
+            if (Array.isArray(urls) && urls.length > 0)
+                return String(urls[0]).slice(0, 80);
+            return undefined;
+        }
+        case 'manage_todo_list':
+            return str('operation') ?? (args['todoList'] ? 'write' : undefined);
+        default:
+            return undefined;
+    }
+}
+function serializeUnknown(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value ?? '');
+    }
+    catch {
+        return String(value ?? '');
+    }
+}
+function minIso(current, candidate) {
+    return !current || candidate < current ? candidate : current;
+}
+function maxIso(current, candidate) {
+    return !current || candidate > current ? candidate : current;
+}