npm - noctrace - Versions diffs - 0.6.0 → 0.7.0 - Mend

noctrace 0.6.0 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/README.md +15 -0
package/bin/claude-config.js +139 -0
package/bin/noctrace-mcp.js +249 -31
package/bin/noctrace.js +31 -0
package/bin/postinstall.js +52 -0
package/bin/preuninstall.js +32 -0
package/dist/client/assets/index-BWO5fecq.css +2 -0
package/dist/client/assets/index-BhUwV-5i.js +30 -0
package/dist/client/index.html +2 -2
package/dist/server/server/routes/api.js +190 -2
package/dist/server/shared/filter.js +1 -1
package/dist/server/shared/parser.js +249 -10
package/dist/server/shared/token-cost.js +68 -0
package/package.json +4 -2
package/dist/client/assets/index-C4vi082v.css +0 -2
package/dist/client/assets/index-DqY0cF0g.js +0 -30

package/dist/client/index.html CHANGED Viewed

@@ -7,8 +7,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;600;700&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-DqY0cF0g.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-C4vi082v.css">
+    <script type="module" crossorigin src="/assets/index-BhUwV-5i.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BWO5fecq.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/server/routes/api.js CHANGED Viewed

@@ -6,7 +6,7 @@ import { Router } from 'express';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { WebSocket } from 'ws';
-import { parseJsonlContent, parseCompactionBoundaries, extractSessionId, extractSessionTitle, extractAgentIds, parseSubAgentContent, } from '../../shared/parser.js';
+import { parseJsonlContent, parseCompactionBoundaries, extractSessionId, extractSessionTitle, extractAgentIds, parseSubAgentContent, parseInstructionsLoaded, } from '../../shared/parser.js';
 import { computeContextHealth } from '../../shared/health.js';
 import { parseAssistantTurns, computeDrift } from '../../shared/drift.js';
 import { attachEfficiencyTips } from '../../shared/tips.js';
@@ -66,6 +66,23 @@ function assertWithinBase(resolved, base) {
 export function buildApiRouter(claudeHome, wss) {
     const router = Router();
     const projectsDir = path.join(claudeHome, 'projects');
+    const teamsDir = path.join(claudeHome, 'teams');
+    const tasksDir = path.join(claudeHome, 'tasks');
+    /**
+     * In-memory registry of MCP-registered session paths.
+     * Populated by POST /api/sessions/register; cleared on unregister or server restart.
+     * When non-empty the client operates in "MCP mode" and shows only these sessions.
+     */
+    const registeredSessionPaths = new Set();
+    /** Broadcast a message to all connected WebSocket clients. */
+    function broadcast(msg) {
+        const payload = JSON.stringify(msg);
+        for (const client of wss.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(payload);
+            }
+        }
+    }
     // ---------------------------------------------------------------------------
     // GET /api/projects
     // ---------------------------------------------------------------------------
@@ -152,6 +169,79 @@ export function buildApiRouter(claudeHome, wss) {
         }
     });
     // ---------------------------------------------------------------------------
