noctrace 0.1.1 → 0.3.0

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

@@ -7,6 +7,54 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { parseJsonlContent, parseCompactionBoundaries, extractSessionId, extractAgentIds, parseSubAgentContent, } from '../../shared/parser';
 import { computeContextHealth } from '../../shared/health';
+import { parseAssistantTurns, computeDrift } from '../../shared/drift';
+/**
+ * Read ~/.claude/sessions/*.json and return a Set of sessionIds
+ * whose PID is still a running claude process.
+ * The registry sessionId matches the JSONL filename.
+ */
+async function getRunningSessionIds(claudeHome) {
+    const sessionsDir = path.join(claudeHome, 'sessions');
+    const running = new Set();
+    let files;
+    try {
+        files = await fs.readdir(sessionsDir);
+    }
+    catch {
+        return running;
+    }
+    for (const file of files) {
+        if (!file.endsWith('.json'))
+            continue;
+        try {
+            const raw = await fs.readFile(path.join(sessionsDir, file), 'utf8');
+            const data = JSON.parse(raw);
+            const pid = typeof data['pid'] === 'number' ? data['pid'] : null;
+            const sid = typeof data['sessionId'] === 'string' ? data['sessionId'] : null;
+            if (pid !== null && sid) {
+                try {
+                    process.kill(pid, 0);
+                    running.add(sid);
+                }
+                catch {
+                    // process not running
+                }
+            }
+        }
+        catch {
+            // skip malformed files
+        }
+    }
+    return running;
+}
+/** Validate that a resolved path is within the allowed base directory. */
+function assertWithinBase(resolved, base) {
+    const normalizedResolved = path.resolve(resolved);
+    const normalizedBase = path.resolve(base);
+    if (!normalizedResolved.startsWith(normalizedBase + path.sep) && normalizedResolved !== normalizedBase) {
+        throw new Error('Path traversal detected');
+    }
+}
 /** Build the Express router, scoped to a given Claude home directory. */
 export function buildApiRouter(claudeHome) {
     const router = Router();
@@ -29,6 +77,7 @@ export function buildApiRouter(claudeHome) {
                 res.json([]);
                 return;
             }
+            const runningSessions = await getRunningSessionIds(claudeHome);
             const projects = [];
             for (const entry of entries) {
                 const entryPath = path.join(projectsDir, entry);
@@ -63,10 +112,26 @@ export function buildApiRouter(claudeHome) {
                     }
                 }
                 const decodedPath = entry.replace(/-/g, '/');
+                // Count sessions with a live process or recent file activity
+                let activeSessionCount = 0;
+                for (const jf of jsonlFiles) {
+                    const sid = jf.replace(/\.jsonl$/, '');
+                    if (runningSessions.has(sid)) {
+                        activeSessionCount++;
+                        continue;
+                    }
+                    try {
+                        const jstat = await fs.stat(path.join(entryPath, jf));
+                        if (Date.now() - jstat.mtime.getTime() < 120_000)
+                            activeSessionCount++;
+                    }
+                    catch { /* skip */ }
+                }
                 projects.push({
                     slug: entry,
                     path: decodedPath,
                     sessionCount,
+                    activeSessionCount,
                     lastModified: latestMtime.toISOString(),
                 });
             }
