@zeitzeuge/node 0.1.0

package/dist/index.js

@@ -0,0 +1,3873 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/reporter.ts
+import { readdirSync, readFileSync, existsSync, rmSync, statSync } from "node:fs";
+import { join, resolve as resolve2 } from "node:path";
+import ora2 from "ora";
+
+// ../utils/src/types.ts
+var LISTENER_IMBALANCE_THRESHOLD = 5;
+function getListenerImbalances(tracking) {
+  return [
+    ...Object.entries(tracking.eventTargetCounts).map(([t, c]) => ({
+      api: "EventTarget",
+      type: t,
+      ...c
+    })),
+    ...Object.entries(tracking.emitterCounts).map(([t, c]) => ({
+      api: "EventEmitter",
+      type: t,
+      ...c
+    }))
+  ].filter((c) => c.addCount > c.removeCount + LISTENER_IMBALANCE_THRESHOLD).sort((a, b) => b.addCount - b.removeCount - (a.addCount - a.removeCount));
+}
+// ../utils/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)
+});
+// ../utils/src/models/init.ts
+async function initModel() {
+  const modelOverride = process.env.ZEITZEUGE_MODEL;
+  const openaiKey = process.env.OPENAI_API_KEY;
+  const anthropicKey = process.env.ANTHROPIC_API_KEY;
+  if (openaiKey) {
+    const { ChatOpenAI } = await import("@langchain/openai");
+    return new ChatOpenAI({
+      model: modelOverride ?? "gpt-5.2",
+      apiKey: openaiKey
+    });
+  }
+  if (anthropicKey) {
+    const { ChatAnthropic } = await import("@langchain/anthropic");
+    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-...
+`);
+}
+// ../utils/src/analysis/agent.ts
+import { setMaxListeners } from "node:events";
+
+// ../utils/src/output/progress.ts
+import pc from "picocolors";
+
+class TodoProgressRenderer {
+  spinner;
+  lastStatusByKey = new Map;
+  lastInProgressKey;
+  baseSpinnerText;
+  printedHeader = false;
+  lastMainToolKey;
+  seenTaskKeys = new Set;
+  lastSubagentToolCallKeys = new Map;
+  dispatchedSubagents = [];
+  namespaceToSubagentName = new Map;
+  currentInProgressContent;
+  totalTodos = 0;
+  completedTodos = 0;
+  subagentTodos = new Map;
+  pendingAutoTasks = new Set;
+  canAnimate;
+  constructor(spinner, { animate = true } = {}) {
+    this.spinner = spinner;
+    this.baseSpinnerText = spinner.text;
+    this.canAnimate = animate;
+  }
+  printHeaderOnce() {
+    if (this.printedHeader)
+      return;
+    this.printedHeader = true;
+    const header = "Performance analysis progress:";
+    this.spinner.stopAndPersist({ symbol: " ", text: header });
+    if (this.canAnimate)
+      this.spinner.start();
+  }
+  progressPrefix() {
+    if (this.totalTodos === 0)
+      return "";
+    return pc.dim(`[${this.completedTodos}/${this.totalTodos}]`) + " ";
+  }
+  recomputeCounts() {
+    let total = 0;
+    let completed = 0;
+    for (const status of this.lastStatusByKey.values()) {
+      if (status !== "cancelled")
+        total++;
+      if (status === "completed")
+        completed++;
+    }
+    this.totalTodos = total;
+    this.completedTodos = completed;
+  }
+  updateSpinnerText(contextLabel) {
+    const prefix = this.progressPrefix();
+    const base = this.baseSpinnerText ?? "";
+    const ctx = contextLabel ? ` (${contextLabel})` : "";
+    this.spinner.text = `${prefix}${base}${ctx}`;
+  }
+  persistLine(symbol, text) {
+    this.spinner.stopAndPersist({ symbol, text });
+    if (this.canAnimate) {
+      this.spinner.start();
+      this.updateSpinnerText(this.currentInProgressContent);
+    }
+  }
+  resolveSubagentName(nsKey, namespace) {
+    return this.namespaceToSubagentName.get(nsKey) ?? extractSubagentNameFromNamespace(namespace, this.dispatchedSubagents) ?? this.dispatchedSubagents[this.dispatchedSubagents.length - 1] ?? "subagent";
+  }
+  subagentProgressPrefix() {
+    const numSubagents = this.dispatchedSubagents.length;
+    if (numSubagents === 0)
+      return "   ";
+    const weightPerSubagent = 1 / numSubagents;
+    let totalProgress = 0;
+    for (const stateMap of this.subagentTodos.values()) {
+      let subTotal = 0;
+      let subCompleted = 0;
+      for (const status of stateMap.values()) {
+        if (status !== "cancelled")
+          subTotal++;
+        if (status === "completed")
+          subCompleted++;
+      }
+      if (subTotal > 0) {
+        totalProgress += subCompleted / subTotal * weightPerSubagent;
+      }
+    }
+    const pct = Math.round(totalProgress * 100);
+    return pc.dim(`${String(pct).padStart(3)}%`);
+  }
+  handleSubagentTodos(todos, nsKey, displayName) {
+    if (!this.subagentTodos.has(nsKey)) {
+      this.subagentTodos.set(nsKey, new Map);
+    }
+    const stateMap = this.subagentTodos.get(nsKey);
+    const transitions = [];
+    for (const todo of todos) {
+      const key = todo.content;
+      const prevStatus = stateMap.get(key);
+      const nextStatus = todo.status;
+      if (prevStatus === nextStatus)
+        continue;
+      stateMap.set(key, nextStatus);
+      transitions.push({ todo, prevStatus });
+    }
+    for (const { todo, prevStatus } of transitions) {
+      if (todo.status === "completed" && prevStatus !== "completed") {
+        this.printHeaderOnce();
+        const pct = this.subagentProgressPrefix();
+        const label = `  ${pct} ${pc.cyan(`[${displayName}]`)} ${pc.green("✓")} ${todo.content}`;
+        this.persistLine(" ", label);
+      } else if (todo.status === "in_progress" && prevStatus !== "in_progress") {
+        this.printHeaderOnce();
+        const pct = this.subagentProgressPrefix();
+        const label = `  ${pct} ${pc.cyan(`[${displayName}]`)} ${pc.yellow("▸")} ${pc.dim(todo.content)}`;
+        this.persistLine(" ", label);
+      }
+    }
+  }
+  handleChunk(chunk, meta) {
+    const isSubagent = meta?.isSubagent === true;
+    const nsKey = normalizeNamespace(meta?.namespace);
+    if (isSubagent && nsKey && !this.namespaceToSubagentName.has(nsKey)) {
+      const name = extractSubagentNameFromChunk(chunk);
+      if (name)
+        this.namespaceToSubagentName.set(nsKey, name);
+    }
+    const toolCalls = extractToolCallsFromStreamChunk(chunk);
+    if (toolCalls && toolCalls.length > 0) {
+      const newlyDispatched = [];
+      for (const tc of toolCalls) {
+        if (!isSubagent && tc.name === "task") {
+          const subagentType = tc.args.subagent_type;
+          if (typeof subagentType === "string" && !this.dispatchedSubagents.includes(subagentType)) {
+            this.dispatchedSubagents.push(subagentType);
+            newlyDispatched.push(subagentType);
+          }
+        }
+        if (tc.name === "write_todos") {
+          if (isSubagent) {
+            const todos2 = tc.args.todos;
+            if (Array.isArray(todos2)) {
+              const displayName = this.resolveSubagentName(nsKey, meta?.namespace);
+              this.handleSubagentTodos(todos2, nsKey, displayName);
+              const autoNsKey = `auto:${displayName}`;
+              if (this.subagentTodos.has(autoNsKey)) {
+                this.subagentTodos.delete(autoNsKey);
+                this.pendingAutoTasks.delete(displayName);
+              }
+            }
+          }
+          continue;
+        }
+        if (tc.name.startsWith("extract"))
+          continue;
+        const dedupKey = tc.name === "task" && typeof tc.args.subagent_type === "string" ? `task:${tc.args.subagent_type}` : tc.name;
+        const signature = formatToolCall(tc);
+        let isDuplicate;
+        if (isSubagent) {
+          const lastKey = this.lastSubagentToolCallKeys.get(nsKey);
+          isDuplicate = dedupKey === lastKey;
+          if (!isDuplicate)
+            this.lastSubagentToolCallKeys.set(nsKey, dedupKey);
+        } else if (dedupKey.startsWith("task:")) {
+          isDuplicate = this.seenTaskKeys.has(dedupKey);
+          if (!isDuplicate)
+            this.seenTaskKeys.add(dedupKey);
+        } else {
+          isDuplicate = dedupKey === this.lastMainToolKey;
+          this.lastMainToolKey = dedupKey;
+        }
+        if (!isDuplicate) {
+          this.printHeaderOnce();
+          const displayName = isSubagent ? this.resolveSubagentName(nsKey, meta?.namespace) : "";
+          const label = isSubagent ? `      ↳ ${pc.cyan(`[${displayName}]`)} ${signature}` : `  ↳ ${signature}`;
+          this.persistLine(" ", pc.dim(label));
+        }
+      }
+      for (const name of newlyDispatched) {
+        const autoNsKey = `auto:${name}`;
+        this.handleSubagentTodos([{ content: "analyzing", status: "in_progress" }], autoNsKey, name);
+        this.pendingAutoTasks.add(name);
+      }
+      if (!isSubagent && this.pendingAutoTasks.size > 0) {
+        const hasNonTaskCalls = toolCalls.some((tc) => tc.name !== "task" && tc.name !== "write_todos");
+        if (hasNonTaskCalls) {
+          for (const name of this.pendingAutoTasks) {
+            const autoNsKey = `auto:${name}`;
+            this.handleSubagentTodos([{ content: "analyzing", status: "completed" }], autoNsKey, name);
+          }
+          this.pendingAutoTasks.clear();
+        }
+      }
+    }
+    if (isSubagent)
+      return;
+    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);
+        this.recomputeCounts();
+        if (nextStatus === "completed" && prevStatus !== "completed") {
+          this.printHeaderOnce();
+          this.persistLine(" ", `  ${this.progressPrefix()}${pc.green("✓")} ${todo.content}`);
+          this.lastMainToolKey = undefined;
+          this.seenTaskKeys.clear();
+          this.lastSubagentToolCallKeys.clear();
+        }
+        if (nextStatus === "in_progress" && this.lastInProgressKey !== key) {
+          this.lastInProgressKey = key;
+          this.currentInProgressContent = todo.content;
+          this.printHeaderOnce();
+          if (this.canAnimate) {
+            this.updateSpinnerText(todo.content);
+          }
+          this.lastMainToolKey = undefined;
+          this.seenTaskKeys.clear();
+          this.lastSubagentToolCallKeys.clear();
+        }
+      }
+    }
+  }
+}
+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;
+  }
+}
+function extractToolCallsFromStreamChunk(chunk) {
+  if (!chunk || typeof chunk !== "object")
+    return;
+  const results = [];
+  const extractFromMessage = (msg) => {
+    if (!msg || typeof msg !== "object")
+      return;
+    const m = msg;
+    if (!Array.isArray(m.tool_calls) || m.tool_calls.length === 0)
+      return;
+    for (const tc of m.tool_calls) {
+      if (tc.name) {
+        results.push({ name: tc.name, args: tc.args ?? {} });
+      }
+    }
+  };
+  const extractFromMessages = (messages) => {
+    if (!Array.isArray(messages))
+      return;
+    const last = messages[messages.length - 1];
+    extractFromMessage(last);
+  };
+  const direct = chunk;
+  if (Array.isArray(direct.messages)) {
+    extractFromMessages(direct.messages);
+    if (results.length > 0)
+      return results;
+  }
+  for (const value of Object.values(chunk)) {
+    if (!value || typeof value !== "object")
+      continue;
+    const nested = value;
+    if (Array.isArray(nested.messages)) {
+      extractFromMessages(nested.messages);
+      if (results.length > 0)
+        return results;
+    }
+  }
+  return results.length > 0 ? results : undefined;
+}
+function formatToolCall(tc) {
+  const args = tc.args;
+  const keys = Object.keys(args);
+  if (keys.length === 0)
+    return `${tc.name}()`;
+  if (keys.length === 1) {
+    const key = keys[0];
+    const val = args[key];
+    if (typeof val === "string" && val.length <= 80) {
+      return `${tc.name}(${key}: ${JSON.stringify(val)})`;
+    }
+  }
+  const parts = [];
+  for (const key of keys.slice(0, 3)) {
+    const val = args[key];
+    parts.push(`${key}: ${truncateValue(val)}`);
+  }
+  if (keys.length > 3)
+    parts.push("...");
+  return `${tc.name}(${parts.join(", ")})`;
+}
+function normalizeNamespace(ns) {
+  if (typeof ns === "string")
+    return ns;
+  if (Array.isArray(ns))
+    return ns.filter((s) => typeof s === "string").join("|");
+  return "";
+}
+function extractSubagentNameFromNamespace(ns, knownNames) {
+  const nsStr = normalizeNamespace(ns).toLowerCase();
+  if (!nsStr)
+    return;
+  for (const name of knownNames) {
+    if (nsStr.includes(name.toLowerCase()))
+      return name;
+  }
+  return;
+}
+function extractSubagentNameFromChunk(chunk) {
+  if (!chunk || typeof chunk !== "object")
+    return;
+  const nameFromMessage = (msg) => {
+    if (!msg || typeof msg !== "object")
+      return;
+    const kwargs = msg.kwargs;
+    if (kwargs && typeof kwargs.name === "string" && kwargs.name.length > 0) {
+      return kwargs.name;
+    }
+    const direct = msg;
+    if (typeof direct.name === "string" && direct.name.length > 0) {
+      return direct.name;
+    }
+  };
+  const obj = chunk;
+  const modelReq = obj.model_request;
+  if (modelReq && Array.isArray(modelReq.messages)) {
+    for (const msg of modelReq.messages) {
+      const name = nameFromMessage(msg);
+      if (name)
+        return name;
+    }
+  }
+  if (Array.isArray(obj.messages) && obj.messages.length > 0) {
+    const last = obj.messages[obj.messages.length - 1];
+    const name = nameFromMessage(last);
+    if (name)
+      return name;
+  }
+  for (const value of Object.values(obj)) {
+    if (!value || typeof value !== "object" || value === modelReq)
+      continue;
+    const nested = value;
+    if (!Array.isArray(nested.messages))
+      continue;
+    for (const msg of nested.messages) {
+      const name = nameFromMessage(msg);
+      if (name)
+        return name;
+    }
+  }
+}
+function truncateValue(val, maxLen = 40) {
+  if (typeof val === "string") {
+    return val.length > maxLen ? JSON.stringify(val.slice(0, maxLen - 3) + "...") : JSON.stringify(val);
+  }
+  if (typeof val === "number" || typeof val === "boolean")
+    return String(val);
+  const json = JSON.stringify(val);
+  if (json && json.length > maxLen)
+    return json.slice(0, maxLen - 3) + "...";
+  return json ?? "undefined";
+}
+
+// ../utils/src/analysis/agent.ts
+function isSubagentNamespace(ns) {
+  if (typeof ns === "string")
+    return ns.includes("tools:");
+  if (Array.isArray(ns))
+    return ns.some((s) => typeof s === "string" && s.includes("tools:"));
+  return false;
+}
+async function invokeWithTodoStreaming(agent, userMessage, spinner, { animateProgress = true } = {}) {
+  const renderer = new TodoProgressRenderer(spinner, { animate: animateProgress });
+  setMaxListeners(0);
+  const controller = new AbortController;
+  setMaxListeners(0, controller.signal);
+  const stream = await agent.stream({ messages: [{ role: "user", content: userMessage }] }, { streamMode: ["updates", "values"], subgraphs: true, signal: controller.signal });
+  let lastValues;
+  for await (const item of stream) {
+    if (!Array.isArray(item)) {
+      renderer.handleChunk(item);
+      lastValues = item;
+      continue;
+    }
+    if (item.length === 3) {
+      const [ns, mode, chunk] = item;
+      const isSubagent = isSubagentNamespace(ns);
+      renderer.handleChunk(chunk, { isSubagent, namespace: ns });
+      if (!isSubagent && mode === "values")
+        lastValues = chunk;
+      continue;
+    }
+    if (item.length === 2) {
+      const [mode, chunk] = item;
+      renderer.handleChunk(chunk);
+      if (mode === "values")
+        lastValues = chunk;
+      continue;
+    }
+  }
+  return lastValues;
+}
+// ../utils/src/analysis/merge-findings.ts
+var FINDINGS_DIR = "/findings";
+var MERGED_FILENAME = "merged.json";
+function toAbsoluteFindingsPath(entryPath) {
+  const lastSlash = entryPath.lastIndexOf("/");
+  const filename = lastSlash >= 0 ? entryPath.slice(lastSlash + 1) : entryPath;
+  return `${FINDINGS_DIR}/${filename}`;
+}
+async function mergeFindings(backend) {
+  let entries;
+  try {
+    entries = await backend.lsInfo(FINDINGS_DIR);
+  } catch {
+    return [];
+  }
+  const jsonFiles = entries.filter((e) => e.path.endsWith(".json") && !e.path.endsWith(MERGED_FILENAME));
+  if (jsonFiles.length === 0) {
+    return [];
+  }
+  const allFindings = [];
+  for (const entry of jsonFiles) {
+    const filePath = toAbsoluteFindingsPath(entry.path);
+    try {
+      const fileData = await backend.readRaw(filePath);
+      const raw = fileData.content.join(`
+`);
+      const parsed = JSON.parse(raw);
+      const validated = FindingsSchema.safeParse(parsed);
+      if (validated.success) {
+        allFindings.push(...validated.data.findings);
+      } else {
+        console.warn(`[merge-findings] Skipping ${filePath}: schema validation failed`);
+      }
+    } catch (err) {
+      console.warn(`[merge-findings] Skipping ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  try {
+    const mergedContent = JSON.stringify({ findings: allFindings }, null, 2);
+    await backend.write(`${FINDINGS_DIR}/${MERGED_FILENAME}`, mergedContent);
+  } catch {}
+  return allFindings;
+}
+// ../utils/src/analysis/deduplication.ts
+function extractFunctionName(finding) {
+  if (finding.hotFunction?.name) {
+    return finding.hotFunction.name;
+  }
+  const text = `${finding.title ?? ""} ${finding.description ?? ""}`;
+  const callMatch = text.match(/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(\)/);
+  if (callMatch)
+    return callMatch[1];
+  const backtickMatch = text.match(/`([a-zA-Z_$][a-zA-Z0-9_$]*)`/);
+  if (backtickMatch)
+    return backtickMatch[1];
+  return null;
+}
+var SEVERITY_ORDER = {
+  critical: 0,
+  warning: 1,
+  info: 2
+};
+var CONFIDENCE_ORDER = {
+  high: 0,
+  medium: 1,
+  low: 2
+};
+function severityRank(s) {
+  return SEVERITY_ORDER[s ?? "info"] ?? 3;
+}
+function confidenceRank(c) {
+  return CONFIDENCE_ORDER[c ?? ""] ?? 3;
+}
+function findingQualityScore(f) {
+  let score = 0;
+  if (f.beforeCode && f.afterCode)
+    score += 100;
+  else if (f.beforeCode || f.afterCode)
+    score += 30;
+  score += (3 - confidenceRank(f.confidence)) * 20;
+  score += (3 - severityRank(f.severity)) * 15;
+  score += Math.min((f.description?.length ?? 0) / 50, 10);
+  if (f.sourceFile)
+    score += 10;
+  if (f.lineNumber)
+    score += 5;
+  return score;
+}
+function deduplicateFindings(findings) {
+  const ungroupable = [];
+  const groups = new Map;
+  for (const finding of findings) {
+    const funcName = extractFunctionName(finding);
+    const sourceFile = finding.sourceFile ?? finding.workspacePath;
+    if (!sourceFile || !funcName) {
+      ungroupable.push(finding);
+      continue;
+    }
+    const normalizedFile = sourceFile.toLowerCase().split("/").pop() ?? sourceFile;
+    const groupKey = `${normalizedFile}::${funcName.toLowerCase()}`;
+    const category = (finding.category ?? "other").toLowerCase();
+    if (!groups.has(groupKey)) {
+      groups.set(groupKey, new Map);
+    }
+    const categoryMap = groups.get(groupKey);
+    if (!categoryMap.has(category)) {
+      categoryMap.set(category, []);
+    }
+    categoryMap.get(category).push(finding);
+  }
+  const deduped = [...ungroupable];
+  for (const categoryMap of groups.values()) {
+    for (const candidatesInCategory of categoryMap.values()) {
+      if (candidatesInCategory.length === 0)
+        continue;
+      let best = candidatesInCategory[0];
+      let bestScore = findingQualityScore(best);
+      for (let i = 1;i < candidatesInCategory.length; i++) {
+        const score = findingQualityScore(candidatesInCategory[i]);
+        if (score > bestScore) {
+          best = candidatesInCategory[i];
+          bestScore = score;
+        }
+      }
+      deduped.push(best);
+    }
+  }
+  return deduped;
+}
+function rankFindings(findings) {
+  return [...findings].sort((a, b) => {
+    const sevDiff = severityRank(a.severity) - severityRank(b.severity);
+    if (sevDiff !== 0)
+      return sevDiff;
+    const impactDiff = (b.impactMs ?? 0) - (a.impactMs ?? 0);
+    if (impactDiff !== 0)
+      return impactDiff;
+    return confidenceRank(a.confidence) - confidenceRank(b.confidence);
+  });
+}
+// ../utils/src/prompts/shared.ts
+var VERIFICATION_RULES = `## Verification rules (mandatory for every finding)
+
+1. **ALWAYS read the source file** before reporting a finding. You MUST have
+   read the actual code. Never report based on function names or profiling data alone.
+2. **Copy code verbatim** — beforeCode must be copied exactly from the file you
+   read, not paraphrased. Line numbers must match what you observed.
+3. **Provide a working fix** — afterCode must be a complete drop-in replacement
+   that compiles, preserves the EXACT function signature, and only fixes the perf issue.
+4. **Never omit beforeCode/afterCode** — every finding MUST have both fields set.
+5. **Do NOT change sync to async** — if a function is synchronous, afterCode must
+   also be synchronous. Replace the inefficient implementation with a faster sync
+   alternative (e.g., use crypto.createHash instead of a manual loop). Mention the
+   async alternative in the description, but keep afterCode as a sync drop-in.`;
+var OUTPUT_FORMAT = `## Output requirements
+
+- Report ALL findings within YOUR scope — typically 3–5 per subagent.
+  Exhaustively analyze every function but stay within your assigned categories.
+- Each finding MUST have sourceFile, beforeCode, and afterCode
+- Be specific — name exact files, functions, and line numbers
+- Provide concrete code-level fixes, not generic advice
+- Do NOT report findings about test files — only about application source files
+
+### CRITICAL: Multiple findings per function and per file
+
+- A single function CAN have multiple distinct issues WITHIN YOUR SCOPE —
+  report each as a SEPARATE finding with a different category.
+- A single file often has MANY issues across different functions. Read the
+  ENTIRE file top-to-bottom and report EVERY issue you find within your scope.
+- If function A calls function B and both have issues, report findings for
+  BOTH functions separately.
+- Do NOT skip issues you consider "minor" — report them with severity: info.
+- Do NOT report issues that belong to another subagent's scope.`;
+var FINDING_CATEGORIES = `## Finding categories
+
+Each finding MUST use one of these EXACT category values — do NOT invent new categories:
+
+- **algorithm** — Inefficient algorithm: O(n²) loops, brute-force search, repeated work
+- **serialization** — Excessive JSON.stringify/parse, string concatenation, encoding
+- **allocation** — Excessive object/array creation, per-call instantiation 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** — Memory leaks, closure-captured references, unbounded data structures
+  that grow without eviction, or high garbage collection overhead. Use this for ANY
+  finding about memory growth, retained references, or missing cleanup/eviction.
+- **listener-leak** — Event listeners not cleaned up properly
+- **unnecessary-computation** — Redundant work that could be cached or eliminated,
+  including regex recompilation with constant patterns
+- **blocking-io** — Synchronous I/O or blocking operations in hot paths
+- **memory-leak** — Memory leaks from unbounded arrays, maps, caches
+- **large-retained-object** — Single objects retaining disproportionate memory
+- **detached-dom** — Detached DOM nodes still referenced in memory
+- **render-blocking** — Render-blocking scripts or stylesheets
+- **long-task** — Long tasks blocking the main thread
+- **waterfall-bottleneck** — Sequential resource chains that could load in parallel
+- **large-asset** — Oversized bundles or assets
+- **frame-blocking-function** — Functions blocking the main thread > 50ms
+- **other** — Doesn't fit any of the above
+
+Prefer more specific categories (algorithm, serialization, allocation, event-handling,
+blocking-io, listener-leak, gc-pressure) over generic ones (hot-function, other).`;
+var PARALLEL_TOOL_CALLS = `## CRITICAL: Tool call strategy — scripts for data, read_file for source
+
+Your FIRST turn MUST:
+1. Run analysis scripts (execute_command) to query the JSON data files.
+   Use pre-built helper scripts in skills/ or write your own using the
+   data-scripting skill.
+2. Call read_file for ALL application source files listed above.
+
+Batch everything into ONE turn. Do NOT read data files one-at-a-time.
+
+For data files: run a helper script or write a custom one. This is faster
+and uses fewer tokens than reading raw JSON.
+
+For source files: use read_file since you need to see the exact code for
+beforeCode/afterCode suggestions.
+
+FORBIDDEN actions:
+- ls — NEVER call ls. File paths are already listed above.
+- glob — NEVER call glob. File paths are already listed above.
+- Reading JSON data files with read_file — use scripts instead.`;
+var WRITE_FINDINGS_REQUIREMENT = `## CRITICAL — Persist your findings to a file
+
+When your analysis is complete, you MUST write ALL findings to a JSON file using write_file.
+
+1. Call write_file with path: \`/findings/<YOUR_AGENT_NAME>.json\`
+   Use your agent name as the filename (e.g. memory-heap, page-load, runtime-blocking,
+   code-pattern, cpu-hotspot, listener-leak, memory-closure).
+
+2. The file content MUST be a JSON object with this exact structure:
+   { "findings": [ { "severity": "...", "title": "...", ... }, ... ] }
+   Each finding must include ALL required fields: severity, title, description,
+   category, sourceFile, lineNumber, suggestedFix, beforeCode, afterCode,
+   confidence, impactMs, estimatedSavingsMs.
+
+3. Write ALL findings in a SINGLE write_file call. Do NOT write findings one at a time.
+
+4. After writing the file, respond with ONLY a brief summary like:
+   "Found 4 issues: 2 critical, 1 warning, 1 info. Written to /findings/memory-heap.json"
+
+The orchestrator reads findings from the file directly — your text response is only for
+progress display. If a finding is not in the JSON file, it does not exist.`;
+var STRUCTURED_OUTPUT_FIELDS = `## Structured output fields — REQUIRED for every finding
+
+Every finding MUST include ALL of these fields:
+
+- \`sourceFile\` — (REQUIRED) the workspace path (e.g. src/utils/parser.ts or scripts/app.js)
+- \`lineNumber\` — (REQUIRED) the 1-based line number, verified by reading the file
+- \`confidence\` — \`high\` if you read the source, \`medium\` if strongly suggested,
+  \`low\` if inferred
+- \`beforeCode\` — (REQUIRED) the CURRENT problematic code, COPIED VERBATIM from the
+  source file you read. Include the full function or the relevant 5–20 lines.
+  This MUST be actual code from the file, not a paraphrase or summary.
+- \`afterCode\` — (REQUIRED) the IMPROVED code showing the fix. This MUST be a
+  complete, working drop-in replacement for \`beforeCode\`:
+  - Same function signature and exports
+  - Same return type and API contract
+  - Only changes the performance issue — preserves all other behavior
+  - Include ALL the code from beforeCode with just the fix applied
+- \`estimatedSavingsMs\` — your estimate of time saved if the fix is applied
+- \`impactMs\` — the current measured cost (e.g. selfTime of the hot function,
+  blocking function duration, resource load time)
+
+### beforeCode / afterCode rules
+
+- NEVER leave beforeCode or afterCode empty. Every finding must have both.
+- beforeCode must be VERBATIM from the source file — do not abbreviate or paraphrase.
+  Copy the COMPLETE function (or the complete relevant section of 5-30 lines).
+  Do NOT use "..." or "// ..." to skip lines. Include the full code block.
+- afterCode must be a COMPLETE, WORKING replacement for the beforeCode block:
+  - SAME function signature — same name, same parameters, same return type
+  - SAME sync/async — if the original is sync, afterCode MUST be sync. Do NOT
+    add async/await, Promises, or callbacks. Replace the slow implementation
+    with a faster synchronous alternative instead.
+  - SAME exports — if the function is exported, afterCode must also export it
+  - Must compile and produce identical behavior except for the performance fix
+  - Include ALL the code from beforeCode, not just the changed lines
+  - If the fix requires adding a module-level constant (e.g., hoisting a RegExp or
+    TextEncoder), include that declaration ABOVE the function in afterCode
+  - For blocking CPU loops: replace with a faster sync algorithm (e.g., use
+    crypto.createHash() instead of a manual loop). Mention async alternatives
+    in the finding description, not in afterCode.
+  - For excessive instantiation: hoist the construction to module level and reuse it.
+    Show the module-level const AND the modified function in afterCode.
+  - For listener leaks: show the fix (e.g., .once() instead of .on(), or return
+    an unsubscribe function). The beforeCode/afterCode should show the same function
+    with only the listener fix changed.
+- afterCode must NOT be a diff, pseudocode, or description of changes
+- If you cannot provide a concrete fix, still include beforeCode and describe
+  the fix approach in afterCode as a code comment within the actual code
+
+### Code fix quality rules
+
+1. **Named functions for event handlers**: NEVER use anonymous functions with
+   .on() or .addEventListener(). Always define a named function or const so
+   it can be removed with .off(event, handler). Example:
+   - BAD:  emitter.on('change', () => { cache = null; })
+   - GOOD: const invalidateCache = () => { cache = null; };
+           emitter.on('change', invalidateCache);
+2. **Surgical listener removal**: Use .off(event, specificHandler) instead of
+   .removeAllListeners(). The cleanup/reset function must remove the EXACT
+   handler that was added.
+3. **Complete guard logic**: If you add a guard flag (e.g., listenerRegistered),
+   the cleanup function MUST reset the flag AND remove the specific listener.
+4. **Include surrounding context**: If the fix adds module-level variables
+   (guard flags, hoisted constants, named handlers), include ALL of them in
+   afterCode so it is self-contained.
+5. **Preserve existing functions**: If the original file has a cleanup/reset
+   function, update it in afterCode to properly undo whatever your fix added.
+   Do NOT ignore existing cleanup functions.`;
+// ../utils/src/prompts/file-list.ts
+function buildFileListPromptSection(config) {
+  const { dataFiles, sourceFiles, testFiles, additionalSections } = config;
+  const lines = [
+    "## FILES IN THIS WORKSPACE — Read these directly. Do NOT use ls or glob.",
+    "",
+    "### Data files"
+  ];
+  for (const file of dataFiles) {
+    if (file.description) {
+      lines.push(`- ${file.path} ${file.description}`);
+    } else {
+      lines.push(`- ${file.path}`);
+    }
+  }
+  if (sourceFiles && sourceFiles.length > 0) {
+    lines.push("", "### Application source files — you MUST read ALL of these in your FIRST turn");
+    for (const f of sourceFiles) {
+      lines.push(`- ${f}`);
+    }
+  }
+  if (testFiles && testFiles.length > 0) {
+    lines.push("", "### Test files");
+    for (const f of testFiles) {
+      lines.push(`- ${f}`);
+    }
+  }
+  if (additionalSections) {
+    for (const section of additionalSections) {
+      lines.push("", `### ${section.title}`);
+      for (const f of section.files) {
+        lines.push(`- ${f}`);
+      }
+    }
+  }
+  lines.push("", "> IMPORTANT: The file paths above are COMPLETE. Do NOT use ls or glob to");
+  lines.push(sourceFiles && sourceFiles.length > 0 ? "> discover files. Just call read_file for each path listed above." : "> discover files. Read the data files first, then read source files selectively.");
+  return lines.join(`
+`);
+}
+function insertFileListIntoPrompt(prompt, fileSection) {
+  if (!fileSection)
+    return prompt;
+  const firstHeadingIdx = prompt.indexOf(`
+## `);
+  if (firstHeadingIdx === -1) {
+    return prompt + `
+
+` + fileSection;
+  }
+  return prompt.slice(0, firstHeadingIdx) + `
+
+` + fileSection + `
+` + prompt.slice(firstHeadingIdx);
+}
+// ../utils/src/workspace/builder.ts
+import { VfsSandbox } from "@langchain/node-vfs";
+
+class PerfAgentSandbox extends VfsSandbox {
+  static #toRelative(p) {
+    const stripped = p.startsWith("/") ? p.slice(1) : p;
+    return stripped || ".";
+  }
+  async read(filePath, offset = 0, limit = 500) {
+    return super.read(PerfAgentSandbox.#toRelative(filePath), offset, limit);
+  }
+  async lsInfo(dirPath) {
+    return super.lsInfo(PerfAgentSandbox.#toRelative(dirPath));
+  }
+  async grepRaw(pattern, searchPath = "/", glob = null) {
+    return super.grepRaw(pattern, PerfAgentSandbox.#toRelative(searchPath), glob);
+  }
+  async globInfo(pattern, searchPath = "/") {
+    return super.globInfo(pattern, PerfAgentSandbox.#toRelative(searchPath));
+  }
+  static async create(options) {
+    const sandbox = new PerfAgentSandbox(options);
+    await sandbox.initialize();
+    return sandbox;
+  }
+}
+async function createWorkspaceFromFiles(files) {
+  const sandbox = await PerfAgentSandbox.create({ initialFiles: files });
+  const cleanup = async () => {
+    try {
+      await sandbox.stop();
+    } catch {}
+  };
+  return { backend: sandbox, cleanup };
+}
+// ../utils/src/skills/data-scripting.ts
+var SKILL_MD = `---
+name: data-scripting
+description: Use this skill when you need to analyze JSON data files in the workspace. Provides instructions for writing Node.js scripts to query, filter, aggregate, and cross-reference data files instead of reading them raw. Includes helper scripts and data file schemas.
+---
+
+# Data Scripting
+
+## Overview
+
+You have a full Node.js runtime available via execute_command. Instead of
+reading large JSON data files with read_file (which consumes many tokens),
+write short scripts that extract exactly what you need.
+
+## When to use scripts vs. read_file
+
+- **read_file**: Source code files you need to see verbatim for
+  beforeCode/afterCode, or small files (<50 lines)
+- **Scripts**: JSON data files, any file >100 lines, cross-referencing
+  multiple files, computing aggregations, filtering by thresholds
+
+## How to run a script
+
+IMPORTANT: All file paths in scripts must use relative paths (no leading
+\`/\`). The execute_command tool runs with the workspace as the current
+directory, so \`fs.readFileSync('hot-functions/application.json')\` resolves
+to \`<workspace>/hot-functions/application.json\`.
+
+Option 1 — inline:
+execute_command: node -e "
+  const data = JSON.parse(require('fs').readFileSync('path/to/file', 'utf8'));
+  const results = data.filter(x => x.duration > 100);
+  console.log(JSON.stringify(results, null, 2));
+"
+
+Option 2 — use a pre-built helper:
+execute_command: node skills/data-scripting/helpers/top-items.js hot-functions/application.json selfTime 10
+
+Option 3 — write a custom script:
+write_file: tmp/my-analysis.js
+execute_command: node tmp/my-analysis.js
+
+## Pre-built helper scripts
+
+### skills/data-scripting/helpers/top-items.js
+Usage: \`node top-items.js <file> <sortField> [limit]\`
+Reads a JSON array, sorts by the given field descending, prints top N items.
+
+### skills/data-scripting/helpers/cross-reference.js
+Usage: \`node cross-reference.js <file1> <field1> <file2> <field2>\`
+Finds items in file1 whose field1 value also appears as field2 in file2.
+
+## Data file schemas
+
+See skills/data-scripting/schemas.md for the JSON structure of every
+data file in this workspace. Read it before writing custom scripts.
+`;
+var SCHEMAS_MD = `# Workspace Data File Schemas
+
+---
+# Workspace files
+---
+
+## summary.json
+{
+  totalTests: number,
+  totalDuration: number,       // ms
+  passCount: number,
+  failCount: number,
+  profileCount: number,
+  slowestFile: string | null,  // file:// URL
+  slowestFileDuration: number,
+  totalGcTime: number,
+  gcPercentage: number
+}
+
+## hot-functions/application.json
+Array of application-code hot functions (filtered to sourceCategory "application"):
+{
+  functionName: string,
+  workspacePath: string,       // e.g. "/src/services/crypto.ts" (has leading /)
+  lineNumber: number,
+  columnNumber: number,
+  selfTime: number,            // ms of CPU self-time
+  totalTime: number,           // ms including callees
+  hitCount: number,
+  selfPercent: number,         // % of total profile duration
+  sourceCategory: "application",
+  sourceSnippet?: string,      // source code context around the hot line
+  callerChain?: [{ functionName, workspacePath, lineNumber }]
+}
+
+## hot-functions/dependencies.json
+Same structure as hot-functions/application.json but sourceCategory "dependency".
+
+## hot-functions/global.json
+All hot functions across all categories (application, dependency, framework, unknown).
+Same item structure. Can be very large (2000+ lines).
+
+## scripts/application.json
+Per-script summary for application code:
+[{ workspacePath: string, selfTime: number, selfPercent: number, functionCount: number }]
+
+## scripts/dependencies.json
+Same structure as scripts/application.json but for dependency scripts.
+
+## src/index.json
+Maps source file paths to their hot functions. Key = workspacePath, value = array:
+{
+  "/src/services/notification-service.ts": [
+    { functionName: string, lineNumber: number, selfTime: number, selfPercent: number }
+  ],
+  "/src/utils/crypto.ts": [...]
+}
+Use this to know WHICH source files have CPU-hot functions.
+
+## listener-tracking.json
+{
+  eventTargetCounts: {},       // browser EventTarget counts (usually empty in Node)
+  emitterCounts: {             // keyed by event name
+    "<eventName>": { addCount: number, removeCount: number },
+    ...
+  },
+  exceedances: [{              // maxListeners threshold exceeded
+    targetType: string,        // e.g. "EventEmitter"
+    eventType: string,         // e.g. "task:changed"
+    listenerCount: number,     // current count that exceeded threshold
+    threshold: number,         // the maxListeners value (default 10)
+    stack: string              // stack trace showing where listener was added
+  }]
+}
+
+## metrics/current.json
+Comprehensive pre-computed metrics (large file):
+{
+  version: number,
+  timestamp: string,
+  suite: { totalDuration, totalTests, passCount, failCount, averageTestDuration,
+           medianTestDuration, p95TestDuration, slowestTestDuration, slowestTestName },
+  cpu: { gcPercentage, gcTime, idlePercentage, idleTime, applicationTime,
+         applicationPercent, dependencyTime, dependencyPercent, testFrameworkTime,
+         testFrameworkPercent },
+  files: { "<file:// URL>": { duration, testCount, setupTime, gcPercentage } },
+  tests: { "<file::testName>": { duration, status } },
+  hotFunctions: [{ key, functionName, scriptUrl, lineNumber, selfTime, selfPercent,
+                   sourceCategory }],
+  listenerTracking: { eventTargetCounts, emitterCounts, exceedances }
+}
+
+## timing/overview.json
+Array of per-file timing data:
+[{
+  file: string,                // file:// URL
+  duration: number,
+  testCount: number,
+  passCount: number,
+  failCount: number,
+  setupTime: number,
+  tests: [{ name: string, duration: number, status: string }]
+}]
+
+## timing/slow-tests.json
+Array of slow tests sorted by duration descending:
+[{ file: string, name: string, duration: number }]
+
+## profiles/index.json
+Manifest mapping test files to their CPU profile paths:
+[{ testFile: string, profilePath: string }]
+
+## profiles/<file>.json
+Per-test-file profile summary:
+{
+  profilePath: string,
+  duration: number,
+  sampleCount: number,
+  hotFunctions: [{
+    functionName, lineNumber, columnNumber, selfTime, totalTime,
+    hitCount, selfPercent, callerChain, sourceCategory, workspacePath
+  }]
+}
+
+---
+# Browser workspace files (CLI agent only — not present in Vitest workspaces)
+---
+
+## heap/summary.json
+{
+  metadata: { url, capturedAt, totalSize, nodeCount, edgeCount },
+  largestObjects: [{ name, type, selfSize, retainedSize, retainerPath: string[] }],
+  typeStats: [{ type, count, totalSize, avgSize }],
+  constructorStats: [{ constructor, count, totalSize, avgSize }],
+  detachedNodes: { count, totalSize, examples: [{ name, retainerPath }] },
+  closureStats: { count, totalSize, topClosures: [{ name, contextSize, retainerPath }] }
+}
+
+## trace/summary.json
+{
+  url: string,
+  timing: { loadComplete, firstContentfulPaint, largestContentfulPaint, totalBlockingTime, longTasks: [...] },
+  requestCount: number,
+  totalTransferSize: number,
+  totalDecodedSize: number,
+  renderBlockingResources: [{ url, type, size, duration, path }],
+  resourceBreakdown: { scripts: { count, totalSize }, stylesheets: {...}, fonts: {...}, images: {...}, other: {...} }
+}
+
+## trace/runtime/blocking-functions.json
+Array of (up to 50 entries, sorted by duration descending):
+{
+  functionName: string,
+  scriptUrl: string,           // URL of the script
+  lineNumber: number,
+  columnNumber: number,
+  duration: number,            // ms blocked on main thread
+  startTime: number,           // ms relative to navigation start
+  callStack: [{                // caller chain (array of objects, NOT strings)
+    functionName: string,
+    scriptUrl: string,
+    lineNumber: number
+  }],
+  category: string             // "scripting" | "layout" | "paint" | etc.
+}
+To get the workspace file path for a scriptUrl, extract the filename:
+  e.g. "https://example.com/static/abc123.js" -> "scripts/abc123.js"
+
+## trace/runtime/event-listeners.json
+Array of (only listeners with addCount > 0):
+{
+  eventType: string,
+  targetType: string,
+  addCount: number,
+  removeCount: number,
+  activeCount: number,
+  stackSnippets: string[]
+}
+
+## trace/runtime/summary.json
+{
+  totalEvents: number,
+  traceDuration: number,       // ms
+  mainThreadId: number,
+  frameBreakdown: { scripting, layout, paint, gc, other },  // all in ms
+  blockingFunctionCount: number,
+  listenerImbalances: number,
+  gcPauseCount: number,
+  gcTotalDuration: number,     // ms
+  frequentEventTypes: string[] // event types dispatched >10 times
+}
+
+## trace/runtime/frame-breakdown.json
+{
+  scripting: number,           // ms spent in script execution
+  layout: number,              // ms spent in layout calculations
+  paint: number,               // ms spent painting
+  gc: number,                  // ms spent in garbage collection
+  other: number                // ms spent in other tasks
+}
+
+## trace/network-waterfall.json
+Array of (sorted by startTime):
+{
+  url: string,
+  type: string,                // "Script" | "Stylesheet" | "Font" | "Document" | "Image"
+  status: number,
+  size: number,                // decoded size in bytes
+  startTime: number,           // ms from navigation start
+  endTime: number,
+  duration: number,
+  isRenderBlocking: boolean,
+  priority: string,
+  path: string | null          // workspace path to stored content (e.g. "/scripts/abc.js")
+}
+
+## trace/asset-manifest.json
+Array of all network assets:
+{
+  url: string,
+  type: string,
+  size: number,                // decoded size in bytes
+  duration: number,
+  isRenderBlocking: boolean,
+  stored: boolean,             // true if content was captured and stored
+  path: string | null          // workspace path if stored
+}
+
+## trace/runtime/raw-events.json
+Array of raw Chrome trace events (can be very large). Each entry has:
+{
+  name: string,                // event name (e.g. "FunctionCall", "Layout", "GCEvent")
+  cat: string,                 // category
+  ph: string,                  // phase ("X" = complete, "B"/"E" = begin/end)
+  ts: number,                  // timestamp in microseconds
+  dur: number,                 // duration in microseconds
+  tid: number,                 // thread ID
+  pid: number,                 // process ID
+  args: object                 // event-specific arguments
+}
+Only use for deep investigation — prefer the summary files first.
+`;
+var TOP_ITEMS_JS = `'use strict';
+
+const fs = require('fs');
+
+const [filePath, sortField, limitArg] = process.argv.slice(2);
+if (!filePath || !sortField) {
+  console.error('Usage: node top-items.js <file> <sortField> [limit]');
+  process.exit(1);
+}
+
+const limit = parseInt(limitArg, 10) || 10;
+
+let raw;
+try {
+  raw = fs.readFileSync(filePath, 'utf8');
+} catch (err) {
+  console.error(\`Error reading \${filePath}: \${err.message}\`);
+  process.exit(1);
+}
+
+let data;
+try {
+  data = JSON.parse(raw);
+} catch (err) {
+  console.error(\`Error parsing JSON from \${filePath}: \${err.message}\`);
+  process.exit(1);
+}
+
+if (!Array.isArray(data)) {
+  console.error(\`Expected a JSON array in \${filePath}, got \${typeof data}\`);
+  process.exit(1);
+}
+
+if (data.length > 0 && !(sortField in data[0])) {
+  console.error(\`Field "\${sortField}" not found in items. Available fields: \${Object.keys(data[0]).join(', ')}\`);
+  process.exit(1);
+}
+
+const sorted = data
+  .slice()
+  .sort((a, b) => (Number(b[sortField]) || 0) - (Number(a[sortField]) || 0))
+  .slice(0, limit);
+
+console.log(JSON.stringify(sorted, null, 2));
+`;
+var CROSS_REFERENCE_JS = `'use strict';
+
+const fs = require('fs');
+
+const [file1Path, field1, file2Path, field2] = process.argv.slice(2);
+if (!file1Path || !field1 || !file2Path || !field2) {
+  console.error('Usage: node cross-reference.js <file1> <field1> <file2> <field2>');
+  process.exit(1);
+}
+
+function readJsonArray(filePath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, 'utf8');
+  } catch (err) {
+    console.error(\`Error reading \${filePath}: \${err.message}\`);
+    process.exit(1);
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (err) {
+    console.error(\`Error parsing JSON from \${filePath}: \${err.message}\`);
+    process.exit(1);
+  }
+  if (!Array.isArray(data)) {
+    console.error(\`Expected a JSON array in \${filePath}, got \${typeof data}\`);
+    process.exit(1);
+  }
+  return data;
+}
+
+const data1 = readJsonArray(file1Path);
+const data2 = readJsonArray(file2Path);
+
+const lookupValues = new Set(data2.map(item => item[field2]));
+const matches = data1.filter(item => lookupValues.has(item[field1]));
+
+if (matches.length === 0) {
+  console.log(\`No items in \${file1Path} have \${field1} matching \${field2} values from \${file2Path}.\`);
+  process.exit(0);
+}
+
+console.log(\`Found \${matches.length} item(s) in \${file1Path} where \${field1} matches \${field2} in \${file2Path}:\\n\`);
+for (const item of matches) {
+  console.log(\`  [\${field1}=\${JSON.stringify(item[field1])}]\`);
+  console.log(JSON.stringify(item, null, 2));
+  console.log();
+}
+`;
+var DATA_SCRIPTING_SKILL_FILES = {
+  "skills/data-scripting/SKILL.md": SKILL_MD,
+  "skills/data-scripting/schemas.md": SCHEMAS_MD,
+  "skills/data-scripting/helpers/top-items.js": TOP_ITEMS_JS,
+  "skills/data-scripting/helpers/cross-reference.js": CROSS_REFERENCE_JS
+};
+// ../utils/src/skills/profile-analysis.ts
+var SKILL_MD2 = `---
+name: profile-analysis
+description: Use this skill when analyzing V8 CPU profiles, hot functions, event listener tracking, and heap allocation data from Vitest test runs. Provides pre-built analysis scripts for common test performance patterns.
+---
+
+# Profile Analysis Scripts
+
+## Overview
+
+Pre-built scripts for analyzing Vitest performance data. Run these
+directly or use them as templates for custom analysis.
+
+## START HERE — Workspace overview
+
+Run this FIRST to get a prioritized summary of the workspace:
+
+execute_command: node skills/profile-analysis/helpers/analyze-workspace.js
+
+Reads summary.json, src/index.json, hot-functions/application.json,
+listener-tracking.json exceedances, and timing/slow-tests.json. Outputs:
+- Suite stats (test count, duration, GC)
+- Which source files have hot functions (from src/index.json)
+- Application hot functions with source snippets
+- Listener exceedances and imbalances
+- Slow tests
+- Full list of source and test files
+
+Use this output to decide which source files to read with read_file.
+
+## Additional scripts
+
+### Analyze hot functions (detailed)
+execute_command: node skills/profile-analysis/helpers/analyze-hotfunctions.js [--threshold 1]
+
+Reads hot-functions/application.json, groups by file, and outputs:
+- Per-file CPU time breakdown
+- Hot functions above threshold (default 1% selfPercent)
+- Caller chains for compound blocker detection
+
+### Analyze listener tracking (detailed)
+execute_command: node skills/profile-analysis/helpers/analyze-listeners.js
+
+Reads listener-tracking.json (emitterCounts + exceedances), outputs:
+- Per-event add/remove counts
+- Events with adds but zero removes (leak candidates)
+- MaxListeners exceedances with stack traces and listener counts
+- Suggested source files to investigate
+
+### Find closure and leak patterns
+execute_command: node skills/profile-analysis/helpers/find-leaks.js
+
+Searches all src/ files for common leak patterns:
+- Maps/Sets/Arrays with .set/.push/.add but no .delete/.clear
+- Closures stored in long-lived data structures
+- .on()/.addEventListener() without corresponding removal
+- Unbounded caches without TTL or maxSize
+
+## Key data files
+
+- src/index.json — maps source files to their hot functions (READ THIS FIRST)
+- hot-functions/application.json — application hot functions with source snippets
+- listener-tracking.json — emitterCounts and exceedances
+- metrics/current.json — comprehensive aggregate metrics (large)
+- profiles/<file>.json — per-test-file profile summaries
+
+## Writing custom scripts
+
+Read skills/data-scripting/schemas.md for JSON structures.
+All source files are under src/ and test files under tests/.
+`;
+var ANALYZE_HOTFUNCTIONS_JS = `'use strict';
+
+const fs = require('fs');
+
+const args = process.argv.slice(2);
+let threshold = 1;
+const thresholdIdx = args.indexOf('--threshold');
+if (thresholdIdx !== -1 && args[thresholdIdx + 1]) {
+  threshold = parseFloat(args[thresholdIdx + 1]);
+}
+
+let hotFunctions;
+try {
+  hotFunctions = JSON.parse(fs.readFileSync('hot-functions/application.json', 'utf8'));
+} catch (err) {
+  console.error('Could not read hot-functions/application.json:', err.message);
+  process.exit(1);
+}
+
+if (!Array.isArray(hotFunctions) || hotFunctions.length === 0) {
+  console.log('No hot functions found.');
+  process.exit(0);
+}
+
+let summary = null;
+try {
+  summary = JSON.parse(fs.readFileSync('summary.json', 'utf8'));
+} catch (_) {}
+
+const byFile = new Map();
+for (const fn of hotFunctions) {
+  const key = fn.workspacePath || '(unknown)';
+  if (!byFile.has(key)) byFile.set(key, []);
+  byFile.get(key).push(fn);
+}
+
+const fileTotals = [];
+for (const [filePath, fns] of byFile) {
+  const totalSelfTime = fns.reduce((sum, f) => sum + (f.selfTime || 0), 0);
+  fileTotals.push({ filePath, totalSelfTime, functions: fns });
+}
+fileTotals.sort((a, b) => b.totalSelfTime - a.totalSelfTime);
+
+console.log('=== Per-File CPU Breakdown ===\\n');
+for (const { filePath, totalSelfTime, functions: fns } of fileTotals) {
+  console.log(\`\${filePath}  (total selfTime: \${totalSelfTime.toFixed(2)}ms)\`);
+  const sorted = fns.slice().sort((a, b) => (b.selfTime || 0) - (a.selfTime || 0));
+  for (const f of sorted) {
+    console.log(\`  \${f.functionName || '(anonymous)'}  line \${f.lineNumber || '?'}  selfTime=\${(f.selfTime || 0).toFixed(2)}ms  selfPercent=\${(f.selfPercent || 0).toFixed(2)}%\`);
+  }
+  console.log();
+}
+
+const aboveThreshold = hotFunctions
+  .filter(f => (f.selfPercent || 0) >= threshold)
+  .sort((a, b) => (b.selfPercent || 0) - (a.selfPercent || 0));
+
+console.log(\`=== Hot Functions Above \${threshold}% Threshold ===\\n\`);
+if (aboveThreshold.length === 0) {
+  console.log(\`No functions above \${threshold}% selfPercent.\\n\`);
+} else {
+  for (const f of aboveThreshold) {
+    console.log(\`\${f.functionName || '(anonymous)'}  \${f.workspacePath || '?'}:\${f.lineNumber || '?'}\`);
+    console.log(\`  selfTime=\${(f.selfTime || 0).toFixed(2)}ms  selfPercent=\${(f.selfPercent || 0).toFixed(2)}%\`);
+  }
+  console.log();
+}
+
+const withCallers = hotFunctions.filter(f => f.callerChain && f.callerChain.length > 0);
+if (withCallers.length > 0) {
+  console.log('=== Caller Chains ===\\n');
+  for (const f of withCallers) {
+    console.log(\`\${f.functionName || '(anonymous)'}  \${f.workspacePath || '?'}:\${f.lineNumber || '?'}\`);
+    for (const caller of f.callerChain) {
+      console.log(\`  <- \${caller.functionName || '(anonymous)'}  \${caller.workspacePath || '?'}:\${caller.lineNumber || '?'}\`);
+    }
+    console.log();
+  }
+}
+
+console.log('=== Summary ===\\n');
+const totalAppSelfTime = hotFunctions.reduce((sum, f) => sum + (f.selfTime || 0), 0);
+console.log(\`Total application selfTime: \${totalAppSelfTime.toFixed(2)}ms\`);
+console.log(\`Total hot functions: \${hotFunctions.length}\`);
+console.log(\`Functions above threshold: \${aboveThreshold.length}\`);
+if (summary) {
+  if (summary.totalGcTime != null) console.log(\`GC time: \${summary.totalGcTime.toFixed(2)}ms\`);
+  if (summary.gcPercentage != null) console.log(\`GC percentage: \${summary.gcPercentage.toFixed(2)}%\`);
+  if (summary.totalDuration != null) console.log(\`Total profile duration: \${summary.totalDuration.toFixed(2)}ms\`);
+}
+`;
+var ANALYZE_LISTENERS_JS = `'use strict';
+
+const fs = require('fs');
+
+let data;
+try {
+  data = JSON.parse(fs.readFileSync('listener-tracking.json', 'utf8'));
+} catch (err) {
+  console.log('No listener tracking data available (listener-tracking.json not found or unreadable).');
+  process.exit(0);
+}
+
+var emitterCounts = data.emitterCounts || {};
+var eventTargetCounts = data.eventTargetCounts || {};
+var exceedances = data.exceedances || [];
+
+var totalAdds = 0, totalRemoves = 0;
+var entries = Object.entries(emitterCounts);
+for (var i = 0; i < entries.length; i++) {
+  totalAdds += entries[i][1].addCount || 0;
+  totalRemoves += entries[i][1].removeCount || 0;
+}
+
+console.log('=== Listener Tracking Summary ===\\n');
+console.log('Total adds: ' + totalAdds);
+console.log('Total removes: ' + totalRemoves);
+console.log('Net active (adds - removes): ' + (totalAdds - totalRemoves) + '\\n');
+
+console.log('=== Per-Event Breakdown ===\\n');
+var sorted = entries.slice().sort(function (a, b) {
+  return (b[1].addCount || 0) - (a[1].addCount || 0);
+});
+for (var i = 0; i < sorted.length; i++) {
+  var name = sorted[i][0];
+  var info = sorted[i][1];
+  var net = (info.addCount || 0) - (info.removeCount || 0);
+  console.log('  ' + name + '  adds=' + (info.addCount || 0) + '  removes=' + (info.removeCount || 0) + '  net=' + net);
+}
+console.log();
+
+var imbalances = entries.filter(function (e) {
+  return (e[1].addCount || 0) > 0 && (e[1].removeCount || 0) === 0;
+});
+console.log('=== Add/Remove Imbalances (adds > 0 with zero removes) ===\\n');
+if (imbalances.length === 0) {
+  console.log('No significant add/remove imbalances detected.\\n');
+} else {
+  for (var i = 0; i < imbalances.length; i++) {
+    var name = imbalances[i][0];
+    var info = imbalances[i][1];
+    console.log('  ' + name + '  adds=' + (info.addCount || 0) + '  removes=0  *** LEAK CANDIDATE ***');
+  }
+  console.log();
+}
+
+console.log('=== MaxListeners Exceedances ===\\n');
+if (exceedances.length === 0) {
+  console.log('No maxListeners exceedances.\\n');
+} else {
+  for (var i = 0; i < exceedances.length; i++) {
+    var e = exceedances[i];
+    console.log(e.eventType + ' on ' + (e.targetType || '(unknown)') + '  listenerCount=' + e.listenerCount + '  threshold=' + e.threshold);
+    if (e.stack) {
+      console.log('  Stack trace:');
+      var lines = e.stack.split('\\n').slice(0, 5);
+      for (var j = 0; j < lines.length; j++) {
+        console.log('    ' + lines[j].trim());
+      }
+    }
+    console.log();
+  }
+}
+
+var filePattern = /(?:src\\/[^\\s:)]+|[a-zA-Z0-9_\\-./]+\\.[jt]sx?)/g;
+var suggestedFiles = {};
+
+for (var i = 0; i < exceedances.length; i++) {
+  if (exceedances[i].stack) {
+    var matches = exceedances[i].stack.match(filePattern);
+    if (matches) {
+      for (var j = 0; j < matches.length; j++) suggestedFiles[matches[j]] = true;
+    }
+  }
+}
+
+var fileList = Object.keys(suggestedFiles);
+console.log('=== Suggested Files to Investigate ===\\n');
+if (fileList.length === 0) {
+  console.log('No file paths extracted from stack traces.');
+} else {
+  for (var i = 0; i < fileList.length; i++) {
+    console.log('  ' + fileList[i]);
+  }
+}
+`;
+var ANALYZE_WORKSPACE_JS = `'use strict';
+
+var fs = require('fs');
+
+function tryRead(path) {
+  try { return JSON.parse(fs.readFileSync(path, 'utf8')); }
+  catch (_) { return null; }
+}
+
+var summary = tryRead('summary.json');
+var srcIndex = tryRead('src/index.json');
+var hotApp = tryRead('hot-functions/application.json');
+var listeners = tryRead('listener-tracking.json');
+var slowTests = tryRead('timing/slow-tests.json');
+
+console.log('=== Workspace Overview ===\\n');
+
+if (summary) {
+  console.log('Suite: ' + summary.totalTests + ' tests, ' + summary.totalDuration + 'ms total');
+  console.log('Pass: ' + summary.passCount + '  Fail: ' + summary.failCount);
+  if (summary.totalGcTime != null) console.log('GC: ' + summary.totalGcTime.toFixed(1) + 'ms (' + (summary.gcPercentage || 0).toFixed(2) + '%)');
+  console.log();
+}
+
+console.log('=== Source Files with Hot Functions (src/index.json) ===\\n');
+if (srcIndex && typeof srcIndex === 'object') {
+  var files = Object.keys(srcIndex);
+  if (files.length === 0) {
+    console.log('No application source files have hot functions.\\n');
+  } else {
+    for (var i = 0; i < files.length; i++) {
+      var fns = srcIndex[files[i]];
+      if (Array.isArray(fns) && fns.length > 0) {
+        var names = fns.map(function (f) { return f.functionName + ' (' + (f.selfTime || 0).toFixed(1) + 'ms, ' + (f.selfPercent || 0).toFixed(1) + '%)'; });
+        console.log('  ' + files[i]);
+        for (var j = 0; j < names.length; j++) console.log('    -> ' + names[j]);
+      } else {
+        console.log('  ' + files[i] + '  (no hot functions)');
+      }
+    }
+    console.log();
+  }
+} else {
+  console.log('src/index.json not available.\\n');
+}
+
+console.log('=== Application Hot Functions ===\\n');
+if (Array.isArray(hotApp) && hotApp.length > 0) {
+  hotApp.sort(function (a, b) { return (b.selfTime || 0) - (a.selfTime || 0); });
+  for (var i = 0; i < hotApp.length; i++) {
+    var f = hotApp[i];
+    console.log('  ' + (f.functionName || '(anon)') + '  ' + (f.workspacePath || '?') + ':' + (f.lineNumber || '?'));
+    console.log('    selfTime=' + (f.selfTime || 0).toFixed(2) + 'ms  selfPercent=' + (f.selfPercent || 0).toFixed(2) + '%');
+    if (f.sourceSnippet) {
+      var snipLines = f.sourceSnippet.split('\\n').slice(0, 4);
+      for (var j = 0; j < snipLines.length; j++) console.log('    | ' + snipLines[j]);
+    }
+  }
+  console.log();
+} else {
+  console.log('No application hot functions found.\\n');
+}
+
+console.log('=== Listener Exceedances ===\\n');
+if (listeners && Array.isArray(listeners.exceedances) && listeners.exceedances.length > 0) {
+  for (var i = 0; i < listeners.exceedances.length; i++) {
+    var e = listeners.exceedances[i];
+    console.log('  ' + e.eventType + ' on ' + (e.targetType || '?') + '  listenerCount=' + e.listenerCount + '  threshold=' + e.threshold);
+    if (e.stack) {
+      var lines = e.stack.split('\\n').slice(0, 3);
+      for (var j = 0; j < lines.length; j++) console.log('    ' + lines[j].trim());
+    }
+  }
+  console.log();
+} else {
+  console.log('No maxListeners exceedances.\\n');
+}
+
+if (listeners && listeners.emitterCounts) {
+  var leaky = Object.entries(listeners.emitterCounts).filter(function (e) {
+    return (e[1].addCount || 0) > 0 && (e[1].removeCount || 0) === 0;
+  });
+  if (leaky.length > 0) {
+    console.log('=== Listener Imbalances (adds without removes) ===\\n');
+    for (var i = 0; i < leaky.length; i++) {
+      console.log('  ' + leaky[i][0] + '  adds=' + leaky[i][1].addCount + '  removes=0');
+    }
+    console.log();
+  }
+}
+
+console.log('=== Slow Tests ===\\n');
+if (Array.isArray(slowTests) && slowTests.length > 0) {
+  for (var i = 0; i < Math.min(5, slowTests.length); i++) {
+    var t = slowTests[i];
+    console.log('  ' + (t.name || t.file || '?') + '  ' + (t.duration || 0).toFixed(1) + 'ms');
+  }
+  console.log();
+} else {
+  console.log('No slow tests data.\\n');
+}
+
+console.log('=== All Source Files ===\\n');
+try {
+  var srcFiles = fs.readdirSync('src', { recursive: true });
+  for (var i = 0; i < srcFiles.length; i++) {
+    var full = 'src/' + srcFiles[i];
+    try {
+      if (fs.statSync(full).isFile() && /\\.[jt]sx?$/.test(full)) console.log('  ' + full);
+    } catch (_) {}
+  }
+} catch (_) {
+  console.log('  (could not list src/)');
+}
+try {
+  var testFiles = fs.readdirSync('tests', { recursive: true });
+  for (var i = 0; i < testFiles.length; i++) {
+    var full = 'tests/' + testFiles[i];
+    try {
+      if (fs.statSync(full).isFile() && /\\.[jt]sx?$/.test(full)) console.log('  ' + full);
+    } catch (_) {}
+  }
+} catch (_) {}
+console.log();
+`;
+var FIND_LEAKS_JS = `'use strict';
+
+const fs = require('fs');
+
+function normalizePath(p) {
+  return p.startsWith('/') ? p.slice(1) : p;
+}
+
+let hotFunctions;
+try {
+  hotFunctions = JSON.parse(fs.readFileSync('hot-functions/application.json', 'utf8'));
+} catch (err) {
+  console.error('Could not read hot-functions/application.json:', err.message);
+  process.exit(1);
+}
+
+const filePaths = [...new Set(hotFunctions.map(f => f.workspacePath).filter(Boolean))];
+
+if (filePaths.length === 0) {
+  console.log('No source file paths found in hot-functions data.');
+  process.exit(0);
+}
+
+const findings = [];
+
+for (const rawPath of filePaths) {
+  const filePath = normalizePath(rawPath);
+  let content;
+  try {
+    content = fs.readFileSync(filePath, 'utf8');
+  } catch (_) {
+    continue;
+  }
+
+  const lines = content.split('\\n');
+  const hasDelete = content.includes('.delete(') || content.includes('.clear(') || content.includes('.splice(');
+  const hasRemoveListener = content.includes('.off(') || content.includes('.removeEventListener(') || content.includes('.removeListener(');
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+
+    if (/\\.(set|push|add)\\(/.test(line) && !hasDelete) {
+      findings.push({ filePath, lineNum, pattern: 'unbounded-collection', line: line.trim() });
+    }
+
+    if ((/\\.on\\(/.test(line) || /\\.addEventListener\\(/.test(line)) && !hasRemoveListener) {
+      findings.push({ filePath, lineNum, pattern: 'listener-leak', line: line.trim() });
+    }
+
+    if (/\\.(set|push)\\(.*(?:=>|function\\s*\\()/.test(line)) {
+      findings.push({ filePath, lineNum, pattern: 'closure-capture', line: line.trim() });
+    }
+
+    if (/\\b(?:cache|Cache|CACHE|memo|Memo|store|Store)\\b/.test(line)
+        && /\\.(set|push|add)\\(/.test(line)
+        && !/(?:ttl|TTL|maxSize|maxAge|expire|limit)/i.test(content)) {
+      findings.push({ filePath, lineNum, pattern: 'unbounded-cache', line: line.trim() });
+    }
+  }
+}
+
+if (findings.length === 0) {
+  console.log('No potential leak patterns found in source files.');
+  process.exit(0);
+}
+
+console.log(\`Found \${findings.length} potential leak pattern(s):\\n\`);
+
+const grouped = new Map();
+for (const f of findings) {
+  if (!grouped.has(f.pattern)) grouped.set(f.pattern, []);
+  grouped.get(f.pattern).push(f);
+}
+
+for (const [pattern, items] of grouped) {
+  console.log(\`--- [\${pattern}] ---\\n\`);
+  for (const { filePath, lineNum, line } of items) {
+    console.log(\`\${filePath}:\${lineNum}: [\${pattern}] \${line}\`);
+  }
+  console.log();
+}
+`;
+var PROFILE_ANALYSIS_SKILL_FILES = {
+  "skills/profile-analysis/SKILL.md": SKILL_MD2,
+  "skills/profile-analysis/helpers/analyze-workspace.js": ANALYZE_WORKSPACE_JS,
+  "skills/profile-analysis/helpers/analyze-hotfunctions.js": ANALYZE_HOTFUNCTIONS_JS,
+  "skills/profile-analysis/helpers/analyze-listeners.js": ANALYZE_LISTENERS_JS,
+  "skills/profile-analysis/helpers/find-leaks.js": FIND_LEAKS_JS
+};
+// ../utils/src/profiling/profile-parser.ts
+var MAX_HOT_FUNCTIONS = 50;
+var MAX_CALL_TREES = 10;
+var CALL_TREE_PRUNE_THRESHOLD = 0.005;
+var MAX_CALLER_CHAIN_DEPTH = 10;
+function parseCpuProfile(profile, profilePath) {
+  if (!profile.samples || profile.samples.length === 0) {
+    return emptySummary(profilePath);
+  }
+  const totalDurationUs = profile.endTime - profile.startTime;
+  const totalDurationMs = totalDurationUs / 1000;
+  const statsMap = buildNodeStats(profile);
+  computeSelfTime(profile, statsMap);
+  computeTotalTime(profile, statsMap);
+  const hotFunctions = extractHotFunctions(statsMap, totalDurationUs);
+  const expensiveCallTrees = extractCallTrees(profile, statsMap, totalDurationUs);
+  const { gcSamples, gcTimeUs, idleTimeUs } = computeSpecialCategories(profile, statsMap);
+  const scriptBreakdown = buildScriptBreakdown(statsMap, totalDurationUs);
+  return {
+    profilePath,
+    duration: round(totalDurationMs),
+    sampleCount: profile.samples.length,
+    hotFunctions,
+    expensiveCallTrees,
+    gcSamples,
+    gcPercentage: totalDurationUs > 0 ? round(gcTimeUs / totalDurationUs * 100) : 0,
+    idlePercentage: totalDurationUs > 0 ? round(idleTimeUs / totalDurationUs * 100) : 0,
+    scriptBreakdown
+  };
+}
+function buildNodeStats(profile) {
+  const statsMap = new Map;
+  for (const node of profile.nodes) {
+    statsMap.set(node.id, {
+      node,
+      selfTime: 0,
+      totalTime: 0,
+      parentIds: new Set
+    });
+  }
+  for (const node of profile.nodes) {
+    if (node.children) {
+      for (const childId of node.children) {
+        const childStats = statsMap.get(childId);
+        if (childStats) {
+          childStats.parentIds.add(node.id);
+        }
+      }
+    }
+  }
+  return statsMap;
+}
+function computeSelfTime(profile, statsMap) {
+  const { samples, timeDeltas } = profile;
+  for (let i = 0;i < samples.length; i++) {
+    const nodeId = samples[i];
+    const delta = timeDeltas[i] ?? 0;
+    const stats = statsMap.get(nodeId);
+    if (stats) {
+      stats.selfTime += Math.max(0, delta);
+    }
+  }
+}
+function computeTotalTime(profile, statsMap) {
+  const childCount = new Map;
+  const queue = [];
+  for (const node of profile.nodes) {
+    const numChildren = node.children?.length ?? 0;
+    childCount.set(node.id, numChildren);
+    if (numChildren === 0) {
+      queue.push(node.id);
+    }
+  }
+  while (queue.length > 0) {
+    const nodeId = queue.shift();
+    const stats = statsMap.get(nodeId);
+    if (!stats)
+      continue;
+    stats.totalTime = stats.selfTime;
+    const children = stats.node.children ?? [];
+    for (const childId of children) {
+      const childStats = statsMap.get(childId);
+      if (childStats) {
+        stats.totalTime += childStats.totalTime;
+      }
+    }
+    for (const parentId of stats.parentIds) {
+      const remaining = (childCount.get(parentId) ?? 1) - 1;
+      childCount.set(parentId, remaining);
+      if (remaining <= 0) {
+        queue.push(parentId);
+      }
+    }
+  }
+}
+var META_FUNCTIONS = new Set(["(root)", "(idle)", "(program)"]);
+function buildCallerChain(nodeId, statsMap) {
+  const chain = [];
+  const visited = new Set;
+  let currentId = nodeId;
+  for (let depth = 0;depth < MAX_CALLER_CHAIN_DEPTH; depth++) {
+    const stats = statsMap.get(currentId);
+    if (!stats || stats.parentIds.size === 0)
+      break;
+    let bestParentId = null;
+    let bestTotalTime = -1;
+    for (const pid of stats.parentIds) {
+      if (visited.has(pid))
+        continue;
+      const parentStats2 = statsMap.get(pid);
+      if (parentStats2 && parentStats2.totalTime > bestTotalTime) {
+        bestTotalTime = parentStats2.totalTime;
+        bestParentId = pid;
+      }
+    }
+    if (bestParentId === null)
+      break;
+    visited.add(bestParentId);
+    const parentStats = statsMap.get(bestParentId);
+    const parentFn = parentStats.node.callFrame.functionName;
+    if (META_FUNCTIONS.has(parentFn))
+      break;
+    if (parentStats.node.callFrame.url) {
+      chain.push({
+        functionName: parentFn || "(anonymous)",
+        scriptUrl: parentStats.node.callFrame.url,
+        lineNumber: parentStats.node.callFrame.lineNumber
+      });
+    }
+    currentId = bestParentId;
+  }
+  return chain;
+}
+function extractHotFunctions(statsMap, totalDurationUs) {
+  const results = [];
+  for (const [nodeId, stats] of statsMap.entries()) {
+    if (stats.selfTime <= 0)
+      continue;
+    const fn = stats.node.callFrame.functionName;
+    if (META_FUNCTIONS.has(fn))
+      continue;
+    const callerChain = buildCallerChain(nodeId, statsMap);
+    results.push({
+      functionName: stats.node.callFrame.functionName || "(anonymous)",
+      scriptUrl: stats.node.callFrame.url,
+      lineNumber: stats.node.callFrame.lineNumber,
+      columnNumber: stats.node.callFrame.columnNumber,
+      selfTime: round(stats.selfTime / 1000),
+      totalTime: round(stats.totalTime / 1000),
+      hitCount: stats.node.hitCount,
+      selfPercent: totalDurationUs > 0 ? round(stats.selfTime / totalDurationUs * 100) : 0,
+      ...callerChain.length > 0 ? { callerChain } : {}
+    });
+  }
+  results.sort((a, b) => b.selfTime - a.selfTime);
+  return results.slice(0, MAX_HOT_FUNCTIONS);
+}
+function extractCallTrees(_profile, statsMap, totalDurationUs) {
+  const rootIds = [];
+  for (const stats of statsMap.values()) {
+    if (stats.parentIds.size === 0) {
+      rootIds.push(stats.node.id);
+    }
+  }
+  const trees = [];
+  for (const rootId of rootIds) {
+    const tree = buildCallTreeNode(rootId, statsMap, totalDurationUs);
+    if (tree && tree.totalTime > 0) {
+      trees.push(tree);
+    }
+  }
+  trees.sort((a, b) => b.totalTime - a.totalTime);
+  return trees.slice(0, MAX_CALL_TREES);
+}
+function buildCallTreeNode(nodeId, statsMap, totalDurationUs) {
+  const stats = statsMap.get(nodeId);
+  if (!stats)
+    return null;
+  const totalPercent = totalDurationUs > 0 ? stats.totalTime / totalDurationUs : 0;
+  if (totalPercent < CALL_TREE_PRUNE_THRESHOLD)
+    return null;
+  const children = [];
+  for (const childId of stats.node.children ?? []) {
+    const childTree = buildCallTreeNode(childId, statsMap, totalDurationUs);
+    if (childTree) {
+      children.push(childTree);
+    }
+  }
+  children.sort((a, b) => b.totalTime - a.totalTime);
+  return {
+    functionName: stats.node.callFrame.functionName || "(anonymous)",
+    scriptUrl: stats.node.callFrame.url,
+    lineNumber: stats.node.callFrame.lineNumber,
+    totalTime: round(stats.totalTime / 1000),
+    totalPercent: round(totalPercent * 100),
+    children
+  };
+}
+function computeSpecialCategories(_profile, statsMap) {
+  let gcSamples = 0;
+  let gcTimeUs = 0;
+  let idleTimeUs = 0;
+  for (const stats of statsMap.values()) {
+    const fn = stats.node.callFrame.functionName;
+    if (fn.includes("(garbage collector)") || fn === "(GC)") {
+      gcSamples += stats.node.hitCount;
+      gcTimeUs += stats.selfTime;
+    }
+    if (fn === "(idle)") {
+      idleTimeUs += stats.selfTime;
+    }
+  }
+  return { gcSamples, gcTimeUs, idleTimeUs };
+}
+function buildScriptBreakdown(statsMap, totalDurationUs) {
+  const scriptMap = new Map;
+  for (const stats of statsMap.values()) {
+    const url = stats.node.callFrame.url;
+    if (!url)
+      continue;
+    let entry = scriptMap.get(url);
+    if (!entry) {
+      entry = { selfTime: 0, functions: new Set };
+      scriptMap.set(url, entry);
+    }
+    entry.selfTime += stats.selfTime;
+    if (stats.selfTime > 0) {
+      entry.functions.add(`${stats.node.callFrame.functionName}:${stats.node.callFrame.lineNumber}`);
+    }
+  }
+  const results = [];
+  for (const [scriptUrl, data] of scriptMap) {
+    results.push({
+      scriptUrl,
+      selfTime: round(data.selfTime / 1000),
+      selfPercent: totalDurationUs > 0 ? round(data.selfTime / totalDurationUs * 100) : 0,
+      functionCount: data.functions.size
+    });
+  }
+  results.sort((a, b) => b.selfTime - a.selfTime);
+  return results;
+}
+function round(n) {
+  return Math.round(n * 100) / 100;
+}
+function emptySummary(profilePath) {
+  return {
+    profilePath,
+    duration: 0,
+    sampleCount: 0,
+    hotFunctions: [],
+    expensiveCallTrees: [],
+    gcSamples: 0,
+    gcPercentage: 0,
+    idlePercentage: 0,
+    scriptBreakdown: []
+  };
+}
+// ../utils/src/profiling/classify.ts
+import { resolve, relative } from "node:path";
+var TEST_FILE_PATTERNS = [/\.test\./, /\.spec\./, /\.bench\./, /__tests__\//, /__mocks__\//];
+var FRAMEWORK_PATTERNS = [
+  /\/vitest\//,
+  /\/tinybench\//,
+  /\/vite\//,
+  /\/@vitest\//,
+  /node:internal\//,
+  /node:v8/,
+  /node:worker_threads/,
+  /node:test/,
+  /bun:test/,
+  /bun:jsc/,
+  /bun:internal/,
+  /\.XdZDrNZV\./,
+  /\.CJqBMi0u\./
+];
+function classifyScript(scriptUrl, projectRoot, testFiles) {
+  if (!scriptUrl)
+    return "unknown";
+  let filePath = scriptUrl;
+  if (filePath.startsWith("file://")) {
+    try {
+      filePath = new URL(filePath).pathname;
+    } catch {}
+  }
+  if (filePath.startsWith("node:") || filePath.startsWith("v8:") || filePath.startsWith("bun:")) {
+    return "framework";
+  }
+  if (filePath.includes("/node_modules/") || filePath.includes("\\node_modules\\")) {
+    return "dependency";
+  }
+  const resolvedProject = resolve(projectRoot);
+  const resolvedFile = resolve(filePath);
+  const rel = relative(resolvedProject, resolvedFile);
+  if (!rel.startsWith("..") && !rel.startsWith("/")) {
+    if (testFiles) {
+      if (testFiles.has(resolvedFile)) {
+        return "test";
+      }
+    }
+    for (const pattern of TEST_FILE_PATTERNS) {
+      if (pattern.test(filePath)) {
+        return "test";
+      }
+    }
+    return "application";
+  }
+  for (const pattern of FRAMEWORK_PATTERNS) {
+    if (pattern.test(filePath)) {
+      return "framework";
+    }
+  }
+  return "unknown";
+}
+// ../utils/src/profiling/merge-hot-functions.ts
+function mergeHotFunctions(profiles) {
+  const merged = new Map;
+  let totalDuration = 0;
+  for (const profile of profiles) {
+    totalDuration += profile.summary.duration;
+    for (const fn of profile.summary.hotFunctions) {
+      const key = `${fn.scriptUrl}:${fn.functionName}:${fn.lineNumber}`;
+      const existing = merged.get(key);
+      if (existing) {
+        existing.selfTime += fn.selfTime;
+        existing.totalTime += fn.totalTime;
+        existing.hitCount += fn.hitCount;
+      } else {
+        merged.set(key, { ...fn });
+      }
+    }
+  }
+  if (totalDuration > 0) {
+    for (const fn of merged.values()) {
+      fn.selfPercent = round2(fn.selfTime / totalDuration * 100);
+    }
+  }
+  const results = Array.from(merged.values());
+  results.sort((a, b) => b.selfTime - a.selfTime);
+  return results.slice(0, 50);
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+// ../utils/src/profiling/metrics.ts
+function computeMetrics(testTiming, profiles, heapProfiles, projectRoot, listenerTracking) {
+  const allTestDurations = testTiming.flatMap((t) => t.tests.map((tc) => tc.duration)).sort((a, b) => a - b);
+  const totalDuration = testTiming.reduce((s, t) => s + t.duration, 0);
+  const totalTests = testTiming.reduce((s, t) => s + t.testCount, 0);
+  const passCount = testTiming.reduce((s, t) => s + t.passCount, 0);
+  const failCount = testTiming.reduce((s, t) => s + t.failCount, 0);
+  const totalSetupTime = testTiming.reduce((s, t) => s + t.setupTime, 0);
+  const averageTestDuration = totalTests > 0 ? totalDuration / totalTests : 0;
+  const medianTestDuration = percentile(allTestDurations, 50);
+  const p95TestDuration = percentile(allTestDurations, 95);
+  const slowestTest = allTestDurations.length > 0 ? testTiming.flatMap((t) => t.tests.map((tc) => ({ ...tc, file: t.file }))).reduce((a, b) => a.duration > b.duration ? a : b) : null;
+  const slowestFile = testTiming.length > 0 ? testTiming.reduce((a, b) => a.duration > b.duration ? a : b) : null;
+  const suite = {
+    totalDuration: round3(totalDuration),
+    totalTests,
+    passCount,
+    failCount,
+    totalSetupTime: round3(totalSetupTime),
+    averageTestDuration: round3(averageTestDuration),
+    medianTestDuration: round3(medianTestDuration),
+    p95TestDuration: round3(p95TestDuration),
+    slowestTestDuration: round3(slowestTest?.duration ?? 0),
+    slowestTestName: slowestTest?.name ?? "",
+    slowestFileDuration: round3(slowestFile?.duration ?? 0),
+    slowestFile: relativize(slowestFile?.file ?? "", projectRoot)
+  };
+  const cpu = computeCpuMetrics(profiles);
+  const files = {};
+  for (const timing of testTiming) {
+    const relPath = relativize(timing.file, projectRoot);
+    const profile = profiles.find((p) => p.testFile === timing.file);
+    files[relPath] = {
+      duration: round3(timing.duration),
+      testCount: timing.testCount,
+      setupTime: round3(timing.setupTime),
+      gcPercentage: round3(profile?.summary.gcPercentage ?? 0)
+    };
+  }
+  const tests = {};
+  for (const timing of testTiming) {
+    const relPath = relativize(timing.file, projectRoot);
+    for (const test of timing.tests) {
+      const key = `${relPath}::${test.name}`;
+      tests[key] = {
+        duration: round3(test.duration),
+        status: test.status
+      };
+    }
+  }
+  const merged = mergeHotFunctions(profiles);
+  const hotFunctions = merged.slice(0, 20).map((fn) => ({
+    key: `${fn.scriptUrl}:${fn.functionName}:${fn.lineNumber}`,
+    functionName: fn.functionName,
+    scriptUrl: relativize(fn.scriptUrl, projectRoot),
+    lineNumber: fn.lineNumber,
+    selfTime: round3(fn.selfTime),
+    selfPercent: round3(fn.selfPercent),
+    sourceCategory: fn.sourceCategory ?? "unknown"
+  }));
+  const heap = heapProfiles && heapProfiles.length > 0 ? {
+    totalAllocatedBytes: heapProfiles.reduce((s, hp) => s + hp.summary.totalAllocatedBytes, 0)
+  } : undefined;
+  return {
+    version: 1,
+    timestamp: new Date().toISOString(),
+    suite,
+    cpu,
+    files,
+    tests,
+    hotFunctions,
+    heap,
+    listenerTracking
+  };
+}
+function computeCpuMetrics(profiles) {
+  if (profiles.length === 0) {
+    return {
+      gcPercentage: 0,
+      gcTime: 0,
+      idlePercentage: 0,
+      idleTime: 0,
+      applicationTime: 0,
+      applicationPercent: 0,
+      dependencyTime: 0,
+      dependencyPercent: 0,
+      testFrameworkTime: 0,
+      testFrameworkPercent: 0
+    };
+  }
+  const totalProfileDuration = profiles.reduce((s, p) => s + p.summary.duration, 0);
+  const totalGcTime = profiles.reduce((s, p) => s + p.summary.duration * p.summary.gcPercentage / 100, 0);
+  const gcPercentage = totalProfileDuration > 0 ? totalGcTime / totalProfileDuration * 100 : 0;
+  const totalIdleTime = profiles.reduce((s, p) => s + p.summary.duration * p.summary.idlePercentage / 100, 0);
+  const idlePercentage = totalProfileDuration > 0 ? totalIdleTime / totalProfileDuration * 100 : 0;
+  let applicationTime = 0;
+  let dependencyTime = 0;
+  let testFrameworkTime = 0;
+  for (const profile of profiles) {
+    for (const script of profile.summary.scriptBreakdown) {
+      switch (script.sourceCategory) {
+        case "application":
+          applicationTime += script.selfTime;
+          break;
+        case "dependency":
+          dependencyTime += script.selfTime;
+          break;
+        case "test":
+        case "framework":
+          testFrameworkTime += script.selfTime;
+          break;
+      }
+    }
+  }
+  const applicationPercent = totalProfileDuration > 0 ? applicationTime / totalProfileDuration * 100 : 0;
+  const dependencyPercent = totalProfileDuration > 0 ? dependencyTime / totalProfileDuration * 100 : 0;
+  const testFrameworkPercent = totalProfileDuration > 0 ? testFrameworkTime / totalProfileDuration * 100 : 0;
+  return {
+    gcPercentage: round3(gcPercentage),
+    gcTime: round3(totalGcTime),
+    idlePercentage: round3(idlePercentage),
+    idleTime: round3(totalIdleTime),
+    applicationTime: round3(applicationTime),
+    applicationPercent: round3(applicationPercent),
+    dependencyTime: round3(dependencyTime),
+    dependencyPercent: round3(dependencyPercent),
+    testFrameworkTime: round3(testFrameworkTime),
+    testFrameworkPercent: round3(testFrameworkPercent)
+  };
+}
+function percentile(sortedValues, p) {
+  if (sortedValues.length === 0)
+    return 0;
+  const idx = Math.ceil(p / 100 * sortedValues.length) - 1;
+  return sortedValues[Math.max(0, idx)];
+}
+function round3(n) {
+  return Math.round(n * 100) / 100;
+}
+function relativize(filePath, projectRoot) {
+  if (!projectRoot || !filePath)
+    return filePath;
+  if (filePath.startsWith(projectRoot)) {
+    const rel = filePath.slice(projectRoot.length);
+    return rel.startsWith("/") ? rel.slice(1) : rel;
+  }
+  return filePath;
+}
+// ../utils/src/profiling/workspace.ts
+var SOURCE_SNIPPET_CONTEXT = 5;
+var SLOW_TEST_THRESHOLD = 100;
+async function createTestWorkspace(options) {
+  const {
+    testTiming,
+    profiles,
+    heapProfiles,
+    testSources,
+    sourcePaths,
+    metrics,
+    listenerTracking
+  } = options;
+  const files = {};
+  const totalTests = testTiming.reduce((s, t) => s + t.testCount, 0);
+  const totalDuration = testTiming.reduce((s, t) => s + t.duration, 0);
+  const passCount = testTiming.reduce((s, t) => s + t.passCount, 0);
+  const failCount = testTiming.reduce((s, t) => s + t.failCount, 0);
+  const slowest = testTiming.length > 0 ? testTiming.reduce((a, b) => a.duration > b.duration ? a : b) : null;
+  const totalGcTime = profiles.reduce((s, p) => s + p.summary.duration * p.summary.gcPercentage / 100, 0);
+  const gcPercentage = totalDuration > 0 ? round4(totalGcTime / totalDuration * 100) : 0;
+  files["/summary.json"] = JSON.stringify({
+    totalTests,
+    totalDuration: round4(totalDuration),
+    passCount,
+    failCount,
+    profileCount: profiles.length,
+    slowestFile: slowest?.file ?? null,
+    slowestFileDuration: slowest ? round4(slowest.duration) : 0,
+    totalGcTime: round4(totalGcTime),
+    gcPercentage
+  }, null, 2);
+  files["/timing/overview.json"] = JSON.stringify(testTiming, null, 2);
+  const slowTests = [];
+  for (const fileTiming of testTiming) {
+    for (const test of fileTiming.tests) {
+      if (test.duration > SLOW_TEST_THRESHOLD) {
+        slowTests.push({ file: fileTiming.file, name: test.name, duration: test.duration });
+      }
+    }
+  }
+  slowTests.sort((a, b) => b.duration - a.duration);
+  files["/timing/slow-tests.json"] = JSON.stringify(slowTests, null, 2);
+  files["/profiles/index.json"] = JSON.stringify(profiles.map((p) => ({ testFile: p.testFile, profilePath: p.profilePath })), null, 2);
+  for (const profile of profiles) {
+    const safeName = sanitizeFilename(profile.testFile);
+    const sanitized = {
+      ...profile.summary,
+      hotFunctions: profile.summary.hotFunctions.map((fn) => {
+        const { scriptUrl: _s, ...rest } = fn;
+        let relPath = relativizePath(fn.scriptUrl, options.projectRoot);
+        if (relPath.startsWith("src/"))
+          relPath = relPath.slice(4);
+        return { ...rest, workspacePath: `/src/${relPath}` };
+      }),
+      scriptBreakdown: profile.summary.scriptBreakdown.map((s) => {
+        const { scriptUrl: _s, ...rest } = s;
+        let relPath = relativizePath(s.scriptUrl, options.projectRoot);
+        if (relPath.startsWith("src/"))
+          relPath = relPath.slice(4);
+        return { ...rest, workspacePath: `/src/${relPath}` };
+      })
+    };
+    files[`/profiles/${safeName}.json`] = JSON.stringify(sanitized, null, 2);
+  }
+  if (heapProfiles && heapProfiles.length > 0) {
+    files["/heap-profiles/index.json"] = JSON.stringify(heapProfiles.map((p) => ({ testFile: p.testFile, profilePath: p.profilePath })), null, 2);
+    for (const hp of heapProfiles) {
+      const safeName = sanitizeFilename(hp.testFile);
+      files[`/heap-profiles/${safeName}.json`] = JSON.stringify(hp.summary, null, 2);
+    }
+  }
+  const mergedHotFunctions = mergeHotFunctions(profiles);
+  files["/hot-functions/global.json"] = JSON.stringify(mergedHotFunctions, null, 2);
+  const appHotFunctions = mergedHotFunctions.filter((fn) => fn.sourceCategory === "application");
+  files["/hot-functions/application.json"] = JSON.stringify(appHotFunctions, null, 2);
+  const depHotFunctions = mergedHotFunctions.filter((fn) => fn.sourceCategory === "dependency");
+  files["/hot-functions/dependencies.json"] = JSON.stringify(depHotFunctions, null, 2);
+  const appScripts = profiles.flatMap((p) => p.summary.scriptBreakdown.filter((s) => s.sourceCategory === "application"));
+  const appScriptMap = new Map;
+  for (const s of appScripts) {
+    const existing = appScriptMap.get(s.scriptUrl);
+    if (existing) {
+      existing.selfTime += s.selfTime;
+      existing.functionCount = Math.max(existing.functionCount, s.functionCount);
+    } else {
+      appScriptMap.set(s.scriptUrl, { selfTime: s.selfTime, functionCount: s.functionCount });
+    }
+  }
+  const totalDurationMs = testTiming.reduce((s, t) => s + t.duration, 0);
+  const appScriptSummary = Array.from(appScriptMap.entries()).map(([scriptUrl, data]) => {
+    let relPath = relativizePath(scriptUrl, options.projectRoot);
+    if (relPath.startsWith("src/"))
+      relPath = relPath.slice(4);
+    return {
+      workspacePath: `/src/${relPath}`,
+      selfTime: round4(data.selfTime),
+      selfPercent: totalDurationMs > 0 ? round4(data.selfTime / totalDurationMs * 100) : 0,
+      functionCount: data.functionCount
+    };
+  }).sort((a, b) => b.selfTime - a.selfTime);
+  files["/scripts/application.json"] = JSON.stringify(appScriptSummary, null, 2);
+  const depScripts = profiles.flatMap((p) => p.summary.scriptBreakdown.filter((s) => s.sourceCategory === "dependency"));
+  const depScriptMap = new Map;
+  for (const s of depScripts) {
+    const existing = depScriptMap.get(s.scriptUrl);
+    if (existing) {
+      existing.selfTime += s.selfTime;
+      existing.functionCount = Math.max(existing.functionCount, s.functionCount);
+    } else {
+      depScriptMap.set(s.scriptUrl, { selfTime: s.selfTime, functionCount: s.functionCount });
+    }
+  }
+  const depScriptSummary = Array.from(depScriptMap.entries()).map(([scriptUrl, data]) => {
+    const relPath = relativizePath(scriptUrl, options.projectRoot);
+    return {
+      workspacePath: relPath.startsWith("node_modules/") ? relPath : scriptUrl,
+      selfTime: round4(data.selfTime),
+      selfPercent: totalDurationMs > 0 ? round4(data.selfTime / totalDurationMs * 100) : 0,
+      functionCount: data.functionCount
+    };
+  }).sort((a, b) => b.selfTime - a.selfTime);
+  files["/scripts/dependencies.json"] = JSON.stringify(depScriptSummary, null, 2);
+  if (metrics) {
+    files["/metrics/current.json"] = JSON.stringify(metrics, null, 2);
+  }
+  if (listenerTracking) {
+    const sanitizedTracking = {
+      ...listenerTracking,
+      exceedances: listenerTracking.exceedances?.map((exc) => {
+        if (!exc.stack || !options.projectRoot)
+          return exc;
+        return { ...exc, stack: exc.stack.replaceAll(options.projectRoot + "/", "") };
+      })
+    };
+    files["/listener-tracking.json"] = JSON.stringify(sanitizedTracking, null, 2);
+  }
+  for (const [filePath, source] of testSources) {
+    let relPath = relativizePath(filePath, options.projectRoot);
+    if (relPath.startsWith("tests/"))
+      relPath = relPath.slice(6);
+    files[`/tests/${relPath}`] = source;
+  }
+  const scriptUrlToWorkspacePath = new Map;
+  if (sourcePaths) {
+    for (const [scriptUrl, source] of sourcePaths) {
+      let relPath = relativizePath(scriptUrl, options.projectRoot);
+      if (relPath.startsWith("src/"))
+        relPath = relPath.slice(4);
+      const wsPath = `/src/${relPath}`;
+      files[wsPath] = source;
+      scriptUrlToWorkspacePath.set(scriptUrl, wsPath);
+      scriptUrlToWorkspacePath.set(`file://${scriptUrl}`, wsPath);
+    }
+  }
+  if (sourcePaths && sourcePaths.size > 0) {
+    const sanitizeCallerChain = (chain) => {
+      if (!chain || chain.length === 0)
+        return;
+      return chain.map(({ scriptUrl, ...rest }) => {
+        let relPath = relativizePath(scriptUrl, options.projectRoot);
+        if (relPath.startsWith("src/"))
+          relPath = relPath.slice(4);
+        const wsPath = relPath.startsWith("node_modules/") || relPath.startsWith("node:") ? relPath : `/src/${relPath}`;
+        return { ...rest, workspacePath: wsPath };
+      });
+    };
+    const enrichHotFunction = (fn) => {
+      const source = sourcePaths.get(fn.scriptUrl) ?? sourcePaths.get(normalizeFileUrl(fn.scriptUrl));
+      const wsPath = scriptUrlToWorkspacePath.get(fn.scriptUrl);
+      const { scriptUrl: _stripped, callerChain, ...fnWithoutScriptUrl } = fn;
+      const sanitizedChain = sanitizeCallerChain(callerChain);
+      const base = {
+        ...fnWithoutScriptUrl,
+        workspacePath: wsPath,
+        ...sanitizedChain ? { callerChain: sanitizedChain } : {}
+      };
+      if (!source || fn.lineNumber < 0)
+        return base;
+      const sourceLines = source.split(`
+`);
+      const targetLine = fn.lineNumber;
+      const start = Math.max(0, targetLine - SOURCE_SNIPPET_CONTEXT);
+      const end = Math.min(sourceLines.length, targetLine + SOURCE_SNIPPET_CONTEXT + 1);
+      const snippet = sourceLines.slice(start, end).map((line, i) => {
+        const lineNum = start + i + 1;
+        const marker = lineNum === targetLine + 1 ? ">" : " ";
+        return `${marker} ${String(lineNum).padStart(4)} | ${line}`;
+      }).join(`
+`);
+      return { ...base, sourceSnippet: snippet };
+    };
+    const enrichedAll = mergedHotFunctions.map(enrichHotFunction);
+    files["/hot-functions/global.json"] = JSON.stringify(enrichedAll, null, 2);
+    files["/hot-functions/application.json"] = JSON.stringify(enrichedAll.filter((fn) => fn.sourceCategory === "application"), null, 2);
+    files["/hot-functions/dependencies.json"] = JSON.stringify(enrichedAll.filter((fn) => fn.sourceCategory === "dependency"), null, 2);
+  }
+  const fileIndex = {};
+  for (const fn of mergedHotFunctions) {
+    const wsPath = scriptUrlToWorkspacePath.get(fn.scriptUrl);
+    if (!wsPath)
+      continue;
+    if (!fileIndex[wsPath])
+      fileIndex[wsPath] = [];
+    fileIndex[wsPath]?.push({
+      functionName: fn.functionName,
+      lineNumber: fn.lineNumber,
+      selfTime: fn.selfTime,
+      selfPercent: fn.selfPercent
+    });
+  }
+  if (Object.keys(fileIndex).length > 0) {
+    files["/src/index.json"] = JSON.stringify(fileIndex, null, 2);
+  }
+  const sourceFilesList = [];
+  const testFilesList = [];
+  for (const key of Object.keys(files)) {
+    if (key.startsWith("/src/") && !key.endsWith("/index.json") && !key.endsWith(".json")) {
+      sourceFilesList.push(key);
+    } else if (key.startsWith("/tests/")) {
+      testFilesList.push(key);
+    }
+  }
+  Object.assign(files, DATA_SCRIPTING_SKILL_FILES);
+  Object.assign(files, PROFILE_ANALYSIS_SKILL_FILES);
+  const { backend, cleanup } = await createWorkspaceFromFiles(files);
+  return { backend, cleanup, sourceFiles: sourceFilesList, testFiles: testFilesList };
+}
+function normalizeFileUrl(url) {
+  if (url.startsWith("file://")) {
+    try {
+      return new URL(url).pathname;
+    } catch {
+      return url.slice(7);
+    }
+  }
+  return url;
+}
+function sanitizeFilename(filePath) {
+  return filePath.replace(/[/\\]/g, "_").replace(/[^a-zA-Z0-9._-]/g, "_").replace(/^_+/, "");
+}
+function round4(n) {
+  return Math.round(n * 100) / 100;
+}
+function relativizePath(filePath, projectRoot) {
+  let normalized = filePath;
+  if (normalized.startsWith("file://")) {
+    try {
+      normalized = new URL(normalized).pathname;
+    } catch {}
+  }
+  if (projectRoot && normalized.startsWith(projectRoot)) {
+    let rel = normalized.slice(projectRoot.length);
+    if (rel.startsWith("/"))
+      rel = rel.slice(1);
+    return rel || normalized.split("/").pop() || normalized;
+  }
+  const nmIdx = normalized.indexOf("node_modules/");
+  if (nmIdx >= 0) {
+    return normalized.slice(nmIdx);
+  }
+  return normalized.split("/").pop() || normalized;
+}
+// ../utils/src/profiling/agent.ts
+import { createDeepAgent } from "deepagents";
+
+// ../utils/src/profiling/prompts/test-shared.ts
+var SEVERITY_RULES = `## Severity classification
+
+Assign severity based on the nature and measured impact of the issue:
+
+- **critical** — Any of:
+  - Synchronous blocking of the event loop (CPU-bound loops, sync crypto, sync I/O)
+  - Functions that CALL blocking functions (compound blockers)
+  - Listener exceedances (count exceeding maxListeners threshold)
+  - GC overhead >10% of total profile duration
+  - A single function consuming >15% of APPLICATION code self-time
+- **warning** — Any of:
+  - Listener add/remove imbalance (addCount > 2× removeCount) without exceedance
+  - O(n²) or worse algorithms on collections
+  - Unnecessary serialization (JSON.parse/JSON.stringify) on hot paths
+  - Closure-based memory leaks or unbounded data structures
+  - A function consuming 5–15% of application self-time
+- **info** — Minor inefficiencies, small optimisation opportunities, per-call
+  object allocation (TextEncoder, RegExp, DateTimeFormat), or patterns that only
+  matter at scale
+
+IMPORTANT: Blocking/event-loop-blocking operations are ALWAYS critical, regardless
+of measured self-time percentage. Even a short blocking call prevents the event loop
+from processing other work and is a correctness issue, not just a performance issue.`;
+
+// ../utils/src/profiling/prompts/cpu-hotspot.ts
+var CPU_HOTSPOT_PROMPT = `You are a specialist in detecting CPU-blocking operations and excessive object instantiation in JavaScript/TypeScript code.
+
+You have access to a workspace with V8 CPU profiling data from a Vitest test run.
+
+## Your focus areas
+
+### 1. Blocking / Event-Loop-Blocking Operations (HIGHEST PRIORITY)
+
+Look for functions that block the event loop with synchronous CPU-intensive work:
+- Synchronous crypto operations (hashing, encryption) that should use async APIs
+- CPU-bound loops (e.g., manual hashing with many iterations, busy-waits)
+- Functions that CALL other blocking functions (compound blocking). Report the
+  CALLER as a separate finding.
+- Synchronous file I/O in hot paths (readFileSync, writeFileSync, etc.)
+- Heavy computation without yielding (e.g., large matrix operations, parsing)
+
+**How to detect:** Read hot-functions/application.json for functions with high selfTime.
+For each one with >= 1% selfPercent, read the source code and check for:
+- Loops with many iterations doing CPU work
+- Calls to other blocking functions (trace the call chain — read the callee's source!)
+- Missing async/await for operations that have async alternatives (e.g., crypto.pbkdf2 vs crypto.pbkdf2Sync)
+
+**IMPORTANT — Compound blockers are SEPARATE findings:**
+If function A calls function B and B is blocking, you MUST report TWO findings:
+1. Function B: the primary blocking operation
+2. Function A: a "compound blocker" that calls B, inheriting and compounding B's cost
+Do NOT just report B and skip A. The developer needs to know both call sites.
+
+### 2. Excessive Object Instantiation (SECONDARY)
+
+Look for functions creating stateless objects on every call that should be
+module-level singletons or hoisted out of loops:
+- \`new TextEncoder()\` / \`new TextDecoder()\` — stateless, should be module-level
+- \`new Intl.DateTimeFormat()\` / \`new Intl.NumberFormat()\` — locale-dependent but cacheable
+- \`new Map()\` / \`new Set()\` — if used as temporary lookup then discarded each call
+- \`new RegExp()\` — if the pattern is constant, compile once at module level
+- \`new Date()\` inside sort comparators — called O(n log n) times
+- Any constructor call inside a hot loop that produces a stateless, reusable object
+
+**How to detect:** Read source files for hot functions and look for object
+construction inside function bodies that could be hoisted to module scope.
+
+**IMPORTANT:** If a function has BOTH a blocking issue AND an instantiation issue,
+report them as TWO separate findings with different categories (blocking-io vs allocation).
+Do NOT skip the instantiation finding just because you already reported a blocking finding
+for the same function.
+
+## Your scope — categories YOU own
+
+You are one of four parallel subagents. Use ONLY these categories:
+- **blocking-io** — for event-loop-blocking operations (sync crypto, CPU loops, sync I/O)
+- **allocation** — for per-call object instantiation (new TextEncoder, new Intl.DateTimeFormat, new Map per call)
+
+Do NOT report findings with categories: algorithm, serialization, gc-pressure,
+listener-leak, event-handling, unnecessary-computation. Other subagents handle those.
+Do NOT report findings about test files (tests/*.ts) — only about src/ files.
+
+## Your workflow
+
+1. In your FIRST turn, do ALL of these in ONE batch:
+   a. Run the workspace overview script:
+      execute_command: node skills/profile-analysis/helpers/analyze-workspace.js
+   b. Run the detailed hot functions script:
+      execute_command: node skills/profile-analysis/helpers/analyze-hotfunctions.js
+   c. Call read_file for EVERY src/ file listed in "FILES IN THIS WORKSPACE" above.
+   Do NOT use ls or glob. Batch everything into ONE turn.
+2. From the script outputs, identify hot functions (>= 1% selfPercent) and match
+   them to the source code you read.
+3. For EACH hot function, analyze its source for blocking patterns or unnecessary instantiation.
+4. Check EVERY source file top-to-bottom, not just the hot ones.
+5. For compound blockers, trace the call chain using the callerChain data from the script output.
+
+${PARALLEL_TOOL_CALLS}
+${VERIFICATION_RULES}
+${SEVERITY_RULES}
+${FINDING_CATEGORIES}
+${OUTPUT_FORMAT}
+${STRUCTURED_OUTPUT_FIELDS}
+${WRITE_FINDINGS_REQUIREMENT}`;
+// ../utils/src/profiling/prompts/listener-leak.ts
+var LISTENER_LEAK_PROMPT = `You are a specialist in detecting event listener leaks and event handling imbalances in JavaScript/TypeScript code.
+
+You have access to a workspace with V8 CPU profiling data and event listener tracking from a Vitest test run.
+
+## Your SOLE focus: Event Listener Leaks
+
+You look for ONE thing: code that registers event listeners without proper cleanup,
+causing listener accumulation, memory growth, and MaxListenersExceededWarning.
+
+### Pattern A — Listener accumulation per call
+
+A function that adds a new listener EVERY TIME it is called, but never removes
+old ones. After N calls, there are N active listeners.
+
+\`\`\`typescript
+// BAD: adds a new listener on every call
+function getData() {
+  emitter.on('update', handler); // accumulates!
+}
+\`\`\`
+
+**Correct fix pattern — use a guard flag + named handler:**
+
+\`\`\`typescript
+// GOOD: register once, named handler, proper cleanup
+let registered = false;
+const onUpdate = () => { cache = null; };
+
+function getData() {
+  if (!registered) {
+    emitter.on('update', onUpdate);
+    registered = true;
+  }
+  // ... rest of function
+}
+
+function reset() {
+  if (registered) {
+    emitter.off('update', onUpdate);  // surgical removal
+    registered = false;
+  }
+}
+\`\`\`
+
+CRITICAL for afterCode: always use a NAMED handler (const onUpdate = ...) so
+it can be removed with .off(). NEVER use anonymous functions with .on().
+If the file has an existing cleanup/reset function, update it to call
+.off(event, handler) and reset the guard flag.
+
+### Pattern B — Missing unsubscribe mechanism
+
+A subscribe-style function that adds listeners but returns no way to remove them.
+
+\`\`\`typescript
+// BAD: no way to unsubscribe
+function subscribe(channel) {
+  emitter.on(channel, handler); // no return value, no cleanup
+}
+\`\`\`
+
+**Correct fix pattern — return an unsubscribe function:**
+
+\`\`\`typescript
+// GOOD: returns cleanup function
+function subscribe(channel, handler) {
+  emitter.on(channel, handler);
+  return () => { emitter.off(channel, handler); };
+}
+\`\`\`
+
+### Pattern C — MaxListeners exceeded (MUST report as a SEPARATE finding)
+
+When listener counts exceed the default maxListeners threshold (10), this
+triggers a MaxListenersExceededWarning at runtime. Check listener-tracking.json
+for the "exceedances" array — each entry shows an event type where the listener
+count exceeded the threshold.
+
+**This is a SEPARATE finding from Pattern A/B**, even if the same function causes
+both the accumulation AND the exceedance. You MUST report:
+1. Pattern A or B finding: the code that adds listeners without cleanup
+2. Pattern C finding: the maxListeners threshold being exceeded, with the
+   specific count, threshold, and event name from the exceedance data
+
+The Pattern C finding MUST have:
+- category: **"event-handling"** (do NOT use "listener-leak" — use a DIFFERENT
+  category from Pattern A/B so both findings survive deduplication)
+- severity: "critical" (exceedances are always critical)
+- title: focus on the event name and threshold, e.g. "maxListeners threshold
+  exceeded for task:changed event (11 listeners, threshold 10)"
+- description: MUST mention ALL of these terms: "maxListeners", "threshold",
+  "exceeded", the event name (e.g. "task:changed"), and the numeric count
+  (e.g. "11") and threshold (e.g. "10") from the tracking data
+
+## Your scope — categories YOU own
+
+You are one of four parallel subagents. Use ONLY these categories:
+- **listener-leak** — for Pattern A (accumulation) and Pattern B (missing unsubscribe)
+- **event-handling** — for Pattern C (maxListeners exceeded)
+
+Do NOT report findings with categories: blocking-io, allocation, algorithm,
+serialization, gc-pressure, unnecessary-computation. Other subagents handle those.
+Do NOT report findings about test files (tests/*.ts) — only about src/ files.
+
+## Your workflow (follow this EXACTLY)
+
+1. In your FIRST turn, do ALL of these in ONE batch:
+   a. Run the workspace overview script:
+      execute_command: node skills/profile-analysis/helpers/analyze-workspace.js
+   b. Run the detailed listener analysis script:
+      execute_command: node skills/profile-analysis/helpers/analyze-listeners.js
+   c. Call read_file for EVERY src/ file listed in "FILES IN THIS WORKSPACE" above.
+   Do NOT use ls or glob. Batch everything into ONE turn.
+2. From the script outputs, identify:
+   - exceedances (listenerCount > maxListeners threshold)
+   - add/remove imbalances (addCount with zero removeCount = leak candidates)
+3. In the source files you already read, find the .on() / .addEventListener() calls
+   and check if corresponding removal exists.
+4. For each issue found, provide before/after code.
+
+## Important: Report EACH pattern as a SEPARATE finding
+
+- If a function adds a listener without removal → one finding about accumulation
+- If a subscribe function has no unsubscribe mechanism → a separate finding
+- If maxListeners is exceeded → a SEPARATE finding (cross-reference with the causal
+  pattern above). This must be its own finding even if you already reported the
+  listener accumulation that caused it. The developer needs to know BOTH that
+  listeners accumulate AND that the threshold is exceeded.
+
+### Minimum expected findings
+
+For a typical codebase with listener leaks, expect at least:
+1. One finding per function that adds listeners without cleanup (Pattern A)
+2. One finding per subscribe function without unsubscribe (Pattern B)
+3. One finding per maxListeners exceedance from tracking data (Pattern C)
+
+${PARALLEL_TOOL_CALLS}
+${VERIFICATION_RULES}
+${SEVERITY_RULES}
+${FINDING_CATEGORIES}
+${OUTPUT_FORMAT}
+${STRUCTURED_OUTPUT_FIELDS}
+${WRITE_FINDINGS_REQUIREMENT}`;
+// ../utils/src/profiling/prompts/memory-closure.ts
+var MEMORY_CLOSURE_PROMPT = `You are a specialist in detecting memory leaks caused by closures, unbounded data structures, and missing cleanup/eviction in JavaScript/TypeScript code.
+
+You have access to a workspace with V8 CPU profiling data from a Vitest test run.
+
+## Your SOLE focus: Closure & Memory Leak Patterns
+
+You look for code where objects, closures, or data structures retain references
+longer than necessary, preventing garbage collection and causing continuous
+memory growth.
+
+### Pattern A — Closures capturing outer-scope data
+
+Closures stored in long-lived data structures that capture variables from
+the enclosing scope — even after the captured data is conceptually stale.
+
+\`\`\`typescript
+// BAD: closure captures 'value' and 'ctx' from enclosing scope
+set(key, value, ctx) {
+  this.cache.set(key, {
+    data: value,
+    refresher: () => {
+      // This closure captures 'value' and 'ctx' — they can
+      // never be garbage collected while the cache entry exists
+      return fetchFresh(key, ctx);
+    }
+  });
+}
+\`\`\`
+
+### Pattern B — Unbounded data structures (no eviction)
+
+Arrays, Maps, or Sets that only grow — elements are added but never removed,
+cleared, or evicted. Over time, memory grows monotonically.
+
+\`\`\`typescript
+// BAD: log grows without bound
+process(item) {
+  this.log.push({
+    item,
+    timestamp: Date.now(),
+    context: this.currentContext  // retains reference forever
+  });
+}
+\`\`\`
+
+### Pattern C — Closures capturing request/response or transient objects
+
+Code that stores closures capturing objects meant to be short-lived (e.g.
+request bodies, response objects, connection handles), preventing them from
+being freed after their lifecycle ends.
+
+\`\`\`typescript
+// BAD: closure captures the full transient object forever
+record(obj) {
+  this.entries.push({
+    id: obj.id,
+    timestamp: Date.now(),
+    getDetails: () => ({
+      payload: obj.payload,   // captures obj.payload forever
+      metadata: obj.metadata  // captures obj.metadata forever
+    })
+  });
+}
+\`\`\`
+
+## Your scope — categories YOU own
+
+You are one of four parallel subagents. Use ONLY this category:
+- **gc-pressure** — for closures capturing outer-scope data, unbounded data
+  structures (Maps, arrays) without eviction, and closures retaining transient objects
+
+Do NOT report findings with categories: blocking-io, allocation, algorithm,
+serialization, listener-leak, event-handling, unnecessary-computation. Other
+subagents handle those. Specifically:
+- Do NOT report event listener leaks (the listener-leak agent handles those)
+- Do NOT report blocking I/O or CPU loops (the cpu-hotspot agent handles those)
+- Do NOT report algorithmic inefficiencies (the code-pattern agent handles those)
+Do NOT report findings about test files (tests/*.ts) — only about src/ files.
+
+## Your workflow (follow this EXACTLY)
+
+1. In your FIRST turn, do ALL of these in ONE batch:
+   a. Run the workspace overview script:
+      execute_command: node skills/profile-analysis/helpers/analyze-workspace.js
+   b. Run the leak finder script:
+      execute_command: node skills/profile-analysis/helpers/find-leaks.js
+   c. Call read_file for EVERY src/ file listed in "FILES IN THIS WORKSPACE" above.
+   Do NOT use ls or glob. Batch everything into ONE turn.
+2. From the script outputs, identify potential leak patterns and allocation hotspots.
+3. For each source file you read, look for:
+   - Module-level or class-level Maps, Sets, Arrays used as stores
+   - Whether a corresponding removal mechanism exists
+   - Closures stored as values that capture outer-scope variables
+4. For each issue found, provide before/after code with proper cleanup.
+
+### CRITICAL: Report EVERY distinct issue, even in the same class
+
+A single class or module can have multiple closure/memory issues. Report
+each as a SEPARATE finding. For example, a CacheService class might have:
+1. A \`set()\` method with a closure that captures outer-scope data
+2. An unbounded access log in \`get()\` that grows without eviction
+3. A Map that stores entries without any TTL or maxSize
+These are THREE separate findings, not one.
+
+${PARALLEL_TOOL_CALLS}
+${VERIFICATION_RULES}
+${SEVERITY_RULES}
+${FINDING_CATEGORIES}
+${OUTPUT_FORMAT}
+${STRUCTURED_OUTPUT_FIELDS}
+${WRITE_FINDINGS_REQUIREMENT}`;
+// ../utils/src/profiling/prompts/code-pattern.ts
+var CODE_PATTERN_PROMPT = `You are a specialist in detecting algorithmic inefficiencies, unnecessary computation, and serialization overhead in JavaScript/TypeScript code.
+
+You have access to a workspace with V8 CPU profiling data from a Vitest test run.
+
+## Your focus areas
+
+### 1. Quadratic or Worse Algorithms (HIGHEST PRIORITY)
+
+Look for O(n²) or worse complexity patterns:
+
+**Pattern A — Nested iteration over same collection:**
+\`\`\`typescript
+// BAD: O(n²) — filter inside a loop
+for (const item of items) {
+  const dupes = items.filter(other => other.id === item.id);
+}
+\`\`\`
+
+**Pattern B — Pairwise comparison:**
+\`\`\`typescript
+// BAD: O(n²) or worse — nested loops over the same or related collections
+for (const a of items) {
+  for (const b of items) {
+    // comparison or accumulation logic
+  }
+}
+\`\`\`
+
+**Pattern C — O(n²) duplicate detection:**
+\`\`\`typescript
+// BAD: filter().length for each element = O(n²)
+items.forEach(item => {
+  if (items.filter(x => x === item).length > 1) { /* duplicate */ }
+});
+// FIX: Use a Set or Map for O(n)
+\`\`\`
+
+### 2. Unnecessary Serialization (SECONDARY)
+
+\`\`\`typescript
+// BAD: deep clone via JSON roundtrip on every call
+return JSON.parse(JSON.stringify(data));
+// FIX: structuredClone(data) or spread operator for shallow copies
+\`\`\`
+
+### 3. Regex Recompilation
+
+\`\`\`typescript
+// BAD: compiles regex on every call
+function validate(input) {
+  const pattern = new RegExp('^[a-z]+$');  // recompiled every call!
+  return pattern.test(input);
+}
+// FIX: const PATTERN = /^[a-z]+$/; at module level
+\`\`\`
+
+### 4. Expensive Sort Comparators
+
+\`\`\`typescript
+// BAD: creates objects inside sort comparator (called O(n log n) times)
+items.sort((a, b) => {
+  const dateA = new Date(a.createdAt);  // new object per comparison!
+  return dateA.getTime() - new Date(b.createdAt).getTime();
+});
+// FIX: pre-compute timestamps before sorting
+\`\`\`
+
+Also check for **functions called FROM sort comparators**. If \`items.sort((a, b) => computeWeight(a) - computeWeight(b))\` calls a function that does expensive work (Date parsing, string operations, object creation), that function runs O(n log n) times per sort — report it as a separate finding.
+
+### 5. Pairwise Correlation / Tag Comparison (O(n² × m²))
+
+Look for functions that compare every pair of items AND every pair of their sub-elements:
+\`\`\`typescript
+// BAD: O(n²×m²) — for each pair of tasks, compare all pairs of their tags
+for (const taskA of tasks) {
+  for (const taskB of tasks) {
+    for (const tagA of taskA.tags) {
+      for (const tagB of taskB.tags) { /* ... */ }
+    }
+  }
+}
+\`\`\`
+Functions named like \`computeCorrelations\`, \`computeTagCorrelations\`, \`findPairs\`, etc. are prime suspects. Also look for \`.sort()\` and \`.join()\` inside inner loops.
+
+## How to detect
+
+1. Read hot-functions/application.json to identify which functions are CPU-hot
+2. Read EVERY application source file — not just the hot ones
+3. Go through EVERY FUNCTION in every file and check for the patterns above
+4. Pay special attention to:
+   - Functions that operate on arrays or collections
+   - Any function containing nested loops or chained .filter/.map/.reduce calls
+   - Functions that call JSON.parse, JSON.stringify, or new RegExp inside a loop or on every invocation
+   - Sort comparators that create objects (new Date(), etc.) — the comparator runs O(n log n) times
+   - Functions called from sort comparators (they inherit O(n log n) invocations)
+   - Functions that do pairwise comparison of collection elements (O(n²) or O(n²×m²))
+   - Duplicate detection using .filter() instead of Set (O(n²) vs O(n))
+
+## Your scope — categories YOU own
+
+You are one of four parallel subagents. Use ONLY these categories:
+- **algorithm** — for O(n²) loops, brute-force, pairwise comparison, expensive sort comparators
+- **serialization** — for unnecessary JSON.parse/JSON.stringify roundtrips
+- **unnecessary-computation** — for regex recompilation with constant patterns
+
+Do NOT report findings with categories: blocking-io, allocation, gc-pressure,
+listener-leak, event-handling. Other subagents handle those. Specifically:
+- Do NOT report per-call object instantiation (new TextEncoder, etc.) — the cpu-hotspot agent handles those
+- Do NOT report event listener leaks — the listener-leak agent handles those
+- Do NOT report closure/memory leaks — the memory-closure agent handles those
+Do NOT report findings about test files (tests/*.ts) — only about src/ files.
+
+## Your workflow
+
+1. In your FIRST turn, do ALL of these in ONE batch:
+   a. Run the workspace overview script:
+      execute_command: node skills/profile-analysis/helpers/analyze-workspace.js
+   b. Call read_file for ALL of these in ONE batch:
+      - scripts/application.json
+      - EVERY src/ file listed in "FILES IN THIS WORKSPACE" above
+   Do NOT use ls or glob.
+2. From the script output, identify which functions are CPU-hot.
+3. For EVERY function in EVERY source file, check for the patterns above.
+4. Report each distinct pattern as a separate finding.
+
+${PARALLEL_TOOL_CALLS}
+${VERIFICATION_RULES}
+${SEVERITY_RULES}
+${FINDING_CATEGORIES}
+${OUTPUT_FORMAT}
+${STRUCTURED_OUTPUT_FIELDS}
+${WRITE_FINDINGS_REQUIREMENT}`;
+
+// ../utils/src/profiling/prompts/index.ts
+var TEST_ORCHESTRATOR_SYSTEM_PROMPT = `You are a performance analysis orchestrator.
+
+## Instructions
+
+1. Read the user message — it contains exactly 4 task descriptions.
+2. In your FIRST response, call the \`task\` tool exactly 4 times.
+   For each, set subagent_type and description EXACTLY as written in the
+   user message. Copy the FULL multi-line description verbatim, including
+   every file path listed.
+3. After all 4 subagents return, respond with: "All subagents complete."
+
+## CRITICAL rules
+
+- Do NOT consolidate, re-read, or re-serialize findings. Subagents write
+  their findings to /findings/*.json files directly.
+- Do NOT add your own findings — all analysis is done by subagents.
+- Do NOT call read_file, grep, ls, or glob.
+- Your response should be SHORT — just confirm completion.`;
+
+// ../utils/src/profiling/agent.ts
+function buildFileListSection(ctx) {
+  const { sourceFiles, testFiles, hasListenerTracking, hasHeapProfiles } = ctx;
+  const dataFiles = [
+    {
+      path: "/src/index.json",
+      description: "(source file -> hot function mapping — read this first)"
+    },
+    {
+      path: "/hot-functions/application.json",
+      description: "(hot functions with selfTime, selfPercent, sourceSnippet)"
+    },
+    { path: "/scripts/application.json", description: "(per-script time breakdown)" },
+    { path: "/profiles/index.json", description: "(manifest of CPU profiles)" }
+  ];
+  if (hasListenerTracking) {
+    dataFiles.push({
+      path: "/listener-tracking.json",
+      description: "(event listener add/remove counts and exceedances)"
+    });
+  }
+  if (hasHeapProfiles) {
+    dataFiles.push({ path: "/heap-profiles/index.json" });
+  }
+  dataFiles.push({ path: "/summary.json", description: "(overall test run stats)" }, { path: "/metrics/current.json" });
+  return buildFileListPromptSection({ dataFiles, sourceFiles, testFiles });
+}
+function buildUserMessage(ctx) {
+  const { metrics, sourceFiles = [], hasListenerTracking } = ctx;
+  const srcFiles = sourceFiles.map((f) => `  ${f}`).join(`
+`);
+  const dataFiles = [
+    "  /src/index.json",
+    "  /hot-functions/application.json",
+    "  /scripts/application.json",
+    hasListenerTracking ? "  /listener-tracking.json" : ""
+  ].filter(Boolean).join(`
+`);
+  const allFiles = `${dataFiles}
+${srcFiles}`;
+  return `Dispatch all 4 subagent tasks NOW in a single response.
+Use these EXACT descriptions (copy them verbatim):
+
+TASK 1 — subagent_type: "cpu-hotspot"
+description: "Find blocking/event-loop-blocking operations and excessive object instantiation.
+In your FIRST response, call read_file for ALL of these files (do NOT use ls or glob):
+${allFiles}
+Read EVERY file above in ONE batch. Then analyze for: synchronous CPU-bound loops, compound blockers (A calls blocking B — report BOTH), and per-call object creation (new TextEncoder, new RegExp, new Date in sort comparators). Report each distinct issue as a separate finding with beforeCode and afterCode."
+
+TASK 2 — subagent_type: "listener-leak"
+description: "Find event listener leaks, add/remove imbalances, and maxListeners exceedances.
+In your FIRST response, call read_file for ALL of these files (do NOT use ls or glob):
+${allFiles}
+Read EVERY file above in ONE batch. Then analyze for: listeners added without removal, missing unsubscribe mechanisms, maxListeners threshold exceedances. Report each pattern as a separate finding with beforeCode and afterCode."
+
+TASK 3 — subagent_type: "memory-closure"
+description: "Find closure-based memory leaks, unbounded data structures, and missing cleanup/eviction.
+In your FIRST response, call read_file for ALL of these files (do NOT use ls or glob):
+${allFiles}
+Read EVERY file above in ONE batch. Then analyze for: closures capturing outer-scope data, unbounded arrays/Maps/Sets with no eviction, closures capturing transient objects. A single class can have 3+ separate issues — report each one. Include beforeCode and afterCode for every finding."
+
+TASK 4 — subagent_type: "code-pattern"
+description: "Find O(n²) algorithms, unnecessary JSON serialization, regex recompilation, and expensive sort comparators.
+In your FIRST response, call read_file for ALL of these files (do NOT use ls or glob):
+${allFiles}
+Read EVERY file above in ONE batch. Then check EVERY function for: nested loops/filter-inside-loop, JSON.parse(JSON.stringify(...)) cloning, new RegExp with constant patterns, sort comparators that create objects. Report each pattern as a separate finding with beforeCode and afterCode."
+
+Test suite: ${metrics.suite.totalTests} tests, ${metrics.suite.totalDuration}ms
+CPU: app ${metrics.cpu.applicationPercent}%, deps ${metrics.cpu.dependencyPercent}%, GC ${metrics.cpu.gcPercentage}%`;
+}
+function buildSubagents(ctx) {
+  const fileSection = ctx ? buildFileListSection(ctx) : "";
+  const inject = (prompt) => insertFileListIntoPrompt(prompt, fileSection);
+  const skills = ["skills/data-scripting/", "skills/profile-analysis/"];
+  return [
+    {
+      name: "cpu-hotspot",
+      description: "Analyzes CPU profiling data to find blocking/event-loop-blocking operations and excessive object instantiation.",
+      systemPrompt: inject(CPU_HOTSPOT_PROMPT),
+      skills
+    },
+    {
+      name: "listener-leak",
+      description: "Detects event listener leaks, add/remove imbalances, and maxListeners exceedances.",
+      systemPrompt: inject(LISTENER_LEAK_PROMPT),
+      skills
+    },
+    {
+      name: "memory-closure",
+      description: "Finds closure-based memory leaks, unbounded data structures, and missing cleanup/eviction.",
+      systemPrompt: inject(MEMORY_CLOSURE_PROMPT),
+      skills
+    },
+    {
+      name: "code-pattern",
+      description: "Detects algorithmic inefficiencies (O(n²)), unnecessary serialization, regex recompilation, and expensive sort comparators.",
+      systemPrompt: inject(CODE_PATTERN_PROMPT),
+      skills
+    }
+  ];
+}
+async function analyzeTestPerformance(model, backend, spinner, context, { animateProgress = true } = {}) {
+  const subagents = buildSubagents(context);
+  const agent = createDeepAgent({
+    model,
+    systemPrompt: TEST_ORCHESTRATOR_SYSTEM_PROMPT,
+    backend,
+    subagents,
+    skills: ["skills/"]
+  });
+  const userMessage = context ? buildUserMessage(context) : [
+    "Analyze the performance of the APPLICATION CODE being tested in this workspace.",
+    "",
+    "Start with hot-functions/application.json, then explore source files to verify",
+    "root causes and provide code-level fixes."
+  ].join(`
+`);
+  await invokeWithTodoStreaming(agent, userMessage, spinner, { animateProgress });
+  const findings = await mergeFindings(backend);
+  if (findings.length === 0) {
+    throw new Error("Subagents did not write any findings to /findings/*.json");
+  }
+  const deduped = deduplicateFindings(findings);
+  return rankFindings(deduped);
+}
+// ../utils/src/output/terminal.ts
+import pc2 from "picocolors";
+import ora from "ora";
+function getTerminalWidth() {
+  const cols = process.stdout.columns || 80;
+  return Math.max(cols - 2, 40);
+}
+var SEVERITY_ICONS = {
+  critical: pc2.red("\uD83D\uDD34 CRITICAL"),
+  warning: pc2.yellow("\uD83D\uDFE1 WARNING"),
+  info: pc2.green("\uD83D\uDFE2 INFO")
+};
+var SEVERITY_LABELS = {
+  critical: pc2.red("CRITICAL"),
+  warning: pc2.yellow("WARNING"),
+  info: pc2.green("INFO")
+};
+var CATEGORY_LABELS = {
+  "memory-leak": "Memory Leak",
+  "large-retained-object": "Large Retained Object",
+  "detached-dom": "Detached DOM",
+  "render-blocking": "Render-Blocking",
+  "long-task": "Long Task",
+  "unused-code": "Unused Code",
+  "waterfall-bottleneck": "Waterfall Bottleneck",
+  "large-asset": "Large Asset",
+  "frame-blocking-function": "Frame-Blocking Function",
+  "listener-leak": "Listener Leak",
+  "gc-pressure": "GC Pressure",
+  "slow-test": "Slow Test",
+  "expensive-setup": "Expensive Setup",
+  "hot-function": "Hot Function",
+  "unnecessary-computation": "Unnecessary Computation",
+  "import-overhead": "Import Overhead",
+  "dependency-bottleneck": "Dependency Bottleneck",
+  algorithm: "Inefficient Algorithm",
+  serialization: "Serialization Overhead",
+  allocation: "Excessive Allocation",
+  "event-handling": "Event Handling",
+  "blocking-io": "Blocking I/O",
+  other: "Other"
+};
+function wrapText(text, maxWidth) {
+  const lines = [];
+  for (const rawLine of text.split(`
+`)) {
+    const words = rawLine.split(/\s+/).filter(Boolean);
+    if (words.length === 0) {
+      lines.push("");
+      continue;
+    }
+    let current = "";
+    for (const word of words) {
+      const next = current ? `${current} ${word}` : word;
+      if (next.length > maxWidth && current) {
+        lines.push(current);
+        current = word;
+      } else {
+        current = next;
+      }
+    }
+    if (current)
+      lines.push(current);
+  }
+  return lines;
+}
+function printFindingsVitest(findings) {
+  const tw = getTerminalWidth();
+  const indent = "  ";
+  const subIndent = indent + "  ";
+  const wrapWidth = tw - subIndent.length;
+  if (findings.length === 0) {
+    console.log(`${indent}${pc2.green("✔")} No significant performance issues found.`);
+    return;
+  }
+  for (const finding of findings) {
+    const severity = SEVERITY_LABELS[finding.severity];
+    const categoryLabel = CATEGORY_LABELS[finding.category] ?? finding.category;
+    console.log(`${indent}${severity} [${categoryLabel}]: ${pc2.bold(finding.title)}`);
+    if (finding.testFile)
+      console.log(pc2.dim(`${subIndent}Test file: ${finding.testFile}`));
+    if (finding.impactMs != null)
+      console.log(pc2.dim(`${subIndent}Impact: ${finding.impactMs.toFixed(0)}ms`));
+    if (finding.resourceUrl) {
+      for (const rl of wrapText(`Resource: ${finding.resourceUrl}`, wrapWidth)) {
+        console.log(pc2.dim(`${subIndent}${rl}`));
+      }
+    }
+    if (finding.hotFunction) {
+      const hf = finding.hotFunction;
+      const fnText = `Function: ${hf.name} at ${hf.scriptUrl}:${hf.lineNumber} ` + `(selfTime: ${hf.selfTime.toFixed(0)}ms, ${hf.selfPercent.toFixed(1)}%)`;
+      for (const fl of wrapText(fnText, wrapWidth)) {
+        console.log(pc2.dim(`${subIndent}${fl}`));
+      }
+    }
+    for (const line of wrapText(finding.description, wrapWidth)) {
+      console.log(`${subIndent}${line}`);
+    }
+    if (finding.suggestedFix) {
+      console.log(pc2.dim(`${subIndent}Suggested fix:`));
+      for (const rawLine of finding.suggestedFix.split(`
+`)) {
+        for (const wl of wrapText(rawLine, wrapWidth - 2)) {
+          console.log(`${subIndent}  ${wl}`);
+        }
+      }
+    }
+    console.log();
+  }
+  const counts = {
+    critical: findings.filter((f) => f.severity === "critical").length,
+    warning: findings.filter((f) => f.severity === "warning").length,
+    info: findings.filter((f) => f.severity === "info").length
+  };
+  console.log(`${indent}${pc2.dim("Summary:")} ${pc2.red(`${counts.critical} critical`)}, ${pc2.yellow(`${counts.warning} warning`)}, ${pc2.green(`${counts.info} info`)}`);
+}
+function printMetricsSummary(metrics) {
+  const indent = "  ";
+  const s = metrics.suite;
+  const c = metrics.cpu;
+  console.log(`${indent}${pc2.bold("Suite")}`);
+  console.log(`${indent}  Total: ${formatMs(s.totalDuration)} · ` + `${s.totalTests} tests (${s.passCount} pass, ${s.failCount} fail) · ` + `Setup: ${formatMs(s.totalSetupTime)}`);
+  console.log(`${indent}  Avg: ${formatMs(s.averageTestDuration)} · ` + `Median: ${formatMs(s.medianTestDuration)} · ` + `P95: ${formatMs(s.p95TestDuration)} · ` + `Slowest: ${formatMs(s.slowestTestDuration)}`);
+  if (s.slowestFile) {
+    console.log(`${indent}  Slowest file: ${s.slowestFile} (${formatMs(s.slowestFileDuration)})`);
+  }
+  if (c.gcTime > 0 || c.applicationTime > 0) {
+    console.log("");
+    console.log(`${indent}${pc2.bold("CPU Breakdown")}`);
+    console.log(`${indent}  Application: ${formatMs(c.applicationTime)} (${c.applicationPercent}%) · ` + `Dependencies: ${formatMs(c.dependencyTime)} (${c.dependencyPercent}%) · ` + `Test/Framework: ${formatMs(c.testFrameworkTime)} (${c.testFrameworkPercent}%)`);
+    console.log(`${indent}  GC: ${formatMs(c.gcTime)} (${c.gcPercentage}%) · ` + `Idle: ${formatMs(c.idleTime)} (${c.idlePercentage}%)`);
+  }
+  if (metrics.hotFunctions.length > 0) {
+    console.log("");
+    console.log(`${indent}${pc2.bold("Top Hot Functions")}`);
+    const top5 = metrics.hotFunctions.slice(0, 5);
+    for (const fn of top5) {
+      const category = fn.sourceCategory !== "unknown" ? pc2.dim(` [${fn.sourceCategory}]`) : "";
+      console.log(`${indent}  ${formatMs(fn.selfTime)} (${fn.selfPercent}%) ${fn.functionName}${category}`);
+      if (fn.scriptUrl) {
+        console.log(pc2.dim(`${indent}    ${fn.scriptUrl}:${fn.lineNumber}`));
+      }
+    }
+  }
+  if (metrics.heap) {
+    console.log("");
+    console.log(`${indent}${pc2.bold("Heap")}: ${formatBytes(metrics.heap.totalAllocatedBytes)} allocated`);
+  }
+  if (metrics.listenerTracking) {
+    const lt = metrics.listenerTracking;
+    console.log("");
+    console.log(`${indent}${pc2.bold("Event Listener Tracking")}`);
+    if (lt.exceedances.length > 0) {
+      for (const exc of lt.exceedances) {
+        console.log(`${indent}  ${pc2.red("⚠")} ${pc2.red(`${exc.targetType}.${exc.eventType}`)}: ` + `${exc.listenerCount} listeners (max: ${exc.threshold})`);
+        if (exc.stack) {
+          for (const line of exc.stack.split(`
+`).slice(0, 2)) {
+            console.log(pc2.dim(`${indent}    ${line}`));
+          }
+        }
+      }
+    }
+    const allImbalances = getListenerImbalances(lt);
+    if (allImbalances.length > 0) {
+      for (const entry of allImbalances.slice(0, 5)) {
+        const leaked = entry.addCount - entry.removeCount;
+        console.log(`${indent}  ${pc2.yellow("⚠")} ${entry.api} "${entry.type}": ` + `${entry.addCount} adds, ${entry.removeCount} removes ` + pc2.yellow(`(${leaked} not cleaned up)`));
+      }
+    }
+  }
+  console.log("");
+}
+function formatMs(ms) {
+  if (ms < 1)
+    return `${(ms * 1000).toFixed(0)}µs`;
+  if (ms < 1000)
+    return `${ms.toFixed(0)}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+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`;
+}
+// ../utils/src/output/report.ts
+import { writeFileSync } from "node:fs";
+var SEVERITY_EMOJI = {
+  critical: "\uD83D\uDD34",
+  warning: "\uD83D\uDFE1",
+  info: "ℹ️"
+};
+var CATEGORY_LABELS2 = {
+  "memory-leak": "Memory Leak",
+  "large-retained-object": "Large Retained Object",
+  "detached-dom": "Detached DOM",
+  "render-blocking": "Render-Blocking",
+  "long-task": "Long Task",
+  "unused-code": "Unused Code",
+  "waterfall-bottleneck": "Waterfall Bottleneck",
+  "large-asset": "Large Asset",
+  "frame-blocking-function": "Frame-Blocking Function",
+  "listener-leak": "Listener Leak",
+  "gc-pressure": "GC Pressure",
+  "slow-test": "Slow Test",
+  "expensive-setup": "Expensive Setup",
+  "hot-function": "Hot Function",
+  "unnecessary-computation": "Unnecessary Computation",
+  "import-overhead": "Import Overhead",
+  "dependency-bottleneck": "Dependency Bottleneck",
+  algorithm: "Inefficient Algorithm",
+  serialization: "Serialization Overhead",
+  allocation: "Excessive Allocation",
+  "event-handling": "Event Handling",
+  "blocking-io": "Blocking I/O",
+  other: "Other"
+};
+function writeTestReport(outputPath, options) {
+  const md = generateTestMarkdown(options);
+  writeFileSync(outputPath, md, "utf-8");
+  return outputPath;
+}
+function generateTestMarkdown(options) {
+  const { version, findings, testTiming, profiles, metrics } = options;
+  const now = new Date;
+  const sections = [];
+  sections.push(`# Vitest Performance Report`);
+  sections.push("");
+  sections.push(`> Analyzed ${now.toISOString().replace("T", " ").slice(0, 16)} UTC by zeitzeuge v${version}`);
+  sections.push("");
+  const totalTests = testTiming.reduce((s, t) => s + t.testCount, 0);
+  const totalFiles = testTiming.length;
+  const totalDuration = testTiming.reduce((s, t) => s + t.duration, 0);
+  const slowest = testTiming.length > 0 ? testTiming.reduce((a, b) => a.duration > b.duration ? a : b) : null;
+  const totalGcTime = profiles.reduce((s, p) => s + p.summary.duration * p.summary.gcPercentage / 100, 0);
+  const gcPercentage = totalDuration > 0 ? (totalGcTime / totalDuration * 100).toFixed(2) : "0";
+  sections.push(`**Test run** ${totalTests} tests across ${totalFiles} files · ` + `**Total duration** ${(totalDuration / 1000).toFixed(2)}s · ` + `**Slowest file** ${slowest ? `${slowest.file} (${(slowest.duration / 1000).toFixed(2)}s)` : "—"} · ` + `**GC overhead** ${gcPercentage}% (${totalGcTime.toFixed(0)}ms)`);
+  sections.push("");
+  if (metrics) {
+    sections.push(`## Performance Metrics`);
+    sections.push("");
+    sections.push(`| Metric | Value |`);
+    sections.push(`|--------|-------|`);
+    sections.push(`| Total Duration | ${fmtMs(metrics.suite.totalDuration)} |`);
+    sections.push(`| Tests | ${metrics.suite.totalTests} (${metrics.suite.passCount} pass, ${metrics.suite.failCount} fail) |`);
+    sections.push(`| Setup Time | ${fmtMs(metrics.suite.totalSetupTime)} |`);
+    sections.push(`| Avg Test Duration | ${fmtMs(metrics.suite.averageTestDuration)} |`);
+    sections.push(`| Median Test Duration | ${fmtMs(metrics.suite.medianTestDuration)} |`);
+    sections.push(`| P95 Test Duration | ${fmtMs(metrics.suite.p95TestDuration)} |`);
+    sections.push(`| Slowest Test | ${fmtMs(metrics.suite.slowestTestDuration)} (\`${metrics.suite.slowestTestName}\`) |`);
+    sections.push("");
+    if (metrics.cpu.applicationTime > 0 || metrics.cpu.gcTime > 0) {
+      sections.push(`### CPU Time Breakdown`);
+      sections.push("");
+      sections.push(`| Category | Time | % |`);
+      sections.push(`|----------|------|---|`);
+      sections.push(`| Application Code | ${fmtMs(metrics.cpu.applicationTime)} | ${metrics.cpu.applicationPercent}% |`);
+      sections.push(`| Dependencies | ${fmtMs(metrics.cpu.dependencyTime)} | ${metrics.cpu.dependencyPercent}% |`);
+      sections.push(`| Test/Framework | ${fmtMs(metrics.cpu.testFrameworkTime)} | ${metrics.cpu.testFrameworkPercent}% |`);
+      sections.push(`| GC | ${fmtMs(metrics.cpu.gcTime)} | ${metrics.cpu.gcPercentage}% |`);
+      sections.push(`| Idle | ${fmtMs(metrics.cpu.idleTime)} | ${metrics.cpu.idlePercentage}% |`);
+      sections.push("");
+    }
+    if (metrics.hotFunctions.length > 0) {
+      sections.push(`### Top Hot Functions`);
+      sections.push("");
+      sections.push(`| Function | Self Time | % | Category |`);
+      sections.push(`|----------|-----------|---|----------|`);
+      for (const fn of metrics.hotFunctions.slice(0, 10)) {
+        sections.push(`| \`${fn.functionName}\` | ${fmtMs(fn.selfTime)} | ${fn.selfPercent}% | ${fn.sourceCategory} |`);
+      }
+      sections.push("");
+    }
+    if (metrics.listenerTracking) {
+      const lt = metrics.listenerTracking;
+      const hasExceedances = lt.exceedances.length > 0;
+      const allImbalances = getListenerImbalances(lt);
+      if (hasExceedances || allImbalances.length > 0) {
+        sections.push(`### Event Listener Tracking`);
+        sections.push("");
+        if (hasExceedances) {
+          sections.push(`**Listener exceedances detected** — one or more EventTarget/EventEmitter ` + `instances accumulated more listeners than their \`maxListeners\` threshold. ` + `This is a strong signal of a listener leak that can cause memory growth.`);
+          sections.push("");
+          sections.push(`| Target | Event | Listeners | Threshold |`);
+          sections.push(`|--------|-------|-----------|-----------|`);
+          for (const exc of lt.exceedances) {
+            sections.push(`| \`${exc.targetType}\` | \`${exc.eventType}\` | ${exc.listenerCount} | ${exc.threshold} |`);
+          }
+          sections.push("");
+        }
+        if (allImbalances.length > 0) {
+          sections.push(`**Listener imbalances:**`);
+          sections.push("");
+          sections.push(`| API | Event | Adds | Removes | Not Cleaned Up |`);
+          sections.push(`|-----|-------|------|---------|----------------|`);
+          for (const entry of allImbalances) {
+            const leaked = entry.addCount - entry.removeCount;
+            sections.push(`| ${entry.api} | \`${entry.type}\` | ${entry.addCount} | ${entry.removeCount} | ${leaked} |`);
+          }
+          sections.push("");
+        }
+      }
+    }
+  }
+  const counts = {
+    critical: findings.filter((f) => f.severity === "critical").length,
+    warning: findings.filter((f) => f.severity === "warning").length,
+    info: findings.filter((f) => f.severity === "info").length
+  };
+  if (findings.length === 0) {
+    sections.push(`## ✅ No issues found`);
+    sections.push("");
+    sections.push(`No significant performance problems were detected. ` + `Tests complete in ${(totalDuration / 1000).toFixed(2)}s — looking healthy.`);
+    sections.push("");
+  } else {
+    sections.push(`**${findings.length} issues found** — ` + `${counts.critical} critical, ${counts.warning} warning, ${counts.info} info`);
+    sections.push("");
+    for (const f of findings) {
+      const emoji = SEVERITY_EMOJI[f.severity];
+      const categoryLabel = CATEGORY_LABELS2[f.category] ?? f.category;
+      sections.push(`---`);
+      sections.push("");
+      sections.push(`## ${emoji} ${f.title}`);
+      sections.push("");
+      const context = [`**${categoryLabel}**`];
+      if (f.confidence)
+        context.push(`confidence: ${f.confidence}`);
+      if (f.impactMs != null)
+        context.push(`${f.impactMs.toFixed(0)}ms impact`);
+      if (f.estimatedSavingsMs != null)
+        context.push(`~${f.estimatedSavingsMs.toFixed(0)}ms savings`);
+      if (f.testFile)
+        context.push(`\`${f.testFile}\``);
+      if (f.hotFunction) {
+        context.push(`\`${f.hotFunction.name}\` (${f.hotFunction.selfTime.toFixed(0)}ms, ${f.hotFunction.selfPercent.toFixed(1)}%)`);
+      }
+      if (f.sourceFile)
+        context.push(`\`${f.sourceFile}${f.lineNumber != null ? `:${f.lineNumber}` : ""}\``);
+      if (f.resourceUrl)
+        context.push(`\`${f.resourceUrl}\``);
+      sections.push(context.join(" · "));
+      sections.push("");
+      if (f.affectedTests && f.affectedTests.length > 0) {
+        sections.push(`**Affected tests:** ${f.affectedTests.map((t) => `\`${t}\``).join(", ")}`);
+        sections.push("");
+      }
+      sections.push(f.description);
+      sections.push("");
+      if (f.beforeCode || f.afterCode) {
+        if (f.beforeCode) {
+          sections.push(`### Before`);
+          sections.push("");
+          sections.push("```ts");
+          sections.push(f.beforeCode);
+          sections.push("```");
+          sections.push("");
+        }
+        if (f.afterCode) {
+          sections.push(`### After`);
+          sections.push("");
+          sections.push("```ts");
+          sections.push(f.afterCode);
+          sections.push("```");
+          sections.push("");
+        }
+      }
+      if (f.suggestedFix) {
+        sections.push(`### How to fix`);
+        sections.push("");
+        const alreadyFenced = f.suggestedFix.includes("```");
+        const looksLikeCode = !alreadyFenced && (f.suggestedFix.includes("{") || f.suggestedFix.includes(";") || f.suggestedFix.includes("=>") || f.suggestedFix.includes("import ") || f.suggestedFix.includes("function "));
+        if (looksLikeCode) {
+          sections.push("```ts");
+          sections.push(f.suggestedFix);
+          sections.push("```");
+        } else {
+          sections.push(f.suggestedFix);
+        }
+        sections.push("");
+      }
+    }
+  }
+  sections.push(`---`);
+  sections.push("");
+  sections.push(`*Generated by zeitzeuge v${version}*`);
+  sections.push("");
+  return sections.join(`
+`);
+}
+function fmtMs(ms) {
+  if (ms < 1)
+    return `${(ms * 1000).toFixed(0)}µs`;
+  if (ms < 1000)
+    return `${ms.toFixed(0)}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+// src/reporter.ts
+async function* zeitZeugeReporter(source) {
+  const profileDir = process.env.ZEITZEUGE_PROFILE_DIR || ".zeitzeuge-profiles";
+  const output = process.env.ZEITZEUGE_OUTPUT || "zeitzeuge-report.md";
+  const projectRoot = process.env.ZEITZEUGE_PROJECT_ROOT || process.cwd();
+  const verbose = process.env.ZEITZEUGE_VERBOSE === "true";
+  const analyzeOnFinish = process.env.ZEITZEUGE_ANALYZE !== "false";
+  const fileTimings = new Map;
+  for await (const event of source) {
+    switch (event.type) {
+      case "test:pass":
+      case "test:fail": {
+        const file = event.data.file ?? "";
+        const name = event.data.name ?? "";
+        const duration = event.data.details?.duration_ms ?? 0;
+        const nesting = event.data.nesting ?? 0;
+        if (nesting === 0 && file) {
+          let acc = fileTimings.get(file);
+          if (!acc) {
+            acc = { file, tests: [], totalDuration: 0 };
+            fileTimings.set(file, acc);
+          }
+          if (event.data.details?.type === "suite") {
+            acc.totalDuration = duration;
+          } else {
+            acc.tests.push({
+              name,
+              duration,
+              status: event.type === "test:pass" ? "pass" : "fail"
+            });
+          }
+        } else if (nesting > 0 && file) {
+          let acc = fileTimings.get(file);
+          if (!acc) {
+            acc = { file, tests: [], totalDuration: 0 };
+            fileTimings.set(file, acc);
+          }
+          acc.tests.push({
+            name,
+            duration,
+            status: event.type === "test:pass" ? "pass" : "fail"
+          });
+        }
+        const icon = event.type === "test:pass" ? "✓" : "✗";
+        yield `${icon} ${name} (${duration.toFixed(1)}ms)
+`;
+        break;
+      }
+      case "test:diagnostic": {
+        if (verbose) {
+          yield `# ${event.data.message}
+`;
+        }
+        break;
+      }
+      case "test:summary": {
+        const counts = event.data.counts;
+        yield `
+# Summary: ${counts?.passed ?? 0} passed, ${counts?.failed ?? 0} failed
+`;
+        if (!analyzeOnFinish)
+          break;
+        const testTiming = buildTestTiming(fileTimings);
+        if (testTiming.length === 0) {
+          yield `# zeitzeuge: No test timing data collected
+`;
+          break;
+        }
+        try {
+          const analysisOutput = await runAnalysis({
+            testTiming,
+            profileDir: resolve2(profileDir),
+            output: resolve2(output),
+            projectRoot: resolve2(projectRoot),
+            verbose
+          });
+          yield analysisOutput;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          yield `# zeitzeuge: Analysis failed — ${msg}
+`;
+        } finally {
+          try {
+            if (existsSync(resolve2(profileDir))) {
+              rmSync(resolve2(profileDir), { recursive: true, force: true });
+            }
+          } catch {}
+        }
+        break;
+      }
+    }
+  }
+}
+function buildTestTiming(fileTimings) {
+  const results = [];
+  for (const acc of fileTimings.values()) {
+    let passCount = 0;
+    let failCount = 0;
+    for (const t of acc.tests) {
+      if (t.status === "pass")
+        passCount++;
+      else if (t.status === "fail")
+        failCount++;
+    }
+    const duration = acc.totalDuration || acc.tests.reduce((s, t) => s + t.duration, 0);
+    results.push({
+      file: acc.file,
+      duration,
+      testCount: acc.tests.length,
+      passCount,
+      failCount,
+      setupTime: 0,
+      tests: acc.tests
+    });
+  }
+  return results;
+}
+async function runAnalysis(opts) {
+  const { testTiming, profileDir, output, projectRoot, verbose } = opts;
+  const lines = [];
+  if (!existsSync(profileDir)) {
+    return `# zeitzeuge: No profile directory found. Run with --cpu-prof --cpu-prof-dir=.zeitzeuge-profiles
+`;
+  }
+  const allFiles = readdirSync(profileDir);
+  const profileFiles = allFiles.filter((f) => f.endsWith(".cpuprofile")).map((f) => {
+    const fullPath = join(profileDir, f);
+    try {
+      const stat = statSync(fullPath);
+      return { name: f, path: fullPath, lastModified: stat.mtimeMs, size: stat.size };
+    } catch {
+      return { name: f, path: fullPath, lastModified: 0, size: 0 };
+    }
+  });
+  if (profileFiles.length === 0) {
+    return `# zeitzeuge: No .cpuprofile files found. Ensure --cpu-prof is passed to test processes.
+`;
+  }
+  lines.push(`
+# zeitzeuge: ${profileFiles.length} CPU profile(s) collected
+`);
+  const byMtime = [...profileFiles].sort((a, b) => a.lastModified - b.lastModified);
+  const orderedTestFiles = testTiming.map((t) => t.file);
+  const PROFILE_ANALYSIS_CAP = 10;
+  const PROFILE_PARSE_BUDGET = Math.min(byMtime.length, PROFILE_ANALYSIS_CAP + 5);
+  const toParse = byMtime.length <= PROFILE_PARSE_BUDGET ? byMtime.map((pf, i) => ({ ...pf, testFile: orderedTestFiles[i] ?? `unknown-${i}` })) : [...byMtime].map((pf, i) => ({ ...pf, testFile: orderedTestFiles[i] ?? `unknown-${i}` })).sort((a, b) => b.size - a.size).slice(0, PROFILE_PARSE_BUDGET);
+  const profiles = [];
+  const testFileSet = new Set(testTiming.map((t) => resolve2(t.file)));
+  for (const pf of toParse) {
+    try {
+      const content = readFileSync(pf.path, "utf-8");
+      const rawProfile = JSON.parse(content);
+      const summary = parseCpuProfile(rawProfile, pf.path);
+      for (const fn of summary.hotFunctions) {
+        fn.sourceCategory = classifyScript(fn.scriptUrl, projectRoot, testFileSet);
+      }
+      for (const script of summary.scriptBreakdown) {
+        script.sourceCategory = classifyScript(script.scriptUrl, projectRoot, testFileSet);
+      }
+      profiles.push({ testFile: pf.testFile, profilePath: pf.path, summary });
+    } catch (err) {
+      if (verbose) {
+        lines.push(`# zeitzeuge: Failed to parse ${pf.name}: ${err instanceof Error ? err.message : err}
+`);
+      }
+    }
+  }
+  profiles.sort((a, b) => b.summary.duration - a.summary.duration);
+  const topProfiles = profiles.slice(0, PROFILE_ANALYSIS_CAP);
+  if (topProfiles.length === 0) {
+    return lines.join("") + `# zeitzeuge: No profiles could be parsed
+`;
+  }
+  const metrics = computeMetrics(testTiming, topProfiles, [], projectRoot);
+  printMetricsSummary(metrics);
+  const testSources = readTestSources(testTiming);
+  const sourcePaths = readHotFunctionSources(topProfiles, projectRoot);
+  const workspace = await createTestWorkspace({
+    testTiming,
+    profiles: topProfiles,
+    testSources,
+    sourcePaths,
+    projectRoot,
+    metrics
+  });
+  try {
+    const model = await initModel();
+    const spinner = ora2({ text: "zeitzeuge: Analyzing...", isEnabled: false }).start();
+    const findings = await analyzeTestPerformance(model, workspace.backend, spinner, {
+      metrics,
+      hasHeapProfiles: false,
+      hasListenerTracking: false,
+      sourceFiles: workspace.sourceFiles,
+      testFiles: workspace.testFiles
+    }, { animateProgress: false });
+    spinner.stop();
+    printFindingsVitest(findings);
+    const reportPath = writeTestReport(output, {
+      version: "0.1.0",
+      findings,
+      testTiming,
+      profiles: topProfiles,
+      metrics
+    });
+    lines.push(`
+# zeitzeuge: Report written to ${reportPath}
+`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("API key")) {
+      lines.push(`# zeitzeuge: No LLM API key found. Set OPENAI_API_KEY or ANTHROPIC_API_KEY.
+`);
+    } else {
+      lines.push(`# zeitzeuge: Analysis failed — ${msg}
+`);
+    }
+  } finally {
+    workspace.cleanup();
+  }
+  return lines.join("");
+}
+function readTestSources(testTiming) {
+  const sources = new Map;
+  for (const timing of testTiming) {
+    try {
+      const resolvedPath = resolve2(timing.file);
+      if (existsSync(resolvedPath)) {
+        sources.set(timing.file, readFileSync(resolvedPath, "utf-8"));
+      }
+    } catch {}
+  }
+  return sources;
+}
+function readHotFunctionSources(profiles, _projectRoot) {
+  const sources = new Map;
+  const seen = new Set;
+  for (const profile of profiles) {
+    for (const fn of profile.summary.hotFunctions) {
+      if (!fn.scriptUrl || seen.has(fn.scriptUrl))
+        continue;
+      const threshold = fn.sourceCategory === "application" ? 0.1 : 1;
+      if (fn.selfPercent < threshold)
+        continue;
+      seen.add(fn.scriptUrl);
+      try {
+        let filePath = fn.scriptUrl;
+        if (filePath.startsWith("file://")) {
+          filePath = new URL(filePath).pathname;
+        }
+        if (existsSync(filePath)) {
+          sources.set(fn.scriptUrl, readFileSync(filePath, "utf-8"));
+        }
+      } catch {}
+    }
+  }
+  return sources;
+}
+export {
+  zeitZeugeReporter,
+  parseCpuProfile,
+  mergeHotFunctions,
+  createTestWorkspace as createNodeTestWorkspace,
+  computeMetrics,
+  classifyScript,
+  analyzeTestPerformance,
+  TEST_ORCHESTRATOR_SYSTEM_PROMPT as NODE_TEST_SYSTEM_PROMPT
+};