agentv 4.16.0 → 4.17.0

package/dist/{chunk-TA2KF32T.js → chunk-MQCJCM3I.js}

@@ -44,7 +44,7 @@ import {
   validateTargetsFile,
   validateWorkspacePaths,
   writeArtifactsFromResults
-} from "./chunk-NENUAMR5.js";
+} from "./chunk-YA2D37ZO.js";
 import {
   DEFAULT_CATEGORY,
   DEFAULT_THRESHOLD,
@@ -2831,6 +2831,10 @@ function loadCombinedResults(filePath) {
   }
   return groups;
 }
+function computeNormalizedGain(baselineScore, candidateScore) {
+  if (baselineScore >= 1) return null;
+  return (candidateScore - baselineScore) / (1 - baselineScore);
+}
 function classifyOutcome(delta, threshold) {
   if (delta >= threshold) return "win";
   if (delta <= -threshold) return "loss";
@@ -2850,6 +2854,7 @@ function compareResults(results1, results2, threshold) {
         score1,
         score2,
         delta,
+        normalizedGain: computeNormalizedGain(score1, score2),
         outcome: classifyOutcome(delta, threshold)
       });
       matchedIds.add(testId);
@@ -2861,6 +2866,8 @@ function compareResults(results1, results2, threshold) {
   const losses = matched.filter((m) => m.outcome === "loss").length;
   const ties = matched.filter((m) => m.outcome === "tie").length;
   const meanDelta = matched.length > 0 ? matched.reduce((sum, m) => sum + m.delta, 0) / matched.length : 0;
+  const gainValues = matched.map((m) => m.normalizedGain).filter((g) => g !== null);
+  const meanNormalizedGain = gainValues.length > 0 ? Math.round(gainValues.reduce((sum, g) => sum + g, 0) / gainValues.length * 1e3) / 1e3 : null;
   return {
     matched,
     unmatched: { file1: unmatchedFile1, file2: unmatchedFile2 },
@@ -2870,7 +2877,8 @@ function compareResults(results1, results2, threshold) {
       wins,
       losses,
       ties,
-      meanDelta: Math.round(meanDelta * 1e3) / 1e3
+      meanDelta: Math.round(meanDelta * 1e3) / 1e3,
+      meanNormalizedGain
     }
   };
 }
@@ -2989,16 +2997,21 @@ function formatTable(comparison, file1, file2) {
     );
   }
   lines.push("");
-  const { wins, losses, ties, meanDelta } = comparison.summary;
+  const { wins, losses, ties, meanDelta, meanNormalizedGain } = comparison.summary;
   const winStr = wins > 0 ? `${c2.green}${wins} win${wins !== 1 ? "s" : ""}${c2.reset}` : `${wins} wins`;
   const lossStr = losses > 0 ? `${c2.red}${losses} loss${losses !== 1 ? "es" : ""}${c2.reset}` : `${losses} losses`;
   const tieStr = `${ties} tie${ties !== 1 ? "s" : ""}`;
   const deltaColor = meanDelta > 0 ? c2.green : meanDelta < 0 ? c2.red : c2.gray;
   const deltaSign = meanDelta >= 0 ? "+" : "";
   const status = meanDelta > 0 ? `${c2.green}improved${c2.reset}` : meanDelta < 0 ? `${c2.red}regressed${c2.reset}` : `${c2.gray}neutral${c2.reset}`;
-  lines.push(
-    `${c2.bold}Summary:${c2.reset} ${winStr}, ${lossStr}, ${tieStr} | Mean \u0394: ${deltaColor}${deltaSign}${meanDelta.toFixed(3)}${c2.reset} | Status: ${status}`
-  );
+  let summaryLine = `${c2.bold}Summary:${c2.reset} ${winStr}, ${lossStr}, ${tieStr} | Mean \u0394: ${deltaColor}${deltaSign}${meanDelta.toFixed(3)}${c2.reset}`;
+  if (meanNormalizedGain != null) {
+    const gColor = meanNormalizedGain > 0 ? c2.green : meanNormalizedGain < 0 ? c2.red : c2.gray;
+    const gSign = meanNormalizedGain >= 0 ? "+" : "";
+    summaryLine += ` | g: ${gColor}${gSign}${meanNormalizedGain.toFixed(3)}${c2.reset}`;
+  }
+  summaryLine += ` | Status: ${status}`;
+  lines.push(summaryLine);
   lines.push("");
   return lines.join("\n");
 }
@@ -3054,13 +3067,18 @@ function formatMatrix(matrixOutput, baselineTarget) {
       ...pairwise.map((pw) => `  ${pw.baseline} \u2192 ${pw.candidate}:`.length)
     );
     for (const p of pairwise) {
-      const { wins, losses, ties, meanDelta } = p.summary;
+      const { wins, losses, ties, meanDelta, meanNormalizedGain } = p.summary;
       const sign = meanDelta >= 0 ? "+" : "";
       const deltaColor = meanDelta > 0 ? c2.green : meanDelta < 0 ? c2.red : c2.gray;
       const label = `  ${p.baseline} \u2192 ${p.candidate}:`;
-      lines.push(
-        `${padRight2(label, maxLabelLen)}  ${wins} win${wins !== 1 ? "s" : ""}, ${losses} loss${losses !== 1 ? "es" : ""}, ${ties} tie${ties !== 1 ? "s" : ""}  (${c2.bold}\u0394${c2.reset} ${deltaColor}${sign}${meanDelta.toFixed(3)}${c2.reset})`
-      );
+      let pairLine = `${padRight2(label, maxLabelLen)}  ${wins} win${wins !== 1 ? "s" : ""}, ${losses} loss${losses !== 1 ? "es" : ""}, ${ties} tie${ties !== 1 ? "s" : ""}  (${c2.bold}\u0394${c2.reset} ${deltaColor}${sign}${meanDelta.toFixed(3)}${c2.reset}`;
+      if (meanNormalizedGain != null) {
+        const gColor = meanNormalizedGain > 0 ? c2.green : meanNormalizedGain < 0 ? c2.red : c2.gray;
+        const gSign = meanNormalizedGain >= 0 ? "+" : "";
+        pairLine += `, ${c2.bold}g${c2.reset} ${gColor}${gSign}${meanNormalizedGain.toFixed(3)}${c2.reset}`;
+      }
+      pairLine += ")";
+      lines.push(pairLine);
     }
   }
   lines.push("");
