agentv 4.17.1 → 4.19.0-next.1

package/dist/{chunk-ILIM6IIX.js → chunk-L7WOR7IR.js}

@@ -1,9 +1,7 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 import {
   HtmlWriter,
-  RESULT_INDEX_FILENAME,
   TARGET_FILE_CANDIDATES,
-  buildDefaultRunDir,
   c,
   detectFileType,
   discoverEvalFiles,
@@ -31,47 +29,58 @@ import {
   resolveEvalPaths,
   resolveResultSourcePath,
   resolveRunCacheFile,
-  resolveRunManifestPath,
   runEvalCommand,
   selectTarget,
   syncRemoteResults,
-  toSnakeCaseDeep,
   toTraceSummary,
   validateCasesFile,
   validateConfigFile,
   validateEvalFile,
   validateFileReferences,
   validateTargetsFile,
-  validateWorkspacePaths,
+  validateWorkspacePaths
+} from "./chunk-YGNBTBXW.js";
+import {
+  RESULT_INDEX_FILENAME,
+  aggregateRunDir,
+  buildDefaultRunDir,
+  resolveRunManifestPath,
+  toSnakeCaseDeep,
   writeArtifactsFromResults
-} from "./chunk-ZUNYOUFO.js";
+} from "./chunk-NL6P5MUH.js";
 import {
   DEFAULT_CATEGORY,
-  DEFAULT_THRESHOLD,
   addBenchmark,
-  createBuiltinRegistry,
   deriveCategory,
   discoverBenchmarks,
   discoverClaudeSessions,
   discoverCodexSessions,
+  getBenchmark,
+  getOutputFilenames,
+  loadBenchmarkRegistry,
+  parseClaudeSession,
+  parseCodexSession,
+  readTranscriptFile,
+  removeBenchmark,
+  scanRepoDeps,
+  toTranscriptJsonLines,
+  transpileEvalYamlFile,
+  trimBaselineResult
+} from "./chunk-R2QDYORI.js";
+import {
+  DEFAULT_THRESHOLD,
+  createBuiltinRegistry,
   discoverCopilotSessions,
   executeScript,
   getAgentvConfigDir,
-  getBenchmark,
-  getOutputFilenames,
   getWorkspacePoolRoot,
   isAgentSkillsFormat,
   listTargetNames,
-  loadBenchmarkRegistry,
   loadTestSuite,
   normalizeLineEndings,
   parseAgentSkillsEvals,
-  parseClaudeSession,
-  parseCodexSession,
   parseCopilotEvents,
   readTargetDefinitions,
-  readTranscriptFile,
-  removeBenchmark,
   runContainsAllAssertion,
   runContainsAnyAssertion,
   runContainsAssertion,
@@ -83,13 +92,9 @@ import {
   runIsJsonAssertion,
   runRegexAssertion,
   runStartsWithAssertion,
-  scanRepoDeps,
   toCamelCaseDeep,
-  toSnakeCaseDeep as toSnakeCaseDeep2,
-  toTranscriptJsonLines,
-  transpileEvalYamlFile,
-  trimBaselineResult
-} from "./chunk-IRU2UOWN.js";
+  toSnakeCaseDeep as toSnakeCaseDeep2
+} from "./chunk-PTYQS37Y.js";
 import {
   __commonJS,
   __require,
@@ -3638,9 +3643,30 @@ var createCommand = subcommands({
   }
 });
 
