agentv 4.27.0 → 4.28.0-next.1

package/dist/{chunk-PH5MHKPL.js → chunk-UV7G7TWO.js}

@@ -45,7 +45,7 @@ import {
   validateFileReferences,
   validateTargetsFile,
   validateWorkspacePaths
-} from "./chunk-VO3THAOI.js";
+} from "./chunk-XM4CHF6C.js";
 import {
   RESULT_INDEX_FILENAME,
   aggregateRunDir,
@@ -53,7 +53,7 @@ import {
   resolveRunManifestPath,
   toSnakeCaseDeep as toSnakeCaseDeep2,
   writeArtifactsFromResults
-} from "./chunk-TWBKRGXR.js";
+} from "./chunk-7T6AF75O.js";
 import {
   DEFAULT_CATEGORY,
   addBenchmark,
@@ -69,10 +69,11 @@ import {
   removeBenchmark,
   runBeforeSessionHook,
   scanRepoDeps,
+  syncBenchmarks,
   toTranscriptJsonLines,
   transpileEvalYamlFile,
   trimBaselineResult
-} from "./chunk-6BAB3XBI.js";
+} from "./chunk-WZVOY2W2.js";
 import {
   DEFAULT_THRESHOLD,
   createBuiltinRegistry,
@@ -102,7 +103,7 @@ import {
   runStartsWithAssertion,
   toCamelCaseDeep,
   toSnakeCaseDeep
-} from "./chunk-VOOYHYPR.js";
+} from "./chunk-VTOY4SMC.js";
 import {
   __commonJS,
   __require,
@@ -863,7 +864,7 @@ var require_src = __commonJS({
 });
 
 // src/index.ts
-import path27 from "node:path";
+import path28 from "node:path";
 
 // ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -3654,8 +3655,63 @@ var createCommand = subcommands({
   }
 });
 
-// src/commands/eval/commands/aggregate.ts
+// src/commands/doctor/index.ts
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
 import path3 from "node:path";
