agentv 2.18.4 → 3.0.0-next.1

package/dist/{chunk-KSUL3F3R.js → chunk-DY4ZDTTO.js}

@@ -25,12 +25,12 @@ import {
   subscribeToCopilotCliLogEntries,
   subscribeToCopilotSdkLogEntries,
   subscribeToPiLogEntries
-} from "./chunk-YTHTGLMT.js";
+} from "./chunk-HF4X7ALN.js";
 
 // package.json
 var package_default = {
   name: "agentv",
-  version: "2.18.4",
+  version: "3.0.0-next.1",
   description: "CLI entry point for AgentV",
   type: "module",
   repository: {
@@ -95,7 +95,7 @@ async function resolveEvalPaths(evalPaths, cwd) {
     const candidatePath = path.isAbsolute(pattern) ? path.normalize(pattern) : path.resolve(cwd, pattern);
     try {
       const stats = await stat(candidatePath);
-      if (stats.isFile() && /\.(ya?ml|jsonl)$/i.test(candidatePath)) {
+      if (stats.isFile() && /\.(ya?ml|jsonl|json)$/i.test(candidatePath)) {
         results.add(candidatePath);
         continue;
       }
@@ -110,7 +110,7 @@ async function resolveEvalPaths(evalPaths, cwd) {
       dot: true,
       followSymbolicLinks: true
     });
-    const yamlMatches = matches.filter((filePath) => /\.(ya?ml|jsonl)$/i.test(filePath));
+    const yamlMatches = matches.filter((filePath) => /\.(ya?ml|jsonl|json)$/i.test(filePath));
     if (yamlMatches.length === 0) {
       unmatched.push(pattern);
       continue;
@@ -123,7 +123,7 @@ async function resolveEvalPaths(evalPaths, cwd) {
     throw new Error(
       `No eval files matched: ${unmatched.join(
         ", "
-      )}. Provide YAML or JSONL paths or globs (e.g., "evals/**/*.yaml", "evals/**/*.jsonl").`
+      )}. Provide YAML, JSONL, or JSON paths or globs (e.g., "evals/**/*.yaml", "evals/**/*.jsonl", "evals.json").`
     );
   }
   const sorted = Array.from(results);
@@ -201,7 +201,7 @@ async function discoverTargetsFile(options) {
 // src/commands/eval/run-eval.ts
 import { constants as constants4 } from "node:fs";
 import { access as access4 } from "node:fs/promises";
-import path10 from "node:path";
+import path12 from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/version-check.ts
@@ -258,16 +258,316 @@ async function promptContinue() {
   return confirm({ message: "Continue anyway?", default: false });
 }
 
+// src/commands/eval/artifact-writer.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path3 from "node:path";
+var PASS_THRESHOLD = 0.8;
+function computeStats(values) {
+  if (values.length === 0) {
+    return { mean: 0, stddev: 0 };
+  }
+  const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
+  const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
+  return {
+    mean: Math.round(mean * 1e3) / 1e3,
+    stddev: Math.round(Math.sqrt(variance) * 1e3) / 1e3
+  };
+}
+function computePassRate(result) {
+  const scores = result.scores;
+  if (scores && scores.length > 0) {
+    const passed = scores.filter((s) => s.score >= PASS_THRESHOLD).length;
+    return passed / scores.length;
+  }
+  return result.score >= PASS_THRESHOLD ? 1 : 0;
+}
+function countToolCalls(result) {
+  const toolCalls = {};
+  let total = 0;
+  const trace = result.trace;
+  if (trace?.steps) {
+    for (const step of trace.steps) {
+      if (step.toolName || step.type === "tool") {
+        const name = step.toolName ?? "unknown";
+        toolCalls[name] = (toolCalls[name] ?? 0) + 1;
+        total += 1;
+      }
+    }
+  }
+  return { toolCalls, total };
+}
+function parseWorkspaceChanges(fileChanges) {
+  if (!fileChanges) {
+    return void 0;
+  }
+  let filesModified = 0;
+  let filesCreated = 0;
+  const lines = fileChanges.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("--- /dev/null")) {
+      filesCreated += 1;
+    } else if (line.startsWith("--- a/")) {
+      filesModified += 1;
+    }
+  }
+  const summaryLines = lines.slice(0, 20);
+  const diffSummary = lines.length > 20 ? `${summaryLines.join("\n")}
+... (${lines.length - 20} more lines)` : fileChanges;
+  return {
+    files_modified: filesModified,
+    files_created: filesCreated,
+    diff_summary: diffSummary
+  };
+}
+function buildExpectations(result) {
+  const expectations = [];
+  if (result.scores && result.scores.length > 0) {
+    for (const evaluator of result.scores) {
+      for (const hit of evaluator.hits) {
+        expectations.push({
+          text: hit,
+          passed: true,
+          evidence: evaluator.reasoning ?? ""
+        });
+      }
+      for (const miss of evaluator.misses) {
+        expectations.push({
+          text: miss,
+          passed: false,
+          evidence: evaluator.reasoning ?? ""
+        });
+      }
+    }
+  } else {
+    for (const hit of result.hits) {
+      expectations.push({ text: hit, passed: true, evidence: result.reasoning ?? "" });
+    }
+    for (const miss of result.misses) {
+      expectations.push({ text: miss, passed: false, evidence: result.reasoning ?? "" });
+    }
+  }
+  return expectations;
+}
+function buildEvaluators(scores) {
+  if (!scores || scores.length === 0) {
+    return void 0;
+  }
+  return scores.map((s) => ({
+    name: s.name,
+    type: s.type,
+    score: s.score,
+    reasoning: s.reasoning ?? "",
+    weight: s.weight,
+    verdict: s.verdict,
+    hits: s.hits,
+    misses: s.misses,
+    details: s.details
+  }));
+}
+function buildGradingArtifact(result) {
+  const expectations = buildExpectations(result);
+  const passed = expectations.filter((e) => e.passed).length;
+  const failed = expectations.filter((e) => !e.passed).length;
+  const total = expectations.length;
+  const { toolCalls, total: totalToolCalls } = countToolCalls(result);
+  const errorsEncountered = result.error ? 1 : 0;
+  return {
+    expectations,
+    summary: {
+      passed,
+      failed,
+      total,
+      pass_rate: total > 0 ? Math.round(passed / total * 1e3) / 1e3 : 0
+    },
+    execution_metrics: {
+      tool_calls: toolCalls,
+      total_tool_calls: totalToolCalls,
+      errors_encountered: errorsEncountered
+    },
+    evaluators: buildEvaluators(result.scores),
+    workspace_changes: parseWorkspaceChanges(result.fileChanges),
+    conversation: result.conversationId ? {
+      turns: result.trace ? result.trace.steps?.length ?? 0 : 0,
+      conversation_id: result.conversationId
+    } : void 0
+  };
+}
+function buildTimingArtifact(results) {
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalDurationMs = 0;
+  for (const result of results) {
+    const usage = result.tokenUsage;
+    if (usage) {
+      totalInput += usage.input ?? 0;
+      totalOutput += usage.output ?? 0;
+    }
+    if (result.durationMs != null) {
+      totalDurationMs += result.durationMs;
+    }
+  }
+  return {
+    total_tokens: totalInput + totalOutput,
+    duration_ms: totalDurationMs,
+    total_duration_seconds: Math.round(totalDurationMs / 1e3 * 1e3) / 1e3,
+    token_usage: {
+      input: totalInput,
+      output: totalOutput
+    }
+  };
+}
+function buildBenchmarkArtifact(results, evalFile = "") {
+  const targetSet = /* @__PURE__ */ new Set();
+  const testIdSet = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    targetSet.add(result.target);
+    testIdSet.add(result.testId);
+  }
+  const targets = [...targetSet].sort();
+  const testIds = [...testIdSet].sort();
+  const runSummary = {};
+  const notes = [];
+  for (const target of targets) {
+    const targetResults = results.filter((r) => r.target === target);
+    const passRates = targetResults.map(computePassRate);
+    const timings = targetResults.filter((r) => r.durationMs != null).map((r) => r.durationMs / 1e3);
+    const tokens = targetResults.filter((r) => r.tokenUsage != null).map((r) => {
+      const usage = r.tokenUsage;
+      return (usage.input ?? 0) + (usage.output ?? 0);
+    });
+    const entry = {
+      pass_rate: computeStats(passRates),
+      time_seconds: computeStats(timings),
+      tokens: computeStats(tokens)
+    };
+    const toolCallCounts = targetResults.map((r) => countToolCalls(r).total);
+    if (toolCallCounts.some((c) => c > 0)) {
+      entry.tool_calls = computeStats(toolCallCounts);
+    }
+    const costs = targetResults.filter((r) => r.costUsd != null).map((r) => r.costUsd);
+    if (costs.length > 0) {
+      entry.cost_usd = computeStats(costs);
+    }
+    runSummary[target] = entry;
+  }
+  const evaluatorScores = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    if (result.scores) {
+      for (const score of result.scores) {
+        const key = `${score.name}:${score.type}`;
+        if (!evaluatorScores.has(key)) {
+          evaluatorScores.set(key, []);
+        }
+        evaluatorScores.get(key)?.push(score.score);
+      }
+    }
+  }
+  let perEvaluatorSummary;
+  if (evaluatorScores.size > 0) {
+    perEvaluatorSummary = {};
+    for (const [key, scores] of evaluatorScores) {
+      perEvaluatorSummary[key] = computeStats(scores);
+    }
+  }
+  const errorCount = results.filter((r) => r.executionStatus === "execution_error").length;
+  if (errorCount > 0) {
+    notes.push(
+      `${errorCount} test(s) had execution errors and are included in pass_rate as failures`
+    );
+  }
+  if (results.length === 0) {
+    notes.push("No results to summarize");
+  }
+  const firstResult = results[0];
+  const timestamp = firstResult?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    metadata: {
+      eval_file: evalFile,
+      timestamp,
+      targets,
+      tests_run: testIds
+    },
+    run_summary: runSummary,
+    per_evaluator_summary: perEvaluatorSummary,
+    notes
+  };
+}
+async function writeArtifactsFromResults(results, outputDir, options) {
+  const gradingDir = path3.join(outputDir, "grading");
+  const timingPath = path3.join(outputDir, "timing.json");
+  const benchmarkPath = path3.join(outputDir, "benchmark.json");
+  await mkdir(gradingDir, { recursive: true });
+  for (const result of results) {
+    const grading = buildGradingArtifact(result);
+    const safeTestId = result.testId.replace(/[/\\:*?"<>|]/g, "_");
+    const gradingPath = path3.join(gradingDir, `${safeTestId}.json`);
+    await writeFile(gradingPath, `${JSON.stringify(grading, null, 2)}
+`, "utf8");
+  }
+  const timing = buildTimingArtifact(results);
+  await writeFile(timingPath, `${JSON.stringify(timing, null, 2)}
+`, "utf8");
+  const benchmark = buildBenchmarkArtifact(results, options?.evalFile);
+  await writeFile(benchmarkPath, `${JSON.stringify(benchmark, null, 2)}
+`, "utf8");
+  return { gradingDir, timingPath, benchmarkPath };
+}
+
+// src/commands/eval/benchmark-writer.ts
+import { writeFile as writeFile2 } from "node:fs/promises";
+var PASS_THRESHOLD2 = 0.8;
+function computeStats2(values) {
+  if (values.length === 0) {
+    return { mean: 0, stddev: 0 };
+  }
+  const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
+  const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
+  return {
+    mean: Math.round(mean * 1e3) / 1e3,
+    stddev: Math.round(Math.sqrt(variance) * 1e3) / 1e3
+  };
+}
+function computePassRate2(result) {
+  const scores = result.scores;
+  if (scores && scores.length > 0) {
+    const passed = scores.filter((s) => s.score >= PASS_THRESHOLD2).length;
+    return passed / scores.length;
+  }
+  return result.score >= PASS_THRESHOLD2 ? 1 : 0;
+}
+function buildBenchmarkJson(results) {
+  const passRates = results.map(computePassRate2);
+  const timings = results.filter((r) => r.durationMs != null).map((r) => r.durationMs / 1e3);
+  const tokens = results.filter((r) => r.tokenUsage != null).map((r) => {
+    const usage = r.tokenUsage;
+    return (usage.input ?? 0) + (usage.output ?? 0);
+  });
+  return {
+    run_summary: {
+      with_skill: {
+        pass_rate: computeStats2(passRates),
+        time_seconds: computeStats2(timings),
+        tokens: computeStats2(tokens)
+      }
+    }
+  };
+}
+async function writeBenchmarkJson(outputPath, results) {
+  const benchmark = buildBenchmarkJson(results);
+  await writeFile2(outputPath, `${JSON.stringify(benchmark, null, 2)}
+`, "utf8");
+}
+
 // src/commands/eval/env.ts
 import { constants as constants3 } from "node:fs";
 import { access as access3 } from "node:fs/promises";
-import path3 from "node:path";
+import path4 from "node:path";
 import { config as loadDotenv } from "dotenv";
 function uniqueDirs(directories) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const dir of directories) {
-    const absolute = path3.resolve(dir);
+    const absolute = path4.resolve(dir);
     if (seen.has(absolute)) {
       continue;
     }
@@ -286,14 +586,14 @@ async function fileExists2(filePath) {
 }
 function collectAncestorDirectories(start, boundary) {
   const directories = [];
-  const boundaryDir = path3.resolve(boundary);
-  let current = path3.resolve(start);
+  const boundaryDir = path4.resolve(boundary);
+  let current = path4.resolve(start);
   while (current !== void 0) {
     directories.push(current);
     if (current === boundaryDir) {
       break;
     }
-    const parent = path3.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current) {
       break;
     }
@@ -303,12 +603,12 @@ function collectAncestorDirectories(start, boundary) {
 }
 async function loadEnvFromHierarchy(options) {
   const { testFilePath, repoRoot, verbose } = options;
-  const testDir = path3.dirname(path3.resolve(testFilePath));
+  const testDir = path4.dirname(path4.resolve(testFilePath));
   const cwd = process.cwd();
   const searchDirs = uniqueDirs([...collectAncestorDirectories(testDir, repoRoot), repoRoot, cwd]);
   const envFiles = [];
   for (const dir of searchDirs) {
-    const candidate = path3.join(dir, ".env");
+    const candidate = path4.join(dir, ".env");
     if (await fileExists2(candidate)) {
       envFiles.push(candidate);
     }
@@ -319,7 +619,7 @@ async function loadEnvFromHierarchy(options) {
     }
     return void 0;
   }
-  for (let i = envFiles.length - 1; i >= 0; i--) {
+  for (let i = 0; i < envFiles.length; i++) {
     const envFile = envFiles[i];
     loadDotenv({ path: envFile, override: false });
     if (verbose) {
@@ -330,83 +630,11 @@ async function loadEnvFromHierarchy(options) {
 }
 
 // src/commands/eval/output-writer.ts
-import path8 from "node:path";
-
-// src/commands/eval/json-writer.ts
-import { mkdir, writeFile } from "node:fs/promises";
-import path4 from "node:path";
-
-// src/utils/case-conversion.ts
-function toSnakeCase(str) {
-  if (/^[A-Z]/.test(str)) {
-    return str;
-  }
-  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-function toSnakeCaseDeep(obj) {
-  if (obj === null || obj === void 0) {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => toSnakeCaseDeep(item));
-  }
-  if (typeof obj === "object") {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      const snakeKey = toSnakeCase(key);
-      result[snakeKey] = toSnakeCaseDeep(value);
-    }
-    return result;
-  }
-  return obj;
-}
-
-// src/commands/eval/json-writer.ts
-var JsonWriter = class _JsonWriter {
-  filePath;
-  results = [];
-  closed = false;
-  constructor(filePath) {
-    this.filePath = filePath;
-  }
-  static async open(filePath) {
-    await mkdir(path4.dirname(filePath), { recursive: true });
-    return new _JsonWriter(filePath);
-  }
-  async append(result) {
-    if (this.closed) {
-      throw new Error("Cannot write to closed JSON writer");
-    }
-    this.results.push(result);
-  }
-  async close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    const passed = this.results.filter((r) => r.score >= 0.5).length;
-    const failed = this.results.length - passed;
-    const total = this.results.length;
-    const output = {
-      stats: {
-        total,
-        passed,
-        failed,
-        passRate: total > 0 ? passed / total : 0
-      },
-      results: this.results
-    };
-    const snakeCaseOutput = toSnakeCaseDeep(output);
-    await writeFile(this.filePath, `${JSON.stringify(snakeCaseOutput, null, 2)}
-`, "utf8");
-  }
-};
+import path10 from "node:path";
 
-// src/commands/eval/jsonl-writer.ts
-import { createWriteStream } from "node:fs";
-import { mkdir as mkdir2 } from "node:fs/promises";
+// src/commands/eval/html-writer.ts
+import { mkdir as mkdir2, writeFile as writeFile3 } from "node:fs/promises";
 import path5 from "node:path";
-import { finished } from "node:stream/promises";
 
 // ../../node_modules/.bun/async-mutex@0.5.0/node_modules/async-mutex/index.mjs
 var E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
@@ -614,7 +842,597 @@ var Mutex = class {
   }
 };
 
+// src/commands/eval/html-writer.ts
+var HtmlWriter = class _HtmlWriter {
+  filePath;
+  results = [];
+  mutex = new Mutex();
+  closed = false;
+  isLive = true;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  static async open(filePath) {
+    await mkdir2(path5.dirname(filePath), { recursive: true });
+    const writer = new _HtmlWriter(filePath);
+    await writer.writeHtml();
+    return writer;
+  }
+  async append(result) {
+    await this.mutex.runExclusive(async () => {
+      if (this.closed) {
+        throw new Error("Cannot write to closed HTML writer");
+      }
+      this.results.push(result);
+      await this.writeHtml();
+    });
+  }
+  async close() {
+    await this.mutex.runExclusive(async () => {
+      if (this.closed) {
+        return;
+      }
+      this.closed = true;
+      this.isLive = false;
+      await this.writeHtml();
+    });
+  }
+  async writeHtml() {
+    const html = generateHtml(this.results, this.isLive);
+    await writeFile3(this.filePath, html, "utf8");
+  }
+};
+function generateHtml(results, isLive) {
+  const lightResults = results.map((r) => {
+    const { requests, trace, ...rest } = r;
+    return rest;
+  });
+  const dataJson = JSON.stringify(lightResults).replace(/<\//g, "<\\/");
+  const metaRefresh = isLive ? '    <meta http-equiv="refresh" content="2">\n' : "";
+  const liveIndicator = isLive ? '<span class="live-badge">\u25CF LIVE</span>' : `<span class="timestamp">${escapeHtml((/* @__PURE__ */ new Date()).toISOString())}</span>`;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+${metaRefresh}    <title>AgentV Evaluation Report</title>
+    <style>
+${STYLES}
+    </style>
+</head>
+<body>
+    <header class="header">
+        <div class="header-left">
+            <h1 class="header-title">AgentV</h1>
+            <span class="header-subtitle">Evaluation Report</span>
+        </div>
+        <div class="header-right">${liveIndicator}</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};
+    var IS_LIVE = ${String(isLive)};
+${SCRIPT}
+    </script>
+</body>
+</html>`;
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var 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)}
+.live-badge{color:var(--success);font-size:12px;font-weight:600;animation:pulse 2s infinite}
+@keyframes pulse{0%,100%{opacity:1}50%{opacity:.4}}
+.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)}
+.empty-state{text-align:center;padding:48px 24px;color:var(--text-muted)}
+.empty-state h3{font-size:16px;margin-bottom:8px;color:var(--text)}
+`;
+var 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";}
+
+  /* ---- compute stats ---- */
+  function computeStats(d){
+    var t=d.length,p=0,f=0,e=0,dur=0,ti=0,to=0,cost=0,sc=[];
+    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);
+    }
+    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};
+  }
+  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 yet</h3><p>'+(IS_LIVE?"Waiting for evaluation results\\u2026 Page will auto-refresh.":"Run an evaluation to generate results.")+"</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");
+    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)+'">';
+      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]));
+    }
+  }
+
+  /* ---- 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(typeof r.input==="string"?r.input:JSON.stringify(r.input,null,2))+"</pre></div>";
+    }
+    h+='<div class="detail-block"><h4>Output</h4><pre class="detail-pre">'+esc(r.answer||"")+"</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>Reasoning</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";
+        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(ev.reasoning||"")+"</td></tr>";
+      }
+      h+="</tbody></table>";
+    }
+
+    /* hits / misses */
+    if(r.hits&&r.hits.length>0){
+      h+='<h4>Passed Expectations</h4><ul class="expect-list pass">';
+      for(var i=0;i<r.hits.length;i++)h+="<li>"+esc(r.hits[i])+"</li>";
+      h+="</ul>";
+    }
+    if(r.misses&&r.misses.length>0){
+      h+='<h4>Failed Expectations</h4><ul class="expect-list fail">';
+      for(var i=0;i<r.misses.length;i++)h+="<li>"+esc(r.misses[i])+"</li>";
+      h+="</ul>";
+    }
+
+    /* 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)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></div>";
+    return h;
+  }
+
+  /* ---- init ---- */
+  render();
+})();
+`;
+
+// src/commands/eval/json-writer.ts
+import { mkdir as mkdir3, writeFile as writeFile4 } from "node:fs/promises";
+import path6 from "node:path";
+
+// src/utils/case-conversion.ts
+function toSnakeCase(str) {
+  if (/^[A-Z]/.test(str)) {
+    return str;
+  }
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function toSnakeCaseDeep(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => toSnakeCaseDeep(item));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const snakeKey = toSnakeCase(key);
+      result[snakeKey] = toSnakeCaseDeep(value);
+    }
+    return result;
+  }
+  return obj;
+}
+
+// src/commands/eval/json-writer.ts
+var JsonWriter = class _JsonWriter {
+  filePath;
+  results = [];
+  closed = false;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  static async open(filePath) {
+    await mkdir3(path6.dirname(filePath), { recursive: true });
+    return new _JsonWriter(filePath);
+  }
+  async append(result) {
+    if (this.closed) {
+      throw new Error("Cannot write to closed JSON writer");
+    }
+    this.results.push(result);
+  }
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    const passed = this.results.filter((r) => r.score >= 0.5).length;
+    const failed = this.results.length - passed;
+    const total = this.results.length;
+    const output = {
+      stats: {
+        total,
+        passed,
+        failed,
+        passRate: total > 0 ? passed / total : 0
+      },
+      results: this.results
+    };
+    const snakeCaseOutput = toSnakeCaseDeep(output);
+    await writeFile4(this.filePath, `${JSON.stringify(snakeCaseOutput, null, 2)}
+`, "utf8");
+  }
+};
+
 // src/commands/eval/jsonl-writer.ts