+    // GET /api/teams
+    // ---------------------------------------------------------------------------
+    /**
+     * Scan ~/.claude/teams/ and return an array of AgentTeam objects.
+     * Returns an empty array if the teams directory doesn't exist.
+     * Each team includes its members (from config.json) and taskCount.
+     */
+    router.get('/teams', async (_req, res) => {
+        try {
+            let teamDirs;
+            try {
+                teamDirs = await fs.readdir(teamsDir);
+            }
+            catch {
+                // Teams directory doesn't exist — this is normal when the feature is unused
+                res.json([]);
+                return;
+            }
+            const teams = [];
+            for (const teamName of teamDirs) {
+                const teamPath = path.join(teamsDir, teamName);
+                let stat;
+                try {
+                    stat = await fs.stat(teamPath);
+                }
+                catch {
+                    continue;
+                }
+                if (!stat.isDirectory())
+                    continue;
+                // Read team config.json
+                const configPath = path.join(teamPath, 'config.json');
+                let members = [];
+                try {
+                    const configRaw = await fs.readFile(configPath, 'utf8');
+                    const config = JSON.parse(configRaw);
+                    const rawMembers = Array.isArray(config['members']) ? config['members'] : [];
+                    for (const m of rawMembers) {
+                        if (typeof m !== 'object' || m === null)
+                            continue;
+                        const member = m;
+                        members.push({
+                            name: typeof member['name'] === 'string' ? member['name'] : 'Unknown',
+                            agentId: typeof member['agent_id'] === 'string' ? member['agent_id']
+                                : typeof member['agentId'] === 'string' ? member['agentId'] : '',
+                            agentType: typeof member['agent_type'] === 'string' ? member['agent_type']
+                                : typeof member['agentType'] === 'string' ? member['agentType'] : '',
+                        });
+                    }
+                }
+                catch {
+                    // config.json missing or malformed — include team with empty members
+                }
+                // Count task files in ~/.claude/tasks/{team-name}/
+                let taskCount = 0;
+                const teamTasksDir = path.join(tasksDir, teamName);
+                try {
+                    const taskFiles = await fs.readdir(teamTasksDir);
+                    taskCount = taskFiles.length;
+                }
+                catch {
+                    // Task directory doesn't exist — taskCount stays 0
+                }
+                teams.push({ name: teamName, members, taskCount });
+            }
+            res.json(teams);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ error: message });
+        }
+    });
+    // ---------------------------------------------------------------------------
     // GET /api/sessions/:slug
     // ---------------------------------------------------------------------------
     /**
@@ -300,6 +390,7 @@ export function buildApiRouter(claudeHome, wss) {
             const sessionId = extractSessionId(content) ?? id;
             const turns = parseAssistantTurns(content);
             const drift = computeDrift(turns);
+            const instructionsLoaded = parseInstructionsLoaded(content);
             // Load sub-agent JSONL files and attach as children to matching agent rows
             const subagentsDir = path.join(projectsDir, slug, id, 'subagents');
             let subagentsDirExists = false;
@@ -362,7 +453,7 @@ export function buildApiRouter(claudeHome, wss) {
                 return r.reduce((sum, row) => sum + row.tips.length + countTips(row.children), 0);
             }
             const tipCount = countTips(rows);
-            res.json({ rows, compactionBoundaries: boundaries, health, sessionId, drift, tipCount });
+            res.json({ rows, compactionBoundaries: boundaries, health, sessionId, drift, tipCount, instructionsLoaded });
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -409,5 +500,102 @@ export function buildApiRouter(claudeHome, wss) {
             res.status(500).json({ error: message });
         }
     });
+    // ---------------------------------------------------------------------------
+    // POST /api/sessions/register
+    // ---------------------------------------------------------------------------
+    /**
+     * Register an MCP-managed session path so noctrace can display it.
+     * Body: { sessionPath: string } — absolute path to a .jsonl file.
+     * Broadcasts `session-registered` to all WebSocket clients.
+     */
+    router.post('/sessions/register', async (req, res) => {
+        try {
+            const body = req.body;
+            const sessionPath = typeof body['sessionPath'] === 'string' ? body['sessionPath'] : null;
+            if (!sessionPath) {
+                res.status(400).json({ error: 'sessionPath is required' });
+                return;
+            }
+            if (!sessionPath.endsWith('.jsonl')) {
+                res.status(400).json({ error: 'sessionPath must be a .jsonl file' });
+                return;
+            }
+            // Normalize and validate that the path is within the Claude projects directory
+            const resolvedPath = path.resolve(sessionPath);
+            try {
+                assertWithinBase(resolvedPath, projectsDir);
+            }
+            catch {
+                res.status(400).json({ error: 'sessionPath must be within the Claude projects directory' });
+                return;
+            }
+            // Verify the file exists (best-effort — it may appear shortly after the MCP starts)
+            try {
+                await fs.access(resolvedPath);
+            }
+            catch {
+                // File not yet created — register anyway; the watcher will pick it up
+            }
+            registeredSessionPaths.add(resolvedPath);
+            broadcast({ type: 'session-registered', sessionPath: resolvedPath });
+            res.json({ ok: true });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ error: message });
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // POST /api/sessions/unregister
+    // ---------------------------------------------------------------------------
+    /**
+     * Remove a previously registered MCP session path from the registry.
+     * Body: { sessionPath: string }.
+     * Broadcasts `session-unregistered` to all WebSocket clients.
+     */
+    router.post('/sessions/unregister', (req, res) => {
+        try {
+            const body = req.body;
+            const sessionPath = typeof body['sessionPath'] === 'string' ? body['sessionPath'] : null;
+            if (!sessionPath) {
+                res.status(400).json({ error: 'sessionPath is required' });
+                return;
+            }
+            const resolvedPath = path.resolve(sessionPath);
+            registeredSessionPaths.delete(resolvedPath);
+            broadcast({ type: 'session-unregistered', sessionPath: resolvedPath });
+            res.json({ ok: true });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ error: message });
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // GET /api/sessions/registered
+    // ---------------------------------------------------------------------------
+    /**
+     * Return the list of currently registered MCP session paths.
+     * An empty array means standalone mode (show all sessions from disk).
+     * A non-empty array means MCP mode (show only registered sessions).
+     */
+    router.get('/sessions/registered', async (_req, res) => {
+        // Prune phantom sessions whose JSONL has not been modified in the last 5 minutes.
+        // Active sessions are written to frequently; stale ones left by SIGKILL won't be.
+        const STALE_THRESHOLD_MS = 5 * 60 * 1000;
+        for (const registeredPath of registeredSessionPaths) {
+            try {
+                const stat = await fs.stat(registeredPath);
+                if (Date.now() - stat.mtime.getTime() > STALE_THRESHOLD_MS) {
+                    registeredSessionPaths.delete(registeredPath);
+                }
+            }
+            catch {
+                // File no longer exists — remove the phantom entry
+                registeredSessionPaths.delete(registeredPath);
+            }
+        }
+        res.json({ sessions: Array.from(registeredSessionPaths) });
+    });
     return router;
 }

package/dist/server/shared/filter.js CHANGED Viewed

@@ -139,7 +139,7 @@ function rowMatchesDirect(row, parsed) {
     // Type filter (OR among typeFilters)
     if (parsed.typeFilters.length > 0) {
         const rowTypeLower = row.toolName.toLowerCase();
-        const rowKind = row.type; // 'agent' | 'tool'
+        const rowKind = row.type; // 'agent' | 'tool' | 'api-error'
         const matched = parsed.typeFilters.some((tf) => rowTypeLower === tf || rowTypeLower.includes(tf) || rowKind === tf);
         if (!matched)
             return false;

package/dist/server/shared/parser.js CHANGED Viewed

@@ -1,3 +1,4 @@
+import { getPricing, computeCost } from './token-cost.js';
 // ---------------------------------------------------------------------------
 // Type guards and helpers
 // ---------------------------------------------------------------------------
@@ -70,6 +71,40 @@ function parseLine(line, idx) {
 function isAgent(name) {
     return name === 'Agent' || name === 'Task';
 }
+/**
+ * Returns true when a tool result with is_error=true represents a tool execution
+ * failure (crash, timeout, permission denied) rather than a tool that ran and
+ * returned an error value. We distinguish by looking for crash/failure keywords
+ * in the output text.
+ */
+function isToolFailure(output) {
+    const lower = output.toLowerCase();
+    return (lower.includes('process exited with') ||
+        lower.includes('timed out') ||
+        lower.includes('timeout') ||
+        lower.includes('permission denied') ||
+        lower.includes('killed') ||
+        lower.includes('segmentation fault') ||
+        lower.includes('posttoolusedfailure') ||
+        lower.includes('tool execution failed') ||
+        lower.includes('failed to execute'));
+}
+/**
+ * Classify an API stop failure message into a short error class label.
+ * Returns e.g. "Rate Limit", "Billing Error", "Server Error", "Auth Error".
+ */
+function classifyStopFailure(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes('rate limit') || lower.includes('rate_limit') || lower.includes('429'))
+        return 'Rate Limit';
+    if (lower.includes('billing') || lower.includes('payment') || lower.includes('credit'))
+        return 'Billing Error';
+    if (lower.includes('auth') || lower.includes('unauthorized') || lower.includes('403') || lower.includes('401'))
+        return 'Auth Error';
+    if (lower.includes('overloaded') || lower.includes('529'))
+        return 'Overloaded';
+    return 'Server Error';
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -100,11 +135,15 @@ export function parseJsonlContent(content) {
         for (const block of c) {
             if (isObj(block) && block['type'] === 'tool_result' && typeof block['tool_use_id'] === 'string') {
                 const tb = block;
+                const output = extractContent(tb.content);
+                const isError = tb.is_error === true;
                 resultMap.set(tb.tool_use_id, {
                     endTime,
-                    output: extractContent(tb.content),
-                    isError: tb.is_error === true,
+                    output,
+                    isError,
+                    isFailure: isError && isToolFailure(output),
                     totalDurationMs: ur.toolUseResult?.totalDurationMs,
+                    agentType: ur.toolUseResult?.agentType,
                 });
             }
         }
@@ -199,10 +238,12 @@ export function parseJsonlContent(content) {
         const ar = rec;
         const startTime = new Date(ar.timestamp).getTime();
         const usage = ar.message.usage;
-        const inputTokens = (usage?.input_tokens ?? 0)
-            + (usage?.cache_creation_input_tokens ?? 0)
-            + (usage?.cache_read_input_tokens ?? 0);
+        const cacheReadTokens = usage?.cache_read_input_tokens ?? 0;
+        const cacheCreateTokens = usage?.cache_creation_input_tokens ?? 0;
+        const rawInputTokens = usage?.input_tokens ?? 0;
+        const inputTokens = rawInputTokens + cacheCreateTokens + cacheReadTokens;
         const outputTokens = usage?.output_tokens ?? 0;
+        const modelName = typeof ar.message.model === 'string' ? ar.message.model : null;
         const contextFillPercent = 0; // recalculated after peak detection
         for (const block of ar.message.content) {
             if (!isToolUse(block))
@@ -234,6 +275,9 @@ export function parseJsonlContent(content) {
                 output: res ? res.output : null,
                 inputTokens,
                 outputTokens,
+                cacheReadTokens,
+                cacheCreateTokens,
+                modelName,
                 contextFillPercent,
                 isReread,
                 assistantUuid: ar.uuid,
@@ -275,6 +319,12 @@ export function parseJsonlContent(content) {
     // First pass: create rows from top-level assistant records
     const rowById = new Map();
     for (const p of pending) {
+        const pricing = getPricing(p.modelName);
+        const rawInput = Math.max(0, p.inputTokens - p.cacheReadTokens - p.cacheCreateTokens);
+        const estimatedCost = p.inputTokens > 0 || p.outputTokens > 0
+            ? computeCost(pricing, rawInput, p.outputTokens, p.cacheReadTokens, p.cacheCreateTokens)
+            : null;
+        const res = resultMap.get(p.id);
         rowById.set(p.id, {
             id: p.id,
             type: isAgent(p.toolName) ? 'agent' : 'tool',
@@ -292,8 +342,12 @@ export function parseJsonlContent(content) {
             tokenDelta: 0,
             contextFillPercent: p.contextFillPercent,
             isReread: p.isReread,
+            isFailure: res?.isFailure ?? false,
             children: [],
             tips: [],
+            modelName: p.modelName,
+            estimatedCost,
+            agentType: res?.agentType ?? null,
         });
     }
     // Create rows from sub-agent progress records
@@ -326,8 +380,12 @@ export function parseJsonlContent(content) {
             tokenDelta: 0,
             contextFillPercent: ctxFill,
             isReread,
+            isFailure: res ? (res.isError && isToolFailure(res.output)) : false,
             children: [],
             tips: [],
+            modelName: null,
+            estimatedCost: null,
+            agentType: null,
         });
     }
     // Nest children: top-level rows use parentUuid ancestry, sub-agent rows use parentToolUseID
@@ -404,6 +462,52 @@ export function parseJsonlContent(content) {
         }
     }
     computeDeltas(top);
+    // Detect API stop failures from system records (rate limit, billing, auth, server errors).
+    // These appear as system records with subtype 'stop_failure' or similar.
+    // We insert them as top-level 'api-error' rows at their point in time.
+    for (const rec of records) {
+        if (rec.type !== 'system')
+            continue;
+        const sr = rec;
+        const subtype = sr.subtype ?? '';
+        const isStopFailure = subtype === 'stop_failure' ||
+            subtype === 'api_error' ||
+            subtype === 'request_failed';
+        if (!isStopFailure)
+            continue;
+        const ts = new Date(sr.timestamp).getTime();
+        // Try to extract an error message from the record's top-level fields.
+        const raw = rec;
+        const errorMsg = (typeof raw['error'] === 'string' ? raw['error'] : null) ||
+            (typeof raw['message'] === 'string' ? raw['message'] : null) ||
+            subtype;
+        const errorClass = classifyStopFailure(errorMsg);
+        const rowId = `api-error-${sr.uuid}`;
+        top.push({
+            id: rowId,
+            type: 'api-error',
+            toolName: errorClass,
+            label: errorMsg,
+            startTime: ts,
+            endTime: ts,
+            duration: 0,
+            status: 'error',
+            parentAgentId: null,
+            input: {},
+            output: errorMsg,
+            inputTokens: 0,
+            outputTokens: 0,
+            tokenDelta: 0,
+            contextFillPercent: 0,
+            isReread: false,
+            isFailure: false,
+            children: [],
+            tips: [],
+            modelName: null,
+            estimatedCost: null,
+            agentType: null,
+        });
+    }
     return top;
 }
 /**
@@ -487,10 +591,13 @@ export function parseSubAgentContent(content) {
         for (const block of c) {
             if (isObj(block) && block['type'] === 'tool_result' && typeof block['tool_use_id'] === 'string') {
                 const tb = block;
+                const output = extractContent(tb.content);
+                const isError = tb.is_error === true;
                 resultMap.set(tb.tool_use_id, {
                     endTime,
-                    output: extractContent(tb.content),
-                    isError: tb.is_error === true,
+                    output,
+                    isError,
+                    isFailure: isError && isToolFailure(output),
                 });
             }
         }
@@ -517,11 +624,15 @@ export function parseSubAgentContent(content) {
         const ar = rec;
         const startTime = new Date(ar.timestamp).getTime();
         const usage = ar.message.usage;
-        const inputTokens = (usage?.input_tokens ?? 0)
-            + (usage?.cache_creation_input_tokens ?? 0)
-            + (usage?.cache_read_input_tokens ?? 0);
+        const cacheReadTokens = usage?.cache_read_input_tokens ?? 0;
+        const cacheCreateTokens = usage?.cache_creation_input_tokens ?? 0;
+        const rawInputTokens = usage?.input_tokens ?? 0;
+        const inputTokens = rawInputTokens + cacheCreateTokens + cacheReadTokens;
         const outputTokens = usage?.output_tokens ?? 0;
+        const modelName = typeof ar.message.model === 'string' ? ar.message.model : null;
         const contextFillPercent = (inputTokens / effectiveWindow) * 100;
+        const pricing = getPricing(modelName);
+        const rawInput = Math.max(0, rawInputTokens);
         for (const block of ar.message.content) {
             if (!isToolUse(block))
                 continue;
@@ -530,6 +641,9 @@ export function parseSubAgentContent(content) {
             const isReread = fp !== null && seenPaths.has(fp);
             if (fp !== null)
                 seenPaths.add(fp);
+            const estimatedCost = inputTokens > 0 || outputTokens > 0
+                ? computeCost(pricing, rawInput, outputTokens, cacheReadTokens, cacheCreateTokens)
+                : null;
             const res = resultMap.get(block.id);
             rows.push({
                 id: block.id,
@@ -548,11 +662,57 @@ export function parseSubAgentContent(content) {
                 tokenDelta: 0,
                 contextFillPercent,
                 isReread,
+                isFailure: res?.isFailure ?? false,
                 children: [],
                 tips: [],
+                modelName,
+                estimatedCost,
+                agentType: null,
             });
         }
     }
+    // Detect API stop failures within sub-agent content
+    for (const rec of records) {
+        if (rec.type !== 'system')
+            continue;
+        const sr = rec;
+        const subtype = sr.subtype ?? '';
+        const isStopFailure = subtype === 'stop_failure' ||
+            subtype === 'api_error' ||
+            subtype === 'request_failed';
+        if (!isStopFailure)
+            continue;
+        const ts = new Date(sr.timestamp).getTime();
+        const raw = rec;
+        const errorMsg = (typeof raw['error'] === 'string' ? raw['error'] : null) ||
+            (typeof raw['message'] === 'string' ? raw['message'] : null) ||
+            subtype;
+        const errorClass = classifyStopFailure(errorMsg);
+        rows.push({
+            id: `api-error-${sr.uuid}`,
+            type: 'api-error',
+            toolName: errorClass,
+            label: errorMsg,
+            startTime: ts,
+            endTime: ts,
+            duration: 0,
+            status: 'error',
+            parentAgentId: null,
+            input: {},
+            output: errorMsg,
+            inputTokens: 0,
+            outputTokens: 0,
+            tokenDelta: 0,
+            contextFillPercent: 0,
+            isReread: false,
+            isFailure: false,
+            children: [],
+            tips: [],
+            modelName: null,
+            estimatedCost: null,
+            agentType: null,
+        });
+    }
     // Compute per-row token delta for sub-agent rows
     const sorted = [...rows].sort((a, b) => a.startTime - b.startTime);
     let prevInput = 0;
@@ -563,6 +723,85 @@ export function parseSubAgentContent(content) {
     }
     return rows;
 }
+/**
+ * Parse instruction-loading records from JSONL content.
+ * Looks for system records with subtype containing "instructions" or similar patterns,
+ * as well as user records with isMeta=true that describe loaded CLAUDE.md files.
+ * Returns a deduplicated list of InstructionFile entries. Never throws.
+ */
+export function parseInstructionsLoaded(content) {
+    const lines = content.split('\n');
+    const seen = new Set();
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!isObj(parsed))
+            continue;
+        const recordType = parsed['type'];
+        const subtype = typeof parsed['subtype'] === 'string' ? parsed['subtype'] : null;
+        // Match system records that describe loaded instruction files
+        if (recordType === 'system') {
+            // Claude Code may emit system records with subtype: "instructions_loaded",
+            // "claude_md_loaded", "context_loaded", or similar
+            const isInstructionRecord = subtype !== null && (subtype.includes('instruction') ||
+                subtype.includes('claude_md') ||
+                subtype.includes('context_load') ||
+                subtype.includes('system_prompt'));
+            if (isInstructionRecord) {
+                const filePath = typeof parsed['filePath'] === 'string' ? parsed['filePath']
+                    : typeof parsed['file_path'] === 'string' ? parsed['file_path']
+                        : typeof parsed['path'] === 'string' ? parsed['path']
+                            : null;
+                if (!filePath || seen.has(filePath))
+                    continue;
+                seen.add(filePath);
+                const loadReason = typeof parsed['reason'] === 'string' ? parsed['reason']
+                    : typeof parsed['load_reason'] === 'string' ? parsed['load_reason']
+                        : subtype ?? 'session_start';
+                const estimatedTokens = typeof parsed['tokens'] === 'number' ? parsed['tokens']
+                    : typeof parsed['token_count'] === 'number' ? parsed['token_count']
+                        : null;
+                const parentFilePath = typeof parsed['parentFilePath'] === 'string' ? parsed['parentFilePath']
+                    : typeof parsed['parent_file_path'] === 'string' ? parsed['parent_file_path']
+                        : null;
+                result.push({ filePath, loadReason, estimatedTokens, parentFilePath });
+                continue;
+            }
+        }
+        // Match user records with isMeta=true that list loaded context files
+        if (recordType === 'user' && parsed['isMeta'] === true) {
+            const metaContent = parsed['content'];
+            const contentStr = typeof metaContent === 'string' ? metaContent : '';
+            if (!contentStr)
+                continue;
+            // Look for patterns like "Loaded CLAUDE.md from /path/to/CLAUDE.md"
+            // or "Instructions loaded: /path/to/CLAUDE.md"
+            const filePathMatches = contentStr.matchAll(/(?:loaded|reading|including)[:\s]+([^\s,\n]+\.md)/gi);
+            for (const match of filePathMatches) {
+                const filePath = match[1];
+                if (!filePath || seen.has(filePath))
+                    continue;
+                seen.add(filePath);
+                result.push({
+                    filePath,
+                    loadReason: 'session_start',
+                    estimatedTokens: null,
+                    parentFilePath: null,
+                });
+            }
+        }
+    }
+    return result;
+}
 /**
  * Extract a mapping of Agent/Task tool_use IDs to sub-agent IDs from session content.
  * Returns a Map where keys are the parent tool_use.id values and values are agentId strings