@@ -3929,7 +3947,7 @@ var evalRunCommand = command({
   },
   handler: async (args) => {
     if (args.evalPaths.length === 0 && process.stdin.isTTY) {
-      const { launchInteractiveWizard } = await import("./interactive-IWGFP7T2.js");
+      const { launchInteractiveWizard } = await import("./interactive-3GW5UCBK.js");
       await launchInteractiveWizard();
       return;
     }
@@ -6972,6 +6990,1739 @@ var resultsFailuresCommand = command({
   }
 });
 
+// src/commands/results/report.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
+import path13 from "node:path";
+
+// src/commands/results/report-template.ts
+var RESULTS_REPORT_TEMPLATE = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>AgentV Evaluation Report</title>
+  <style>
+    * { box-sizing: border-box; }
+    html, body { margin: 0; padding: 0; }
+    :root {
+      color-scheme: dark;
+      --canvas: #030712;
+      --surface: #111827;
+      --surface-muted: rgba(17, 24, 39, 0.5);
+      --surface-hover: rgba(17, 24, 39, 0.3);
+      --border: #1f2937;
+      --text: #d1d5db;
+      --text-muted: #9ca3af;
+      --text-subtle: #6b7280;
+      --heading: #ffffff;
+      --accent: #22d3ee;
+      --accent-weak: rgba(8, 145, 178, 0.2);
+      --pass: #34d399;
+      --warn: #facc15;
+      --fail: #f87171;
+      --track: #1f2937;
+      --pill-gradient: linear-gradient(90deg, #60a5fa 0%, #2563eb 100%);
+      --font: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+      --radius-md: 6px;
+      --radius-lg: 8px;
+    }
+
+    :root.light {
+      color-scheme: light;
+      --canvas: #f8fafc;
+      --surface: #ffffff;
+      --surface-muted: rgba(241, 245, 249, 0.8);
+      --surface-hover: rgba(241, 245, 249, 0.5);
+      --border: #e2e8f0;
+      --text: #1e293b;
+      --text-muted: #64748b;
+      --text-subtle: #94a3b8;
+      --heading: #0f172a;
+      --accent: #0891b2;
+      --accent-weak: rgba(8, 145, 178, 0.1);
+      --pass: #16a34a;
+      --warn: #ca8a04;
+      --fail: #dc2626;
+      --track: #e2e8f0;
+      --pill-gradient: linear-gradient(90deg, #3b82f6 0%, #2563eb 100%);
+    }
+
+    :root.light .chip {
+      border-color: rgba(8, 145, 178, 0.3);
+      background: rgba(8, 145, 178, 0.08);
+      color: #0891b2;
+    }
+
+    :root.light .assertion-badge {
+      border-color: rgba(8, 145, 178, 0.3);
+      background: rgba(8, 145, 178, 0.08);
+      color: #0891b2;
+    }
+
+    :root.light .pass-rate-label {
+      color: #ffffff;
+    }
+
+    :root.light .group-header {
+      background: rgba(241, 245, 249, 0.8);
+    }
+
+    :root.light .status-pill {
+      background: rgba(241, 245, 249, 0.8);
+    }
+
+    :root.light .assertion-item {
+      background: rgba(241, 245, 249, 0.5);
+      border-color: var(--border);
+    }
+
+    :root.light .detail-row td {
+      background: rgba(248, 250, 252, 0.8);
+    }
+
+    body {
+      background: var(--canvas);
+      color: var(--text);
+      font-family: var(--font);
+      font-size: 14px;
+      line-height: 1.5;
+    }
+
+    button, input, select {
+      font: inherit;
+    }
+
+    .tabular,
+    .num,
+    .pass-rate-label,
+    .metric-value,
+    .count-label,
+    .table-num {
+      font-variant-numeric: tabular-nums;
+    }
+
+    .shell {
+      min-height: 100vh;
+    }
+
+    .header {
+      border-bottom: 1px solid var(--border);
+      background: var(--surface);
+      padding: 16px 24px;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 16px;
+    }
+
+    .header-title-wrap {
+      display: flex;
+      flex-direction: column;
+      gap: 4px;
+    }
+
+    .eyebrow {
+      color: var(--text-muted);
+      font-size: 12px;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+    }
+
+    .header-title {
+      color: var(--heading);
+      font-size: 24px;
+      font-weight: 600;
+      margin: 0;
+    }
+
+    .header-subtitle {
+      color: var(--text-muted);
+      margin: 0;
+    }
+
+    .header-meta {
+      display: flex;
+      flex-wrap: wrap;
+      justify-content: flex-end;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .chip {
+      border: 1px solid rgba(8, 145, 178, 0.45);
+      background: rgba(8, 145, 178, 0.16);
+      color: #67e8f9;
+      border-radius: var(--radius-md);
+      padding: 4px 8px;
+      font-size: 12px;
+      font-weight: 500;
+    }
+
+    .tabs {
+      display: flex;
+      gap: 4px;
+      padding: 0 24px;
+      border-bottom: 1px solid var(--border);
+      background: var(--canvas);
+    }
+
+    .tab {
+      background: transparent;
+      border: none;
+      border-bottom: 2px solid transparent;
+      color: var(--text-muted);
+      cursor: pointer;
+      padding: 12px 8px 10px;
+      transition: color 120ms ease, border-color 120ms ease;
+    }
+
+    .tab:hover {
+      color: var(--text);
+    }
+
+    .tab.active {
+      color: var(--accent);
+      border-bottom-color: var(--accent);
+    }
+
+    .app {
+      padding: 24px;
+      display: flex;
+      flex-direction: column;
+      gap: 24px;
+    }
+
+    .empty-state {
+      border: 1px solid var(--border);
+      border-radius: var(--radius-lg);
+      background: var(--surface);
+      padding: 32px;
+      text-align: center;
+    }
+
+    .empty-state h2 {
+      margin: 0 0 8px;
+      color: var(--heading);
+      font-size: 18px;
+      font-weight: 500;
+    }
+
+    .empty-state p {
+      margin: 0;
+      color: var(--text-muted);
+    }
+
+    .stats-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+      gap: 12px;
+    }
+
+    .stat-card {
+      border: 1px solid var(--border);
+      border-radius: var(--radius-lg);
+      background: var(--surface);
+      padding: 16px;
+      display: flex;
+      flex-direction: column;
+      gap: 6px;
+      min-height: 96px;
+    }
+
+    .stat-label {
+      color: var(--text-muted);
+      font-size: 12px;
+      letter-spacing: 0.04em;
+      text-transform: uppercase;
+    }
+
+    .stat-value {
+      color: var(--heading);
+      font-size: 28px;
+      font-weight: 600;
+      line-height: 1.1;
+    }
+
+    .tone-pass .stat-value,
+    .text-pass { color: var(--pass); }
+    .tone-warn .stat-value,
+    .text-warn { color: var(--warn); }
+    .tone-fail .stat-value,
+    .text-fail { color: var(--fail); }
+
+    .section {
+      display: flex;
+      flex-direction: column;
+      gap: 12px;
+    }
+
+    .section-heading {
+      display: flex;
+      align-items: baseline;
+      justify-content: space-between;
+      gap: 12px;
+      flex-wrap: wrap;
+    }
+
+    .section-heading h2 {
+      margin: 0;
+      color: var(--heading);
+      font-size: 20px;
+      font-weight: 600;
+    }
+
+    .section-heading p {
+      margin: 0;
+      color: var(--text-muted);
+    }
+
+    .table-wrap {
+      overflow-x: auto;
+      border: 1px solid var(--border);
+      border-radius: var(--radius-lg);
+      background: var(--surface);
+    }
+
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      font-size: 14px;
+    }
+
+    thead {
+      border-bottom: 1px solid var(--border);
+      background: var(--surface-muted);
+    }
+
+    th {
+      padding: 12px 16px;
+      text-align: left;
+      font-weight: 500;
+      color: var(--text-muted);
+      white-space: nowrap;
+    }
+
+    td {
+      padding: 12px 16px;
+      border-top: 1px solid rgba(31, 41, 55, 0.5);
+      vertical-align: top;
+    }
+
+    tbody tr {
+      transition: background-color 120ms ease;
+    }
+
+    tbody tr:hover {
+      background: var(--surface-hover);
+    }
+
+    .sortable {
+      cursor: pointer;
+      user-select: none;
+    }
+
+    .sortable:hover {
+      color: var(--text);
+    }
+
+    .table-num {
+      text-align: right;
+      color: var(--text);
+      white-space: nowrap;
+    }
+
+    .table-muted {
+      color: var(--text-muted);
+    }
+
+    .id-cell {
+      font-weight: 500;
+      color: var(--heading);
+    }
+
+    .status-pill {
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      padding: 2px 8px;
+      border-radius: 999px;
+      border: 1px solid var(--border);
+      background: rgba(17, 24, 39, 0.6);
+      color: var(--text);
+      font-size: 12px;
+      white-space: nowrap;
+    }
+
+    .status-dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 999px;
+      background: var(--text-subtle);
+    }
+
+    .status-pass .status-dot { background: var(--pass); }
+    .status-fail .status-dot { background: var(--fail); }
+    .status-error .status-dot { background: var(--warn); }
+
+    .pass-rate-track {
+      width: 80px;
+      height: 20px;
+      overflow: hidden;
+      border-radius: 999px;
+      background: var(--track);
+      position: relative;
+      border: 1px solid rgba(31, 41, 55, 0.8);
+    }
+
+    .pass-rate-fill {
+      position: absolute;
+      inset: 0 auto 0 0;
+      background: var(--pill-gradient);
+      border-radius: 999px;
+    }
+
+    .pass-rate-label {
+      position: absolute;
+      inset: 0;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 12px;
+      font-weight: 600;
+      color: #ffffff;
+      white-space: nowrap;
+      z-index: 1;
+    }
+
+    .histogram {
+      border: 1px solid var(--border);
+      border-radius: var(--radius-lg);
+      background: var(--surface);
+      padding: 16px;
+      display: flex;
+      flex-direction: column;
+      gap: 10px;
+    }
+
+    .hist-row {
+      display: grid;
+      grid-template-columns: 72px 1fr 40px;
+      gap: 12px;
+      align-items: center;
+    }
+
+    .hist-label,
+    .hist-count {
+      color: var(--text-muted);
+      font-size: 12px;
+    }
+
+    .hist-bar-track {
+      height: 16px;
+      border-radius: 999px;
+      background: var(--track);
+      overflow: hidden;
+    }
+
+    .hist-bar-fill {
+      height: 100%;
+      border-radius: 999px;
+      background: var(--pill-gradient);
+    }
+
+    .filter-bar {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+      align-items: center;
+    }
+
+    .filter-input,
+    .filter-select {
+      border: 1px solid #374151;
+      border-radius: var(--radius-md);
+      background: var(--canvas);
+      color: var(--text);
+      padding: 8px 10px;
+    }
+
+    .filter-input::placeholder {
+      color: var(--text-subtle);
+    }
+
+    .filter-input:focus,
+    .filter-select:focus {
+      outline: none;
+      border-color: var(--accent);
+      box-shadow: 0 0 0 1px var(--accent);
+    }
+
+    .filter-input {
+      min-width: 260px;
+      flex: 1 1 260px;
+    }
+
+    .filter-count {
+      margin-left: auto;
+      color: var(--text-muted);
+      font-size: 12px;
+    }
+
+    .group-list {
+      display: flex;
+      flex-direction: column;
+      gap: 16px;
+    }
+
+    .group-card {
+      border: 1px solid var(--border);
+      border-radius: var(--radius-lg);
+      overflow: hidden;
+      background: var(--surface);
+    }
+
+    .group-header {
+      padding: 16px;
+      border-bottom: 1px solid var(--border);
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      gap: 12px;
+      flex-wrap: wrap;
+      background: rgba(17, 24, 39, 0.65);
+    }
+
+    .group-title-wrap {
+      display: flex;
+      flex-direction: column;
+      gap: 4px;
+    }
+
+    .group-title {
+      margin: 0;
+      color: var(--heading);
+      font-size: 18px;
+      font-weight: 600;
+    }
+
+    .group-subtitle {
+      margin: 0;
+      color: var(--text-muted);
+      font-size: 13px;
+    }
+
+    .group-metrics {
+      display: flex;
+      flex-wrap: wrap;
+      align-items: center;
+      gap: 10px 14px;
+    }
+
+    .metric {
+      display: flex;
+      flex-direction: column;
+      gap: 2px;
+    }
+
+    .metric-label {
+      color: var(--text-muted);
+      font-size: 12px;
+    }
+
+    .metric-value {
+      color: var(--heading);
+      font-weight: 500;
+    }
+
+    .test-row {
+      cursor: pointer;
+    }
+
+    .expand-cell {
+      width: 40px;
+      color: var(--text-muted);
+      text-align: center;
+    }
+
+    .detail-row td {
+      padding: 0;
+      background: rgba(3, 7, 18, 0.5);
+    }
+
+    .detail-panel {
+      padding: 16px;
+      display: flex;
+      flex-direction: column;
+      gap: 16px;
+    }
+
+    .detail-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+      gap: 16px;
+    }
+
+    .detail-card,
+    .assertion-card,
+    .error-card {
+      border: 1px solid var(--border);
+      border-radius: var(--radius-lg);
+      background: var(--surface);
+      padding: 16px;
+    }
+
+    .detail-card h4,
+    .assertion-card h4,
+    .error-card h4 {
+      margin: 0 0 10px;
+      color: var(--heading);
+      font-size: 14px;
+      font-weight: 500;
+    }
+
+    pre {
+      margin: 0;
+      white-space: pre-wrap;
+      word-break: break-word;
+      font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+      font-size: 12px;
+      color: var(--text);
+      max-height: 320px;
+      overflow: auto;
+    }
+
+    .evaluator-table-wrap {
+      border: 1px solid var(--border);
+      border-radius: var(--radius-lg);
+      overflow-x: auto;
+      background: var(--surface);
+    }
+
+    .evaluator-table-wrap th,
+    .evaluator-table-wrap td {
+      padding: 14px 20px;
+    }
+
+    .assertion-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+      gap: 16px;
+    }
+
+    .assertion-list {
+      list-style: none;
+      margin: 0;
+      padding: 0;
+      display: flex;
+      flex-direction: column;
+      gap: 10px;
+    }
+
+    .assertion-item {
+      border: 1px solid rgba(31, 41, 55, 0.8);
+      border-radius: var(--radius-md);
+      background: rgba(3, 7, 18, 0.45);
+      padding: 10px 12px;
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+    }
+
+    .assertion-topline {
+      display: flex;
+      align-items: center;
+      flex-wrap: wrap;
+      gap: 8px;
+    }
+
+    .assertion-badge {
+      border: 1px solid rgba(8, 145, 178, 0.45);
+      background: rgba(8, 145, 178, 0.16);
+      color: #67e8f9;
+      border-radius: var(--radius-md);
+      padding: 2px 8px;
+      font-size: 12px;
+      font-weight: 500;
+      align-self: flex-start;
+    }
+
+    .assertion-status {
+      font-size: 12px;
+      font-weight: 500;
+    }
+
+    .assertion-text {
+      color: var(--text);
+    }
+
+    .assertion-evidence {
+      color: var(--text-muted);
+      font-size: 12px;
+      white-space: pre-wrap;
+      word-break: break-word;
+    }
+
+    .meta-row {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px 16px;
+      color: var(--text-muted);
+      font-size: 12px;
+      border-top: 1px solid var(--border);
+      padding-top: 12px;
+    }
+
+    .error-card {
+      border-color: rgba(248, 113, 113, 0.45);
+      background: rgba(127, 29, 29, 0.18);
+    }
+
+    .error-card h4,
+    .error-card pre {
+      color: #fecaca;
+    }
+
+    .muted {
+      color: var(--text-muted);
+    }
+
+    .hidden {
+      display: none;
+    }
+
+    .theme-toggle {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: var(--radius-md);
+      color: var(--text-muted);
+      cursor: pointer;
+      padding: 6px 10px;
+      font-size: 13px;
+      transition: color 120ms ease, border-color 120ms ease;
+      white-space: nowrap;
+    }
+
+    .theme-toggle:hover {
+      color: var(--text);
+      border-color: var(--text-muted);
+    }
+
+    .criteria-cell {
+      color: var(--text-muted);
+      font-size: 13px;
+      max-width: 320px;
+    }
+
+    .io-toggle {
+      cursor: pointer;
+      user-select: none;
+      color: var(--text-muted);
+      font-size: 13px;
+      border: 1px solid var(--border);
+      border-radius: var(--radius-md);
+      background: var(--surface);
+      padding: 8px 12px;
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+    }
+
+    .io-toggle:hover {
+      color: var(--text);
+    }
+
+    .io-toggle[open] > summary {
+      margin-bottom: 12px;
+    }
+
+    .io-toggle > summary {
+      list-style: none;
+    }
+
+    .io-toggle > summary::-webkit-details-marker {
+      display: none;
+    }
+
+    @media (max-width: 900px) {
+      .header,
+      .group-header,
+      .section-heading {
+        align-items: flex-start;
+      }
+
+      .filter-count {
+        width: 100%;
+        margin-left: 0;
+      }
+    }
+
+    @media (prefers-reduced-motion: reduce) {
+      *, *::before, *::after {
+        transition: none !important;
+        scroll-behavior: auto !important;
+      }
+    }
+  </style>
+</head>
+<body>
+  <div class="shell">
+    <header class="header">
+      <div class="header-title-wrap">
+        <div class="eyebrow">AgentV static export</div>
+        <h1 class="header-title">Evaluation Report</h1>
+        <p class="header-subtitle">Studio-themed HTML generated from an existing AgentV results workspace.</p>
+      </div>
+      <div class="header-meta" id="header-meta"></div>
+    </header>
+
+    <nav class="tabs" aria-label="Report sections" id="tab-nav">
+      <button class="tab active" type="button" data-tab="overview">Overview</button>
+      <button class="tab" type="button" data-tab="tests">Test Cases</button>
+    </nav>
+
+    <main class="app" id="app"></main>
+  </div>
+
+  <script>
+    const RAW_DATA = __DATA_PLACEHOLDER__;
+
+    (function () {
+      function pick(obj, keys, fallback) {
+        for (let i = 0; i < keys.length; i += 1) {
+          const key = keys[i];
+          if (obj && Object.prototype.hasOwnProperty.call(obj, key) && obj[key] !== undefined && obj[key] !== null) {
+            return obj[key];
+          }
+        }
+        return fallback;
+      }
+
+      function asString(value, fallback) {
+        return typeof value === 'string' ? value : fallback;
+      }
+
+      function asNumber(value, fallback) {
+        return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+      }
+
+      function asArray(value) {
+        return Array.isArray(value) ? value : [];
+      }
+
+      function normalizeAssertion(value, assertionType) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+        return {
+          text: asString(value.text, 'Untitled assertion'),
+          passed: Boolean(value.passed),
+          evidence: asString(value.evidence, ''),
+          assertion_type: asString(value.assertion_type, '') || assertionType,
+        };
+      }
+
+      function normalizeScores(value) {
+        return asArray(value)
+          .map((entry) => {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return null;
+            const scoreName = asString(pick(entry, ['name', 'type'], 'assertion'), 'assertion');
+            const scoreType = asString(pick(entry, ['type', 'name'], 'assertion'), 'assertion');
+            const assertions = asArray(entry.assertions)
+              .map((assertion) => normalizeAssertion(assertion, scoreName))
+              .filter(Boolean);
+            return {
+              name: scoreName,
+              type: scoreType,
+              score: asNumber(entry.score, 0),
+              assertions,
+            };
+          })
+          .filter(Boolean);
+      }
+
+      function normalizeTokenUsage(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+          return { input: 0, output: 0, reasoning: 0 };
+        }
+        return {
+          input: asNumber(pick(value, ['input', 'input_tokens', 'inputTokens'], 0), 0),
+          output: asNumber(pick(value, ['output', 'output_tokens', 'outputTokens'], 0), 0),
+          reasoning: asNumber(pick(value, ['reasoning', 'reasoning_tokens', 'reasoningTokens'], 0), 0),
+        };
+      }
+
+      function normalizeResult(raw, index) {
+        const scores = normalizeScores(pick(raw, ['scores'], []));
+        const fallbackAssertions = asArray(pick(raw, ['assertions'], []))
+          .map((assertion) => normalizeAssertion(assertion, 'assertion'))
+          .filter(Boolean);
+        const flattenedAssertions = scores.flatMap((score) => score.assertions);
+        const displayAssertions = flattenedAssertions.length > 0 ? flattenedAssertions : fallbackAssertions;
+        const testId = asString(pick(raw, ['test_id', 'testId'], 'unknown'), 'unknown');
+        const target = asString(pick(raw, ['target'], 'unknown'), 'unknown');
+        const evalFile = asString(pick(raw, ['eval_file', 'evalFile'], 'ungrouped'), 'ungrouped');
+        const executionStatus = asString(pick(raw, ['execution_status', 'executionStatus'], ''), '');
+        return {
+          _key: \`\${evalFile}:\${target}:\${testId}:\${index}\`,
+          raw,
+          eval_file: evalFile,
+          test_id: testId,
+          target,
+          score: asNumber(pick(raw, ['score'], 0), 0),
+          duration_ms: asNumber(pick(raw, ['duration_ms', 'durationMs'], 0), 0),
+          cost_usd: asNumber(pick(raw, ['cost_usd', 'costUsd'], 0), 0),
+          timestamp: asString(pick(raw, ['timestamp'], ''), ''),
+          execution_status: executionStatus,
+          error: asString(pick(raw, ['error'], ''), ''),
+          input: pick(raw, ['input'], null),
+          output: pick(raw, ['output'], null),
+          token_usage: normalizeTokenUsage(pick(raw, ['token_usage', 'tokenUsage'], {})),
+          total_tokens: 0,
+          scores,
+          assertions: displayAssertions,
+        };
+      }
+
+      function escapeHtml(value) {
+        return String(value)
+          .replace(/&/g, '&amp;')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;')
+          .replace(/"/g, '&quot;');
+      }
+
+      function statusOf(result) {
+        if (result.execution_status === 'execution_error') return 'error';
+        if (result.execution_status === 'quality_failure') return 'fail';
+        if (result.execution_status === 'ok') return 'pass';
+        if (result.error) return 'error';
+        return result.score >= 0.5 ? 'pass' : 'fail';
+      }
+
+      function statusLabel(status) {
+        if (status === 'pass') return 'Passed';
+        if (status === 'fail') return 'Failed';
+        return 'Error';
+      }
+
+      function toneForScore(value) {
+        if (value >= 0.8) return 'text-pass';
+        if (value >= 0.5) return 'text-warn';
+        return 'text-fail';
+      }
+
+      function toneClassForRate(value) {
+        if (value >= 0.8) return 'tone-pass';
+        if (value >= 0.5) return 'tone-warn';
+        return 'tone-fail';
+      }
+
+      function formatPercent(value) {
+        return \`\${(value * 100).toFixed(1)}%\`;
+      }
+
+      function formatDuration(ms) {
+        if (!ms) return '-';
+        if (ms < 1000) return \`\${Math.round(ms)}ms\`;
+        if (ms < 60000) return \`\${(ms / 1000).toFixed(1)}s\`;
+        const minutes = Math.floor(ms / 60000);
+        const seconds = Math.round((ms % 60000) / 1000);
+        return \`\${minutes}m \${seconds}s\`;
+      }
+
+      function formatTokens(value) {
+        if (!value) return '-';
+        if (value >= 1000000) return \`\${(value / 1000000).toFixed(1)}M\`;
+        if (value >= 1000) return \`\${(value / 1000).toFixed(1)}K\`;
+        return String(value);
+      }
+
+      function formatCost(value) {
+        if (!value) return '-';
+        if (value < 0.01) return '<$0.01';
+        return \`$\${value.toFixed(2)}\`;
+      }
+
+      function totalTokens(result) {
+        return (result.token_usage.input || 0) + (result.token_usage.output || 0) + (result.token_usage.reasoning || 0);
+      }
+
+      function computeStats(rows) {
+        const stats = {
+          total: rows.length,
+          passed: 0,
+          failed: 0,
+          errors: 0,
+          total_duration_ms: 0,
+          total_tokens: 0,
+          total_cost_usd: 0,
+          scores: [],
+        };
+        rows.forEach((row) => {
+          const status = statusOf(row);
+          if (status === 'pass') stats.passed += 1;
+          else if (status === 'fail') stats.failed += 1;
+          else stats.errors += 1;
+          stats.total_duration_ms += row.duration_ms || 0;
+          stats.total_tokens += totalTokens(row);
+          stats.total_cost_usd += row.cost_usd || 0;
+          if (status !== 'error') stats.scores.push(row.score);
+        });
+        const graded = stats.passed + stats.failed;
+        stats.pass_rate = graded > 0 ? stats.passed / graded : 0;
+        return stats;
+      }
+
+      function groupBy(rows, key) {
+        const map = new Map();
+        rows.forEach((row) => {
+          const value = row[key];
+          if (!map.has(value)) map.set(value, []);
+          map.get(value).push(row);
+        });
+        return Array.from(map.entries()).map(([name, entries]) => ({
+          name,
+          rows: entries,
+          stats: computeStats(entries),
+        }));
+      }
+
+      function uniqueScoreNames(rows) {
+        const seen = new Set();
+        rows.forEach((row) => {
+          row.scores.forEach((score) => seen.add(score.name));
+        });
+        return Array.from(seen.values()).sort();
+      }
+
+      function scoreForName(row, scoreName) {
+        const match = row.scores.find((score) => score.name === scoreName);
+        return match ? match.score : null;
+      }
+
+      function sortRows(rows, sort) {
+        const direction = sort.dir === 'asc' ? 1 : -1;
+        const statusRank = { pass: 0, fail: 1, error: 2 };
+        return rows.slice().sort((left, right) => {
+          let a;
+          let b;
+          if (sort.col === 'status') {
+            a = statusRank[statusOf(left)];
+            b = statusRank[statusOf(right)];
+          } else if (sort.col.startsWith('score:')) {
+            const scoreName = sort.col.slice('score:'.length);
+            a = scoreForName(left, scoreName);
+            b = scoreForName(right, scoreName);
+          } else {
+            a = left[sort.col];
+            b = right[sort.col];
+          }
+          if (a == null && b == null) return 0;
+          if (a == null) return 1;
+          if (b == null) return -1;
+          if (typeof a === 'string' || typeof b === 'string') {
+            return String(a).localeCompare(String(b)) * direction;
+          }
+          return (a - b) * direction;
+        });
+      }
+
+      function matchesSearch(row, search) {
+        if (!search) return true;
+        const haystack = [
+          row.test_id,
+          row.target,
+          row.eval_file,
+          row.error,
+          extractCriteria(row),
+          row.assertions.map((assertion) => \`\${assertion.assertion_type} \${assertion.text} \${assertion.evidence}\`).join(' '),
+        ].join(' ').toLowerCase();
+        return haystack.includes(search.toLowerCase());
+      }
+
+      function filterRows(rows, filter) {
+        return rows.filter((row) => {
+          const status = statusOf(row);
+          if (filter.status !== 'all' && status !== filter.status) return false;
+          if (filter.target !== 'all' && row.target !== filter.target) return false;
+          if (!matchesSearch(row, filter.search)) return false;
+          return true;
+        });
+      }
+
+      function renderPassRate(rate) {
+        return \`
+          <span class="pass-rate-track">
+            <span class="pass-rate-fill" style="width:\${Math.max(0, Math.min(100, rate * 100))}%"></span>
+            <span class="pass-rate-label">\${formatPercent(rate)}</span>
+          </span>
+        \`;
+      }
+
+      function formatJson(value) {
+        if (value == null) return '';
+        if (typeof value === 'string') return value;
+        try {
+          return JSON.stringify(value, null, 2);
+        } catch (error) {
+          return String(value);
+        }
+      }
+
+      function renderStatusPill(status) {
+        return \`
+          <span class="status-pill status-\${status}">
+            <span class="status-dot"></span>
+            <span>\${statusLabel(status)}</span>
+          </span>
+        \`;
+      }
+
+      function renderAssertions(assertions) {
+        if (assertions.length === 0) {
+          return '<p class="muted">No assertions.</p>';
+        }
+        return \`
+          <ul class="assertion-list">
+            \${assertions.map((assertion) => \`
+              <li class="assertion-item">
+                <div class="assertion-topline">
+                  <span class="assertion-status \${assertion.passed ? 'text-pass' : 'text-fail'}">\${assertion.passed ? '\\u2713' : '\\u2717'}</span>
+                  \${assertion.assertion_type ? \`<span class="assertion-badge">\${escapeHtml(assertion.assertion_type)}</span>\` : ''}
+                  <span class="assertion-text">\${escapeHtml(assertion.text)}</span>
+                </div>
+                \${assertion.evidence ? \`<div class="assertion-evidence">\${escapeHtml(assertion.evidence)}</div>\` : ''}
+              </li>
+            \`).join('')}
+          </ul>
+        \`;
+      }
+
+      function extractCriteria(row) {
+        if (row.input && typeof row.input === 'object' && row.input.prompt) {
+          return String(row.input.prompt);
+        }
+        if (typeof row.input === 'string' && row.input.length > 0 && row.input.length <= 200) {
+          return row.input;
+        }
+        if (row.assertions && row.assertions.length > 0) {
+          const types = Array.from(new Set(row.assertions.map(a => a.assertion_type).filter(Boolean)));
+          const firstText = row.assertions[0].text || '';
+          const prefix = types.length > 0 ? types.join(', ') + ': ' : '';
+          const full = prefix + firstText;
+          return full.length > 120 ? full.slice(0, 117) + '...' : full;
+        }
+        return '';
+      }
+
+      function renderDetail(row, evaluatorNames, hasAnyCost) {
+        const meta = [];
+        if (row.timestamp) meta.push(escapeHtml(row.timestamp));
+        if (row.target) meta.push(escapeHtml(row.target));
+        if (row.duration_ms) meta.push(escapeHtml(formatDuration(row.duration_ms)));
+        if (totalTokens(row)) meta.push(escapeHtml(\`\${formatTokens(totalTokens(row))} tokens\`));
+        if (hasAnyCost && row.cost_usd) meta.push(escapeHtml(formatCost(row.cost_usd)));
+
+        const hasIo = row.input != null || row.output != null;
+
+        return \`
+          <div class="detail-panel">
+            <div class="assertion-card">
+              <h4>Assertions (\${row.assertions.length})</h4>
+              \${renderAssertions(row.assertions)}
+            </div>
+
+            \${row.error ? \`
+              <div class="error-card">
+                <h4>Error</h4>
+                <pre>\${escapeHtml(row.error)}</pre>
+              </div>
+            \` : ''}
+
+            \${hasIo ? \`
+              <details class="io-toggle">
+                <summary>\\u25B8 Input / Output</summary>
+                <div class="detail-grid">
+                  <div class="detail-card">
+                    <h4>Input</h4>
+                    <pre>\${escapeHtml(formatJson(row.input))}</pre>
+                  </div>
+                  <div class="detail-card">
+                    <h4>Output</h4>
+                    <pre>\${escapeHtml(formatJson(row.output))}</pre>
+                  </div>
+                </div>
+              </details>
+            \` : ''}
+
+            <div class="meta-row">\${meta.join('<span>&middot;</span>')}</div>
+          </div>
+        \`;
+      }
+
+      const DATA = asArray(RAW_DATA).map(normalizeResult);
+      DATA.forEach((row) => {
+        row.total_tokens = totalTokens(row);
+      });
+      const STATE = {
+        tab: 'overview',
+        filter: { status: 'all', target: 'all', search: '' },
+        sort: { col: 'test_id', dir: 'asc' },
+        expanded: {},
+      };
+
+      const APP = document.getElementById('app');
+      const HEADER_META = document.getElementById('header-meta');
+      const TAB_BUTTONS = Array.from(document.querySelectorAll('.tab'));
+      const TARGETS = Array.from(new Set(DATA.map((row) => row.target))).sort();
+      const EVALUATOR_NAMES = uniqueScoreNames(DATA);
+      const HAS_ANY_COST = DATA.some((row) => row.cost_usd > 0);
+      const OVERALL_STATS = computeStats(DATA);
+      const EVAL_GROUPS = groupBy(DATA, 'eval_file').sort((a, b) => a.name.localeCompare(b.name));
+      const TARGET_GROUPS = groupBy(DATA, 'target').sort((a, b) => a.name.localeCompare(b.name));
+
+      function syncHeaderMeta() {
+        const themeLabel = document.documentElement.classList.contains('light') ? '\\u263E Dark' : '\\u2600 Light';
+        HEADER_META.innerHTML = \`
+          <span class="chip">\${escapeHtml(String(DATA.length))} tests</span>
+          <span class="chip">\${escapeHtml(String(EVAL_GROUPS.length))} eval files</span>
+          <span class="chip">\${escapeHtml(String(TARGETS.length))} targets</span>
+          <button class="theme-toggle" id="theme-btn" type="button">\${themeLabel}</button>
+        \`;
+        document.getElementById('theme-btn').addEventListener('click', toggleTheme);
+      }
+
+      function toggleTheme() {
+        document.documentElement.classList.toggle('light');
+        syncHeaderMeta();
+      }
+
+      function setTab(tab) {
+        STATE.tab = tab;
+        TAB_BUTTONS.forEach((button) => {
+          button.classList.toggle('active', button.getAttribute('data-tab') === tab);
+        });
+        render();
+      }
+
+      TAB_BUTTONS.forEach((button) => {
+        button.addEventListener('click', () => setTab(button.getAttribute('data-tab')));
+      });
+
+      function renderStatCard(label, value, tone) {
+        return \`
+          <div class="stat-card \${tone || ''}">
+            <div class="stat-label">\${escapeHtml(label)}</div>
+            <div class="stat-value">\${escapeHtml(value)}</div>
+          </div>
+        \`;
+      }
+
+      function renderOverview() {
+        if (DATA.length === 0) {
+          APP.innerHTML = \`
+            <div class="empty-state">
+              <h2>No results loaded</h2>
+              <p>Add one or more parsed JSONL result rows to the template placeholder.</p>
+            </div>
+          \`;
+          return;
+        }
+
+        const overviewSections = [];
+        overviewSections.push(\`
+          <section class="section">
+            <div class="stats-grid">
+              \${renderStatCard('Total tests', String(OVERALL_STATS.total))}
+              \${renderStatCard('Eval files', String(EVAL_GROUPS.length))}
+              \${renderStatCard('Targets', String(TARGETS.length))}
+              \${renderStatCard('Passed', String(OVERALL_STATS.passed), 'tone-pass')}
+              \${renderStatCard('Failed', String(OVERALL_STATS.failed), 'tone-fail')}
+              \${renderStatCard('Errors', String(OVERALL_STATS.errors), OVERALL_STATS.errors > 0 ? 'tone-warn' : '')}
+              \${renderStatCard('Pass rate', formatPercent(OVERALL_STATS.pass_rate), toneClassForRate(OVERALL_STATS.pass_rate))}
+              \${renderStatCard('Duration', formatDuration(OVERALL_STATS.total_duration_ms))}
+              \${renderStatCard('Tokens', formatTokens(OVERALL_STATS.total_tokens))}
+              \${HAS_ANY_COST ? renderStatCard('Cost', formatCost(OVERALL_STATS.total_cost_usd)) : ''}
+            </div>
+          </section>
+        \`);
+
+        overviewSections.push(\`
+          <section class="section">
+            <div class="section-heading">
+              <div>
+                <h2>Eval Files</h2>
+                <p>Grouped exactly as the exported template will render them in the Test Cases tab.</p>
+              </div>
+            </div>
+            <div class="table-wrap">
+              <table>
+                <thead>
+                  <tr>
+                    <th>Eval file</th>
+                    <th>Pass rate</th>
+                    <th class="table-num">Passed</th>
+                    <th class="table-num">Failed</th>
+                    <th class="table-num">Errors</th>
+                    <th class="table-num">Tests</th>
+                    <th class="table-num">Duration</th>
+                    <th class="table-num">Tokens</th>
+                    \${HAS_ANY_COST ? '<th class="table-num">Cost</th>' : ''}
+                  </tr>
+                </thead>
+                <tbody>
+                  \${EVAL_GROUPS.map((group) => \`
+                    <tr>
+                      <td class="id-cell">\${escapeHtml(group.name)}</td>
+                      <td>\${renderPassRate(group.stats.pass_rate)}</td>
+                      <td class="table-num text-pass">\${escapeHtml(String(group.stats.passed))}</td>
+                      <td class="table-num text-fail">\${escapeHtml(String(group.stats.failed))}</td>
+                      <td class="table-num text-warn">\${escapeHtml(String(group.stats.errors))}</td>
+                      <td class="table-num">\${escapeHtml(String(group.stats.total))}</td>
+                      <td class="table-num">\${escapeHtml(formatDuration(group.stats.total_duration_ms))}</td>
+                      <td class="table-num">\${escapeHtml(formatTokens(group.stats.total_tokens))}</td>
+                      \${HAS_ANY_COST ? \`<td class="table-num">\${escapeHtml(formatCost(group.stats.total_cost_usd))}</td>\` : ''}
+                    </tr>
+                  \`).join('')}
+                </tbody>
+              </table>
+            </div>
+          </section>
+        \`);
+
+        if (TARGET_GROUPS.length > 1) {
+          overviewSections.push(\`
+            <section class="section">
+              <div class="section-heading">
+                <div>
+                  <h2>Targets</h2>
+                  <p>Cross-target summary for the loaded result set.</p>
+                </div>
+              </div>
+              <div class="table-wrap">
+                <table>
+                  <thead>
+                    <tr>
+                      <th>Target</th>
+                    <th>Pass rate</th>
+                      <th class="table-num">Passed</th>
+                      <th class="table-num">Failed</th>
+                      <th class="table-num">Errors</th>
+                      <th class="table-num">Avg score</th>
+                      <th class="table-num">Duration</th>
+                      <th class="table-num">Tokens</th>
+                      \${HAS_ANY_COST ? '<th class="table-num">Cost</th>' : ''}
+                    </tr>
+                  </thead>
+                  <tbody>
+                    \${TARGET_GROUPS.map((group) => {
+                      const gradedRows = group.rows.filter((row) => statusOf(row) !== 'error');
+                      const avgScore = gradedRows.length > 0
+                        ? gradedRows.reduce((sum, row) => sum + row.score, 0) / gradedRows.length
+                        : 0;
+                      return \`
+                        <tr>
+                          <td class="id-cell">\${escapeHtml(group.name)}</td>
+                      <td>\${renderPassRate(group.stats.pass_rate)}</td>
+                          <td class="table-num text-pass">\${escapeHtml(String(group.stats.passed))}</td>
+                          <td class="table-num text-fail">\${escapeHtml(String(group.stats.failed))}</td>
+                          <td class="table-num text-warn">\${escapeHtml(String(group.stats.errors))}</td>
+                          <td class="table-num \${toneForScore(avgScore)}">\${escapeHtml(formatPercent(avgScore))}</td>
+                          <td class="table-num">\${escapeHtml(formatDuration(group.stats.total_duration_ms))}</td>
+                          <td class="table-num">\${escapeHtml(formatTokens(group.stats.total_tokens))}</td>
+                          \${HAS_ANY_COST ? \`<td class="table-num">\${escapeHtml(formatCost(group.stats.total_cost_usd))}</td>\` : ''}
+                        </tr>
+                      \`;
+                    }).join('')}
+                  </tbody>
+                </table>
+              </div>
+            </section>
+          \`);
+        }
+
+        if (OVERALL_STATS.scores.length > 0) {
+          const buckets = [0, 0, 0, 0, 0];
+          OVERALL_STATS.scores.forEach((score) => {
+            const index = Math.min(Math.floor(score * 5), 4);
+            buckets[index] += 1;
+          });
+          const maxBucket = Math.max.apply(null, buckets);
+          const labels = ['0-20%', '20-40%', '40-60%', '60-80%', '80-100%'];
+          overviewSections.push(\`
+            <section class="section">
+              <div class="section-heading">
+                <div>
+                  <h2>Score Distribution</h2>
+                  <p>Histogram across all non-error result rows.</p>
+                </div>
+              </div>
+              <div class="histogram">
+                \${buckets.map((count, index) => \`
+                  <div class="hist-row">
+                    <div class="hist-label">\${labels[index]}</div>
+                    <div class="hist-bar-track">
+                      <div class="hist-bar-fill" style="width:\${maxBucket > 0 ? (count / maxBucket) * 100 : 0}%"></div>
+                    </div>
+                    <div class="hist-count tabular">\${count}</div>
+                  </div>
+                \`).join('')}
+              </div>
+            </section>
+          \`);
+        }
+
+        APP.innerHTML = overviewSections.join('');
+      }
+
+      function renderSortableHeader(label, col) {
+        const arrow = STATE.sort.col === col ? (STATE.sort.dir === 'asc' ? ' \u2191' : ' \u2193') : '';
+        return \`<th class="sortable" data-sort="\${escapeHtml(col)}">\${escapeHtml(label)}\${arrow}</th>\`;
+      }
+
+      function renderTestGroups() {
+        const filteredRows = filterRows(DATA, STATE.filter);
+        const filteredGroups = groupBy(filteredRows, 'eval_file').sort((a, b) => a.name.localeCompare(b.name));
+        const hasMultipleTargets = TARGETS.length > 1;
+        const hasCriteria = DATA.some((row) => extractCriteria(row).length > 0);
+        if (filteredRows.length === 0) {
+          return '<div class="empty-state"><h2>No matching tests</h2><p>Adjust the filters or search text.</p></div>';
+        }
+
+        const colCount = 4 + (hasCriteria ? 1 : 0) + (hasMultipleTargets ? 1 : 0) + (HAS_ANY_COST ? 1 : 0);
+
+        return \`
+          <div class="group-list">
+            \${filteredGroups.map((group) => {
+              const sortedRows = sortRows(group.rows, STATE.sort);
+              const groupSummary = [];
+              groupSummary.push(\`\${group.stats.passed}/\${group.stats.total} passed\`);
+              if (group.stats.failed > 0) groupSummary.push(\`\${group.stats.failed} failed\`);
+              if (group.stats.errors > 0) groupSummary.push(\`\${group.stats.errors} errors\`);
+              return \`
+                <section class="group-card">
+                  <div class="group-header">
+                    <div class="group-title-wrap">
+                      <h2 class="group-title">\${escapeHtml(group.name)}</h2>
+                      <p class="group-subtitle">\${escapeHtml(groupSummary.join(' | '))}</p>
+                    </div>
+                    <div class="group-metrics">
+                      <div class="metric">
+                        <span class="metric-label">Pass rate</span>
+                        <span class="metric-value">\${escapeHtml(formatPercent(group.stats.pass_rate))}</span>
+                      </div>
+                      <div class="metric">
+                        <span class="metric-label">Tests</span>
+                        <span class="metric-value">\${escapeHtml(String(group.stats.total))}</span>
+                      </div>
+                      <div class="metric">
+                        <span class="metric-label">Duration</span>
+                        <span class="metric-value">\${escapeHtml(formatDuration(group.stats.total_duration_ms))}</span>
+                      </div>
+                    </div>
+                  </div>
+                  <div class="table-wrap">
+                    <table>
+                      <thead>
+                        <tr>
+                          <th class="expand-cell"></th>
+                          \${renderSortableHeader('Test ID', 'test_id')}
+                          \${hasCriteria ? '<th>Criteria</th>' : ''}
+                          \${hasMultipleTargets ? renderSortableHeader('Target', 'target') : ''}
+                          \${renderSortableHeader('Score', 'score')}
+                          \${renderSortableHeader('Result', 'status')}
+                          \${HAS_ANY_COST ? renderSortableHeader('Cost', 'cost_usd') : ''}
+                        </tr>
+                      </thead>
+                      <tbody>
+                        \${sortedRows.map((row) => {
+                          const expanded = Boolean(STATE.expanded[row._key]);
+                          const criteria = extractCriteria(row);
+                          return \`
+                            <tr class="test-row" data-expand="\${escapeHtml(row._key)}">
+                              <td class="expand-cell">\${expanded ? '\\u25BE' : '\\u25B8'}</td>
+                              <td class="id-cell">\${escapeHtml(row.test_id)}</td>
+                              \${hasCriteria ? \`<td class="criteria-cell">\${escapeHtml(criteria)}</td>\` : ''}
+                              \${hasMultipleTargets ? \`<td class="table-muted">\${escapeHtml(row.target)}</td>\` : ''}
+                              <td class="table-num \${toneForScore(row.score)}">\${escapeHtml(formatPercent(row.score))}</td>
+                              <td>\${renderStatusPill(statusOf(row))}</td>
+                              \${HAS_ANY_COST ? \`<td class="table-num">\${escapeHtml(formatCost(row.cost_usd))}</td>\` : ''}
+                            </tr>
+                            \${expanded ? \`<tr class="detail-row"><td colspan="\${colCount}">\${renderDetail(row, EVALUATOR_NAMES, HAS_ANY_COST)}</td></tr>\` : ''}
+                          \`;
+                        }).join('')}
+                      </tbody>
+                    </table>
+                  </div>
+                </section>
+              \`;
+            }).join('')}
+          </div>
+        \`;
+      }
+
+      function bindTestEvents() {
+        const statusInput = document.getElementById('filter-status');
+        const targetInput = document.getElementById('filter-target');
+        const searchInput = document.getElementById('filter-search');
+        const sortableHeaders = Array.from(document.querySelectorAll('[data-sort]'));
+        const expandableRows = Array.from(document.querySelectorAll('[data-expand]'));
+
+        if (statusInput) {
+          statusInput.value = STATE.filter.status;
+          statusInput.addEventListener('change', (event) => {
+            STATE.filter.status = event.target.value;
+            render();
+          });
+        }
+
+        if (targetInput) {
+          targetInput.value = STATE.filter.target;
+          targetInput.addEventListener('change', (event) => {
+            STATE.filter.target = event.target.value;
+            render();
+          });
+        }
+
+        if (searchInput) {
+          searchInput.value = STATE.filter.search;
+          searchInput.addEventListener('input', (event) => {
+            STATE.filter.search = event.target.value;
+            render();
+          });
+        }
+
+        sortableHeaders.forEach((header) => {
+          header.addEventListener('click', () => {
+            const col = header.getAttribute('data-sort');
+            if (STATE.sort.col === col) {
+              STATE.sort.dir = STATE.sort.dir === 'asc' ? 'desc' : 'asc';
+            } else {
+              STATE.sort.col = col;
+              STATE.sort.dir = 'asc';
+            }
+            render();
+          });
+        });
+
+        expandableRows.forEach((row) => {
+          row.addEventListener('click', () => {
+            const key = row.getAttribute('data-expand');
+            STATE.expanded[key] = !STATE.expanded[key];
+            render();
+          });
+        });
+      }
+
+      function renderTests() {
+        const filteredRows = filterRows(DATA, STATE.filter);
+        APP.innerHTML = \`
+          <section class="section">
+            <div class="section-heading">
+              <div>
+                <h2>Test Cases</h2>
+                <p>Grouped by source eval file with assertion type badges carried down from parent score entries.</p>
+              </div>
+            </div>
+            <div class="filter-bar">
+              <select class="filter-select" id="filter-status" aria-label="Filter by status">
+                <option value="all">All status</option>
+                <option value="pass">Passed</option>
+                <option value="fail">Failed</option>
+                <option value="error">Errors</option>
+              </select>
+              \${TARGETS.length > 1 ? \`
+                <select class="filter-select" id="filter-target" aria-label="Filter by target">
+                  <option value="all">All targets</option>
+                  \${TARGETS.map((target) => \`<option value="\${escapeHtml(target)}">\${escapeHtml(target)}</option>\`).join('')}
+                </select>
+              \` : ''}
+              <input class="filter-input" id="filter-search" type="search" placeholder="Search test IDs, targets, eval files, or assertion text">
+              <span class="filter-count">\${escapeHtml(String(filteredRows.length))} of \${escapeHtml(String(DATA.length))} tests</span>
+            </div>
+            \${renderTestGroups()}
+          </section>
+        \`;
+        bindTestEvents();
+      }
+
+      const IS_SMALL = DATA.length <= 20;
+      const TAB_NAV = document.getElementById('tab-nav');
+
+      function render() {
+        if (IS_SMALL) {
+          TAB_NAV.classList.add('hidden');
+          renderSinglePage();
+        } else {
+          TAB_NAV.classList.remove('hidden');
+          if (STATE.tab === 'overview') renderOverview();
+          else renderTests();
+        }
+      }
+
+      function renderSinglePage() {
+        if (DATA.length === 0) {
+          APP.innerHTML = \`
+            <div class="empty-state">
+              <h2>No results loaded</h2>
+              <p>Add one or more parsed JSONL result rows to the template placeholder.</p>
+            </div>
+          \`;
+          return;
+        }
+
+        const sections = [];
+        sections.push(\`
+          <section class="section">
+            <div class="stats-grid">
+              \${renderStatCard('Total tests', String(OVERALL_STATS.total))}
+              \${renderStatCard('Passed', String(OVERALL_STATS.passed), 'tone-pass')}
+              \${renderStatCard('Failed', String(OVERALL_STATS.failed), OVERALL_STATS.failed > 0 ? 'tone-fail' : '')}
+              \${renderStatCard('Pass rate', formatPercent(OVERALL_STATS.pass_rate), toneClassForRate(OVERALL_STATS.pass_rate))}
+              \${renderStatCard('Duration', formatDuration(OVERALL_STATS.total_duration_ms))}
+              \${HAS_ANY_COST ? renderStatCard('Cost', formatCost(OVERALL_STATS.total_cost_usd)) : ''}
+            </div>
+          </section>
+        \`);
+
+        sections.push(\`
+          <section class="section">
+            <div class="filter-bar">
+              <select class="filter-select" id="filter-status" aria-label="Filter by status">
+                <option value="all">All status</option>
+                <option value="pass">Passed</option>
+                <option value="fail">Failed</option>
+                <option value="error">Errors</option>
+              </select>
+              <input class="filter-input" id="filter-search" type="search" placeholder="Search test IDs, targets, or assertion text">
+            </div>
+            \${renderTestGroups()}
+          </section>
+        \`);
+
+        APP.innerHTML = sections.join('');
+        bindTestEvents();
+      }
+
+      syncHeaderMeta();
+      render();
+    })();
+  </script>
+</body>
+</html>
+`;
+
+// src/commands/results/report.ts
+function normalizeEvalFileLabel(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  return path13.basename(trimmed).replace(/\.results\.jsonl$/i, "").replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "").replace(/\.jsonl$/i, "");
+}
+function readBenchmarkEvalFile(sourceFile) {
+  const benchmarkPath = path13.join(path13.dirname(sourceFile), "benchmark.json");
+  if (!existsSync8(benchmarkPath)) {
+    return void 0;
+  }
+  try {
+    const benchmark = JSON.parse(readFileSync7(benchmarkPath, "utf8"));
+    return normalizeEvalFileLabel(benchmark.metadata?.eval_file);
+  } catch {
+    return void 0;
+  }
+}
+function deriveReportPath(sourceFile) {
+  return path13.join(path13.dirname(sourceFile), "report.html");
+}
+function serializeReportResult(result, sourceFile, manifestRecord, benchmarkEvalFile) {
+  const fallbackEvalFile = normalizeEvalFileLabel(manifestRecord?.eval_file) ?? benchmarkEvalFile ?? normalizeEvalFileLabel(result.suite) ?? path13.basename(path13.dirname(sourceFile));
+  return {
+    timestamp: result.timestamp,
+    test_id: result.testId,
+    suite: result.suite,
+    category: result.category,
+    target: result.target,
+    score: result.score,
+    scores: result.scores,
+    execution_status: result.executionStatus,
+    error: result.error,
+    duration_ms: result.durationMs,
+    token_usage: result.tokenUsage,
+    cost_usd: result.costUsd,
+    input: result.input,
+    output: result.output,
+    assertions: result.assertions,
+    eval_file: fallbackEvalFile
+  };
+}
+async function loadReportSource(source, cwd) {
+  const { sourceFile } = await resolveSourceFile(source, cwd);
+  const resolvedSourceFile = resolveResultSourcePath(sourceFile, cwd);
+  const content = readFileSync7(resolvedSourceFile, "utf8");
+  const records = parseResultManifest(content);
+  const results = loadManifestResults(resolvedSourceFile);
+  if (results.length === 0) {
+    throw new Error(`No results found in ${resolvedSourceFile}`);
+  }
+  return {
+    sourceFile: resolvedSourceFile,
+    results,
+    records,
+    benchmarkEvalFile: readBenchmarkEvalFile(resolvedSourceFile)
+  };
+}
+function renderResultsReport(results, sourceFile, records, benchmarkEvalFile) {
+  if (!RESULTS_REPORT_TEMPLATE.includes("__DATA_PLACEHOLDER__")) {
+    throw new Error("Report template is missing __DATA_PLACEHOLDER__");
+  }
+  const rows = results.map(
+    (result, index) => serializeReportResult(result, sourceFile, records[index], benchmarkEvalFile)
+  );
+  const dataJson = JSON.stringify(rows).replace(/<\//g, "<\\/");
+  return RESULTS_REPORT_TEMPLATE.replace("__DATA_PLACEHOLDER__", dataJson);
+}
+async function writeResultsReport(source, outputPath, cwd) {
+  const { sourceFile, results, records, benchmarkEvalFile } = await loadReportSource(source, cwd);
+  const resolvedOutputPath = outputPath ? path13.isAbsolute(outputPath) ? outputPath : path13.resolve(cwd, outputPath) : deriveReportPath(sourceFile);
+  const html = renderResultsReport(results, sourceFile, records, benchmarkEvalFile);
+  mkdirSync2(path13.dirname(resolvedOutputPath), { recursive: true });
+  writeFileSync3(resolvedOutputPath, html, "utf8");
+  const written = readFileSync7(resolvedOutputPath, "utf8");
+  if (written.includes("__DATA_PLACEHOLDER__")) {
+    throw new Error("Report placeholder substitution failed");
+  }
+  return { sourceFile, outputPath: resolvedOutputPath, html: written };
+}
+var resultsReportCommand = command({
+  name: "report",
+  description: "Generate a static HTML report from a run workspace or index.jsonl manifest",
+  args: {
+    source: sourceArg,
+    out: option({
+      type: optional(string),
+      long: "out",
+      short: "o",
+      description: "Output HTML file (defaults to <run-dir>/report.html)"
+    }),
+    dir: option({
+      type: optional(string),
+      long: "dir",
+      short: "d",
+      description: "Working directory (default: current directory)"
+    })
+  },
+  handler: async ({ source, out, dir }) => {
+    const cwd = dir ?? process.cwd();
+    try {
+      const { sourceFile, outputPath } = await writeResultsReport(source, out, cwd);
+      console.log(`Report written to ${outputPath}`);
+      console.log(`Source: ${sourceFile}`);
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  }
+});
+
 // src/commands/results/show.ts
 function findResult(results, testId) {
   return results.find((r) => r.testId === testId);
@@ -7054,7 +8805,7 @@ var resultsShowCommand = command({
 });
 
 // src/commands/results/summary.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "node:fs";
 function formatSummary(results, grading) {
   const total = results.length;
   let passed;
@@ -7105,9 +8856,9 @@ var resultsSummaryCommand = command({
       const { results, sourceFile } = await loadResults(source, cwd);
       let grading;
       const gradingPath = sourceFile.replace(/\.jsonl$/, ".grading.json");
-      if (existsSync8(gradingPath)) {
+      if (existsSync9(gradingPath)) {
         try {
-          grading = JSON.parse(readFileSync7(gradingPath, "utf8"));
+          grading = JSON.parse(readFileSync8(gradingPath, "utf8"));
         } catch {
         }
       }
@@ -7120,11 +8871,11 @@ var resultsSummaryCommand = command({
 });
 
 // src/commands/results/validate.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8, statSync as statSync4 } from "node:fs";
-import path13 from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync9, statSync as statSync4 } from "node:fs";
+import path14 from "node:path";
 function checkDirectoryNaming(runDir) {
-  const dirName = path13.basename(runDir);
-  const pathSegments = path13.normalize(runDir).split(path13.sep).filter(Boolean);
+  const dirName = path14.basename(runDir);
+  const pathSegments = path14.normalize(runDir).split(path14.sep).filter(Boolean);
   const runsIndex = pathSegments.lastIndexOf("runs");
   const diagnostics = [];
   if (runsIndex < 0 || runsIndex >= pathSegments.length - 1) {
@@ -7154,14 +8905,14 @@ function validateRunDirectory(runDir) {
   return { diagnostics, entries: entries2 };
 }
 function checkIndexJsonl(runDir) {
-  const indexPath = path13.join(runDir, "index.jsonl");
+  const indexPath = path14.join(runDir, "index.jsonl");
   const diagnostics = [];
   const entries2 = [];
-  if (!existsSync9(indexPath)) {
+  if (!existsSync10(indexPath)) {
     diagnostics.push({ severity: "error", message: "index.jsonl is missing" });
     return { diagnostics, entries: entries2 };
   }
-  const content = readFileSync8(indexPath, "utf8");
+  const content = readFileSync9(indexPath, "utf8");
   const lines = content.split("\n").filter((l) => l.trim().length > 0);
   if (lines.length === 0) {
     diagnostics.push({ severity: "error", message: "index.jsonl is empty" });
@@ -7253,15 +9004,15 @@ function checkArtifactFiles(runDir, entries2) {
   for (const entry of entries2) {
     const testId = entry.test_id ?? "?";
     if (entry.grading_path) {
-      const gradingPath = path13.join(runDir, entry.grading_path);
-      if (!existsSync9(gradingPath)) {
+      const gradingPath = path14.join(runDir, entry.grading_path);
+      if (!existsSync10(gradingPath)) {
         diagnostics.push({
           severity: "error",
           message: `${testId}: grading.json not found at '${entry.grading_path}'`
         });
       } else {
         try {
-          const grading = JSON.parse(readFileSync8(gradingPath, "utf8"));
+          const grading = JSON.parse(readFileSync9(gradingPath, "utf8"));
           if (!grading.assertions || !Array.isArray(grading.assertions)) {
             diagnostics.push({
               severity: "error",
@@ -7283,8 +9034,8 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
     if (entry.timing_path) {
-      const timingPath = path13.join(runDir, entry.timing_path);
-      if (!existsSync9(timingPath)) {
+      const timingPath = path14.join(runDir, entry.timing_path);
+      if (!existsSync10(timingPath)) {
         diagnostics.push({
           severity: "warning",
           message: `${testId}: timing.json not found at '${entry.timing_path}'`
@@ -7292,8 +9043,8 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
   }
-  const benchmarkPath = path13.join(runDir, "benchmark.json");
-  if (!existsSync9(benchmarkPath)) {
+  const benchmarkPath = path14.join(runDir, "benchmark.json");
+  if (!existsSync10(benchmarkPath)) {
     diagnostics.push({ severity: "warning", message: "benchmark.json is missing" });
   }
   return diagnostics;
@@ -7309,8 +9060,8 @@ var resultsValidateCommand = command({
     })
   },
   handler: async ({ runDir }) => {
-    const resolvedDir = path13.resolve(runDir);
-    if (!existsSync9(resolvedDir) || !statSync4(resolvedDir).isDirectory()) {
+    const resolvedDir = path14.resolve(runDir);
+    if (!existsSync10(resolvedDir) || !statSync4(resolvedDir).isDirectory()) {
       console.error(`Error: '${runDir}' is not a directory`);
       process.exit(1);
     }
@@ -7343,6 +9094,7 @@ var resultsCommand = subcommands({
   description: "Inspect, export, and manage evaluation results",
   cmds: {
     export: resultsExportCommand,
+    report: resultsReportCommand,
     summary: resultsSummaryCommand,
     failures: resultsFailuresCommand,
     show: resultsShowCommand,
@@ -7351,15 +9103,15 @@ var resultsCommand = subcommands({
 });
 
 // src/commands/results/serve.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11, readdirSync as readdirSync4, statSync as statSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import path17 from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync12, readdirSync as readdirSync4, statSync as statSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import path18 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { Hono } from "hono";
 
 // src/commands/results/eval-runner.ts
 import { execFileSync, spawn } from "node:child_process";
-import { existsSync as existsSync10 } from "node:fs";
-import path14 from "node:path";
+import { existsSync as existsSync11 } from "node:fs";
+import path15 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var activeRuns = /* @__PURE__ */ new Map();
 function generateRunId() {
@@ -7381,16 +9133,16 @@ async function discoverTargetsInProject(cwd) {
   const repoRoot = await findRepoRoot(cwd) ?? cwd;
   let targetsFilePath;
   for (const candidate of TARGET_FILE_CANDIDATES) {
-    const fullPath = path14.join(cwd, candidate);
-    if (existsSync10(fullPath)) {
+    const fullPath = path15.join(cwd, candidate);
+    if (existsSync11(fullPath)) {
       targetsFilePath = fullPath;
       break;
     }
   }
   if (!targetsFilePath) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const fullPath = path14.join(repoRoot, candidate);
-      if (existsSync10(fullPath)) {
+      const fullPath = path15.join(repoRoot, candidate);
+      if (existsSync11(fullPath)) {
         targetsFilePath = fullPath;
         break;
       }
@@ -7439,19 +9191,19 @@ function buildCliPreview(args) {
 }
 function resolveCliPath(cwd) {
   const candidates = [
-    path14.join(cwd, "apps/cli/src/cli.ts"),
-    path14.join(cwd, "apps/cli/dist/cli.js")
+    path15.join(cwd, "apps/cli/src/cli.ts"),
+    path15.join(cwd, "apps/cli/dist/cli.js")
   ];
   for (const c4 of candidates) {
-    if (existsSync10(c4)) {
+    if (existsSync11(c4)) {
       return { binPath: "bun", args: [c4] };
     }
   }
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path14.dirname(fileURLToPath2(import.meta.url));
-  const fromSrc = path14.resolve(currentDir, "../../../cli.ts");
-  const fromDist = path14.resolve(currentDir, "../../cli.js");
-  if (existsSync10(fromSrc)) return { binPath: "bun", args: [fromSrc] };
-  if (existsSync10(fromDist)) return { binPath: "bun", args: [fromDist] };
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path15.dirname(fileURLToPath2(import.meta.url));
+  const fromSrc = path15.resolve(currentDir, "../../../cli.ts");
+  const fromDist = path15.resolve(currentDir, "../../cli.js");
+  if (existsSync11(fromSrc)) return { binPath: "bun", args: [fromSrc] };
+  if (existsSync11(fromDist)) return { binPath: "bun", args: [fromDist] };
   if (isCommandAvailable("agentv")) {
     return { binPath: "agentv", args: [] };
   }
@@ -7739,19 +9491,19 @@ Process error: ${err2.message}`;
 }
 
 // src/commands/results/run-tags.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import path15 from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync10, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import path16 from "node:path";
 var RUN_TAGS_FILENAME = "tags.json";
 var MAX_TAGS_PER_RUN = 20;
 var MAX_TAG_LENGTH = 60;
 function runTagsPath(manifestPath) {
-  return path15.join(path15.dirname(manifestPath), RUN_TAGS_FILENAME);
+  return path16.join(path16.dirname(manifestPath), RUN_TAGS_FILENAME);
 }
 function readRunTags(manifestPath) {
   const fp = runTagsPath(manifestPath);
-  if (!existsSync11(fp)) return void 0;
+  if (!existsSync12(fp)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync9(fp, "utf8"));
+    const parsed = JSON.parse(readFileSync10(fp, "utf8"));
     if (!parsed || typeof parsed !== "object") return void 0;
     const record = parsed;
     if (!Array.isArray(record.tags)) return void 0;
@@ -7777,13 +9529,13 @@ function writeRunTags(manifestPath, tags) {
     tags: cleaned,
     updated_at: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync3(runTagsPath(manifestPath), `${JSON.stringify(entry, null, 2)}
+  writeFileSync4(runTagsPath(manifestPath), `${JSON.stringify(entry, null, 2)}
 `, "utf8");
   return entry;
 }
 function deleteRunTags(manifestPath) {
   const fp = runTagsPath(manifestPath);
-  if (existsSync11(fp)) {
+  if (existsSync12(fp)) {
     unlinkSync2(fp);
   }
 }
@@ -7816,18 +9568,18 @@ function normalizeTags(tags) {
 }
 
 // src/commands/results/studio-config.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync2, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "node:fs";
-import path16 from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync3, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "node:fs";
+import path17 from "node:path";
 import { parse as parseYaml, stringify as stringifyYaml2 } from "yaml";
 var DEFAULTS = {
   threshold: DEFAULT_THRESHOLD
 };
 function loadStudioConfig(agentvDir) {
-  const configPath = path16.join(agentvDir, "config.yaml");
-  if (!existsSync12(configPath)) {
+  const configPath = path17.join(agentvDir, "config.yaml");
+  if (!existsSync13(configPath)) {
     return { ...DEFAULTS };
   }
-  const raw = readFileSync10(configPath, "utf-8");
+  const raw = readFileSync11(configPath, "utf-8");
   const parsed = parseYaml(raw);
   if (!parsed || typeof parsed !== "object") {
     return { ...DEFAULTS };
@@ -7849,13 +9601,13 @@ function loadStudioConfig(agentvDir) {
   };
 }
 function saveStudioConfig(agentvDir, config) {
-  if (!existsSync12(agentvDir)) {
-    mkdirSync2(agentvDir, { recursive: true });
+  if (!existsSync13(agentvDir)) {
+    mkdirSync3(agentvDir, { recursive: true });
   }
-  const configPath = path16.join(agentvDir, "config.yaml");
+  const configPath = path17.join(agentvDir, "config.yaml");
   let existing = {};
-  if (existsSync12(configPath)) {
-    const raw = readFileSync10(configPath, "utf-8");
+  if (existsSync13(configPath)) {
+    const raw = readFileSync11(configPath, "utf-8");
     const parsed = parseYaml(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       existing = parsed;
@@ -7871,14 +9623,14 @@ function saveStudioConfig(agentvDir, config) {
     existing.studio = { ...config };
   }
   const yamlStr = stringifyYaml2(existing);
-  writeFileSync4(configPath, yamlStr, "utf-8");
+  writeFileSync5(configPath, yamlStr, "utf-8");
 }
 
 // src/commands/results/serve.ts
 async function resolveSourceFile2(source, cwd) {
   if (source) {
     let resolved = resolveResultSourcePath(source, cwd);
-    if (!existsSync13(resolved)) {
+    if (!existsSync14(resolved)) {
       throw new Error(`Source file not found: ${resolved}`);
     }
     resolved = resolveRunManifestPath(resolved);
@@ -7886,7 +9638,7 @@ async function resolveSourceFile2(source, cwd) {
   }
   const cache = await loadRunCache(cwd);
   const cachedFile = cache ? resolveRunCacheFile(cache) : "";
-  if (cachedFile && existsSync13(cachedFile)) {
+  if (cachedFile && existsSync14(cachedFile)) {
     return cachedFile;
   }
   const metas = listResultFiles(cwd, 10);
@@ -7916,26 +9668,26 @@ function resolveDashboardMode(projectCount, options) {
   return { isMultiProject: projectCount > 1, showMultiWarning: false };
 }
 function feedbackPath(resultDir) {
-  return path17.join(resultDir, "feedback.json");
+  return path18.join(resultDir, "feedback.json");
 }
 function readFeedback(cwd) {
   const fp = feedbackPath(cwd);
-  if (!existsSync13(fp)) {
+  if (!existsSync14(fp)) {
     return { reviews: [] };
   }
   try {
-    return JSON.parse(readFileSync11(fp, "utf8"));
+    return JSON.parse(readFileSync12(fp, "utf8"));
   } catch (err2) {
     console.error(`Warning: could not parse ${fp}, starting fresh: ${err2.message}`);
     return { reviews: [] };
   }
 }
 function writeFeedback(cwd, data) {
-  writeFileSync5(feedbackPath(cwd), `${JSON.stringify(data, null, 2)}
+  writeFileSync6(feedbackPath(cwd), `${JSON.stringify(data, null, 2)}
 `, "utf8");
 }
 function buildFileTree(dirPath, relativeTo) {
-  if (!existsSync13(dirPath) || !statSync5(dirPath).isDirectory()) {
+  if (!existsSync14(dirPath) || !statSync5(dirPath).isDirectory()) {
     return [];
   }
   const entries2 = readdirSync4(dirPath, { withFileTypes: true });
@@ -7943,8 +9695,8 @@ function buildFileTree(dirPath, relativeTo) {
     if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
     return a.name.localeCompare(b.name);
   }).map((entry) => {
-    const fullPath = path17.join(dirPath, entry.name);
-    const relPath = path17.relative(relativeTo, fullPath);
+    const fullPath = path18.join(dirPath, entry.name);
+    const relPath = path18.relative(relativeTo, fullPath);
     if (entry.isDirectory()) {
       return {
         name: entry.name,
@@ -7957,7 +9709,7 @@ function buildFileTree(dirPath, relativeTo) {
   });
 }
 function inferLanguage(filePath) {
-  const ext = path17.extname(filePath).toLowerCase();
+  const ext = path18.extname(filePath).toLowerCase();
   const langMap = {
     ".json": "json",
     ".jsonl": "json",
@@ -8158,11 +9910,11 @@ async function handleEvalFiles(c4, { searchDir }) {
   const meta = await findRunById(searchDir, filename);
   if (!meta) return c4.json({ error: "Run not found" }, 404);
   try {
-    const content = readFileSync11(meta.path, "utf8");
+    const content = readFileSync12(meta.path, "utf8");
     const records = parseResultManifest(content);
     const record = records.find((r) => r.test_id === evalId);
     if (!record) return c4.json({ error: "Eval not found" }, 404);
-    const baseDir = path17.dirname(meta.path);
+    const baseDir = path18.dirname(meta.path);
     const knownPaths = [
       record.grading_path,
       record.timing_path,
@@ -8171,14 +9923,14 @@ async function handleEvalFiles(c4, { searchDir }) {
       record.response_path
     ].filter((p) => !!p);
     if (knownPaths.length === 0) return c4.json({ files: [] });
-    const artifactDirs = knownPaths.map((p) => path17.dirname(p));
+    const artifactDirs = knownPaths.map((p) => path18.dirname(p));
     let commonDir = artifactDirs[0];
     for (const dir of artifactDirs) {
       while (!dir.startsWith(commonDir)) {
-        commonDir = path17.dirname(commonDir);
+        commonDir = path18.dirname(commonDir);
       }
     }
-    const artifactAbsDir = path17.join(baseDir, commonDir);
+    const artifactAbsDir = path18.join(baseDir, commonDir);
     const files = buildFileTree(artifactAbsDir, baseDir);
     return c4.json({ files });
   } catch {
@@ -8193,16 +9945,16 @@ async function handleEvalFileContent(c4, { searchDir }) {
   const markerIdx = c4.req.path.indexOf(marker);
   const filePath = markerIdx >= 0 ? c4.req.path.slice(markerIdx + marker.length) : "";
   if (!filePath) return c4.json({ error: "No file path specified" }, 400);
-  const baseDir = path17.dirname(meta.path);
-  const absolutePath = path17.resolve(baseDir, filePath);
-  if (!absolutePath.startsWith(path17.resolve(baseDir) + path17.sep) && absolutePath !== path17.resolve(baseDir)) {
+  const baseDir = path18.dirname(meta.path);
+  const absolutePath = path18.resolve(baseDir, filePath);
+  if (!absolutePath.startsWith(path18.resolve(baseDir) + path18.sep) && absolutePath !== path18.resolve(baseDir)) {
     return c4.json({ error: "Path traversal not allowed" }, 403);
   }
-  if (!existsSync13(absolutePath) || !statSync5(absolutePath).isFile()) {
+  if (!existsSync14(absolutePath) || !statSync5(absolutePath).isFile()) {
     return c4.json({ error: "File not found" }, 404);
   }
   try {
-    const fileContent = readFileSync11(absolutePath, "utf8");
+    const fileContent = readFileSync12(absolutePath, "utf8");
     const language = inferLanguage(absolutePath);
     return c4.json({ content: fileContent, language });
   } catch {
@@ -8331,6 +10083,18 @@ async function handleCompare(c4, { searchDir, agentvDir }) {
     } catch {
     }
   }
+  const baselineTarget = c4.req.query("baseline") ?? "";
+  if (baselineTarget && !targetsSet.has(baselineTarget)) {
+    return c4.json({ error: `Baseline target "${baselineTarget}" does not exist in the data` }, 400);
+  }
+  const baselineScores = /* @__PURE__ */ new Map();
+  if (baselineTarget) {
+    for (const entry of cellMap.values()) {
+      if (entry.target === baselineTarget && entry.evalCount > 0) {
+        baselineScores.set(entry.experiment, entry.scoreSum / entry.evalCount);
+      }
+    }
+  }
   const cells = [...cellMap.values()].map((entry) => {
     const dedupMap = /* @__PURE__ */ new Map();
     for (const t of entry.tests) {
@@ -8338,15 +10102,24 @@ async function handleCompare(c4, { searchDir, agentvDir }) {
     }
     const dedupedTests = [...dedupMap.values()];
     const cappedTests = dedupedTests.slice(-MAX_TESTS_PER_CELL);
-    return {
+    const avgScore = entry.evalCount > 0 ? entry.scoreSum / entry.evalCount : 0;
+    const cell = {
       experiment: entry.experiment,
       target: entry.target,
       eval_count: entry.evalCount,
       passed_count: entry.passedCount,
       pass_rate: entry.evalCount > 0 ? entry.passedCount / entry.evalCount : 0,
-      avg_score: entry.evalCount > 0 ? entry.scoreSum / entry.evalCount : 0,
+      avg_score: avgScore,
       tests: cappedTests
     };
+    if (baselineTarget && entry.target !== baselineTarget) {
+      const baseAvg = baselineScores.get(entry.experiment);
+      if (baseAvg !== void 0) {
+        cell.delta = Math.round((avgScore - baseAvg) * 1e3) / 1e3;
+        cell.normalized_gain = baseAvg >= 1 ? null : Math.round((avgScore - baseAvg) / (1 - baseAvg) * 1e3) / 1e3;
+      }
+    }
+    return cell;
   });
   runEntries.sort((a, b) => b.started_at.localeCompare(a.started_at));
   return c4.json({
@@ -8394,13 +10167,13 @@ function handleConfig(c4, { agentvDir, searchDir }, options) {
   return c4.json({
     ...loadStudioConfig(agentvDir),
     read_only: options?.readOnly === true,
-    project_name: path17.basename(searchDir),
+    project_name: path18.basename(searchDir),
     multi_project_dashboard: options?.multiProjectDashboard === true
   });
 }
 function handleFeedbackRead(c4, { searchDir }) {
-  const resultsDir = path17.join(searchDir, ".agentv", "results");
-  return c4.json(readFeedback(existsSync13(resultsDir) ? resultsDir : searchDir));
+  const resultsDir = path18.join(searchDir, ".agentv", "results");
+  return c4.json(readFeedback(existsSync14(resultsDir) ? resultsDir : searchDir));
 }
 async function handleRunTagsPut(c4, { searchDir }) {
   const filename = c4.req.param("filename") ?? "";
@@ -8448,18 +10221,18 @@ async function handleRunTagsDelete(c4, { searchDir }) {
 }
 function createApp(results, resultDir, cwd, sourceFile, options) {
   const searchDir = cwd ?? resultDir;
-  const agentvDir = path17.join(searchDir, ".agentv");
+  const agentvDir = path18.join(searchDir, ".agentv");
   const defaultCtx = { searchDir, agentvDir };
   const readOnly = options?.readOnly === true;
   const app2 = new Hono();
   function withBenchmark(c4, handler) {
     const benchmark = getBenchmark(c4.req.param("benchmarkId") ?? "");
-    if (!benchmark || !existsSync13(benchmark.path)) {
+    if (!benchmark || !existsSync14(benchmark.path)) {
       return c4.json({ error: "Project not found" }, 404);
     }
     return handler(c4, {
       searchDir: benchmark.path,
-      agentvDir: path17.join(benchmark.path, ".agentv")
+      agentvDir: path18.join(benchmark.path, ".agentv")
     });
   }
   app2.post("/api/config", async (c4) => {
@@ -8786,20 +10559,20 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     { readOnly }
   );
   const studioDistPath = options?.studioDir ?? resolveStudioDistDir();
-  if (!studioDistPath || !existsSync13(path17.join(studioDistPath, "index.html"))) {
+  if (!studioDistPath || !existsSync14(path18.join(studioDistPath, "index.html"))) {
     throw new Error('Studio dist not found. Run "bun run build" in apps/studio/ to build the SPA.');
   }
   app2.get("/", (c4) => {
-    const indexPath = path17.join(studioDistPath, "index.html");
-    if (existsSync13(indexPath)) return c4.html(readFileSync11(indexPath, "utf8"));
+    const indexPath = path18.join(studioDistPath, "index.html");
+    if (existsSync14(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
     return c4.notFound();
   });
   app2.get("/assets/*", (c4) => {
     const assetPath = c4.req.path;
-    const filePath = path17.join(studioDistPath, assetPath);
-    if (!existsSync13(filePath)) return c4.notFound();
-    const content = readFileSync11(filePath);
-    const ext = path17.extname(filePath);
+    const filePath = path18.join(studioDistPath, assetPath);
+    if (!existsSync14(filePath)) return c4.notFound();
+    const content = readFileSync12(filePath);
+    const ext = path18.extname(filePath);
     const mimeTypes = {
       ".js": "application/javascript",
       ".css": "text/css",
@@ -8820,26 +10593,26 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
   });
   app2.get("*", (c4) => {
     if (c4.req.path.startsWith("/api/")) return c4.json({ error: "Not found" }, 404);
-    const indexPath = path17.join(studioDistPath, "index.html");
-    if (existsSync13(indexPath)) return c4.html(readFileSync11(indexPath, "utf8"));
+    const indexPath = path18.join(studioDistPath, "index.html");
+    if (existsSync14(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
     return c4.notFound();
   });
   return app2;
 }
 function resolveStudioDistDir() {
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path17.dirname(fileURLToPath3(import.meta.url));
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path18.dirname(fileURLToPath3(import.meta.url));
   const candidates = [
     // From src/commands/results/ → sibling apps/studio/dist
-    path17.resolve(currentDir, "../../../../studio/dist"),
+    path18.resolve(currentDir, "../../../../studio/dist"),
     // From dist/ → sibling apps/studio/dist (monorepo dev)
-    path17.resolve(currentDir, "../../studio/dist"),
+    path18.resolve(currentDir, "../../studio/dist"),
     // Bundled inside CLI dist (published package: dist/studio/)
-    path17.resolve(currentDir, "studio"),
+    path18.resolve(currentDir, "studio"),
     // From dist/ in monorepo root context
-    path17.resolve(currentDir, "../../../apps/studio/dist")
+    path18.resolve(currentDir, "../../../apps/studio/dist")
   ];
   for (const candidate of candidates) {
-    if (existsSync13(candidate) && existsSync13(path17.join(candidate, "index.html"))) {
+    if (existsSync14(candidate) && existsSync14(path18.join(candidate, "index.html"))) {
       return candidate;
     }
   }
@@ -8945,7 +10718,7 @@ Discovered ${discovered.length} project(s).`);
       } else {
         const cache = await loadRunCache(cwd);
         const cachedFile = cache ? resolveRunCacheFile(cache) : "";
-        if (cachedFile && existsSync13(cachedFile)) {
+        if (cachedFile && existsSync14(cachedFile)) {
           sourceFile = cachedFile;
           results = loadManifestResults(cachedFile);
         } else {
@@ -8956,7 +10729,7 @@ Discovered ${discovered.length} project(s).`);
           }
         }
       }
-      const resultDir = sourceFile ? path17.dirname(path17.resolve(sourceFile)) : cwd;
+      const resultDir = sourceFile ? path18.dirname(path18.resolve(sourceFile)) : cwd;
       const app2 = createApp(results, resultDir, cwd, sourceFile, {
         readOnly,
         multiProjectDashboard: isMultiProject
@@ -9080,8 +10853,8 @@ var selfCommand = subcommands({
 });
 
 // src/commands/transpile/index.ts
-import { writeFileSync as writeFileSync6 } from "node:fs";
-import path18 from "node:path";
+import { writeFileSync as writeFileSync7 } from "node:fs";
+import path19 from "node:path";
 var transpileCommand = command({
   name: "transpile",
   description: "Convert an EVAL.yaml file to Agent Skills evals.json format",
@@ -9105,7 +10878,7 @@ var transpileCommand = command({
   handler: async ({ input, outDir, stdout }) => {
     let result;
     try {
-      result = transpileEvalYamlFile(path18.resolve(input));
+      result = transpileEvalYamlFile(path19.resolve(input));
     } catch (error) {
       console.error(`Error: ${error.message}`);
       process.exit(1);
@@ -9129,12 +10902,12 @@ var transpileCommand = command({
       process.stdout.write("\n");
       return;
     }
-    const outputDir = outDir ? path18.resolve(outDir) : path18.dirname(path18.resolve(input));
+    const outputDir = outDir ? path19.resolve(outDir) : path19.dirname(path19.resolve(input));
     const fileNames = getOutputFilenames(result);
     for (const [skill, evalsJson] of result.files) {
       const fileName = fileNames.get(skill) ?? "evals.json";
-      const outputPath = path18.join(outputDir, fileName);
-      writeFileSync6(outputPath, `${JSON.stringify(evalsJson, null, 2)}
+      const outputPath = path19.join(outputDir, fileName);
+      writeFileSync7(outputPath, `${JSON.stringify(evalsJson, null, 2)}
 `);
       console.log(`Transpiled to ${outputPath}`);
     }
@@ -9142,7 +10915,7 @@ var transpileCommand = command({
 });
 
 // src/commands/trend/index.ts
-import path19 from "node:path";
+import path20 from "node:path";
 var colors2 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -9192,7 +10965,7 @@ function colorizeSlope(value) {
 }
 function ensureTrendIndexPath(source, cwd) {
   const resolved = resolveResultSourcePath(source, cwd);
-  if (path19.basename(resolved) !== RESULT_INDEX_FILENAME) {
+  if (path20.basename(resolved) !== RESULT_INDEX_FILENAME) {
     throw new Error(
       `Unsupported result source for trend: ${source}. Use a run workspace directory or ${RESULT_INDEX_FILENAME} manifest.`
     );
@@ -9212,7 +10985,7 @@ function resolveTrendSources(cwd, sources, last) {
   if (last < 2) {
     throw new Error("--last must be at least 2");
   }
-  const metas = listResultFiles(cwd).filter((meta) => path19.basename(meta.path) === RESULT_INDEX_FILENAME).slice(0, last);
+  const metas = listResultFiles(cwd).filter((meta) => path20.basename(meta.path) === RESULT_INDEX_FILENAME).slice(0, last);
   if (metas.length < 2) {
     throw new Error(
       "Trend analysis requires at least 2 canonical run workspaces in .agentv/results/runs/"
@@ -9227,10 +11000,10 @@ function getRunLabel(sourcePath, timestamp) {
   if (timestamp) {
     return timestamp;
   }
-  return path19.basename(path19.dirname(sourcePath));
+  return path20.basename(path20.dirname(sourcePath));
 }
 function getRunSortKey(sourcePath, timestamp) {
-  return timestamp ?? path19.basename(path19.dirname(sourcePath));
+  return timestamp ?? path20.basename(path20.dirname(sourcePath));
 }
 function mean2(values) {
   return values.reduce((sum, value) => sum + value, 0) / values.length;
@@ -9485,7 +11258,7 @@ var trendCommand = command({
 });
 
 // src/commands/trim/index.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "node:fs";
 var trimCommand = command({
   name: "trim",
   description: "Trim evaluation results for baseline storage (strips debug/audit fields)",
@@ -9504,7 +11277,7 @@ var trimCommand = command({
   },
   handler: async ({ input, out }) => {
     try {
-      const content = readFileSync12(input, "utf8");
+      const content = readFileSync13(input, "utf8");
       const lines = content.trim().split("\n").filter((line) => line.trim());
       const trimmedLines = lines.map((line) => {
         const record = JSON.parse(line);
@@ -9516,7 +11289,7 @@ var trimCommand = command({
       const output = `${trimmedLines.join("\n")}
 `;
       if (out) {
-        writeFileSync7(out, output, "utf8");
+        writeFileSync8(out, output, "utf8");
         console.error(`Trimmed ${lines.length} record(s) \u2192 ${out}`);
       } else {
         process.stdout.write(output);
@@ -9611,7 +11384,7 @@ function isTTY() {
 // src/commands/validate/validate-files.ts
 import { constants } from "node:fs";
 import { access, readdir as readdir4, stat } from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 import fg2 from "fast-glob";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
@@ -9626,7 +11399,7 @@ async function validateFiles(paths) {
   };
 }
 async function validateSingleFile(filePath) {
-  const absolutePath = path20.resolve(filePath);
+  const absolutePath = path21.resolve(filePath);
   const fileType = await detectFileType(absolutePath);
   let result;
   if (fileType === "eval") {
@@ -9670,7 +11443,7 @@ async function validateSingleFile(filePath) {
 async function expandPaths(paths) {
   const expanded = /* @__PURE__ */ new Set();
   for (const inputPath of paths) {
-    const absolutePath = path20.resolve(inputPath);
+    const absolutePath = path21.resolve(inputPath);
     try {
       await access(absolutePath, constants.F_OK);
       const stats = await stat(absolutePath);
@@ -9698,7 +11471,7 @@ async function expandPaths(paths) {
     if (yamlMatches.length === 0) {
       console.warn(`Warning: No YAML files matched pattern: ${inputPath}`);
     }
-    for (const f of yamlMatches) expanded.add(path20.normalize(f));
+    for (const f of yamlMatches) expanded.add(path21.normalize(f));
   }
   const sorted = Array.from(expanded);
   sorted.sort();
@@ -9709,7 +11482,7 @@ async function findYamlFiles(dirPath) {
   try {
     const entries2 = await readdir4(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path20.join(dirPath, entry.name);
+      const fullPath = path21.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -9726,11 +11499,11 @@ async function findYamlFiles(dirPath) {
   return results;
 }
 function isYamlFile(filePath) {
-  const ext = path20.extname(filePath).toLowerCase();
+  const ext = path21.extname(filePath).toLowerCase();
   return ext === ".yaml" || ext === ".yml";
 }
 function isEvalYamlFile(filePath) {
-  const lower = path20.basename(filePath).toLowerCase();
+  const lower = path21.basename(filePath).toLowerCase();
   return lower.endsWith(".eval.yaml") || lower.endsWith(".eval.yml");
 }
 
@@ -9785,9 +11558,9 @@ var validateCommand = command({
 });
 
 // src/commands/workspace/clean.ts
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 import { readFile as readFile6, readdir as readdir5, rm } from "node:fs/promises";
-import path21 from "node:path";
+import path22 from "node:path";
 async function confirm(message) {
   const readline2 = await import("node:readline");
   const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
@@ -9814,7 +11587,7 @@ var cleanCommand = command({
   },
   handler: async ({ repo, force }) => {
     const poolRoot = getWorkspacePoolRoot();
-    if (!existsSync14(poolRoot)) {
+    if (!existsSync15(poolRoot)) {
       console.log("No workspace pool entries found.");
       return;
     }
@@ -9823,8 +11596,8 @@ var cleanCommand = command({
       const poolDirs = entries2.filter((e) => e.isDirectory());
       const matchingDirs = [];
       for (const dir of poolDirs) {
-        const poolDir = path21.join(poolRoot, dir.name);
-        const metadataPath = path21.join(poolDir, "metadata.json");
+        const poolDir = path22.join(poolRoot, dir.name);
+        const metadataPath = path22.join(poolDir, "metadata.json");
         try {
           const raw = await readFile6(metadataPath, "utf-8");
           const metadata = JSON.parse(raw);
@@ -9855,7 +11628,7 @@ var cleanCommand = command({
       }
       for (const dir of matchingDirs) {
         await rm(dir, { recursive: true, force: true });
-        console.log(`Removed: ${path21.basename(dir).slice(0, 12)}...`);
+        console.log(`Removed: ${path22.basename(dir).slice(0, 12)}...`);
       }
       console.log("Done.");
     } else {
@@ -9873,7 +11646,7 @@ var cleanCommand = command({
 });
 
 // src/commands/workspace/deps.ts
-import path22 from "node:path";
+import path23 from "node:path";
 var depsCommand = command({
   name: "deps",
   description: "Scan eval files and list git repo dependencies needed by workspaces",
@@ -9897,7 +11670,7 @@ var depsCommand = command({
     const resolvedPaths = await resolveEvalPaths(evalPaths, cwd);
     const result = await scanRepoDeps(resolvedPaths);
     for (const err2 of result.errors) {
-      console.error(`warning: ${path22.relative(cwd, err2.file)}: ${err2.message}`);
+      console.error(`warning: ${path23.relative(cwd, err2.file)}: ${err2.message}`);
     }
     const output = {
       repos: result.repos.map((r) => ({
@@ -9905,7 +11678,7 @@ var depsCommand = command({
         ...r.ref !== void 0 && { ref: r.ref },
         ...r.clone !== void 0 && { clone: r.clone },
         ...r.checkout !== void 0 && { checkout: r.checkout },
-        ...usedBy && { used_by: r.usedBy.map((p) => path22.relative(cwd, p)) }
+        ...usedBy && { used_by: r.usedBy.map((p) => path23.relative(cwd, p)) }
       }))
     };
     console.log(JSON.stringify(output, null, 2));
@@ -9913,15 +11686,15 @@ var depsCommand = command({
 });
 
 // src/commands/workspace/list.ts
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync16 } from "node:fs";
 import { readFile as readFile7, readdir as readdir6, stat as stat2 } from "node:fs/promises";
-import path23 from "node:path";
+import path24 from "node:path";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
     const entries2 = await readdir6(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path23.join(dirPath, entry.name);
+      const fullPath = path24.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(fullPath);
       } else {
@@ -9945,7 +11718,7 @@ var listCommand = command({
   args: {},
   handler: async () => {
     const poolRoot = getWorkspacePoolRoot();
-    if (!existsSync15(poolRoot)) {
+    if (!existsSync16(poolRoot)) {
       console.log("No workspace pool entries found.");
       return;
     }
@@ -9956,11 +11729,11 @@ var listCommand = command({
       return;
     }
     for (const dir of poolDirs) {
-      const poolDir = path23.join(poolRoot, dir.name);
+      const poolDir = path24.join(poolRoot, dir.name);
       const fingerprint = dir.name;
       const poolEntries = await readdir6(poolDir, { withFileTypes: true });
       const slots = poolEntries.filter((e) => e.isDirectory() && e.name.startsWith("slot-"));
-      const metadataPath = path23.join(poolDir, "metadata.json");
+      const metadataPath = path24.join(poolDir, "metadata.json");
       let metadata = null;
       try {
         const raw = await readFile7(metadataPath, "utf-8");
@@ -10007,8 +11780,8 @@ var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var CONFIG_DIR = getAgentvConfigDir();
 var CACHE_FILE = "version-check.json";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/agentv/latest";
-async function getCachedUpdateInfo(path24) {
-  const filePath = path24 ?? join5(CONFIG_DIR, CACHE_FILE);
+async function getCachedUpdateInfo(path25) {
+  const filePath = path25 ?? join5(CONFIG_DIR, CACHE_FILE);
   try {
     const raw = await readFile8(filePath, "utf-8");
     const data = JSON.parse(raw);
@@ -10169,4 +11942,4 @@ export {
   preprocessArgv,
   runCli
 };
-//# sourceMappingURL=chunk-TA2KF32T.js.map
+//# sourceMappingURL=chunk-MQCJCM3I.js.map