@@ -88,6 +153,13 @@ export function buildApiRouter(claudeHome) {
     router.get('/sessions/:slug', async (req, res) => {
         const { slug } = req.params;
         const projectDir = path.join(projectsDir, slug);
+        try {
+            assertWithinBase(projectDir, projectsDir);
+        }
+        catch {
+            res.status(400).json({ error: 'Invalid path' });
+            return;
+        }
         try {
             let files;
             try {
@@ -97,6 +169,7 @@ export function buildApiRouter(claudeHome) {
                 res.status(404).json({ error: `Project not found: ${slug}` });
                 return;
             }
+            const runningSessions = await getRunningSessionIds(claudeHome);
             const jsonlFiles = files.filter((f) => f.endsWith('.jsonl'));
             const sessions = [];
             for (const file of jsonlFiles) {
@@ -111,31 +184,56 @@ export function buildApiRouter(claudeHome) {
                 }
                 let startTime = null;
                 let rowCount = 0;
+                let permissionMode = null;
+                let isRemoteControlled = false;
+                let isActive = false;
                 try {
                     const content = await fs.readFile(filePath, 'utf8');
-                    // Extract startTime from the first non-empty line's timestamp field
-                    const firstLine = content.split('\n').find((l) => l.trim() !== '');
-                    if (firstLine) {
+                    const lines = content.split('\n');
+                    // Extract metadata from lines (scan first 50 for speed)
+                    const scanLimit = Math.min(lines.length, 50);
+                    for (let i = 0; i < scanLimit; i++) {
+                        const line = lines[i].trim();
+                        if (!line)
+                            continue;
                         let parsed;
                         try {
-                            parsed = JSON.parse(firstLine);
+                            parsed = JSON.parse(line);
                         }
                         catch {
-                            // skip
+                            continue;
                         }
-                        if (typeof parsed === 'object' &&
-                            parsed !== null &&
-                            !Array.isArray(parsed) &&
-                            'timestamp' in parsed &&
-                            typeof parsed['timestamp'] === 'string') {
+                        // Extract startTime from first record with timestamp
+                        if (startTime === null && typeof parsed['timestamp'] === 'string') {
                             startTime = parsed['timestamp'];
                         }
+                        // Extract permissionMode from user records
+                        if (parsed['type'] === 'user' && 'permissionMode' in parsed && permissionMode === null) {
+                            permissionMode = parsed['permissionMode'] ?? null;
+                        }
+                        // Detect remote control from bridge_status system records
+                        if (parsed['type'] === 'system' && parsed['subtype'] === 'bridge_status') {
+                            isRemoteControlled = true;
+                        }
                     }
-                    rowCount = parseJsonlContent(content).length;
+                    rowCount = lines.filter((l) => l.trim()).length;
+                    // Active if: live process in registry OR file modified within last 2 minutes
+                    // Registry covers CLI sessions; mtime covers Desktop app sessions
+                    isActive = runningSessions.has(id) || (Date.now() - stat.mtime.getTime() < 120_000);
                 }
                 catch {
                     // Unreadable file — still include with null startTime
                 }
+                let driftFactor = null;
+                try {
+                    const content = await fs.readFile(filePath, 'utf8');
+                    const sessionTurns = parseAssistantTurns(content);
+                    const sessionDrift = computeDrift(sessionTurns);
+                    driftFactor = sessionTurns.length >= 5 ? sessionDrift.driftFactor : null;
+                }
+                catch {
+                    // Drift computation is best-effort — don't fail the session listing
+                }
                 sessions.push({
                     id,
                     projectSlug: slug,
@@ -143,6 +241,10 @@ export function buildApiRouter(claudeHome) {
                     startTime,
                     lastModified: stat.mtime.toISOString(),
                     rowCount,
+                    isActive,
+                    permissionMode,
+                    isRemoteControlled,
+                    driftFactor,
                 });
             }
             // Sort by lastModified descending (most recent first)
@@ -164,6 +266,13 @@ export function buildApiRouter(claudeHome) {
     router.get('/session/:slug/:id', async (req, res) => {
         const { slug, id } = req.params;
         const filePath = path.join(projectsDir, slug, `${id}.jsonl`);
+        try {
+            assertWithinBase(filePath, projectsDir);
+        }
+        catch {
+            res.status(400).json({ error: 'Invalid path' });
+            return;
+        }
         try {
             let content;
             try {
@@ -177,6 +286,8 @@ export function buildApiRouter(claudeHome) {
             const boundaries = parseCompactionBoundaries(content);
             const health = computeContextHealth(rows, boundaries.length);
             const sessionId = extractSessionId(content) ?? id;
+            const turns = parseAssistantTurns(content);
+            const drift = computeDrift(turns);
             // Load sub-agent JSONL files and attach as children to matching agent rows
             const subagentsDir = path.join(projectsDir, slug, id, 'subagents');
             let subagentsDirExists = false;
@@ -191,6 +302,9 @@ export function buildApiRouter(claudeHome) {
                 // Build a map of tool_use_id → agentId from the parent session content
                 const agentIdMap = extractAgentIds(content);
                 for (const [toolUseId, agentId] of agentIdMap) {
+                    // Validate agentId to prevent path traversal via crafted JSONL content
+                    if (!/^[a-zA-Z0-9_-]+$/.test(agentId))
+                        continue;
                     const subAgentFile = path.join(subagentsDir, `agent-${agentId}.jsonl`);
                     let subAgentContent;
                     try {
@@ -216,13 +330,18 @@ export function buildApiRouter(claudeHome) {
             for (const row of rows) {
                 if (row.type !== 'agent' || row.children.length === 0)
                     continue;
-                const childMax = Math.max(...row.children.map((c) => c.endTime ?? c.startTime));
+                let childMax = -Infinity;
+                for (const c of row.children) {
+                    const end = c.endTime ?? c.startTime;
+                    if (end > childMax)
+                        childMax = end;
+                }
                 if (childMax > (row.endTime ?? 0)) {
                     row.endTime = childMax;
                     row.duration = childMax - row.startTime;
                 }
             }
-            res.json({ rows, compactionBoundaries: boundaries, health, sessionId });
+            res.json({ rows, compactionBoundaries: boundaries, health, sessionId, drift });
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);

package/dist/server/server/watcher.js

@@ -6,6 +6,7 @@ import chokidar from 'chokidar';
 import fs from 'node:fs';
 import { parseJsonlContent, parseCompactionBoundaries } from '../shared/parser';
 import { computeContextHealth } from '../shared/health';
+import { parseAssistantTurns, computeDrift } from '../shared/drift';
 /**
  * Watch a single JSONL session file for appended content.
  * On each file change, reads only the newly appended bytes, parses them into
@@ -39,23 +40,31 @@ export function watchSession(filePath, callbacks) {
             finally {
                 fs.closeSync(fd);
             }
-            bytesRead = fileSize;
-            const newContent = buffer.toString('utf8');
-            const newRows = parseJsonlContent(newContent);
-            if (newRows.length === 0)
+            // Only advance bytesRead for complete lines to avoid partial JSONL reads
+            const raw = buffer.toString('utf8');
+            const lastNewline = raw.lastIndexOf('\n');
+            if (lastNewline === -1) {
+                // No complete line yet — wait for next change event
                 return;
-            // Re-read full file for accurate health score (it's cumulative)
+            }
+            bytesRead += Buffer.byteLength(raw.slice(0, lastNewline + 1), 'utf8');
+            // Read full file once — needed for accurate health (cumulative metrics)
+            // and to produce complete rows with correct parent-child relationships
             let fullContent = '';
             try {
                 fullContent = fs.readFileSync(filePath, 'utf8');
             }
             catch {
-                fullContent = newContent;
+                fullContent = buffer.toString('utf8');
             }
-            const boundaries = parseCompactionBoundaries(fullContent);
             const allRows = parseJsonlContent(fullContent);
+            if (allRows.length === 0)
+                return;
+            const boundaries = parseCompactionBoundaries(fullContent);
             const health = computeContextHealth(allRows, boundaries.length);
-            callbacks.onNewRows(newRows, health, boundaries);
+            const turns = parseAssistantTurns(fullContent);
+            const drift = computeDrift(turns);
+            callbacks.onNewRows(allRows, health, boundaries, drift);
         }
         catch (err) {
             console.warn('[noctrace] watcher error:', err instanceof Error ? err.message : String(err));

package/dist/server/server/ws.js

@@ -3,6 +3,7 @@
  * Mounts at /ws. One watcher per connection, cleaned up on disconnect.
  */
 import { WebSocketServer, WebSocket } from 'ws';
+import { spawn } from 'node:child_process';
 import path from 'node:path';
 import { watchSession } from './watcher';
 // ---------------------------------------------------------------------------
@@ -12,7 +13,8 @@ function isClientMessage(val) {
     if (typeof val !== 'object' || val === null)
         return false;
     const obj = val;
-    return obj['type'] === 'watch' || obj['type'] === 'unwatch';
+    return obj['type'] === 'watch' || obj['type'] === 'unwatch'
+        || obj['type'] === 'resume' || obj['type'] === 'resume-cancel';
 }
 function send(ws, msg) {
     if (ws.readyState === WebSocket.OPEN) {
@@ -28,15 +30,22 @@ function send(ws, msg) {
  * back in real time using chokidar file watching.
  */
 export function setupWebSocket(server, claudeHome) {
-    const wss = new WebSocketServer({ server, path: '/ws' });
+    const wss = new WebSocketServer({ server, path: '/ws', maxPayload: 64 * 1024 });
     wss.on('connection', (ws, _req) => {
         let stopWatcher = null;
+        let resumeProc = null;
         const stopCurrent = () => {
             if (stopWatcher) {
                 stopWatcher();
                 stopWatcher = null;
             }
         };
+        const killResume = () => {
+            if (resumeProc) {
+                resumeProc.kill('SIGTERM');
+                resumeProc = null;
+            }
+        };
         ws.on('message', (data) => {
             let parsed;
             try {
@@ -54,6 +63,107 @@ export function setupWebSocket(server, claudeHome) {
                 stopCurrent();
                 return;
             }
+            if (parsed.type === 'resume-cancel') {
+                killResume();
+                return;
+            }
+            if (parsed.type === 'resume') {
+                killResume();
+                const { sessionId, message: userMsg, fork } = parsed;
+                if (!sessionId || !userMsg) {
+                    send(ws, { type: 'resume-error', message: 'resume requires sessionId and message' });
+                    return;
+                }
+                // Validate sessionId format — must be a UUID-like string, no dashes-starting args
+                if (!/^[a-zA-Z0-9_-]+$/.test(sessionId) || sessionId.startsWith('-')) {
+                    send(ws, { type: 'resume-error', message: 'Invalid sessionId format' });
+                    return;
+                }
+                const args = ['--resume', sessionId, '--print', '--verbose', '--output-format', 'stream-json'];
+                if (fork)
+                    args.push('--fork-session');
+                args.push(userMsg);
+                try {
+                    const proc = spawn('claude', args, {
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                        env: { ...process.env },
+                    });
+                    resumeProc = proc;
+                    // Buffer for incomplete lines from chunked TCP data
+                    let lineBuffer = '';
+                    /**
+                     * Process a complete, newline-terminated stream-json line.
+                     * Extracts assistant text chunks and ignores result-type messages
+                     * (the final result is already accumulated via chunk messages).
+                     */
+                    const processLine = (line) => {
+                        if (!line.trim())
+                            return;
+                        try {
+                            const obj = JSON.parse(line);
+                            if (obj['type'] === 'assistant') {
+                                // Extract text from message content blocks
+                                const msgContent = obj['message'];
+                                if (typeof msgContent === 'object' && msgContent !== null) {
+                                    const content = msgContent['content'];
+                                    if (Array.isArray(content)) {
+                                        for (const block of content) {
+                                            if (typeof block === 'object' && block !== null &&
+                                                block['type'] === 'text' &&
+                                                typeof block['text'] === 'string') {
+                                                send(ws, { type: 'resume-chunk', text: block['text'] });
+                                            }
+                                        }
+                                    }
+                                }
+                                else if (typeof msgContent === 'string') {
+                                    send(ws, { type: 'resume-chunk', text: msgContent });
+                                }
+                            }
+                            // 'result' type: final accumulated text — no additional chunk needed
+                            // since assistant chunks have already been streamed incrementally
+                        }
+                        catch {
+                            // Non-JSON line (e.g. debug output) — ignore silently
+                        }
+                    };
+                    proc.stdout?.on('data', (chunk) => {
+                        lineBuffer += chunk.toString();
+                        const lines = lineBuffer.split('\n');
+                        // All but the last element are complete lines; last may be partial
+                        lineBuffer = lines.pop() ?? '';
+                        for (const line of lines) {
+                            processLine(line);
+                        }
+                    });
+                    proc.stdout?.on('end', () => {
+                        // Flush any remaining buffered content
+                        if (lineBuffer.trim()) {
+                            processLine(lineBuffer);
+                            lineBuffer = '';
+                        }
+                    });
+                    proc.stderr?.on('data', (_chunk) => {
+                        // Intentionally suppress stderr — claude CLI writes progress to stderr
+                        // which would pollute the chat output with non-content noise
+                    });
+                    proc.on('close', (code) => {
+                        send(ws, { type: 'resume-done', exitCode: code });
+                        if (resumeProc === proc)
+                            resumeProc = null;
+                    });
+                    proc.on('error', (err) => {
+                        send(ws, { type: 'resume-error', message: err.message });
+                        if (resumeProc === proc)
+                            resumeProc = null;
+                    });
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    send(ws, { type: 'resume-error', message: msg });
+                }
+                return;
+            }
             // Watch message
             const { slug, id } = parsed;
             if (!slug || !id) {
@@ -62,20 +172,28 @@ export function setupWebSocket(server, claudeHome) {
             }
             // Stop any existing watcher before starting a new one
             stopCurrent();
-            const filePath = path.join(claudeHome, 'projects', slug, `${id}.jsonl`);
+            const projectsBase = path.join(claudeHome, 'projects');
+            const filePath = path.join(projectsBase, slug, `${id}.jsonl`);
+            const resolved = path.resolve(filePath);
+            if (!resolved.startsWith(path.resolve(projectsBase) + path.sep)) {
+                send(ws, { type: 'error', message: 'Invalid path' });
+                return;
+            }
             const handle = watchSession(filePath, {
-                onNewRows: (rows, health, boundaries) => {
-                    send(ws, { type: 'rows', rows, health, boundaries });
+                onNewRows: (rows, health, boundaries, drift) => {
+                    send(ws, { type: 'rows', rows, health, boundaries, drift });
                 },
             });
             stopWatcher = handle.stop;
         });
         ws.on('close', () => {
             stopCurrent();
+            killResume();
         });
         ws.on('error', (err) => {
             console.warn('[noctrace] ws error:', err.message);
             stopCurrent();
+            killResume();
         });
     });
 }

package/dist/server/shared/drift.js

@@ -0,0 +1,94 @@
+const SAMPLE_SIZE = 5;
+/**
+ * Extract per-turn token usage from raw JSONL content.
+ *
+ * Scans for assistant records and sums all token usage fields per turn.
+ * Malformed lines and records missing usage data are silently skipped.
+ * Returns an array of {@link AssistantTurn} objects sorted by timestamp.
+ */
+export function parseAssistantTurns(content) {
+    const turns = [];
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '')
+            continue;
+        let record;
+        try {
+            record = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (typeof record !== 'object' ||
+            record === null ||
+            record.type !== 'assistant') {
+            continue;
+        }
+        const raw = record;
+        const usage = raw.message?.usage;
+        if (usage == null)
+            continue;
+        const inputTokens = usage.input_tokens ?? 0;
+        const outputTokens = usage.output_tokens ?? 0;
+        const cacheCreationTokens = usage.cache_creation_input_tokens ?? 0;
+        const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+        const totalTokens = inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens;
+        if (totalTokens === 0 || isNaN(totalTokens))
+            continue;
+        const timestamp = raw.timestamp != null
+            ? new Date(raw.timestamp).getTime()
+            : 0;
+        turns.push({ timestamp, totalTokens, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens });
+    }
+    return turns.sort((a, b) => a.timestamp - b.timestamp);
+}
+/**
+ * Compute token drift factor from assistant turns.
+ *
+ * Compares the average total tokens of the first {@link SAMPLE_SIZE} turns
+ * (baseline) against the last {@link SAMPLE_SIZE} turns (current).
+ * Returns a {@link DriftAnalysis} with `driftFactor = 1.0` when there is
+ * insufficient data or when baseline is zero (guards against division by zero).
+ */
+export function computeDrift(turns) {
+    const turnCount = turns.length;
+    const totalTokens = turns.reduce((sum, t) => sum + t.totalTokens, 0);
+    if (turnCount < SAMPLE_SIZE) {
+        return {
+            driftFactor: 1.0,
+            baselineTokens: 0,
+            currentTokens: 0,
+            turnCount,
+            totalTokens,
+            estimatedSavings: 0,
+        };
+    }
+    const firstSlice = turns.slice(0, SAMPLE_SIZE);
+    const lastSlice = turns.slice(-SAMPLE_SIZE);
+    const baselineTokens = Math.round(firstSlice.reduce((sum, t) => sum + t.totalTokens, 0) / SAMPLE_SIZE);
+    const currentTokens = Math.round(lastSlice.reduce((sum, t) => sum + t.totalTokens, 0) / SAMPLE_SIZE);
+    if (baselineTokens === 0) {
+        return {
+            driftFactor: 1.0,
+            baselineTokens,
+            currentTokens,
+            turnCount,
+            totalTokens,
+            estimatedSavings: 0,
+        };
+    }
+    const driftFactor = Math.round((currentTokens / baselineTokens) * 10) / 10;
+    let estimatedSavings = 0;
+    if (driftFactor > 2) {
+        // Tokens spent beyond a 2x drift threshold could be reclaimed by rotating the session
+        estimatedSavings = Math.max(0, totalTokens - turnCount * baselineTokens * 2);
+    }
+    return {
+        driftFactor,
+        baselineTokens,
+        currentTokens,
+        turnCount,
+        totalTokens,
+        estimatedSavings,
+    };
+}

package/dist/server/shared/parser.js

@@ -221,7 +221,7 @@ export function parseJsonlContent(content) {
                 : (res ? res.endTime : null);
             const effectiveDuration = agentRealDuration !== null
                 ? agentRealDuration
-                : (res ? res.endTime - startTime : null);
+                : (res ? Math.max(0, res.endTime - startTime) : null);
             pending.push({
                 id: block.id,
                 toolName: block.name,
@@ -289,6 +289,7 @@ export function parseJsonlContent(content) {
             output: p.output,
             inputTokens: p.inputTokens,
             outputTokens: p.outputTokens,
+            tokenDelta: 0,
             contextFillPercent: p.contextFillPercent,
             isReread: p.isReread,
             children: [],
@@ -321,6 +322,7 @@ export function parseJsonlContent(content) {
             output: res ? res.output : null,
             inputTokens: sp.inputTokens,
             outputTokens: sp.outputTokens,
+            tokenDelta: 0,
             contextFillPercent: ctxFill,
             isReread,
             children: [],
@@ -364,7 +366,12 @@ export function parseJsonlContent(content) {
     for (const row of rowById.values()) {
         if (row.type !== 'agent' || row.children.length === 0)
             continue;
-        const childMax = Math.max(...row.children.map((c) => c.endTime ?? c.startTime));
+        let childMax = -Infinity;
+        for (const c of row.children) {
+            const end = c.endTime ?? c.startTime;
+            if (end > childMax)
+                childMax = end;
+        }
         if (childMax > (row.endTime ?? 0)) {
             row.endTime = childMax;
             row.duration = childMax - row.startTime;
@@ -382,6 +389,19 @@ export function parseJsonlContent(content) {
     for (const row of rowById.values()) {
         row.contextFillPercent = (row.inputTokens / effectiveWindow) * 100;
     }
+    // Compute per-row token delta from consecutive inputTokens (sorted by startTime)
+    function computeDeltas(rows) {
+        const sorted = [...rows].sort((a, b) => a.startTime - b.startTime);
+        let prev = 0;
+        for (const row of sorted) {
+            row.tokenDelta = row.inputTokens > 0 ? Math.max(0, row.inputTokens - prev) : 0;
+            if (row.inputTokens > 0)
+                prev = row.inputTokens;
+            if (row.children.length > 0)
+                computeDeltas(row.children);
+        }
+    }
+    computeDeltas(top);
     return top;
 }
 /**
@@ -486,19 +506,28 @@ export function parseSubAgentContent(content) {
                 label: buildLabel(block.name, block.input),
                 startTime,
                 endTime: res ? res.endTime : null,
-                duration: res ? res.endTime - startTime : null,
+                duration: res ? Math.max(0, res.endTime - startTime) : null,
                 status: res ? (res.isError ? 'error' : 'success') : 'running',
                 parentAgentId: null,
                 input: block.input,
                 output: res ? res.output : null,
                 inputTokens,
                 outputTokens,
+                tokenDelta: 0,
                 contextFillPercent,
                 isReread,
                 children: [],
             });
         }
     }
+    // Compute per-row token delta for sub-agent rows
+    const sorted = [...rows].sort((a, b) => a.startTime - b.startTime);
+    let prevInput = 0;
+    for (const row of sorted) {
+        row.tokenDelta = row.inputTokens > 0 ? Math.max(0, row.inputTokens - prevInput) : 0;
+        if (row.inputTokens > 0)
+            prevInput = row.inputTokens;
+    }
     return rows;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noctrace",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Chrome DevTools Network-tab-style waterfall visualizer for Claude Code agent workflows",
   "type": "module",
   "license": "MIT",