+// src/commands/eval/commands/aggregate.ts
+import path3 from "node:path";
+var evalAggregateCommand = command({
+  name: "aggregate",
+  description: "Recompute benchmark.json and timing.json from a run directory. Deduplicates by (test_id, target), keeping the last entry.",
+  args: {
+    runDir: positional({
+      type: string,
+      displayName: "run-dir",
+      description: "Path to a run directory containing index.jsonl"
+    })
+  },
+  handler: async (args) => {
+    const runDir = path3.resolve(args.runDir);
+    const { benchmarkPath, timingPath, testCount, targetCount } = await aggregateRunDir(runDir);
+    console.log(`Aggregated ${testCount} test result(s) across ${targetCount} target(s)`);
+    console.log(`  Benchmark: ${benchmarkPath}`);
+    console.log(`  Timing:    ${timingPath}`);
+  }
+});
+
 // src/commands/eval/commands/assert.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 import fg from "fast-glob";
 var evalAssertCommand = command({
   name: "assert",
@@ -3671,7 +3697,7 @@ var evalAssertCommand = command({
     let resolvedOutput;
     let resolvedInput;
     if (file) {
-      const content = JSON.parse(readFileSync2(path3.resolve(file), "utf8"));
+      const content = JSON.parse(readFileSync2(path4.resolve(file), "utf8"));
       resolvedOutput = content.output ?? "";
       resolvedInput = content.input ?? "";
     } else {
@@ -3737,11 +3763,11 @@ var evalAssertCommand = command({
   }
 });
 async function findGraderScript(graderName, startDir) {
-  let dir = path3.resolve(startDir);
-  const root = path3.parse(dir).root;
+  let dir = path4.resolve(startDir);
+  const root = path4.parse(dir).root;
   while (dir !== root) {
     for (const subdir of ["graders", "judges"]) {
-      const gradersDir = path3.join(dir, ".agentv", subdir);
+      const gradersDir = path4.join(dir, ".agentv", subdir);
       const found = await fg([`${graderName}.{ts,js,mts,mjs}`], {
         cwd: gradersDir,
         absolute: true,
@@ -3749,7 +3775,7 @@ async function findGraderScript(graderName, startDir) {
       });
       if (found.length > 0) return found[0];
     }
-    dir = path3.dirname(dir);
+    dir = path4.dirname(dir);
   }
   return null;
 }
@@ -3762,7 +3788,7 @@ var evalRunCommand = command({
     evalPaths: restPositionals({
       type: string,
       displayName: "eval-paths",
-      description: "Path(s) or glob(s) to evaluation .yaml file(s)"
+      description: "Path(s) or glob(s) to evaluation files (.yaml, .eval.ts)"
     }),
     target: multioption({
       type: array(string),
@@ -3895,6 +3921,14 @@ var evalRunCommand = command({
       long: "retry-errors",
       description: "Path to a previous run workspace or index.jsonl manifest \u2014 re-run only execution_error test cases"
     }),
+    resume: flag({
+      long: "resume",
+      description: "Resume an interrupted run: skip already-completed tests and append new results to --output dir"
+    }),
+    rerunFailed: flag({
+      long: "rerun-failed",
+      description: "Rerun failed/errored tests while keeping passing results. Implies --resume semantics"
+    }),
     strict: flag({
       long: "strict",
       description: "Exit with error on version mismatch (instead of warning)"
@@ -3947,7 +3981,7 @@ var evalRunCommand = command({
   },
   handler: async (args) => {
     if (args.evalPaths.length === 0 && process.stdin.isTTY) {
-      const { launchInteractiveWizard } = await import("./interactive-LFCOVXPQ.js");
+      const { launchInteractiveWizard } = await import("./interactive-UZSFYMCF.js");
       await launchInteractiveWizard();
       return;
     }
@@ -3981,6 +4015,8 @@ var evalRunCommand = command({
       otelCaptureContent: args.otelCaptureContent,
       otelGroupTurns: args.otelGroupTurns,
       retryErrors: args.retryErrors,
+      resume: args.resume,
+      rerunFailed: args.rerunFailed,
       strict: args.strict,
       benchmarkJson: args.benchmarkJson,
       artifacts: args.artifacts,
@@ -4008,13 +4044,14 @@ var evalCommand = subcommands({
   description: "Evaluation commands",
   cmds: {
     run: evalRunCommand,
-    assert: evalAssertCommand
+    assert: evalAssertCommand,
+    aggregate: evalAggregateCommand
   }
 });
 
 // src/commands/import/claude.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import path4 from "node:path";
+import path5 from "node:path";
 var importClaudeCommand = command({
   name: "claude",
   description: "Import a Claude Code session transcript for offline grading",
@@ -4086,8 +4123,8 @@ var importClaudeCommand = command({
     const rawJsonl = await readTranscriptFile(sessionFilePath);
     const transcript = parseClaudeSession(rawJsonl);
     const shortId = (sessionId ?? transcript.source.sessionId).slice(0, 8);
-    const outputPath = output ?? path4.join(".agentv", "transcripts", `claude-${shortId}.jsonl`);
-    await mkdir2(path4.dirname(outputPath), { recursive: true });
+    const outputPath = output ?? path5.join(".agentv", "transcripts", `claude-${shortId}.jsonl`);
+    await mkdir2(path5.dirname(outputPath), { recursive: true });
     const jsonLines = toTranscriptJsonLines(transcript);
     await writeFile2(
       outputPath,
@@ -4131,7 +4168,7 @@ function formatDurationMs(ms) {
 
 // src/commands/import/codex.ts
 import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import path5 from "node:path";
+import path6 from "node:path";
 var importCodexCommand = command({
   name: "codex",
   description: "Import a Codex CLI session transcript for offline grading",
@@ -4203,8 +4240,8 @@ var importCodexCommand = command({
     const rawJsonl = await readTranscriptFile(session.filePath);
     const transcript = parseCodexSession(rawJsonl);
     const shortId = session.sessionId.slice(0, 8);
-    const outputPath = output ?? path5.join(".agentv", "transcripts", `codex-${shortId}.jsonl`);
-    await mkdir3(path5.dirname(outputPath), { recursive: true });
+    const outputPath = output ?? path6.join(".agentv", "transcripts", `codex-${shortId}.jsonl`);
+    await mkdir3(path6.dirname(outputPath), { recursive: true });
     const jsonLines = toTranscriptJsonLines(transcript);
     await writeFile3(
       outputPath,
@@ -4243,7 +4280,7 @@ function formatDurationMs2(ms) {
 
 // src/commands/import/copilot.ts
 import { mkdir as mkdir4, readFile, writeFile as writeFile4 } from "node:fs/promises";
-import path6 from "node:path";
+import path7 from "node:path";
 var importCopilotCommand = command({
   name: "copilot",
   description: "Import a Copilot CLI session transcript for offline grading",
@@ -4308,7 +4345,7 @@ var importCopilotCommand = command({
       );
       process.exit(1);
     }
-    const eventsPath = path6.join(sessionDir, "events.jsonl");
+    const eventsPath = path7.join(sessionDir, "events.jsonl");
     const rawJsonl = await readFile(eventsPath, "utf8");
     const parsed = parseCopilotEvents(rawJsonl);
     const transcript = {
@@ -4325,8 +4362,8 @@ var importCopilotCommand = command({
       costUsd: null
     };
     const shortId = resolvedSessionId.slice(0, 8);
-    const outputPath = output ?? path6.join(".agentv", "transcripts", `copilot-${shortId}.jsonl`);
-    await mkdir4(path6.dirname(outputPath), { recursive: true });
+    const outputPath = output ?? path7.join(".agentv", "transcripts", `copilot-${shortId}.jsonl`);
+    await mkdir4(path7.dirname(outputPath), { recursive: true });
     const jsonLines = toTranscriptJsonLines(transcript);
     await writeFile4(
       outputPath,
@@ -4371,12 +4408,12 @@ function formatDurationMs3(ms) {
 // src/commands/import/huggingface.ts
 import { execFile } from "node:child_process";
 import { existsSync } from "node:fs";
-import path7 from "node:path";
+import path8 from "node:path";
 function findScript() {
   const candidates = [
-    path7.resolve(__dirname, "..", "..", "..", "..", "..", "scripts", "import-huggingface.py"),
-    path7.resolve(__dirname, "..", "..", "..", "..", "scripts", "import-huggingface.py"),
-    path7.resolve(process.cwd(), "scripts", "import-huggingface.py")
+    path8.resolve(__dirname, "..", "..", "..", "..", "..", "scripts", "import-huggingface.py"),
+    path8.resolve(__dirname, "..", "..", "..", "..", "scripts", "import-huggingface.py"),
+    path8.resolve(process.cwd(), "scripts", "import-huggingface.py")
   ];
   for (const candidate of candidates) {
     if (existsSync(candidate)) return candidate;
@@ -4488,29 +4525,29 @@ var importCommand = subcommands({
 
 // src/commands/init/index.ts
 import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 import * as readline from "node:readline/promises";
 
 // src/templates/index.ts
 import { readFileSync as readFileSync3, readdirSync, statSync } from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 import { fileURLToPath } from "node:url";
 function getAgentvTemplates() {
   return getTemplatesFromDir(".agentv");
 }
 function getEnvExampleTemplate() {
-  const currentDir = path8.dirname(fileURLToPath(import.meta.url));
-  const templatesBase = currentDir.includes(`${path8.sep}dist`) ? path8.join(currentDir, "templates") : currentDir;
-  const content = readFileSync3(path8.join(templatesBase, ".env.example"), "utf-8");
+  const currentDir = path9.dirname(fileURLToPath(import.meta.url));
+  const templatesBase = currentDir.includes(`${path9.sep}dist`) ? path9.join(currentDir, "templates") : currentDir;
+  const content = readFileSync3(path9.join(templatesBase, ".env.example"), "utf-8");
   return { path: ".env.example", content };
 }
 function getTemplatesFromDir(subdir) {
-  const currentDir = path8.dirname(fileURLToPath(import.meta.url));
+  const currentDir = path9.dirname(fileURLToPath(import.meta.url));
   let templatesDir;
-  if (currentDir.includes(`${path8.sep}dist`)) {
-    templatesDir = path8.join(currentDir, "templates", subdir);
+  if (currentDir.includes(`${path9.sep}dist`)) {
+    templatesDir = path9.join(currentDir, "templates", subdir);
   } else {
-    templatesDir = path8.join(currentDir, subdir);
+    templatesDir = path9.join(currentDir, subdir);
   }
   return readTemplatesRecursively(templatesDir, "");
 }
@@ -4518,15 +4555,15 @@ function readTemplatesRecursively(dir, relativePath) {
   const templates = [];
   const entries2 = readdirSync(dir);
   for (const entry of entries2) {
-    const fullPath = path8.join(dir, entry);
+    const fullPath = path9.join(dir, entry);
     const stat3 = statSync(fullPath);
-    const entryRelativePath = relativePath ? path8.join(relativePath, entry) : entry;
+    const entryRelativePath = relativePath ? path9.join(relativePath, entry) : entry;
     if (stat3.isDirectory()) {
       templates.push(...readTemplatesRecursively(fullPath, entryRelativePath));
     } else {
       const content = readFileSync3(fullPath, "utf-8");
       templates.push({
-        path: entryRelativePath.split(path8.sep).join("/"),
+        path: entryRelativePath.split(path9.sep).join("/"),
         // Normalize to forward slashes
         content
       });
@@ -4555,22 +4592,22 @@ async function promptYesNo(message) {
   }
 }
 async function initCommand(options = {}) {
-  const targetPath = path9.resolve(options.targetPath ?? ".");
-  const agentvDir = path9.join(targetPath, ".agentv");
+  const targetPath = path10.resolve(options.targetPath ?? ".");
+  const agentvDir = path10.join(targetPath, ".agentv");
   const otherAgentvTemplates = getAgentvTemplates();
   const envTemplate = getEnvExampleTemplate();
   const existingFiles = [];
   if (envTemplate) {
-    const envFilePath = path9.join(targetPath, ".env.example");
+    const envFilePath = path10.join(targetPath, ".env.example");
     if (existsSync2(envFilePath)) {
       existingFiles.push(".env.example");
     }
   }
   if (existsSync2(agentvDir)) {
     for (const template of otherAgentvTemplates) {
-      const targetFilePath = path9.join(agentvDir, template.path);
+      const targetFilePath = path10.join(agentvDir, template.path);
       if (existsSync2(targetFilePath)) {
-        existingFiles.push(path9.relative(targetPath, targetFilePath));
+        existingFiles.push(path10.relative(targetPath, targetFilePath));
       }
     }
   }
@@ -4592,18 +4629,18 @@ async function initCommand(options = {}) {
     mkdirSync(agentvDir, { recursive: true });
   }
   if (envTemplate) {
-    const envFilePath = path9.join(targetPath, ".env.example");
+    const envFilePath = path10.join(targetPath, ".env.example");
     writeFileSync2(envFilePath, envTemplate.content, "utf-8");
     console.log("Created .env.example");
   }
   for (const template of otherAgentvTemplates) {
-    const targetFilePath = path9.join(agentvDir, template.path);
-    const targetDirPath = path9.dirname(targetFilePath);
+    const targetFilePath = path10.join(agentvDir, template.path);
+    const targetDirPath = path10.dirname(targetFilePath);
     if (!existsSync2(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync2(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path9.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path10.relative(targetPath, targetFilePath)}`);
   }
   console.log("\nAgentV initialized successfully!");
   console.log("\nFiles installed to root:");
@@ -4611,7 +4648,7 @@ async function initCommand(options = {}) {
     console.log("  - .env.example");
   }
   console.log(`
-Files installed to ${path9.relative(targetPath, agentvDir)}:`);
+Files installed to ${path10.relative(targetPath, agentvDir)}:`);
   for (const t of otherAgentvTemplates) {
     console.log(`  - ${t.path}`);
   }
@@ -4643,13 +4680,13 @@ var initCmdTsCommand = command({
 
 // src/commands/inspect/filter.ts
 import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 function collectIndexFiles(dir) {
   const files = [];
   try {
     const entries2 = readdirSync2(dir, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path10.join(dir, entry.name);
+      const fullPath = path11.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...collectIndexFiles(fullPath));
       } else if (entry.name === "index.jsonl") {
@@ -4700,7 +4737,7 @@ function parseFilterableRecords(filePath) {
     }
     let experiment = typeof raw.experiment === "string" ? raw.experiment : void 0;
     if (!experiment) {
-      const parts = filePath.split(path10.sep);
+      const parts = filePath.split(path11.sep);
       const runsIdx = parts.indexOf("runs");
       if (runsIdx !== -1 && parts.length - runsIdx >= 3) {
         const candidate = parts[runsIdx + 1];
@@ -4755,7 +4792,7 @@ function buildFilterPredicate(opts) {
 }
 function discoverFilterSources(searchPath, cwd) {
   if (searchPath) {
-    const resolved = path10.isAbsolute(searchPath) ? searchPath : path10.resolve(cwd, searchPath);
+    const resolved = path11.isAbsolute(searchPath) ? searchPath : path11.resolve(cwd, searchPath);
     if (!existsSync3(resolved)) {
       console.error(`${c.red}Error:${c.reset} Path does not exist: ${resolved}`);
       process.exit(1);
@@ -4768,7 +4805,7 @@ function discoverFilterSources(searchPath, cwd) {
     }
     return [resolved];
   }
-  return collectIndexFiles(path10.join(cwd, ".agentv", "results", "runs"));
+  return collectIndexFiles(path11.join(cwd, ".agentv", "results", "runs"));
 }
 function formatFilterTable(records) {
   const lines = [];
@@ -5042,7 +5079,7 @@ function parseAssertSpec(spec) {
     }
     default:
       throw new Error(
-        `Unsupported evaluator type: "${type}". Supported: ${SUPPORTED_TYPES.join(", ")}`
+        `Unsupported grader type: "${type}". Supported: ${SUPPORTED_TYPES.join(", ")}`
       );
   }
 }
@@ -5164,7 +5201,7 @@ var traceScoreCommand = command({
       type: string,
       long: "assert",
       short: "a",
-      description: "Evaluator spec: contains:<val>, regex:<pat>, is-json, equals:<val>, latency:<ms>, cost:<usd>, token-usage:<params>, execution-metrics:<params>"
+      description: "Grader spec: contains:<val>, regex:<pat>, is-json, equals:<val>, latency:<ms>, cost:<usd>, token-usage:<params>, execution-metrics:<params>"
     }),
     testId: option({
       type: optional(string),
@@ -5241,13 +5278,13 @@ var traceScoreCommand = command({
 
 // src/commands/inspect/search.ts
 import { existsSync as existsSync4, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 function collectJsonlFiles(dir) {
   const files = [];
   try {
     const entries2 = readdirSync3(dir, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path11.join(dir, entry.name);
+      const fullPath = path12.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...collectJsonlFiles(fullPath));
       } else if (entry.name.endsWith(".jsonl")) {
@@ -5306,7 +5343,7 @@ function searchJsonlFile(filePath, regex2, targetFilter, experimentFilter) {
 }
 function discoverSources(basePath, cwd) {
   if (basePath) {
-    const resolved = path11.isAbsolute(basePath) ? basePath : path11.resolve(cwd, basePath);
+    const resolved = path12.isAbsolute(basePath) ? basePath : path12.resolve(cwd, basePath);
     if (!existsSync4(resolved)) {
       console.error(`${c.red}Error:${c.reset} Path does not exist: ${resolved}`);
       process.exit(1);
@@ -5320,8 +5357,8 @@ function discoverSources(basePath, cwd) {
     return [resolved];
   }
   const sources = [];
-  sources.push(...collectJsonlFiles(path11.join(cwd, ".agentv", "results", "runs")));
-  sources.push(...collectJsonlFiles(path11.join(cwd, ".agentv", "transcripts")));
+  sources.push(...collectJsonlFiles(path12.join(cwd, ".agentv", "results", "runs")));
+  sources.push(...collectJsonlFiles(path12.join(cwd, ".agentv", "transcripts")));
   return sources;
 }
 function formatSearchResults(matches, pattern) {
@@ -5873,7 +5910,7 @@ import { readFile as readFile2, readdir, writeFile as writeFile5 } from "node:fs
 import { join } from "node:path";
 var evalBenchCommand = command({
   name: "bench",
-  description: "Merge evaluator scores and produce benchmark artifacts",
+  description: "Merge grader scores and produce benchmark artifacts",
   args: {
     exportDir: positional({
       type: string,
@@ -6862,7 +6899,7 @@ var pipelineCommand = subcommands({
 });
 
 // src/commands/results/export.ts
-import path12 from "node:path";
+import path13 from "node:path";
 
 // src/commands/results/shared.ts
 import { existsSync as existsSync7 } from "node:fs";
@@ -6909,20 +6946,20 @@ async function loadResults(source, cwd) {
 
 // src/commands/results/export.ts
 function deriveOutputDir(cwd, sourceFile) {
-  if (path12.basename(sourceFile) !== RESULT_INDEX_FILENAME) {
+  if (path13.basename(sourceFile) !== RESULT_INDEX_FILENAME) {
     throw new Error(`Expected a run manifest named ${RESULT_INDEX_FILENAME}: ${sourceFile}`);
   }
-  const runDir = path12.dirname(sourceFile);
-  const segments = path12.normalize(runDir).split(path12.sep).filter(Boolean);
+  const runDir = path13.dirname(sourceFile);
+  const segments = path13.normalize(runDir).split(path13.sep).filter(Boolean);
   const runsIndex = segments.lastIndexOf("runs");
   if (runsIndex >= 0 && runsIndex < segments.length - 1) {
-    return path12.join(cwd, ".agentv", "results", "export", ...segments.slice(runsIndex + 1));
+    return path13.join(cwd, ".agentv", "results", "export", ...segments.slice(runsIndex + 1));
   }
-  const parentDir = path12.basename(runDir);
+  const parentDir = path13.basename(runDir);
   if (parentDir.startsWith("eval_")) {
-    return path12.join(cwd, ".agentv", "results", "export", parentDir.slice(5));
+    return path13.join(cwd, ".agentv", "results", "export", parentDir.slice(5));
   }
-  return path12.join(cwd, ".agentv", "results", "export", parentDir);
+  return path13.join(cwd, ".agentv", "results", "export", parentDir);
 }
 async function loadExportSource(source, cwd) {
   const { sourceFile } = await resolveSourceFile(source, cwd);
@@ -6955,7 +6992,7 @@ var resultsExportCommand = command({
     const cwd = dir ?? process.cwd();
     try {
       const { sourceFile, results } = await loadExportSource(source, cwd);
-      const outputDir = out ? path12.isAbsolute(out) ? out : path12.resolve(cwd, out) : deriveOutputDir(cwd, sourceFile);
+      const outputDir = out ? path13.isAbsolute(out) ? out : path13.resolve(cwd, out) : deriveOutputDir(cwd, sourceFile);
       await writeArtifactsFromResults(results, outputDir, {
         evalFile: sourceFile
       });
@@ -7016,7 +7053,7 @@ var resultsFailuresCommand = command({
 
 // src/commands/results/report.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 
 // src/commands/results/report-template.ts
 var RESULTS_REPORT_TEMPLATE = `<!DOCTYPE html>
@@ -8640,10 +8677,10 @@ function normalizeEvalFileLabel(value) {
   if (!trimmed) {
     return void 0;
   }
-  return path13.basename(trimmed).replace(/\.results\.jsonl$/i, "").replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "").replace(/\.jsonl$/i, "");
+  return path14.basename(trimmed).replace(/\.results\.jsonl$/i, "").replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "").replace(/\.jsonl$/i, "");
 }
 function readBenchmarkEvalFile(sourceFile) {
-  const benchmarkPath = path13.join(path13.dirname(sourceFile), "benchmark.json");
+  const benchmarkPath = path14.join(path14.dirname(sourceFile), "benchmark.json");
   if (!existsSync8(benchmarkPath)) {
     return void 0;
   }
@@ -8655,10 +8692,10 @@ function readBenchmarkEvalFile(sourceFile) {
   }
 }
 function deriveReportPath(sourceFile) {
-  return path13.join(path13.dirname(sourceFile), "report.html");
+  return path14.join(path14.dirname(sourceFile), "report.html");
 }
 function serializeReportResult(result, sourceFile, manifestRecord, benchmarkEvalFile) {
-  const fallbackEvalFile = normalizeEvalFileLabel(manifestRecord?.eval_file) ?? benchmarkEvalFile ?? normalizeEvalFileLabel(result.suite) ?? path13.basename(path13.dirname(sourceFile));
+  const fallbackEvalFile = normalizeEvalFileLabel(manifestRecord?.eval_file) ?? benchmarkEvalFile ?? normalizeEvalFileLabel(result.suite) ?? path14.basename(path14.dirname(sourceFile));
   return {
     timestamp: result.timestamp,
     test_id: result.testId,
@@ -8706,9 +8743,9 @@ function renderResultsReport(results, sourceFile, records, benchmarkEvalFile) {
 }
 async function writeResultsReport(source, outputPath, cwd) {
   const { sourceFile, results, records, benchmarkEvalFile } = await loadReportSource(source, cwd);
-  const resolvedOutputPath = outputPath ? path13.isAbsolute(outputPath) ? outputPath : path13.resolve(cwd, outputPath) : deriveReportPath(sourceFile);
+  const resolvedOutputPath = outputPath ? path14.isAbsolute(outputPath) ? outputPath : path14.resolve(cwd, outputPath) : deriveReportPath(sourceFile);
   const html = renderResultsReport(results, sourceFile, records, benchmarkEvalFile);
-  mkdirSync2(path13.dirname(resolvedOutputPath), { recursive: true });
+  mkdirSync2(path14.dirname(resolvedOutputPath), { recursive: true });
   writeFileSync3(resolvedOutputPath, html, "utf8");
   const written = readFileSync7(resolvedOutputPath, "utf8");
   if (written.includes("__DATA_PLACEHOLDER__")) {
@@ -8896,10 +8933,10 @@ var resultsSummaryCommand = command({
 
 // src/commands/results/validate.ts
 import { existsSync as existsSync10, readFileSync as readFileSync9, statSync as statSync4 } from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 function checkDirectoryNaming(runDir) {
-  const dirName = path14.basename(runDir);
-  const pathSegments = path14.normalize(runDir).split(path14.sep).filter(Boolean);
+  const dirName = path15.basename(runDir);
+  const pathSegments = path15.normalize(runDir).split(path15.sep).filter(Boolean);
   const runsIndex = pathSegments.lastIndexOf("runs");
   const diagnostics = [];
   if (runsIndex < 0 || runsIndex >= pathSegments.length - 1) {
@@ -8929,7 +8966,7 @@ function validateRunDirectory(runDir) {
   return { diagnostics, entries: entries2 };
 }
 function checkIndexJsonl(runDir) {
-  const indexPath = path14.join(runDir, "index.jsonl");
+  const indexPath = path15.join(runDir, "index.jsonl");
   const diagnostics = [];
   const entries2 = [];
   if (!existsSync10(indexPath)) {
@@ -8978,7 +9015,7 @@ function checkIndexJsonl(runDir) {
       if (!entry.scores || !Array.isArray(entry.scores) || entry.scores.length === 0) {
         diagnostics.push({
           severity: "warning",
-          message: `index.jsonl line ${i + 1} (${entry.test_id ?? "?"}): missing 'scores[]' array \u2014 dashboard may not show per-evaluator breakdown`
+          message: `index.jsonl line ${i + 1} (${entry.test_id ?? "?"}): missing 'scores[]' array \u2014 dashboard may not show per-grader breakdown`
         });
       } else {
         for (let j = 0; j < entry.scores.length; j++) {
@@ -9028,7 +9065,7 @@ function checkArtifactFiles(runDir, entries2) {
   for (const entry of entries2) {
     const testId = entry.test_id ?? "?";
     if (entry.grading_path) {
-      const gradingPath = path14.join(runDir, entry.grading_path);
+      const gradingPath = path15.join(runDir, entry.grading_path);
       if (!existsSync10(gradingPath)) {
         diagnostics.push({
           severity: "error",
@@ -9058,7 +9095,7 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
     if (entry.timing_path) {
-      const timingPath = path14.join(runDir, entry.timing_path);
+      const timingPath = path15.join(runDir, entry.timing_path);
       if (!existsSync10(timingPath)) {
         diagnostics.push({
           severity: "warning",
@@ -9067,7 +9104,7 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
   }
-  const benchmarkPath = path14.join(runDir, "benchmark.json");
+  const benchmarkPath = path15.join(runDir, "benchmark.json");
   if (!existsSync10(benchmarkPath)) {
     diagnostics.push({ severity: "warning", message: "benchmark.json is missing" });
   }
@@ -9084,7 +9121,7 @@ var resultsValidateCommand = command({
     })
   },
   handler: async ({ runDir }) => {
-    const resolvedDir = path14.resolve(runDir);
+    const resolvedDir = path15.resolve(runDir);
     if (!existsSync10(resolvedDir) || !statSync4(resolvedDir).isDirectory()) {
       console.error(`Error: '${runDir}' is not a directory`);
       process.exit(1);
@@ -9128,14 +9165,14 @@ var resultsCommand = subcommands({
 
 // src/commands/results/serve.ts
 import { existsSync as existsSync14, readFileSync as readFileSync12, readdirSync as readdirSync4, statSync as statSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import path18 from "node:path";
+import path19 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { Hono } from "hono";
 
 // src/commands/results/eval-runner.ts
 import { execFileSync, spawn } from "node:child_process";
 import { existsSync as existsSync11 } from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var activeRuns = /* @__PURE__ */ new Map();
 function generateRunId() {
@@ -9157,7 +9194,7 @@ async function discoverTargetsInProject(cwd) {
   const repoRoot = await findRepoRoot(cwd) ?? cwd;
   let targetsFilePath;
   for (const candidate of TARGET_FILE_CANDIDATES) {
-    const fullPath = path15.join(cwd, candidate);
+    const fullPath = path16.join(cwd, candidate);
     if (existsSync11(fullPath)) {
       targetsFilePath = fullPath;
       break;
@@ -9165,7 +9202,7 @@ async function discoverTargetsInProject(cwd) {
   }
   if (!targetsFilePath) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const fullPath = path15.join(repoRoot, candidate);
+      const fullPath = path16.join(repoRoot, candidate);
       if (existsSync11(fullPath)) {
         targetsFilePath = fullPath;
         break;
@@ -9215,17 +9252,17 @@ function buildCliPreview(args) {
 }
 function resolveCliPath(cwd) {
   const candidates = [
-    path15.join(cwd, "apps/cli/src/cli.ts"),
-    path15.join(cwd, "apps/cli/dist/cli.js")
+    path16.join(cwd, "apps/cli/src/cli.ts"),
+    path16.join(cwd, "apps/cli/dist/cli.js")
   ];
   for (const c4 of candidates) {
     if (existsSync11(c4)) {
       return { binPath: "bun", args: [c4] };
     }
   }
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path15.dirname(fileURLToPath2(import.meta.url));
-  const fromSrc = path15.resolve(currentDir, "../../../cli.ts");
-  const fromDist = path15.resolve(currentDir, "../../cli.js");
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path16.dirname(fileURLToPath2(import.meta.url));
+  const fromSrc = path16.resolve(currentDir, "../../../cli.ts");
+  const fromDist = path16.resolve(currentDir, "../../cli.js");
   if (existsSync11(fromSrc)) return { binPath: "bun", args: [fromSrc] };
   if (existsSync11(fromDist)) return { binPath: "bun", args: [fromDist] };
   if (isCommandAvailable("agentv")) {
@@ -9516,12 +9553,12 @@ Process error: ${err2.message}`;
 
 // src/commands/results/run-tags.ts
 import { existsSync as existsSync12, readFileSync as readFileSync10, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 var RUN_TAGS_FILENAME = "tags.json";
 var MAX_TAGS_PER_RUN = 20;
 var MAX_TAG_LENGTH = 60;
 function runTagsPath(manifestPath) {
-  return path16.join(path16.dirname(manifestPath), RUN_TAGS_FILENAME);
+  return path17.join(path17.dirname(manifestPath), RUN_TAGS_FILENAME);
 }
 function readRunTags(manifestPath) {
   const fp = runTagsPath(manifestPath);
@@ -9593,13 +9630,13 @@ function normalizeTags(tags) {
 
 // src/commands/results/studio-config.ts
 import { existsSync as existsSync13, mkdirSync as mkdirSync3, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 import { parse as parseYaml, stringify as stringifyYaml2 } from "yaml";
 var DEFAULTS = {
   threshold: DEFAULT_THRESHOLD
 };
 function loadStudioConfig(agentvDir) {
-  const configPath = path17.join(agentvDir, "config.yaml");
+  const configPath = path18.join(agentvDir, "config.yaml");
   if (!existsSync13(configPath)) {
     return { ...DEFAULTS };
   }
@@ -9628,7 +9665,7 @@ function saveStudioConfig(agentvDir, config) {
   if (!existsSync13(agentvDir)) {
     mkdirSync3(agentvDir, { recursive: true });
   }
-  const configPath = path17.join(agentvDir, "config.yaml");
+  const configPath = path18.join(agentvDir, "config.yaml");
   let existing = {};
   if (existsSync13(configPath)) {
     const raw = readFileSync11(configPath, "utf-8");
@@ -9692,7 +9729,7 @@ function resolveDashboardMode(projectCount, options) {
   return { isMultiProject: projectCount > 1, showMultiWarning: false };
 }
 function feedbackPath(resultDir) {
-  return path18.join(resultDir, "feedback.json");
+  return path19.join(resultDir, "feedback.json");
 }
 function readFeedback(cwd) {
   const fp = feedbackPath(cwd);
@@ -9719,8 +9756,8 @@ function buildFileTree(dirPath, relativeTo) {
     if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
     return a.name.localeCompare(b.name);
   }).map((entry) => {
-    const fullPath = path18.join(dirPath, entry.name);
-    const relPath = path18.relative(relativeTo, fullPath);
+    const fullPath = path19.join(dirPath, entry.name);
+    const relPath = path19.relative(relativeTo, fullPath);
     if (entry.isDirectory()) {
       return {
         name: entry.name,
@@ -9733,7 +9770,7 @@ function buildFileTree(dirPath, relativeTo) {
   });
 }
 function inferLanguage(filePath) {
-  const ext = path18.extname(filePath).toLowerCase();
+  const ext = path19.extname(filePath).toLowerCase();
   const langMap = {
     ".json": "json",
     ".jsonl": "json",
@@ -9938,7 +9975,7 @@ async function handleEvalFiles(c4, { searchDir }) {
     const records = parseResultManifest(content);
     const record = records.find((r) => r.test_id === evalId);
     if (!record) return c4.json({ error: "Eval not found" }, 404);
-    const baseDir = path18.dirname(meta.path);
+    const baseDir = path19.dirname(meta.path);
     const knownPaths = [
       record.grading_path,
       record.timing_path,
@@ -9947,14 +9984,14 @@ async function handleEvalFiles(c4, { searchDir }) {
       record.response_path
     ].filter((p) => !!p);
     if (knownPaths.length === 0) return c4.json({ files: [] });
-    const artifactDirs = knownPaths.map((p) => path18.dirname(p));
+    const artifactDirs = knownPaths.map((p) => path19.dirname(p));
     let commonDir = artifactDirs[0];
     for (const dir of artifactDirs) {
       while (!dir.startsWith(commonDir)) {
-        commonDir = path18.dirname(commonDir);
+        commonDir = path19.dirname(commonDir);
       }
     }
-    const artifactAbsDir = path18.join(baseDir, commonDir);
+    const artifactAbsDir = path19.join(baseDir, commonDir);
     const files = buildFileTree(artifactAbsDir, baseDir);
     return c4.json({ files });
   } catch {
@@ -9969,9 +10006,9 @@ async function handleEvalFileContent(c4, { searchDir }) {
   const markerIdx = c4.req.path.indexOf(marker);
   const filePath = markerIdx >= 0 ? c4.req.path.slice(markerIdx + marker.length) : "";
   if (!filePath) return c4.json({ error: "No file path specified" }, 400);
-  const baseDir = path18.dirname(meta.path);
-  const absolutePath = path18.resolve(baseDir, filePath);
-  if (!absolutePath.startsWith(path18.resolve(baseDir) + path18.sep) && absolutePath !== path18.resolve(baseDir)) {
+  const baseDir = path19.dirname(meta.path);
+  const absolutePath = path19.resolve(baseDir, filePath);
+  if (!absolutePath.startsWith(path19.resolve(baseDir) + path19.sep) && absolutePath !== path19.resolve(baseDir)) {
     return c4.json({ error: "Path traversal not allowed" }, 403);
   }
   if (!existsSync14(absolutePath) || !statSync5(absolutePath).isFile()) {
@@ -10191,12 +10228,12 @@ function handleConfig(c4, { agentvDir, searchDir }, options) {
   return c4.json({
     ...loadStudioConfig(agentvDir),
     read_only: options?.readOnly === true,
-    project_name: path18.basename(searchDir),
+    project_name: path19.basename(searchDir),
     multi_project_dashboard: options?.multiProjectDashboard === true
   });
 }
 function handleFeedbackRead(c4, { searchDir }) {
-  const resultsDir = path18.join(searchDir, ".agentv", "results");
+  const resultsDir = path19.join(searchDir, ".agentv", "results");
   return c4.json(readFeedback(existsSync14(resultsDir) ? resultsDir : searchDir));
 }
 async function handleRunTagsPut(c4, { searchDir }) {
@@ -10245,7 +10282,7 @@ async function handleRunTagsDelete(c4, { searchDir }) {
 }
 function createApp(results, resultDir, cwd, sourceFile, options) {
   const searchDir = cwd ?? resultDir;
-  const agentvDir = path18.join(searchDir, ".agentv");
+  const agentvDir = path19.join(searchDir, ".agentv");
   const defaultCtx = { searchDir, agentvDir };
   const readOnly = options?.readOnly === true;
   const app2 = new Hono();
@@ -10256,7 +10293,7 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     }
     return handler(c4, {
       searchDir: benchmark.path,
-      agentvDir: path18.join(benchmark.path, ".agentv")
+      agentvDir: path19.join(benchmark.path, ".agentv")
     });
   }
   app2.post("/api/config", async (c4) => {
@@ -10583,20 +10620,20 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     { readOnly }
   );
   const studioDistPath = options?.studioDir ?? resolveStudioDistDir();
-  if (!studioDistPath || !existsSync14(path18.join(studioDistPath, "index.html"))) {
+  if (!studioDistPath || !existsSync14(path19.join(studioDistPath, "index.html"))) {
     throw new Error('Studio dist not found. Run "bun run build" in apps/studio/ to build the SPA.');
   }
   app2.get("/", (c4) => {
-    const indexPath = path18.join(studioDistPath, "index.html");
+    const indexPath = path19.join(studioDistPath, "index.html");
     if (existsSync14(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
     return c4.notFound();
   });
   app2.get("/assets/*", (c4) => {
     const assetPath = c4.req.path;
-    const filePath = path18.join(studioDistPath, assetPath);
+    const filePath = path19.join(studioDistPath, assetPath);
     if (!existsSync14(filePath)) return c4.notFound();
     const content = readFileSync12(filePath);
-    const ext = path18.extname(filePath);
+    const ext = path19.extname(filePath);
     const mimeTypes = {
       ".js": "application/javascript",
       ".css": "text/css",
@@ -10617,26 +10654,26 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
   });
   app2.get("*", (c4) => {
     if (c4.req.path.startsWith("/api/")) return c4.json({ error: "Not found" }, 404);
-    const indexPath = path18.join(studioDistPath, "index.html");
+    const indexPath = path19.join(studioDistPath, "index.html");
     if (existsSync14(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
     return c4.notFound();
   });
   return app2;
 }
 function resolveStudioDistDir() {
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path18.dirname(fileURLToPath3(import.meta.url));
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path19.dirname(fileURLToPath3(import.meta.url));
   const candidates = [
     // From src/commands/results/ → sibling apps/studio/dist
-    path18.resolve(currentDir, "../../../../studio/dist"),
+    path19.resolve(currentDir, "../../../../studio/dist"),
     // From dist/ → sibling apps/studio/dist (monorepo dev)
-    path18.resolve(currentDir, "../../studio/dist"),
+    path19.resolve(currentDir, "../../studio/dist"),
     // Bundled inside CLI dist (published package: dist/studio/)
-    path18.resolve(currentDir, "studio"),
+    path19.resolve(currentDir, "studio"),
     // From dist/ in monorepo root context
-    path18.resolve(currentDir, "../../../apps/studio/dist")
+    path19.resolve(currentDir, "../../../apps/studio/dist")
   ];
   for (const candidate of candidates) {
-    if (existsSync14(candidate) && existsSync14(path18.join(candidate, "index.html"))) {
+    if (existsSync14(candidate) && existsSync14(path19.join(candidate, "index.html"))) {
       return candidate;
     }
   }
@@ -10753,7 +10790,7 @@ Discovered ${discovered.length} project(s).`);
           }
         }
       }
-      const resultDir = sourceFile ? path18.dirname(path18.resolve(sourceFile)) : cwd;
+      const resultDir = sourceFile ? path19.dirname(path19.resolve(sourceFile)) : cwd;
       const app2 = createApp(results, resultDir, cwd, sourceFile, {
         readOnly,
         multiProjectDashboard: isMultiProject
@@ -10878,7 +10915,7 @@ var selfCommand = subcommands({
 
 // src/commands/transpile/index.ts
 import { writeFileSync as writeFileSync7 } from "node:fs";
-import path19 from "node:path";
+import path20 from "node:path";
 var transpileCommand = command({
   name: "transpile",
   description: "Convert an EVAL.yaml file to Agent Skills evals.json format",
@@ -10902,7 +10939,7 @@ var transpileCommand = command({
   handler: async ({ input, outDir, stdout }) => {
     let result;
     try {
-      result = transpileEvalYamlFile(path19.resolve(input));
+      result = transpileEvalYamlFile(path20.resolve(input));
     } catch (error) {
       console.error(`Error: ${error.message}`);
       process.exit(1);
@@ -10926,11 +10963,11 @@ var transpileCommand = command({
       process.stdout.write("\n");
       return;
     }
-    const outputDir = outDir ? path19.resolve(outDir) : path19.dirname(path19.resolve(input));
+    const outputDir = outDir ? path20.resolve(outDir) : path20.dirname(path20.resolve(input));
     const fileNames = getOutputFilenames(result);
     for (const [skill, evalsJson] of result.files) {
       const fileName = fileNames.get(skill) ?? "evals.json";
-      const outputPath = path19.join(outputDir, fileName);
+      const outputPath = path20.join(outputDir, fileName);
       writeFileSync7(outputPath, `${JSON.stringify(evalsJson, null, 2)}
 `);
       console.log(`Transpiled to ${outputPath}`);
@@ -10939,7 +10976,7 @@ var transpileCommand = command({
 });
 
 // src/commands/trend/index.ts
-import path20 from "node:path";
+import path21 from "node:path";
 var colors2 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -10989,7 +11026,7 @@ function colorizeSlope(value) {
 }
 function ensureTrendIndexPath(source, cwd) {
   const resolved = resolveResultSourcePath(source, cwd);
-  if (path20.basename(resolved) !== RESULT_INDEX_FILENAME) {
+  if (path21.basename(resolved) !== RESULT_INDEX_FILENAME) {
     throw new Error(
       `Unsupported result source for trend: ${source}. Use a run workspace directory or ${RESULT_INDEX_FILENAME} manifest.`
     );
@@ -11009,7 +11046,7 @@ function resolveTrendSources(cwd, sources, last) {
   if (last < 2) {
     throw new Error("--last must be at least 2");
   }
-  const metas = listResultFiles(cwd).filter((meta) => path20.basename(meta.path) === RESULT_INDEX_FILENAME).slice(0, last);
+  const metas = listResultFiles(cwd).filter((meta) => path21.basename(meta.path) === RESULT_INDEX_FILENAME).slice(0, last);
   if (metas.length < 2) {
     throw new Error(
       "Trend analysis requires at least 2 canonical run workspaces in .agentv/results/runs/"
@@ -11024,10 +11061,10 @@ function getRunLabel(sourcePath, timestamp) {
   if (timestamp) {
     return timestamp;
   }
-  return path20.basename(path20.dirname(sourcePath));
+  return path21.basename(path21.dirname(sourcePath));
 }
 function getRunSortKey(sourcePath, timestamp) {
-  return timestamp ?? path20.basename(path20.dirname(sourcePath));
+  return timestamp ?? path21.basename(path21.dirname(sourcePath));
 }
 function mean2(values) {
   return values.reduce((sum, value) => sum + value, 0) / values.length;
@@ -11408,7 +11445,7 @@ function isTTY() {
 // src/commands/validate/validate-files.ts
 import { constants } from "node:fs";
 import { access, readdir as readdir4, stat } from "node:fs/promises";
-import path21 from "node:path";
+import path22 from "node:path";
 import fg2 from "fast-glob";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
@@ -11423,7 +11460,7 @@ async function validateFiles(paths) {
   };
 }
 async function validateSingleFile(filePath) {
-  const absolutePath = path21.resolve(filePath);
+  const absolutePath = path22.resolve(filePath);
   const fileType = await detectFileType(absolutePath);
   let result;
   if (fileType === "eval") {
@@ -11467,7 +11504,7 @@ async function validateSingleFile(filePath) {
 async function expandPaths(paths) {
   const expanded = /* @__PURE__ */ new Set();
   for (const inputPath of paths) {
-    const absolutePath = path21.resolve(inputPath);
+    const absolutePath = path22.resolve(inputPath);
     try {
       await access(absolutePath, constants.F_OK);
       const stats = await stat(absolutePath);
@@ -11495,7 +11532,7 @@ async function expandPaths(paths) {
     if (yamlMatches.length === 0) {
       console.warn(`Warning: No YAML files matched pattern: ${inputPath}`);
     }
-    for (const f of yamlMatches) expanded.add(path21.normalize(f));
+    for (const f of yamlMatches) expanded.add(path22.normalize(f));
   }
   const sorted = Array.from(expanded);
   sorted.sort();
@@ -11506,7 +11543,7 @@ async function findYamlFiles(dirPath) {
   try {
     const entries2 = await readdir4(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path21.join(dirPath, entry.name);
+      const fullPath = path22.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -11523,11 +11560,11 @@ async function findYamlFiles(dirPath) {
   return results;
 }
 function isYamlFile(filePath) {
-  const ext = path21.extname(filePath).toLowerCase();
+  const ext = path22.extname(filePath).toLowerCase();
   return ext === ".yaml" || ext === ".yml";
 }
 function isEvalYamlFile(filePath) {
-  const lower = path21.basename(filePath).toLowerCase();
+  const lower = path22.basename(filePath).toLowerCase();
   return lower.endsWith(".eval.yaml") || lower.endsWith(".eval.yml");
 }
 
@@ -11584,7 +11621,7 @@ var validateCommand = command({
 // src/commands/workspace/clean.ts
 import { existsSync as existsSync15 } from "node:fs";
 import { readFile as readFile6, readdir as readdir5, rm } from "node:fs/promises";
-import path22 from "node:path";
+import path23 from "node:path";
 async function confirm(message) {
   const readline2 = await import("node:readline");
   const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
@@ -11620,8 +11657,8 @@ var cleanCommand = command({
       const poolDirs = entries2.filter((e) => e.isDirectory());
       const matchingDirs = [];
       for (const dir of poolDirs) {
-        const poolDir = path22.join(poolRoot, dir.name);
-        const metadataPath = path22.join(poolDir, "metadata.json");
+        const poolDir = path23.join(poolRoot, dir.name);
+        const metadataPath = path23.join(poolDir, "metadata.json");
         try {
           const raw = await readFile6(metadataPath, "utf-8");
           const metadata = JSON.parse(raw);
@@ -11652,7 +11689,7 @@ var cleanCommand = command({
       }
       for (const dir of matchingDirs) {
         await rm(dir, { recursive: true, force: true });
-        console.log(`Removed: ${path22.basename(dir).slice(0, 12)}...`);
+        console.log(`Removed: ${path23.basename(dir).slice(0, 12)}...`);
       }
       console.log("Done.");
     } else {
@@ -11670,7 +11707,7 @@ var cleanCommand = command({
 });
 
 // src/commands/workspace/deps.ts
-import path23 from "node:path";
+import path24 from "node:path";
 var depsCommand = command({
   name: "deps",
   description: "Scan eval files and list git repo dependencies needed by workspaces",
@@ -11694,7 +11731,7 @@ var depsCommand = command({
     const resolvedPaths = await resolveEvalPaths(evalPaths, cwd);
     const result = await scanRepoDeps(resolvedPaths);
     for (const err2 of result.errors) {
-      console.error(`warning: ${path23.relative(cwd, err2.file)}: ${err2.message}`);
+      console.error(`warning: ${path24.relative(cwd, err2.file)}: ${err2.message}`);
     }
     const output = {
       repos: result.repos.map((r) => ({
@@ -11702,7 +11739,7 @@ var depsCommand = command({
         ...r.ref !== void 0 && { ref: r.ref },
         ...r.clone !== void 0 && { clone: r.clone },
         ...r.checkout !== void 0 && { checkout: r.checkout },
-        ...usedBy && { used_by: r.usedBy.map((p) => path23.relative(cwd, p)) }
+        ...usedBy && { used_by: r.usedBy.map((p) => path24.relative(cwd, p)) }
       }))
     };
     console.log(JSON.stringify(output, null, 2));
@@ -11712,13 +11749,13 @@ var depsCommand = command({
 // src/commands/workspace/list.ts
 import { existsSync as existsSync16 } from "node:fs";
 import { readFile as readFile7, readdir as readdir6, stat as stat2 } from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
     const entries2 = await readdir6(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path24.join(dirPath, entry.name);
+      const fullPath = path25.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(fullPath);
       } else {
@@ -11753,11 +11790,11 @@ var listCommand = command({
       return;
     }
     for (const dir of poolDirs) {
-      const poolDir = path24.join(poolRoot, dir.name);
+      const poolDir = path25.join(poolRoot, dir.name);
       const fingerprint = dir.name;
       const poolEntries = await readdir6(poolDir, { withFileTypes: true });
       const slots = poolEntries.filter((e) => e.isDirectory() && e.name.startsWith("slot-"));
-      const metadataPath = path24.join(poolDir, "metadata.json");
+      const metadataPath = path25.join(poolDir, "metadata.json");
       let metadata = null;
       try {
         const raw = await readFile7(metadataPath, "utf-8");
@@ -11804,8 +11841,8 @@ var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var CONFIG_DIR = getAgentvConfigDir();
 var CACHE_FILE = "version-check.json";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/agentv/latest";
-async function getCachedUpdateInfo(path25) {
-  const filePath = path25 ?? join5(CONFIG_DIR, CACHE_FILE);
+async function getCachedUpdateInfo(path26) {
+  const filePath = path26 ?? join5(CONFIG_DIR, CACHE_FILE);
   try {
     const raw = await readFile8(filePath, "utf-8");
     const data = JSON.parse(raw);
@@ -11907,7 +11944,7 @@ var app = subcommands({
     workspace: workspaceCommand
   }
 });
-var EVAL_SUBCOMMANDS = /* @__PURE__ */ new Set(["run", "assert"]);
+var EVAL_SUBCOMMANDS = /* @__PURE__ */ new Set(["run", "assert", "aggregate"]);
 var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
   "import",
   "inspect",
@@ -11966,4 +12003,4 @@ export {
   preprocessArgv,
   runCli
 };
-//# sourceMappingURL=chunk-ILIM6IIX.js.map
+//# sourceMappingURL=chunk-L7WOR7IR.js.map