agentv 3.10.2 → 3.11.0

package/dist/{chunk-6UE665XI.js → chunk-ETMDLQ72.js}

@@ -1,6 +1,7 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 import {
   HtmlWriter,
+  buildAggregateGradingArtifact,
   buildBenchmarkArtifact,
   buildGradingArtifact,
   buildTimingArtifact,
@@ -10,6 +11,7 @@ import {
   package_default,
   parseJsonlResults,
   resolveEvalPaths,
+  resolveRunCacheFile,
   runEvalCommand,
   selectTarget,
   toSnakeCaseDeep,
@@ -17,7 +19,7 @@ import {
   validateEvalFile,
   validateFileReferences,
   validateTargetsFile
-} from "./chunk-F7LAJMTO.js";
+} from "./chunk-JEW3FEO7.js";
 import {
   createBuiltinRegistry,
   createProvider,
@@ -35,7 +37,7 @@ import {
   toSnakeCaseDeep as toSnakeCaseDeep2,
   transpileEvalYamlFile,
   trimBaselineResult
-} from "./chunk-KGK5NUFG.js";
+} from "./chunk-EZGWZVVK.js";
 import {
   __commonJS,
   __esm,
@@ -3711,7 +3713,7 @@ async function listPromptEvalTestIds(evalPath) {
 async function getPromptEvalInput(evalPath, testId) {
   const repoRoot = await findRepoRoot(process.cwd());
   const evalCase = await loadTestById(evalPath, repoRoot, testId);
-  const fileMap = buildFileMap(evalCase.input_segments, evalCase.file_paths);
+  const fileMap = buildFileMap(evalCase.input, evalCase.file_paths);
   return {
     test_id: evalCase.id,
     input: resolveMessages(evalCase.input, fileMap),
@@ -3732,7 +3734,7 @@ async function getPromptEvalExpectedOutput(evalPath, testId) {
 async function getPromptEvalGradingBrief(evalPath, testId) {
   const repoRoot = await findRepoRoot(process.cwd());
   const evalCase = await loadTestById(evalPath, repoRoot, testId);
-  const fileMap = buildFileMap(evalCase.input_segments, evalCase.file_paths);
+  const fileMap = buildFileMap(evalCase.input, evalCase.file_paths);
   const resolvedInput = resolveMessages(evalCase.input, fileMap);
   const lines = [];
   const inputText = extractTextFromMessages(resolvedInput);
@@ -3795,11 +3797,14 @@ function extractTextFromMessages(messages) {
   }
   return "";
 }
-function buildFileMap(inputSegments, allFilePaths) {
+function buildFileMap(inputMessages, allFilePaths) {
   const map = /* @__PURE__ */ new Map();
-  for (const segment of inputSegments) {
-    if (segment.type === "file" && typeof segment.path === "string" && typeof segment.resolvedPath === "string") {
-      map.set(segment.path, segment.resolvedPath);
+  for (const message of inputMessages) {
+    if (!Array.isArray(message.content)) {
+      continue;
+    }
+    for (const segment of message.content) {
+      registerResolvedFileSegment(map, segment);
     }
   }
   return {
@@ -3813,6 +3818,17 @@ function buildFileMap(inputSegments, allFilePaths) {
     }
   };
 }
+function registerResolvedFileSegment(map, segment) {
+  if (segment.type !== "file" || typeof segment.resolvedPath !== "string") {
+    return;
+  }
+  const aliases = [segment.value, segment.path].filter(
+    (alias) => typeof alias === "string"
+  );
+  for (const alias of aliases) {
+    map.set(alias, segment.resolvedPath);
+  }
+}
 function resolveMessages(messages, fileMap) {
   return messages.map((message) => {
     if (typeof message.content === "string") {
@@ -4187,7 +4203,7 @@ var evalRunCommand = command({
   },
   handler: async (args) => {
     if (args.evalPaths.length === 0 && process.stdin.isTTY) {
-      const { launchInteractiveWizard } = await import("./interactive-EO6AR2R3.js");
+      const { launchInteractiveWizard } = await import("./interactive-AD4PRYDN.js");
       await launchInteractiveWizard();
       return;
     }
@@ -4620,37 +4636,65 @@ function loadResultFile(filePath) {
   });
 }
 function listResultFiles(cwd, limit) {
-  const resultsDir = path7.join(cwd, ".agentv", "results");
-  let files;
+  const baseDir = path7.join(cwd, ".agentv", "results");
+  const rawDir = path7.join(baseDir, "raw");
+  const files = [];
   try {
-    files = readdirSync2(resultsDir).filter((f) => f.endsWith(".jsonl"));
+    const entries2 = readdirSync2(rawDir, { withFileTypes: true });
+    for (const entry of entries2) {
+      if (entry.isDirectory()) {
+        const jsonlPath = path7.join(rawDir, entry.name, "results.jsonl");
+        try {
+          statSync2(jsonlPath);
+          files.push({ filePath: jsonlPath, displayName: entry.name });
+        } catch {
+        }
+      }
+    }
+    for (const entry of entries2) {
+      if (!entry.isDirectory() && entry.name.endsWith(".jsonl")) {
+        files.push({ filePath: path7.join(rawDir, entry.name), displayName: entry.name });
+      }
+    }
   } catch {
-    return [];
   }
-  files.sort((a, b) => b.localeCompare(a));
-  if (limit !== void 0 && limit > 0) {
-    files = files.slice(0, limit);
+  try {
+    const entries2 = readdirSync2(baseDir).filter((f) => f.endsWith(".jsonl"));
+    for (const entry of entries2) {
+      files.push({ filePath: path7.join(baseDir, entry), displayName: entry });
+    }
+  } catch {
   }
+  const seen = /* @__PURE__ */ new Set();
+  const uniqueFiles = [];
+  for (const file of files) {
+    const key = file.displayName.replace(/\.jsonl$/, "");
+    if (!seen.has(key)) {
+      seen.add(key);
+      uniqueFiles.push(file);
+    }
+  }
+  uniqueFiles.sort((a, b) => b.displayName.localeCompare(a.displayName));
+  const limited = limit !== void 0 && limit > 0 ? uniqueFiles.slice(0, limit) : uniqueFiles;
   const metas = [];
-  for (const filename of files) {
-    const filePath = path7.join(resultsDir, filename);
+  for (const { filePath, displayName } of limited) {
     try {
-      const stat3 = statSync2(filePath);
+      const fileStat = statSync2(filePath);
       const results = loadResultFile(filePath);
       const testCount = results.length;
       const passCount = results.filter((r) => r.score >= 1).length;
       const passRate = testCount > 0 ? passCount / testCount : 0;
       const avgScore = testCount > 0 ? results.reduce((sum, r) => sum + r.score, 0) / testCount : 0;
-      const filenameTimestamp = extractTimestampFromFilename(filename);
+      const filenameTimestamp = extractTimestampFromFilename(displayName);
       const timestamp = filenameTimestamp ?? results[0]?.timestamp ?? "unknown";
       metas.push({
         path: filePath,
-        filename,
+        filename: displayName,
         timestamp,
         testCount,
         passRate,
         avgScore,
-        sizeBytes: stat3.size
+        sizeBytes: fileStat.size
       });
     } catch {
     }
@@ -4704,6 +4748,12 @@ function exportResults(sourceFile, content, outputDir) {
   const timing = buildTimingArtifact(patched);
   writeFileSync3(path8.join(outputDir, "timing.json"), `${JSON.stringify(timing, null, 2)}
 `);
+  const aggregateGrading = buildAggregateGradingArtifact(patched);
+  writeFileSync3(
+    path8.join(outputDir, "grading.json"),
+    `${JSON.stringify(aggregateGrading, null, 2)}
+`
+  );
   const gradingDir = path8.join(outputDir, "grading");
   mkdirSync2(gradingDir, { recursive: true });
   for (const result of patched) {
@@ -4717,18 +4767,46 @@ function exportResults(sourceFile, content, outputDir) {
   for (const result of patched) {
     if (result.output && result.output.length > 0) {
       const id = safeTestId(result);
-      writeFileSync3(path8.join(outputsDir, `${id}.txt`), JSON.stringify(result.output, null, 2));
+      const md = formatOutputMarkdown(result.output);
+      writeFileSync3(path8.join(outputsDir, `${id}.md`), md);
+    }
+  }
+  const inputsDir = path8.join(outputDir, "inputs");
+  mkdirSync2(inputsDir, { recursive: true });
+  for (const result of patched) {
+    const id = safeTestId(result);
+    const input = extractInput(result);
+    if (input) {
+      writeFileSync3(path8.join(inputsDir, `${id}.md`), input);
     }
   }
 }
+function formatOutputMarkdown(output) {
+  return output.map((msg) => `@[${msg.role}]:
+${String(msg.content ?? "")}`).join("\n\n");
+}
+function extractInput(result) {
+  const input = result.input;
+  if (!input) return null;
+  if (typeof input === "string") return input;
+  if (Array.isArray(input) && input.length > 0) {
+    return formatOutputMarkdown(input);
+  }
+  return null;
+}
 function safeTestId(result) {
   const raw = result.testId ?? result.evalId ?? "unknown";
   return String(raw).replace(/[/\\:*?"<>|]/g, "_");
 }
 function deriveOutputDir(cwd, sourceFile) {
+  const parentDir = path8.basename(path8.dirname(sourceFile));
+  if (parentDir.startsWith("eval_")) {
+    const dirName2 = parentDir.slice(5);
+    return path8.join(cwd, ".agentv", "results", "export", dirName2);
+  }
   const basename = path8.basename(sourceFile, ".jsonl");
   const dirName = basename.startsWith("eval_") ? basename.slice(5) : basename;
-  return path8.join(cwd, ".agentv", "results", dirName);
+  return path8.join(cwd, ".agentv", "results", "export", dirName);
 }
 var resultsExportCommand = command({
   name: "export",
@@ -4743,7 +4821,7 @@ var resultsExportCommand = command({
       type: optional(string),
       long: "out",
       short: "o",
-      description: "Output directory (defaults to .agentv/results/<run-timestamp>/)"
+      description: "Output directory (defaults to .agentv/results/export/<run-timestamp>/)"
     }),
     dir: option({
       type: optional(string),
@@ -4760,8 +4838,9 @@ var resultsExportCommand = command({
         sourceFile = path8.isAbsolute(source) ? source : path8.resolve(cwd, source);
       } else {
         const cache = await loadRunCache(cwd);
-        if (cache && existsSync2(cache.lastResultFile)) {
-          sourceFile = cache.lastResultFile;
+        const cachedFile = cache ? resolveRunCacheFile(cache) : "";
+        if (cachedFile && existsSync2(cachedFile)) {
+          sourceFile = cachedFile;
         } else {
           const metas = listResultFiles(cwd, 1);
           if (metas.length === 0) {
@@ -4788,12 +4867,1013 @@ var resultsExportCommand = command({
   }
 });
 
+// src/commands/results/shared.ts
+import { existsSync as existsSync3, readFileSync as readFileSync7 } from "node:fs";
+import path9 from "node:path";
+var sourceArg = positional({
+  type: optional(string),
+  displayName: "source",
+  description: "JSONL result file (defaults to most recent in .agentv/results/)"
+});
+async function resolveSourceFile(source, cwd) {
+  let sourceFile;
+  if (source) {
+    sourceFile = path9.isAbsolute(source) ? source : path9.resolve(cwd, source);
+    if (!existsSync3(sourceFile)) {
+      console.error(`Error: File not found: ${sourceFile}`);
+      process.exit(1);
+    }
+  } else {
+    const cache = await loadRunCache(cwd);
+    const cachedFile = cache ? resolveRunCacheFile(cache) : "";
+    if (cachedFile && existsSync3(cachedFile)) {
+      sourceFile = cachedFile;
+    } else {
+      const metas = listResultFiles(cwd, 1);
+      if (metas.length === 0) {
+        console.error("Error: No result files found in .agentv/results/");
+        console.error("Run an evaluation first: agentv eval <eval-file>");
+        process.exit(1);
+      }
+      sourceFile = metas[0].path;
+    }
+  }
+  const content = readFileSync7(sourceFile, "utf8");
+  return { sourceFile, content };
+}
+async function loadResults(source, cwd) {
+  const { sourceFile, content } = await resolveSourceFile(source, cwd);
+  const results = parseJsonlResults(content);
+  if (results.length === 0) {
+    console.error(`No results found in ${sourceFile}`);
+    process.exit(1);
+  }
+  return { results: patchTestIds(results), sourceFile };
+}
+function patchTestIds(results) {
+  return results.map((r) => {
+    if (!r.testId && r.evalId) {
+      return { ...r, testId: String(r.evalId) };
+    }
+    return r;
+  });
+}
+
+// src/commands/results/failures.ts
+function formatFailures(results) {
+  return results.filter((r) => r.score < 1).map((r) => {
+    let assertions = (r.assertions ?? []).map((a) => ({
+      text: a.text,
+      passed: a.passed,
+      evidence: a.evidence
+    }));
+    if (assertions.length === 0 && r.scores) {
+      assertions = r.scores.flatMap(
+        (s) => (s.assertions ?? []).map((a) => ({
+          text: a.text,
+          passed: a.passed,
+          evidence: a.evidence
+        }))
+      );
+    }
+    return { test_id: r.testId, score: r.score, assertions };
+  });
+}
+var resultsFailuresCommand = command({
+  name: "failures",
+  description: "Show only failed tests with assertion evidence",
+  args: {
+    source: sourceArg,
+    dir: option({
+      type: optional(string),
+      long: "dir",
+      short: "d",
+      description: "Working directory (default: current directory)"
+    })
+  },
+  handler: async ({ source, dir }) => {
+    const cwd = dir ?? process.cwd();
+    try {
+      const { results } = await loadResults(source, cwd);
+      console.log(JSON.stringify(formatFailures(results), null, 2));
+    } 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);
+}
+function formatInput(result) {
+  const input = result.input;
+  if (!input) return "(no input)";
+  if (typeof input === "string") return input;
+  if (Array.isArray(input)) {
+    return input.map((msg) => String(msg.content ?? "")).join("\n");
+  }
+  return "(no input)";
+}
+function formatOutput(result) {
+  if (!result.output || result.output.length === 0) return "(no output)";
+  return result.output.map((msg) => String(msg.content ?? "")).join("\n");
+}
+function formatShow(result) {
+  const usage = result.tokenUsage;
+  let allAssertions = (result.assertions ?? []).map((a) => ({
+    text: a.text,
+    passed: a.passed,
+    evidence: a.evidence
+  }));
+  if (allAssertions.length === 0 && result.scores) {
+    allAssertions = result.scores.flatMap(
+      (s) => (s.assertions ?? []).map((a) => ({
+        text: a.text,
+        passed: a.passed,
+        evidence: a.evidence
+      }))
+    );
+  }
+  const totalTokens = usage ? (usage.input ?? 0) + (usage.output ?? 0) : void 0;
+  return {
+    test_id: result.testId,
+    score: result.score,
+    duration_ms: result.durationMs,
+    total_tokens: totalTokens,
+    input: formatInput(result),
+    assertions: allAssertions,
+    response: formatOutput(result)
+  };
+}
+var resultsShowCommand = command({
+  name: "show",
+  description: "Show full detail for a single test result",
+  args: {
+    source: sourceArg,
+    testId: option({
+      type: string,
+      long: "test-id",
+      short: "t",
+      description: "Test ID to display"
+    }),
+    dir: option({
+      type: optional(string),
+      long: "dir",
+      short: "d",
+      description: "Working directory (default: current directory)"
+    })
+  },
+  handler: async ({ source, testId, dir }) => {
+    const cwd = dir ?? process.cwd();
+    try {
+      const { results } = await loadResults(source, cwd);
+      const result = findResult(results, testId);
+      if (!result) {
+        const available = results.map((r) => r.testId).join(", ");
+        console.error(`Error: Test ID "${testId}" not found.`);
+        console.error(`Available test IDs: ${available}`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(formatShow(result), null, 2));
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/results/summary.ts
+import { existsSync as existsSync4, readFileSync as readFileSync8 } from "node:fs";
+function formatSummary(results, grading) {
+  const total = results.length;
+  let passed;
+  let failed;
+  let passRate;
+  if (grading) {
+    passed = grading.summary.passed;
+    failed = grading.summary.failed;
+    passRate = grading.summary.pass_rate;
+  } else {
+    passed = results.filter((r) => r.score >= 1).length;
+    failed = total - passed;
+    passRate = total > 0 ? Math.round(results.reduce((s, r) => s + r.score, 0) / total * 1e3) / 1e3 : 0;
+  }
+  let totalDurationMs = 0;
+  let totalTokens = 0;
+  for (const r of results) {
+    if (r.durationMs != null) totalDurationMs += r.durationMs;
+    const usage = r.tokenUsage;
+    if (usage) totalTokens += (usage.input ?? 0) + (usage.output ?? 0);
+  }
+  const failedTestIds = results.filter((r) => r.score < 1).map((r) => r.testId);
+  return {
+    total,
+    passed,
+    failed,
+    pass_rate: { mean: passRate },
+    total_duration_ms: totalDurationMs,
+    total_tokens: totalTokens,
+    failed_test_ids: failedTestIds
+  };
+}
+var resultsSummaryCommand = command({
+  name: "summary",
+  description: "Show compact pass/fail summary of eval results",
+  args: {
+    source: sourceArg,
+    dir: option({
+      type: optional(string),
+      long: "dir",
+      short: "d",
+      description: "Working directory (default: current directory)"
+    })
+  },
+  handler: async ({ source, dir }) => {
+    const cwd = dir ?? process.cwd();
+    try {
+      const { results, sourceFile } = await loadResults(source, cwd);
+      let grading;
+      const gradingPath = sourceFile.replace(/\.jsonl$/, ".grading.json");
+      if (existsSync4(gradingPath)) {
+        try {
+          grading = JSON.parse(readFileSync8(gradingPath, "utf8"));
+        } catch {
+        }
+      }
+      console.log(JSON.stringify(formatSummary(results, grading), null, 2));
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  }
+});
+
 // src/commands/results/index.ts
 var resultsCommand = subcommands({
   name: "results",
   description: "Inspect, export, and manage evaluation results",
   cmds: {
-    export: resultsExportCommand
+    export: resultsExportCommand,
+    summary: resultsSummaryCommand,
+    failures: resultsFailuresCommand,
+    show: resultsShowCommand
+  }
+});
+
+// src/commands/results/serve.ts
+import { existsSync as existsSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "node:fs";
+import path10 from "node:path";
+import { Hono } from "hono";
+async function resolveSourceFile2(source, cwd) {
+  if (source) {
+    const resolved = path10.isAbsolute(source) ? source : path10.resolve(cwd, source);
+    if (!existsSync5(resolved)) {
+      throw new Error(`Source file not found: ${resolved}`);
+    }
+    return resolved;
+  }
+  const cache = await loadRunCache(cwd);
+  const cachedFile = cache ? resolveRunCacheFile(cache) : "";
+  if (cachedFile && existsSync5(cachedFile)) {
+    return cachedFile;
+  }
+  const metas = listResultFiles(cwd, 10);
+  if (metas.length === 0) {
+    throw new Error(
+      "No result files found in .agentv/results/\nRun an evaluation first: agentv eval <eval-file>"
+    );
+  }
+  if (metas.length > 1) {
+    console.log("Available result files:");
+    for (const m of metas) {
+      console.log(`  ${m.path}`);
+    }
+    console.log(`
+Serving most recent: ${metas[0].path}
+`);
+  }
+  return metas[0].path;
+}
+function loadResults2(content) {
+  const results = parseJsonlResults(content);
+  if (results.length === 0) {
+    throw new Error("No valid results found in JSONL content");
+  }
+  return results.map((r) => {
+    if (!r.testId && r.evalId) {
+      return { ...r, testId: String(r.evalId) };
+    }
+    return r;
+  });
+}
+function feedbackPath(cwd) {
+  return path10.join(cwd, "feedback.json");
+}
+function readFeedback(cwd) {
+  const fp = feedbackPath(cwd);
+  if (!existsSync5(fp)) {
+    return { reviews: [] };
+  }
+  try {
+    return JSON.parse(readFileSync9(fp, "utf8"));
+  } catch (err2) {
+    console.error(`Warning: could not parse ${fp}, starting fresh: ${err2.message}`);
+    return { reviews: [] };
+  }
+}
+function writeFeedback(cwd, data) {
+  writeFileSync4(feedbackPath(cwd), `${JSON.stringify(data, null, 2)}
+`, "utf8");
+}
+function createApp(results, cwd) {
+  const app2 = new Hono();
+  app2.get("/", (c3) => {
+    return c3.html(generateServeHtml(results));
+  });
+  app2.get("/api/feedback", (c3) => {
+    const data = readFeedback(cwd);
+    return c3.json(data);
+  });
+  app2.post("/api/feedback", async (c3) => {
+    let body;
+    try {
+      body = await c3.req.json();
+    } catch {
+      return c3.json({ error: "Invalid JSON" }, 400);
+    }
+    if (!body || typeof body !== "object") {
+      return c3.json({ error: "Invalid payload" }, 400);
+    }
+    const payload = body;
+    if (!Array.isArray(payload.reviews)) {
+      return c3.json({ error: "Missing reviews array" }, 400);
+    }
+    const incoming = payload.reviews;
+    for (const review of incoming) {
+      if (typeof review.test_id !== "string" || typeof review.comment !== "string") {
+        return c3.json({ error: "Each review must have test_id and comment strings" }, 400);
+      }
+    }
+    const existing = readFeedback(cwd);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const review of incoming) {
+      const newReview = {
+        test_id: review.test_id,
+        comment: review.comment,
+        updated_at: now
+      };
+      const idx = existing.reviews.findIndex((r) => r.test_id === newReview.test_id);
+      if (idx >= 0) {
+        existing.reviews[idx] = newReview;
+      } else {
+        existing.reviews.push(newReview);
+      }
+    }
+    writeFeedback(cwd, existing);
+    return c3.json(existing);
+  });
+  return app2;
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function generateServeHtml(results) {
+  const lightResults = results.map((r) => {
+    const { requests, trace, ...rest } = r;
+    const toolCalls = trace?.toolCalls && Object.keys(trace.toolCalls).length > 0 ? trace.toolCalls : void 0;
+    const graderDurationMs = (r.scores ?? []).reduce((sum, s) => sum + (s.durationMs ?? 0), 0);
+    return {
+      ...rest,
+      ...toolCalls && { _toolCalls: toolCalls },
+      ...graderDurationMs > 0 && { _graderDurationMs: graderDurationMs }
+    };
+  });
+  const dataJson = JSON.stringify(lightResults).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>AgentV Results Review</title>
+    <style>
+${SERVE_STYLES}
+    </style>
+</head>
+<body>
+    <header class="header">
+        <div class="header-left">
+            <h1 class="header-title">AgentV</h1>
+            <span class="header-subtitle">Results Review</span>
+        </div>
+        <div class="header-right">
+            <span class="timestamp">${escapeHtml((/* @__PURE__ */ new Date()).toISOString())}</span>
+        </div>
+    </header>
+    <nav class="tabs" id="tabs">
+        <button class="tab active" data-tab="overview">Overview</button>
+        <button class="tab" data-tab="tests">Test Cases</button>
+    </nav>
+    <main id="app"></main>
+    <script>
+    var DATA = ${dataJson};
+${SERVE_SCRIPT}
+    </script>
+</body>
+</html>`;
+}
+var SERVE_STYLES = `
+*{margin:0;padding:0;box-sizing:border-box}
+:root{
+  --bg:#f6f8fa;--surface:#fff;--border:#d0d7de;--border-light:#e8ebee;
+  --text:#1f2328;--text-muted:#656d76;
+  --primary:#0969da;--primary-bg:#ddf4ff;
+  --success:#1a7f37;--success-bg:#dafbe1;
+  --danger:#cf222e;--danger-bg:#ffebe9;
+  --warning:#9a6700;--warning-bg:#fff8c5;
+  --radius:6px;
+  --shadow:0 1px 3px rgba(31,35,40,.04),0 1px 2px rgba(31,35,40,.06);
+  --font:-apple-system,BlinkMacSystemFont,"Segoe UI","Noto Sans",Helvetica,Arial,sans-serif;
+  --mono:ui-monospace,SFMono-Regular,"SF Mono",Menlo,Consolas,monospace;
+}
+body{font-family:var(--font);background:var(--bg);color:var(--text);line-height:1.5;font-size:14px}
+
+/* Header */
+.header{background:var(--surface);border-bottom:1px solid var(--border);padding:12px 24px;display:flex;align-items:center;justify-content:space-between}
+.header-left{display:flex;align-items:baseline;gap:12px}
+.header-title{font-size:18px;font-weight:600}
+.header-subtitle{font-size:14px;color:var(--text-muted)}
+.timestamp{font-size:12px;color:var(--text-muted);font-family:var(--mono)}
+
+/* Tabs */
+.tabs{background:var(--surface);border-bottom:1px solid var(--border);padding:0 24px;display:flex}
+.tab{background:none;border:none;padding:10px 16px;font-size:14px;color:var(--text-muted);cursor:pointer;border-bottom:2px solid transparent;font-family:var(--font);transition:color .15s,border-color .15s}
+.tab:hover{color:var(--text)}
+.tab.active{color:var(--text);font-weight:600;border-bottom-color:var(--primary)}
+
+#app{max-width:1280px;margin:0 auto;padding:24px}
+
+/* Stat cards */
+.stats-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(140px,1fr));gap:12px;margin-bottom:24px}
+.stat-card{background:var(--surface);border:1px solid var(--border);border-radius:var(--radius);padding:16px;text-align:center;box-shadow:var(--shadow)}
+.stat-card.pass .stat-value{color:var(--success)}
+.stat-card.fail .stat-value{color:var(--danger)}
+.stat-card.error .stat-value{color:var(--danger)}
+.stat-card.warn .stat-value{color:var(--warning)}
+.stat-card.total .stat-value{color:var(--primary)}
+.stat-value{font-size:28px;font-weight:700;line-height:1.2}
+.stat-label{font-size:12px;color:var(--text-muted);text-transform:uppercase;letter-spacing:.5px;margin-top:4px}
+
+/* Sections */
+.section{margin-bottom:24px}
+.section-title{font-size:16px;font-weight:600;margin-bottom:12px}
+
+/* Tables */
+.table-wrap{overflow-x:auto;background:var(--surface);border:1px solid var(--border);border-radius:var(--radius);box-shadow:var(--shadow)}
+.data-table{width:100%;border-collapse:collapse;font-size:13px}
+.data-table th{background:var(--bg);border-bottom:1px solid var(--border);padding:8px 12px;text-align:left;font-weight:600;font-size:12px;color:var(--text-muted);text-transform:uppercase;letter-spacing:.3px;white-space:nowrap}
+.data-table th.sortable{cursor:pointer;user-select:none}
+.data-table th.sortable:hover{color:var(--text)}
+.data-table td{padding:8px 12px;border-bottom:1px solid var(--border-light);vertical-align:middle}
+.data-table tbody tr:last-child td{border-bottom:none}
+
+/* Status icons */
+.status-icon{display:inline-flex;align-items:center;justify-content:center;width:22px;height:22px;border-radius:50%;font-size:12px;font-weight:700}
+.status-icon.pass{background:var(--success-bg);color:var(--success)}
+.status-icon.fail{background:var(--danger-bg);color:var(--danger)}
+.status-icon.error{background:var(--warning-bg);color:var(--warning)}
+
+/* Score colors */
+.score-high{color:var(--success);font-weight:600}
+.score-mid{color:var(--warning);font-weight:600}
+.score-low{color:var(--danger);font-weight:600}
+
+/* Pass-rate bar */
+.bar-bg{width:100px;height:8px;background:var(--border-light);border-radius:4px;overflow:hidden}
+.bar-fill{height:100%;border-radius:4px;transition:width .3s}
+.bar-fill.score-high{background:var(--success)}
+.bar-fill.score-mid{background:var(--warning)}
+.bar-fill.score-low{background:var(--danger)}
+
+/* Histogram */
+.histogram{background:var(--surface);border:1px solid var(--border);border-radius:var(--radius);padding:16px;box-shadow:var(--shadow)}
+.hist-row{display:flex;align-items:center;gap:12px;margin-bottom:8px}
+.hist-row:last-child{margin-bottom:0}
+.hist-label{width:60px;font-size:12px;color:var(--text-muted);text-align:right;flex-shrink:0}
+.hist-bar-bg{flex:1;height:20px;background:var(--border-light);border-radius:3px;overflow:hidden}
+.hist-bar{height:100%;border-radius:3px;transition:width .3s}
+.hist-count{width:30px;font-size:12px;color:var(--text-muted);text-align:right;flex-shrink:0}
+
+/* Filters */
+.filter-bar{display:flex;gap:8px;margin-bottom:16px;align-items:center;flex-wrap:wrap}
+.filter-select,.filter-search{padding:6px 10px;border:1px solid var(--border);border-radius:var(--radius);font-size:13px;background:var(--surface);color:var(--text);font-family:var(--font)}
+.filter-search{flex:1;min-width:200px}
+.filter-count{font-size:12px;color:var(--text-muted);margin-left:auto}
+
+/* Test rows */
+.test-row{cursor:pointer;transition:background .1s}
+.test-row:hover{background:var(--bg)!important}
+.test-row.expanded{background:var(--primary-bg)!important}
+.expand-col{width:32px;text-align:center}
+.expand-icon{color:var(--text-muted);font-size:12px}
+.fw-medium{font-weight:500}
+.text-pass{color:var(--success)}.text-fail{color:var(--danger)}.text-error{color:var(--warning)}
+
+/* Detail panel */
+.detail-row td{padding:0!important;background:var(--bg)!important}
+.detail-panel{padding:16px 24px}
+.detail-grid{display:grid;grid-template-columns:1fr 1fr;gap:16px;margin-bottom:16px}
+.detail-block h4{font-size:12px;color:var(--text-muted);text-transform:uppercase;letter-spacing:.3px;margin-bottom:6px}
+.detail-pre{background:var(--surface);border:1px solid var(--border);border-radius:var(--radius);padding:12px;font-family:var(--mono);font-size:12px;white-space:pre-wrap;word-break:break-word;max-height:300px;overflow-y:auto;line-height:1.6}
+.detail-panel h4{font-size:13px;font-weight:600;margin:16px 0 8px}
+.eval-table{width:100%;border-collapse:collapse;font-size:13px;background:var(--surface);border:1px solid var(--border);border-radius:var(--radius);margin-bottom:12px}
+.eval-table th{background:var(--bg);padding:6px 10px;text-align:left;font-size:11px;font-weight:600;color:var(--text-muted);text-transform:uppercase;border-bottom:1px solid var(--border)}
+.eval-table td{padding:8px 10px;border-bottom:1px solid var(--border-light)}
+.reasoning-cell{max-width:500px;font-size:12px;color:var(--text-muted)}
+.expect-list{list-style:none;padding:0;margin-bottom:12px}
+.expect-list li{padding:4px 8px 4px 24px;position:relative;font-size:13px}
+.expect-list.pass li::before{content:"\\2713";position:absolute;left:4px;color:var(--success);font-weight:700}
+.expect-list.fail li::before{content:"\\2717";position:absolute;left:4px;color:var(--danger);font-weight:700}
+.error-box{background:var(--danger-bg);border:1px solid var(--danger);border-radius:var(--radius);padding:12px;margin-bottom:12px}
+.error-box h4{color:var(--danger);margin:0 0 6px}
+.error-box pre{font-family:var(--mono);font-size:12px;white-space:pre-wrap;word-break:break-word}
+.detail-meta{font-size:12px;color:var(--text-muted);margin-top:12px;padding-top:12px;border-top:1px solid var(--border-light)}
+.tool-calls{display:flex;flex-wrap:wrap;gap:6px;margin-bottom:12px}
+.tool-tag{display:inline-block;padding:2px 10px;font-size:12px;font-family:var(--mono);background:var(--primary-bg);color:var(--primary);border:1px solid var(--border);border-radius:12px}
+.empty-state{text-align:center;padding:48px 24px;color:var(--text-muted)}
+.empty-state h3{font-size:16px;margin-bottom:8px;color:var(--text)}
+
+/* Feedback */
+.feedback-section{margin-top:16px;padding-top:16px;border-top:1px solid var(--border-light)}
+.feedback-input{width:100%;min-height:80px;padding:8px 12px;border:1px solid var(--border);border-radius:var(--radius);font-family:var(--font);font-size:13px;resize:vertical;background:var(--surface);color:var(--text)}
+.feedback-input:focus{outline:none;border-color:var(--primary);box-shadow:0 0 0 3px var(--primary-bg)}
+.feedback-submit{margin-top:8px;padding:6px 16px;background:var(--primary);color:#fff;border:none;border-radius:var(--radius);font-size:13px;cursor:pointer;font-family:var(--font)}
+.feedback-submit:hover{opacity:.9}
+.feedback-submit:disabled{opacity:.5;cursor:default}
+.feedback-status{margin-left:8px;font-size:12px;color:var(--success)}
+`;
+var SERVE_SCRIPT = `
+(function(){
+  /* ---- helpers ---- */
+  function esc(s){
+    if(s==null)return"";
+    return String(s).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;");
+  }
+  function getStatus(r){
+    if(r.executionStatus==="execution_error")return"error";
+    if(r.executionStatus==="quality_failure")return"fail";
+    if(r.executionStatus==="ok")return"pass";
+    if(r.error)return"error";
+    return r.score>=0.5?"pass":"fail";
+  }
+  function sIcon(s){
+    if(s==="pass")return'<span class="status-icon pass">\\u2713</span>';
+    if(s==="fail")return'<span class="status-icon fail">\\u2717</span>';
+    return'<span class="status-icon error">!</span>';
+  }
+  function fmtDur(ms){
+    if(ms==null)return"\\u2014";
+    if(ms<1000)return ms+"ms";
+    if(ms<60000)return(ms/1000).toFixed(1)+"s";
+    return Math.floor(ms/60000)+"m "+Math.round((ms%60000)/1000)+"s";
+  }
+  function fmtTok(n){
+    if(n==null)return"\\u2014";
+    if(n>=1e6)return(n/1e6).toFixed(1)+"M";
+    if(n>=1e3)return(n/1e3).toFixed(1)+"K";
+    return String(n);
+  }
+  function fmtCost(u){if(u==null)return"\\u2014";if(u<0.01)return"<$0.01";return"$"+u.toFixed(2);}
+  function fmtPct(v){if(v==null)return"\\u2014";return(v*100).toFixed(1)+"%";}
+  function sCls(v){if(v==null)return"";if(v>=0.9)return"score-high";if(v>=0.5)return"score-mid";return"score-low";}
+
+  /* ---- feedback state ---- */
+  var feedbackCache={};
+
+  function loadFeedback(){
+    fetch("/api/feedback").then(function(r){return r.json();}).then(function(d){
+      if(d&&d.reviews){
+        for(var i=0;i<d.reviews.length;i++){
+          feedbackCache[d.reviews[i].test_id]=d.reviews[i].comment;
+        }
+        populateFeedbackTextareas();
+      }
+    }).catch(function(){});
+  }
+
+  function populateFeedbackTextareas(){
+    var areas=document.querySelectorAll(".feedback-input");
+    for(var i=0;i<areas.length;i++){
+      var tid=areas[i].getAttribute("data-test-id");
+      if(tid&&feedbackCache[tid]!=null){
+        areas[i].value=feedbackCache[tid];
+      }
+    }
+  }
+
+  function saveFeedback(testId,comment,statusEl,btn){
+    btn.disabled=true;
+    statusEl.textContent="Saving...";
+    statusEl.style.color="var(--text-muted)";
+    fetch("/api/feedback",{
+      method:"POST",
+      headers:{"Content-Type":"application/json"},
+      body:JSON.stringify({reviews:[{test_id:testId,comment:comment}]})
+    }).then(function(r){return r.json();}).then(function(){
+      feedbackCache[testId]=comment;
+      statusEl.textContent="Saved";
+      statusEl.style.color="var(--success)";
+      btn.disabled=false;
+      setTimeout(function(){statusEl.textContent="";},2000);
+    }).catch(function(){
+      statusEl.textContent="Error saving";
+      statusEl.style.color="var(--danger)";
+      btn.disabled=false;
+    });
+  }
+
+  /* ---- compute stats ---- */
+  function computeStats(d){
+    var t=d.length,p=0,f=0,e=0,dur=0,ti=0,to=0,cost=0,sc=[],tc=0;
+    for(var i=0;i<d.length;i++){
+      var r=d[i],s=getStatus(r);
+      if(s==="pass")p++;else if(s==="fail")f++;else e++;
+      if(r.durationMs)dur+=r.durationMs;
+      if(r.tokenUsage){ti+=(r.tokenUsage.input||0);to+=(r.tokenUsage.output||0);}
+      if(r.costUsd)cost+=r.costUsd;
+      if(s!=="error")sc.push(r.score);
+      if(r._toolCalls){for(var k in r._toolCalls)tc+=r._toolCalls[k];}
+    }
+    var g=t-e;
+    return{total:t,passed:p,failed:f,errors:e,passRate:g>0?p/g:0,dur:dur,tokens:ti+to,inTok:ti,outTok:to,cost:cost,scores:sc,toolCalls:tc};
+  }
+  function computeTargets(d){
+    var m={};
+    for(var i=0;i<d.length;i++){
+      var r=d[i],tgt=r.target||"unknown";
+      if(!m[tgt])m[tgt]={target:tgt,results:[],p:0,f:0,e:0,ts:0,sc:0,dur:0,tok:0,cost:0};
+      var o=m[tgt];o.results.push(r);
+      var s=getStatus(r);
+      if(s==="pass")o.p++;else if(s==="fail")o.f++;else o.e++;
+      if(s!=="error"){o.ts+=r.score;o.sc++;}
+      if(r.durationMs)o.dur+=r.durationMs;
+      if(r.tokenUsage)o.tok+=(r.tokenUsage.input||0)+(r.tokenUsage.output||0);
+      if(r.costUsd)o.cost+=r.costUsd;
+    }
+    var a=[];for(var k in m)a.push(m[k]);return a;
+  }
+  function getEvalNames(){
+    var n={};
+    for(var i=0;i<DATA.length;i++){
+      var sc=DATA[i].scores;
+      if(sc)for(var j=0;j<sc.length;j++)n[sc[j].name]=true;
+    }
+    return Object.keys(n);
+  }
+  function getEvalScore(r,name){
+    if(!r.scores)return null;
+    for(var i=0;i<r.scores.length;i++)if(r.scores[i].name===name)return r.scores[i].score;
+    return null;
+  }
+
+  var stats=computeStats(DATA);
+  var tgtStats=computeTargets(DATA);
+  var tgtNames=tgtStats.map(function(t){return t.target;});
+
+  /* ---- state ---- */
+  var state={tab:"overview",filter:{status:"all",target:"all",search:""},sort:{col:"testId",dir:"asc"},expanded:{}};
+
+  /* ---- DOM refs ---- */
+  var app=document.getElementById("app");
+  var tabBtns=document.querySelectorAll(".tab");
+
+  /* ---- tabs ---- */
+  function setTab(t){
+    state.tab=t;
+    for(var i=0;i<tabBtns.length;i++)tabBtns[i].classList.toggle("active",tabBtns[i].getAttribute("data-tab")===t);
+    render();
+  }
+  for(var i=0;i<tabBtns.length;i++){
+    tabBtns[i].addEventListener("click",(function(b){return function(){setTab(b.getAttribute("data-tab"));};})(tabBtns[i]));
+  }
+
+  /* ---- render ---- */
+  function render(){
+    if(DATA.length===0){app.innerHTML='<div class="empty-state"><h3>No results</h3><p>No evaluation results to display.</p></div>';return;}
+    if(state.tab==="overview")renderOverview();else renderTests();
+  }
+
+  /* ---- stat card helper ---- */
+  function card(label,value,type){
+    return'<div class="stat-card '+type+'"><div class="stat-value">'+value+'</div><div class="stat-label">'+label+"</div></div>";
+  }
+
+  /* ---- overview ---- */
+  function renderOverview(){
+    var h='<div class="stats-grid">';
+    h+=card("Total Tests",stats.total,"total");
+    h+=card("Passed",stats.passed,"pass");
+    h+=card("Failed",stats.failed,"fail");
+    h+=card("Errors",stats.errors,"error");
+    var prCls=stats.passRate>=0.9?"pass":stats.passRate>=0.5?"warn":"fail";
+    h+=card("Pass Rate",fmtPct(stats.passRate),prCls);
+    h+=card("Duration",fmtDur(stats.dur),"neutral");
+    h+=card("Tokens",fmtTok(stats.tokens),"neutral");
+    h+=card("Est. Cost",fmtCost(stats.cost),"neutral");
+    if(stats.toolCalls>0)h+=card("Tool Calls",fmtTok(stats.toolCalls),"neutral");
+    h+="</div>";
+
+    /* targets table */
+    if(tgtStats.length>1){
+      h+='<div class="section"><h2 class="section-title">Targets</h2><div class="table-wrap"><table class="data-table">';
+      h+="<thead><tr><th>Target</th><th>Pass Rate</th><th></th><th>Passed</th><th>Failed</th><th>Errors</th><th>Avg Score</th><th>Duration</th><th>Tokens</th><th>Cost</th></tr></thead><tbody>";
+      for(var i=0;i<tgtStats.length;i++){
+        var t=tgtStats[i],g=t.p+t.f,pr=g>0?t.p/g:0,avg=t.sc>0?t.ts/t.sc:0;
+        h+="<tr><td class=\\"fw-medium\\">"+esc(t.target)+"</td><td>"+fmtPct(pr)+'</td><td><div class="bar-bg"><div class="bar-fill '+sCls(pr)+'" style="width:'+(pr*100)+'%"></div></div></td>';
+        h+='<td class="text-pass">'+t.p+'</td><td class="text-fail">'+t.f+'</td><td class="text-error">'+t.e+"</td>";
+        h+='<td class="'+sCls(avg)+'">'+fmtPct(avg)+"</td><td>"+fmtDur(t.dur)+"</td><td>"+fmtTok(t.tok)+"</td><td>"+fmtCost(t.cost)+"</td></tr>";
+      }
+      h+="</tbody></table></div></div>";
+    }
+
+    /* histogram */
+    if(stats.scores.length>0){
+      var bk=[0,0,0,0,0];
+      for(var i=0;i<stats.scores.length;i++){var idx=Math.min(Math.floor(stats.scores[i]*5),4);bk[idx]++;}
+      var mx=Math.max.apply(null,bk);
+      var lb=["0\\u201320%","20\\u201340%","40\\u201360%","60\\u201380%","80\\u2013100%"];
+      h+='<div class="section"><h2 class="section-title">Score Distribution</h2><div class="histogram">';
+      for(var i=0;i<bk.length;i++){
+        var pct=mx>0?(bk[i]/mx*100):0;
+        h+='<div class="hist-row"><span class="hist-label">'+lb[i]+'</span><div class="hist-bar-bg"><div class="hist-bar '+(i>=4?"score-high":i>=2?"score-mid":"score-low")+'" style="width:'+pct+'%"></div></div><span class="hist-count">'+bk[i]+"</span></div>";
+      }
+      h+="</div></div>";
+    }
+    app.innerHTML=h;
+  }
+
+  /* ---- test cases ---- */
+  function renderTests(){
+    var evalNames=getEvalNames();
+    var h='<div class="filter-bar">';
+    h+='<select id="flt-status" class="filter-select"><option value="all">All Status</option><option value="pass">Passed</option><option value="fail">Failed</option><option value="error">Errors</option></select>';
+    if(tgtNames.length>1){
+      h+='<select id="flt-target" class="filter-select"><option value="all">All Targets</option>';
+      for(var i=0;i<tgtNames.length;i++)h+='<option value="'+esc(tgtNames[i])+'">'+esc(tgtNames[i])+"</option>";
+      h+="</select>";
+    }
+    h+='<input type="text" id="flt-search" class="filter-search" placeholder="Search tests..." value="'+esc(state.filter.search)+'">';
+    h+='<span class="filter-count" id="flt-count"></span></div>';
+
+    h+='<div class="table-wrap"><table class="data-table" id="test-tbl"><thead><tr>';
+    h+='<th class="expand-col"></th>';
+    h+=sHdr("Status","status");
+    h+=sHdr("Test ID","testId");
+    if(tgtNames.length>1)h+=sHdr("Target","target");
+    h+=sHdr("Score","score");
+    for(var i=0;i<evalNames.length;i++)h+="<th>"+esc(evalNames[i])+"</th>";
+    h+=sHdr("Duration","durationMs");
+    h+=sHdr("Cost","costUsd");
+    h+="</tr></thead><tbody id=\\"test-body\\"></tbody></table></div>";
+    app.innerHTML=h;
+
+    /* wire events */
+    var selS=document.getElementById("flt-status");
+    selS.value=state.filter.status;
+    selS.addEventListener("change",function(e){state.filter.status=e.target.value;renderRows();});
+    var selT=document.getElementById("flt-target");
+    if(selT){selT.value=state.filter.target;selT.addEventListener("change",function(e){state.filter.target=e.target.value;renderRows();});}
+    document.getElementById("flt-search").addEventListener("input",function(e){state.filter.search=e.target.value;renderRows();});
+    var ths=document.querySelectorAll("th[data-sort]");
+    for(var i=0;i<ths.length;i++){
+      ths[i].addEventListener("click",(function(th){return function(){
+        var c=th.getAttribute("data-sort");
+        if(state.sort.col===c)state.sort.dir=state.sort.dir==="asc"?"desc":"asc";
+        else{state.sort.col=c;state.sort.dir="asc";}
+        renderTests();
+      };})(ths[i]));
+    }
+    renderRows();
+  }
+
+  function sHdr(label,col){
+    var arrow="";
+    if(state.sort.col===col)arrow=state.sort.dir==="asc"?" \\u2191":" \\u2193";
+    return'<th class="sortable" data-sort="'+col+'">'+label+arrow+"</th>";
+  }
+
+  function filtered(){
+    var out=[];
+    for(var i=0;i<DATA.length;i++){
+      var r=DATA[i],s=getStatus(r);
+      if(state.filter.status!=="all"&&s!==state.filter.status)continue;
+      if(state.filter.target!=="all"&&r.target!==state.filter.target)continue;
+      if(state.filter.search&&(r.testId||"").toLowerCase().indexOf(state.filter.search.toLowerCase())===-1)continue;
+      out.push(r);
+    }
+    var col=state.sort.col,dir=state.sort.dir==="asc"?1:-1;
+    out.sort(function(a,b){
+      var va=col==="status"?getStatus(a):a[col],vb=col==="status"?getStatus(b):b[col];
+      if(va==null&&vb==null)return 0;if(va==null)return 1;if(vb==null)return-1;
+      if(typeof va==="string")return va.localeCompare(vb)*dir;
+      return(va-vb)*dir;
+    });
+    return out;
+  }
+
+  function renderRows(){
+    var rows=filtered(),evalNames=getEvalNames();
+    var tbody=document.getElementById("test-body");
+    var colSpan=5+evalNames.length+(tgtNames.length>1?1:0);
+    document.getElementById("flt-count").textContent=rows.length+" of "+DATA.length+" tests";
+    var h="";
+    for(var i=0;i<rows.length;i++){
+      var r=rows[i],s=getStatus(r),key=r.testId+":"+r.target,exp=!!state.expanded[key];
+      h+='<tr class="test-row '+s+(exp?" expanded":"")+'" data-key="'+esc(key)+'" data-test-id="'+esc(r.testId)+'">';
+      h+='<td class="expand-col"><span class="expand-icon">'+(exp?"\\u25BE":"\\u25B8")+"</span></td>";
+      h+="<td>"+sIcon(s)+"</td>";
+      h+='<td class="fw-medium">'+esc(r.testId)+"</td>";
+      if(tgtNames.length>1)h+="<td>"+esc(r.target)+"</td>";
+      h+='<td class="'+sCls(r.score)+'">'+fmtPct(r.score)+"</td>";
+      for(var j=0;j<evalNames.length;j++){
+        var es=getEvalScore(r,evalNames[j]);
+        h+='<td class="'+sCls(es)+'">'+(es!=null?fmtPct(es):"\\u2014")+"</td>";
+      }
+      h+="<td>"+fmtDur(r.durationMs)+"</td><td>"+fmtCost(r.costUsd)+"</td></tr>";
+      if(exp)h+='<tr class="detail-row"><td colspan="'+colSpan+'">'+renderDetail(r)+"</td></tr>";
+    }
+    if(rows.length===0)h+='<tr><td colspan="'+colSpan+'" class="empty-state">No matching tests</td></tr>';
+    tbody.innerHTML=h;
+
+    /* row click */
+    var trs=tbody.querySelectorAll(".test-row");
+    for(var k=0;k<trs.length;k++){
+      trs[k].addEventListener("click",(function(tr){return function(){
+        var key=tr.getAttribute("data-key");
+        state.expanded[key]=!state.expanded[key];
+        renderRows();
+      };})(trs[k]));
+    }
+
+    /* wire feedback buttons */
+    var btns=tbody.querySelectorAll(".feedback-submit");
+    for(var k=0;k<btns.length;k++){
+      btns[k].addEventListener("click",(function(btn){return function(ev){
+        ev.stopPropagation();
+        var tid=btn.getAttribute("data-test-id");
+        var sec=btn.closest(".feedback-section");
+        var ta=sec.querySelector(".feedback-input");
+        var st=sec.querySelector(".feedback-status");
+        saveFeedback(tid,ta.value,st,btn);
+      };})(btns[k]));
+    }
+
+    /* prevent textarea clicks from toggling row */
+    var tas=tbody.querySelectorAll(".feedback-input");
+    for(var k=0;k<tas.length;k++){
+      tas[k].addEventListener("click",function(ev){ev.stopPropagation();});
+    }
+
+    populateFeedbackTextareas();
+  }
+
+  /* ---- detail panel ---- */
+  function renderDetail(r){
+    var h='<div class="detail-panel">';
+
+    /* input / output */
+    h+='<div class="detail-grid">';
+    if(r.input!=null){
+      h+='<div class="detail-block"><h4>Input</h4><pre class="detail-pre">'+esc(JSON.stringify(r.input,null,2))+"</pre></div>";
+    }
+    h+='<div class="detail-block"><h4>Output</h4><pre class="detail-pre">'+esc(r.output?JSON.stringify(r.output,null,2):"")+"</pre></div>";
+    h+="</div>";
+
+    /* evaluator results */
+    if(r.scores&&r.scores.length>0){
+      h+="<h4>Evaluator Results</h4>";
+      h+='<table class="eval-table"><thead><tr><th>Evaluator</th><th>Score</th><th>Status</th><th>Assertions</th></tr></thead><tbody>';
+      for(var i=0;i<r.scores.length;i++){
+        var ev=r.scores[i],evS=ev.score>=0.5?"pass":"fail";
+        var evAssertions=ev.assertions||[];
+        var evSummary=evAssertions.map(function(a){return (a.passed?"\\u2713 ":"\\u2717 ")+a.text;}).join("; ");
+        h+="<tr><td class=\\"fw-medium\\">"+esc(ev.name)+'</td><td class="'+sCls(ev.score)+'">'+fmtPct(ev.score)+"</td><td>"+sIcon(evS)+'</td><td class="reasoning-cell">'+esc(evSummary)+"</td></tr>";
+      }
+      h+="</tbody></table>";
+    }
+
+    /* assertions */
+    var passedA=r.assertions?r.assertions.filter(function(a){return a.passed;}):[];
+    var failedA=r.assertions?r.assertions.filter(function(a){return !a.passed;}):[];
+    if(passedA.length>0){
+      h+='<h4>Passed Assertions</h4><ul class="expect-list pass">';
+      for(var i=0;i<passedA.length;i++)h+="<li>"+esc(passedA[i].text)+(passedA[i].evidence?" <span class=\\"reasoning-cell\\">("+esc(passedA[i].evidence)+")</span>":"")+"</li>";
+      h+="</ul>";
+    }
+    if(failedA.length>0){
+      h+='<h4>Failed Assertions</h4><ul class="expect-list fail">';
+      for(var i=0;i<failedA.length;i++)h+="<li>"+esc(failedA[i].text)+(failedA[i].evidence?" <span class=\\"reasoning-cell\\">("+esc(failedA[i].evidence)+")</span>":"")+"</li>";
+      h+="</ul>";
+    }
+
+    /* tool calls */
+    if(r._toolCalls){
+      var tc=r._toolCalls,tcArr=[];
+      for(var k in tc)tcArr.push({name:k,count:tc[k]});
+      tcArr.sort(function(a,b){return b.count-a.count;});
+      h+='<h4>Tool Calls</h4><div class="tool-calls">';
+      for(var i=0;i<tcArr.length;i++)h+='<span class="tool-tag">'+esc(tcArr[i].name)+": "+tcArr[i].count+"</span>";
+      h+="</div>";
+    }
+
+    /* error */
+    if(r.error)h+='<div class="error-box"><h4>Error</h4><pre>'+esc(r.error)+"</pre></div>";
+
+    /* metadata */
+    h+='<div class="detail-meta">';
+    var m=[];
+    if(r.tokenUsage)m.push(fmtTok(r.tokenUsage.input)+" in / "+fmtTok(r.tokenUsage.output)+" out tokens");
+    if(r.durationMs){
+      if(r._graderDurationMs>0){
+        var execMs=r.durationMs-r._graderDurationMs;
+        m.push(fmtDur(execMs>0?execMs:0)+" executor + "+fmtDur(r._graderDurationMs)+" grader");
+      }else{
+        m.push(fmtDur(r.durationMs));
+      }
+    }
+    if(r.target)m.push(r.target);
+    if(r.costUsd)m.push(fmtCost(r.costUsd));
+    if(r.timestamp)m.push(r.timestamp);
+    h+=esc(m.join(" \\u00B7 "));
+    h+="</div>";
+
+    /* feedback section */
+    var tid=r.testId||"";
+    var existingComment=feedbackCache[tid]||"";
+    h+='<div class="feedback-section">';
+    h+='<h4>Feedback</h4>';
+    h+='<textarea class="feedback-input" data-test-id="'+esc(tid)+'" placeholder="Add feedback for this test..." onclick="event.stopPropagation()">'+esc(existingComment)+'</textarea>';
+    h+='<div style="display:flex;align-items:center">';
+    h+='<button class="feedback-submit" data-test-id="'+esc(tid)+'">Save Feedback</button>';
+    h+='<span class="feedback-status"></span>';
+    h+='</div></div>';
+
+    h+="</div>";
+    return h;
+  }
+
+  /* ---- init ---- */
+  loadFeedback();
+  render();
+})();
+`;
+var resultsServeCommand = command({
+  name: "serve",
+  description: "Start a local HTTP server to review evaluation results",
+  args: {
+    source: positional({
+      type: optional(string),
+      displayName: "source",
+      description: "JSONL result file to serve (defaults to most recent in .agentv/results/)"
+    }),
+    port: option({
+      type: optional(number),
+      long: "port",
+      short: "p",
+      description: "Port to listen on (default: 3117)"
+    }),
+    dir: option({
+      type: optional(string),
+      long: "dir",
+      short: "d",
+      description: "Working directory (default: current directory)"
+    })
+  },
+  handler: async ({ source, port, dir }) => {
+    const cwd = dir ?? process.cwd();
+    const listenPort = port ?? 3117;
+    try {
+      const sourceFile = await resolveSourceFile2(source, cwd);
+      const content = readFileSync9(sourceFile, "utf8");
+      const results = loadResults2(content);
+      const app2 = createApp(results, cwd);
+      console.log(`Serving ${results.length} result(s) from ${sourceFile}`);
+      console.log(`Dashboard: http://localhost:${listenPort}`);
+      console.log(`Feedback API: http://localhost:${listenPort}/api/feedback`);
+      console.log(`Feedback file: ${feedbackPath(cwd)}`);
+      console.log("Press Ctrl+C to stop");
+      const { serve: startServer } = await import("@hono/node-server");
+      startServer({
+        fetch: app2.fetch,
+        port: listenPort
+      });
+      await new Promise(() => {
+      });
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
   }
 });
 
@@ -5043,7 +6123,6 @@ function buildEvalTest(raw) {
     id: raw.test_id ?? "unknown",
     question: "",
     input: [],
-    input_segments: [],
     expected_output: [],
     file_paths: [],
     criteria: ""
@@ -5640,8 +6719,8 @@ var traceCommand = subcommands({
 });
 
 // src/commands/transpile/index.ts
-import { writeFileSync as writeFileSync4 } from "node:fs";
-import path9 from "node:path";
+import { writeFileSync as writeFileSync5 } from "node:fs";
+import path11 from "node:path";
 var transpileCommand = command({
   name: "transpile",
   description: "Convert an EVAL.yaml file to Agent Skills evals.json format",
@@ -5665,7 +6744,7 @@ var transpileCommand = command({
   handler: async ({ input, outDir, stdout }) => {
     let result;
     try {
-      result = transpileEvalYamlFile(path9.resolve(input));
+      result = transpileEvalYamlFile(path11.resolve(input));
     } catch (error) {
       console.error(`Error: ${error.message}`);
       process.exit(1);
@@ -5689,12 +6768,12 @@ var transpileCommand = command({
       process.stdout.write("\n");
       return;
     }
-    const outputDir = outDir ? path9.resolve(outDir) : path9.dirname(path9.resolve(input));
+    const outputDir = outDir ? path11.resolve(outDir) : path11.dirname(path11.resolve(input));
     const fileNames = getOutputFilenames(result);
     for (const [skill, evalsJson] of result.files) {
       const fileName = fileNames.get(skill) ?? "evals.json";
-      const outputPath = path9.join(outputDir, fileName);
-      writeFileSync4(outputPath, `${JSON.stringify(evalsJson, null, 2)}
+      const outputPath = path11.join(outputDir, fileName);
+      writeFileSync5(outputPath, `${JSON.stringify(evalsJson, null, 2)}
 `);
       console.log(`Transpiled to ${outputPath}`);
     }
@@ -5702,7 +6781,7 @@ var transpileCommand = command({
 });
 
 // src/commands/trim/index.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
 var trimCommand = command({
   name: "trim",
   description: "Trim evaluation results for baseline storage (strips debug/audit fields)",
@@ -5721,7 +6800,7 @@ var trimCommand = command({
   },
   handler: async ({ input, out }) => {
     try {
-      const content = readFileSync7(input, "utf8");
+      const content = readFileSync10(input, "utf8");
       const lines = content.trim().split("\n").filter((line) => line.trim());
       const trimmedLines = lines.map((line) => {
         const record = JSON.parse(line);
@@ -5733,7 +6812,7 @@ var trimCommand = command({
       const output = `${trimmedLines.join("\n")}
 `;
       if (out) {
-        writeFileSync5(out, output, "utf8");
+        writeFileSync6(out, output, "utf8");
         console.error(`Trimmed ${lines.length} record(s) \u2192 ${out}`);
       } else {
         process.stdout.write(output);
@@ -5752,7 +6831,7 @@ var ANSI_GREEN = "\x1B[32m";
 var ANSI_CYAN = "\x1B[36m";
 var ANSI_BOLD = "\x1B[1m";
 var ANSI_RESET = "\x1B[0m";
-function formatSummary(summary, useColors) {
+function formatSummary2(summary, useColors) {
   const lines = [];
   lines.push("");
   lines.push(formatHeader("Validation Summary", useColors));
@@ -5828,7 +6907,7 @@ function isTTY() {
 // src/commands/validate/validate-files.ts
 import { constants } from "node:fs";
 import { access, readdir, stat } from "node:fs/promises";
-import path10 from "node:path";
+import path12 from "node:path";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
   const results = [];
@@ -5846,7 +6925,7 @@ async function validateFiles(paths) {
   };
 }
 async function validateSingleFile(filePath) {
-  const absolutePath = path10.resolve(filePath);
+  const absolutePath = path12.resolve(filePath);
   const fileType = await detectFileType(absolutePath);
   let result;
   if (fileType === "eval") {
@@ -5871,7 +6950,7 @@ async function validateSingleFile(filePath) {
 async function expandPaths(paths) {
   const expanded = [];
   for (const inputPath of paths) {
-    const absolutePath = path10.resolve(inputPath);
+    const absolutePath = path12.resolve(inputPath);
     try {
       await access(absolutePath, constants.F_OK);
     } catch {
@@ -5895,7 +6974,7 @@ async function findYamlFiles(dirPath) {
   try {
     const entries2 = await readdir(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path10.join(dirPath, entry.name);
+      const fullPath = path12.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -5912,7 +6991,7 @@ async function findYamlFiles(dirPath) {
   return results;
 }
 function isYamlFile(filePath) {
-  const ext = path10.extname(filePath).toLowerCase();
+  const ext = path12.extname(filePath).toLowerCase();
   return ext === ".yaml" || ext === ".yml";
 }
 
@@ -5924,7 +7003,7 @@ async function runValidateCommand(paths) {
   }
   const summary = await validateFiles(paths);
   const useColors = isTTY();
-  console.log(formatSummary(summary, useColors));
+  console.log(formatSummary2(summary, useColors));
   if (summary.invalidFiles > 0) {
     process.exit(1);
   }
@@ -5950,9 +7029,9 @@ var validateCommand = command({
 });
 
 // src/commands/workspace/clean.ts
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { readFile as readFile2, readdir as readdir2, rm } from "node:fs/promises";
-import path11 from "node:path";
+import path13 from "node:path";
 async function confirm(message) {
   const readline2 = await import("node:readline");
   const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
@@ -5979,7 +7058,7 @@ var cleanCommand = command({
   },
   handler: async ({ repo, force }) => {
     const poolRoot = getWorkspacePoolRoot();
-    if (!existsSync3(poolRoot)) {
+    if (!existsSync6(poolRoot)) {
       console.log("No workspace pool entries found.");
       return;
     }
@@ -5988,8 +7067,8 @@ var cleanCommand = command({
       const poolDirs = entries2.filter((e) => e.isDirectory());
       const matchingDirs = [];
       for (const dir of poolDirs) {
-        const poolDir = path11.join(poolRoot, dir.name);
-        const metadataPath = path11.join(poolDir, "metadata.json");
+        const poolDir = path13.join(poolRoot, dir.name);
+        const metadataPath = path13.join(poolDir, "metadata.json");
         try {
           const raw = await readFile2(metadataPath, "utf-8");
           const metadata = JSON.parse(raw);
@@ -6020,7 +7099,7 @@ var cleanCommand = command({
       }
       for (const dir of matchingDirs) {
         await rm(dir, { recursive: true, force: true });
-        console.log(`Removed: ${path11.basename(dir).slice(0, 12)}...`);
+        console.log(`Removed: ${path13.basename(dir).slice(0, 12)}...`);
       }
       console.log("Done.");
     } else {
@@ -6038,15 +7117,15 @@ var cleanCommand = command({
 });
 
 // src/commands/workspace/list.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { readFile as readFile3, readdir as readdir3, stat as stat2 } from "node:fs/promises";
-import path12 from "node:path";
+import path14 from "node:path";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
     const entries2 = await readdir3(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path12.join(dirPath, entry.name);
+      const fullPath = path14.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(fullPath);
       } else {
@@ -6070,7 +7149,7 @@ var listCommand = command({
   args: {},
   handler: async () => {
     const poolRoot = getWorkspacePoolRoot();
-    if (!existsSync4(poolRoot)) {
+    if (!existsSync7(poolRoot)) {
       console.log("No workspace pool entries found.");
       return;
     }
@@ -6081,11 +7160,11 @@ var listCommand = command({
       return;
     }
     for (const dir of poolDirs) {
-      const poolDir = path12.join(poolRoot, dir.name);
+      const poolDir = path14.join(poolRoot, dir.name);
       const fingerprint = dir.name;
       const poolEntries = await readdir3(poolDir, { withFileTypes: true });
       const slots = poolEntries.filter((e) => e.isDirectory() && e.name.startsWith("slot-"));
-      const metadataPath = path12.join(poolDir, "metadata.json");
+      const metadataPath = path14.join(poolDir, "metadata.json");
       let metadata = null;
       try {
         const raw = await readFile3(metadataPath, "utf-8");
@@ -6131,8 +7210,8 @@ var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var AGENTV_DIR = getAgentvHome();
 var CACHE_FILE = "version-check.json";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/agentv/latest";
-async function getCachedUpdateInfo(path13) {
-  const filePath = path13 ?? join(AGENTV_DIR, CACHE_FILE);
+async function getCachedUpdateInfo(path15) {
+  const filePath = path15 ?? join(AGENTV_DIR, CACHE_FILE);
   try {
     const raw = await readFile4(filePath, "utf-8");
     const data = JSON.parse(raw);
@@ -6224,6 +7303,7 @@ var app = subcommands({
     init: initCmdTsCommand,
     results: resultsCommand,
     self: selfCommand,
+    serve: resultsServeCommand,
     trace: traceCommand,
     transpile: transpileCommand,
     trim: trimCommand,
@@ -6241,6 +7321,7 @@ var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
   "init",
   "results",
   "self",
+  "serve",
   "trace",
   "transpile",
   "trim",
@@ -6287,4 +7368,4 @@ export {
   preprocessArgv,
   runCli
 };
-//# sourceMappingURL=chunk-6UE665XI.js.map
+//# sourceMappingURL=chunk-ETMDLQ72.js.map