npm - zeitzeuge - Versions diffs - 0.6.0 → 0.6.2 - Mend

zeitzeuge 0.6.0 → 0.6.2

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 (9) hide show

package/dist/cli.js +1006 -1027
package/dist/output/report.d.ts.map +1 -1
package/dist/vitest/index.js +1640 -1623
package/dist/vitest/listener-tracker.d.ts +7 -0
package/dist/vitest/listener-tracker.d.ts.map +1 -1
package/dist/vitest/reporter.d.ts +6 -3
package/dist/vitest/reporter.d.ts.map +1 -1
package/dist/vitest/workspace.d.ts.map +1 -1
package/package.json +1 -1

package/dist/cli.js CHANGED Viewed

@@ -1,742 +1,108 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
-// src/analysis/prompts.ts
-var SYSTEM_PROMPT = `You are an expert web performance engineer. You have access to a virtual filesystem workspace containing captured data from a real page load: heap snapshot, network trace, and Chrome runtime trace.
-## Workspace structure
-- /heap/summary.json — Parsed V8 heap snapshot: largest objects, type stats, constructor stats, detached DOM nodes, closure stats
-- /trace/summary.json — Page load metrics: timing, long tasks, render-blocking resources, resource breakdown
-- /trace/network-waterfall.json — Every network request with timing, size, priority, render-blocking status
-- /trace/asset-manifest.json — Index of all assets with paths to stored files
-- /trace/runtime/summary.json — Runtime trace overview: frame breakdown (scripting/layout/paint/GC), blocking function count, listener imbalances, GC stats
-- /trace/runtime/blocking-functions.json — Functions that blocked the main thread > 50ms, with script URL, line number, call stack, and duration
-- /trace/runtime/event-listeners.json — Event listener add/remove counts per event type, with source locations
-- /trace/runtime/frame-breakdown.json — Time spent in scripting vs layout vs paint vs GC
-- /trace/runtime/raw-events.json — Full Chrome trace events (large file — read to investigate specific function calls, layouts, GC, and event dispatches)
-- /scripts/*.js — Actual JavaScript source files captured during page load
-- /styles/*.css — Actual CSS source files
-- /html/document.html — The HTML document
-## Your workflow
-1. Read /heap/summary.json, /trace/summary.json, AND /trace/runtime/summary.json first for the big picture
-2. Identify the highest-impact issues from all datasets
-3. For each issue, dive into the relevant source files to understand the root cause
-4. Provide specific, code-level fixes
-## What to look for
-### Memory issues (from heap data)
-- Memory leaks: unbounded arrays, maps, caches that grow without bound
-- Detached DOM nodes: DOM elements removed from the document but still referenced
-- Large retained objects: single objects or trees retaining disproportionate memory
-- Closure leaks: closures capturing variables they no longer need
-### Page-load issues (from trace + source code)
-- Render-blocking scripts: <script> in <head> without async/defer — read the script to judge if it must be synchronous
-- Render-blocking CSS: large stylesheets blocking first paint
-- Long tasks (> 50ms): identify the function/module causing the block by reading the source
-- Large bundles: scripts > 100KB — search for unused imports or code that could be lazy-loaded
-- Sequential waterfalls: resources chained sequentially that could load in parallel
-### Runtime issues (from Chrome trace)
-- Frame-blocking functions: read /trace/runtime/blocking-functions.json first, then inspect the actual script source at the reported line number to understand what the function does and how to optimize it
-- Event listener leaks: check /trace/runtime/event-listeners.json for event types where addCount >> removeCount, then grep the scripts for those addEventListener calls
-- GC pressure: high GC pause counts or duration suggest excessive short-lived object creation — look for hot loops creating objects
-- Layout thrashing: forced synchronous layouts caused by reading layout properties (offsetHeight, getBoundingClientRect) after DOM writes
-## Severity classification
-Assign severity based on measured impact — do NOT guess:
-- **critical** — A blocking function >500ms, retained heap object >5MB,
-  render-blocking resource >200KB, listener addCount > 10× removeCount,
-  or GC pauses totalling >500ms
-- **warning** — A blocking function 100–500ms, retained heap object 1–5MB,
-  render-blocking resource 50–200KB, listener addCount > 2× removeCount,
-  or GC pauses totalling 100–500ms
-- **info** — Blocking function 50–100ms, retained object <1MB, minor
-  optimisation opportunities, or observations about dependency usage
-Always base severity on the actual numbers from the captured data — never inflate.
-## Verification rules
-These rules are mandatory for every finding:
-1. **ALWAYS read the source file** in /scripts/, /styles/, or /html/ and
-   verify the code BEFORE suggesting a fix. Never suggest a fix for code
-   you have not read.
-2. **Never guess at line numbers** — confirm by reading the file. If the
-   trace reports a line number but the source doesn't match, say so.
-3. Each \`suggestedFix\` MUST reference the actual current code and describe
-   what to change. Include a before/after snippet from the real source.
-4. If the heap summary, trace summary, and runtime summary all show healthy
-   numbers, state that the page is well-optimised — do NOT manufacture
-   findings.
-5. Never report a finding based solely on a URL or resource name — always
-   read the actual content to confirm the issue.
-## Cross-referencing data
-- When a script appears in BOTH /trace/runtime/blocking-functions.json (CPU)
-  AND /heap/summary.json (memory), mention both dimensions in the finding.
-- Check /trace/runtime/event-listeners.json for listener imbalances and
-  cross-reference with the actual addEventListener calls in /scripts/.
-- Use /trace/network-waterfall.json to identify sequential chains, then read
-  the initiating script to confirm the dependency.
-- When GC pauses are significant, cross-reference with heap data to identify
-  which constructors or allocation patterns are responsible.
-## Estimating impactMs
-Every finding should include an \`impactMs\` estimate when possible:
-- For render-blocking resources: impactMs ≈ the resource's load duration
-  (from the network waterfall) that could be deferred.
-- For blocking functions: impactMs ≈ the function's duration minus 50ms
-  (the long-task threshold).
-- For memory issues: impactMs may not apply — use \`retainedSize\` instead.
-- If you cannot reasonably estimate the savings, omit impactMs rather than
-  guessing.
-## Output guidelines
-- Report 3–7 findings, ordered by impact (mix of memory, page-load, and runtime if all have issues)
-- Be specific — name actual files, functions, object constructors, and retention paths
-- Provide concrete code fixes, not generic advice
-- If heap, trace, and runtime all look healthy, say so — don't manufacture issues
-## Structured output fields
-For each finding, fill in as many fields as applicable:
-- \`sourceFile\` — the workspace path (e.g. /scripts/app.js) or resource URL
-  where the issue occurs. Always set this when you can identify the file.
-- \`lineNumber\` — the 1-based line number in the source file. Only set after
-  verifying by reading the file.
-- \`confidence\` — \`high\` if you read the source and confirmed the issue,
-  \`medium\` if the profiling data strongly suggests it but you couldn't fully
-  verify, \`low\` if inferred from patterns.
-- \`estimatedSavingsMs\` — your estimate of time saved if the fix is applied.
-- \`beforeCode\` — a snippet of the CURRENT problematic code, copied from the
-  source file you read. Keep it focused (5–15 lines).
-- \`afterCode\` — the IMPROVED code snippet showing the fix. Must be a drop-in
-  replacement for \`beforeCode\`.
-- \`impactMs\` — the current measured cost (e.g. blocking function duration,
-  resource load time).`;
-// src/vitest/prompts.ts
-var VITEST_SYSTEM_PROMPT = `You are an expert in JavaScript/TypeScript performance optimization.
-You have access to a workspace containing V8 CPU profiling data captured during
-a Vitest test run. The workspace may also include V8 heap profiling data
-captured via Node's \`--heap-prof\` (allocation sampling).
-The profiling data covers BOTH the test code AND the application code being tested.
-**Your primary goal is to analyze the PERFORMANCE OF THE APPLICATION CODE
-being tested** — the functions, modules, and algorithms that the developer
-wrote and is benchmarking or testing. Test infrastructure overhead (Vitest,
-tinybench, test setup) is secondary context.
-## Source categories
-Every hot function and script in the workspace has a \`sourceCategory\` field:
-- **application** — Code in the user's project (the code being tested).
-  This is your PRIMARY focus. Find bottlenecks, inefficiencies, and
-  optimization opportunities in these functions.
-- **dependency** — Third-party code in node_modules. Report when a dependency
-  is a significant bottleneck, since the developer may be able to choose
-  an alternative, configure it differently, or avoid calling it in hot paths.
-- **test** — Test files. Only mention if the test setup itself is creating
-  artificial overhead that masks application performance.
-- **framework** — Vitest/tinybench/V8 internals. Generally ignore unless
-  they dominate the profile in an unexpected way.
-## Workspace structure
-- /summary.json — Overall test run: total tests, duration, pass/fail, GC stats
-- /timing/overview.json — Per-file test durations and individual test times
-- /timing/slow-tests.json — Tests exceeding the slow threshold
-- /profiles/index.json — Manifest mapping test files to their CPU profiles
-- /profiles/<file>.json — CPU profile summary: hot functions (with sourceCategory),
-  call trees, GC samples, script breakdown (with sourceCategory)
-- /heap-profiles/index.json — (optional) Manifest mapping test files to heap profiles
-- /heap-profiles/<file>.json — (optional) Heap profile summary: allocation hotspots,
-  per-script allocated bytes (with sourceCategory)
-- /hot-functions/application.json — **START HERE**: Hot functions from application code only.
-  Each entry includes a \`sourceSnippet\` (lines around the hot line) and \`workspacePath\`
-  (path to the full source file in the workspace) when source code is available.
-- /hot-functions/dependencies.json — Hot functions from third-party dependencies
-- /hot-functions/global.json — All hot functions across all categories
-- /scripts/application.json — Per-script time breakdown for application code
-- /scripts/dependencies.json — Per-script time breakdown for dependencies
-- /listener-tracking.json — (optional) Event listener tracking data captured from
-  worker processes. Contains per-event-type add/remove counts for EventTarget and
-  EventEmitter, plus exceedances where listener counts exceeded maxListeners.
-- /src/index.json — Mapping of source files to their hot functions (quick overview
-  of which files matter and what bottlenecks they contain)
-- /tests/<relative-path> — Test source files (directory structure preserved)
-- /src/<relative-path> — Application and dependency source files referenced by
-  hot functions (directory structure preserved from the project root)
+// src/cli.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
-## Your workflow
+// src/models/init.ts
+import { ChatOpenAI } from "@langchain/openai";
+import { ChatAnthropic } from "@langchain/anthropic";
+function initModel() {
+  const modelOverride = process.env.ZEITZEUGE_MODEL;
+  const openaiKey = process.env.OPENAI_API_KEY;
+  const anthropicKey = process.env.ANTHROPIC_API_KEY;
+  if (openaiKey) {
+    return new ChatOpenAI({
+      model: modelOverride ?? "gpt-5.2",
+      apiKey: openaiKey
+    });
+  }
+  if (anthropicKey) {
+    return new ChatAnthropic({
+      model: modelOverride ?? "claude-opus-4-6",
+      apiKey: anthropicKey
+    });
+  }
+  throw new Error(`No API key found. Set OPENAI_API_KEY or ANTHROPIC_API_KEY in your environment.
-1. Read /hot-functions/application.json FIRST — these are the application-level
-   bottlenecks the developer wants to optimize
-2. Read /scripts/application.json for the per-file view of application code time
-3. Read /hot-functions/dependencies.json for costly dependency calls
-4. If present, read /heap-profiles/index.json and /heap-profiles/<file>.json to identify
-   allocation hotspots (functions/scripts allocating lots of bytes)
-5. If present, read /listener-tracking.json for event listener add/remove patterns
-   and listener exceedances (too many listeners on a single target)
-6. Read /summary.json and /timing/overview.json for the big picture
-7. Read CPU profiles in /profiles/ for detailed call trees of the slowest tests
-8. Read the actual source code in /src/ and /tests/ to understand root causes
-9. Provide specific, actionable fixes targeting the application code
+` + `  export OPENAI_API_KEY=sk-...
+` + `  # or
+` + `  export ANTHROPIC_API_KEY=sk-ant-...
+`);
+}
-## What to look for
+// src/browser/launch.ts
+import { remote } from "webdriverio";
+async function launchBrowser(options = {}) {
+  const { headless = true } = options;
+  const browser = await remote({
+    capabilities: {
+      browserName: "chrome",
+      "goog:chromeOptions": {
+        args: [
+          ...headless ? ["--headless=new"] : [],
+          "--no-sandbox",
+          "--disable-gpu",
+          "--disable-dev-shm-usage"
+        ]
+      }
+    },
+    logLevel: "warn"
+  });
+  return browser;
+}
+async function closeBrowser(browser) {
+  try {
+    await browser.deleteSession();
+  } catch {}
+}
-### Application code bottlenecks (PRIMARY FOCUS)
-- Functions with high self time — where is the application spending CPU?
-- Expensive algorithms: O(n²) loops, unnecessary sorting, repeated work
-- String/JSON operations: excessive serialization, string concatenation in loops
-- Object allocation hotspots: functions creating many short-lived objects
-- Synchronous blocking: file I/O, crypto, or compression in hot paths
-- Redundant computation: values computed repeatedly that could be cached/memoized
-- Data structure choices: using arrays where Maps/Sets would be O(1)
-### Dependency-related bottlenecks
-- Dependencies consuming disproportionate CPU — suggest alternatives or configuration
-- Unnecessary calls to expensive dependency APIs in hot paths
-- Dependencies pulled in for simple operations that could be hand-written
-### GC pressure from application code
-- Application functions creating many temporary objects in tight loops
-- Large array/object allocations that could be pooled or reused
-- Closures capturing large scopes unnecessarily
-### Allocation hotspots (from heap profiles, if present)
-- Functions allocating a large share of total bytes (even if CPU isn't dominant)
-- Scripts/modules responsible for most allocation — suggest caching, reuse, pooling,
-  or avoiding intermediate arrays/objects
-- When allocation hotspots match CPU hotspots, prioritize fixes there first
-### Call chain analysis
-- Each hot function includes a \`callerChain\` field — the chain of callers
-  from the hot function up toward the entry point. Use this to understand
-  WHY a function is hot and which application-level call triggers it.
-- Trace expensive call trees to find which APPLICATION function triggers them
-- Follow the call tree from application entry points down to the hot leaf functions
-- Identify which application-level design decisions lead to the bottleneck
-### Event listener tracking (from /listener-tracking.json, if present)
-- **Exceedances** — when a single EventTarget or EventEmitter accumulates more
-  listeners than its maxListeners threshold (default 10), this is a strong
-  signal of a listener leak. The exceedance data includes the target type
-  (e.g. AbortSignal), event name, listener count, and a stack trace snippet
-  pointing to the code that registered the excess listener.
-- **Add/remove imbalances** — when \`addCount\` significantly exceeds
-  \`removeCount\` for a given event type, listeners are being registered but
-  not cleaned up. This causes memory growth and eventually GC pressure.
-  Look for patterns like:
-  - AbortSignal abort listeners not cleaned up (common with fetch/streams)
-  - EventEmitter listeners added in loops without corresponding removal
-  - Missing \`{ once: true }\` option or \`AbortController\` cleanup
-- When exceedances or imbalances are found, read the source code to identify
-  the root cause and suggest specific fixes (e.g. using \`AbortController\`,
-  \`removeEventListener\`, \`{ once: true }\`, or restructuring listener
-  registration to avoid accumulation).
-### Test infrastructure (SECONDARY — only if impactful)
-- Test setup creating artificial overhead that dwarfs application execution
-- Benchmarks measuring setup cost instead of application performance
-- Only mention if it prevents getting clean application performance data
-## Finding categories
-Each finding MUST use one of these exact category values:
-- **algorithm** — Inefficient algorithm: O(n²) loops, brute-force search, repeated work
-- **serialization** — Excessive JSON.stringify/parse, string concatenation, encoding
-- **allocation** — Excessive object/array creation causing GC pressure
-- **event-handling** — Listener leaks, unbounded event handler accumulation
-- **hot-function** — Generic CPU-hot function that doesn't fit a more specific category
-- **gc-pressure** — High garbage collection overhead
-- **listener-leak** — Event listeners not cleaned up properly
-- **unnecessary-computation** — Redundant work that could be cached or eliminated
-- **blocking-io** — Synchronous I/O or blocking operations in hot paths
-- **dependency-bottleneck** — Expensive dependency call the developer can optimize
-- **slow-test** — Test itself is slow due to setup or teardown
-- **expensive-setup** — Costly test setup (beforeAll/beforeEach)
-- **import-overhead** — Expensive module imports at test time
-- **other** — Doesn't fit any of the above
-Prefer more specific categories (algorithm, serialization, allocation, event-handling)
-over generic ones (hot-function, other) when the root cause is clear.
-## Severity classification
-Assign severity based on measured impact — do NOT guess:
-- **critical** — A single function consuming >15% self-time, listener exceedances
-  (count exceeding maxListeners), or GC overhead >10% of total profile duration
-- **warning** — A function consuming 5–15% self-time, listener add/remove imbalance
-  where addCount > 2× removeCount, or GC overhead between 5–10%
-- **info** — A function consuming <5% self-time, minor inefficiencies,
-  dependency observations, or small optimisation opportunities
-Always base severity on the actual numbers from the profiling data — never inflate.
-## Verification rules
-These rules are mandatory for every finding:
-1. **ALWAYS read the source file** in /src/ or /tests/ and verify the code
-   BEFORE suggesting a fix. Never suggest a fix for code you have not read.
-2. **Never guess at line numbers** — confirm by reading the file. If the profile
-   reports line 42 but the source at line 42 doesn't match, say so.
-3. Each \`suggestedFix\` MUST reference the actual current code and describe
-   what to change. Include a before/after snippet from the real source.
-4. If /hot-functions/application.json is empty or every function is <1%
-   self-time, state that the application code is efficient — do NOT
-   manufacture findings.
-5. Never report a finding based solely on a function name — always read the
-   implementation to confirm the issue exists.
-## Cross-referencing data
-- When a function appears in BOTH /hot-functions/ (CPU hotspot) AND
-  /heap-profiles/ (allocation hotspot), prioritise it and mention both
-  dimensions in the finding.
-- Cross-reference /hot-functions/ data with /heap-profiles/ when both are
-  present to find functions that are expensive in both CPU and memory.
-- Check whether hot dependency calls originate from application code by
-  tracing the call tree in /profiles/.
-- When /listener-tracking.json is present, cross-reference exceedance stack
-  traces with the source code in /src/ to pinpoint the registration site.
-- /metrics/current.json contains pre-computed aggregate metrics (suite totals,
-  CPU category breakdown, top hot functions). Use it for the big-picture
-  numbers when sizing impact.
-## Estimating impactMs
-Every finding should include an \`impactMs\` estimate when possible:
-- Use the hot function's \`selfTime\` as the baseline cost.
-- Estimate what fraction of that cost the fix would eliminate
-  (e.g. an O(n²) → O(n) fix on data of size 1000 might eliminate ~99%).
-- impactMs = selfTime × estimated fraction eliminated.
-- Example: a function with selfTime 200ms in a 1000ms run, where an
-  algorithm fix would remove ~80% of the work → impactMs ≈ 160.
-- If you cannot reasonably estimate the savings, omit impactMs rather than
-  guessing.
-## Output guidelines
-- Report 3–7 findings, ordered by impact ON THE APPLICATION CODE
-- Focus findings on functions the developer CAN change (application code first,
-  then dependency usage patterns, then test structure)
-- Be specific — name actual files, functions, line numbers from the source code
-- Provide concrete code-level fixes, not generic advice
-- When reporting a dependency bottleneck, explain what application code is
-  calling it and how the developer can reduce that cost
-- If the application code is already efficient, say so — don't force findings
-  about test infrastructure just to fill the report
-## Structured output fields
-For each finding, fill in as many fields as applicable:
-- \`sourceFile\` — the workspace path (e.g. /src/utils/parser.ts) or original
-  file path where the issue occurs. Always set this when you can identify
-  the file.
-- \`lineNumber\` — the 1-based line number in the source file. Only set after
-  verifying by reading the file.
-- \`confidence\` — \`high\` if you read the source and confirmed the issue,
-  \`medium\` if the profiling data strongly suggests it but you couldn't fully
-  verify, \`low\` if inferred from patterns.
-- \`estimatedSavingsMs\` — your estimate of time saved if the fix is applied.
-- \`beforeCode\` — a snippet of the CURRENT problematic code, copied from the
-  source file you read. Keep it focused (5–15 lines).
-- \`afterCode\` — the IMPROVED code snippet showing the fix. Must be a drop-in
-  replacement for \`beforeCode\`.
-- \`affectedTests\` — list of test names that exercise this code path and would
-  benefit from the fix.
-- \`impactMs\` — the current measured cost (e.g. selfTime of the hot function).`;
-// src/schema.ts
-import { z } from "zod";
-var ALL_CATEGORIES, FindingSchema, FindingsSchema;
-var init_schema = __esm(() => {
-  ALL_CATEGORIES = [
-    "memory-leak",
-    "large-retained-object",
-    "detached-dom",
-    "render-blocking",
-    "long-task",
-    "unused-code",
-    "waterfall-bottleneck",
-    "large-asset",
-    "frame-blocking-function",
-    "listener-leak",
-    "gc-pressure",
-    "slow-test",
-    "expensive-setup",
-    "hot-function",
-    "unnecessary-computation",
-    "import-overhead",
-    "dependency-bottleneck",
-    "algorithm",
-    "serialization",
-    "allocation",
-    "event-handling",
-    "blocking-io",
-    "other"
-  ];
-  FindingSchema = z.object({
-    severity: z.enum(["critical", "warning", "info"]),
-    title: z.string().describe("Short title for the finding"),
-    description: z.string().describe("Detailed explanation of the issue"),
-    category: z.string().describe(`Category of the performance issue. Use one of: ${ALL_CATEGORIES.join(", ")}`),
-    resourceUrl: z.string().optional().describe("URL of the resource involved"),
-    workspacePath: z.string().optional().describe("Path in the VFS workspace"),
-    impactMs: z.number().optional().describe("Estimated current cost in ms (e.g. selfTime of the hot function)"),
-    estimatedSavingsMs: z.number().optional().describe("Estimated time savings in ms if the fix is applied. Computed as impactMs × fraction eliminated by the fix."),
-    confidence: z.enum(["high", "medium", "low"]).optional().describe("How confident you are in this finding. high = verified in source code, medium = strong signal but partial verification, low = inferred from data patterns"),
-    retainedSize: z.number().optional().describe("Retained heap size in bytes"),
-    retainerPath: z.array(z.string()).optional().describe("Object retention path in the heap"),
-    sourceFile: z.string().optional().describe("Primary source file where the issue occurs (workspace path or original path)"),
-    lineNumber: z.number().optional().describe("Line number in the source file where the issue occurs (1-based)"),
-    suggestedFix: z.string().describe("Code snippet or guidance to fix the issue"),
-    beforeCode: z.string().optional().describe("The current problematic code snippet from the source file"),
-    afterCode: z.string().optional().describe("The improved code snippet that fixes the issue"),
-    testFile: z.string().optional().describe("Test file path (for test performance findings)"),
-    affectedTests: z.array(z.string()).optional().describe("Test names that would benefit from this fix (for test performance findings)"),
-    hotFunction: z.object({
-      name: z.string(),
-      scriptUrl: z.string(),
-      lineNumber: z.number(),
-      selfTime: z.number(),
-      selfPercent: z.number()
-    }).optional().describe("Hot function details (for hot-function findings)")
-  });
-  FindingsSchema = z.object({
-    findings: z.array(FindingSchema)
-  });
-});
-// src/output/progress.ts
-class TodoProgressRenderer {
-  spinner;
-  lastStatusByKey = new Map;
-  lastInProgressKey;
-  baseSpinnerText;
-  printedHeader = false;
-  constructor(spinner) {
-    this.spinner = spinner;
-    this.baseSpinnerText = spinner.text;
-  }
-  printHeaderOnce() {
-    if (this.printedHeader)
-      return;
-    this.printedHeader = true;
-    const header = "Performance analysis progress:";
-    this.spinner.stopAndPersist({ symbol: " ", text: header });
-    this.spinner.start();
+// src/browser/runtime-trace.ts
+var SCRIPTING_EVENTS = new Set([
+  "FunctionCall",
+  "EvaluateScript",
+  "TimerFire",
+  "RequestAnimationFrame",
+  "FireAnimationFrame"
+]);
+var LAYOUT_EVENTS = new Set(["Layout", "UpdateLayoutTree", "RecalculateStyles"]);
+var PAINTING_EVENTS = new Set(["Paint", "CompositeLayers", "RasterTask"]);
+var GC_EVENT_NAMES = new Set(["MajorGC", "MinorGC"]);
+var BLOCKING_EVENT_NAMES = new Set(["FunctionCall", "EvaluateScript"]);
+var BLOCKING_THRESHOLD_US = 50000;
+function parseRuntimeTrace(traceEvents, navigationStartTs) {
+  if (traceEvents.length === 0) {
+    return emptyRuntimeTrace();
   }
-  handleChunk(chunk) {
-    const todos = extractTodosFromStreamChunk(chunk);
-    if (!todos)
-      return;
-    for (const todo of todos) {
-      const key = todo.id && String(todo.id) || todo.content;
-      const prevStatus = this.lastStatusByKey.get(key);
-      const nextStatus = todo.status;
-      if (prevStatus !== nextStatus) {
-        this.lastStatusByKey.set(key, nextStatus);
-        if (nextStatus === "completed" && prevStatus !== "completed") {
-          this.printHeaderOnce();
-          this.spinner.stopAndPersist({ symbol: " ", text: `  ✓ ${todo.content}` });
-          this.spinner.start();
-        }
-        if (nextStatus === "in_progress" && this.lastInProgressKey !== key) {
-          this.lastInProgressKey = key;
-          this.printHeaderOnce();
-          const base = this.baseSpinnerText ?? this.spinner.text;
-          this.spinner.text = base ? `${base} (${todo.content})` : todo.content;
-        }
-      }
-    }
+  const mainThreadId = findMainThread(traceEvents);
+  const mainEvents = traceEvents.filter((e) => e.tid === mainThreadId);
+  const blockingFunctions = extractBlockingFunctions(mainEvents, navigationStartTs);
+  const eventListeners = extractEventListenerInfo(mainEvents);
+  const frameBreakdown = buildFrameBreakdown(mainEvents);
+  const gcEvents = extractGCEvents(mainEvents, navigationStartTs);
+  const frequentEvents = findFrequentEvents(mainEvents);
+  let minTs = Infinity;
+  let maxTs = -Infinity;
+  for (const e of traceEvents) {
+    if (e.ts < minTs)
+      minTs = e.ts;
+    const endTs = e.ts + (e.dur ?? 0);
+    if (endTs > maxTs)
+      maxTs = endTs;
   }
-}
-function extractTodosFromStreamChunk(chunk) {
-  if (!chunk || typeof chunk !== "object")
-    return;
-  const direct = chunk;
-  if (Array.isArray(direct.todos))
-    return direct.todos;
-  for (const value of Object.values(chunk)) {
-    if (!value || typeof value !== "object")
-      continue;
-    const nested = value;
-    if (Array.isArray(nested.todos))
-      return nested.todos;
-  }
-}
-// src/analysis/agent.ts
-var exports_agent = {};
-__export(exports_agent, {
-  formatBytes: () => formatBytes,
-  analyzeTestPerformance: () => analyzeTestPerformance,
-  analyze: () => analyze
-});
-import {
-  createDeepAgent
-} from "deepagents";
-import { providerStrategy } from "langchain";
-async function invokeWithTodoStreaming(agent, userMessage, spinner) {
-  const renderer = new TodoProgressRenderer(spinner);
-  const stream = await agent.stream({ messages: [{ role: "user", content: userMessage }] }, { streamMode: ["updates", "values"] });
-  let lastValues;
-  for await (const item of stream) {
-    if (Array.isArray(item) && item.length === 2) {
-      const mode = item[0];
-      const chunk = item[1];
-      renderer.handleChunk(chunk);
-      if (mode === "values")
-        lastValues = chunk;
-      continue;
-    }
-    renderer.handleChunk(item);
-    lastValues = item;
-  }
-  return lastValues;
-}
-function buildPageLoadUserMessage(ctx) {
-  const { url, heapSummary, traceResult } = ctx;
-  const m = traceResult.metrics;
-  const reqCount = traceResult.networkRequests.length;
-  const renderBlocking = traceResult.networkRequests.filter((r) => r.isRenderBlocking).length;
-  const totalTransfer = traceResult.networkRequests.reduce((s, r) => s + r.encodedSize, 0);
-  const hasRuntime = !!traceResult.runtimeTrace;
-  const lines = [
-    "Analyze the frontend performance data in this workspace.",
-    "",
-    `URL: ${url}`,
-    `Page load: ${Math.round(m.loadComplete)}ms | FCP: ${Math.round(m.firstContentfulPaint)}ms | LCP: ${Math.round(m.largestContentfulPaint)}ms | TBT: ${Math.round(m.totalBlockingTime)}ms`,
-    `Heap: ${formatBytes(heapSummary.metadata.totalSize)} total, ${heapSummary.metadata.nodeCount.toLocaleString()} nodes, ${heapSummary.detachedNodes.count} detached DOM nodes`,
-    `Network: ${reqCount} requests, ${formatBytes(totalTransfer)} transferred, ${renderBlocking} render-blocking`,
-    `Long tasks: ${m.longTasks.length}`
-  ];
-  if (hasRuntime) {
-    const rt = traceResult.runtimeTrace;
-    lines.push(`Runtime trace: ${rt.blockingFunctions.length} blocking functions, ${rt.gcEvents.length} GC events (${Math.round(rt.gcEvents.reduce((s, e) => s + e.duration, 0))}ms total)`);
-  }
-  lines.push("", "Available data:", "- /heap/summary.json — parsed heap snapshot", "- /trace/summary.json — page load metrics", "- /trace/network-waterfall.json — request timing and sizes", "- /trace/asset-manifest.json — index of stored assets");
-  if (hasRuntime) {
-    lines.push("- /trace/runtime/summary.json — runtime trace overview", "- /trace/runtime/blocking-functions.json — main thread blocking functions", "- /trace/runtime/event-listeners.json — listener add/remove counts", "- /trace/runtime/frame-breakdown.json — scripting vs layout vs paint vs GC", "- /trace/runtime/raw-events.json — full Chrome trace events");
-  }
-  lines.push("- /scripts/ — JavaScript source files", "- /styles/ — CSS source files", "- /html/document.html — page markup", "", "Explore the workspace, read source files to verify root causes, and provide code-level fixes.");
-  return lines.join(`
-`);
-}
-async function analyze(model, backend, spinner, context) {
-  const agent = createDeepAgent({
-    model,
-    systemPrompt: SYSTEM_PROMPT,
-    backend,
-    responseFormat: providerStrategy(FindingsSchema)
-  });
-  const userMessage = context ? buildPageLoadUserMessage(context) : [
-    "Analyze the frontend performance data in this workspace.",
-    "",
-    "Start by reading /heap/summary.json, /trace/summary.json, and /trace/runtime/summary.json",
-    "to understand the overall picture, then explore source files to verify root causes."
-  ].join(`
-`);
-  const result = await invokeWithTodoStreaming(agent, userMessage, spinner);
-  const findings = result.structuredResponse.findings;
-  if (!Array.isArray(findings)) {
-    throw new Error("Agent did not return structured findings.");
-  }
-  return findings;
-}
-function buildVitestUserMessage(ctx) {
-  const { metrics, hasHeapProfiles, hasListenerTracking } = ctx;
-  const lines = [
-    "Analyze the performance of the APPLICATION CODE being tested in this Vitest workspace.",
-    "",
-    `Test suite: ${metrics.suite.totalTests} tests, total duration ${metrics.suite.totalDuration}ms`,
-    `CPU breakdown: application ${metrics.cpu.applicationPercent}%, dependencies ${metrics.cpu.dependencyPercent}%, GC ${metrics.cpu.gcPercentage}%, idle ${metrics.cpu.idlePercentage}%`,
-    `Slowest file: ${metrics.suite.slowestFile} (${metrics.suite.slowestFileDuration}ms)`,
-    `Slowest test: ${metrics.suite.slowestTestName} (${metrics.suite.slowestTestDuration}ms)`,
-    "",
-    "Available data:",
-    "- /hot-functions/application.json — application-level CPU hotspots",
-    "- /scripts/application.json — per-file CPU time for application code",
-    "- /hot-functions/dependencies.json — dependency CPU hotspots",
-    "- /scripts/dependencies.json — per-file CPU time for dependencies"
-  ];
-  if (hasListenerTracking) {
-    lines.push("- /listener-tracking.json — event listener add/remove patterns and exceedances");
-  }
-  if (hasHeapProfiles) {
-    lines.push("- /heap-profiles/index.json — heap profile manifest", "- /heap-profiles/<file>.json — per-file allocation hotspots");
-  }
-  lines.push("- /summary.json — overall test run summary", "- /timing/overview.json — per-file test durations", "- /timing/slow-tests.json — tests exceeding the slow threshold", "- /profiles/ — full CPU profile summaries with call trees", "- /metrics/current.json — pre-computed aggregate metrics", "- /src/ and /tests/ — source files", "", "Focus findings on the APPLICATION code — what can the developer change in their own", "codebase to improve performance? Read source files to verify root causes before suggesting fixes.");
-  return lines.join(`
-`);
-}
-async function analyzeTestPerformance(model, backend, spinner, context) {
-  const agent = createDeepAgent({
-    model,
-    systemPrompt: VITEST_SYSTEM_PROMPT,
-    backend,
-    responseFormat: providerStrategy(FindingsSchema)
-  });
-  const userMessage = context ? buildVitestUserMessage(context) : [
-    "Analyze the performance of the APPLICATION CODE being tested in this Vitest workspace.",
-    "",
-    "Start with /hot-functions/application.json, then explore source files to verify",
-    "root causes and provide code-level fixes."
-  ].join(`
-`);
-  const result = await invokeWithTodoStreaming(agent, userMessage, spinner);
-  const findings = result.structuredResponse?.findings;
-  if (!Array.isArray(findings)) {
-    throw new Error(`Failed to analyze test performance: ${result.messages.at(-1)?.text}`);
-  }
-  return findings;
-}
-function formatBytes(bytes) {
-  if (bytes < 1024)
-    return `${bytes} B`;
-  if (bytes < 1024 * 1024)
-    return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-var init_agent = __esm(() => {
-  init_schema();
-});
-// src/cli.ts
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-// src/models/init.ts
-import { ChatOpenAI } from "@langchain/openai";
-import { ChatAnthropic } from "@langchain/anthropic";
-function initModel() {
-  const modelOverride = process.env.ZEITZEUGE_MODEL;
-  const openaiKey = process.env.OPENAI_API_KEY;
-  const anthropicKey = process.env.ANTHROPIC_API_KEY;
-  if (openaiKey) {
-    return new ChatOpenAI({
-      model: modelOverride ?? "gpt-5.2",
-      apiKey: openaiKey
-    });
-  }
-  if (anthropicKey) {
-    return new ChatAnthropic({
-      model: modelOverride ?? "claude-opus-4-6",
-      apiKey: anthropicKey
-    });
-  }
-  throw new Error(`No API key found. Set OPENAI_API_KEY or ANTHROPIC_API_KEY in your environment.
-` + `  export OPENAI_API_KEY=sk-...
-` + `  # or
-` + `  export ANTHROPIC_API_KEY=sk-ant-...
-`);
-}
-// src/browser/launch.ts
-import { remote } from "webdriverio";
-async function launchBrowser(options = {}) {
-  const { headless = true } = options;
-  const browser = await remote({
-    capabilities: {
-      browserName: "chrome",
-      "goog:chromeOptions": {
-        args: [
-          ...headless ? ["--headless=new"] : [],
-          "--no-sandbox",
-          "--disable-gpu",
-          "--disable-dev-shm-usage"
-        ]
-      }
-    },
-    logLevel: "warn"
-  });
-  return browser;
-}
-async function closeBrowser(browser) {
-  try {
-    await browser.deleteSession();
-  } catch {}
-}
-// src/browser/runtime-trace.ts
-var SCRIPTING_EVENTS = new Set([
-  "FunctionCall",
-  "EvaluateScript",
-  "TimerFire",
-  "RequestAnimationFrame",
-  "FireAnimationFrame"
-]);
-var LAYOUT_EVENTS = new Set(["Layout", "UpdateLayoutTree", "RecalculateStyles"]);
-var PAINTING_EVENTS = new Set(["Paint", "CompositeLayers", "RasterTask"]);
-var GC_EVENT_NAMES = new Set(["MajorGC", "MinorGC"]);
-var BLOCKING_EVENT_NAMES = new Set(["FunctionCall", "EvaluateScript"]);
-var BLOCKING_THRESHOLD_US = 50000;
-function parseRuntimeTrace(traceEvents, navigationStartTs) {
-  if (traceEvents.length === 0) {
-    return emptyRuntimeTrace();
-  }
-  const mainThreadId = findMainThread(traceEvents);
-  const mainEvents = traceEvents.filter((e) => e.tid === mainThreadId);
-  const blockingFunctions = extractBlockingFunctions(mainEvents, navigationStartTs);
-  const eventListeners = extractEventListenerInfo(mainEvents);
-  const frameBreakdown = buildFrameBreakdown(mainEvents);
-  const gcEvents = extractGCEvents(mainEvents, navigationStartTs);
-  const frequentEvents = findFrequentEvents(mainEvents);
-  let minTs = Infinity;
-  let maxTs = -Infinity;
-  for (const e of traceEvents) {
-    if (e.ts < minTs)
-      minTs = e.ts;
-    const endTs = e.ts + (e.dur ?? 0);
-    if (endTs > maxTs)
-      maxTs = endTs;
-  }
-  const traceDuration = (maxTs - minTs) / 1000;
-  return {
-    totalEvents: traceEvents.length,
-    mainThreadId,
-    traceDuration,
-    frameBreakdown,
-    blockingFunctions,
-    eventListeners,
-    gcEvents,
-    frequentEvents
-  };
+  const traceDuration = (maxTs - minTs) / 1000;
+  return {
+    totalEvents: traceEvents.length,
+    mainThreadId,
+    traceDuration,
+    frameBreakdown,
+    blockingFunctions,
+    eventListeners,
+    gcEvents,
+    frequentEvents
+  };
 }
 function findMainThread(events) {
   const metadata = events.find((e) => e.cat === "__metadata" && e.name === "thread_name" && e.args?.name === "CrRendererMain");
@@ -1107,313 +473,923 @@ async function tracePageLoad(cdpSession, _options = {}) {
   };
 }
-// src/browser/capture.ts
-async function capturePage(browser, url, options = {}) {
-  const { timeout = 30000 } = options;
-  const puppeteerBrowser = await browser.getPuppeteer();
-  const pages = await puppeteerBrowser.pages();
-  const page = pages[0];
-  if (!page) {
-    throw new Error("No page found in Puppeteer browser");
-  }
-  const cdpSession = await page.createCDPSession();
-  const traceHandle = await tracePageLoad(cdpSession, options);
-  await page.goto(url, {
-    waitUntil: "load",
-    timeout
-  });
-  await new Promise((r) => setTimeout(r, 2000));
-  const traceResult = await traceHandle.stop();
-  await cdpSession.send("HeapProfiler.enable");
-  const chunks = [];
-  cdpSession.on("HeapProfiler.addHeapSnapshotChunk", (params) => {
-    chunks.push(params.chunk);
-  });
-  await cdpSession.send("HeapProfiler.collectGarbage");
-  await cdpSession.send("HeapProfiler.takeHeapSnapshot", {
-    reportProgress: false
-  });
-  await cdpSession.send("HeapProfiler.disable");
-  await cdpSession.detach();
-  return {
-    heapSnapshot: {
-      data: chunks.join(""),
-      capturedAt: Date.now(),
-      url
-    },
-    trace: traceResult
-  };
-}
+// src/browser/capture.ts
+async function capturePage(browser, url, options = {}) {
+  const { timeout = 30000 } = options;
+  const puppeteerBrowser = await browser.getPuppeteer();
+  const pages = await puppeteerBrowser.pages();
+  const page = pages[0];
+  if (!page) {
+    throw new Error("No page found in Puppeteer browser");
+  }
+  const cdpSession = await page.createCDPSession();
+  const traceHandle = await tracePageLoad(cdpSession, options);
+  await page.goto(url, {
+    waitUntil: "load",
+    timeout
+  });
+  await new Promise((r) => setTimeout(r, 2000));
+  const traceResult = await traceHandle.stop();
+  await cdpSession.send("HeapProfiler.enable");
+  const chunks = [];
+  cdpSession.on("HeapProfiler.addHeapSnapshotChunk", (params) => {
+    chunks.push(params.chunk);
+  });
+  await cdpSession.send("HeapProfiler.collectGarbage");
+  await cdpSession.send("HeapProfiler.takeHeapSnapshot", {
+    reportProgress: false
+  });
+  await cdpSession.send("HeapProfiler.disable");
+  await cdpSession.detach();
+  return {
+    heapSnapshot: {
+      data: chunks.join(""),
+      capturedAt: Date.now(),
+      url
+    },
+    trace: traceResult
+  };
+}
+// src/analysis/parser.ts
+function parseSnapshot(rawSnapshot) {
+  const v8 = JSON.parse(rawSnapshot.data);
+  const meta = v8.snapshot.meta;
+  const nodeFieldCount = meta.node_fields.length;
+  const edgeFieldCount = meta.edge_fields.length;
+  const nodeTypes = meta.node_types[0];
+  const edgeTypes = meta.edge_types[0];
+  const nodeTypeIdx = meta.node_fields.indexOf("type");
+  const nodeNameIdx = meta.node_fields.indexOf("name");
+  const nodeIdIdx = meta.node_fields.indexOf("id");
+  const nodeSelfSizeIdx = meta.node_fields.indexOf("self_size");
+  const nodeEdgeCountIdx = meta.node_fields.indexOf("edge_count");
+  const nodeDetachednessIdx = meta.node_fields.indexOf("detachedness");
+  const edgeTypeIdx = meta.edge_fields.indexOf("type");
+  const edgeNameIdx = meta.edge_fields.indexOf("name_or_index");
+  const edgeToNodeIdx = meta.edge_fields.indexOf("to_node");
+  const nodeCount = v8.snapshot.node_count;
+  const nodes = [];
+  let edgeOffset = 0;
+  let totalSize = 0;
+  for (let i = 0;i < nodeCount; i++) {
+    const base = i * nodeFieldCount;
+    const selfSize = v8.nodes[base + nodeSelfSizeIdx] ?? 0;
+    totalSize += selfSize;
+    nodes.push({
+      ordinal: i,
+      type: nodeTypes[v8.nodes[base + nodeTypeIdx] ?? 0] ?? "unknown",
+      name: v8.strings[v8.nodes[base + nodeNameIdx] ?? 0] ?? "",
+      id: v8.nodes[base + nodeIdIdx] ?? 0,
+      selfSize,
+      edgeCount: v8.nodes[base + nodeEdgeCountIdx] ?? 0,
+      detachedness: nodeDetachednessIdx >= 0 ? v8.nodes[base + nodeDetachednessIdx] ?? 0 : 0,
+      edgeStartIndex: edgeOffset
+    });
+    edgeOffset += (v8.nodes[base + nodeEdgeCountIdx] ?? 0) * edgeFieldCount;
+  }
+  const adjacency = Array.from({ length: nodeCount }, () => []);
+  for (let i = 0;i < nodeCount; i++)
+    adjacency[i] = [];
+  const reverseAdj = Array.from({ length: nodeCount }, () => []);
+  for (let i = 0;i < nodeCount; i++)
+    reverseAdj[i] = [];
+  for (let i = 0;i < nodeCount; i++) {
+    const node = nodes[i];
+    for (let e = 0;e < node.edgeCount; e++) {
+      const edgeBase = node.edgeStartIndex + e * edgeFieldCount;
+      const edgeTypeVal = edgeTypes[v8.edges[edgeBase + edgeTypeIdx] ?? 0];
+      if (edgeTypeVal === "weak")
+        continue;
+      const toNodeArrayIdx = v8.edges[edgeBase + edgeToNodeIdx] ?? 0;
+      const toOrdinal = toNodeArrayIdx / nodeFieldCount;
+      if (toOrdinal >= 0 && toOrdinal < nodeCount) {
+        adjacency[i].push(toOrdinal);
+        reverseAdj[toOrdinal].push(i);
+      }
+    }
+  }
+  const visited = new Uint8Array(nodeCount);
+  const bfsOrder = [];
+  const queue = [0];
+  visited[0] = 1;
+  while (queue.length > 0) {
+    const curr = queue.shift();
+    bfsOrder.push(curr);
+    for (const next of adjacency[curr]) {
+      if (!visited[next]) {
+        visited[next] = 1;
+        queue.push(next);
+      }
+    }
+  }
+  const dominators = new Int32Array(nodeCount).fill(-1);
+  dominators[0] = 0;
+  const nodeToRpo = new Int32Array(nodeCount).fill(-1);
+  for (let i = 0;i < bfsOrder.length; i++) {
+    nodeToRpo[bfsOrder[i]] = i;
+  }
+  function intersect(b1Init, b2Init) {
+    let b1 = b1Init;
+    let b2 = b2Init;
+    let finger1 = nodeToRpo[b1];
+    let finger2 = nodeToRpo[b2];
+    while (finger1 !== finger2) {
+      while (finger1 > finger2) {
+        b1 = dominators[b1];
+        if (b1 < 0)
+          return 0;
+        finger1 = nodeToRpo[b1];
+      }
+      while (finger2 > finger1) {
+        b2 = dominators[b2];
+        if (b2 < 0)
+          return 0;
+        finger2 = nodeToRpo[b2];
+      }
+    }
+    return b1;
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (let i = 1;i < bfsOrder.length; i++) {
+      const node = bfsOrder[i];
+      let newIdom = -1;
+      for (const pred of reverseAdj[node]) {
+        if (dominators[pred] < 0)
+          continue;
+        if (newIdom < 0) {
+          newIdom = pred;
+        } else {
+          newIdom = intersect(newIdom, pred);
+        }
+      }
+      if (newIdom >= 0 && dominators[node] !== newIdom) {
+        dominators[node] = newIdom;
+        changed = true;
+      }
+    }
+  }
+  const retainedSizes = new Float64Array(nodeCount);
+  for (let i = 0;i < nodeCount; i++) {
+    retainedSizes[i] = nodes[i].selfSize;
+  }
+  for (let i = bfsOrder.length - 1;i > 0; i--) {
+    const node = bfsOrder[i];
+    const dom = dominators[node];
+    if (dom >= 0 && dom !== node) {
+      retainedSizes[dom] = retainedSizes[dom] + retainedSizes[node];
+    }
+  }
+  const indexed = bfsOrder.filter((i) => i > 0).map((i) => ({ ordinal: i, retainedSize: retainedSizes[i] })).sort((a, b) => b.retainedSize - a.retainedSize).slice(0, 50);
+  function getEdgeName(toOrdinal) {
+    const dom = dominators[toOrdinal];
+    if (dom < 0)
+      return "";
+    const domNode = nodes[dom];
+    for (let e = 0;e < domNode.edgeCount; e++) {
+      const edgeBase = domNode.edgeStartIndex + e * edgeFieldCount;
+      const toNodeArrayIdx = v8.edges[edgeBase + edgeToNodeIdx] ?? 0;
+      if (toNodeArrayIdx / nodeFieldCount === toOrdinal) {
+        const nameOrIndex = v8.edges[edgeBase + edgeNameIdx] ?? 0;
+        const edgeTypeVal = edgeTypes[v8.edges[edgeBase + edgeTypeIdx] ?? 0];
+        if (edgeTypeVal === "element")
+          return `[${nameOrIndex}]`;
+        return v8.strings[nameOrIndex] ?? String(nameOrIndex);
+      }
+    }
+    return "";
+  }
+  function getRetainerPath(targetOrdinal, maxDepth = 10) {
+    const path = [];
+    let current = targetOrdinal;
+    const pathVisited = new Set;
+    for (let depth = 0;depth < maxDepth; depth++) {
+      const node = nodes[current];
+      const edgeName = getEdgeName(current);
+      path.unshift(edgeName ? `${node.name || node.type}` : node.name || node.type);
+      if (current === 0)
+        break;
+      pathVisited.add(current);
+      const dom = dominators[current];
+      if (dom < 0 || dom === current || pathVisited.has(dom))
+        break;
+      current = dom;
+    }
+    return path;
+  }
+  const largestObjects = indexed.map(({ ordinal, retainedSize }) => {
+    const node = nodes[ordinal];
+    return {
+      name: node.name || `(${node.type})`,
+      type: node.type,
+      selfSize: node.selfSize,
+      retainedSize,
+      retainerPath: getRetainerPath(ordinal)
+    };
+  });
+  const typeMap = new Map;
+  for (const node of nodes) {
+    if (!visited[node.ordinal])
+      continue;
+    const existing = typeMap.get(node.type);
+    if (existing) {
+      existing.count++;
+      existing.totalSize += node.selfSize;
+    } else {
+      typeMap.set(node.type, { count: 1, totalSize: node.selfSize });
+    }
+  }
+  const typeStats = Array.from(typeMap.entries()).map(([type, stats]) => ({
+    type,
+    count: stats.count,
+    totalSize: stats.totalSize,
+    avgSize: stats.count > 0 ? Math.round(stats.totalSize / stats.count) : 0
+  })).sort((a, b) => b.totalSize - a.totalSize);
+  const ctorMap = new Map;
+  for (const node of nodes) {
+    if (!visited[node.ordinal])
+      continue;
+    if (node.type !== "object" || !node.name)
+      continue;
+    const existing = ctorMap.get(node.name);
+    if (existing) {
+      existing.count++;
+      existing.totalSize += node.selfSize;
+    } else {
+      ctorMap.set(node.name, { count: 1, totalSize: node.selfSize });
+    }
+  }
+  const constructorStats = Array.from(ctorMap.entries()).map(([ctor, stats]) => ({
+    constructor: ctor,
+    count: stats.count,
+    totalSize: stats.totalSize,
+    avgSize: stats.count > 0 ? Math.round(stats.totalSize / stats.count) : 0
+  })).sort((a, b) => b.totalSize - a.totalSize).slice(0, 30);
+  const detachedExamples = [];
+  let detachedCount = 0;
+  let detachedTotalSize = 0;
+  for (const node of nodes) {
+    if (!visited[node.ordinal])
+      continue;
+    const isDetached = nodeDetachednessIdx >= 0 && node.detachedness > 0 || node.name.includes("Detached") || node.type === "native" && /HTML\w*Element|Document|Node/.test(node.name) && node.name.includes("Detached");
+    if (isDetached) {
+      detachedCount++;
+      detachedTotalSize += node.selfSize;
+      if (detachedExamples.length < 10) {
+        detachedExamples.push({
+          name: node.name || `(${node.type})`,
+          retainerPath: getRetainerPath(node.ordinal)
+        });
+      }
+    }
+  }
+  const detachedNodes = {
+    count: detachedCount,
+    totalSize: detachedTotalSize,
+    examples: detachedExamples
+  };
+  const closureNodes = nodes.filter((n) => visited[n.ordinal] && n.type === "closure");
+  const closureTotalSize = closureNodes.reduce((sum, n) => sum + n.selfSize, 0);
+  const topClosures = closureNodes.sort((a, b) => b.selfSize - a.selfSize).slice(0, 20).map((n) => ({
+    name: n.name || "(anonymous)",
+    contextSize: n.selfSize,
+    retainerPath: getRetainerPath(n.ordinal)
+  }));
+  const closureStats = {
+    count: closureNodes.length,
+    totalSize: closureTotalSize,
+    topClosures
+  };
+  return {
+    metadata: {
+      url: rawSnapshot.url,
+      capturedAt: rawSnapshot.capturedAt,
+      totalSize,
+      nodeCount: v8.snapshot.node_count,
+      edgeCount: v8.snapshot.edge_count
+    },
+    largestObjects,
+    typeStats,
+    constructorStats,
+    detachedNodes,
+    closureStats
+  };
+}
+// src/analysis/agent.ts
+import {
+  createDeepAgent
+} from "deepagents";
+import { providerStrategy } from "langchain";
+// src/analysis/prompts.ts
+var SYSTEM_PROMPT = `You are an expert web performance engineer. You have access to a virtual filesystem workspace containing captured data from a real page load: heap snapshot, network trace, and Chrome runtime trace.
+## Workspace structure
+- /heap/summary.json — Parsed V8 heap snapshot: largest objects, type stats, constructor stats, detached DOM nodes, closure stats
+- /trace/summary.json — Page load metrics: timing, long tasks, render-blocking resources, resource breakdown
+- /trace/network-waterfall.json — Every network request with timing, size, priority, render-blocking status
+- /trace/asset-manifest.json — Index of all assets with paths to stored files
+- /trace/runtime/summary.json — Runtime trace overview: frame breakdown (scripting/layout/paint/GC), blocking function count, listener imbalances, GC stats
+- /trace/runtime/blocking-functions.json — Functions that blocked the main thread > 50ms, with script URL, line number, call stack, and duration
+- /trace/runtime/event-listeners.json — Event listener add/remove counts per event type, with source locations
+- /trace/runtime/frame-breakdown.json — Time spent in scripting vs layout vs paint vs GC
+- /trace/runtime/raw-events.json — Full Chrome trace events (large file — read to investigate specific function calls, layouts, GC, and event dispatches)
+- /scripts/*.js — Actual JavaScript source files captured during page load
+- /styles/*.css — Actual CSS source files
+- /html/document.html — The HTML document
+## Your workflow
+1. Read /heap/summary.json, /trace/summary.json, AND /trace/runtime/summary.json first for the big picture
+2. Identify the highest-impact issues from all datasets
+3. For each issue, dive into the relevant source files to understand the root cause
+4. Provide specific, code-level fixes
+## What to look for
+### Memory issues (from heap data)
+- Memory leaks: unbounded arrays, maps, caches that grow without bound
+- Detached DOM nodes: DOM elements removed from the document but still referenced
+- Large retained objects: single objects or trees retaining disproportionate memory
+- Closure leaks: closures capturing variables they no longer need
+### Page-load issues (from trace + source code)
+- Render-blocking scripts: <script> in <head> without async/defer — read the script to judge if it must be synchronous
+- Render-blocking CSS: large stylesheets blocking first paint
+- Long tasks (> 50ms): identify the function/module causing the block by reading the source
+- Large bundles: scripts > 100KB — search for unused imports or code that could be lazy-loaded
+- Sequential waterfalls: resources chained sequentially that could load in parallel
+### Runtime issues (from Chrome trace)
+- Frame-blocking functions: read /trace/runtime/blocking-functions.json first, then inspect the actual script source at the reported line number to understand what the function does and how to optimize it
+- Event listener leaks: check /trace/runtime/event-listeners.json for event types where addCount >> removeCount, then grep the scripts for those addEventListener calls
+- GC pressure: high GC pause counts or duration suggest excessive short-lived object creation — look for hot loops creating objects
+- Layout thrashing: forced synchronous layouts caused by reading layout properties (offsetHeight, getBoundingClientRect) after DOM writes
+## Severity classification
+Assign severity based on measured impact — do NOT guess:
+- **critical** — A blocking function >500ms, retained heap object >5MB,
+  render-blocking resource >200KB, listener addCount > 10× removeCount,
+  or GC pauses totalling >500ms
+- **warning** — A blocking function 100–500ms, retained heap object 1–5MB,
+  render-blocking resource 50–200KB, listener addCount > 2× removeCount,
+  or GC pauses totalling 100–500ms
+- **info** — Blocking function 50–100ms, retained object <1MB, minor
+  optimisation opportunities, or observations about dependency usage
+Always base severity on the actual numbers from the captured data — never inflate.
+## Verification rules
+These rules are mandatory for every finding:
+1. **ALWAYS read the source file** in /scripts/, /styles/, or /html/ and
+   verify the code BEFORE suggesting a fix. Never suggest a fix for code
+   you have not read.
+2. **Never guess at line numbers** — confirm by reading the file. If the
+   trace reports a line number but the source doesn't match, say so.
+3. Each \`suggestedFix\` MUST reference the actual current code and describe
+   what to change. Include a before/after snippet from the real source.
+4. If the heap summary, trace summary, and runtime summary all show healthy
+   numbers, state that the page is well-optimised — do NOT manufacture
+   findings.
+5. Never report a finding based solely on a URL or resource name — always
+   read the actual content to confirm the issue.
+## Cross-referencing data
+- When a script appears in BOTH /trace/runtime/blocking-functions.json (CPU)
+  AND /heap/summary.json (memory), mention both dimensions in the finding.
+- Check /trace/runtime/event-listeners.json for listener imbalances and
+  cross-reference with the actual addEventListener calls in /scripts/.
+- Use /trace/network-waterfall.json to identify sequential chains, then read
+  the initiating script to confirm the dependency.
+- When GC pauses are significant, cross-reference with heap data to identify
+  which constructors or allocation patterns are responsible.
+## Estimating impactMs
+Every finding should include an \`impactMs\` estimate when possible:
+- For render-blocking resources: impactMs ≈ the resource's load duration
+  (from the network waterfall) that could be deferred.
+- For blocking functions: impactMs ≈ the function's duration minus 50ms
+  (the long-task threshold).
+- For memory issues: impactMs may not apply — use \`retainedSize\` instead.
+- If you cannot reasonably estimate the savings, omit impactMs rather than
+  guessing.
+## Output guidelines
+- Report 3–7 findings, ordered by impact (mix of memory, page-load, and runtime if all have issues)
+- Be specific — name actual files, functions, object constructors, and retention paths
+- Provide concrete code fixes, not generic advice
+- If heap, trace, and runtime all look healthy, say so — don't manufacture issues
+## Structured output fields
+For each finding, fill in as many fields as applicable:
+- \`sourceFile\` — the workspace path (e.g. /scripts/app.js) or resource URL
+  where the issue occurs. Always set this when you can identify the file.
+- \`lineNumber\` — the 1-based line number in the source file. Only set after
+  verifying by reading the file.
+- \`confidence\` — \`high\` if you read the source and confirmed the issue,
+  \`medium\` if the profiling data strongly suggests it but you couldn't fully
+  verify, \`low\` if inferred from patterns.
+- \`estimatedSavingsMs\` — your estimate of time saved if the fix is applied.
+- \`beforeCode\` — a snippet of the CURRENT problematic code, copied from the
+  source file you read. Keep it focused (5–15 lines).
+- \`afterCode\` — the IMPROVED code snippet showing the fix. Must be a drop-in
+  replacement for \`beforeCode\`.
+- \`impactMs\` — the current measured cost (e.g. blocking function duration,
+  resource load time).`;
+// src/vitest/prompts.ts
+var VITEST_SYSTEM_PROMPT = `You are an expert in JavaScript/TypeScript performance optimization.
+You have access to a workspace containing V8 CPU profiling data captured during
+a Vitest test run. The workspace may also include V8 heap profiling data
+captured via Node's \`--heap-prof\` (allocation sampling).
+The profiling data covers BOTH the test code AND the application code being tested.
+**Your primary goal is to analyze the PERFORMANCE OF THE APPLICATION CODE
+being tested** — the functions, modules, and algorithms that the developer
+wrote and is benchmarking or testing. Test infrastructure overhead (Vitest,
+tinybench, test setup) is secondary context.
+## Source categories
+Every hot function and script in the workspace has a \`sourceCategory\` field:
+- **application** — Code in the user's project (the code being tested).
+  This is your PRIMARY focus. Find bottlenecks, inefficiencies, and
+  optimization opportunities in these functions.
+- **dependency** — Third-party code in node_modules. Report when a dependency
+  is a significant bottleneck, since the developer may be able to choose
+  an alternative, configure it differently, or avoid calling it in hot paths.
+- **test** — Test files. Only mention if the test setup itself is creating
+  artificial overhead that masks application performance.
+- **framework** — Vitest/tinybench/V8 internals. Generally ignore unless
+  they dominate the profile in an unexpected way.
+## Workspace structure
+- /summary.json — Overall test run: total tests, duration, pass/fail, GC stats
+- /timing/overview.json — Per-file test durations and individual test times
+- /timing/slow-tests.json — Tests exceeding the slow threshold
+- /profiles/index.json — Manifest mapping test files to their CPU profiles
+- /profiles/<file>.json — CPU profile summary: hot functions (with sourceCategory),
+  call trees, GC samples, script breakdown (with sourceCategory)
+- /heap-profiles/index.json — (optional) Manifest mapping test files to heap profiles
+- /heap-profiles/<file>.json — (optional) Heap profile summary: allocation hotspots,
+  per-script allocated bytes (with sourceCategory)
+- /hot-functions/application.json — **START HERE**: Hot functions from application code only.
+  Each entry includes a \`sourceSnippet\` (lines around the hot line) and \`workspacePath\`
+  (path to the full source file in the workspace) when source code is available.
+- /hot-functions/dependencies.json — Hot functions from third-party dependencies
+- /hot-functions/global.json — All hot functions across all categories
+- /scripts/application.json — Per-script time breakdown for application code
+- /scripts/dependencies.json — Per-script time breakdown for dependencies
+- /listener-tracking.json — (optional) Event listener tracking data captured from
+  worker processes. Contains per-event-type add/remove counts for EventTarget and
+  EventEmitter, plus exceedances where listener counts exceeded maxListeners.
+- /src/index.json — Mapping of source files to their hot functions (quick overview
+  of which files matter and what bottlenecks they contain)
+- /tests/<relative-path> — Test source files (directory structure preserved)
+- /src/<relative-path> — Application and dependency source files referenced by
+  hot functions (directory structure preserved from the project root)
+## Your workflow
+1. Read /hot-functions/application.json FIRST — these are the application-level
+   bottlenecks the developer wants to optimize
+2. Read /scripts/application.json for the per-file view of application code time
+3. Read /hot-functions/dependencies.json for costly dependency calls
+4. If present, read /heap-profiles/index.json and /heap-profiles/<file>.json to identify
+   allocation hotspots (functions/scripts allocating lots of bytes)
+5. If present, read /listener-tracking.json for event listener add/remove patterns
+   and listener exceedances (too many listeners on a single target)
+6. Read /summary.json and /timing/overview.json for the big picture
+7. Read CPU profiles in /profiles/ for detailed call trees of the slowest tests
+8. Read the actual source code in /src/ and /tests/ to understand root causes
+9. Provide specific, actionable fixes targeting the application code
+## What to look for
+### Application code bottlenecks (PRIMARY FOCUS)
+- Functions with high self time — where is the application spending CPU?
+- Expensive algorithms: O(n²) loops, unnecessary sorting, repeated work
+- String/JSON operations: excessive serialization, string concatenation in loops
+- Object allocation hotspots: functions creating many short-lived objects
+- Synchronous blocking: file I/O, crypto, or compression in hot paths
+- Redundant computation: values computed repeatedly that could be cached/memoized
+- Data structure choices: using arrays where Maps/Sets would be O(1)
+### Dependency-related bottlenecks
+- Dependencies consuming disproportionate CPU — suggest alternatives or configuration
+- Unnecessary calls to expensive dependency APIs in hot paths
+- Dependencies pulled in for simple operations that could be hand-written
+### GC pressure from application code
+- Application functions creating many temporary objects in tight loops
+- Large array/object allocations that could be pooled or reused
+- Closures capturing large scopes unnecessarily
+### Allocation hotspots (from heap profiles, if present)
+- Functions allocating a large share of total bytes (even if CPU isn't dominant)
+- Scripts/modules responsible for most allocation — suggest caching, reuse, pooling,
+  or avoiding intermediate arrays/objects
+- When allocation hotspots match CPU hotspots, prioritize fixes there first
+### Call chain analysis
+- Each hot function includes a \`callerChain\` field — the chain of callers
+  from the hot function up toward the entry point. Use this to understand
+  WHY a function is hot and which application-level call triggers it.
+- Trace expensive call trees to find which APPLICATION function triggers them
+- Follow the call tree from application entry points down to the hot leaf functions
+- Identify which application-level design decisions lead to the bottleneck
+### Event listener tracking (from /listener-tracking.json, if present)
+- **Exceedances** — when a single EventTarget or EventEmitter accumulates more
+  listeners than its maxListeners threshold (default 10), this is a strong
+  signal of a listener leak. The exceedance data includes the target type
+  (e.g. AbortSignal), event name, listener count, and a stack trace snippet
+  pointing to the code that registered the excess listener.
+- **Add/remove imbalances** — when \`addCount\` significantly exceeds
+  \`removeCount\` for a given event type, listeners are being registered but
+  not cleaned up. This causes memory growth and eventually GC pressure.
+  Look for patterns like:
+  - AbortSignal abort listeners not cleaned up (common with fetch/streams)
+  - EventEmitter listeners added in loops without corresponding removal
+  - Missing \`{ once: true }\` option or \`AbortController\` cleanup
+- When exceedances or imbalances are found, read the source code to identify
+  the root cause and suggest specific fixes (e.g. using \`AbortController\`,
+  \`removeEventListener\`, \`{ once: true }\`, or restructuring listener
+  registration to avoid accumulation).
+### Test infrastructure (SECONDARY — only if impactful)
+- Test setup creating artificial overhead that dwarfs application execution
+- Benchmarks measuring setup cost instead of application performance
+- Only mention if it prevents getting clean application performance data
+## Finding categories
+Each finding MUST use one of these exact category values:
+- **algorithm** — Inefficient algorithm: O(n²) loops, brute-force search, repeated work
+- **serialization** — Excessive JSON.stringify/parse, string concatenation, encoding
+- **allocation** — Excessive object/array creation causing GC pressure
+- **event-handling** — Listener leaks, unbounded event handler accumulation
+- **hot-function** — Generic CPU-hot function that doesn't fit a more specific category
+- **gc-pressure** — High garbage collection overhead
+- **listener-leak** — Event listeners not cleaned up properly
+- **unnecessary-computation** — Redundant work that could be cached or eliminated
+- **blocking-io** — Synchronous I/O or blocking operations in hot paths
+- **dependency-bottleneck** — Expensive dependency call the developer can optimize
+- **slow-test** — Test itself is slow due to setup or teardown
+- **expensive-setup** — Costly test setup (beforeAll/beforeEach)
+- **import-overhead** — Expensive module imports at test time
+- **other** — Doesn't fit any of the above
+Prefer more specific categories (algorithm, serialization, allocation, event-handling)
+over generic ones (hot-function, other) when the root cause is clear.
+## Severity classification
+Assign severity based on measured impact — do NOT guess:
+- **critical** — A single function consuming >15% self-time, listener exceedances
+  (count exceeding maxListeners), or GC overhead >10% of total profile duration
+- **warning** — A function consuming 5–15% self-time, listener add/remove imbalance
+  where addCount > 2× removeCount, or GC overhead between 5–10%
+- **info** — A function consuming <5% self-time, minor inefficiencies,
+  dependency observations, or small optimisation opportunities
+Always base severity on the actual numbers from the profiling data — never inflate.
+## Verification rules
+These rules are mandatory for every finding:
+1. **ALWAYS read the source file** in /src/ or /tests/ and verify the code
+   BEFORE suggesting a fix. Never suggest a fix for code you have not read.
+2. **Never guess at line numbers** — confirm by reading the file. If the profile
+   reports line 42 but the source at line 42 doesn't match, say so.
+3. Each \`suggestedFix\` MUST reference the actual current code and describe
+   what to change. Include a before/after snippet from the real source.
+4. If /hot-functions/application.json is empty or every function is <1%
+   self-time, state that the application code is efficient — do NOT
+   manufacture findings.
+5. Never report a finding based solely on a function name — always read the
+   implementation to confirm the issue exists.
+## Cross-referencing data
+- When a function appears in BOTH /hot-functions/ (CPU hotspot) AND
+  /heap-profiles/ (allocation hotspot), prioritise it and mention both
+  dimensions in the finding.
+- Cross-reference /hot-functions/ data with /heap-profiles/ when both are
+  present to find functions that are expensive in both CPU and memory.
+- Check whether hot dependency calls originate from application code by
+  tracing the call tree in /profiles/.
+- When /listener-tracking.json is present, cross-reference exceedance stack
+  traces with the source code in /src/ to pinpoint the registration site.
+- /metrics/current.json contains pre-computed aggregate metrics (suite totals,
+  CPU category breakdown, top hot functions). Use it for the big-picture
+  numbers when sizing impact.
+## Estimating impactMs
+Every finding should include an \`impactMs\` estimate when possible:
-// src/analysis/parser.ts
-function parseSnapshot(rawSnapshot) {
-  const v8 = JSON.parse(rawSnapshot.data);
-  const meta = v8.snapshot.meta;
-  const nodeFieldCount = meta.node_fields.length;
-  const edgeFieldCount = meta.edge_fields.length;
-  const nodeTypes = meta.node_types[0];
-  const edgeTypes = meta.edge_types[0];
-  const nodeTypeIdx = meta.node_fields.indexOf("type");
-  const nodeNameIdx = meta.node_fields.indexOf("name");
-  const nodeIdIdx = meta.node_fields.indexOf("id");
-  const nodeSelfSizeIdx = meta.node_fields.indexOf("self_size");
-  const nodeEdgeCountIdx = meta.node_fields.indexOf("edge_count");
-  const nodeDetachednessIdx = meta.node_fields.indexOf("detachedness");
-  const edgeTypeIdx = meta.edge_fields.indexOf("type");
-  const edgeNameIdx = meta.edge_fields.indexOf("name_or_index");
-  const edgeToNodeIdx = meta.edge_fields.indexOf("to_node");
-  const nodeCount = v8.snapshot.node_count;
-  const nodes = [];
-  let edgeOffset = 0;
-  let totalSize = 0;
-  for (let i = 0;i < nodeCount; i++) {
-    const base = i * nodeFieldCount;
-    const selfSize = v8.nodes[base + nodeSelfSizeIdx] ?? 0;
-    totalSize += selfSize;
-    nodes.push({
-      ordinal: i,
-      type: nodeTypes[v8.nodes[base + nodeTypeIdx] ?? 0] ?? "unknown",
-      name: v8.strings[v8.nodes[base + nodeNameIdx] ?? 0] ?? "",
-      id: v8.nodes[base + nodeIdIdx] ?? 0,
-      selfSize,
-      edgeCount: v8.nodes[base + nodeEdgeCountIdx] ?? 0,
-      detachedness: nodeDetachednessIdx >= 0 ? v8.nodes[base + nodeDetachednessIdx] ?? 0 : 0,
-      edgeStartIndex: edgeOffset
-    });
-    edgeOffset += (v8.nodes[base + nodeEdgeCountIdx] ?? 0) * edgeFieldCount;
-  }
-  const adjacency = Array.from({ length: nodeCount }, () => []);
-  for (let i = 0;i < nodeCount; i++)
-    adjacency[i] = [];
-  const reverseAdj = Array.from({ length: nodeCount }, () => []);
-  for (let i = 0;i < nodeCount; i++)
-    reverseAdj[i] = [];
-  for (let i = 0;i < nodeCount; i++) {
-    const node = nodes[i];
-    for (let e = 0;e < node.edgeCount; e++) {
-      const edgeBase = node.edgeStartIndex + e * edgeFieldCount;
-      const edgeTypeVal = edgeTypes[v8.edges[edgeBase + edgeTypeIdx] ?? 0];
-      if (edgeTypeVal === "weak")
-        continue;
-      const toNodeArrayIdx = v8.edges[edgeBase + edgeToNodeIdx] ?? 0;
-      const toOrdinal = toNodeArrayIdx / nodeFieldCount;
-      if (toOrdinal >= 0 && toOrdinal < nodeCount) {
-        adjacency[i].push(toOrdinal);
-        reverseAdj[toOrdinal].push(i);
-      }
-    }
-  }
-  const visited = new Uint8Array(nodeCount);
-  const bfsOrder = [];
-  const queue = [0];
-  visited[0] = 1;
-  while (queue.length > 0) {
-    const curr = queue.shift();
-    bfsOrder.push(curr);
-    for (const next of adjacency[curr]) {
-      if (!visited[next]) {
-        visited[next] = 1;
-        queue.push(next);
-      }
-    }
-  }
-  const dominators = new Int32Array(nodeCount).fill(-1);
-  dominators[0] = 0;
-  const nodeToRpo = new Int32Array(nodeCount).fill(-1);
-  for (let i = 0;i < bfsOrder.length; i++) {
-    nodeToRpo[bfsOrder[i]] = i;
-  }
-  function intersect(b1Init, b2Init) {
-    let b1 = b1Init;
-    let b2 = b2Init;
-    let finger1 = nodeToRpo[b1];
-    let finger2 = nodeToRpo[b2];
-    while (finger1 !== finger2) {
-      while (finger1 > finger2) {
-        b1 = dominators[b1];
-        if (b1 < 0)
-          return 0;
-        finger1 = nodeToRpo[b1];
-      }
-      while (finger2 > finger1) {
-        b2 = dominators[b2];
-        if (b2 < 0)
-          return 0;
-        finger2 = nodeToRpo[b2];
-      }
-    }
-    return b1;
-  }
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (let i = 1;i < bfsOrder.length; i++) {
-      const node = bfsOrder[i];
-      let newIdom = -1;
-      for (const pred of reverseAdj[node]) {
-        if (dominators[pred] < 0)
-          continue;
-        if (newIdom < 0) {
-          newIdom = pred;
-        } else {
-          newIdom = intersect(newIdom, pred);
-        }
-      }
-      if (newIdom >= 0 && dominators[node] !== newIdom) {
-        dominators[node] = newIdom;
-        changed = true;
-      }
-    }
-  }
-  const retainedSizes = new Float64Array(nodeCount);
-  for (let i = 0;i < nodeCount; i++) {
-    retainedSizes[i] = nodes[i].selfSize;
+- Use the hot function's \`selfTime\` as the baseline cost.
+- Estimate what fraction of that cost the fix would eliminate
+  (e.g. an O(n²) → O(n) fix on data of size 1000 might eliminate ~99%).
+- impactMs = selfTime × estimated fraction eliminated.
+- Example: a function with selfTime 200ms in a 1000ms run, where an
+  algorithm fix would remove ~80% of the work → impactMs ≈ 160.
+- If you cannot reasonably estimate the savings, omit impactMs rather than
+  guessing.
+## Output guidelines
+- Report 3–7 findings, ordered by impact ON THE APPLICATION CODE
+- Focus findings on functions the developer CAN change (application code first,
+  then dependency usage patterns, then test structure)
+- Be specific — name actual files, functions, line numbers from the source code
+- Provide concrete code-level fixes, not generic advice
+- When reporting a dependency bottleneck, explain what application code is
+  calling it and how the developer can reduce that cost
+- If the application code is already efficient, say so — don't force findings
+  about test infrastructure just to fill the report
+## Structured output fields
+For each finding, fill in as many fields as applicable:
+- \`sourceFile\` — the workspace path (e.g. /src/utils/parser.ts) or original
+  file path where the issue occurs. Always set this when you can identify
+  the file.
+- \`lineNumber\` — the 1-based line number in the source file. Only set after
+  verifying by reading the file.
+- \`confidence\` — \`high\` if you read the source and confirmed the issue,
+  \`medium\` if the profiling data strongly suggests it but you couldn't fully
+  verify, \`low\` if inferred from patterns.
+- \`estimatedSavingsMs\` — your estimate of time saved if the fix is applied.
+- \`beforeCode\` — a snippet of the CURRENT problematic code, copied from the
+  source file you read. Keep it focused (5–15 lines).
+- \`afterCode\` — the IMPROVED code snippet showing the fix. Must be a drop-in
+  replacement for \`beforeCode\`.
+- \`affectedTests\` — list of test names that exercise this code path and would
+  benefit from the fix.
+- \`impactMs\` — the current measured cost (e.g. selfTime of the hot function).`;
+// src/schema.ts
+import { z } from "zod";
+var ALL_CATEGORIES = [
+  "memory-leak",
+  "large-retained-object",
+  "detached-dom",
+  "render-blocking",
+  "long-task",
+  "unused-code",
+  "waterfall-bottleneck",
+  "large-asset",
+  "frame-blocking-function",
+  "listener-leak",
+  "gc-pressure",
+  "slow-test",
+  "expensive-setup",
+  "hot-function",
+  "unnecessary-computation",
+  "import-overhead",
+  "dependency-bottleneck",
+  "algorithm",
+  "serialization",
+  "allocation",
+  "event-handling",
+  "blocking-io",
+  "other"
+];
+var FindingSchema = z.object({
+  severity: z.enum(["critical", "warning", "info"]),
+  title: z.string().describe("Short title for the finding"),
+  description: z.string().describe("Detailed explanation of the issue"),
+  category: z.string().describe(`Category of the performance issue. Use one of: ${ALL_CATEGORIES.join(", ")}`),
+  resourceUrl: z.string().optional().describe("URL of the resource involved"),
+  workspacePath: z.string().optional().describe("Path in the VFS workspace"),
+  impactMs: z.number().optional().describe("Estimated current cost in ms (e.g. selfTime of the hot function)"),
+  estimatedSavingsMs: z.number().optional().describe("Estimated time savings in ms if the fix is applied. Computed as impactMs × fraction eliminated by the fix."),
+  confidence: z.enum(["high", "medium", "low"]).optional().describe("How confident you are in this finding. high = verified in source code, medium = strong signal but partial verification, low = inferred from data patterns"),
+  retainedSize: z.number().optional().describe("Retained heap size in bytes"),
+  retainerPath: z.array(z.string()).optional().describe("Object retention path in the heap"),
+  sourceFile: z.string().optional().describe("Primary source file where the issue occurs (workspace path or original path)"),
+  lineNumber: z.number().optional().describe("Line number in the source file where the issue occurs (1-based)"),
+  suggestedFix: z.string().describe("Code snippet or guidance to fix the issue"),
+  beforeCode: z.string().optional().describe("The current problematic code snippet from the source file"),
+  afterCode: z.string().optional().describe("The improved code snippet that fixes the issue"),
+  testFile: z.string().optional().describe("Test file path (for test performance findings)"),
+  affectedTests: z.array(z.string()).optional().describe("Test names that would benefit from this fix (for test performance findings)"),
+  hotFunction: z.object({
+    name: z.string(),
+    scriptUrl: z.string(),
+    lineNumber: z.number(),
+    selfTime: z.number(),
+    selfPercent: z.number()
+  }).optional().describe("Hot function details (for hot-function findings)")
+});
+var FindingsSchema = z.object({
+  findings: z.array(FindingSchema)
+});
+// src/output/progress.ts
+class TodoProgressRenderer {
+  spinner;
+  lastStatusByKey = new Map;
+  lastInProgressKey;
+  baseSpinnerText;
+  printedHeader = false;
+  constructor(spinner) {
+    this.spinner = spinner;
+    this.baseSpinnerText = spinner.text;
   }
-  for (let i = bfsOrder.length - 1;i > 0; i--) {
-    const node = bfsOrder[i];
-    const dom = dominators[node];
-    if (dom >= 0 && dom !== node) {
-      retainedSizes[dom] = retainedSizes[dom] + retainedSizes[node];
-    }
+  printHeaderOnce() {
+    if (this.printedHeader)
+      return;
+    this.printedHeader = true;
+    const header = "Performance analysis progress:";
+    this.spinner.stopAndPersist({ symbol: " ", text: header });
+    this.spinner.start();
   }
-  const indexed = bfsOrder.filter((i) => i > 0).map((i) => ({ ordinal: i, retainedSize: retainedSizes[i] })).sort((a, b) => b.retainedSize - a.retainedSize).slice(0, 50);
-  function getEdgeName(toOrdinal) {
-    const dom = dominators[toOrdinal];
-    if (dom < 0)
-      return "";
-    const domNode = nodes[dom];
-    for (let e = 0;e < domNode.edgeCount; e++) {
-      const edgeBase = domNode.edgeStartIndex + e * edgeFieldCount;
-      const toNodeArrayIdx = v8.edges[edgeBase + edgeToNodeIdx] ?? 0;
-      if (toNodeArrayIdx / nodeFieldCount === toOrdinal) {
-        const nameOrIndex = v8.edges[edgeBase + edgeNameIdx] ?? 0;
-        const edgeTypeVal = edgeTypes[v8.edges[edgeBase + edgeTypeIdx] ?? 0];
-        if (edgeTypeVal === "element")
-          return `[${nameOrIndex}]`;
-        return v8.strings[nameOrIndex] ?? String(nameOrIndex);
+  handleChunk(chunk) {
+    const todos = extractTodosFromStreamChunk(chunk);
+    if (!todos)
+      return;
+    for (const todo of todos) {
+      const key = todo.id && String(todo.id) || todo.content;
+      const prevStatus = this.lastStatusByKey.get(key);
+      const nextStatus = todo.status;
+      if (prevStatus !== nextStatus) {
+        this.lastStatusByKey.set(key, nextStatus);
+        if (nextStatus === "completed" && prevStatus !== "completed") {
+          this.printHeaderOnce();
+          this.spinner.stopAndPersist({ symbol: " ", text: `  ✓ ${todo.content}` });
+          this.spinner.start();
+        }
+        if (nextStatus === "in_progress" && this.lastInProgressKey !== key) {
+          this.lastInProgressKey = key;
+          this.printHeaderOnce();
+          const base = this.baseSpinnerText ?? this.spinner.text;
+          this.spinner.text = base ? `${base} (${todo.content})` : todo.content;
+        }
       }
     }
-    return "";
-  }
-  function getRetainerPath(targetOrdinal, maxDepth = 10) {
-    const path = [];
-    let current = targetOrdinal;
-    const pathVisited = new Set;
-    for (let depth = 0;depth < maxDepth; depth++) {
-      const node = nodes[current];
-      const edgeName = getEdgeName(current);
-      path.unshift(edgeName ? `${node.name || node.type}` : node.name || node.type);
-      if (current === 0)
-        break;
-      pathVisited.add(current);
-      const dom = dominators[current];
-      if (dom < 0 || dom === current || pathVisited.has(dom))
-        break;
-      current = dom;
-    }
-    return path;
   }
-  const largestObjects = indexed.map(({ ordinal, retainedSize }) => {
-    const node = nodes[ordinal];
-    return {
-      name: node.name || `(${node.type})`,
-      type: node.type,
-      selfSize: node.selfSize,
-      retainedSize,
-      retainerPath: getRetainerPath(ordinal)
-    };
-  });
-  const typeMap = new Map;
-  for (const node of nodes) {
-    if (!visited[node.ordinal])
+}
+function extractTodosFromStreamChunk(chunk) {
+  if (!chunk || typeof chunk !== "object")
+    return;
+  const direct = chunk;
+  if (Array.isArray(direct.todos))
+    return direct.todos;
+  for (const value of Object.values(chunk)) {
+    if (!value || typeof value !== "object")
       continue;
-    const existing = typeMap.get(node.type);
-    if (existing) {
-      existing.count++;
-      existing.totalSize += node.selfSize;
-    } else {
-      typeMap.set(node.type, { count: 1, totalSize: node.selfSize });
-    }
+    const nested = value;
+    if (Array.isArray(nested.todos))
+      return nested.todos;
   }
-  const typeStats = Array.from(typeMap.entries()).map(([type, stats]) => ({
-    type,
-    count: stats.count,
-    totalSize: stats.totalSize,
-    avgSize: stats.count > 0 ? Math.round(stats.totalSize / stats.count) : 0
-  })).sort((a, b) => b.totalSize - a.totalSize);
-  const ctorMap = new Map;
-  for (const node of nodes) {
-    if (!visited[node.ordinal])
-      continue;
-    if (node.type !== "object" || !node.name)
+}
+// src/analysis/agent.ts
+async function invokeWithTodoStreaming(agent, userMessage, spinner) {
+  const renderer = new TodoProgressRenderer(spinner);
+  const stream = await agent.stream({ messages: [{ role: "user", content: userMessage }] }, { streamMode: ["updates", "values"] });
+  let lastValues;
+  for await (const item of stream) {
+    if (Array.isArray(item) && item.length === 2) {
+      const mode = item[0];
+      const chunk = item[1];
+      renderer.handleChunk(chunk);
+      if (mode === "values")
+        lastValues = chunk;
       continue;
-    const existing = ctorMap.get(node.name);
-    if (existing) {
-      existing.count++;
-      existing.totalSize += node.selfSize;
-    } else {
-      ctorMap.set(node.name, { count: 1, totalSize: node.selfSize });
     }
+    renderer.handleChunk(item);
+    lastValues = item;
   }
-  const constructorStats = Array.from(ctorMap.entries()).map(([ctor, stats]) => ({
-    constructor: ctor,
-    count: stats.count,
-    totalSize: stats.totalSize,
-    avgSize: stats.count > 0 ? Math.round(stats.totalSize / stats.count) : 0
-  })).sort((a, b) => b.totalSize - a.totalSize).slice(0, 30);
-  const detachedExamples = [];
-  let detachedCount = 0;
-  let detachedTotalSize = 0;
-  for (const node of nodes) {
-    if (!visited[node.ordinal])
-      continue;
-    const isDetached = nodeDetachednessIdx >= 0 && node.detachedness > 0 || node.name.includes("Detached") || node.type === "native" && /HTML\w*Element|Document|Node/.test(node.name) && node.name.includes("Detached");
-    if (isDetached) {
-      detachedCount++;
-      detachedTotalSize += node.selfSize;
-      if (detachedExamples.length < 10) {
-        detachedExamples.push({
-          name: node.name || `(${node.type})`,
-          retainerPath: getRetainerPath(node.ordinal)
-        });
-      }
-    }
+  return lastValues;
+}
+function buildPageLoadUserMessage(ctx) {
+  const { url, heapSummary, traceResult } = ctx;
+  const m = traceResult.metrics;
+  const reqCount = traceResult.networkRequests.length;
+  const renderBlocking = traceResult.networkRequests.filter((r) => r.isRenderBlocking).length;
+  const totalTransfer = traceResult.networkRequests.reduce((s, r) => s + r.encodedSize, 0);
+  const hasRuntime = !!traceResult.runtimeTrace;
+  const lines = [
+    "Analyze the frontend performance data in this workspace.",
+    "",
+    `URL: ${url}`,
+    `Page load: ${Math.round(m.loadComplete)}ms | FCP: ${Math.round(m.firstContentfulPaint)}ms | LCP: ${Math.round(m.largestContentfulPaint)}ms | TBT: ${Math.round(m.totalBlockingTime)}ms`,
+    `Heap: ${formatBytes(heapSummary.metadata.totalSize)} total, ${heapSummary.metadata.nodeCount.toLocaleString()} nodes, ${heapSummary.detachedNodes.count} detached DOM nodes`,
+    `Network: ${reqCount} requests, ${formatBytes(totalTransfer)} transferred, ${renderBlocking} render-blocking`,
+    `Long tasks: ${m.longTasks.length}`
+  ];
+  if (hasRuntime) {
+    const rt = traceResult.runtimeTrace;
+    lines.push(`Runtime trace: ${rt.blockingFunctions.length} blocking functions, ${rt.gcEvents.length} GC events (${Math.round(rt.gcEvents.reduce((s, e) => s + e.duration, 0))}ms total)`);
   }
-  const detachedNodes = {
-    count: detachedCount,
-    totalSize: detachedTotalSize,
-    examples: detachedExamples
-  };
-  const closureNodes = nodes.filter((n) => visited[n.ordinal] && n.type === "closure");
-  const closureTotalSize = closureNodes.reduce((sum, n) => sum + n.selfSize, 0);
-  const topClosures = closureNodes.sort((a, b) => b.selfSize - a.selfSize).slice(0, 20).map((n) => ({
-    name: n.name || "(anonymous)",
-    contextSize: n.selfSize,
-    retainerPath: getRetainerPath(n.ordinal)
-  }));
-  const closureStats = {
-    count: closureNodes.length,
-    totalSize: closureTotalSize,
-    topClosures
-  };
-  return {
-    metadata: {
-      url: rawSnapshot.url,
-      capturedAt: rawSnapshot.capturedAt,
-      totalSize,
-      nodeCount: v8.snapshot.node_count,
-      edgeCount: v8.snapshot.edge_count
-    },
-    largestObjects,
-    typeStats,
-    constructorStats,
-    detachedNodes,
-    closureStats
-  };
+  lines.push("", "Available data:", "- /heap/summary.json — parsed heap snapshot", "- /trace/summary.json — page load metrics", "- /trace/network-waterfall.json — request timing and sizes", "- /trace/asset-manifest.json — index of stored assets");
+  if (hasRuntime) {
+    lines.push("- /trace/runtime/summary.json — runtime trace overview", "- /trace/runtime/blocking-functions.json — main thread blocking functions", "- /trace/runtime/event-listeners.json — listener add/remove counts", "- /trace/runtime/frame-breakdown.json — scripting vs layout vs paint vs GC", "- /trace/runtime/raw-events.json — full Chrome trace events");
+  }
+  lines.push("- /scripts/ — JavaScript source files", "- /styles/ — CSS source files", "- /html/document.html — page markup", "", "Explore the workspace, read source files to verify root causes, and provide code-level fixes.");
+  return lines.join(`
+`);
+}
+async function analyze(model, backend, spinner, context) {
+  const agent = createDeepAgent({
+    model,
+    systemPrompt: SYSTEM_PROMPT,
+    backend,
+    responseFormat: providerStrategy(FindingsSchema)
+  });
+  const userMessage = context ? buildPageLoadUserMessage(context) : [
+    "Analyze the frontend performance data in this workspace.",
+    "",
+    "Start by reading /heap/summary.json, /trace/summary.json, and /trace/runtime/summary.json",
+    "to understand the overall picture, then explore source files to verify root causes."
+  ].join(`
+`);
+  const result = await invokeWithTodoStreaming(agent, userMessage, spinner);
+  const findings = result.structuredResponse.findings;
+  if (!Array.isArray(findings)) {
+    throw new Error("Agent did not return structured findings.");
+  }
+  return findings;
+}
+function buildVitestUserMessage(ctx) {
+  const { metrics, hasHeapProfiles, hasListenerTracking } = ctx;
+  const lines = [
+    "Analyze the performance of the APPLICATION CODE being tested in this Vitest workspace.",
+    "",
+    `Test suite: ${metrics.suite.totalTests} tests, total duration ${metrics.suite.totalDuration}ms`,
+    `CPU breakdown: application ${metrics.cpu.applicationPercent}%, dependencies ${metrics.cpu.dependencyPercent}%, GC ${metrics.cpu.gcPercentage}%, idle ${metrics.cpu.idlePercentage}%`,
+    `Slowest file: ${metrics.suite.slowestFile} (${metrics.suite.slowestFileDuration}ms)`,
+    `Slowest test: ${metrics.suite.slowestTestName} (${metrics.suite.slowestTestDuration}ms)`,
+    "",
+    "Available data:",
+    "- /hot-functions/application.json — application-level CPU hotspots",
+    "- /scripts/application.json — per-file CPU time for application code",
+    "- /hot-functions/dependencies.json — dependency CPU hotspots",
+    "- /scripts/dependencies.json — per-file CPU time for dependencies"
+  ];
+  if (hasListenerTracking) {
+    lines.push("- /listener-tracking.json — event listener add/remove patterns and exceedances");
+  }
+  if (hasHeapProfiles) {
+    lines.push("- /heap-profiles/index.json — heap profile manifest", "- /heap-profiles/<file>.json — per-file allocation hotspots");
+  }
+  lines.push("- /summary.json — overall test run summary", "- /timing/overview.json — per-file test durations", "- /timing/slow-tests.json — tests exceeding the slow threshold", "- /profiles/ — full CPU profile summaries with call trees", "- /metrics/current.json — pre-computed aggregate metrics", "- /src/ and /tests/ — source files", "", "Focus findings on the APPLICATION code — what can the developer change in their own", "codebase to improve performance? Read source files to verify root causes before suggesting fixes.");
+  return lines.join(`
+`);
+}
+async function analyzeTestPerformance(model, backend, spinner, context) {
+  const agent = createDeepAgent({
+    model,
+    systemPrompt: VITEST_SYSTEM_PROMPT,
+    backend,
+    responseFormat: providerStrategy(FindingsSchema)
+  });
+  const userMessage = context ? buildVitestUserMessage(context) : [
+    "Analyze the performance of the APPLICATION CODE being tested in this Vitest workspace.",
+    "",
+    "Start with /hot-functions/application.json, then explore source files to verify",
+    "root causes and provide code-level fixes."
+  ].join(`
+`);
+  const result = await invokeWithTodoStreaming(agent, userMessage, spinner);
+  const findings = result.structuredResponse?.findings;
+  if (!Array.isArray(findings)) {
+    throw new Error(`Failed to analyze test performance: ${result.messages.at(-1)?.text}`);
+  }
+  return findings;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
-// src/cli.ts
-init_agent();
 // src/sandbox/workspace.ts
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
@@ -1578,12 +1554,13 @@ function getListenerImbalances(tracking) {
     }))
   ].filter((c) => c.addCount > c.removeCount + LISTENER_IMBALANCE_THRESHOLD).sort((a, b) => b.addCount - b.removeCount - (a.addCount - a.removeCount));
 }
+var LISTENER_TRACKING_JSONL = "listener-tracking.jsonl";
 function generateListenerTrackerScript(outputDir) {
   return `// zeitzeuge: Event listener tracker (auto-injected via --import)
 // Tracks EventTarget/EventEmitter listener add/remove patterns
-// and writes a summary to the profile directory on process exit.
+// and appends a summary line to a shared JSONL file on process exit.
-import { writeFileSync } from 'node:fs';
+import { appendFileSync } from 'node:fs';
 import { join } from 'node:path';
 import EventEmitter from 'node:events';
@@ -1717,8 +1694,10 @@ process.on('exit', () => {
       Object.keys(data.emitterCounts).length > 0;
     if (!hasData) return;
-    const outPath = join(OUTPUT_DIR, 'listener-tracking-' + process.pid + '.json');
-    writeFileSync(outPath, JSON.stringify(data));
+    // Append a single JSON line to the shared JSONL file.
+    // Each line is well under PIPE_BUF so O_APPEND guarantees atomicity.
+    const outPath = join(OUTPUT_DIR, '${LISTENER_TRACKING_JSONL}');
+    appendFileSync(outPath, JSON.stringify(data) + '\\n');
   } catch {}
 });
 `;