@raquezha/notrace 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @raquezha/notrace
 
+## 0.2.0
+
+### Minor Changes
+
+- 382b624: Add model usage breakdowns, switch insights, lazy timeline rendering, and refreshed report samples.
+
+### Patch Changes
+
+- 04d574e: Refactor notrace report rendering into modular report-app files and add focused regression coverage without changing package dependencies or entrypoints.
+
+## 0.1.2
+
+### Patch Changes
+
+- a0f076e: Fix notrace index lock behavior under contention and add regression coverage for lock handling and usage normalization.
+- 894da0a: Add Vitest scaffolding and extract `handleSessionShutdown` for testability with no intended runtime behavior change.
+- 9d6c8b2: Skip writing per-session notrace artifacts for ghost sessions and add regression coverage for ghost vs non-ghost shutdown behavior.
+
 ## 0.1.1
 
 ### Patch Changes

package/dist/notrace/index.d.ts

@@ -1,2 +1,36 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { NotraceCaptureMode, NotraceEvent, NotraceExtensionTelemetry } from "./types.js";
+import { type WorkflowAdapter } from "./adapters.js";
+type UsageLike = {
+    input?: number;
+    output?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    totalTokens?: number;
+    cost?: {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+        total?: number;
+    };
+};
+export declare function normalizeUsage(raw: unknown): Required<Pick<UsageLike, "inputTokens" | "outputTokens" | "cacheReadTokens" | "cacheWriteTokens" | "totalTokens">> & {
+    totalCostUsd: number;
+};
+export type SessionShutdownDeps = {
+    events: NotraceEvent[];
+    startTime: number;
+    traceId: string;
+    extensionTelemetry: Map<string, NotraceExtensionTelemetry>;
+    captureMode: NotraceCaptureMode;
+    notraceDir: string;
+    adapter: WorkflowAdapter;
+};
+export declare function handleSessionShutdown(e: any, ctx: any, deps: SessionShutdownDeps): Promise<void>;
 export default function (pi: ExtensionAPI): void;
+export {};

package/dist/notrace/index.js

@@ -1,9 +1,10 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, chmodSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, chmodSync, rmSync } from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 import { execSync } from "node:child_process";
 import { getActiveAdapter } from "./adapters.js";
-import { generateHtmlReport, generateDashboardHtml } from "./renderer.js";
+import { generateHtmlReport } from "./report-app/report.js";
+import { generateDashboardHtml } from "./report-app/dashboard-report.js";
 const REDACTED = "[REDACTED by notrace]";
 const SENSITIVE_VALUE_RE = /(bearer\s+[a-z0-9._~+/=-]{12,}|sk-[a-z0-9_-]{16,}|gh[pousr]_[a-z0-9_]{16,}|AKIA[0-9A-Z]{16})/gi;
 const TELEMETRY_CHANNEL = "notrace.telemetry.extension";