+var DEPS = [];
+function findBinary(name) {
+  const localBin = path3.join(getAgentvConfigDir(), "bin", name);
+  if (existsSync(localBin)) return localBin;
+  const pathDirs = (process.env.PATH ?? "").split(path3.delimiter);
+  for (const dir of pathDirs) {
+    const candidate = path3.join(dir, name);
+    if (existsSync(candidate)) return candidate;
+  }
+  return void 0;
+}
+function getBinaryVersion(binaryPath) {
+  try {
+    const output = execFileSync(binaryPath, ["--version"], { stdio: "pipe", encoding: "utf-8" });
+    return output.trim().split("\n")[0] ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var doctorCommand = command({
+  name: "doctor",
+  description: "Check external dependencies required by agentv",
+  args: {},
+  handler: () => {
+    const binDir = path3.join(getAgentvConfigDir(), "bin");
+    console.log("agentv doctor\n");
+    console.log(`Local bin dir: ${binDir}
+`);
+    let allPresent = true;
+    for (const dep of DEPS) {
+      const binaryPath = findBinary(dep.name);
+      if (binaryPath) {
+        const version = getBinaryVersion(binaryPath);
+        console.log(`  \u2713 ${dep.name}`);
+        console.log(`      path:    ${binaryPath}`);
+        console.log(`      version: ${version}`);
+        console.log(`      note:    ${dep.description}`);
+      } else {
+        allPresent = false;
+        console.log(`  \u2717 ${dep.name}  (not found)`);
+        console.log(`      note:    ${dep.description}`);
+        console.log(`      install: ${dep.installHint}`);
+      }
+      console.log();
+    }
+    if (!allPresent) {
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/eval/commands/aggregate.ts
+import path4 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.",
@@ -3667,7 +3723,7 @@ var evalAggregateCommand = command({
     })
   },
   handler: async (args) => {
-    const runDir = path3.resolve(args.runDir);
+    const runDir = path4.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}`);
@@ -3677,7 +3733,7 @@ var evalAggregateCommand = command({
 
 // src/commands/eval/commands/assert.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 import fg from "fast-glob";
 var evalAssertCommand = command({
   name: "assert",
@@ -3708,7 +3764,7 @@ var evalAssertCommand = command({
     let resolvedOutput;
     let resolvedInput;
     if (file) {
-      const content = JSON.parse(readFileSync2(path4.resolve(file), "utf8"));
+      const content = JSON.parse(readFileSync2(path5.resolve(file), "utf8"));
       resolvedOutput = content.output ?? "";
       resolvedInput = content.input ?? "";
     } else {
@@ -3774,11 +3830,11 @@ var evalAssertCommand = command({
   }
 });
 async function findGraderScript(graderName, startDir) {
-  let dir = path4.resolve(startDir);
-  const root = path4.parse(dir).root;
+  let dir = path5.resolve(startDir);
+  const root = path5.parse(dir).root;
   while (dir !== root) {
     for (const subdir of ["graders", "judges"]) {
-      const gradersDir = path4.join(dir, ".agentv", subdir);
+      const gradersDir = path5.join(dir, ".agentv", subdir);
       const found = await fg([`${graderName}.{ts,js,mts,mjs}`], {
         cwd: gradersDir,
         absolute: true,
@@ -3786,7 +3842,7 @@ async function findGraderScript(graderName, startDir) {
       });
       if (found.length > 0) return found[0];
     }
-    dir = path4.dirname(dir);
+    dir = path5.dirname(dir);
   }
   return null;
 }
@@ -3997,7 +4053,7 @@ var evalRunCommand = command({
   },
   handler: async (args) => {
     if (args.evalPaths.length === 0 && process.stdin.isTTY) {
-      const { launchInteractiveWizard } = await import("./interactive-UG4YNLYK.js");
+      const { launchInteractiveWizard } = await import("./interactive-MMQ6OO6X.js");
       await launchInteractiveWizard();
       return;
     }
@@ -4075,7 +4131,7 @@ var evalCommand = subcommands({
 
 // src/commands/import/claude.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import path5 from "node:path";
+import path6 from "node:path";
 var importClaudeCommand = command({
   name: "claude",
   description: "Import a Claude Code session transcript for offline grading",
@@ -4147,8 +4203,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 ?? path5.join(".agentv", "transcripts", `claude-${shortId}.jsonl`);
-    await mkdir2(path5.dirname(outputPath), { recursive: true });
+    const outputPath = output ?? path6.join(".agentv", "transcripts", `claude-${shortId}.jsonl`);
+    await mkdir2(path6.dirname(outputPath), { recursive: true });
     const jsonLines = toTranscriptJsonLines(transcript);
     await writeFile2(
       outputPath,
@@ -4192,7 +4248,7 @@ function formatDurationMs(ms) {
 
 // src/commands/import/codex.ts
 import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import path6 from "node:path";
+import path7 from "node:path";
 var importCodexCommand = command({
   name: "codex",
   description: "Import a Codex CLI session transcript for offline grading",
@@ -4264,8 +4320,8 @@ var importCodexCommand = command({
     const rawJsonl = await readTranscriptFile(session.filePath);
     const transcript = parseCodexSession(rawJsonl);
     const shortId = session.sessionId.slice(0, 8);
-    const outputPath = output ?? path6.join(".agentv", "transcripts", `codex-${shortId}.jsonl`);
-    await mkdir3(path6.dirname(outputPath), { recursive: true });
+    const outputPath = output ?? path7.join(".agentv", "transcripts", `codex-${shortId}.jsonl`);
+    await mkdir3(path7.dirname(outputPath), { recursive: true });
     const jsonLines = toTranscriptJsonLines(transcript);
     await writeFile3(
       outputPath,
@@ -4304,7 +4360,7 @@ function formatDurationMs2(ms) {
 
 // src/commands/import/copilot.ts
 import { mkdir as mkdir4, readFile, writeFile as writeFile4 } from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 var importCopilotCommand = command({
   name: "copilot",
   description: "Import a Copilot CLI session transcript for offline grading",
@@ -4369,7 +4425,7 @@ var importCopilotCommand = command({
       );
       process.exit(1);
     }
-    const eventsPath = path7.join(sessionDir, "events.jsonl");
+    const eventsPath = path8.join(sessionDir, "events.jsonl");
     const rawJsonl = await readFile(eventsPath, "utf8");
     const parsed = parseCopilotEvents(rawJsonl);
     const transcript = {
@@ -4386,8 +4442,8 @@ var importCopilotCommand = command({
       costUsd: null
     };
     const shortId = resolvedSessionId.slice(0, 8);
-    const outputPath = output ?? path7.join(".agentv", "transcripts", `copilot-${shortId}.jsonl`);
-    await mkdir4(path7.dirname(outputPath), { recursive: true });
+    const outputPath = output ?? path8.join(".agentv", "transcripts", `copilot-${shortId}.jsonl`);
+    await mkdir4(path8.dirname(outputPath), { recursive: true });
     const jsonLines = toTranscriptJsonLines(transcript);
     await writeFile4(
       outputPath,
@@ -4431,16 +4487,16 @@ function formatDurationMs3(ms) {
 
 // src/commands/import/huggingface.ts
 import { execFile } from "node:child_process";
-import { existsSync } from "node:fs";
-import path8 from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import path9 from "node:path";
 function findScript() {
   const candidates = [
-    path8.resolve(__dirname, "..", "..", "..", "..", "..", "scripts", "import-huggingface.py"),
-    path8.resolve(__dirname, "..", "..", "..", "..", "scripts", "import-huggingface.py"),
-    path8.resolve(process.cwd(), "scripts", "import-huggingface.py")
+    path9.resolve(__dirname, "..", "..", "..", "..", "..", "scripts", "import-huggingface.py"),
+    path9.resolve(__dirname, "..", "..", "..", "..", "scripts", "import-huggingface.py"),
+    path9.resolve(process.cwd(), "scripts", "import-huggingface.py")
   ];
   for (const candidate of candidates) {
-    if (existsSync(candidate)) return candidate;
+    if (existsSync2(candidate)) return candidate;
   }
   return candidates[candidates.length - 1];
 }
@@ -4472,7 +4528,7 @@ var importHuggingFaceCommand = command({
   },
   handler: async ({ repo, split, limit, output }) => {
     const scriptPath = findScript();
-    if (!existsSync(scriptPath)) {
+    if (!existsSync2(scriptPath)) {
       console.error(`Error: Python script not found at ${scriptPath}`);
       console.error(
         "Make sure you are running from the agentv repository root, or install agentv from source."
@@ -4548,30 +4604,30 @@ var importCommand = subcommands({
 });
 
 // src/commands/init/index.ts
-import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
-import path10 from "node:path";
+import { existsSync as existsSync3, mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
+import path11 from "node:path";
 import * as readline from "node:readline/promises";
 
 // src/templates/index.ts
 import { readFileSync as readFileSync3, readdirSync, statSync } from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 import { fileURLToPath } from "node:url";
 function getAgentvTemplates() {
   return getTemplatesFromDir(".agentv");
 }
 function getEnvExampleTemplate() {
-  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");
+  const currentDir = path10.dirname(fileURLToPath(import.meta.url));
+  const templatesBase = currentDir.includes(`${path10.sep}dist`) ? path10.join(currentDir, "templates") : currentDir;
+  const content = readFileSync3(path10.join(templatesBase, ".env.example"), "utf-8");
   return { path: ".env.example", content };
 }
 function getTemplatesFromDir(subdir) {
-  const currentDir = path9.dirname(fileURLToPath(import.meta.url));
+  const currentDir = path10.dirname(fileURLToPath(import.meta.url));
   let templatesDir;
-  if (currentDir.includes(`${path9.sep}dist`)) {
-    templatesDir = path9.join(currentDir, "templates", subdir);
+  if (currentDir.includes(`${path10.sep}dist`)) {
+    templatesDir = path10.join(currentDir, "templates", subdir);
   } else {
-    templatesDir = path9.join(currentDir, subdir);
+    templatesDir = path10.join(currentDir, subdir);
   }
   return readTemplatesRecursively(templatesDir, "");
 }
@@ -4579,15 +4635,15 @@ function readTemplatesRecursively(dir, relativePath) {
   const templates = [];
   const entries2 = readdirSync(dir);
   for (const entry of entries2) {
-    const fullPath = path9.join(dir, entry);
+    const fullPath = path10.join(dir, entry);
     const stat3 = statSync(fullPath);
-    const entryRelativePath = relativePath ? path9.join(relativePath, entry) : entry;
+    const entryRelativePath = relativePath ? path10.join(relativePath, entry) : entry;
     if (stat3.isDirectory()) {
       templates.push(...readTemplatesRecursively(fullPath, entryRelativePath));
     } else {
       const content = readFileSync3(fullPath, "utf-8");
       templates.push({
-        path: entryRelativePath.split(path9.sep).join("/"),
+        path: entryRelativePath.split(path10.sep).join("/"),
         // Normalize to forward slashes
         content
       });
@@ -4618,22 +4674,22 @@ async function promptYesNo(message) {
   }
 }
 async function initCommand(options = {}) {
-  const targetPath = path10.resolve(options.targetPath ?? ".");
-  const agentvDir = path10.join(targetPath, ".agentv");
+  const targetPath = path11.resolve(options.targetPath ?? ".");
+  const agentvDir = path11.join(targetPath, ".agentv");
   const otherAgentvTemplates = getAgentvTemplates();
   const envTemplate = getEnvExampleTemplate();
   const existingFiles = [];
   if (envTemplate) {
-    const envFilePath = path10.join(targetPath, ".env.example");
-    if (existsSync2(envFilePath)) {
+    const envFilePath = path11.join(targetPath, ".env.example");
+    if (existsSync3(envFilePath)) {
       existingFiles.push(".env.example");
     }
   }
-  if (existsSync2(agentvDir)) {
+  if (existsSync3(agentvDir)) {
     for (const template of otherAgentvTemplates) {
-      const targetFilePath = path10.join(agentvDir, template.path);
-      if (existsSync2(targetFilePath)) {
-        existingFiles.push(path10.relative(targetPath, targetFilePath));
+      const targetFilePath = path11.join(agentvDir, template.path);
+      if (existsSync3(targetFilePath)) {
+        existingFiles.push(path11.relative(targetPath, targetFilePath));
       }
     }
   }
@@ -4651,22 +4707,22 @@ async function initCommand(options = {}) {
     }
     console.log();
   }
-  if (!existsSync2(agentvDir)) {
+  if (!existsSync3(agentvDir)) {
     mkdirSync(agentvDir, { recursive: true });
   }
   if (envTemplate) {
-    const envFilePath = path10.join(targetPath, ".env.example");
+    const envFilePath = path11.join(targetPath, ".env.example");
     writeFileSync2(envFilePath, envTemplate.content, "utf-8");
     console.log("Created .env.example");
   }
   for (const template of otherAgentvTemplates) {
-    const targetFilePath = path10.join(agentvDir, template.path);
-    const targetDirPath = path10.dirname(targetFilePath);
-    if (!existsSync2(targetDirPath)) {
+    const targetFilePath = path11.join(agentvDir, template.path);
+    const targetDirPath = path11.dirname(targetFilePath);
+    if (!existsSync3(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync2(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path10.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path11.relative(targetPath, targetFilePath)}`);
   }
   console.log("\nAgentV initialized successfully!");
   console.log("\nFiles installed to root:");
@@ -4674,7 +4730,7 @@ async function initCommand(options = {}) {
     console.log("  - .env.example");
   }
   console.log(`
-Files installed to ${path10.relative(targetPath, agentvDir)}:`);
+Files installed to ${path11.relative(targetPath, agentvDir)}:`);
   for (const t of otherAgentvTemplates) {
     console.log(`  - ${t.path}`);
   }
@@ -4705,14 +4761,14 @@ 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 path11 from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import path12 from "node:path";
 function collectIndexFiles(dir) {
   const files = [];
   try {
     const entries2 = readdirSync2(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(...collectIndexFiles(fullPath));
       } else if (entry.name === "index.jsonl") {
@@ -4763,7 +4819,7 @@ function parseFilterableRecords(filePath) {
     }
     let experiment = typeof raw.experiment === "string" ? raw.experiment : void 0;
     if (!experiment) {
-      const parts = filePath.split(path11.sep);
+      const parts = filePath.split(path12.sep);
       const runsIdx = parts.indexOf("runs");
       if (runsIdx !== -1 && parts.length - runsIdx >= 3) {
         const candidate = parts[runsIdx + 1];
@@ -4818,8 +4874,8 @@ function buildFilterPredicate(opts) {
 }
 function discoverFilterSources(searchPath, cwd) {
   if (searchPath) {
-    const resolved = path11.isAbsolute(searchPath) ? searchPath : path11.resolve(cwd, searchPath);
-    if (!existsSync3(resolved)) {
+    const resolved = path12.isAbsolute(searchPath) ? searchPath : path12.resolve(cwd, searchPath);
+    if (!existsSync4(resolved)) {
       console.error(`${c.red}Error:${c.reset} Path does not exist: ${resolved}`);
       process.exit(1);
     }
@@ -4831,7 +4887,7 @@ function discoverFilterSources(searchPath, cwd) {
     }
     return [resolved];
   }
-  return collectIndexFiles(path11.join(cwd, ".agentv", "results", "runs"));
+  return collectIndexFiles(path12.join(cwd, ".agentv", "results", "runs"));
 }
 function formatFilterTable(records) {
   const lines = [];
@@ -5303,14 +5359,14 @@ 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 path12 from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
+import path13 from "node:path";
 function collectJsonlFiles(dir) {
   const files = [];
   try {
     const entries2 = readdirSync3(dir, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path12.join(dir, entry.name);
+      const fullPath = path13.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...collectJsonlFiles(fullPath));
       } else if (entry.name.endsWith(".jsonl")) {
@@ -5369,8 +5425,8 @@ function searchJsonlFile(filePath, regex2, targetFilter, experimentFilter) {
 }
 function discoverSources(basePath, cwd) {
   if (basePath) {
-    const resolved = path12.isAbsolute(basePath) ? basePath : path12.resolve(cwd, basePath);
-    if (!existsSync4(resolved)) {
+    const resolved = path13.isAbsolute(basePath) ? basePath : path13.resolve(cwd, basePath);
+    if (!existsSync5(resolved)) {
       console.error(`${c.red}Error:${c.reset} Path does not exist: ${resolved}`);
       process.exit(1);
     }
@@ -5383,8 +5439,8 @@ function discoverSources(basePath, cwd) {
     return [resolved];
   }
   const sources = [];
-  sources.push(...collectJsonlFiles(path12.join(cwd, ".agentv", "results", "runs")));
-  sources.push(...collectJsonlFiles(path12.join(cwd, ".agentv", "transcripts")));
+  sources.push(...collectJsonlFiles(path13.join(cwd, ".agentv", "results", "runs")));
+  sources.push(...collectJsonlFiles(path13.join(cwd, ".agentv", "transcripts")));
   return sources;
 }
 function formatSearchResults(matches, pattern) {
@@ -5931,7 +5987,7 @@ var inspectCommand = subcommands({
 });
 
 // src/commands/pipeline/bench.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { readFile as readFile2, readdir, writeFile as writeFile5 } from "node:fs/promises";
 import { join } from "node:path";
 var evalBenchCommand = command({
@@ -6042,7 +6098,7 @@ var evalBenchCommand = command({
       }));
       let executionStatus = "ok";
       const timingPath = join(testDir, "timing.json");
-      if (existsSync5(timingPath)) {
+      if (existsSync6(timingPath)) {
         try {
           const timing = JSON.parse(await readFile2(timingPath, "utf8"));
           if (typeof timing.execution_status === "string") {
@@ -6051,7 +6107,7 @@ var evalBenchCommand = command({
         } catch {
         }
       }
-      const hasResponse = existsSync5(join(testDir, "response.md"));
+      const hasResponse = existsSync6(join(testDir, "response.md"));
       indexLines.push(
         JSON.stringify({
           timestamp: manifest.timestamp,
@@ -6596,7 +6652,7 @@ async function writeJson(filePath, data) {
 
 // src/commands/pipeline/run.ts
 import { exec } from "node:child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync6, unlinkSync } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6, unlinkSync } from "node:fs";
 import { mkdir as mkdir7, readFile as readFile5, readdir as readdir3, writeFile as writeFile8 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname as dirname2, join as join4, relative as relative2, resolve as resolve2 } from "node:path";
@@ -6610,7 +6666,7 @@ function loadEnvFile(dir) {
   let current = resolve2(dir);
   while (true) {
     const candidate = join4(current, ".env");
-    if (existsSync6(candidate)) {
+    if (existsSync7(candidate)) {
       const env2 = {};
       for (const line of readFileSync6(candidate, "utf8").split("\n")) {
         const trimmed = line.trim();
@@ -6809,7 +6865,7 @@ var evalRunCommand2 = command({
           });
           const durationMs = Math.round(performance.now() - start);
           let response;
-          if (existsSync6(outputFile)) {
+          if (existsSync7(outputFile)) {
             response = readFileSync6(outputFile, "utf8");
           } else {
             response = "ERROR: No output file generated";
@@ -6842,8 +6898,8 @@ var evalRunCommand2 = command({
           invCompleted++;
           writeInvProgress();
           try {
-            if (existsSync6(promptFile)) unlinkSync(promptFile);
-            if (existsSync6(outputFile)) unlinkSync(outputFile);
+            if (existsSync7(promptFile)) unlinkSync(promptFile);
+            if (existsSync7(outputFile)) unlinkSync(outputFile);
           } catch {
           }
         }
@@ -7010,10 +7066,10 @@ var pipelineCommand = subcommands({
 });
 
 // src/commands/results/export.ts
-import path13 from "node:path";
+import path14 from "node:path";
 
 // src/commands/results/shared.ts
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 var sourceArg = positional({
   type: optional(string),
   displayName: "source",
@@ -7023,7 +7079,7 @@ async function resolveSourceFile(source, cwd) {
   let sourceFile;
   if (source) {
     sourceFile = resolveResultSourcePath(source, cwd);
-    if (!existsSync7(sourceFile)) {
+    if (!existsSync8(sourceFile)) {
       console.error(`Error: File not found: ${sourceFile}`);
       process.exit(1);
     }
@@ -7031,7 +7087,7 @@ async function resolveSourceFile(source, cwd) {
   } else {
     const cache = await loadRunCache(cwd);
     const cachedFile = cache ? resolveRunCacheFile(cache) : "";
-    if (cachedFile && existsSync7(cachedFile)) {
+    if (cachedFile && existsSync8(cachedFile)) {
       sourceFile = cachedFile;
     } else {
       const metas = listResultFiles(cwd, 1);
@@ -7057,20 +7113,20 @@ async function loadResults(source, cwd) {
 
 // src/commands/results/export.ts
 function deriveOutputDir(cwd, sourceFile) {
-  if (path13.basename(sourceFile) !== RESULT_INDEX_FILENAME) {
+  if (path14.basename(sourceFile) !== RESULT_INDEX_FILENAME) {
     throw new Error(`Expected a run manifest named ${RESULT_INDEX_FILENAME}: ${sourceFile}`);
   }
-  const runDir = path13.dirname(sourceFile);
-  const segments = path13.normalize(runDir).split(path13.sep).filter(Boolean);
+  const runDir = path14.dirname(sourceFile);
+  const segments = path14.normalize(runDir).split(path14.sep).filter(Boolean);
   const runsIndex = segments.lastIndexOf("runs");
   if (runsIndex >= 0 && runsIndex < segments.length - 1) {
-    return path13.join(cwd, ".agentv", "results", "export", ...segments.slice(runsIndex + 1));
+    return path14.join(cwd, ".agentv", "results", "export", ...segments.slice(runsIndex + 1));
   }
-  const parentDir = path13.basename(runDir);
+  const parentDir = path14.basename(runDir);
   if (parentDir.startsWith("eval_")) {
-    return path13.join(cwd, ".agentv", "results", "export", parentDir.slice(5));
+    return path14.join(cwd, ".agentv", "results", "export", parentDir.slice(5));
   }
-  return path13.join(cwd, ".agentv", "results", "export", parentDir);
+  return path14.join(cwd, ".agentv", "results", "export", parentDir);
 }
 async function loadExportSource(source, cwd) {
   const { sourceFile } = await resolveSourceFile(source, cwd);
@@ -7103,7 +7159,7 @@ var resultsExportCommand = command({
     const cwd = dir ?? process.cwd();
     try {
       const { sourceFile, results } = await loadExportSource(source, cwd);
-      const outputDir = out ? path13.isAbsolute(out) ? out : path13.resolve(cwd, out) : deriveOutputDir(cwd, sourceFile);
+      const outputDir = out ? path14.isAbsolute(out) ? out : path14.resolve(cwd, out) : deriveOutputDir(cwd, sourceFile);
       await writeArtifactsFromResults(results, outputDir, {
         evalFile: sourceFile
       });
@@ -7163,8 +7219,8 @@ 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 path14 from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
+import path15 from "node:path";
 
 // src/commands/results/report-template.ts
 var RESULTS_REPORT_TEMPLATE = `<!DOCTYPE html>
@@ -8788,11 +8844,11 @@ function normalizeEvalFileLabel(value) {
   if (!trimmed) {
     return void 0;
   }
-  return path14.basename(trimmed).replace(/\.results\.jsonl$/i, "").replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "").replace(/\.jsonl$/i, "");
+  return path15.basename(trimmed).replace(/\.results\.jsonl$/i, "").replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "").replace(/\.jsonl$/i, "");
 }
 function readBenchmarkEvalFile(sourceFile) {
-  const benchmarkPath = path14.join(path14.dirname(sourceFile), "benchmark.json");
-  if (!existsSync8(benchmarkPath)) {
+  const benchmarkPath = path15.join(path15.dirname(sourceFile), "benchmark.json");
+  if (!existsSync9(benchmarkPath)) {
     return void 0;
   }
   try {
@@ -8803,10 +8859,10 @@ function readBenchmarkEvalFile(sourceFile) {
   }
 }
 function deriveReportPath(sourceFile) {
-  return path14.join(path14.dirname(sourceFile), "report.html");
+  return path15.join(path15.dirname(sourceFile), "report.html");
 }
 function serializeReportResult(result, sourceFile, manifestRecord, benchmarkEvalFile) {
-  const fallbackEvalFile = normalizeEvalFileLabel(manifestRecord?.eval_file) ?? benchmarkEvalFile ?? normalizeEvalFileLabel(result.suite) ?? path14.basename(path14.dirname(sourceFile));
+  const fallbackEvalFile = normalizeEvalFileLabel(manifestRecord?.eval_file) ?? benchmarkEvalFile ?? normalizeEvalFileLabel(result.suite) ?? path15.basename(path15.dirname(sourceFile));
   return {
     timestamp: result.timestamp,
     test_id: result.testId,
@@ -8854,9 +8910,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 ? path14.isAbsolute(outputPath) ? outputPath : path14.resolve(cwd, outputPath) : deriveReportPath(sourceFile);
+  const resolvedOutputPath = outputPath ? path15.isAbsolute(outputPath) ? outputPath : path15.resolve(cwd, outputPath) : deriveReportPath(sourceFile);
   const html = renderResultsReport(results, sourceFile, records, benchmarkEvalFile);
-  mkdirSync2(path14.dirname(resolvedOutputPath), { recursive: true });
+  mkdirSync2(path15.dirname(resolvedOutputPath), { recursive: true });
   writeFileSync3(resolvedOutputPath, html, "utf8");
   const written = readFileSync7(resolvedOutputPath, "utf8");
   if (written.includes("__DATA_PLACEHOLDER__")) {
@@ -8977,7 +9033,7 @@ var resultsShowCommand = command({
 });
 
 // src/commands/results/summary.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "node:fs";
 function formatSummary(results, grading) {
   const total = results.length;
   let passed;
@@ -9028,7 +9084,7 @@ var resultsSummaryCommand = command({
       const { results, sourceFile } = await loadResults(source, cwd);
       let grading;
       const gradingPath = sourceFile.replace(/\.jsonl$/, ".grading.json");
-      if (existsSync9(gradingPath)) {
+      if (existsSync10(gradingPath)) {
         try {
           grading = JSON.parse(readFileSync8(gradingPath, "utf8"));
         } catch {
@@ -9043,11 +9099,11 @@ var resultsSummaryCommand = command({
 });
 
 // src/commands/results/validate.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9, statSync as statSync4 } from "node:fs";
-import path15 from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync9, statSync as statSync4 } from "node:fs";
+import path16 from "node:path";
 function checkDirectoryNaming(runDir) {
-  const dirName = path15.basename(runDir);
-  const pathSegments = path15.normalize(runDir).split(path15.sep).filter(Boolean);
+  const dirName = path16.basename(runDir);
+  const pathSegments = path16.normalize(runDir).split(path16.sep).filter(Boolean);
   const runsIndex = pathSegments.lastIndexOf("runs");
   const diagnostics = [];
   if (runsIndex < 0 || runsIndex >= pathSegments.length - 1) {
@@ -9077,10 +9133,10 @@ function validateRunDirectory(runDir) {
   return { diagnostics, entries: entries2 };
 }
 function checkIndexJsonl(runDir) {
-  const indexPath = path15.join(runDir, "index.jsonl");
+  const indexPath = path16.join(runDir, "index.jsonl");
   const diagnostics = [];
   const entries2 = [];
-  if (!existsSync10(indexPath)) {
+  if (!existsSync11(indexPath)) {
     diagnostics.push({ severity: "error", message: "index.jsonl is missing" });
     return { diagnostics, entries: entries2 };
   }
@@ -9176,8 +9232,8 @@ function checkArtifactFiles(runDir, entries2) {
   for (const entry of entries2) {
     const testId = entry.test_id ?? "?";
     if (entry.grading_path) {
-      const gradingPath = path15.join(runDir, entry.grading_path);
-      if (!existsSync10(gradingPath)) {
+      const gradingPath = path16.join(runDir, entry.grading_path);
+      if (!existsSync11(gradingPath)) {
         diagnostics.push({
           severity: "error",
           message: `${testId}: grading.json not found at '${entry.grading_path}'`
@@ -9206,8 +9262,8 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
     if (entry.timing_path) {
-      const timingPath = path15.join(runDir, entry.timing_path);
-      if (!existsSync10(timingPath)) {
+      const timingPath = path16.join(runDir, entry.timing_path);
+      if (!existsSync11(timingPath)) {
         diagnostics.push({
           severity: "warning",
           message: `${testId}: timing.json not found at '${entry.timing_path}'`
@@ -9215,8 +9271,8 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
   }
-  const benchmarkPath = path15.join(runDir, "benchmark.json");
-  if (!existsSync10(benchmarkPath)) {
+  const benchmarkPath = path16.join(runDir, "benchmark.json");
+  if (!existsSync11(benchmarkPath)) {
     diagnostics.push({ severity: "warning", message: "benchmark.json is missing" });
   }
   return diagnostics;
@@ -9232,8 +9288,8 @@ var resultsValidateCommand = command({
     })
   },
   handler: async ({ runDir }) => {
-    const resolvedDir = path15.resolve(runDir);
-    if (!existsSync10(resolvedDir) || !statSync4(resolvedDir).isDirectory()) {
+    const resolvedDir = path16.resolve(runDir);
+    if (!existsSync11(resolvedDir) || !statSync4(resolvedDir).isDirectory()) {
       console.error(`Error: '${runDir}' is not a directory`);
       process.exit(1);
     }
@@ -9275,15 +9331,15 @@ 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 path19 from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync12, readdirSync as readdirSync4, statSync as statSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import path20 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 path16 from "node:path";
+import { execFileSync as execFileSync2, spawn } from "node:child_process";
+import { existsSync as existsSync12 } from "node:fs";
+import path17 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var activeRuns = /* @__PURE__ */ new Map();
 function generateRunId() {
@@ -9303,7 +9359,7 @@ function pruneFinishedRuns() {
 }
 function getActiveRunTarget(indexJsonlPath) {
   for (const run2 of activeRuns.values()) {
-    if (run2.outputDir && path16.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
+    if (run2.outputDir && path17.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
       return run2.target;
     }
   }
@@ -9313,16 +9369,16 @@ async function discoverTargetsInProject(cwd) {
   const repoRoot = await findRepoRoot(cwd) ?? cwd;
   let targetsFilePath;
   for (const candidate of TARGET_FILE_CANDIDATES) {
-    const fullPath = path16.join(cwd, candidate);
-    if (existsSync11(fullPath)) {
+    const fullPath = path17.join(cwd, candidate);
+    if (existsSync12(fullPath)) {
       targetsFilePath = fullPath;
       break;
     }
   }
   if (!targetsFilePath) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const fullPath = path16.join(repoRoot, candidate);
-      if (existsSync11(fullPath)) {
+      const fullPath = path17.join(repoRoot, candidate);
+      if (existsSync12(fullPath)) {
         targetsFilePath = fullPath;
         break;
       }
@@ -9395,19 +9451,19 @@ function buildCliPreview(args) {
 }
 function resolveCliPath(cwd) {
   const candidates = [
-    path16.join(cwd, "apps/cli/src/cli.ts"),
-    path16.join(cwd, "apps/cli/dist/cli.js")
+    path17.join(cwd, "apps/cli/src/cli.ts"),
+    path17.join(cwd, "apps/cli/dist/cli.js")
   ];
   for (const c4 of candidates) {
-    if (existsSync11(c4)) {
+    if (existsSync12(c4)) {
       return { binPath: "bun", args: [c4] };
     }
   }
-  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] };
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path17.dirname(fileURLToPath2(import.meta.url));
+  const fromSrc = path17.resolve(currentDir, "../../cli.ts");
+  const fromDist = path17.resolve(currentDir, "cli.js");
+  if (existsSync12(fromSrc)) return { binPath: "bun", args: [fromSrc] };
+  if (existsSync12(fromDist)) return { binPath: "bun", args: [fromDist] };
   if (isCommandAvailable("agentv")) {
     return { binPath: "agentv", args: [] };
   }
@@ -9415,7 +9471,7 @@ function resolveCliPath(cwd) {
 }
 function isCommandAvailable(cmd) {
   try {
-    execFileSync(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" });
+    execFileSync2(process.platform === "win32" ? "where" : "which", [cmd], { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -9470,7 +9526,7 @@ function registerEvalRoutes(app2, getCwd, options) {
       return c4.json({ error: "Cannot locate agentv CLI entry point" }, 500);
     }
     const args = buildCliArgs(body);
-    const outputDir = body.output?.trim() ? path16.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
+    const outputDir = body.output?.trim() ? path17.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
     if (!body.output?.trim()) {
       args.push("--output", outputDir);
     }
@@ -9640,7 +9696,7 @@ Process error: ${err2.message}`;
       return c4.json({ error: "Cannot locate agentv CLI entry point" }, 500);
     }
     const args = buildCliArgs(body);
-    const outputDir = body.output?.trim() ? path16.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
+    const outputDir = body.output?.trim() ? path17.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
     if (!body.output?.trim()) {
       args.push("--output", outputDir);
     }
@@ -9754,17 +9810,17 @@ 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 path17 from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync10, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import path18 from "node:path";
 var RUN_TAGS_FILENAME = "tags.json";
 var MAX_TAGS_PER_RUN = 20;
 var MAX_TAG_LENGTH = 60;
 function runTagsPath(manifestPath) {
-  return path17.join(path17.dirname(manifestPath), RUN_TAGS_FILENAME);
+  return path18.join(path18.dirname(manifestPath), RUN_TAGS_FILENAME);
 }
 function readRunTags(manifestPath) {
   const fp = runTagsPath(manifestPath);
-  if (!existsSync12(fp)) return void 0;
+  if (!existsSync13(fp)) return void 0;
   try {
     const parsed = JSON.parse(readFileSync10(fp, "utf8"));
     if (!parsed || typeof parsed !== "object") return void 0;
@@ -9798,7 +9854,7 @@ function writeRunTags(manifestPath, tags) {
 }
 function deleteRunTags(manifestPath) {
   const fp = runTagsPath(manifestPath);
-  if (existsSync12(fp)) {
+  if (existsSync13(fp)) {
     unlinkSync2(fp);
   }
 }
@@ -9831,15 +9887,15 @@ 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 path18 from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync3, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "node:fs";
+import path19 from "node:path";
 import { stringify as stringifyYaml2 } from "yaml";
 var DEFAULTS = {
   threshold: DEFAULT_THRESHOLD
 };
 function loadStudioConfig(agentvDir) {
-  const configPath = path18.join(agentvDir, "config.yaml");
-  if (!existsSync13(configPath)) {
+  const configPath = path19.join(agentvDir, "config.yaml");
+  if (!existsSync14(configPath)) {
     return { ...DEFAULTS };
   }
   const raw = readFileSync11(configPath, "utf-8");
@@ -9864,12 +9920,12 @@ function loadStudioConfig(agentvDir) {
   };
 }
 function saveStudioConfig(agentvDir, config) {
-  if (!existsSync13(agentvDir)) {
+  if (!existsSync14(agentvDir)) {
     mkdirSync3(agentvDir, { recursive: true });
   }
-  const configPath = path18.join(agentvDir, "config.yaml");
+  const configPath = path19.join(agentvDir, "config.yaml");
   let existing = {};
-  if (existsSync13(configPath)) {
+  if (existsSync14(configPath)) {
     const raw = readFileSync11(configPath, "utf-8");
     const parsed = parseYamlValue(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -9893,7 +9949,7 @@ function saveStudioConfig(agentvDir, config) {
 async function resolveSourceFile2(source, cwd) {
   if (source) {
     let resolved = resolveResultSourcePath(source, cwd);
-    if (!existsSync14(resolved)) {
+    if (!existsSync15(resolved)) {
       throw new Error(`Source file not found: ${resolved}`);
     }
     resolved = resolveRunManifestPath(resolved);
@@ -9901,7 +9957,7 @@ async function resolveSourceFile2(source, cwd) {
   }
   const cache = await loadRunCache(cwd);
   const cachedFile = cache ? resolveRunCacheFile(cache) : "";
-  if (cachedFile && existsSync14(cachedFile)) {
+  if (cachedFile && existsSync15(cachedFile)) {
     return cachedFile;
   }
   const metas = listResultFiles(cwd, 10);
@@ -9931,11 +9987,11 @@ function resolveDashboardMode(benchmarkCount, options) {
   return { isMultiBenchmark: benchmarkCount > 1, showMultiWarning: false };
 }
 function feedbackPath(resultDir) {
-  return path19.join(resultDir, "feedback.json");
+  return path20.join(resultDir, "feedback.json");
 }
 function readFeedback(cwd) {
   const fp = feedbackPath(cwd);
-  if (!existsSync14(fp)) {
+  if (!existsSync15(fp)) {
     return { reviews: [] };
   }
   try {
@@ -9950,7 +10006,7 @@ function writeFeedback(cwd, data) {
 `, "utf8");
 }
 function buildFileTree(dirPath, relativeTo) {
-  if (!existsSync14(dirPath) || !statSync5(dirPath).isDirectory()) {
+  if (!existsSync15(dirPath) || !statSync5(dirPath).isDirectory()) {
     return [];
   }
   const entries2 = readdirSync4(dirPath, { withFileTypes: true });
@@ -9958,8 +10014,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 = path19.join(dirPath, entry.name);
-    const relPath = path19.relative(relativeTo, fullPath);
+    const fullPath = path20.join(dirPath, entry.name);
+    const relPath = path20.relative(relativeTo, fullPath);
     if (entry.isDirectory()) {
       return {
         name: entry.name,
@@ -9972,7 +10028,7 @@ function buildFileTree(dirPath, relativeTo) {
   });
 }
 function inferLanguage(filePath) {
-  const ext = path19.extname(filePath).toLowerCase();
+  const ext = path20.extname(filePath).toLowerCase();
   const langMap = {
     ".json": "json",
     ".jsonl": "json",
@@ -10077,12 +10133,12 @@ async function handleRunDetail(c4, { searchDir }) {
 }
 function deriveResumeMeta(cwd, manifestPath) {
   const out = {};
-  const runDir = path19.dirname(manifestPath);
-  const relative3 = path19.relative(cwd, runDir);
+  const runDir = path20.dirname(manifestPath);
+  const relative3 = path20.relative(cwd, runDir);
   out.run_dir = relative3 !== "" && !relative3.startsWith("..") ? relative3 : runDir;
   try {
-    const benchmarkPath = path19.join(runDir, "benchmark.json");
-    if (existsSync14(benchmarkPath)) {
+    const benchmarkPath = path20.join(runDir, "benchmark.json");
+    if (existsSync15(benchmarkPath)) {
       const parsed = JSON.parse(readFileSync12(benchmarkPath, "utf8"));
       const evalFile = parsed.metadata?.eval_file;
       if (typeof evalFile === "string" && evalFile.trim()) {
@@ -10214,7 +10270,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 = path19.dirname(meta.path);
+    const baseDir = path20.dirname(meta.path);
     const knownPaths = [
       record.grading_path,
       record.timing_path,
@@ -10223,14 +10279,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) => path19.dirname(p));
+    const artifactDirs = knownPaths.map((p) => path20.dirname(p));
     let commonDir = artifactDirs[0];
     for (const dir of artifactDirs) {
       while (!dir.startsWith(commonDir)) {
-        commonDir = path19.dirname(commonDir);
+        commonDir = path20.dirname(commonDir);
       }
     }
-    const artifactAbsDir = path19.join(baseDir, commonDir);
+    const artifactAbsDir = path20.join(baseDir, commonDir);
     const files = buildFileTree(artifactAbsDir, baseDir);
     return c4.json({ files });
   } catch {
@@ -10245,12 +10301,12 @@ 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 = path19.dirname(meta.path);
-  const absolutePath = path19.resolve(baseDir, filePath);
-  if (!absolutePath.startsWith(path19.resolve(baseDir) + path19.sep) && absolutePath !== path19.resolve(baseDir)) {
+  const baseDir = path20.dirname(meta.path);
+  const absolutePath = path20.resolve(baseDir, filePath);
+  if (!absolutePath.startsWith(path20.resolve(baseDir) + path20.sep) && absolutePath !== path20.resolve(baseDir)) {
     return c4.json({ error: "Path traversal not allowed" }, 403);
   }
-  if (!existsSync14(absolutePath) || !statSync5(absolutePath).isFile()) {
+  if (!existsSync15(absolutePath) || !statSync5(absolutePath).isFile()) {
     return c4.json({ error: "File not found" }, 404);
   }
   try {
@@ -10467,13 +10523,13 @@ function handleConfig(c4, { agentvDir, searchDir }, options) {
   return c4.json({
     ...loadStudioConfig(agentvDir),
     read_only: options?.readOnly === true,
-    benchmark_name: path19.basename(searchDir),
+    benchmark_name: path20.basename(searchDir),
     multi_benchmark_dashboard: options?.multiBenchmarkDashboard === true
   });
 }
 function handleFeedbackRead(c4, { searchDir }) {
-  const resultsDir = path19.join(searchDir, ".agentv", "results");
-  return c4.json(readFeedback(existsSync14(resultsDir) ? resultsDir : searchDir));
+  const resultsDir = path20.join(searchDir, ".agentv", "results");
+  return c4.json(readFeedback(existsSync15(resultsDir) ? resultsDir : searchDir));
 }
 async function handleRunTagsPut(c4, { searchDir }) {
   const filename = c4.req.param("filename") ?? "";
@@ -10521,18 +10577,18 @@ async function handleRunTagsDelete(c4, { searchDir }) {
 }
 function createApp(results, resultDir, cwd, sourceFile, options) {
   const searchDir = cwd ?? resultDir;
-  const agentvDir = path19.join(searchDir, ".agentv");
+  const agentvDir = path20.join(searchDir, ".agentv");
   const defaultCtx = { searchDir, agentvDir };
   const readOnly = options?.readOnly === true;
   const app2 = new Hono();
   function withBenchmark(c4, handler) {
     const benchmark = getBenchmark(c4.req.param("benchmarkId") ?? "");
-    if (!benchmark || !existsSync14(benchmark.path)) {
+    if (!benchmark || !existsSync15(benchmark.path)) {
       return c4.json({ error: "Benchmark not found" }, 404);
     }
     return handler(c4, {
       searchDir: benchmark.path,
-      agentvDir: path19.join(benchmark.path, ".agentv")
+      agentvDir: path20.join(benchmark.path, ".agentv")
     });
   }
   app2.post("/api/config", async (c4) => {
@@ -10845,20 +10901,20 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     { readOnly }
   );
   const studioDistPath = options?.studioDir ?? resolveStudioDistDir();
-  if (!studioDistPath || !existsSync14(path19.join(studioDistPath, "index.html"))) {
+  if (!studioDistPath || !existsSync15(path20.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 = path19.join(studioDistPath, "index.html");
-    if (existsSync14(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
+    const indexPath = path20.join(studioDistPath, "index.html");
+    if (existsSync15(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
     return c4.notFound();
   });
   app2.get("/assets/*", (c4) => {
     const assetPath = c4.req.path;
-    const filePath = path19.join(studioDistPath, assetPath);
-    if (!existsSync14(filePath)) return c4.notFound();
+    const filePath = path20.join(studioDistPath, assetPath);
+    if (!existsSync15(filePath)) return c4.notFound();
     const content = readFileSync12(filePath);
-    const ext = path19.extname(filePath);
+    const ext = path20.extname(filePath);
     const mimeTypes = {
       ".js": "application/javascript",
       ".css": "text/css",
@@ -10879,26 +10935,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 = path19.join(studioDistPath, "index.html");
-    if (existsSync14(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
+    const indexPath = path20.join(studioDistPath, "index.html");
+    if (existsSync15(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
     return c4.notFound();
   });
   return app2;
 }
 function resolveStudioDistDir() {
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path19.dirname(fileURLToPath3(import.meta.url));
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path20.dirname(fileURLToPath3(import.meta.url));
   const candidates = [
     // From src/commands/results/ → sibling apps/studio/dist
-    path19.resolve(currentDir, "../../../../studio/dist"),
+    path20.resolve(currentDir, "../../../../studio/dist"),
     // From dist/ → sibling apps/studio/dist (monorepo dev)
-    path19.resolve(currentDir, "../../studio/dist"),
+    path20.resolve(currentDir, "../../studio/dist"),
     // Bundled inside CLI dist (published package: dist/studio/)
-    path19.resolve(currentDir, "studio"),
+    path20.resolve(currentDir, "studio"),
     // From dist/ in monorepo root context
-    path19.resolve(currentDir, "../../../apps/studio/dist")
+    path20.resolve(currentDir, "../../../apps/studio/dist")
   ];
   for (const candidate of candidates) {
-    if (existsSync14(candidate) && existsSync14(path19.join(candidate, "index.html"))) {
+    if (existsSync15(candidate) && existsSync15(path20.join(candidate, "index.html"))) {
       return candidate;
     }
   }
@@ -10972,7 +11028,7 @@ var resultsServeCommand = command({
       return;
     }
     const repoRoot = await findRepoRoot(cwd);
-    const yamlConfig = await loadConfig(path19.join(cwd, "_"), repoRoot);
+    const yamlConfig = await loadConfig(path20.join(cwd, "_"), repoRoot);
     if (yamlConfig?.required_version) {
       await enforceRequiredVersion(yamlConfig.required_version);
     }
@@ -10981,6 +11037,7 @@ var resultsServeCommand = command({
       registry.benchmarks.length,
       { multi, single }
     );
+    await syncBenchmarks(registry.benchmarks);
     try {
       let results = [];
       let sourceFile;
@@ -10990,7 +11047,7 @@ var resultsServeCommand = command({
       } else {
         const cache = await loadRunCache(cwd);
         const cachedFile = cache ? resolveRunCacheFile(cache) : "";
-        if (cachedFile && existsSync14(cachedFile)) {
+        if (cachedFile && existsSync15(cachedFile)) {
           sourceFile = cachedFile;
           results = loadManifestResults(cachedFile);
         } else {
@@ -11001,7 +11058,7 @@ var resultsServeCommand = command({
           }
         }
       }
-      const resultDir = sourceFile ? path19.dirname(path19.resolve(sourceFile)) : cwd;
+      const resultDir = sourceFile ? path20.dirname(path20.resolve(sourceFile)) : cwd;
       const app2 = createApp(results, resultDir, cwd, sourceFile, {
         readOnly,
         multiBenchmarkDashboard: isMultiBenchmark
@@ -11095,14 +11152,14 @@ var selfCommand = subcommands({
 });
 
 // src/commands/skills/index.ts
-import { existsSync as existsSync15, readFileSync as readFileSync13, readdirSync as readdirSync5 } from "node:fs";
-import path20 from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync13, readdirSync as readdirSync5 } from "node:fs";
+import path21 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function isValidSkillsDir(dir) {
-  if (!existsSync15(dir)) return false;
+  if (!existsSync16(dir)) return false;
   try {
     return readdirSync5(dir, { withFileTypes: true }).some(
-      (e) => e.isDirectory() && existsSync15(path20.join(dir, e.name, "SKILL.md"))
+      (e) => e.isDirectory() && existsSync16(path21.join(dir, e.name, "SKILL.md"))
     );
   } catch {
     return false;
@@ -11110,15 +11167,15 @@ function isValidSkillsDir(dir) {
 }
 function findSkillsDir() {
   const selfFile = fileURLToPath4(import.meta.url);
-  let dir = path20.dirname(selfFile);
+  let dir = path21.dirname(selfFile);
   for (let i = 0; i < 6; i++) {
-    const distCandidate = path20.join(dir, "dist", "skills");
+    const distCandidate = path21.join(dir, "dist", "skills");
     if (isValidSkillsDir(distCandidate)) return distCandidate;
-    const repoRootCandidate = path20.join(dir, "skills-data");
+    const repoRootCandidate = path21.join(dir, "skills-data");
     if (isValidSkillsDir(repoRootCandidate)) return repoRootCandidate;
-    const legacyCandidate = path20.join(dir, "skills");
+    const legacyCandidate = path21.join(dir, "skills");
     if (isValidSkillsDir(legacyCandidate)) return legacyCandidate;
-    dir = path20.dirname(dir);
+    dir = path21.dirname(dir);
   }
   return null;
 }
@@ -11133,40 +11190,40 @@ function requireSkillsDir() {
   return dir;
 }
 function listSkillNames(skillsDir) {
-  if (!existsSync15(skillsDir)) return [];
+  if (!existsSync16(skillsDir)) return [];
   return readdirSync5(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
 }
 function readSkillFile(skillDir, relPath) {
-  const full = path20.join(skillDir, relPath);
-  if (!existsSync15(full)) return null;
+  const full = path21.join(skillDir, relPath);
+  if (!existsSync16(full)) return null;
   return readFileSync13(full, "utf-8");
 }
 function collectDir(dir, prefix = "") {
   const result = {};
-  if (!existsSync15(dir)) return result;
+  if (!existsSync16(dir)) return result;
   for (const entry of readdirSync5(dir, { withFileTypes: true })) {
     const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
-      Object.assign(result, collectDir(path20.join(dir, entry.name), relPath));
+      Object.assign(result, collectDir(path21.join(dir, entry.name), relPath));
     } else {
-      result[relPath] = readFileSync13(path20.join(dir, entry.name), "utf-8");
+      result[relPath] = readFileSync13(path21.join(dir, entry.name), "utf-8");
     }
   }
   return result;
 }
 function listSkillSubdirs(skillDir) {
-  if (!existsSync15(skillDir)) return [];
+  if (!existsSync16(skillDir)) return [];
   return readdirSync5(skillDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
 }
 function readSkill(skillsDir, name, full) {
-  const skillDir = path20.join(skillsDir, name);
-  if (!existsSync15(skillDir)) return null;
+  const skillDir = path21.join(skillsDir, name);
+  if (!existsSync16(skillDir)) return null;
   const content = readSkillFile(skillDir, "SKILL.md");
   if (content === null) return null;
   if (!full) return { name, content };
   const files = {};
   for (const sub of listSkillSubdirs(skillDir)) {
-    const subDir = path20.join(skillDir, sub);
+    const subDir = path21.join(skillDir, sub);
     const collected = collectDir(subDir, sub);
     Object.assign(files, collected);
   }
@@ -11176,15 +11233,15 @@ function findRefFile(skillDir, refName) {
   const candidates = refName.endsWith(".md") ? [refName] : [refName, `${refName}.md`];
   for (const sub of listSkillSubdirs(skillDir)) {
     for (const candidate of candidates) {
-      const filePath = path20.join(skillDir, sub, candidate);
-      if (existsSync15(filePath)) {
+      const filePath = path21.join(skillDir, sub, candidate);
+      if (existsSync16(filePath)) {
         return { relPath: `${sub}/${candidate}`, content: readFileSync13(filePath, "utf-8") };
       }
     }
   }
   for (const candidate of candidates) {
-    const filePath = path20.join(skillDir, candidate);
-    if (existsSync15(filePath)) {
+    const filePath = path21.join(skillDir, candidate);
+    if (existsSync16(filePath)) {
       return { relPath: candidate, content: readFileSync13(filePath, "utf-8") };
     }
   }
@@ -11193,7 +11250,7 @@ function findRefFile(skillDir, refName) {
 function listRefFiles(skillDir) {
   const out = [];
   for (const sub of listSkillSubdirs(skillDir)) {
-    const subDir = path20.join(skillDir, sub);
+    const subDir = path21.join(skillDir, sub);
     for (const entry of readdirSync5(subDir, { withFileTypes: true })) {
       if (entry.isFile()) out.push(`${sub}/${entry.name}`);
     }
@@ -11277,8 +11334,8 @@ var skillsGetCommand = command({
         }
         process.exit(1);
       }
-      const skillDir = path20.join(skillsDir, name);
-      if (!existsSync15(skillDir)) {
+      const skillDir = path21.join(skillsDir, name);
+      if (!existsSync16(skillDir)) {
         const msg = `skill '${name}' not found`;
         if (json) {
           process.stdout.write(`${JSON.stringify({ success: false, error: msg })}
@@ -11366,8 +11423,8 @@ var skillsPathCommand = command({
   handler: ({ name }) => {
     const skillsDir = requireSkillsDir();
     if (name) {
-      const skillDir = path20.join(skillsDir, name);
-      if (!existsSync15(skillDir)) {
+      const skillDir = path21.join(skillsDir, name);
+      if (!existsSync16(skillDir)) {
         console.error(`Error: skill '${name}' not found`);
         process.exit(1);
       }
@@ -11389,7 +11446,7 @@ var skillsCommand = subcommands({
 
 // src/commands/transpile/index.ts
 import { writeFileSync as writeFileSync7 } from "node:fs";
-import path21 from "node:path";
+import path22 from "node:path";
 var transpileCommand = command({
   name: "transpile",
   description: "Convert an EVAL.yaml file to Agent Skills evals.json format",
@@ -11413,7 +11470,7 @@ var transpileCommand = command({
   handler: async ({ input, outDir, stdout }) => {
     let result;
     try {
-      result = transpileEvalYamlFile(path21.resolve(input));
+      result = transpileEvalYamlFile(path22.resolve(input));
     } catch (error) {
       console.error(`Error: ${error.message}`);
       process.exit(1);
@@ -11437,11 +11494,11 @@ var transpileCommand = command({
       process.stdout.write("\n");
       return;
     }
-    const outputDir = outDir ? path21.resolve(outDir) : path21.dirname(path21.resolve(input));
+    const outputDir = outDir ? path22.resolve(outDir) : path22.dirname(path22.resolve(input));
     const fileNames = getOutputFilenames(result);
     for (const [skill, evalsJson] of result.files) {
       const fileName = fileNames.get(skill) ?? "evals.json";
-      const outputPath = path21.join(outputDir, fileName);
+      const outputPath = path22.join(outputDir, fileName);
       writeFileSync7(outputPath, `${JSON.stringify(evalsJson, null, 2)}
 `);
       console.log(`Transpiled to ${outputPath}`);
@@ -11450,7 +11507,7 @@ var transpileCommand = command({
 });
 
 // src/commands/trend/index.ts
-import path22 from "node:path";
+import path23 from "node:path";
 var colors2 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -11500,7 +11557,7 @@ function colorizeSlope(value) {
 }
 function ensureTrendIndexPath(source, cwd) {
   const resolved = resolveResultSourcePath(source, cwd);
-  if (path22.basename(resolved) !== RESULT_INDEX_FILENAME) {
+  if (path23.basename(resolved) !== RESULT_INDEX_FILENAME) {
     throw new Error(
       `Unsupported result source for trend: ${source}. Use a run workspace directory or ${RESULT_INDEX_FILENAME} manifest.`
     );
@@ -11520,7 +11577,7 @@ function resolveTrendSources(cwd, sources, last) {
   if (last < 2) {
     throw new Error("--last must be at least 2");
   }
-  const metas = listResultFiles(cwd).filter((meta) => path22.basename(meta.path) === RESULT_INDEX_FILENAME).slice(0, last);
+  const metas = listResultFiles(cwd).filter((meta) => path23.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/"
@@ -11535,10 +11592,10 @@ function getRunLabel(sourcePath, timestamp) {
   if (timestamp) {
     return timestamp;
   }
-  return path22.basename(path22.dirname(sourcePath));
+  return path23.basename(path23.dirname(sourcePath));
 }
 function getRunSortKey(sourcePath, timestamp) {
-  return timestamp ?? path22.basename(path22.dirname(sourcePath));
+  return timestamp ?? path23.basename(path23.dirname(sourcePath));
 }
 function mean2(values) {
   return values.reduce((sum, value) => sum + value, 0) / values.length;
@@ -11919,7 +11976,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 path23 from "node:path";
+import path24 from "node:path";
 import fg2 from "fast-glob";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
@@ -11934,7 +11991,7 @@ async function validateFiles(paths) {
   };
 }
 async function validateSingleFile(filePath) {
-  const absolutePath = path23.resolve(filePath);
+  const absolutePath = path24.resolve(filePath);
   const fileType = await detectFileType(absolutePath);
   let result;
   if (fileType === "eval") {
@@ -11978,7 +12035,7 @@ async function validateSingleFile(filePath) {
 async function expandPaths(paths) {
   const expanded = /* @__PURE__ */ new Set();
   for (const inputPath of paths) {
-    const absolutePath = path23.resolve(inputPath);
+    const absolutePath = path24.resolve(inputPath);
     try {
       await access(absolutePath, constants.F_OK);
       const stats = await stat(absolutePath);
@@ -12006,7 +12063,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(path23.normalize(f));
+    for (const f of yamlMatches) expanded.add(path24.normalize(f));
   }
   const sorted = Array.from(expanded);
   sorted.sort();
@@ -12017,7 +12074,7 @@ async function findYamlFiles(dirPath) {
   try {
     const entries2 = await readdir4(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path23.join(dirPath, entry.name);
+      const fullPath = path24.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -12034,11 +12091,11 @@ async function findYamlFiles(dirPath) {
   return results;
 }
 function isYamlFile(filePath) {
-  const ext = path23.extname(filePath).toLowerCase();
+  const ext = path24.extname(filePath).toLowerCase();
   return ext === ".yaml" || ext === ".yml";
 }
 function isEvalYamlFile(filePath) {
-  const lower = path23.basename(filePath).toLowerCase();
+  const lower = path24.basename(filePath).toLowerCase();
   return lower.endsWith(".eval.yaml") || lower.endsWith(".eval.yml");
 }
 
@@ -12093,9 +12150,9 @@ var validateCommand = command({
 });
 
 // src/commands/workspace/clean.ts
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 import { readFile as readFile6, readdir as readdir5, rm } from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 async function confirm(message) {
   const readline2 = await import("node:readline");
   const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
@@ -12122,7 +12179,7 @@ var cleanCommand = command({
   },
   handler: async ({ repo, force }) => {
     const poolRoot = getWorkspacePoolRoot();
-    if (!existsSync16(poolRoot)) {
+    if (!existsSync17(poolRoot)) {
       console.log("No workspace pool entries found.");
       return;
     }
@@ -12131,8 +12188,8 @@ var cleanCommand = command({
       const poolDirs = entries2.filter((e) => e.isDirectory());
       const matchingDirs = [];
       for (const dir of poolDirs) {
-        const poolDir = path24.join(poolRoot, dir.name);
-        const metadataPath = path24.join(poolDir, "metadata.json");
+        const poolDir = path25.join(poolRoot, dir.name);
+        const metadataPath = path25.join(poolDir, "metadata.json");
         try {
           const raw = await readFile6(metadataPath, "utf-8");
           const metadata = JSON.parse(raw);
@@ -12163,7 +12220,7 @@ var cleanCommand = command({
       }
       for (const dir of matchingDirs) {
         await rm(dir, { recursive: true, force: true });
-        console.log(`Removed: ${path24.basename(dir).slice(0, 12)}...`);
+        console.log(`Removed: ${path25.basename(dir).slice(0, 12)}...`);
       }
       console.log("Done.");
     } else {
@@ -12181,7 +12238,7 @@ var cleanCommand = command({
 });
 
 // src/commands/workspace/deps.ts
-import path25 from "node:path";
+import path26 from "node:path";
 var depsCommand = command({
   name: "deps",
   description: "Scan eval files and list git repo dependencies needed by workspaces",
@@ -12205,7 +12262,7 @@ var depsCommand = command({
     const resolvedPaths = await resolveEvalPaths(evalPaths, cwd);
     const result = await scanRepoDeps(resolvedPaths);
     for (const err2 of result.errors) {
-      console.error(`warning: ${path25.relative(cwd, err2.file)}: ${err2.message}`);
+      console.error(`warning: ${path26.relative(cwd, err2.file)}: ${err2.message}`);
     }
     const output = {
       repos: result.repos.map((r) => ({
@@ -12213,7 +12270,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) => path25.relative(cwd, p)) }
+        ...usedBy && { used_by: r.usedBy.map((p) => path26.relative(cwd, p)) }
       }))
     };
     console.log(JSON.stringify(output, null, 2));
@@ -12221,15 +12278,15 @@ var depsCommand = command({
 });
 
 // src/commands/workspace/list.ts
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync18 } from "node:fs";
 import { readFile as readFile7, readdir as readdir6, stat as stat2 } from "node:fs/promises";
-import path26 from "node:path";
+import path27 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 = path26.join(dirPath, entry.name);
+      const fullPath = path27.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(fullPath);
       } else {
@@ -12253,7 +12310,7 @@ var listCommand = command({
   args: {},
   handler: async () => {
     const poolRoot = getWorkspacePoolRoot();
-    if (!existsSync17(poolRoot)) {
+    if (!existsSync18(poolRoot)) {
       console.log("No workspace pool entries found.");
       return;
     }
@@ -12264,11 +12321,11 @@ var listCommand = command({
       return;
     }
     for (const dir of poolDirs) {
-      const poolDir = path26.join(poolRoot, dir.name);
+      const poolDir = path27.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 = path26.join(poolDir, "metadata.json");
+      const metadataPath = path27.join(poolDir, "metadata.json");
       let metadata = null;
       try {
         const raw = await readFile7(metadataPath, "utf-8");
@@ -12315,8 +12372,8 @@ var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var CONFIG_DIR = getAgentvConfigDir();
 var CACHE_FILE = "version-check.json";
 var NPM_REGISTRY_BASE = "https://registry.npmjs.org/agentv/";
-async function getCachedUpdateInfo(path28) {
-  const filePath = path28 ?? join5(CONFIG_DIR, CACHE_FILE);
+async function getCachedUpdateInfo(path29) {
+  const filePath = path29 ?? join5(CONFIG_DIR, CACHE_FILE);
   try {
     const raw = await readFile8(filePath, "utf-8");
     const data = JSON.parse(raw);
@@ -12406,6 +12463,7 @@ var app = subcommands({
     compare: compareCommand,
     convert: convertCommand,
     create: createCommand,
+    doctor: doctorCommand,
     init: initCmdTsCommand,
     pipeline: pipelineCommand,
     results: resultsCommand,
@@ -12428,6 +12486,7 @@ var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
   "compare",
   "convert",
   "create",
+  "doctor",
   "init",
   "pipeline",
   "results",
@@ -12477,7 +12536,7 @@ ${updateNotice}
   const processedArgv = preprocessArgv(argv);
   const cwd = process.cwd();
   const repoRoot = await findRepoRoot(cwd);
-  const sessionConfig = await loadConfig(path27.join(cwd, "_"), repoRoot);
+  const sessionConfig = await loadConfig(path28.join(cwd, "_"), repoRoot);
   const beforeSessionCommand = sessionConfig?.hooks?.before_session;
   if (beforeSessionCommand) {
     runBeforeSessionHook(beforeSessionCommand);
@@ -12490,4 +12549,4 @@ export {
   preprocessArgv,
   runCli
 };
-//# sourceMappingURL=chunk-PH5MHKPL.js.map
+//# sourceMappingURL=chunk-UV7G7TWO.js.map