+import { createWriteStream } from "node:fs";
+import { mkdir as mkdir4 } from "node:fs/promises";
+import path7 from "node:path";
+import { finished } from "node:stream/promises";
 var JsonlWriter = class _JsonlWriter {
   stream;
   mutex = new Mutex();
@@ -623,7 +1441,7 @@ var JsonlWriter = class _JsonlWriter {
     this.stream = stream;
   }
   static async open(filePath) {
-    await mkdir2(path5.dirname(filePath), { recursive: true });
+    await mkdir4(path7.dirname(filePath), { recursive: true });
     const stream = createWriteStream(filePath, { flags: "w", encoding: "utf8" });
     return new _JsonlWriter(stream);
   }
@@ -654,8 +1472,8 @@ var JsonlWriter = class _JsonlWriter {
 };
 
 // src/commands/eval/junit-writer.ts
-import { mkdir as mkdir3, writeFile as writeFile2 } from "node:fs/promises";
-import path6 from "node:path";
+import { mkdir as mkdir5, writeFile as writeFile5 } from "node:fs/promises";
+import path8 from "node:path";
 function escapeXml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
@@ -667,7 +1485,7 @@ var JunitWriter = class _JunitWriter {
     this.filePath = filePath;
   }
   static async open(filePath) {
-    await mkdir3(path6.dirname(filePath), { recursive: true });
+    await mkdir5(path8.dirname(filePath), { recursive: true });
     return new _JunitWriter(filePath);
   }
   async append(result) {
@@ -729,14 +1547,14 @@ ${testCases.join("\n")}
 ${suiteXmls.join("\n")}
 </testsuites>
 `;
-    await writeFile2(this.filePath, xml, "utf8");
+    await writeFile5(this.filePath, xml, "utf8");
   }
 };
 
 // src/commands/eval/yaml-writer.ts
 import { createWriteStream as createWriteStream2 } from "node:fs";
-import { mkdir as mkdir4 } from "node:fs/promises";
-import path7 from "node:path";
+import { mkdir as mkdir6 } from "node:fs/promises";
+import path9 from "node:path";
 import { finished as finished2 } from "node:stream/promises";
 import { stringify as stringifyYaml } from "yaml";
 var YamlWriter = class _YamlWriter {
@@ -748,7 +1566,7 @@ var YamlWriter = class _YamlWriter {
     this.stream = stream;
   }
   static async open(filePath) {
-    await mkdir4(path7.dirname(filePath), { recursive: true });
+    await mkdir6(path9.dirname(filePath), { recursive: true });
     const stream = createWriteStream2(filePath, { flags: "w", encoding: "utf8" });
     return new _YamlWriter(stream);
   }
@@ -794,6 +1612,8 @@ async function createOutputWriter(filePath, format) {
       return JsonlWriter.open(filePath);
     case "yaml":
       return YamlWriter.open(filePath);
+    case "html":
+      return HtmlWriter.open(filePath);
     default: {
       const exhaustiveCheck = format;
       throw new Error(`Unsupported output format: ${exhaustiveCheck}`);
@@ -806,15 +1626,17 @@ function getDefaultExtension(format) {
       return ".jsonl";
     case "yaml":
       return ".yaml";
+    case "html":
+      return ".html";
     default: {
       const exhaustiveCheck = format;
       throw new Error(`Unsupported output format: ${exhaustiveCheck}`);
     }
   }
 }
-var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".jsonl", ".json", ".xml", ".yaml", ".yml"]);
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".jsonl", ".json", ".xml", ".yaml", ".yml", ".html", ".htm"]);
 function createWriterFromPath(filePath) {
-  const ext = path8.extname(filePath).toLowerCase();
+  const ext = path10.extname(filePath).toLowerCase();
   switch (ext) {
     case ".jsonl":
       return JsonlWriter.open(filePath);
@@ -825,6 +1647,9 @@ function createWriterFromPath(filePath) {
     case ".yaml":
     case ".yml":
       return YamlWriter.open(filePath);
+    case ".html":
+    case ".htm":
+      return HtmlWriter.open(filePath);
     default:
       throw new Error(
         `Unsupported output file extension "${ext}". Supported: ${[...SUPPORTED_EXTENSIONS].join(", ")}`
@@ -898,12 +1723,12 @@ var ProgressDisplay = class {
   }
   addLogPaths(paths, provider) {
     const newPaths = [];
-    for (const path11 of paths) {
-      if (this.logPathSet.has(path11)) {
+    for (const path13 of paths) {
+      if (this.logPathSet.has(path13)) {
         continue;
       }
-      this.logPathSet.add(path11);
-      newPaths.push(path11);
+      this.logPathSet.add(path13);
+      newPaths.push(path13);
     }
     if (newPaths.length === 0) {
       return;
@@ -916,8 +1741,8 @@ var ProgressDisplay = class {
       this.hasPrintedLogHeader = true;
     }
     const startIndex = this.logPaths.length - newPaths.length;
-    newPaths.forEach((path11, offset) => {
-      console.log(`${startIndex + offset + 1}. ${path11}`);
+    newPaths.forEach((path13, offset) => {
+      console.log(`${startIndex + offset + 1}. ${path13}`);
     });
   }
   finish() {
@@ -1207,10 +2032,10 @@ function formatMatrixSummary(results) {
 }
 
 // ../../packages/core/dist/evaluation/validation/index.js
-import { readFile } from "node:fs/promises";
-import path9 from "node:path";
-import { parse } from "yaml";
 import { readFile as readFile2 } from "node:fs/promises";
+import path11 from "node:path";
+import { parse } from "yaml";
+import { readFile as readFile22 } from "node:fs/promises";
 import path22 from "node:path";
 import { parse as parse2 } from "yaml";
 import { readFile as readFile3 } from "node:fs/promises";
@@ -1226,7 +2051,7 @@ var SCHEMA_TARGETS_V2 = "agentv-targets-v2.2";
 var SCHEMA_CONFIG_V2 = "agentv-config-v2";
 async function detectFileType(filePath) {
   try {
-    const content = await readFile(filePath, "utf8");
+    const content = await readFile2(filePath, "utf8");
     const parsed = parse(content);
     if (typeof parsed !== "object" || parsed === null) {
       return inferFileTypeFromPath(filePath);
@@ -1251,8 +2076,8 @@ async function detectFileType(filePath) {
   }
 }
 function inferFileTypeFromPath(filePath) {
-  const normalized = path9.normalize(filePath).replace(/\\/g, "/");
-  const basename = path9.basename(filePath);
+  const normalized = path11.normalize(filePath).replace(/\\/g, "/");
+  const basename = path11.basename(filePath);
   if (normalized.includes("/.agentv/")) {
     if (basename === "config.yaml" || basename === "config.yml") {
       return "config";
@@ -1287,7 +2112,7 @@ async function validateEvalFile(filePath) {
   const absolutePath = path22.resolve(filePath);
   let parsed;
   try {
-    const content = await readFile2(absolutePath, "utf8");
+    const content = await readFile22(absolutePath, "utf8");
     parsed = parse2(content);
   } catch (error) {
     errors.push({
@@ -1454,7 +2279,7 @@ async function validateEvalFile(filePath) {
         });
       }
     }
-    const assertField = evalCase.assert;
+    const assertField = evalCase.assertions ?? evalCase.assert;
     if (assertField !== void 0) {
       validateAssertArray(assertField, location, absolutePath, errors);
     }
@@ -1625,14 +2450,14 @@ function validateAssertArray(assertField, parentLocation, filePath, errors) {
     errors.push({
       severity: "warning",
       filePath,
-      location: `${parentLocation}.assert`,
-      message: "'assert' must be an array of assertion objects."
+      location: `${parentLocation}.assertions`,
+      message: "'assertions' must be an array of assertion objects."
     });
     return;
   }
   for (let i = 0; i < assertField.length; i++) {
     const item = assertField[i];
-    const location = `${parentLocation}.assert[${i}]`;
+    const location = `${parentLocation}.assertions[${i}]`;
     if (!isObject(item)) {
       errors.push({
         severity: "warning",
@@ -1931,6 +2756,7 @@ function getKnownSettings(provider) {
       return COPILOT_CLI_SETTINGS;
     case "claude":
     case "claude-code":
+    case "claude-cli":
     case "claude-sdk":
       return CLAUDE_SETTINGS;
     case "vscode":
@@ -1950,7 +2776,15 @@ function validateUnknownSettings(target, provider, absolutePath, location, error
   if (!knownSettings) {
     return;
   }
-  const baseFields = /* @__PURE__ */ new Set(["name", "provider", "judge_target", "workers", "$schema", "targets"]);
+  const baseFields = /* @__PURE__ */ new Set([
+    "name",
+    "provider",
+    "grader_target",
+    "judge_target",
+    "workers",
+    "$schema",
+    "targets"
+  ]);
   for (const key of Object.keys(target)) {
     if (removedTargetFields.has(key)) {
       errors.push({
@@ -2157,13 +2991,13 @@ async function validateTargetsFile(filePath) {
     if (typeof provider === "string") {
       validateUnknownSettings(target, provider, absolutePath, location, errors);
     }
-    const judgeTarget = target.judge_target;
-    if (judgeTarget !== void 0 && typeof judgeTarget !== "string") {
+    const graderTarget = target.grader_target ?? target.judge_target;
+    if (graderTarget !== void 0 && typeof graderTarget !== "string") {
       errors.push({
         severity: "error",
         filePath: absolutePath,
-        location: `${location}.judge_target`,
-        message: "Invalid 'judge_target' field (must be a string)"
+        location: `${location}.grader_target`,
+        message: "Invalid 'grader_target' field (must be a string)"
       });
     }
   }
@@ -2473,7 +3307,7 @@ Errors in ${targetsFilePath}:`);
     const mockTarget = {
       kind: "mock",
       name: `${targetDefinition.name}-dry-run`,
-      judgeTarget: void 0,
+      graderTarget: void 0,
       config: {
         response: '{"answer":"Mock dry-run response"}',
         delayMs: dryRunDelay,
@@ -2564,7 +3398,7 @@ Errors in ${targetsFilePath}:`);
       const mockTarget = {
         kind: "mock",
         name: `${targetDefinition.name}-dry-run`,
-        judgeTarget: void 0,
+        graderTarget: void 0,
         config: {
           response: '{"answer":"Mock dry-run response"}',
           delayMs: dryRunDelay,
@@ -2719,7 +3553,11 @@ function normalizeOptions(rawOptions, config, yamlExecution) {
     otelGroupTurns: normalizeBoolean(rawOptions.otelGroupTurns),
     retryErrors: normalizeString(rawOptions.retryErrors),
     workspaceMode,
-    workspacePath
+    workspacePath,
+    benchmarkJson: normalizeString(rawOptions.benchmarkJson),
+    artifacts: normalizeString(rawOptions.artifacts),
+    graderTarget: normalizeString(rawOptions.graderTarget),
+    model: normalizeString(rawOptions.model)
   };
 }
 async function ensureFileExists(filePath, description) {
@@ -2733,7 +3571,7 @@ function buildDefaultOutputPath(cwd, format) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const baseName = "eval";
   const extension = getDefaultExtension(format);
-  return path10.join(cwd, ".agentv", "results", `${baseName}_${timestamp}${extension}`);
+  return path12.join(cwd, ".agentv", "results", `${baseName}_${timestamp}${extension}`);
 }
 function createProgressReporter(maxWorkers, options) {
   const display = new ProgressDisplay(maxWorkers, options);
@@ -2747,7 +3585,7 @@ function createProgressReporter(maxWorkers, options) {
   };
 }
 function makeEvalKey(testFilePath, evalId) {
-  return `${path10.resolve(testFilePath)}::${evalId}`;
+  return `${path12.resolve(testFilePath)}::${evalId}`;
 }
 function createDisplayIdTracker() {
   const map = /* @__PURE__ */ new Map();
@@ -2952,6 +3790,8 @@ async function runSingleEvalFile(params) {
     trials: trialsConfig,
     totalBudgetUsd,
     failOnError,
+    graderTarget: options.graderTarget,
+    model: options.model,
     streamCallbacks: streamingObserver?.getStreamCallbacks(),
     onResult: async (result) => {
       streamingObserver?.finalizeEvalCase(result.score, result.error);
@@ -3004,16 +3844,19 @@ async function runEvalCommand(input) {
     );
   }
   const repoRoot = await findRepoRoot(cwd);
-  const yamlConfig = await loadConfig(path10.join(cwd, "_"), repoRoot);
+  const yamlConfig = await loadConfig(path12.join(cwd, "_"), repoRoot);
   if (yamlConfig?.required_version) {
     await enforceRequiredVersion(yamlConfig.required_version, {
       strict: normalizeBoolean(input.rawOptions.strict)
     });
   }
   let options = normalizeOptions(input.rawOptions, config, yamlConfig?.execution);
+  if (options.graderTarget === "agentv" && !options.model) {
+    throw new Error("--grader-target agentv requires --model (e.g., --model openai:gpt-5-mini)");
+  }
   let retryNonErrorResults;
   if (options.retryErrors) {
-    const retryPath = path10.resolve(options.retryErrors);
+    const retryPath = path12.resolve(options.retryErrors);
     await ensureFileExists(retryPath, "Retry-errors JSONL file");
     const errorIds = await loadErrorTestIds(retryPath);
     if (errorIds.length === 0) {
@@ -3026,7 +3869,7 @@ async function runEvalCommand(input) {
     retryNonErrorResults = await loadNonErrorResults(retryPath);
   }
   if (options.workspacePath) {
-    const resolvedWorkspace = path10.resolve(options.workspacePath);
+    const resolvedWorkspace = path12.resolve(options.workspacePath);
     try {
       const { stat: stat2 } = await import("node:fs/promises");
       const stats = await stat2(resolvedWorkspace);
@@ -3048,7 +3891,7 @@ async function runEvalCommand(input) {
   const useFileExport = !!(options.otelFile || options.traceFile);
   if (options.exportOtel || useFileExport) {
     try {
-      const { OtelTraceExporter, OTEL_BACKEND_PRESETS } = await import("./dist-EDQZMZH2.js");
+      const { OtelTraceExporter, OTEL_BACKEND_PRESETS } = await import("./dist-WN2QIOQR.js");
       let endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
       let headers = {};
       if (options.otelBackend) {
@@ -3072,8 +3915,8 @@ async function runEvalCommand(input) {
         headers,
         captureContent,
         groupTurns: options.otelGroupTurns,
-        otlpFilePath: options.otelFile ? path10.resolve(options.otelFile) : void 0,
-        traceFilePath: options.traceFile ? path10.resolve(options.traceFile) : void 0
+        otlpFilePath: options.otelFile ? path12.resolve(options.otelFile) : void 0,
+        traceFilePath: options.traceFile ? path12.resolve(options.traceFile) : void 0
       });
       const initialized = await otelExporter.init();
       if (!initialized) {
@@ -3089,8 +3932,8 @@ async function runEvalCommand(input) {
       otelExporter = null;
     }
   }
-  const outputPath = options.outPath ? path10.resolve(options.outPath) : buildDefaultOutputPath(cwd, options.format);
-  const extraOutputPaths = options.outputPaths.map((p) => path10.resolve(p));
+  const outputPath = options.outPath ? path12.resolve(options.outPath) : buildDefaultOutputPath(cwd, options.format);
+  const extraOutputPaths = options.outputPaths.map((p) => path12.resolve(p));
   const allOutputPaths = extraOutputPaths.length > 0 ? [outputPath, ...extraOutputPaths] : [outputPath];
   const uniqueOutputPaths = [...new Set(allOutputPaths)];
   let outputWriter;
@@ -3104,12 +3947,12 @@ async function runEvalCommand(input) {
       console.log(`  ${p}`);
     }
   }
-  const resolvedTestFiles = input.testFiles.map((file) => path10.resolve(file));
+  const resolvedTestFiles = input.testFiles.map((file) => path12.resolve(file));
   if (options.otelFile) {
-    console.log(`OTLP JSON file: ${path10.resolve(options.otelFile)}`);
+    console.log(`OTLP JSON file: ${path12.resolve(options.otelFile)}`);
   }
   if (options.traceFile) {
-    console.log(`Trace file: ${path10.resolve(options.traceFile)}`);
+    console.log(`Trace file: ${path12.resolve(options.traceFile)}`);
   }
   const evaluationRunner = await resolveEvaluationRunner();
   const allResults = [];
@@ -3122,7 +3965,23 @@ async function runEvalCommand(input) {
   );
   const perFileWorkers = options.workers ? Math.max(1, Math.floor(totalWorkers / fileConcurrency)) : void 0;
   const fileMetadata = /* @__PURE__ */ new Map();
+  const tsFiles = [];
+  const yamlFiles = [];
   for (const testFilePath of resolvedTestFiles) {
+    if (/\.(ts|js|mts|mjs)$/.test(testFilePath)) {
+      tsFiles.push(testFilePath);
+    } else {
+      yamlFiles.push(testFilePath);
+    }
+  }
+  for (const tsFile of tsFiles) {
+    await ensureFileExists(tsFile, "TypeScript eval file");
+    await import(pathToFileURL(tsFile).href);
+  }
+  if (yamlFiles.length === 0 && tsFiles.length > 0) {
+    return;
+  }
+  for (const testFilePath of yamlFiles) {
     const meta = await prepareFileMetadata({
       testFilePath,
       repoRoot,
@@ -3139,7 +3998,7 @@ async function runEvalCommand(input) {
     cliNoCache: options.noCache,
     yamlCache: yamlCacheEnabled
   });
-  const cache = cacheEnabled ? new ResponseCache(yamlCachePath ? path10.resolve(yamlCachePath) : void 0) : void 0;
+  const cache = cacheEnabled ? new ResponseCache(yamlCachePath ? path12.resolve(yamlCachePath) : void 0) : void 0;
   const useCache = cacheEnabled;
   if (cacheEnabled) {
     console.log(`Response cache: enabled${yamlCachePath ? ` (${yamlCachePath})` : ""}`);
@@ -3269,6 +4128,24 @@ async function runEvalCommand(input) {
     if (isMatrixMode && allResults.length > 0) {
       console.log(formatMatrixSummary(allResults));
     }
+    if (options.benchmarkJson && allResults.length > 0) {
+      const benchmarkPath = path12.resolve(options.benchmarkJson);
+      await writeBenchmarkJson(benchmarkPath, allResults);
+      console.log(`Benchmark written to: ${benchmarkPath}`);
+    }
+    if (options.artifacts && allResults.length > 0) {
+      const artifactsDir = path12.resolve(options.artifacts);
+      const evalFile = resolvedTestFiles.length === 1 ? resolvedTestFiles[0] : "";
+      const {
+        gradingDir,
+        timingPath,
+        benchmarkPath: abp
+      } = await writeArtifactsFromResults(allResults, artifactsDir, { evalFile });
+      console.log(`Artifacts written to: ${artifactsDir}`);
+      console.log(`  Grading: ${gradingDir} (${allResults.length} files)`);
+      console.log(`  Timing:  ${timingPath}`);
+      console.log(`  Benchmark: ${abp}`);
+    }
     const failedWithWorkspaces = allResults.filter(
       (r) => r.workspacePath && (r.error || r.score < 0.5)
     );
@@ -3308,7 +4185,7 @@ async function resolveEvaluationRunner() {
   if (!overridePath) {
     return runEvaluation;
   }
-  const resolved = path10.isAbsolute(overridePath) ? overridePath : path10.resolve(process.cwd(), overridePath);
+  const resolved = path12.isAbsolute(overridePath) ? overridePath : path12.resolve(process.cwd(), overridePath);
   const moduleUrl = pathToFileURL(resolved).href;
   const mod = await import(moduleUrl);
   const candidate = mod.runEvaluation;
@@ -3323,6 +4200,7 @@ async function resolveEvaluationRunner() {
 export {
   package_default,
   toSnakeCaseDeep,
+  HtmlWriter,
   resolveEvalPaths,
   findRepoRoot,
   detectFileType,
@@ -3335,4 +4213,4 @@ export {
   selectTarget,
   runEvalCommand
 };
-//# sourceMappingURL=chunk-KSUL3F3R.js.map
+//# sourceMappingURL=chunk-DY4ZDTTO.js.map