@@ -40,14 +41,18 @@ function sanitizeTraceValue(value) {
 function asNumber(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
-function normalizeUsage(raw) {
+export function normalizeUsage(raw) {
     const usage = (raw && typeof raw === "object" ? raw : {});
+    const inputTokens = asNumber(usage.inputTokens ?? usage.input);
+    const outputTokens = asNumber(usage.outputTokens ?? usage.output);
+    const cacheReadTokens = asNumber(usage.cacheReadTokens ?? usage.cacheRead);
+    const cacheWriteTokens = asNumber(usage.cacheWriteTokens ?? usage.cacheWrite);
     return {
-        inputTokens: asNumber(usage.inputTokens ?? usage.input),
-        outputTokens: asNumber(usage.outputTokens ?? usage.output),
-        cacheReadTokens: asNumber(usage.cacheReadTokens ?? usage.cacheRead),
-        cacheWriteTokens: asNumber(usage.cacheWriteTokens ?? usage.cacheWrite),
-        totalTokens: asNumber(usage.totalTokens),
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+        totalTokens: usage.totalTokens == null ? inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens : asNumber(usage.totalTokens),
         totalCostUsd: asNumber(usage.cost?.total),
     };
 }
@@ -164,6 +169,129 @@ function createIndexEntry(record, htmlPath, recordPath) {
         },
     };
 }
+export async function handleSessionShutdown(e, ctx, deps) {
+    const shutdownReason = typeof e?.reason === "string" ? e.reason : null;
+    const endedAt = Date.now();
+    const context = deps.adapter.getContext(ctx.cwd);
+    const finalTraceId = ctx.sessionManager?.getSessionId?.() || deps.traceId;
+    const outputDir = path.join(deps.notraceDir, "sessions", finalTraceId.replace(/[^a-z0-9]/gi, "-"));
+    const repositoryName = path.basename(ctx.cwd);
+    let branchName = null;
+    try {
+        branchName = execSync("git branch --show-current", { cwd: ctx.cwd, stdio: ["ignore", "pipe", "ignore"], encoding: "utf8", timeout: 1000 }).trim() || null;
+    }
+    catch {
+        // not a git repo or no commits yet
+    }
+    const recordPath = path.join(outputDir, "notrace.json");
+    let mergedEvents = deps.events;
+    let originalStartedAt = deps.startTime;
+    let originalTask = null;
+    if (existsSync(recordPath)) {
+        try {
+            const oldRecord = readJsonFile(recordPath, null);
+            if (Array.isArray(oldRecord.events)) {
+                mergedEvents = [...oldRecord.events, ...deps.events];
+            }
+            if (oldRecord.session?.startedAt) {
+                originalStartedAt = new Date(oldRecord.session.startedAt).getTime();
+            }
+            if (oldRecord.task) {
+                originalTask = oldRecord.task;
+            }
+        }
+        catch (err) {
+            // ignore parse errors
+        }
+    }
+    const activity = collectActivity(mergedEvents, originalStartedAt, endedAt);
+    // Do not index purely empty ghost sessions
+    const isGhostSession = activity.llmCallCount === 0 && activity.toolCallCount === 0 && activity.totals.totalTokens === 0;
+    const telemetry = Object.fromEntries([...deps.extensionTelemetry.entries()].sort(([a], [b]) => a.localeCompare(b)));
+    const record = {
+        kind: "notrace-run",
+        schemaVersion: SCHEMA_VERSION,
+        traceId: finalTraceId,
+        repository: {
+            name: repositoryName,
+            cwd: ctx.cwd,
+            branch: branchName,
+        },
+        session: {
+            id: finalTraceId,
+            startedAt: new Date(originalStartedAt).toISOString(),
+            endedAt: new Date(endedAt).toISOString(),
+            durationMs: activity.durationMs,
+            shutdownReason,
+        },
+        task: toTaskInfo(context) || originalTask,
+        captureMode: deps.captureMode,
+        conditions: buildConditions(mergedEvents, telemetry),
+        activity,
+        telemetry: { extensions: telemetry },
+        events: mergedEvents,
+    };
+    validateRunRecord(record);
+    const htmlPath = path.join(outputDir, "notrace.html");
+    if (!isGhostSession) {
+        const html = generateHtmlReport(record);
+        mkdirSync(outputDir, { recursive: true });
+        writePrivateFileAtomic(htmlPath, html);
+        writePrivateFileAtomic(recordPath, `${JSON.stringify(record, null, 2)}\n`);
+    }
+    const indexPath = path.join(deps.notraceDir, "index.json");
+    const lockPath = `${indexPath}.lock`;
+    let lockAcquired = false;
+    for (let i = 0; i < 20; i++) {
+        try {
+            writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
+            lockAcquired = true;
+            break;
+        }
+        catch {
+            const t = Date.now();
+            while (Date.now() - t < 50) { } // busy wait 50ms
+        }
+    }
+    if (!lockAcquired) {
+        // Could not get exclusive access to the index after retrying. Skip the
+        // index/dashboard update rather than racing another process's
+        // read-modify-write on index.json. The per-session record and HTML
+        // report were already written above and are not affected.
+        console.warn(`[notrace] Could not acquire index lock, skipping index update for ${finalTraceId}`);
+    }
+    else {
+        try {
+            const existing = readJsonFile(indexPath, { sessions: [] });
+            let sessions = Array.isArray(existing.sessions) ? existing.sessions.filter((s) => s.sessionId !== finalTraceId) : [];
+            if (!isGhostSession) {
+                sessions.push(createIndexEntry(record, htmlPath, recordPath));
+            }
+            writePrivateFileAtomic(indexPath, `${JSON.stringify({ sessions }, null, 2)}\n`);
+            writePrivateFileAtomic(path.join(deps.notraceDir, "index.html"), generateDashboardHtml(sessions, {}));
+        }
+        finally {
+            if (existsSync(lockPath)) {
+                try {
+                    rmSync(lockPath);
+                }
+                catch { }
+            }
+        }
+    }
+    if (context && !isGhostSession) {
+        const displayPath = htmlPath.startsWith(os.homedir())
+            ? `~${htmlPath.slice(os.homedir().length)}`
+            : htmlPath;
+        deps.adapter.attach(context, {
+            html: displayPath,
+            record: recordPath
+        });
+    }
+    if (!isGhostSession) {
+        console.log(`\n\x1b[1m\x1b[38;5;208m[notrace] Session Retrospective: file://${htmlPath}\x1b[0m\n`);
+    }
+}
 function normalizeTelemetryPayload(raw) {
     if (!raw || typeof raw !== "object")
         return null;
@@ -194,7 +322,6 @@ export default function (pi) {
     const startTime = Date.now();
     let traceId = "";
     let activeLlmPayload = null;
-    let shutdownReason = null;
     const extensionTelemetry = new Map();
     currentMode = getInitialMode();
     if (typeof pi.events?.on === "function") {
@@ -249,115 +376,14 @@ export default function (pi) {
         }
     });
     pi.on("session_shutdown", async (e, ctx) => {
-        shutdownReason = typeof e?.reason === "string" ? e.reason : null;
-        const endedAt = Date.now();
-        const adapter = getActiveAdapter(ctx.cwd);
-        const context = adapter.getContext(ctx.cwd);
-        const notraceDir = process.env.NOTRACE_DIR || path.join(os.homedir(), ".notrace");
-        const finalTraceId = ctx.sessionManager?.getSessionId?.() || traceId;
-        const outputDir = path.join(notraceDir, "sessions", finalTraceId.replace(/[^a-z0-9]/gi, "-"));
-        const repositoryName = path.basename(ctx.cwd);
-        let branchName = null;
-        try {
-            branchName = execSync("git branch --show-current", { cwd: ctx.cwd, stdio: ["ignore", "pipe", "ignore"], encoding: "utf8", timeout: 1000 }).trim() || null;
-        }
-        catch {
-            // not a git repo or no commits yet
-        }
-        const recordPath = path.join(outputDir, "notrace.json");
-        let mergedEvents = events;
-        let originalStartedAt = startTime;
-        let originalTask = null;
-        if (existsSync(recordPath)) {
-            try {
-                const oldRecord = readJsonFile(recordPath, null);
-                if (Array.isArray(oldRecord.events)) {
-                    mergedEvents = [...oldRecord.events, ...events];
-                }
-                if (oldRecord.session?.startedAt) {
-                    originalStartedAt = new Date(oldRecord.session.startedAt).getTime();
-                }
-                if (oldRecord.task) {
-                    originalTask = oldRecord.task;
-                }
-            }
-            catch (err) {
-                // ignore parse errors
-            }
-        }
-        const activity = collectActivity(mergedEvents, originalStartedAt, endedAt);
-        // Do not index purely empty ghost sessions
-        const isGhostSession = activity.llmCallCount === 0 && activity.toolCallCount === 0 && activity.totals.totalTokens === 0;
-        const telemetry = Object.fromEntries([...extensionTelemetry.entries()].sort(([a], [b]) => a.localeCompare(b)));
-        const record = {
-            kind: "notrace-run",
-            schemaVersion: SCHEMA_VERSION,
-            traceId: finalTraceId,
-            repository: {
-                name: repositoryName,
-                cwd: ctx.cwd,
-                branch: branchName,
-            },
-            session: {
-                id: finalTraceId,
-                startedAt: new Date(originalStartedAt).toISOString(),
-                endedAt: new Date(endedAt).toISOString(),
-                durationMs: activity.durationMs,
-                shutdownReason,
-            },
-            task: toTaskInfo(context) || originalTask,
+        await handleSessionShutdown(e, ctx, {
+            events,
+            startTime,
+            traceId,
+            extensionTelemetry,
             captureMode: currentMode,
-            conditions: buildConditions(mergedEvents, telemetry),
-            activity,
-            telemetry: { extensions: telemetry },
-            events: mergedEvents,
-        };
-        validateRunRecord(record);
-        const html = generateHtmlReport(record);
-        mkdirSync(outputDir, { recursive: true });
-        const htmlPath = path.join(outputDir, "notrace.html");
-        writePrivateFileAtomic(htmlPath, html);
-        writePrivateFileAtomic(recordPath, `${JSON.stringify(record, null, 2)}\n`);
-        const indexPath = path.join(notraceDir, "index.json");
-        const lockPath = `${indexPath}.lock`;
-        let lockAcquired = false;
-        for (let i = 0; i < 20; i++) {
-            try {
-                writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
-                lockAcquired = true;
-                break;
-            }
-            catch {
-                const t = Date.now();
-                while (Date.now() - t < 50) { } // busy wait 50ms
-            }
-        }
-        try {
-            const existing = readJsonFile(indexPath, { sessions: [] });
-            let sessions = Array.isArray(existing.sessions) ? existing.sessions.filter((s) => s.sessionId !== finalTraceId) : [];
-            if (!isGhostSession) {
-                sessions.push(createIndexEntry(record, htmlPath, recordPath));
-            }
-            writePrivateFileAtomic(indexPath, `${JSON.stringify({ sessions }, null, 2)}\n`);
-            writePrivateFileAtomic(path.join(notraceDir, "index.html"), generateDashboardHtml(sessions, {}));
-        }
-        finally {
-            if (lockAcquired && existsSync(lockPath)) {
-                try {
-                    import("node:fs").then(fs => fs.rmSync ? fs.rmSync(lockPath) : fs.unlinkSync(lockPath));
-                }
-                catch { }
-            }
-        }
-        if (context) {
-            const displayPath = htmlPath.startsWith(os.homedir())
-                ? `~${htmlPath.slice(os.homedir().length)}`
-                : htmlPath;
-            adapter.attach(context, {
-                html: displayPath,
-                record: recordPath
-            });
-        }
-        console.log(`\n\x1b[1m\x1b[38;5;208m[notrace] Session Retrospective: file://${htmlPath}\x1b[0m\n`);
+            notraceDir: process.env.NOTRACE_DIR || path.join(os.homedir(), ".notrace"),
+            adapter: getActiveAdapter(ctx.cwd),
+        });
     });
 }

package/dist/notrace/report-app/__tests__/analytics.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/notrace/report-app/__tests__/analytics.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import { buildModelSummary, buildModelSwitches, groupByModel } from "../analytics.js";
+const events = [
+    { type: "llm_completion", model: "a", provider: "x", timestamp: 1000, usage: { input: 10, output: 5, totalTokens: 15, cost: { total: 1 } } },
+    { type: "llm_completion", model: "a", provider: "x", timestamp: "2026-06-17T17:00:02.000Z", usage: { input: 20, output: 10, totalTokens: 30, cost: { total: 2 } }, errorMessage: "oops" },
+    { type: "llm_completion", model: "b", provider: "y", timestamp: "2026-06-17T17:00:03.000Z", usage: { input: 40, output: 20, cost: { total: 3 } } }, // missing totalTokens
+];
+describe("report-app analytics", () => {
+    it("groups model usage and falls back when totalTokens is missing", () => {
+        const grouped = groupByModel(events);
+        expect(grouped.a.count).toBe(2);
+        expect(grouped.a.inputTokens).toBe(30);
+        expect(grouped.a.errors).toBe(1);
+        // b is missing totalTokens, should fallback to input + output (40 + 20)
+        expect(grouped.b.totalTokens).toBe(60);
+    });
+    it("tracks model switches and normalizes string timestamps", () => {
+        const switches = buildModelSwitches(events);
+        expect(switches).toHaveLength(1);
+        expect(switches[0].from).toBe("a");
+        expect(switches[0].to).toBe("b");
+        expect(switches[0].providerChanged).toBe(true);
+        // timestamp Delta between "2026-06-17T17:00:02.000Z" and "2026-06-17T17:00:03.000Z" is 1000ms
+        expect(switches[0].timeDelta).toBe(1000);
+        // falls back to input + output when totalTokens is missing
+        expect(switches[0].tokens).toBe(60);
+    });
+    it("builds summary", () => {
+        const summary = buildModelSummary(events);
+        expect(summary.firstModel).toBe("a");
+        expect(summary.finalModel).toBe("b");
+        expect(summary.switchCount).toBe(1);
+        expect(summary.uniqueModels).toBe(2);
+    });
+});

package/dist/notrace/report-app/__tests__/card.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/notrace/report-app/__tests__/card.test.js

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { renderCollapsibleSection, renderKeyValueList, renderToolResultHtml, renderToolUseHtml } from "../components/card.js";
+describe("report-app card", () => {
+    it("renders tool use and result cards", () => {
+        const useHtml = renderToolUseHtml("bash", { command: "echo hi" });
+        const resultHtml = renderToolResultHtml("tool-1", { stdout: "ok" }, true);
+        expect(useHtml).toContain("chat-tool-use");
+        expect(useHtml).toContain("bash");
+        expect(resultHtml).toContain("Tool Result: tool-1");
+        expect(resultHtml).toContain("color: var(--err);");
+    });
+    it("escapes injected content", () => {
+        const html = renderToolUseHtml("<script>alert(1)</script>", "<script>alert(1)</script>");
+        expect(html).toContain("&lt;script&gt;alert(1)&lt;/script&gt;");
+        expect(html).not.toContain("<script>alert(1)</script>");
+    });
+    it("renders collapsible sections and key-value lists", () => {
+        const section = renderCollapsibleSection("Models", "<div>body</div>", true);
+        const kv = renderKeyValueList([["A", "B"], ["Empty", ""]]);
+        expect(section).toContain("panel collapsible");
+        expect(section).toContain(" open");
+        expect(kv).toContain("kv-list");
+        expect(kv).toContain("Empty");
+        expect(kv).toContain(">-<");
+    });
+});

package/dist/notrace/report-app/__tests__/event.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/notrace/report-app/__tests__/event.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { renderEventCard } from "../components/event.js";
+describe("report-app event", () => {
+    it("escapes hostile content in lazy event body attributes", () => {
+        const hostileEvent = {
+            type: "llm_completion",
+            outputContent: '<img src=x onerror=alert(1)><script>alert(1)</script>" autofocus onfocus=alert(1)',
+            timestamp: 1000
+        };
+        const html = renderEventCard(hostileEvent);
+        // The data-lazy-event-body attribute should contain the URI-encoded then HTML-escaped string.
+        // It must NOT contain the raw dangerous strings.
+        expect(html).not.toContain("<script>alert(1)</script>");
+        expect(html).not.toContain('onerror=alert(1)');
+        expect(html).toContain("data-lazy-event-body=");
+        // Double check that the encoded payload still holds the data safely.
+        expect(html).toContain("alert(1)"); // uri encoded form might just be alert(1) but the < > and " will be %3C %3E %22
+        expect(html).toContain("%26lt%3Bscript%26gt%3Balert(1)%26lt%3B%2Fscript%26gt%3B");
+    });
+});

package/dist/notrace/report-app/__tests__/format.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/notrace/report-app/__tests__/format.test.js

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { formatDateDay, formatMs, formatTelemetryStatus, formatTimeMinutes, formatTimeSeconds, formatTokens, formatUsd, parseDate, taskDisplay, workflowClassName, workflowDisplayName } from "../format.js";
+describe("report-app format", () => {
+    it("parses valid dates and rejects invalid ones", () => {
+        expect(parseDate("2026-06-17T17:00:00Z")?.toISOString()).toBe("2026-06-17T17:00:00.000Z");
+        expect(parseDate("nope")).toBeNull();
+    });
+    it("formats date and time pieces", () => {
+        expect(formatDateDay("2026-06-17T17:00:00Z")).toBe("2026-06-17");
+        expect(formatTimeMinutes("2026-06-17T17:00:00Z")).toMatch(/^17:00|\d{2}:\d{2}$/);
+        expect(formatTimeSeconds("2026-06-17T17:00:00Z")).toMatch(/^17:00:00|\d{2}:\d{2}:\d{2}$/);
+    });
+    it("formats workflow labels and classes", () => {
+        expect(workflowDisplayName("norpiv")).toBe("RPIV");
+        expect(workflowDisplayName("research")).toBe("Research");
+        expect(workflowDisplayName(undefined)).toBe("Generic");
+        expect(workflowClassName("norpiv")).toBe("workflow-rpiv");
+        expect(workflowClassName("research")).toBe("workflow-research");
+        expect(workflowClassName(undefined)).toBe("workflow-generic");
+    });
+    it("preserves old taskDisplay semantics for direct and nested shapes", () => {
+        expect(taskDisplay({ workflow: "research", id: "branch:main" })).toBe("Branch main");
+        expect(taskDisplay({ task: { workflow: "norpiv", id: "NR-101" } })).toBe("NR-101");
+        expect(taskDisplay({ workflow: "generic" })).toBe("General session");
+        expect(taskDisplay({ workflow: "weird" })).toBe("No active task");
+    });
+    it("formats usd, tokens, durations, and telemetry status", () => {
+        expect(formatUsd(0)).toBe("$0");
+        expect(formatUsd(1.234567)).toBe("$1.23457");
+        expect(formatTokens(999)).toBe("999");
+        expect(formatTokens(1500)).toBe("1.5k");
+        expect(formatTokens(2_500_000)).toBe("2.50M");
+        expect(formatMs(0)).toBe("-");
+        expect(formatMs(15_000)).toBe("15s");
+        expect(formatMs(125_000)).toBe("2m 5s");
+        expect(formatMs(3_780_000)).toBe("1h 3m");
+        expect(formatTelemetryStatus("active")).toBe("Active");
+        expect(formatTelemetryStatus("loaded-disabled")).toBe("Loaded disabled");
+        expect(formatTelemetryStatus(undefined)).toBe("Unknown");
+    });
+});

package/dist/notrace/report-app/__tests__/report.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/notrace/report-app/__tests__/report.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { generateHtmlReport } from "../report.js";
+const record = {
+    traceId: "session-1",
+    repository: { name: "nothing", branch: "main" },
+    session: { id: "session-1", startedAt: "2026-06-17T17:00:00Z", durationMs: 15000 },
+    task: { workflow: "research", id: "branch:main" },
+    captureMode: "full",
+    conditions: { providers: ["anthropic"] },
+    activity: {
+        llmCallCount: 1,
+        toolCallCount: 1,
+        toolErrorCount: 0,
+        durationMs: 15000,
+        totals: { inputTokens: 10, outputTokens: 5, cacheReadTokens: 0, cacheWriteTokens: 0, totalTokens: 15, totalCostUsd: 0.01 },
+    },
+    telemetry: { extensions: {} },
+    events: [
+        { type: "llm_completion", model: "claude", provider: "anthropic", timestamp: 1710000000000, inputPayload: { messages: [{ role: "user", content: "hi" }] }, outputContent: "hello", usage: { totalTokens: 15, cost: { total: 0.01 } } },
+    ],
+};
+describe("report-app report", () => {
+    it("renders structural markers", () => {
+        const html = generateHtmlReport(record);
+        expect(html).toContain("Session retrospective");
+        expect(html).toContain("Run Summary");
+        expect(html).toContain("Timeline");
+        expect(html).toContain("Branch main");
+        expect(html).toContain("claude");
+    });
+});

package/dist/notrace/report-app/analytics.d.ts

@@ -0,0 +1,3 @@
+export declare function groupByModel(events: any[]): Record<string, any>;
+export declare function buildModelSwitches(events: any[]): any[];
+export declare function buildModelSummary(events: any[]): any;

package/dist/notrace/report-app/analytics.js

@@ -0,0 +1,78 @@
+export function groupByModel(events) {
+    const models = {};
+    for (const ev of events) {
+        if (ev.type !== "llm_completion")
+            continue;
+        const name = ev.model || "unknown";
+        if (!models[name]) {
+            models[name] = { count: 0, inputTokens: 0, outputTokens: 0, totalTokens: 0, cost: 0, cacheRead: 0, cacheWrite: 0, errors: 0 };
+        }
+        const m = models[name];
+        m.count++;
+        if (ev.usage) {
+            const input = Number(ev.usage.inputTokens || ev.usage.input || 0);
+            const output = Number(ev.usage.outputTokens || ev.usage.output || 0);
+            const cacheR = Number(ev.usage.cacheReadTokens || ev.usage.cacheRead || 0);
+            const cacheW = Number(ev.usage.cacheWriteTokens || ev.usage.cacheWrite || 0);
+            m.inputTokens += input;
+            m.outputTokens += output;
+            m.cacheRead += cacheR;
+            m.cacheWrite += cacheW;
+            m.totalTokens += Number(ev.usage.totalTokens || (input + output + cacheR + cacheW));
+            m.cost += Number(ev.usage.cost?.total || 0);
+        }
+        if (ev.errorMessage)
+            m.errors++;
+    }
+    return models;
+}
+export function buildModelSwitches(events) {
+    const switches = [];
+    let lastModel = null;
+    let lastProvider = null;
+    let lastTime = null;
+    let completionIndex = 0;
+    for (const ev of events) {
+        if (ev.type !== "llm_completion")
+            continue;
+        completionIndex++;
+        const currentModel = ev.model || "unknown";
+        const currentProvider = ev.provider || "unknown";
+        const currentTimestamp = ev.timestamp ? new Date(ev.timestamp).getTime() : 0;
+        const validTimestamp = Number.isNaN(currentTimestamp) ? 0 : currentTimestamp;
+        if (lastModel && lastModel !== currentModel) {
+            const input = Number(ev.usage?.inputTokens || ev.usage?.input || 0);
+            const output = Number(ev.usage?.outputTokens || ev.usage?.output || 0);
+            const cacheR = Number(ev.usage?.cacheReadTokens || ev.usage?.cacheRead || 0);
+            const cacheW = Number(ev.usage?.cacheWriteTokens || ev.usage?.cacheWrite || 0);
+            switches.push({
+                index: completionIndex,
+                from: lastModel,
+                to: currentModel,
+                fromProvider: lastProvider || "unknown",
+                toProvider: currentProvider,
+                providerChanged: (lastProvider || "unknown") !== currentProvider,
+                timestamp: validTimestamp,
+                timeDelta: lastTime ? validTimestamp - lastTime : 0,
+                cost: Number(ev.usage?.cost?.total || 0),
+                tokens: Number(ev.usage?.totalTokens || (input + output + cacheR + cacheW))
+            });
+        }
+        lastModel = currentModel;
+        lastProvider = currentProvider;
+        lastTime = validTimestamp;
+    }
+    return switches;
+}
+export function buildModelSummary(events) {
+    const completions = events.filter((ev) => ev.type === "llm_completion");
+    if (!completions.length)
+        return null;
+    const uniqueModels = new Set(completions.map((ev) => ev.model || "unknown"));
+    return {
+        firstModel: completions[0]?.model || "unknown",
+        finalModel: completions[completions.length - 1]?.model || "unknown",
+        switchCount: buildModelSwitches(events).length,
+        uniqueModels: uniqueModels.size,
+    };
+}

package/dist/notrace/report-app/client.d.ts

@@ -0,0 +1,2 @@
+export declare const COPY_SCRIPT = "(() => {\n    document.querySelectorAll('[data-copy-value]').forEach((button) => {\n      button.addEventListener('click', async () => {\n        const value = button.getAttribute('data-copy-value') || '';\n        try {\n          if (navigator.clipboard?.writeText) {\n            await navigator.clipboard.writeText(value);\n          } else {\n            const textarea = document.createElement('textarea');\n            textarea.value = value;\n            textarea.style.position = 'fixed';\n            textarea.style.opacity = '0';\n            document.body.appendChild(textarea);\n            textarea.focus();\n            textarea.select();\n            document.execCommand('copy');\n            textarea.remove();\n          }\n          const previous = button.innerHTML;\n          button.classList.add('copied');\n          button.innerHTML = '<svg width=\"14\" height=\"14\" viewBox=\"0 0 24 24\" aria-hidden=\"true\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.4\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M20 6 9 17l-5-5\"></path></svg>';\n          setTimeout(() => {\n            button.classList.remove('copied');\n            button.innerHTML = previous;\n          }, 1400);\n        } catch {\n          button.textContent = 'ERR';\n        }\n      });\n    });\n\n    document.querySelectorAll('details[data-lazy-event-body]').forEach((details) => {\n      details.addEventListener('toggle', () => {\n        if (!details.open) return;\n        if (details.querySelector('.event-body')) return;\n        const html = decodeURIComponent(details.getAttribute('data-lazy-event-body') || '');\n        details.insertAdjacentHTML('beforeend', html);\n      }, { once: false });\n    });\n\n    const topBtn = document.querySelector('.back-to-top');\n    if (topBtn) {\n      const syncTopButton = () => {\n        const scrollable = document.documentElement.scrollHeight > window.innerHeight + 24;\n        const show = scrollable && window.scrollY > 200;\n        topBtn.classList.toggle('visible', show);\n      };\n      window.addEventListener('scroll', syncTopButton, { passive: true });\n      window.addEventListener('resize', syncTopButton);\n      syncTopButton();\n    }\n  })();";
+export declare const DASHBOARD_SORT_SCRIPT = "(() => {\n    const table = document.querySelector('[data-dashboard-table]');\n    if (!table) return;\n    const tbody = table.querySelector('tbody');\n    if (!tbody) return;\n    const buttons = Array.from(document.querySelectorAll('[data-sort-key]'));\n    let currentKey = 'index';\n    let currentDir = 'desc';\n\n    function icon(dir) {\n      return dir === 'asc' ? '\u2191' : '\u2193';\n    }\n\n    function updateState() {\n      buttons.forEach(btn => {\n        const key = btn.getAttribute('data-sort-key');\n        const state = btn.querySelector('.sort-state');\n        if (!state) return;\n        state.textContent = key === currentKey ? icon(currentDir) : '';\n      });\n    }\n\n    function compare(a, b, key) {\n      if (key === 'index' || key === 'started' || key === 'tokens' || key === 'cost') {\n        return Number(a.dataset[key] || 0) - Number(b.dataset[key] || 0);\n      }\n      return String(a.dataset[key] || '').localeCompare(String(b.dataset[key] || ''));\n    }\n\n    function sortBy(key) {\n      const rows = Array.from(tbody.querySelectorAll('tr'));\n      rows.sort((a, b) => {\n        const result = compare(a, b, key);\n        return currentDir === 'asc' ? result : -result;\n      });\n      rows.forEach(row => tbody.appendChild(row));\n      updateState();\n    }\n\n    buttons.forEach(btn => {\n      btn.addEventListener('click', () => {\n        const key = btn.getAttribute('data-sort-key') || 'index';\n        if (currentKey === key) currentDir = currentDir === 'asc' ? 'desc' : 'asc';\n        else {\n          currentKey = key;\n          currentDir = key === 'workflow' ? 'asc' : 'desc';\n        }\n        sortBy(currentKey);\n      });\n    });\n\n    sortBy(currentKey);\n  })();";