agentv 4.10.0 → 4.11.2-next.1

package/dist/{chunk-VA64NETD.js → chunk-YLVQNF23.js}

@@ -2,32 +2,47 @@ import { createRequire } from 'node:module'; const require = createRequire(impor
 import {
   HtmlWriter,
   RESULT_INDEX_FILENAME,
-  RESULT_RUNS_DIRNAME,
   TARGET_FILE_CANDIDATES,
   buildDefaultRunDir,
+  c,
   detectFileType,
   discoverEvalFiles,
   findRepoRoot,
+  findRunById,
+  formatCost,
+  formatDuration,
+  formatNumber,
+  formatScore,
+  formatSize,
+  getRemoteResultsStatus,
+  getTraceSpans,
+  getTraceSummary,
+  listMergedResultFiles,
+  listResultFiles,
   loadLightweightResults,
   loadManifestResults,
+  loadResultFile,
   loadRunCache,
+  maybeAutoExportRunArtifacts,
   package_default,
+  padLeft,
+  padRight,
   parseResultManifest,
   resolveEvalPaths,
-  resolveExistingRunPrimaryPath,
   resolveResultSourcePath,
   resolveRunCacheFile,
   resolveRunManifestPath,
-  resolveWorkspaceOrFilePath,
   runEvalCommand,
   selectTarget,
+  syncRemoteResults,
   toSnakeCaseDeep,
+  toTraceSummary,
   validateConfigFile,
   validateEvalFile,
   validateFileReferences,
   validateTargetsFile,
   writeArtifactsFromResults
-} from "./chunk-KF6BABQ5.js";
+} from "./chunk-DHWFLK6T.js";
 import {
   DEFAULT_CATEGORY,
   DEFAULT_THRESHOLD,
@@ -61,7 +76,7 @@ import {
   toTranscriptJsonLine,
   transpileEvalYamlFile,
   trimBaselineResult
-} from "./chunk-SE73HJZG.js";
+} from "./chunk-FQGY6QXQ.js";
 import {
   __commonJS,
   __require,
@@ -2770,7 +2785,7 @@ var colors = {
   gray: "\x1B[90m"
 };
 var noColor = process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
-var c = noColor ? Object.fromEntries(Object.keys(colors).map((k) => [k, ""])) : colors;
+var c2 = noColor ? Object.fromEntries(Object.keys(colors).map((k) => [k, ""])) : colors;
 function loadCompareResults(filePath) {
   return loadLightweightResults(resolveResultSourcePath(filePath)).map((record) => {
     if (!record.testId || record.testId === "unknown") {
@@ -2904,29 +2919,29 @@ function determineMatrixExitCode(matrixOutput, baselineTarget) {
 function formatDelta(delta) {
   const sign = delta >= 0 ? "+" : "";
   const formatted = `${sign}${delta.toFixed(2)}`;
-  if (delta > 0) return `${c.green}${formatted}${c.reset}`;
-  if (delta < 0) return `${c.red}${formatted}${c.reset}`;
-  return `${c.gray}${formatted}${c.reset}`;
+  if (delta > 0) return `${c2.green}${formatted}${c2.reset}`;
+  if (delta < 0) return `${c2.red}${formatted}${c2.reset}`;
+  return `${c2.gray}${formatted}${c2.reset}`;
 }
 function formatOutcome(outcome) {
   switch (outcome) {
     case "win":
-      return `${c.green}\u2713 win${c.reset}`;
+      return `${c2.green}\u2713 win${c2.reset}`;
     case "loss":
-      return `${c.red}\u2717 loss${c.reset}`;
+      return `${c2.red}\u2717 loss${c2.reset}`;
     case "tie":
-      return `${c.gray}= tie${c.reset}`;
+      return `${c2.gray}= tie${c2.reset}`;
   }
 }
 var ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
 function stripAnsi2(str) {
   return str.replace(ansiPattern, "");
 }
-function padRight(str, len) {
+function padRight2(str, len) {
   const plainLen = stripAnsi2(str).length;
   return str + " ".repeat(Math.max(0, len - plainLen));
 }
-function padLeft(str, len) {
+function padLeft2(str, len) {
   const plainLen = stripAnsi2(str).length;
   return " ".repeat(Math.max(0, len - plainLen)) + str;
 }
@@ -2934,42 +2949,42 @@ function formatTable(comparison, file1, file2) {
   const lines = [];
   lines.push("");
   lines.push(
-    `${c.bold}Comparing:${c.reset} ${c.cyan}${file1}${c.reset} \u2192 ${c.cyan}${file2}${c.reset}`
+    `${c2.bold}Comparing:${c2.reset} ${c2.cyan}${file1}${c2.reset} \u2192 ${c2.cyan}${file2}${c2.reset}`
   );
   lines.push("");
   if (comparison.matched.length === 0) {
-    lines.push(`${c.yellow}No matching test IDs found between files.${c.reset}`);
+    lines.push(`${c2.yellow}No matching test IDs found between files.${c2.reset}`);
   } else {
     const maxIdLen = Math.max(
       7,
       ...comparison.matched.map((m) => m.testId.length)
     );
-    const header = `  ${padRight("Test ID", maxIdLen)}  ${padLeft("Baseline", 8)}  ${padLeft("Candidate", 9)}  ${padLeft("Delta", 8)}  Result`;
-    lines.push(`${c.dim}${header}${c.reset}`);
+    const header = `  ${padRight2("Test ID", maxIdLen)}  ${padLeft2("Baseline", 8)}  ${padLeft2("Candidate", 9)}  ${padLeft2("Delta", 8)}  Result`;
+    lines.push(`${c2.dim}${header}${c2.reset}`);
     lines.push(
-      `${c.dim}  ${"\u2500".repeat(maxIdLen)}  ${"\u2500".repeat(8)}  ${"\u2500".repeat(9)}  ${"\u2500".repeat(8)}  ${"\u2500".repeat(8)}${c.reset}`
+      `${c2.dim}  ${"\u2500".repeat(maxIdLen)}  ${"\u2500".repeat(8)}  ${"\u2500".repeat(9)}  ${"\u2500".repeat(8)}  ${"\u2500".repeat(8)}${c2.reset}`
     );
     for (const m of comparison.matched) {
-      const row = `  ${padRight(m.testId, maxIdLen)}  ${padLeft(m.score1.toFixed(2), 8)}  ${padLeft(m.score2.toFixed(2), 9)}  ${padLeft(formatDelta(m.delta), 8)}  ${formatOutcome(m.outcome)}`;
+      const row = `  ${padRight2(m.testId, maxIdLen)}  ${padLeft2(m.score1.toFixed(2), 8)}  ${padLeft2(m.score2.toFixed(2), 9)}  ${padLeft2(formatDelta(m.delta), 8)}  ${formatOutcome(m.outcome)}`;
       lines.push(row);
     }
   }
   if (comparison.unmatched.file1 > 0 || comparison.unmatched.file2 > 0) {
     lines.push("");
     lines.push(
-      `${c.yellow}\u26A0 Unmatched:${c.reset} ${comparison.unmatched.file1} in baseline, ${comparison.unmatched.file2} in candidate`
+      `${c2.yellow}\u26A0 Unmatched:${c2.reset} ${comparison.unmatched.file1} in baseline, ${comparison.unmatched.file2} in candidate`
     );
   }
   lines.push("");
   const { wins, losses, ties, meanDelta } = comparison.summary;
-  const winStr = wins > 0 ? `${c.green}${wins} win${wins !== 1 ? "s" : ""}${c.reset}` : `${wins} wins`;
-  const lossStr = losses > 0 ? `${c.red}${losses} loss${losses !== 1 ? "es" : ""}${c.reset}` : `${losses} losses`;
+  const winStr = wins > 0 ? `${c2.green}${wins} win${wins !== 1 ? "s" : ""}${c2.reset}` : `${wins} wins`;
+  const lossStr = losses > 0 ? `${c2.red}${losses} loss${losses !== 1 ? "es" : ""}${c2.reset}` : `${losses} losses`;
   const tieStr = `${ties} tie${ties !== 1 ? "s" : ""}`;
-  const deltaColor = meanDelta > 0 ? c.green : meanDelta < 0 ? c.red : c.gray;
+  const deltaColor = meanDelta > 0 ? c2.green : meanDelta < 0 ? c2.red : c2.gray;
   const deltaSign = meanDelta >= 0 ? "+" : "";
-  const status = meanDelta > 0 ? `${c.green}improved${c.reset}` : meanDelta < 0 ? `${c.red}regressed${c.reset}` : `${c.gray}neutral${c.reset}`;
+  const status = meanDelta > 0 ? `${c2.green}improved${c2.reset}` : meanDelta < 0 ? `${c2.red}regressed${c2.reset}` : `${c2.gray}neutral${c2.reset}`;
   lines.push(
-    `${c.bold}Summary:${c.reset} ${winStr}, ${lossStr}, ${tieStr} | Mean \u0394: ${deltaColor}${deltaSign}${meanDelta.toFixed(3)}${c.reset} | Status: ${status}`
+    `${c2.bold}Summary:${c2.reset} ${winStr}, ${lossStr}, ${tieStr} | Mean \u0394: ${deltaColor}${deltaSign}${meanDelta.toFixed(3)}${c2.reset} | Status: ${status}`
   );
   lines.push("");
   return lines.join("\n");
@@ -2978,10 +2993,10 @@ function formatMatrix(matrixOutput, baselineTarget) {
   const { matrix, pairwise, targets } = matrixOutput;
   const lines = [];
   lines.push("");
-  lines.push(`${c.bold}Score Matrix${c.reset}`);
+  lines.push(`${c2.bold}Score Matrix${c2.reset}`);
   lines.push("");
   if (matrix.length === 0) {
-    lines.push(`${c.yellow}No results found.${c.reset}`);
+    lines.push(`${c2.yellow}No results found.${c2.reset}`);
     return lines.join("\n");
   }
   const testIdWidth = Math.max(
@@ -2989,49 +3004,49 @@ function formatMatrix(matrixOutput, baselineTarget) {
     ...matrix.map((r) => r.testId.length)
   );
   const targetWidths = targets.map((t) => Math.max(t.length, 6));
-  let header = `  ${padRight("Test ID", testIdWidth)}`;
+  let header = `  ${padRight2("Test ID", testIdWidth)}`;
   for (let i = 0; i < targets.length; i++) {
-    header += `  ${padLeft(targets[i], targetWidths[i])}`;
+    header += `  ${padLeft2(targets[i], targetWidths[i])}`;
   }
-  lines.push(`${c.dim}${header}${c.reset}`);
+  lines.push(`${c2.dim}${header}${c2.reset}`);
   let sep = `  ${"\u2500".repeat(testIdWidth)}`;
   for (let i = 0; i < targets.length; i++) {
     sep += `  ${"\u2500".repeat(targetWidths[i])}`;
   }
-  lines.push(`${c.dim}${sep}${c.reset}`);
+  lines.push(`${c2.dim}${sep}${c2.reset}`);
   for (const row of matrix) {
-    let line = `  ${padRight(row.testId, testIdWidth)}`;
+    let line = `  ${padRight2(row.testId, testIdWidth)}`;
     for (let i = 0; i < targets.length; i++) {
       const score = row.scores[targets[i]];
       const scoreStr = score !== void 0 ? score.toFixed(2) : "  --";
       if (baselineTarget && targets[i] !== baselineTarget && score !== void 0) {
         const baselineScore = row.scores[baselineTarget];
         if (baselineScore !== void 0 && score < baselineScore) {
-          line += `  ${padLeft(`${c.red}${scoreStr}${c.reset}`, targetWidths[i])}`;
+          line += `  ${padLeft2(`${c2.red}${scoreStr}${c2.reset}`, targetWidths[i])}`;
         } else if (baselineScore !== void 0 && score > baselineScore) {
-          line += `  ${padLeft(`${c.green}${scoreStr}${c.reset}`, targetWidths[i])}`;
+          line += `  ${padLeft2(`${c2.green}${scoreStr}${c2.reset}`, targetWidths[i])}`;
         } else {
-          line += `  ${padLeft(scoreStr, targetWidths[i])}`;
+          line += `  ${padLeft2(scoreStr, targetWidths[i])}`;
         }
       } else {
-        line += `  ${padLeft(scoreStr, targetWidths[i])}`;
+        line += `  ${padLeft2(scoreStr, targetWidths[i])}`;
       }
     }
     lines.push(line);
   }
   if (pairwise.length > 0) {
     lines.push("");
-    lines.push(`${c.bold}Pairwise Summary:${c.reset}`);
+    lines.push(`${c2.bold}Pairwise Summary:${c2.reset}`);
     const maxLabelLen = Math.max(
       ...pairwise.map((pw) => `  ${pw.baseline} \u2192 ${pw.candidate}:`.length)
     );
     for (const p of pairwise) {
       const { wins, losses, ties, meanDelta } = p.summary;
       const sign = meanDelta >= 0 ? "+" : "";
-      const deltaColor = meanDelta > 0 ? c.green : meanDelta < 0 ? c.red : c.gray;
+      const deltaColor = meanDelta > 0 ? c2.green : meanDelta < 0 ? c2.red : c2.gray;
       const label = `  ${p.baseline} \u2192 ${p.candidate}:`;
       lines.push(
-        `${padRight(label, maxLabelLen)}  ${wins} win${wins !== 1 ? "s" : ""}, ${losses} loss${losses !== 1 ? "es" : ""}, ${ties} tie${ties !== 1 ? "s" : ""}  (${c.bold}\u0394${c.reset} ${deltaColor}${sign}${meanDelta.toFixed(3)}${c.reset})`
+        `${padRight2(label, maxLabelLen)}  ${wins} win${wins !== 1 ? "s" : ""}, ${losses} loss${losses !== 1 ? "es" : ""}, ${ties} tie${ties !== 1 ? "s" : ""}  (${c2.bold}\u0394${c2.reset} ${deltaColor}${sign}${meanDelta.toFixed(3)}${c2.reset})`
       );
     }
   }
@@ -3754,6 +3769,11 @@ var evalRunCommand = command({
       long: "output-format",
       description: "[Deprecated] Output format: 'jsonl', 'yaml', or 'html' (default: jsonl)"
     }),
+    experiment: option({
+      type: optional(string),
+      long: "experiment",
+      description: "Experiment label for canonical run output (default: default)"
+    }),
     export: multioption({
       type: array(string),
       long: "export",
@@ -3892,7 +3912,7 @@ var evalRunCommand = command({
   },
   handler: async (args) => {
     if (args.evalPaths.length === 0 && process.stdin.isTTY) {
-      const { launchInteractiveWizard } = await import("./interactive-SNKK6VCV.js");
+      const { launchInteractiveWizard } = await import("./interactive-OPHUF2UP.js");
       await launchInteractiveWizard();
       return;
     }
@@ -3905,6 +3925,7 @@ var evalRunCommand = command({
       out: args.out,
       output: args.output,
       outputFormat: args.outputFormat,
+      experiment: args.experiment,
       export: args.export,
       dryRun: args.dryRun,
       dryRunDelay: args.dryRunDelay,
@@ -4299,42 +4320,149 @@ function formatDurationMs3(ms) {
   return `${minutes}m ${remainingSeconds}s`;
 }
 
+// src/commands/import/huggingface.ts
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import path7 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")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return candidates[candidates.length - 1];
+}
+var importHuggingFaceCommand = command({
+  name: "huggingface",
+  description: "Import a HuggingFace dataset into AgentV EVAL.yaml format",
+  args: {
+    repo: option({
+      type: string,
+      long: "repo",
+      description: "HuggingFace dataset repository (e.g. SWE-bench/SWE-bench_Verified)"
+    }),
+    split: option({
+      type: optional(string),
+      long: "split",
+      description: "Dataset split to load (default: test)"
+    }),
+    limit: option({
+      type: optional(number),
+      long: "limit",
+      description: "Maximum number of instances to import"
+    }),
+    output: option({
+      type: optional(string),
+      long: "output",
+      short: "o",
+      description: "Output directory for EVAL.yaml files (default: evals/)"
+    })
+  },
+  handler: async ({ repo, split, limit, output }) => {
+    const scriptPath = findScript();
+    if (!existsSync(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."
+      );
+      process.exit(1);
+    }
+    const args = [scriptPath, "--repo", repo];
+    if (split) args.push("--split", split);
+    if (limit !== void 0) args.push("--limit", String(limit));
+    if (output) args.push("--output", output);
+    console.log(`Importing from HuggingFace: ${repo} (split=${split ?? "test"})...`);
+    try {
+      await new Promise((resolve3, reject) => {
+        const child = execFile("uv", ["run", ...args], { maxBuffer: 50 * 1024 * 1024 }, (error) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve3();
+          }
+        });
+        let stderrBuf = "";
+        child.stderr?.on("data", (data) => {
+          const chunk = data.toString();
+          stderrBuf += chunk;
+          process.stderr.write(data);
+        });
+        let stdout = "";
+        child.stdout?.on("data", (data) => {
+          stdout += data.toString();
+        });
+        child.on("close", (code) => {
+          if (code === 0 && stdout.trim()) {
+            try {
+              const summary = JSON.parse(stdout.trim());
+              console.log(
+                `
+Imported ${summary.files_created} eval(s) from ${summary.dataset} \u2192 ${summary.output_dir}/`
+              );
+            } catch {
+              if (stdout.trim()) console.log(stdout.trim());
+            }
+          } else if (code !== 0) {
+            const tail = stderrBuf.trim().slice(-2e3);
+            if (tail) {
+              console.error("\n--- import-huggingface.py stderr (last 2 000 chars) ---");
+              console.error(tail);
+            }
+          }
+        });
+      });
+    } catch (err2) {
+      if (err2 instanceof Error && err2.code === "ENOENT") {
+        console.error(
+          "Error: `uv` is not installed or not found on PATH.\nInstall it with: curl -LsSf https://astral.sh/uv/install.sh | sh\nSee https://docs.astral.sh/uv/ for details."
+        );
+        process.exit(1);
+      }
+      throw err2;
+    }
+  }
+});
+
 // src/commands/import/index.ts
 var importCommand = subcommands({
   name: "import",
-  description: "Import agent session transcripts for offline grading",
+  description: "Import agent session transcripts and datasets for offline grading",
   cmds: {
     claude: importClaudeCommand,
     codex: importCodexCommand,
-    copilot: importCopilotCommand
+    copilot: importCopilotCommand,
+    huggingface: importHuggingFaceCommand
   }
 });
 
 // src/commands/init/index.ts
-import { existsSync, mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
-import path8 from "node:path";
+import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
+import path9 from "node:path";
 import * as readline from "node:readline/promises";
 
 // src/templates/index.ts
 import { readFileSync as readFileSync3, readdirSync, statSync } from "node:fs";
-import path7 from "node:path";
+import path8 from "node:path";
 import { fileURLToPath } from "node:url";
 function getAgentvTemplates() {
   return getTemplatesFromDir(".agentv");
 }
 function getEnvExampleTemplate() {
-  const currentDir = path7.dirname(fileURLToPath(import.meta.url));
-  const templatesBase = currentDir.includes(`${path7.sep}dist`) ? path7.join(currentDir, "templates") : currentDir;
-  const content = readFileSync3(path7.join(templatesBase, ".env.example"), "utf-8");
+  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");
   return { path: ".env.example", content };
 }
 function getTemplatesFromDir(subdir) {
-  const currentDir = path7.dirname(fileURLToPath(import.meta.url));
+  const currentDir = path8.dirname(fileURLToPath(import.meta.url));
   let templatesDir;
-  if (currentDir.includes(`${path7.sep}dist`)) {
-    templatesDir = path7.join(currentDir, "templates", subdir);
+  if (currentDir.includes(`${path8.sep}dist`)) {
+    templatesDir = path8.join(currentDir, "templates", subdir);
   } else {
-    templatesDir = path7.join(currentDir, subdir);
+    templatesDir = path8.join(currentDir, subdir);
   }
   return readTemplatesRecursively(templatesDir, "");
 }
@@ -4342,15 +4470,15 @@ function readTemplatesRecursively(dir, relativePath) {
   const templates = [];
   const entries2 = readdirSync(dir);
   for (const entry of entries2) {
-    const fullPath = path7.join(dir, entry);
+    const fullPath = path8.join(dir, entry);
     const stat3 = statSync(fullPath);
-    const entryRelativePath = relativePath ? path7.join(relativePath, entry) : entry;
+    const entryRelativePath = relativePath ? path8.join(relativePath, entry) : entry;
     if (stat3.isDirectory()) {
       templates.push(...readTemplatesRecursively(fullPath, entryRelativePath));
     } else {
       const content = readFileSync3(fullPath, "utf-8");
       templates.push({
-        path: entryRelativePath.split(path7.sep).join("/"),
+        path: entryRelativePath.split(path8.sep).join("/"),
         // Normalize to forward slashes
         content
       });
@@ -4379,22 +4507,22 @@ async function promptYesNo(message) {
   }
 }
 async function initCommand(options = {}) {
-  const targetPath = path8.resolve(options.targetPath ?? ".");
-  const agentvDir = path8.join(targetPath, ".agentv");
+  const targetPath = path9.resolve(options.targetPath ?? ".");
+  const agentvDir = path9.join(targetPath, ".agentv");
   const otherAgentvTemplates = getAgentvTemplates();
   const envTemplate = getEnvExampleTemplate();
   const existingFiles = [];
   if (envTemplate) {
-    const envFilePath = path8.join(targetPath, ".env.example");
-    if (existsSync(envFilePath)) {
+    const envFilePath = path9.join(targetPath, ".env.example");
+    if (existsSync2(envFilePath)) {
       existingFiles.push(".env.example");
     }
   }
-  if (existsSync(agentvDir)) {
+  if (existsSync2(agentvDir)) {
     for (const template of otherAgentvTemplates) {
-      const targetFilePath = path8.join(agentvDir, template.path);
-      if (existsSync(targetFilePath)) {
-        existingFiles.push(path8.relative(targetPath, targetFilePath));
+      const targetFilePath = path9.join(agentvDir, template.path);
+      if (existsSync2(targetFilePath)) {
+        existingFiles.push(path9.relative(targetPath, targetFilePath));
       }
     }
   }
@@ -4412,22 +4540,22 @@ async function initCommand(options = {}) {
     }
     console.log();
   }
-  if (!existsSync(agentvDir)) {
+  if (!existsSync2(agentvDir)) {
     mkdirSync(agentvDir, { recursive: true });
   }
   if (envTemplate) {
-    const envFilePath = path8.join(targetPath, ".env.example");
+    const envFilePath = path9.join(targetPath, ".env.example");
     writeFileSync2(envFilePath, envTemplate.content, "utf-8");
     console.log("Created .env.example");
   }
   for (const template of otherAgentvTemplates) {
-    const targetFilePath = path8.join(agentvDir, template.path);
-    const targetDirPath = path8.dirname(targetFilePath);
-    if (!existsSync(targetDirPath)) {
+    const targetFilePath = path9.join(agentvDir, template.path);
+    const targetDirPath = path9.dirname(targetFilePath);
+    if (!existsSync2(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync2(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path8.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path9.relative(targetPath, targetFilePath)}`);
   }
   console.log("\nAgentV initialized successfully!");
   console.log("\nFiles installed to root:");
@@ -4435,7 +4563,7 @@ async function initCommand(options = {}) {
     console.log("  - .env.example");
   }
   console.log(`
-Files installed to ${path8.relative(targetPath, agentvDir)}:`);
+Files installed to ${path9.relative(targetPath, agentvDir)}:`);
   for (const t of otherAgentvTemplates) {
     console.log(`  - ${t.path}`);
   }
@@ -4465,415 +4593,291 @@ var initCmdTsCommand = command({
   }
 });
 
-// src/commands/inspect/utils.ts
-import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
-import path9 from "node:path";
-var colors2 = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  green: "\x1B[32m",
-  red: "\x1B[31m",
-  yellow: "\x1B[33m",
-  cyan: "\x1B[36m",
-  gray: "\x1B[90m"
-};
-var noColor2 = process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
-var c2 = noColor2 ? Object.fromEntries(Object.keys(colors2).map((k) => [k, ""])) : colors2;
-var ansiPattern2 = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
-function stripAnsi3(str) {
-  return str.replace(ansiPattern2, "");
-}
-function padRight2(str, len) {
-  const plainLen = stripAnsi3(str).length;
-  return str + " ".repeat(Math.max(0, len - plainLen));
-}
-function padLeft2(str, len) {
-  const plainLen = stripAnsi3(str).length;
-  return " ".repeat(Math.max(0, len - plainLen)) + str;
-}
-function loadResultFile(filePath) {
-  const resolvedFilePath = resolveTraceResultPath(filePath);
-  if (path9.extname(resolvedFilePath) === ".json") {
-    return loadOtlpTraceFile(resolvedFilePath);
-  }
-  if (path9.basename(resolvedFilePath) === RESULT_INDEX_FILENAME) {
-    return loadManifestAsRawResults(resolvedFilePath);
+// 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";
+function collectIndexFiles(dir) {
+  const files = [];
+  try {
+    const entries2 = readdirSync2(dir, { withFileTypes: true });
+    for (const entry of entries2) {
+      const fullPath = path10.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...collectIndexFiles(fullPath));
+      } else if (entry.name === "index.jsonl") {
+        files.push(fullPath);
+      }
+    }
+  } catch {
   }
-  return loadJsonlRecords(resolvedFilePath);
-}
-function resolveTraceResultPath(filePath) {
-  return resolveWorkspaceOrFilePath(filePath);
+  return files;
 }
-function loadJsonlRecords(filePath) {
-  const content = readFileSync4(filePath, "utf8");
-  const lines = content.trim().split("\n").filter((line) => line.trim());
-  return lines.map((line, i) => {
-    const record = JSON.parse(line);
-    if (typeof record.score !== "number") {
-      throw new Error(`Missing or invalid score in result at line ${i + 1}: ${line.slice(0, 100)}`);
+function extractToolNames(record) {
+  const tools = /* @__PURE__ */ new Set();
+  const trace = record.trace;
+  if (trace?.tool_calls && typeof trace.tool_calls === "object") {
+    for (const name of Object.keys(trace.tool_calls)) {
+      tools.add(name);
     }
-    return record;
-  });
-}
-function loadManifestAsRawResults(filePath) {
-  return loadManifestResults(filePath).map(toRawResult);
-}
-function toRawResult(result) {
-  return {
-    timestamp: result.timestamp,
-    test_id: result.testId,
-    suite: result.suite,
-    conversation_id: result.conversationId,
-    score: result.score,
-    assertions: result.assertions?.map((assertion) => ({
-      text: assertion.text,
-      passed: assertion.passed,
-      evidence: assertion.evidence
-    })),
-    target: result.target,
-    error: result.error,
-    scores: result.scores?.map((score) => ({
-      name: score.name,
-      type: score.type,
-      score: score.score,
-      assertions: score.assertions?.map((assertion) => ({
-        text: assertion.text,
-        passed: assertion.passed,
-        evidence: assertion.evidence
-      })),
-      weight: score.weight
-    })),
-    token_usage: result.tokenUsage ? {
-      input: result.tokenUsage.input,
-      output: result.tokenUsage.output,
-      cached: result.tokenUsage.cached
-    } : void 0,
-    cost_usd: result.costUsd,
-    duration_ms: result.durationMs,
-    start_time: result.startTime,
-    end_time: result.endTime,
-    input: result.input,
-    output: result.output,
-    file_changes: result.fileChanges
-  };
-}
-function loadOtlpTraceFile(filePath) {
-  const parsed = JSON.parse(readFileSync4(filePath, "utf8"));
-  const spans = parsed.resourceSpans?.flatMap((resource) => resource.scopeSpans ?? []).flatMap((scope) => scope.spans ?? []);
-  if (!spans || spans.length === 0) {
-    return [];
   }
-  const spanMap = /* @__PURE__ */ new Map();
-  const childMap = /* @__PURE__ */ new Map();
-  for (const span of spans) {
-    if (!span.spanId) continue;
-    spanMap.set(span.spanId, span);
-    if (span.parentSpanId) {
-      const siblings = childMap.get(span.parentSpanId) ?? [];
-      siblings.push(span);
-      childMap.set(span.parentSpanId, siblings);
-    }
-  }
-  const roots = spans.filter((span) => !span.parentSpanId || !spanMap.has(span.parentSpanId));
-  const supportedRoots = roots.filter(isAgentvEvalRoot);
-  const candidateRoots = supportedRoots.length > 0 ? supportedRoots : roots;
-  return candidateRoots.map((root, index) => {
-    const descendants = collectChildSpans(root.spanId, childMap);
-    const rootAttrs = parseOtlpAttributes(root.attributes);
-    const parsedDescendants = descendants.map((span) => ({
-      ...span,
-      parsedAttributes: parseOtlpAttributes(span.attributes)
-    }));
-    const toolSpans = parsedDescendants.filter(
-      (span) => typeof span.parsedAttributes.gen_ai_tool_name === "string"
-    );
-    const llmSpans = parsedDescendants.filter(
-      (span) => span.parsedAttributes.gen_ai_operation_name === "chat" || typeof span.name === "string" && span.name.startsWith("chat ")
-    );
-    const tokenUsage = descendants.reduce(
-      (acc, span) => {
-        const attrs = parseOtlpAttributes(span.attributes);
-        acc.input += numberAttr(attrs.gen_ai_usage_input_tokens) ?? 0;
-        acc.output += numberAttr(attrs.gen_ai_usage_output_tokens) ?? 0;
-        const cached = numberAttr(attrs.gen_ai_usage_cache_read_input_tokens);
-        if (cached !== void 0 && cached > 0) {
-          acc.cached = (acc.cached ?? 0) + cached;
+  const output = record.output;
+  if (Array.isArray(output)) {
+    for (const msg of output) {
+      if (typeof msg === "object" && msg !== null && Array.isArray(msg.tool_calls)) {
+        for (const tc of msg.tool_calls) {
+          if (typeof tc.tool === "string") {
+            tools.add(tc.tool);
+          }
         }
-        return acc;
-      },
-      { input: 0, output: 0, cached: void 0 }
-    );
-    const traceSummary = buildDerivedTraceSummary({
-      trace: {
-        event_count: numberAttr(rootAttrs.agentv_trace_event_count) ?? (toolSpans.length > 0 ? toolSpans.length : void 0),
-        tool_calls: countRawSpanNames(
-          toolSpans.map((span) => ({
-            type: "tool",
-            name: String(span.parsedAttributes.gen_ai_tool_name)
-          }))
-        ),
-        error_count: descendants.filter((span) => span.status?.code === 2).length || void 0,
-        llm_call_count: numberAttr(rootAttrs.agentv_trace_llm_call_count) ?? (llmSpans.length > 0 ? llmSpans.length : void 0)
-      },
-      spans: [
-        ...llmSpans.map((span) => ({
-          type: "llm",
-          name: span.name ?? "chat",
-          duration_ms: durationFromSpan(span)
-        })),
-        ...toolSpans.map((span) => ({
-          type: "tool",
-          name: String(span.parsedAttributes.gen_ai_tool_name),
-          duration_ms: durationFromSpan(span)
-        }))
-      ],
-      duration_ms: numberAttr(rootAttrs.agentv_trace_duration_ms) ?? durationFromSpan(root),
-      cost_usd: numberAttr(rootAttrs.agentv_trace_cost_usd),
-      token_usage: tokenUsage.input || tokenUsage.output || tokenUsage.cached || numberAttr(rootAttrs.agentv_trace_token_input) || numberAttr(rootAttrs.agentv_trace_token_output) || numberAttr(rootAttrs.agentv_trace_token_cached) ? {
-        input: tokenUsage.input || numberAttr(rootAttrs.agentv_trace_token_input) || 0,
-        output: tokenUsage.output || numberAttr(rootAttrs.agentv_trace_token_output) || 0,
-        ...tokenUsage.cached || numberAttr(rootAttrs.agentv_trace_token_cached) ? {
-          cached: tokenUsage.cached || numberAttr(rootAttrs.agentv_trace_token_cached) || 0
-        } : {}
-      } : void 0
-    });
-    const score = numberAttr(rootAttrs.agentv_score);
-    if (score === void 0) {
-      throw new Error(
-        `Unsupported OTLP trace root span at index ${index + 1}: missing agentv.score attribute`
-      );
+      }
     }
-    return {
-      test_id: stringAttr(rootAttrs.agentv_test_id) ?? stringAttr(rootAttrs.agentv_eval_id) ?? `trace-${index + 1}`,
-      suite: stringAttr(rootAttrs.agentv_suite),
-      target: stringAttr(rootAttrs.agentv_target),
-      score,
-      error: root.status?.code === 2 ? root.status.message : void 0,
-      cost_usd: traceSummary?.cost_usd,
-      duration_ms: traceSummary?.duration_ms,
-      token_usage: traceSummary?.token_usage,
-      trace: traceSummary ? {
-        event_count: traceSummary.event_count,
-        tool_calls: traceSummary.tool_calls,
-        error_count: traceSummary.error_count,
-        tool_durations: traceSummary.tool_durations,
-        llm_call_count: traceSummary.llm_call_count,
-        token_usage: traceSummary.token_usage,
-        cost_usd: traceSummary.cost_usd,
-        duration_ms: traceSummary.duration_ms
-      } : void 0,
-      spans: traceSummary?.spans,
-      output: stringAttr(rootAttrs.agentv_output_text),
-      scores: root.events?.filter(
-        (event) => event.name?.startsWith("agentv.grader.") || event.name?.startsWith("agentv.evaluator.")
-      ).map((event) => {
-        const attrs = parseOtlpAttributes(event.attributes);
-        const name = event.name?.replace(/^agentv\.grader\./, "").replace(/^agentv\.evaluator\./, "") ?? "unknown";
-        return {
-          name,
-          type: stringAttr(attrs.agentv_grader_type) ?? stringAttr(attrs.agentv_evaluator_type) ?? "unknown",
-          score: numberAttr(attrs.agentv_grader_score) ?? numberAttr(attrs.agentv_evaluator_score) ?? 0
-        };
-      })
-    };
-  });
-}
-function isAgentvEvalRoot(span) {
-  const attrs = parseOtlpAttributes(span.attributes);
-  return span.name === "agentv.eval" || numberAttr(attrs.agentv_score) !== void 0 || typeof stringAttr(attrs.agentv_test_id) === "string";
-}
-function collectChildSpans(spanId, childMap) {
-  if (!spanId) return [];
-  const direct = childMap.get(spanId) ?? [];
-  const all = [...direct];
-  for (const child of direct) {
-    all.push(...collectChildSpans(child.spanId, childMap));
-  }
-  return all;
-}
-function parseOtlpAttributes(attributes) {
-  const parsed = {};
-  for (const attribute of attributes ?? []) {
-    parsed[attribute.key.replace(/\./g, "_")] = parseOtlpValue(attribute.value);
-  }
-  return parsed;
-}
-function parseOtlpValue(value) {
-  if (!value) return void 0;
-  if ("stringValue" in value && value.stringValue !== void 0) return value.stringValue;
-  if ("intValue" in value && value.intValue !== void 0) return Number(value.intValue);
-  if ("doubleValue" in value && value.doubleValue !== void 0) return value.doubleValue;
-  if ("boolValue" in value && value.boolValue !== void 0) return value.boolValue;
-  if ("arrayValue" in value)
-    return (value.arrayValue?.values ?? []).map((entry) => parseOtlpValue(entry));
-  return void 0;
-}
-function durationFromSpan(span) {
-  const start = Number(span.startTimeUnixNano);
-  const end = Number(span.endTimeUnixNano);
-  if (!Number.isFinite(start) || !Number.isFinite(end)) return void 0;
-  return Math.round((end - start) / 1e6);
-}
-function stringAttr(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function numberAttr(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function buildDerivedTraceSummary(result) {
-  const toolSpans = (result.spans ?? []).filter((span) => span.type === "tool");
-  const llmSpans = (result.spans ?? []).filter((span) => span.type === "llm");
-  const toolCalls = result.trace?.tool_calls ?? countRawSpanNames(toolSpans);
-  const toolDurations = result.trace?.tool_durations ?? groupRawSpanDurations(toolSpans);
-  const hasSpanData = (result.spans?.length ?? 0) > 0;
-  const eventCount = result.trace?.event_count ?? (hasSpanData ? toolSpans.length : void 0);
-  const llmCallCount = result.trace?.llm_call_count ?? (hasSpanData ? llmSpans.length : void 0);
-  if (!result.trace && !result.spans?.length && result.token_usage === void 0 && result.cost_usd === void 0 && result.duration_ms === void 0) {
-    return void 0;
-  }
-  return {
-    event_count: eventCount,
-    tool_calls: toolCalls,
-    error_count: result.trace?.error_count,
-    tool_durations: toolDurations,
-    llm_call_count: llmCallCount,
-    token_usage: result.trace?.token_usage ?? result.token_usage,
-    cost_usd: result.trace?.cost_usd ?? result.cost_usd,
-    duration_ms: result.trace?.duration_ms ?? result.duration_ms,
-    spans: result.spans
-  };
-}
-function countRawSpanNames(spans) {
-  const counts = {};
-  for (const span of spans) {
-    counts[span.name] = (counts[span.name] ?? 0) + 1;
   }
-  return Object.keys(counts).length > 0 ? counts : void 0;
-}
-function groupRawSpanDurations(spans) {
-  const grouped = {};
-  for (const span of spans) {
-    if (span.duration_ms === void 0) continue;
-    const existing = grouped[span.name] ?? [];
-    existing.push(span.duration_ms);
-    grouped[span.name] = existing;
-  }
-  return Object.keys(grouped).length > 0 ? grouped : void 0;
-}
-function getTraceSummary(result) {
-  const derived = buildDerivedTraceSummary(result);
-  if (!derived) return void 0;
-  const { spans: _spans, ...trace } = derived;
-  return trace;
-}
-function getTraceSpans(result) {
-  return buildDerivedTraceSummary(result)?.spans ?? [];
+  return [...tools];
 }
-function toTraceSummary(result) {
-  const rawTrace = getTraceSummary(result);
-  if (!rawTrace) return void 0;
-  return toCamelCaseDeep(rawTrace);
-}
-function listResultFiles(cwd, limit) {
-  const runsDir = path9.join(cwd, ".agentv", "results", RESULT_RUNS_DIRNAME);
-  const files = [];
+function parseFilterableRecords(filePath) {
+  let content;
   try {
-    const entries2 = readdirSync2(runsDir, { withFileTypes: true });
-    for (const entry of entries2) {
-      if (!entry.isDirectory()) {
-        continue;
-      }
-      const primaryPath = resolveExistingRunPrimaryPath(path9.join(runsDir, entry.name));
-      if (primaryPath) {
-        files.push({ filePath: primaryPath, displayName: entry.name });
+    content = readFileSync4(filePath, "utf8");
+  } catch {
+    return [];
+  }
+  const lines = content.split("\n").filter((line) => line.trim());
+  const records = [];
+  for (const line of lines) {
+    let raw;
+    try {
+      raw = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    let experiment = typeof raw.experiment === "string" ? raw.experiment : void 0;
+    if (!experiment) {
+      const parts = filePath.split(path10.sep);
+      const runsIdx = parts.indexOf("runs");
+      if (runsIdx !== -1 && parts.length - runsIdx >= 3) {
+        const candidate = parts[runsIdx + 1];
+        if (candidate && !/^\d{4}-\d{2}-\d{2}T/.test(candidate)) {
+          experiment = candidate;
+        }
       }
     }
-  } catch {
+    records.push({
+      file: filePath,
+      test_id: typeof raw.test_id === "string" ? raw.test_id : "unknown",
+      suite: typeof raw.suite === "string" ? raw.suite : void 0,
+      target: typeof raw.target === "string" ? raw.target : void 0,
+      experiment,
+      score: typeof raw.score === "number" ? raw.score : 0,
+      execution_status: typeof raw.execution_status === "string" ? raw.execution_status : void 0,
+      error: typeof raw.error === "string" ? raw.error : void 0,
+      timestamp: typeof raw.timestamp === "string" ? raw.timestamp : void 0,
+      tool_names: extractToolNames(raw)
+    });
   }
-  files.sort((a, b) => b.displayName.localeCompare(a.displayName));
-  const limited = limit !== void 0 && limit > 0 ? files.slice(0, limit) : files;
-  const metas = [];
-  for (const { filePath, displayName } of limited) {
+  return records;
+}
+function buildFilterPredicate(opts) {
+  return (record) => {
+    if (opts.target && record.target !== opts.target) return false;
+    if (opts.experiment && record.experiment !== opts.experiment) return false;
+    if (opts.scoreBelow !== void 0 && record.score >= opts.scoreBelow) return false;
+    if (opts.scoreAbove !== void 0 && record.score <= opts.scoreAbove) return false;
+    if (opts.status) {
+      const statusMap = {
+        pass: ["ok"],
+        fail: ["quality_failure"],
+        error: ["error", "timeout", "provider_error"]
+      };
+      const allowedStatuses = statusMap[opts.status] ?? [opts.status];
+      if (record.execution_status && !allowedStatuses.includes(record.execution_status))
+        return false;
+      if (!record.execution_status) {
+        if (opts.status === "pass" && record.score < 1) return false;
+        if (opts.status === "fail" && record.score >= 1) return false;
+        if (opts.status === "error" && !record.error) return false;
+      }
+    }
+    if (opts.hasTool) {
+      const toolPattern = opts.hasTool.toLowerCase();
+      const hasMatch = record.tool_names.some((t) => t.toLowerCase().includes(toolPattern));
+      if (!hasMatch) return false;
+    }
+    return true;
+  };
+}
+function discoverFilterSources(searchPath, cwd) {
+  if (searchPath) {
+    const resolved = path10.isAbsolute(searchPath) ? searchPath : path10.resolve(cwd, searchPath);
+    if (!existsSync3(resolved)) {
+      console.error(`${c.red}Error:${c.reset} Path does not exist: ${resolved}`);
+      process.exit(1);
+    }
     try {
-      const fileStat = statSync2(filePath);
-      const results = loadResultFile(filePath);
-      const testCount = results.length;
-      const passCount = results.filter((r) => r.score >= DEFAULT_THRESHOLD).length;
-      const passRate = testCount > 0 ? passCount / testCount : 0;
-      const avgScore = testCount > 0 ? results.reduce((sum, r) => sum + r.score, 0) / testCount : 0;
-      const filenameTimestamp = extractTimestampFromFilename(displayName);
-      const timestamp = filenameTimestamp ?? results[0]?.timestamp ?? "unknown";
-      metas.push({
-        path: filePath,
-        filename: displayName,
-        timestamp,
-        testCount,
-        passRate,
-        avgScore,
-        sizeBytes: fileStat.size
-      });
+      if (statSync2(resolved).isDirectory()) {
+        return collectIndexFiles(resolved);
+      }
     } catch {
     }
+    return [resolved];
   }
-  return metas;
+  return collectIndexFiles(path10.join(cwd, ".agentv", "results", "runs"));
 }
-function extractTimestampFromFilename(filename) {
-  const match = filename.match(
-    /(?:^|eval_)(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z)(?:\.jsonl)?$/
+function formatFilterTable(records) {
+  const lines = [];
+  if (records.length === 0) {
+    lines.push(`${c.yellow}No matching results found.${c.reset}`);
+    return lines.join("\n");
+  }
+  lines.push("");
+  lines.push(
+    `${c.bold}Filtered Results${c.reset} ${c.dim}(${records.length} match${records.length !== 1 ? "es" : ""})${c.reset}`
   );
-  if (!match) return void 0;
-  return match[1].replace(/-(\d{2})-(\d{2})-(\d{3})Z$/, ":$1:$2.$3Z");
-}
-function formatNumber(n) {
-  return n.toLocaleString();
-}
-function formatDuration(ms) {
-  if (ms < 1e3) return `${Math.round(ms)}ms`;
-  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
-  const minutes = Math.floor(ms / 6e4);
-  const seconds = (ms % 6e4 / 1e3).toFixed(0);
-  return `${minutes}m${seconds}s`;
-}
-function formatCost(usd) {
-  if (usd < 0.01) return `$${usd.toFixed(4)}`;
-  return `$${usd.toFixed(3)}`;
-}
-function formatSize(bytes) {
-  if (bytes < 1024) return `${bytes}B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}
-function formatScore(score) {
-  return `${(score * 100).toFixed(0)}%`;
+  lines.push("");
+  const maxIdLen = Math.min(32, Math.max(7, ...records.map((r) => r.test_id.length)));
+  const maxTargetLen = Math.min(16, Math.max(6, ...records.map((r) => (r.target ?? "").length)));
+  const maxExpLen = Math.min(20, Math.max(10, ...records.map((r) => (r.experiment ?? "").length)));
+  const header = `  ${padRight("Test ID", maxIdLen)}  ${padRight("Target", maxTargetLen)}  ${padRight("Experiment", maxExpLen)}  ${padLeft("Score", 6)}  Status`;
+  lines.push(`${c.dim}${header}${c.reset}`);
+  lines.push(
+    `${c.dim}  ${"\u2500".repeat(maxIdLen)}  ${"\u2500".repeat(maxTargetLen)}  ${"\u2500".repeat(maxExpLen)}  ${"\u2500".repeat(6)}  ${"\u2500".repeat(16)}${c.reset}`
+  );
+  for (const record of records) {
+    const scoreColor = record.score >= 1 ? c.green : record.score >= 0.5 ? c.yellow : c.red;
+    const status = record.execution_status ?? (record.error ? "error" : record.score >= 1 ? "ok" : "quality_failure");
+    const statusColor = status === "ok" ? c.green : status === "error" ? c.red : c.yellow;
+    const row = `  ${padRight(record.test_id.slice(0, maxIdLen), maxIdLen)}  ${padRight((record.target ?? "-").slice(0, maxTargetLen), maxTargetLen)}  ${padRight((record.experiment ?? "-").slice(0, maxExpLen), maxExpLen)}  ${padLeft(`${scoreColor}${formatScore(record.score)}${c.reset}`, 6)}  ${statusColor}${status}${c.reset}`;
+    lines.push(row);
+  }
+  lines.push("");
+  const passCount = records.filter((r) => r.score >= 1).length;
+  const avgScore = records.length > 0 ? records.reduce((sum, r) => sum + r.score, 0) / records.length : 0;
+  lines.push(
+    `${c.dim}${records.length} result${records.length !== 1 ? "s" : ""} | ${passCount} passed | avg score: ${formatScore(avgScore)}${c.reset}`
+  );
+  lines.push("");
+  return lines.join("\n");
 }
+var inspectFilterCommand = command({
+  name: "filter",
+  description: "Filter evaluation results by target, experiment, score, status, or tool usage",
+  args: {
+    path: positional({
+      type: optional(string),
+      displayName: "path",
+      description: "Directory or file to filter (default: .agentv/results/runs/)"
+    }),
+    target: option({
+      type: optional(string),
+      long: "target",
+      description: "Filter by target name"
+    }),
+    experiment: option({
+      type: optional(string),
+      long: "experiment",
+      description: "Filter by experiment name"
+    }),
+    scoreBelow: option({
+      type: optional(number),
+      long: "score-below",
+      description: "Filter to results with score below this value"
+    }),
+    scoreAbove: option({
+      type: optional(number),
+      long: "score-above",
+      description: "Filter to results with score above this value"
+    }),
+    status: option({
+      type: optional(string),
+      long: "status",
+      description: "Filter by execution status: pass, fail, error (or raw value like ok, quality_failure)"
+    }),
+    hasTool: option({
+      type: optional(string),
+      long: "has-tool",
+      description: "Filter to results that used a specific tool (substring match)"
+    }),
+    dir: option({
+      type: optional(string),
+      long: "dir",
+      short: "d",
+      description: "Working directory (default: current directory)"
+    }),
+    format: option({
+      type: optional(oneOf(["table", "json"])),
+      long: "format",
+      short: "f",
+      description: "Output format: table (default) or json"
+    })
+  },
+  handler: async ({
+    path: searchPath,
+    target,
+    experiment,
+    scoreBelow,
+    scoreAbove,
+    status,
+    hasTool,
+    dir,
+    format
+  }) => {
+    const cwd = dir ?? process.cwd();
+    const sources = discoverFilterSources(searchPath, cwd);
+    if (sources.length === 0) {
+      console.error(`${c.yellow}No result files found.${c.reset}`);
+      console.error(`${c.dim}Run an evaluation first, or specify a path.${c.reset}`);
+      process.exit(0);
+    }
+    const allRecords = [];
+    for (const source of sources) {
+      allRecords.push(...parseFilterableRecords(source));
+    }
+    if (allRecords.length === 0) {
+      console.error(`${c.yellow}No results found in the specified path.${c.reset}`);
+      process.exit(0);
+    }
+    const predicate = buildFilterPredicate({
+      target,
+      experiment,
+      scoreBelow,
+      scoreAbove,
+      status,
+      hasTool
+    });
+    const filtered = allRecords.filter(predicate);
+    if (format === "json") {
+      console.log(JSON.stringify(filtered, null, 2));
+    } else {
+      console.log(formatFilterTable(filtered));
+    }
+  }
+});
 
 // src/commands/inspect/list.ts
 function formatListTable(metas) {
   const lines = [];
   if (metas.length === 0) {
-    lines.push(`${c2.yellow}No run workspaces found in .agentv/results/runs/${c2.reset}`);
-    lines.push(`${c2.dim}Run an evaluation first: agentv run <eval-file>${c2.reset}`);
+    lines.push(`${c.yellow}No run workspaces found in .agentv/results/runs/${c.reset}`);
+    lines.push(`${c.dim}Run an evaluation first: agentv run <eval-file>${c.reset}`);
     return lines.join("\n");
   }
   lines.push("");
-  lines.push(`${c2.bold}Evaluation Runs${c2.reset} ${c2.dim}(.agentv/results/runs/)${c2.reset}`);
+  lines.push(`${c.bold}Evaluation Runs${c.reset} ${c.dim}(.agentv/results/runs/)${c.reset}`);
   lines.push("");
   const maxFileLen = Math.max(4, ...metas.map((m) => m.filename.length));
-  const header = `  ${padRight2("File", maxFileLen)}  ${padLeft2("Tests", 5)}  ${padLeft2("Pass", 5)}  ${padLeft2("Score", 6)}  ${padLeft2("Size", 7)}  Timestamp`;
-  lines.push(`${c2.dim}${header}${c2.reset}`);
+  const header = `  ${padRight("File", maxFileLen)}  ${padLeft("Tests", 5)}  ${padLeft("Pass", 5)}  ${padLeft("Score", 6)}  ${padLeft("Size", 7)}  Timestamp`;
+  lines.push(`${c.dim}${header}${c.reset}`);
   lines.push(
-    `${c2.dim}  ${"\u2500".repeat(maxFileLen)}  ${"\u2500".repeat(5)}  ${"\u2500".repeat(5)}  ${"\u2500".repeat(6)}  ${"\u2500".repeat(7)}  ${"\u2500".repeat(24)}${c2.reset}`
+    `${c.dim}  ${"\u2500".repeat(maxFileLen)}  ${"\u2500".repeat(5)}  ${"\u2500".repeat(5)}  ${"\u2500".repeat(6)}  ${"\u2500".repeat(7)}  ${"\u2500".repeat(24)}${c.reset}`
   );
   for (const meta of metas) {
-    const passColor = meta.passRate >= 1 ? c2.green : meta.passRate >= 0.5 ? c2.yellow : c2.red;
-    const scoreColor = meta.avgScore >= 0.9 ? c2.green : meta.avgScore >= 0.5 ? c2.yellow : c2.red;
-    const row = `  ${padRight2(meta.filename, maxFileLen)}  ${padLeft2(String(meta.testCount), 5)}  ${padLeft2(`${passColor}${formatScore(meta.passRate)}${c2.reset}`, 5)}  ${padLeft2(`${scoreColor}${formatScore(meta.avgScore)}${c2.reset}`, 6)}  ${padLeft2(formatSize(meta.sizeBytes), 7)}  ${c2.dim}${meta.timestamp}${c2.reset}`;
+    const passColor = meta.passRate >= 1 ? c.green : meta.passRate >= 0.5 ? c.yellow : c.red;
+    const scoreColor = meta.avgScore >= 0.9 ? c.green : meta.avgScore >= 0.5 ? c.yellow : c.red;
+    const row = `  ${padRight(meta.filename, maxFileLen)}  ${padLeft(String(meta.testCount), 5)}  ${padLeft(`${passColor}${formatScore(meta.passRate)}${c.reset}`, 5)}  ${padLeft(`${scoreColor}${formatScore(meta.avgScore)}${c.reset}`, 6)}  ${padLeft(formatSize(meta.sizeBytes), 7)}  ${c.dim}${meta.timestamp}${c.reset}`;
     lines.push(row);
   }
   lines.push("");
   lines.push(
-    `${c2.dim}${metas.length} run workspace${metas.length !== 1 ? "s" : ""} found${c2.reset}`
+    `${c.dim}${metas.length} run workspace${metas.length !== 1 ? "s" : ""} found${c.reset}`
   );
   lines.push("");
   return lines.join("\n");
@@ -5073,19 +5077,19 @@ function renderTable(scored, assertSpec) {
     { header: "Verdict", width: 8 },
     { header: "Detail", width: 50 }
   ];
-  const headerLine = cols.map((col) => padRight2(`${c2.bold}${col.header}${c2.reset}`, col.width)).join("  ");
+  const headerLine = cols.map((col) => padRight(`${c.bold}${col.header}${c.reset}`, col.width)).join("  ");
   lines.push(headerLine);
   lines.push(cols.map((col) => "\u2500".repeat(col.width)).join("\u2500\u2500"));
   for (const r of scored) {
-    const verdictColor = r.verdict === "pass" ? c2.green : c2.red;
+    const verdictColor = r.verdict === "pass" ? c.green : c.red;
     const failed = r.assertions.filter((a) => !a.passed);
     const passed = r.assertions.filter((a) => a.passed);
     const detail = failed.length > 0 ? failed[0].text.slice(0, 48) : passed.length > 0 ? passed[0].text.slice(0, 48) : "";
     const row = [
-      padRight2(r.testId.slice(0, 24), cols[0].width),
-      padLeft2(formatScore(r.originalScore), cols[1].width),
-      padLeft2(`${verdictColor}${formatScore(r.newScore)}${c2.reset}`, cols[2].width),
-      padRight2(`${verdictColor}${r.verdict.toUpperCase()}${c2.reset}`, cols[3].width),
+      padRight(r.testId.slice(0, 24), cols[0].width),
+      padLeft(formatScore(r.originalScore), cols[1].width),
+      padLeft(`${verdictColor}${formatScore(r.newScore)}${c.reset}`, cols[2].width),
+      padRight(`${verdictColor}${r.verdict.toUpperCase()}${c.reset}`, cols[3].width),
       detail.slice(0, cols[4].width)
     ].join("  ");
     lines.push(row);
@@ -5095,7 +5099,7 @@ function renderTable(scored, assertSpec) {
   const meanScore = total > 0 ? scored.reduce((sum, r) => sum + r.newScore, 0) / total : 0;
   lines.push("");
   lines.push(
-    `${c2.bold}Assert:${c2.reset} ${assertSpec}  ${c2.bold}Results:${c2.reset} ${passCount}/${total} passed (${formatScore(passCount / (total || 1))})  ${c2.bold}Mean:${c2.reset} ${formatScore(meanScore)}`
+    `${c.bold}Assert:${c.reset} ${assertSpec}  ${c.bold}Results:${c.reset} ${passCount}/${total} passed (${formatScore(passCount / (total || 1))})  ${c.bold}Mean:${c.reset} ${formatScore(meanScore)}`
   );
   return lines.join("\n");
 }
@@ -5132,7 +5136,7 @@ var traceScoreCommand = command({
       evaluatorConfig = parseAssertSpec(assertSpec);
     } catch (err2) {
       const msg = err2 instanceof Error ? err2.message : String(err2);
-      console.error(`${c2.red}Error:${c2.reset} ${msg}`);
+      console.error(`${c.red}Error:${c.reset} ${msg}`);
       process.exit(1);
     }
     let results;
@@ -5140,11 +5144,11 @@ var traceScoreCommand = command({
       results = loadResultFile(file);
     } catch (err2) {
       const msg = err2 instanceof Error ? err2.message : String(err2);
-      console.error(`${c2.red}Error:${c2.reset} Could not load result file: ${msg}`);
+      console.error(`${c.red}Error:${c.reset} Could not load result file: ${msg}`);
       process.exit(1);
     }
     if (results.length === 0) {
-      console.error(`${c2.yellow}Warning:${c2.reset} No results found in ${file}`);
+      console.error(`${c.yellow}Warning:${c.reset} No results found in ${file}`);
       process.exit(0);
     }
     const traceRequired = ["latency", "cost", "token-usage", "execution-metrics"].includes(
@@ -5156,7 +5160,7 @@ var traceScoreCommand = command({
       );
       if (!hasTrace) {
         console.error(
-          `${c2.red}Error:${c2.reset} Source lacks trace metrics. Use an OTLP trace export via ${c2.bold}--otel-file${c2.reset} or a run manifest with summary metrics in ${c2.bold}index.jsonl${c2.reset}.`
+          `${c.red}Error:${c.reset} Source lacks trace metrics. Use an OTLP trace export via ${c.bold}--otel-file${c.reset} or a run manifest with summary metrics in ${c.bold}index.jsonl${c.reset}.`
         );
         process.exit(1);
       }
@@ -5166,12 +5170,12 @@ var traceScoreCommand = command({
       scored = await runScore(results, evaluatorConfig, testId);
     } catch (err2) {
       const msg = err2 instanceof Error ? err2.message : String(err2);
-      console.error(`${c2.red}Error:${c2.reset} Scoring failed: ${msg}`);
+      console.error(`${c.red}Error:${c.reset} Scoring failed: ${msg}`);
       process.exit(1);
     }
     if (scored.length === 0) {
       console.error(
-        `${c2.yellow}Warning:${c2.reset} No results matched${testId ? ` test ID "${testId}"` : ""}`
+        `${c.yellow}Warning:${c.reset} No results matched${testId ? ` test ID "${testId}"` : ""}`
       );
       process.exit(0);
     }
@@ -5187,6 +5191,192 @@ 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";
+function collectJsonlFiles(dir) {
+  const files = [];
+  try {
+    const entries2 = readdirSync3(dir, { withFileTypes: true });
+    for (const entry of entries2) {
+      const fullPath = path11.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...collectJsonlFiles(fullPath));
+      } else if (entry.name.endsWith(".jsonl")) {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function extractSnippet(text, matchIndex, matchLength, contextChars = 60) {
+  const start = Math.max(0, matchIndex - contextChars);
+  const end = Math.min(text.length, matchIndex + matchLength + contextChars);
+  let snippet = text.slice(start, end);
+  if (start > 0) snippet = `...${snippet}`;
+  if (end < text.length) snippet = `${snippet}...`;
+  return snippet.replace(/\n/g, "\\n").replace(/\r/g, "");
+}
+function searchJsonlFile(filePath, regex2, targetFilter, experimentFilter) {
+  const matches = [];
+  let content;
+  try {
+    content = readFileSync5(filePath, "utf8");
+  } catch {
+    return matches;
+  }
+  const lines = content.split("\n").filter((line) => line.trim());
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const target = typeof record.target === "string" ? record.target : void 0;
+    const experiment = typeof record.experiment === "string" ? record.experiment : void 0;
+    const score = typeof record.score === "number" ? record.score : void 0;
+    const testId = typeof record.test_id === "string" ? record.test_id : typeof record.source === "object" && record.source !== null ? record.source.session_id : void 0;
+    if (targetFilter && target !== targetFilter) continue;
+    if (experimentFilter && experiment !== experimentFilter) continue;
+    const match = regex2.exec(line);
+    if (match) {
+      matches.push({
+        file: filePath,
+        id: testId ?? `line-${i + 1}`,
+        lineNumber: i + 1,
+        snippet: extractSnippet(line, match.index, match[0].length),
+        target,
+        experiment,
+        score
+      });
+    }
+  }
+  return matches;
+}
+function discoverSources(basePath, cwd) {
+  if (basePath) {
+    const resolved = path11.isAbsolute(basePath) ? basePath : path11.resolve(cwd, basePath);
+    if (!existsSync4(resolved)) {
+      console.error(`${c.red}Error:${c.reset} Path does not exist: ${resolved}`);
+      process.exit(1);
+    }
+    try {
+      if (statSync3(resolved).isDirectory()) {
+        return collectJsonlFiles(resolved);
+      }
+    } catch {
+    }
+    return [resolved];
+  }
+  const sources = [];
+  sources.push(...collectJsonlFiles(path11.join(cwd, ".agentv", "results", "runs")));
+  sources.push(...collectJsonlFiles(path11.join(cwd, ".agentv", "transcripts")));
+  return sources;
+}
+function formatSearchResults(matches, pattern) {
+  const lines = [];
+  if (matches.length === 0) {
+    lines.push(`${c.yellow}No matches found for pattern: ${pattern}${c.reset}`);
+    return lines.join("\n");
+  }
+  lines.push("");
+  lines.push(`${c.bold}Search Results${c.reset} ${c.dim}pattern: /${pattern}/${c.reset}`);
+  lines.push(
+    `${c.dim}${matches.length} record${matches.length !== 1 ? "s" : ""} matched${c.reset}`
+  );
+  lines.push("");
+  const byFile = /* @__PURE__ */ new Map();
+  for (const match of matches) {
+    const existing = byFile.get(match.file) ?? [];
+    existing.push(match);
+    byFile.set(match.file, existing);
+  }
+  for (const [file, fileMatches] of byFile) {
+    lines.push(`${c.cyan}${file}${c.reset}`);
+    for (const match of fileMatches) {
+      const meta = [];
+      if (match.target) meta.push(`target:${match.target}`);
+      if (match.experiment) meta.push(`exp:${match.experiment}`);
+      if (match.score !== void 0) meta.push(`score:${match.score}`);
+      const metaStr = meta.length > 0 ? ` ${c.dim}[${meta.join(", ")}]${c.reset}` : "";
+      lines.push(
+        `  ${c.bold}${match.id}${c.reset} ${c.dim}(line ${match.lineNumber})${c.reset}${metaStr}`
+      );
+      lines.push(`    ${match.snippet}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var inspectSearchCommand = command({
+  name: "search",
+  description: "Search across evaluation results and transcripts for a regex pattern",
+  args: {
+    pattern: option({
+      type: string,
+      long: "pattern",
+      short: "p",
+      description: "Regex pattern to search for in result/transcript content"
+    }),
+    path: positional({
+      type: optional(string),
+      displayName: "path",
+      description: "Directory or file to search (default: .agentv/results/runs/ and .agentv/transcripts/)"
+    }),
+    target: option({
+      type: optional(string),
+      long: "target",
+      description: "Filter results to a specific target name"
+    }),
+    experiment: option({
+      type: optional(string),
+      long: "experiment",
+      description: "Filter results to a specific experiment name"
+    }),
+    dir: option({
+      type: optional(string),
+      long: "dir",
+      short: "d",
+      description: "Working directory (default: current directory)"
+    }),
+    format: option({
+      type: optional(oneOf(["table", "json"])),
+      long: "format",
+      short: "f",
+      description: "Output format: table (default) or json"
+    })
+  },
+  handler: async ({ pattern, path: searchPath, target, experiment, dir, format }) => {
+    const cwd = dir ?? process.cwd();
+    let regex2;
+    try {
+      regex2 = new RegExp(pattern, "i");
+    } catch (err2) {
+      console.error(`${c.red}Error:${c.reset} Invalid regex pattern: ${err2.message}`);
+      process.exit(1);
+    }
+    const sources = discoverSources(searchPath, cwd);
+    if (sources.length === 0) {
+      console.error(`${c.yellow}No JSONL files found to search.${c.reset}`);
+      console.error(`${c.dim}Run an evaluation first, or specify a path to search.${c.reset}`);
+      process.exit(0);
+    }
+    const allMatches = [];
+    for (const source of sources) {
+      const fileMatches = searchJsonlFile(source, regex2, target, experiment);
+      allMatches.push(...fileMatches);
+    }
+    if (format === "json") {
+      console.log(JSON.stringify(toSnakeCaseDeep(allMatches), null, 2));
+    } else {
+      console.log(formatSearchResults(allMatches, pattern));
+    }
+  }
+});
+
 // src/commands/inspect/show.ts
 function renderFlatTrace(result) {
   const trace = getTraceSummary(result);
@@ -5214,8 +5404,8 @@ function renderFlatTrace(result) {
 }
 function renderScores(scores) {
   return scores.map((s) => {
-    const scoreColor = s.score >= 0.9 ? c2.green : s.score >= 0.5 ? c2.yellow : c2.red;
-    return `${s.name} ${scoreColor}${formatScore(s.score)}${c2.reset}`;
+    const scoreColor = s.score >= 0.9 ? c.green : s.score >= 0.5 ? c.yellow : c.red;
+    return `${s.name} ${scoreColor}${formatScore(s.score)}${c.reset}`;
   }).join(" | ");
 }
 function renderTree(result) {
@@ -5228,7 +5418,7 @@ function renderTree(result) {
     if (getTraceSummary(result) || result.duration_ms !== void 0 || result.cost_usd !== void 0) {
       return renderFlatTrace(result);
     }
-    return `${c2.dim}No trace data available${c2.reset}`;
+    return `${c.dim}No trace data available${c.reset}`;
   }
   const lines = [];
   const testId = result.test_id ?? result.eval_id ?? "unknown";
@@ -5238,7 +5428,7 @@ function renderTree(result) {
   if (totalDuration !== void 0) rootParts.push(formatDuration(totalDuration));
   if (totalTokens !== void 0) rootParts.push(`${formatNumber(totalTokens)} tok`);
   if (result.cost_usd !== void 0) rootParts.push(formatCost(result.cost_usd));
-  lines.push(`${c2.bold}${rootParts.join(", ")}${c2.reset}`);
+  lines.push(`${c.bold}${rootParts.join(", ")}${c.reset}`);
   const steps = [];
   for (let i = 0; i < messages.length; i++) {
     const msg = messages[i];
@@ -5256,7 +5446,7 @@ function renderTree(result) {
     const connector = isLast ? "\u2514\u2500" : "\u251C\u2500";
     const childPrefix = isLast ? "   " : "\u2502  ";
     if (step.type === "llm") {
-      const parts = [`${c2.cyan}model${c2.reset}`];
+      const parts = [`${c.cyan}model${c.reset}`];
       if (step.msg.duration_ms !== void 0) parts.push(formatDuration(step.msg.duration_ms));
       if (step.msg.token_usage) {
         const tok = step.msg.token_usage.input + step.msg.token_usage.output;
@@ -5267,18 +5457,18 @@ function renderTree(result) {
       const toolCalls = step.msg.tool_calls ?? [];
       if (toolCalls.length === 1) {
         const tc = toolCalls[0];
-        const parts = [`${c2.yellow}${tc.tool}${c2.reset}`];
+        const parts = [`${c.yellow}${tc.tool}${c.reset}`];
         if (tc.duration_ms !== void 0) parts.push(formatDuration(tc.duration_ms));
         lines.push(`${connector} ${parts.join(", ")}`);
       } else {
-        const parts = [`${c2.dim}tools${c2.reset}`];
+        const parts = [`${c.dim}tools${c.reset}`];
         if (step.msg.duration_ms !== void 0) parts.push(formatDuration(step.msg.duration_ms));
         lines.push(`${connector} ${parts.join(", ")}`);
         for (let ti = 0; ti < toolCalls.length; ti++) {
           const tc = toolCalls[ti];
           const isLastTool = ti === toolCalls.length - 1;
           const toolConnector = isLastTool ? "\u2514\u2500" : "\u251C\u2500";
-          const tcParts = [`${c2.yellow}${tc.tool}${c2.reset}`];
+          const tcParts = [`${c.yellow}${tc.tool}${c.reset}`];
           if (tc.duration_ms !== void 0) tcParts.push(formatDuration(tc.duration_ms));
           lines.push(`${childPrefix}${toolConnector} ${tcParts.join(", ")}`);
         }
@@ -5287,7 +5477,7 @@ function renderTree(result) {
   }
   if (result.scores && result.scores.length > 0) {
     lines.push("");
-    lines.push(`${c2.dim}Scores:${c2.reset} ${renderScores(result.scores)}`);
+    lines.push(`${c.dim}Scores:${c.reset} ${renderScores(result.scores)}`);
   }
   return lines.join("\n");
 }
@@ -5299,11 +5489,11 @@ function renderSpanTree(result, spans) {
   if (result.duration_ms !== void 0) rootParts.push(formatDuration(result.duration_ms));
   if (totalTokens !== void 0) rootParts.push(`${formatNumber(totalTokens)} tok`);
   if (result.cost_usd !== void 0) rootParts.push(formatCost(result.cost_usd));
-  lines.push(`${c2.bold}${rootParts.join(", ")}${c2.reset}`);
+  lines.push(`${c.bold}${rootParts.join(", ")}${c.reset}`);
   spans.forEach((span, index) => {
     const connector = index === spans.length - 1 ? "\u2514\u2500" : "\u251C\u2500";
-    const color = span.type === "llm" ? c2.cyan : c2.yellow;
-    const parts = [`${color}${span.name}${c2.reset}`];
+    const color = span.type === "llm" ? c.cyan : c.yellow;
+    const parts = [`${color}${span.name}${c.reset}`];
     if (span.duration_ms !== void 0) {
       parts.push(formatDuration(span.duration_ms));
     }
@@ -5311,7 +5501,7 @@ function renderSpanTree(result, spans) {
   });
   if (result.scores && result.scores.length > 0) {
     lines.push("");
-    lines.push(`${c2.dim}Scores:${c2.reset} ${renderScores(result.scores)}`);
+    lines.push(`${c.dim}Scores:${c.reset} ${renderScores(result.scores)}`);
   }
   return lines.join("\n");
 }
@@ -5322,30 +5512,30 @@ function formatResultDetail(result, index, tree) {
     lines.push(renderTree(result));
     return lines.join("\n");
   }
-  const scoreColor = result.score >= 0.9 ? c2.green : result.score >= 0.5 ? c2.yellow : c2.red;
+  const scoreColor = result.score >= 0.9 ? c.green : result.score >= 0.5 ? c.yellow : c.red;
   lines.push(
-    `${c2.bold}${testId}${c2.reset}  ${scoreColor}${formatScore(result.score)}${c2.reset}${result.target ? `  ${c2.dim}target: ${result.target}${c2.reset}` : ""}${result.suite ? `  ${c2.dim}suite: ${result.suite}${c2.reset}` : ""}`
+    `${c.bold}${testId}${c.reset}  ${scoreColor}${formatScore(result.score)}${c.reset}${result.target ? `  ${c.dim}target: ${result.target}${c.reset}` : ""}${result.suite ? `  ${c.dim}suite: ${result.suite}${c.reset}` : ""}`
   );
   if (result.error) {
-    lines.push(`  ${c2.red}Error: ${result.error}${c2.reset}`);
+    lines.push(`  ${c.red}Error: ${result.error}${c.reset}`);
   }
   if (result.assertions && result.assertions.length > 0) {
     const passed = result.assertions.filter((a) => a.passed);
     const failed = result.assertions.filter((a) => !a.passed);
     if (passed.length > 0)
       lines.push(
-        `  ${c2.green}\u2713 Passed:${c2.reset} ${passed.map((a) => a.text).join(", ")}`
+        `  ${c.green}\u2713 Passed:${c.reset} ${passed.map((a) => a.text).join(", ")}`
       );
     if (failed.length > 0)
       lines.push(
-        `  ${c2.red}\u2717 Failed:${c2.reset} ${failed.map((a) => a.text).join(", ")}`
+        `  ${c.red}\u2717 Failed:${c.reset} ${failed.map((a) => a.text).join(", ")}`
       );
   }
   if (result.scores && result.scores.length > 0) {
-    lines.push(`  ${c2.dim}Scores:${c2.reset} ${renderScores(result.scores)}`);
+    lines.push(`  ${c.dim}Scores:${c.reset} ${renderScores(result.scores)}`);
   }
   if (result.trace || result.duration_ms !== void 0 || result.cost_usd !== void 0) {
-    lines.push(`  ${c2.dim}Trace:${c2.reset} ${renderFlatTrace(result)}`);
+    lines.push(`  ${c.dim}Trace:${c.reset} ${renderFlatTrace(result)}`);
   }
   if (result.assertions && result.assertions.length > 0) {
     const withEvidence = result.assertions.filter((a) => a.evidence);
@@ -5353,7 +5543,7 @@ function formatResultDetail(result, index, tree) {
       const maxLen = 200;
       const evidence = withEvidence[0].evidence;
       const truncated = evidence.length > maxLen ? `${evidence.slice(0, maxLen)}...` : evidence;
-      lines.push(`  ${c2.dim}Evidence: ${truncated}${c2.reset}`);
+      lines.push(`  ${c.dim}Evidence: ${truncated}${c.reset}`);
     }
   }
   return lines.join("\n");
@@ -5364,9 +5554,9 @@ function formatShowTable(results, filePath, testIdFilter, tree) {
   if (testIdFilter) {
     filtered = results.filter((r) => (r.test_id ?? r.eval_id) === testIdFilter);
     if (filtered.length === 0) {
-      lines.push(`${c2.yellow}No results found with test ID "${testIdFilter}"${c2.reset}`);
+      lines.push(`${c.yellow}No results found with test ID "${testIdFilter}"${c.reset}`);
       lines.push("");
-      lines.push(`${c2.dim}Available test IDs:${c2.reset}`);
+      lines.push(`${c.dim}Available test IDs:${c.reset}`);
       for (const r of results) {
         lines.push(`  ${r.test_id ?? r.eval_id ?? "(unnamed)"}`);
       }
@@ -5374,19 +5564,19 @@ function formatShowTable(results, filePath, testIdFilter, tree) {
     }
   }
   lines.push("");
-  lines.push(`${c2.bold}Results:${c2.reset} ${c2.cyan}${filePath}${c2.reset}`);
+  lines.push(`${c.bold}Results:${c.reset} ${c.cyan}${filePath}${c.reset}`);
   const totalTests = filtered.length;
   const passCount = filtered.filter((r) => r.score >= 1).length;
   const failCount = totalTests - passCount;
   const avgScore = totalTests > 0 ? filtered.reduce((sum, r) => sum + r.score, 0) / totalTests : 0;
   lines.push(
-    `${c2.dim}${totalTests} test${totalTests !== 1 ? "s" : ""} | ${c2.green}${passCount} passed${c2.reset}${c2.dim}${failCount > 0 ? ` | ${c2.red}${failCount} failed${c2.reset}${c2.dim}` : ""} | avg score: ${formatScore(avgScore)}${c2.reset}`
+    `${c.dim}${totalTests} test${totalTests !== 1 ? "s" : ""} | ${c.green}${passCount} passed${c.reset}${c.dim}${failCount > 0 ? ` | ${c.red}${failCount} failed${c.reset}${c.dim}` : ""} | avg score: ${formatScore(avgScore)}${c.reset}`
   );
   lines.push("");
   for (let i = 0; i < filtered.length; i++) {
     lines.push(formatResultDetail(filtered[i], i, tree ?? false));
     if (i < filtered.length - 1) {
-      lines.push(`${c2.dim}${"\u2500".repeat(60)}${c2.reset}`);
+      lines.push(`${c.dim}${"\u2500".repeat(60)}${c.reset}`);
     }
   }
   lines.push("");
@@ -5515,32 +5705,32 @@ function groupResults(results, groupBy2) {
 function formatStatsTable(groups, filePath) {
   const lines = [];
   lines.push("");
-  lines.push(`${c2.bold}Statistics:${c2.reset} ${c2.cyan}${filePath}${c2.reset}`);
+  lines.push(`${c.bold}Statistics:${c.reset} ${c.cyan}${filePath}${c.reset}`);
   for (const group of groups) {
     if (groups.length > 1 || group.label !== "all") {
       lines.push("");
       lines.push(
-        `${c2.bold}Group: ${group.label}${c2.reset} ${c2.dim}(${group.results.length} tests)${c2.reset}`
+        `${c.bold}Group: ${group.label}${c.reset} ${c.dim}(${group.results.length} tests)${c.reset}`
       );
     } else {
-      lines.push(`${c2.dim}${group.results.length} tests${c2.reset}`);
+      lines.push(`${c.dim}${group.results.length} tests${c.reset}`);
     }
     lines.push("");
     const metrics = collectMetrics(group.results);
     if (metrics.length === 0) {
-      lines.push(`${c2.yellow}No trace metrics available${c2.reset}`);
+      lines.push(`${c.yellow}No trace metrics available${c.reset}`);
       continue;
     }
     const nameWidth = Math.max(12, ...metrics.map((m) => m.name.length));
     const colWidth = 10;
-    const header = `  ${padRight2("Metric", nameWidth)}  ${padLeft2("Mean", colWidth)}  ${padLeft2("P50", colWidth)}  ${padLeft2("P90", colWidth)}  ${padLeft2("P95", colWidth)}  ${padLeft2("P99", colWidth)}`;
-    lines.push(`${c2.dim}${header}${c2.reset}`);
+    const header = `  ${padRight("Metric", nameWidth)}  ${padLeft("Mean", colWidth)}  ${padLeft("P50", colWidth)}  ${padLeft("P90", colWidth)}  ${padLeft("P95", colWidth)}  ${padLeft("P99", colWidth)}`;
+    lines.push(`${c.dim}${header}${c.reset}`);
     lines.push(
-      `${c2.dim}  ${"\u2500".repeat(nameWidth)}  ${"\u2500".repeat(colWidth)}  ${"\u2500".repeat(colWidth)}  ${"\u2500".repeat(colWidth)}  ${"\u2500".repeat(colWidth)}  ${"\u2500".repeat(colWidth)}${c2.reset}`
+      `${c.dim}  ${"\u2500".repeat(nameWidth)}  ${"\u2500".repeat(colWidth)}  ${"\u2500".repeat(colWidth)}  ${"\u2500".repeat(colWidth)}  ${"\u2500".repeat(colWidth)}  ${"\u2500".repeat(colWidth)}${c.reset}`
     );
     for (const metric of metrics) {
       const sorted = [...metric.values].sort((a, b) => a - b);
-      const row = `  ${padRight2(metric.name, nameWidth)}  ${padLeft2(metric.formatter(mean(sorted)), colWidth)}  ${padLeft2(metric.formatter(percentile(sorted, 50)), colWidth)}  ${padLeft2(metric.formatter(percentile(sorted, 90)), colWidth)}  ${padLeft2(metric.formatter(percentile(sorted, 95)), colWidth)}  ${padLeft2(metric.formatter(percentile(sorted, 99)), colWidth)}`;
+      const row = `  ${padRight(metric.name, nameWidth)}  ${padLeft(metric.formatter(mean(sorted)), colWidth)}  ${padLeft(metric.formatter(percentile(sorted, 50)), colWidth)}  ${padLeft(metric.formatter(percentile(sorted, 90)), colWidth)}  ${padLeft(metric.formatter(percentile(sorted, 95)), colWidth)}  ${padLeft(metric.formatter(percentile(sorted, 99)), colWidth)}`;
       lines.push(row);
     }
   }
@@ -5620,15 +5810,17 @@ var inspectCommand = subcommands({
   name: "inspect",
   description: "Inspect and analyze evaluation results",
   cmds: {
+    filter: inspectFilterCommand,
     list: traceListCommand,
     score: traceScoreCommand,
+    search: inspectSearchCommand,
     show: traceShowCommand,
     stats: traceStatsCommand
   }
 });
 
 // src/commands/pipeline/bench.ts
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import { readFile as readFile2, readdir, writeFile as writeFile5 } from "node:fs/promises";
 import { join } from "node:path";
 var evalBenchCommand = command({
@@ -5739,7 +5931,7 @@ var evalBenchCommand = command({
       }));
       let executionStatus = "ok";
       const timingPath = join(testDir, "timing.json");
-      if (existsSync2(timingPath)) {
+      if (existsSync5(timingPath)) {
         try {
           const timing = JSON.parse(await readFile2(timingPath, "utf8"));
           if (typeof timing.execution_status === "string") {
@@ -5748,7 +5940,7 @@ var evalBenchCommand = command({
         } catch {
         }
       }
-      const hasResponse = existsSync2(join(testDir, "response.md"));
+      const hasResponse = existsSync5(join(testDir, "response.md"));
       indexLines.push(
         JSON.stringify({
           timestamp: manifest.timestamp,
@@ -5796,6 +5988,33 @@ var evalBenchCommand = command({
       "utf8"
     );
     console.log(`Benchmark: ${testIds.length} test(s), pass_rate=${passRateStats.mean}`);
+    const results = indexLines.map((line) => JSON.parse(line));
+    await maybeAutoExportRunArtifacts({
+      cwd: process.cwd(),
+      run_dir: exportDir,
+      experiment,
+      test_files: manifest.eval_file ? [manifest.eval_file] : [],
+      results: results.map((result) => ({
+        testId: result.test_id,
+        score: result.score,
+        executionStatus: result.execution_status,
+        target: result.target,
+        timestamp: result.timestamp
+      })),
+      eval_summaries: [
+        {
+          eval_file: manifest.eval_file ?? "pipeline",
+          total: results.length,
+          passed: results.filter((result) => result.score >= DEFAULT_THRESHOLD).length,
+          avg_score: results.length > 0 ? results.reduce((sum, result) => sum + result.score, 0) / results.length : 0,
+          results: results.map((result) => ({
+            test_id: result.test_id,
+            score: result.score,
+            status: result.execution_status === "execution_error" ? "ERROR" : result.score >= DEFAULT_THRESHOLD ? "PASS" : "FAIL"
+          }))
+        }
+      ]
+    });
   }
 });
 function computeStats(values) {
@@ -5987,7 +6206,7 @@ var evalInputCommand = command({
     out: option({
       type: optional(string),
       long: "out",
-      description: "Output directory for extracted inputs (default: .agentv/results/runs/<timestamp>)"
+      description: "Output directory for extracted inputs (default: .agentv/results/runs/<experiment>/<timestamp>)"
     }),
     experiment: option({
       type: optional(string),
@@ -5997,7 +6216,7 @@ var evalInputCommand = command({
   },
   handler: async ({ evalPath, out, experiment }) => {
     const resolvedEvalPath = resolve(evalPath);
-    const outDir = resolve(out ?? buildDefaultRunDir(process.cwd()));
+    const outDir = resolve(out ?? buildDefaultRunDir(process.cwd(), experiment));
     const repoRoot = await findRepoRoot(dirname(resolvedEvalPath));
     const evalDir = dirname(resolvedEvalPath);
     const category = deriveCategory(relative(process.cwd(), resolvedEvalPath));
@@ -6147,7 +6366,7 @@ async function writeJson(filePath, data) {
 
 // src/commands/pipeline/run.ts
 import { exec } from "node:child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync5, unlinkSync } from "node:fs";
+import { existsSync as existsSync6, 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";
@@ -6161,9 +6380,9 @@ function loadEnvFile(dir) {
   let current = resolve2(dir);
   while (true) {
     const candidate = join4(current, ".env");
-    if (existsSync3(candidate)) {
+    if (existsSync6(candidate)) {
       const env2 = {};
-      for (const line of readFileSync5(candidate, "utf8").split("\n")) {
+      for (const line of readFileSync6(candidate, "utf8").split("\n")) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("#")) continue;
         const eqIdx = trimmed.indexOf("=");
@@ -6190,7 +6409,7 @@ var evalRunCommand2 = command({
     out: option({
       type: optional(string),
       long: "out",
-      description: "Output directory for results (default: .agentv/results/runs/<timestamp>)"
+      description: "Output directory for results (default: .agentv/results/runs/<experiment>/<timestamp>)"
     }),
     workers: option({
       type: optional(number),
@@ -6210,7 +6429,7 @@ var evalRunCommand2 = command({
   },
   handler: async ({ evalPath, out, workers, experiment, graderType }) => {
     const resolvedEvalPath = resolve2(evalPath);
-    const outDir = resolve2(out ?? buildDefaultRunDir(process.cwd()));
+    const outDir = resolve2(out ?? buildDefaultRunDir(process.cwd(), experiment));
     const repoRoot = await findRepoRoot(dirname2(resolvedEvalPath));
     const evalDir = dirname2(resolvedEvalPath);
     const category = deriveCategory(relative2(process.cwd(), resolvedEvalPath));
@@ -6348,8 +6567,8 @@ var evalRunCommand2 = command({
           });
           const durationMs = Math.round(performance.now() - start);
           let response;
-          if (existsSync3(outputFile)) {
-            response = readFileSync5(outputFile, "utf8");
+          if (existsSync6(outputFile)) {
+            response = readFileSync6(outputFile, "utf8");
           } else {
             response = "ERROR: No output file generated";
           }
@@ -6381,8 +6600,8 @@ var evalRunCommand2 = command({
           invCompleted++;
           writeInvProgress();
           try {
-            if (existsSync3(promptFile)) unlinkSync(promptFile);
-            if (existsSync3(outputFile)) unlinkSync(outputFile);
+            if (existsSync6(promptFile)) unlinkSync(promptFile);
+            if (existsSync6(outputFile)) unlinkSync(outputFile);
           } catch {
           }
         }
@@ -6469,7 +6688,7 @@ async function writeGraderConfigs2(testDir, assertions, evalDir) {
       let promptContent = "";
       if (config.resolvedPromptPath) {
         try {
-          promptContent = readFileSync5(config.resolvedPromptPath, "utf8");
+          promptContent = readFileSync6(config.resolvedPromptPath, "utf8");
         } catch {
           promptContent = typeof config.prompt === "string" ? config.prompt : "";
         }
@@ -6500,10 +6719,10 @@ var pipelineCommand = subcommands({
 });
 
 // src/commands/results/export.ts
-import path10 from "node:path";
+import path12 from "node:path";
 
 // src/commands/results/shared.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 var sourceArg = positional({
   type: optional(string),
   displayName: "source",
@@ -6513,7 +6732,7 @@ async function resolveSourceFile(source, cwd) {
   let sourceFile;
   if (source) {
     sourceFile = resolveResultSourcePath(source, cwd);
-    if (!existsSync4(sourceFile)) {
+    if (!existsSync7(sourceFile)) {
       console.error(`Error: File not found: ${sourceFile}`);
       process.exit(1);
     }
@@ -6521,7 +6740,7 @@ async function resolveSourceFile(source, cwd) {
   } else {
     const cache = await loadRunCache(cwd);
     const cachedFile = cache ? resolveRunCacheFile(cache) : "";
-    if (cachedFile && existsSync4(cachedFile)) {
+    if (cachedFile && existsSync7(cachedFile)) {
       sourceFile = cachedFile;
     } else {
       const metas = listResultFiles(cwd, 1);
@@ -6547,14 +6766,20 @@ async function loadResults(source, cwd) {
 
 // src/commands/results/export.ts
 function deriveOutputDir(cwd, sourceFile) {
-  if (path10.basename(sourceFile) !== RESULT_INDEX_FILENAME) {
+  if (path12.basename(sourceFile) !== RESULT_INDEX_FILENAME) {
     throw new Error(`Expected a run manifest named ${RESULT_INDEX_FILENAME}: ${sourceFile}`);
   }
-  const parentDir = path10.basename(path10.dirname(sourceFile));
+  const runDir = path12.dirname(sourceFile);
+  const segments = path12.normalize(runDir).split(path12.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));
+  }
+  const parentDir = path12.basename(runDir);
   if (parentDir.startsWith("eval_")) {
-    return path10.join(cwd, ".agentv", "results", "export", parentDir.slice(5));
+    return path12.join(cwd, ".agentv", "results", "export", parentDir.slice(5));
   }
-  return path10.join(cwd, ".agentv", "results", "export", parentDir);
+  return path12.join(cwd, ".agentv", "results", "export", parentDir);
 }
 async function loadExportSource(source, cwd) {
   const { sourceFile } = await resolveSourceFile(source, cwd);
@@ -6587,7 +6812,7 @@ var resultsExportCommand = command({
     const cwd = dir ?? process.cwd();
     try {
       const { sourceFile, results } = await loadExportSource(source, cwd);
-      const outputDir = out ? path10.isAbsolute(out) ? out : path10.resolve(cwd, out) : deriveOutputDir(cwd, sourceFile);
+      const outputDir = out ? path12.isAbsolute(out) ? out : path12.resolve(cwd, out) : deriveOutputDir(cwd, sourceFile);
       await writeArtifactsFromResults(results, outputDir, {
         evalFile: sourceFile
       });
@@ -6728,7 +6953,7 @@ var resultsShowCommand = command({
 });
 
 // src/commands/results/summary.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
 function formatSummary(results, grading) {
   const total = results.length;
   let passed;
@@ -6779,9 +7004,9 @@ var resultsSummaryCommand = command({
       const { results, sourceFile } = await loadResults(source, cwd);
       let grading;
       const gradingPath = sourceFile.replace(/\.jsonl$/, ".grading.json");
-      if (existsSync5(gradingPath)) {
+      if (existsSync8(gradingPath)) {
         try {
-          grading = JSON.parse(readFileSync6(gradingPath, "utf8"));
+          grading = JSON.parse(readFileSync7(gradingPath, "utf8"));
         } catch {
         }
       }
@@ -6794,16 +7019,17 @@ var resultsSummaryCommand = command({
 });
 
 // src/commands/results/validate.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7, statSync as statSync3 } from "node:fs";
-import path11 from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync8, statSync as statSync4 } from "node:fs";
+import path13 from "node:path";
 function checkDirectoryNaming(runDir) {
-  const dirName = path11.basename(runDir);
-  const parentName = path11.basename(path11.dirname(runDir));
+  const dirName = path13.basename(runDir);
+  const pathSegments = path13.normalize(runDir).split(path13.sep).filter(Boolean);
+  const runsIndex = pathSegments.lastIndexOf("runs");
   const diagnostics = [];
-  if (parentName !== "runs") {
+  if (runsIndex < 0 || runsIndex >= pathSegments.length - 1) {
     diagnostics.push({
       severity: "warning",
-      message: `Directory is not under a 'runs/' parent (found '${parentName}/'). Expected: .agentv/results/runs/<run-dir>`
+      message: "Directory is not under a 'runs/' tree. Expected: .agentv/results/runs/<experiment>/<run-dir>"
     });
   }
   const isNewFormat = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z$/.test(dirName);
@@ -6816,15 +7042,25 @@ function checkDirectoryNaming(runDir) {
   }
   return diagnostics;
 }
+function validateRunDirectory(runDir) {
+  const diagnostics = [];
+  diagnostics.push(...checkDirectoryNaming(runDir));
+  const { diagnostics: indexDiags, entries: entries2 } = checkIndexJsonl(runDir);
+  diagnostics.push(...indexDiags);
+  if (entries2.length > 0) {
+    diagnostics.push(...checkArtifactFiles(runDir, entries2));
+  }
+  return { diagnostics, entries: entries2 };
+}
 function checkIndexJsonl(runDir) {
-  const indexPath = path11.join(runDir, "index.jsonl");
+  const indexPath = path13.join(runDir, "index.jsonl");
   const diagnostics = [];
   const entries2 = [];
-  if (!existsSync6(indexPath)) {
+  if (!existsSync9(indexPath)) {
     diagnostics.push({ severity: "error", message: "index.jsonl is missing" });
     return { diagnostics, entries: entries2 };
   }
-  const content = readFileSync7(indexPath, "utf8");
+  const content = readFileSync8(indexPath, "utf8");
   const lines = content.split("\n").filter((l) => l.trim().length > 0);
   if (lines.length === 0) {
     diagnostics.push({ severity: "error", message: "index.jsonl is empty" });
@@ -6916,15 +7152,15 @@ function checkArtifactFiles(runDir, entries2) {
   for (const entry of entries2) {
     const testId = entry.test_id ?? "?";
     if (entry.grading_path) {
-      const gradingPath = path11.join(runDir, entry.grading_path);
-      if (!existsSync6(gradingPath)) {
+      const gradingPath = path13.join(runDir, entry.grading_path);
+      if (!existsSync9(gradingPath)) {
         diagnostics.push({
           severity: "error",
           message: `${testId}: grading.json not found at '${entry.grading_path}'`
         });
       } else {
         try {
-          const grading = JSON.parse(readFileSync7(gradingPath, "utf8"));
+          const grading = JSON.parse(readFileSync8(gradingPath, "utf8"));
           if (!grading.assertions || !Array.isArray(grading.assertions)) {
             diagnostics.push({
               severity: "error",
@@ -6946,8 +7182,8 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
     if (entry.timing_path) {
-      const timingPath = path11.join(runDir, entry.timing_path);
-      if (!existsSync6(timingPath)) {
+      const timingPath = path13.join(runDir, entry.timing_path);
+      if (!existsSync9(timingPath)) {
         diagnostics.push({
           severity: "warning",
           message: `${testId}: timing.json not found at '${entry.timing_path}'`
@@ -6955,8 +7191,8 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
   }
-  const benchmarkPath = path11.join(runDir, "benchmark.json");
-  if (!existsSync6(benchmarkPath)) {
+  const benchmarkPath = path13.join(runDir, "benchmark.json");
+  if (!existsSync9(benchmarkPath)) {
     diagnostics.push({ severity: "warning", message: "benchmark.json is missing" });
   }
   return diagnostics;
@@ -6972,18 +7208,12 @@ var resultsValidateCommand = command({
     })
   },
   handler: async ({ runDir }) => {
-    const resolvedDir = path11.resolve(runDir);
-    if (!existsSync6(resolvedDir) || !statSync3(resolvedDir).isDirectory()) {
+    const resolvedDir = path13.resolve(runDir);
+    if (!existsSync9(resolvedDir) || !statSync4(resolvedDir).isDirectory()) {
       console.error(`Error: '${runDir}' is not a directory`);
       process.exit(1);
     }
-    const allDiagnostics = [];
-    allDiagnostics.push(...checkDirectoryNaming(resolvedDir));
-    const { diagnostics: indexDiags, entries: entries2 } = checkIndexJsonl(resolvedDir);
-    allDiagnostics.push(...indexDiags);
-    if (entries2.length > 0) {
-      allDiagnostics.push(...checkArtifactFiles(resolvedDir, entries2));
-    }
+    const { diagnostics: allDiagnostics, entries: entries2 } = validateRunDirectory(resolvedDir);
     const errors = allDiagnostics.filter((d) => d.severity === "error");
     const warnings = allDiagnostics.filter((d) => d.severity === "warning");
     if (allDiagnostics.length === 0) {
@@ -7020,15 +7250,15 @@ var resultsCommand = subcommands({
 });
 
 // src/commands/results/serve.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9, readdirSync as readdirSync3, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import path14 from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync10, readdirSync as readdirSync4, statSync as statSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import path16 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { Hono } from "hono";
 
 // src/commands/results/eval-runner.ts
 import { spawn } from "node:child_process";
-import { existsSync as existsSync7 } from "node:fs";
-import path12 from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import path14 from "node:path";
 var activeRuns = /* @__PURE__ */ new Map();
 function generateRunId() {
   const now = /* @__PURE__ */ new Date();
@@ -7049,16 +7279,16 @@ async function discoverTargetsInProject(cwd) {
   const repoRoot = await findRepoRoot(cwd) ?? cwd;
   let targetsFilePath;
   for (const candidate of TARGET_FILE_CANDIDATES) {
-    const fullPath = path12.join(cwd, candidate);
-    if (existsSync7(fullPath)) {
+    const fullPath = path14.join(cwd, candidate);
+    if (existsSync10(fullPath)) {
       targetsFilePath = fullPath;
       break;
     }
   }
   if (!targetsFilePath) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const fullPath = path12.join(repoRoot, candidate);
-      if (existsSync7(fullPath)) {
+      const fullPath = path14.join(repoRoot, candidate);
+      if (existsSync10(fullPath)) {
         targetsFilePath = fullPath;
         break;
       }
@@ -7107,22 +7337,23 @@ function buildCliPreview(args) {
 }
 function resolveCliPath(cwd) {
   const candidates = [
-    path12.join(cwd, "apps/cli/src/cli.ts"),
-    path12.join(cwd, "apps/cli/dist/cli.js")
+    path14.join(cwd, "apps/cli/src/cli.ts"),
+    path14.join(cwd, "apps/cli/dist/cli.js")
   ];
   for (const c4 of candidates) {
-    if (existsSync7(c4)) {
+    if (existsSync10(c4)) {
       return { bunPath: "bun", cliPath: c4 };
     }
   }
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path12.dirname(new URL(import.meta.url).pathname);
-  const fromSrc = path12.resolve(currentDir, "../../../cli.ts");
-  const fromDist = path12.resolve(currentDir, "../../cli.js");
-  if (existsSync7(fromSrc)) return { bunPath: "bun", cliPath: fromSrc };
-  if (existsSync7(fromDist)) return { bunPath: "bun", cliPath: fromDist };
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path14.dirname(new URL(import.meta.url).pathname);
+  const fromSrc = path14.resolve(currentDir, "../../../cli.ts");
+  const fromDist = path14.resolve(currentDir, "../../cli.js");
+  if (existsSync10(fromSrc)) return { bunPath: "bun", cliPath: fromSrc };
+  if (existsSync10(fromDist)) return { bunPath: "bun", cliPath: fromDist };
   return void 0;
 }
-function registerEvalRoutes(app2, getCwd) {
+function registerEvalRoutes(app2, getCwd, options) {
+  const readOnly = options?.readOnly === true;
   app2.get("/api/eval/discover", async (c4) => {
     const cwd = getCwd(c4);
     try {
@@ -7148,6 +7379,9 @@ function registerEvalRoutes(app2, getCwd) {
     }
   });
   app2.post("/api/eval/run", async (c4) => {
+    if (readOnly) {
+      return c4.json({ error: "Studio is running in read-only mode" }, 403);
+    }
     const cwd = getCwd(c4);
     let body;
     try {
@@ -7389,18 +7623,18 @@ Process error: ${err2.message}`;
 }
 
 // src/commands/results/studio-config.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "node:fs";
-import path13 from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync2, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "node:fs";
+import path15 from "node:path";
 import { parse as parseYaml, stringify as stringifyYaml2 } from "yaml";
 var DEFAULTS = {
   threshold: DEFAULT_THRESHOLD
 };
 function loadStudioConfig(agentvDir) {
-  const configPath = path13.join(agentvDir, "config.yaml");
-  if (!existsSync8(configPath)) {
+  const configPath = path15.join(agentvDir, "config.yaml");
+  if (!existsSync11(configPath)) {
     return { ...DEFAULTS };
   }
-  const raw = readFileSync8(configPath, "utf-8");
+  const raw = readFileSync9(configPath, "utf-8");
   const parsed = parseYaml(raw);
   if (!parsed || typeof parsed !== "object") {
     return { ...DEFAULTS };
@@ -7422,13 +7656,13 @@ function loadStudioConfig(agentvDir) {
   };
 }
 function saveStudioConfig(agentvDir, config) {
-  if (!existsSync8(agentvDir)) {
+  if (!existsSync11(agentvDir)) {
     mkdirSync2(agentvDir, { recursive: true });
   }
-  const configPath = path13.join(agentvDir, "config.yaml");
+  const configPath = path15.join(agentvDir, "config.yaml");
   let existing = {};
-  if (existsSync8(configPath)) {
-    const raw = readFileSync8(configPath, "utf-8");
+  if (existsSync11(configPath)) {
+    const raw = readFileSync9(configPath, "utf-8");
     const parsed = parseYaml(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       existing = parsed;
@@ -7451,7 +7685,7 @@ function saveStudioConfig(agentvDir, config) {
 async function resolveSourceFile2(source, cwd) {
   if (source) {
     let resolved = resolveResultSourcePath(source, cwd);
-    if (!existsSync9(resolved)) {
+    if (!existsSync12(resolved)) {
       throw new Error(`Source file not found: ${resolved}`);
     }
     resolved = resolveRunManifestPath(resolved);
@@ -7459,7 +7693,7 @@ async function resolveSourceFile2(source, cwd) {
   }
   const cache = await loadRunCache(cwd);
   const cachedFile = cache ? resolveRunCacheFile(cache) : "";
-  if (cachedFile && existsSync9(cachedFile)) {
+  if (cachedFile && existsSync12(cachedFile)) {
     return cachedFile;
   }
   const metas = listResultFiles(cwd, 10);
@@ -7479,16 +7713,25 @@ Serving most recent: ${metas[0].path}
   }
   return metas[0].path;
 }
+function resolveDashboardMode(projectCount, options) {
+  if (options.single === true) {
+    return { isMultiProject: false, showMultiWarning: options.multi === true };
+  }
+  if (options.multi === true) {
+    return { isMultiProject: true, showMultiWarning: true };
+  }
+  return { isMultiProject: projectCount > 1, showMultiWarning: false };
+}
 function feedbackPath(resultDir) {
-  return path14.join(resultDir, "feedback.json");
+  return path16.join(resultDir, "feedback.json");
 }
 function readFeedback(cwd) {
   const fp = feedbackPath(cwd);
-  if (!existsSync9(fp)) {
+  if (!existsSync12(fp)) {
     return { reviews: [] };
   }
   try {
-    return JSON.parse(readFileSync9(fp, "utf8"));
+    return JSON.parse(readFileSync10(fp, "utf8"));
   } catch (err2) {
     console.error(`Warning: could not parse ${fp}, starting fresh: ${err2.message}`);
     return { reviews: [] };
@@ -7499,16 +7742,16 @@ function writeFeedback(cwd, data) {
 `, "utf8");
 }
 function buildFileTree(dirPath, relativeTo) {
-  if (!existsSync9(dirPath) || !statSync4(dirPath).isDirectory()) {
+  if (!existsSync12(dirPath) || !statSync5(dirPath).isDirectory()) {
     return [];
   }
-  const entries2 = readdirSync3(dirPath, { withFileTypes: true });
+  const entries2 = readdirSync4(dirPath, { withFileTypes: true });
   return entries2.sort((a, b) => {
     if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
     return a.name.localeCompare(b.name);
   }).map((entry) => {
-    const fullPath = path14.join(dirPath, entry.name);
-    const relPath = path14.relative(relativeTo, fullPath);
+    const fullPath = path16.join(dirPath, entry.name);
+    const relPath = path16.relative(relativeTo, fullPath);
     if (entry.isDirectory()) {
       return {
         name: entry.name,
@@ -7521,7 +7764,7 @@ function buildFileTree(dirPath, relativeTo) {
   });
 }
 function inferLanguage(filePath) {
-  const ext = path14.extname(filePath).toLowerCase();
+  const ext = path16.extname(filePath).toLowerCase();
   const langMap = {
     ".json": "json",
     ".jsonl": "json",
@@ -7559,8 +7802,8 @@ function stripHeavyFields(results) {
     };
   });
 }
-function handleRuns(c4, { searchDir }) {
-  const metas = listResultFiles(searchDir);
+async function handleRuns(c4, { searchDir }) {
+  const { runs: metas } = await listMergedResultFiles(searchDir);
   return c4.json({
     runs: metas.map((m) => {
       let target;
@@ -7575,32 +7818,38 @@ function handleRuns(c4, { searchDir }) {
       }
       return {
         filename: m.filename,
+        display_name: m.displayName,
         path: m.path,
         timestamp: m.timestamp,
         test_count: m.testCount,
         pass_rate: m.passRate,
         avg_score: m.avgScore,
         size_bytes: m.sizeBytes,
+        source: m.source,
         ...target && { target },
         ...experiment && { experiment }
       };
     })
   });
 }
-function handleRunDetail(c4, { searchDir }) {
-  const filename = c4.req.param("filename");
-  const meta = listResultFiles(searchDir).find((m) => m.filename === filename);
+async function handleRunDetail(c4, { searchDir }) {
+  const filename = c4.req.param("filename") ?? "";
+  const meta = await findRunById(searchDir, filename);
   if (!meta) return c4.json({ error: "Run not found" }, 404);
   try {
     const loaded = loadManifestResults(meta.path);
-    return c4.json({ results: stripHeavyFields(loaded), source: meta.filename });
+    return c4.json({
+      results: stripHeavyFields(loaded),
+      source: meta.source,
+      source_label: meta.displayName
+    });
   } catch {
     return c4.json({ error: "Failed to load run" }, 500);
   }
 }
-function handleRunSuites(c4, { searchDir, agentvDir }) {
-  const filename = c4.req.param("filename");
-  const meta = listResultFiles(searchDir).find((m) => m.filename === filename);
+async function handleRunSuites(c4, { searchDir, agentvDir }) {
+  const filename = c4.req.param("filename") ?? "";
+  const meta = await findRunById(searchDir, filename);
   if (!meta) return c4.json({ error: "Run not found" }, 404);
   try {
     const loaded = loadManifestResults(meta.path);
@@ -7626,9 +7875,9 @@ function handleRunSuites(c4, { searchDir, agentvDir }) {
     return c4.json({ error: "Failed to load suites" }, 500);
   }
 }
-function handleRunCategories(c4, { searchDir, agentvDir }) {
-  const filename = c4.req.param("filename");
-  const meta = listResultFiles(searchDir).find((m) => m.filename === filename);
+async function handleRunCategories(c4, { searchDir, agentvDir }) {
+  const filename = c4.req.param("filename") ?? "";
+  const meta = await findRunById(searchDir, filename);
   if (!meta) return c4.json({ error: "Run not found" }, 404);
   try {
     const loaded = loadManifestResults(meta.path);
@@ -7661,10 +7910,10 @@ function handleRunCategories(c4, { searchDir, agentvDir }) {
     return c4.json({ error: "Failed to load categories" }, 500);
   }
 }
-function handleCategorySuites(c4, { searchDir, agentvDir }) {
-  const filename = c4.req.param("filename");
+async function handleCategorySuites(c4, { searchDir, agentvDir }) {
+  const filename = c4.req.param("filename") ?? "";
   const category = decodeURIComponent(c4.req.param("category") ?? "");
-  const meta = listResultFiles(searchDir).find((m) => m.filename === filename);
+  const meta = await findRunById(searchDir, filename);
   if (!meta) return c4.json({ error: "Run not found" }, 404);
   try {
     const loaded = loadManifestResults(meta.path);
@@ -7691,10 +7940,10 @@ function handleCategorySuites(c4, { searchDir, agentvDir }) {
     return c4.json({ error: "Failed to load suites" }, 500);
   }
 }
-function handleEvalDetail(c4, { searchDir }) {
-  const filename = c4.req.param("filename");
+async function handleEvalDetail(c4, { searchDir }) {
+  const filename = c4.req.param("filename") ?? "";
   const evalId = c4.req.param("evalId");
-  const meta = listResultFiles(searchDir).find((m) => m.filename === filename);
+  const meta = await findRunById(searchDir, filename);
   if (!meta) return c4.json({ error: "Run not found" }, 404);
   try {
     const loaded = loadManifestResults(meta.path);
@@ -7705,17 +7954,17 @@ function handleEvalDetail(c4, { searchDir }) {
     return c4.json({ error: "Failed to load eval" }, 500);
   }
 }
-function handleEvalFiles(c4, { searchDir }) {
-  const filename = c4.req.param("filename");
+async function handleEvalFiles(c4, { searchDir }) {
+  const filename = c4.req.param("filename") ?? "";
   const evalId = c4.req.param("evalId");
-  const meta = listResultFiles(searchDir).find((m) => m.filename === filename);
+  const meta = await findRunById(searchDir, filename);
   if (!meta) return c4.json({ error: "Run not found" }, 404);
   try {
-    const content = readFileSync9(meta.path, "utf8");
+    const content = readFileSync10(meta.path, "utf8");
     const records = parseResultManifest(content);
     const record = records.find((r) => r.test_id === evalId);
     if (!record) return c4.json({ error: "Eval not found" }, 404);
-    const baseDir = path14.dirname(meta.path);
+    const baseDir = path16.dirname(meta.path);
     const knownPaths = [
       record.grading_path,
       record.timing_path,
@@ -7724,47 +7973,46 @@ function handleEvalFiles(c4, { searchDir }) {
       record.response_path
     ].filter((p) => !!p);
     if (knownPaths.length === 0) return c4.json({ files: [] });
-    const artifactDirs = knownPaths.map((p) => path14.dirname(p));
+    const artifactDirs = knownPaths.map((p) => path16.dirname(p));
     let commonDir = artifactDirs[0];
     for (const dir of artifactDirs) {
       while (!dir.startsWith(commonDir)) {
-        commonDir = path14.dirname(commonDir);
+        commonDir = path16.dirname(commonDir);
       }
     }
-    const artifactAbsDir = path14.join(baseDir, commonDir);
+    const artifactAbsDir = path16.join(baseDir, commonDir);
     const files = buildFileTree(artifactAbsDir, baseDir);
     return c4.json({ files });
   } catch {
     return c4.json({ error: "Failed to load file tree" }, 500);
   }
 }
-function handleEvalFileContent(c4, { searchDir }) {
-  const filename = c4.req.param("filename");
-  const evalId = c4.req.param("evalId");
-  const meta = listResultFiles(searchDir).find((m) => m.filename === filename);
+async function handleEvalFileContent(c4, { searchDir }) {
+  const filename = c4.req.param("filename") ?? "";
+  const meta = await findRunById(searchDir, filename);
   if (!meta) return c4.json({ error: "Run not found" }, 404);
-  const marker = `/runs/${filename}/evals/${evalId}/files/`;
+  const marker = "/files/";
   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 = path14.dirname(meta.path);
-  const absolutePath = path14.resolve(baseDir, filePath);
-  if (!absolutePath.startsWith(path14.resolve(baseDir) + path14.sep) && absolutePath !== path14.resolve(baseDir)) {
+  const baseDir = path16.dirname(meta.path);
+  const absolutePath = path16.resolve(baseDir, filePath);
+  if (!absolutePath.startsWith(path16.resolve(baseDir) + path16.sep) && absolutePath !== path16.resolve(baseDir)) {
     return c4.json({ error: "Path traversal not allowed" }, 403);
   }
-  if (!existsSync9(absolutePath) || !statSync4(absolutePath).isFile()) {
+  if (!existsSync12(absolutePath) || !statSync5(absolutePath).isFile()) {
     return c4.json({ error: "File not found" }, 404);
   }
   try {
-    const fileContent = readFileSync9(absolutePath, "utf8");
+    const fileContent = readFileSync10(absolutePath, "utf8");
     const language = inferLanguage(absolutePath);
     return c4.json({ content: fileContent, language });
   } catch {
     return c4.json({ error: "Failed to read file" }, 500);
   }
 }
-function handleExperiments(c4, { searchDir, agentvDir }) {
-  const metas = listResultFiles(searchDir);
+async function handleExperiments(c4, { searchDir, agentvDir }) {
+  const { runs: metas } = await listMergedResultFiles(searchDir);
   const { threshold: pass_threshold } = loadStudioConfig(agentvDir);
   const experimentMap = /* @__PURE__ */ new Map();
   for (const m of metas) {
@@ -7802,8 +8050,70 @@ function handleExperiments(c4, { searchDir, agentvDir }) {
   }));
   return c4.json({ experiments });
 }
-function handleTargets(c4, { searchDir, agentvDir }) {
-  const metas = listResultFiles(searchDir);
+async function handleCompare(c4, { searchDir, agentvDir }) {
+  const { runs: metas } = await listMergedResultFiles(searchDir);
+  const { threshold: pass_threshold } = loadStudioConfig(agentvDir);
+  const cellMap = /* @__PURE__ */ new Map();
+  const experimentsSet = /* @__PURE__ */ new Set();
+  const targetsSet = /* @__PURE__ */ new Set();
+  for (const m of metas) {
+    try {
+      const records = loadLightweightResults(m.path);
+      for (const r of records) {
+        const experiment = r.experiment ?? "default";
+        const target = r.target ?? "default";
+        experimentsSet.add(experiment);
+        targetsSet.add(target);
+        const key = JSON.stringify([experiment, target]);
+        const entry = cellMap.get(key) ?? {
+          experiment,
+          target,
+          evalCount: 0,
+          passedCount: 0,
+          scoreSum: 0,
+          tests: []
+        };
+        const passed = r.score >= pass_threshold;
+        entry.evalCount++;
+        if (passed) entry.passedCount++;
+        entry.scoreSum += r.score;
+        entry.tests.push({
+          test_id: r.testId,
+          score: r.score,
+          passed,
+          execution_status: r.executionStatus
+        });
+        cellMap.set(key, entry);
+      }
+    } catch {
+    }
+  }
+  const MAX_TESTS_PER_CELL = 100;
+  const cells = [...cellMap.values()].map((entry) => {
+    const dedupMap = /* @__PURE__ */ new Map();
+    for (const t of entry.tests) {
+      dedupMap.set(t.test_id, t);
+    }
+    const dedupedTests = [...dedupMap.values()];
+    const cappedTests = dedupedTests.slice(-MAX_TESTS_PER_CELL);
+    return {
+      experiment: entry.experiment,
+      target: entry.target,
+      eval_count: entry.evalCount,
+      passed_count: entry.passedCount,
+      pass_rate: entry.evalCount > 0 ? entry.passedCount / entry.evalCount : 0,
+      avg_score: entry.evalCount > 0 ? entry.scoreSum / entry.evalCount : 0,
+      tests: cappedTests
+    };
+  });
+  return c4.json({
+    experiments: [...experimentsSet].sort(),
+    targets: [...targetsSet].sort(),
+    cells
+  });
+}
+async function handleTargets(c4, { searchDir, agentvDir }) {
+  const { runs: metas } = await listMergedResultFiles(searchDir);
   const { threshold: pass_threshold } = loadStudioConfig(agentvDir);
   const targetMap = /* @__PURE__ */ new Map();
   for (const m of metas) {
@@ -7836,29 +8146,38 @@ function handleTargets(c4, { searchDir, agentvDir }) {
   }));
   return c4.json({ targets });
 }
-function handleConfig(c4, { agentvDir }) {
-  return c4.json(loadStudioConfig(agentvDir));
+function handleConfig(c4, { agentvDir, searchDir }, options) {
+  return c4.json({
+    ...loadStudioConfig(agentvDir),
+    read_only: options?.readOnly === true,
+    project_name: path16.basename(searchDir),
+    multi_project_dashboard: options?.multiProjectDashboard === true
+  });
 }
 function handleFeedbackRead(c4, { searchDir }) {
-  const resultsDir = path14.join(searchDir, ".agentv", "results");
-  return c4.json(readFeedback(existsSync9(resultsDir) ? resultsDir : searchDir));
+  const resultsDir = path16.join(searchDir, ".agentv", "results");
+  return c4.json(readFeedback(existsSync12(resultsDir) ? resultsDir : searchDir));
 }
 function createApp(results, resultDir, cwd, sourceFile, options) {
   const searchDir = cwd ?? resultDir;
-  const agentvDir = path14.join(searchDir, ".agentv");
+  const agentvDir = path16.join(searchDir, ".agentv");
   const defaultCtx = { searchDir, agentvDir };
+  const readOnly = options?.readOnly === true;
   const app2 = new Hono();
   function withProject(c4, handler) {
     const project = getProject(c4.req.param("projectId") ?? "");
-    if (!project || !existsSync9(project.path)) {
+    if (!project || !existsSync12(project.path)) {
       return c4.json({ error: "Project not found" }, 404);
     }
     return handler(c4, {
       searchDir: project.path,
-      agentvDir: path14.join(project.path, ".agentv")
+      agentvDir: path16.join(project.path, ".agentv")
     });
   }
   app2.post("/api/config", async (c4) => {
+    if (readOnly) {
+      return c4.json({ error: "Studio is running in read-only mode" }, 403);
+    }
     try {
       const body = await c4.req.json();
       const current = loadStudioConfig(agentvDir);
@@ -7881,32 +8200,37 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
       last_opened_at: entry.lastOpenedAt
     };
   }
-  app2.get("/api/projects", (c4) => {
+  app2.get("/api/projects", async (c4) => {
     const registry = loadProjectRegistry();
-    const projects = registry.projects.map((p) => {
-      let runCount = 0;
-      let passRate = 0;
-      let lastRun = null;
-      try {
-        const metas = listResultFiles(p.path);
-        runCount = metas.length;
-        if (metas.length > 0) {
-          const totalPassRate = metas.reduce((sum, m) => sum + m.passRate, 0);
-          passRate = totalPassRate / metas.length;
-          lastRun = metas[0].timestamp;
+    const projects = await Promise.all(
+      registry.projects.map(async (p) => {
+        let runCount = 0;
+        let passRate = 0;
+        let lastRun = null;
+        try {
+          const { runs: metas } = await listMergedResultFiles(p.path);
+          runCount = metas.length;
+          if (metas.length > 0) {
+            const totalPassRate = metas.reduce((sum, m) => sum + m.passRate, 0);
+            passRate = totalPassRate / metas.length;
+            lastRun = metas[0].timestamp;
+          }
+        } catch {
         }
-      } catch {
-      }
-      return {
-        ...projectEntryToWire(p),
-        run_count: runCount,
-        pass_rate: passRate,
-        last_run: lastRun
-      };
-    });
+        return {
+          ...projectEntryToWire(p),
+          run_count: runCount,
+          pass_rate: passRate,
+          last_run: lastRun
+        };
+      })
+    );
     return c4.json({ projects });
   });
   app2.post("/api/projects", async (c4) => {
+    if (readOnly) {
+      return c4.json({ error: "Studio is running in read-only mode" }, 403);
+    }
     try {
       const body = await c4.req.json();
       if (!body.path) return c4.json({ error: "Missing path" }, 400);
@@ -7917,15 +8241,18 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     }
   });
   app2.delete("/api/projects/:projectId", (c4) => {
+    if (readOnly) {
+      return c4.json({ error: "Studio is running in read-only mode" }, 403);
+    }
     const removed = removeProject(c4.req.param("projectId") ?? "");
     if (!removed) return c4.json({ error: "Project not found" }, 404);
     return c4.json({ ok: true });
   });
-  app2.get("/api/projects/:projectId/summary", (c4) => {
+  app2.get("/api/projects/:projectId/summary", async (c4) => {
     const project = getProject(c4.req.param("projectId") ?? "");
     if (!project) return c4.json({ error: "Project not found" }, 404);
     try {
-      const metas = listResultFiles(project.path);
+      const { runs: metas } = await listMergedResultFiles(project.path);
       const runCount = metas.length;
       const passRate = runCount > 0 ? metas.reduce((s, m) => s + m.passRate, 0) / runCount : 0;
       const lastRun = metas.length > 0 ? metas[0].timestamp : null;
@@ -7942,6 +8269,9 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     }
   });
   app2.post("/api/projects/discover", async (c4) => {
+    if (readOnly) {
+      return c4.json({ error: "Studio is running in read-only mode" }, 403);
+    }
     try {
       const body = await c4.req.json();
       if (!body.path) return c4.json({ error: "Missing path" }, 400);
@@ -7952,12 +8282,12 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
       return c4.json({ error: err2.message }, 400);
     }
   });
-  app2.get("/api/projects/all-runs", (c4) => {
+  app2.get("/api/projects/all-runs", async (c4) => {
     const registry = loadProjectRegistry();
     const allRuns = [];
     for (const p of registry.projects) {
       try {
-        const metas = listResultFiles(p.path);
+        const { runs: metas } = await listMergedResultFiles(p.path);
         for (const m of metas) {
           let target;
           let experiment;
@@ -7971,12 +8301,14 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
           }
           allRuns.push({
             filename: m.filename,
+            display_name: m.displayName,
             path: m.path,
             timestamp: m.timestamp,
             test_count: m.testCount,
             pass_rate: m.passRate,
             avg_score: m.avgScore,
             size_bytes: m.sizeBytes,
+            source: m.source,
             ...target && { target },
             ...experiment && { experiment },
             project_id: p.id,
@@ -7989,7 +8321,15 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     allRuns.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
     return c4.json({ runs: allRuns });
   });
-  app2.get("/api/config", (c4) => handleConfig(c4, defaultCtx));
+  app2.get(
+    "/api/config",
+    (c4) => handleConfig(c4, defaultCtx, {
+      readOnly,
+      multiProjectDashboard: options?.multiProjectDashboard
+    })
+  );
+  app2.get("/api/remote/status", async (c4) => c4.json(await getRemoteResultsStatus(searchDir)));
+  app2.post("/api/remote/sync", async (c4) => c4.json(await syncRemoteResults(searchDir)));
   app2.get("/api/runs", (c4) => handleRuns(c4, defaultCtx));
   app2.get("/api/runs/:filename", (c4) => handleRunDetail(c4, defaultCtx));
   app2.get("/api/runs/:filename/suites", (c4) => handleRunSuites(c4, defaultCtx));
@@ -8002,12 +8342,16 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
   app2.get("/api/runs/:filename/evals/:evalId/files", (c4) => handleEvalFiles(c4, defaultCtx));
   app2.get("/api/runs/:filename/evals/:evalId/files/*", (c4) => handleEvalFileContent(c4, defaultCtx));
   app2.get("/api/experiments", (c4) => handleExperiments(c4, defaultCtx));
+  app2.get("/api/compare", (c4) => handleCompare(c4, defaultCtx));
   app2.get("/api/targets", (c4) => handleTargets(c4, defaultCtx));
   app2.get("/api/feedback", (c4) => {
     const data = readFeedback(resultDir);
     return c4.json(data);
   });
   app2.post("/api/feedback", async (c4) => {
+    if (readOnly) {
+      return c4.json({ error: "Studio is running in read-only mode" }, 403);
+    }
     let body;
     try {
       body = await c4.req.json();
@@ -8045,8 +8389,8 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     writeFeedback(resultDir, existing);
     return c4.json(existing);
   });
-  app2.get("/api/index", (c4) => {
-    const metas = listResultFiles(searchDir);
+  app2.get("/api/index", async (c4) => {
+    const { runs: metas } = await listMergedResultFiles(searchDir);
     const entries2 = metas.map((m) => {
       let totalCostUsd = 0;
       try {
@@ -8056,6 +8400,7 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
       }
       return {
         run_filename: m.filename,
+        display_name: m.displayName,
         test_count: m.testCount,
         pass_rate: m.passRate,
         avg_score: m.avgScore,
@@ -8065,7 +8410,27 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     });
     return c4.json({ entries: entries2 });
   });
-  app2.get("/api/projects/:projectId/config", (c4) => withProject(c4, handleConfig));
+  app2.get(
+    "/api/projects/:projectId/config",
+    (c4) => withProject(
+      c4,
+      (ctx, dataCtx) => handleConfig(ctx, dataCtx, {
+        readOnly,
+        multiProjectDashboard: options?.multiProjectDashboard
+      })
+    )
+  );
+  app2.get(
+    "/api/projects/:projectId/remote/status",
+    (c4) => withProject(
+      c4,
+      async (ctx, dataCtx) => ctx.json(await getRemoteResultsStatus(dataCtx.searchDir))
+    )
+  );
+  app2.post(
+    "/api/projects/:projectId/remote/sync",
+    (c4) => withProject(c4, async (ctx, dataCtx) => ctx.json(await syncRemoteResults(dataCtx.searchDir)))
+  );
   app2.get("/api/projects/:projectId/runs", (c4) => withProject(c4, handleRuns));
   app2.get("/api/projects/:projectId/runs/:filename", (c4) => withProject(c4, handleRunDetail));
   app2.get("/api/projects/:projectId/runs/:filename/suites", (c4) => withProject(c4, handleRunSuites));
@@ -8090,31 +8455,36 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     (c4) => withProject(c4, handleEvalFileContent)
   );
   app2.get("/api/projects/:projectId/experiments", (c4) => withProject(c4, handleExperiments));
+  app2.get("/api/projects/:projectId/compare", (c4) => withProject(c4, handleCompare));
   app2.get("/api/projects/:projectId/targets", (c4) => withProject(c4, handleTargets));
   app2.get("/api/projects/:projectId/feedback", (c4) => withProject(c4, handleFeedbackRead));
-  registerEvalRoutes(app2, (c4) => {
-    const projectId = c4.req.param("projectId");
-    if (projectId) {
-      const project = getProject(projectId);
-      if (project) return project.path;
-    }
-    return searchDir;
-  });
+  registerEvalRoutes(
+    app2,
+    (c4) => {
+      const projectId = c4.req.param("projectId");
+      if (projectId) {
+        const project = getProject(projectId);
+        if (project) return project.path;
+      }
+      return searchDir;
+    },
+    { readOnly }
+  );
   const studioDistPath = options?.studioDir ?? resolveStudioDistDir();
-  if (!studioDistPath || !existsSync9(path14.join(studioDistPath, "index.html"))) {
+  if (!studioDistPath || !existsSync12(path16.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 = path14.join(studioDistPath, "index.html");
-    if (existsSync9(indexPath)) return c4.html(readFileSync9(indexPath, "utf8"));
+    const indexPath = path16.join(studioDistPath, "index.html");
+    if (existsSync12(indexPath)) return c4.html(readFileSync10(indexPath, "utf8"));
     return c4.notFound();
   });
   app2.get("/assets/*", (c4) => {
     const assetPath = c4.req.path;
-    const filePath = path14.join(studioDistPath, assetPath);
-    if (!existsSync9(filePath)) return c4.notFound();
-    const content = readFileSync9(filePath);
-    const ext = path14.extname(filePath);
+    const filePath = path16.join(studioDistPath, assetPath);
+    if (!existsSync12(filePath)) return c4.notFound();
+    const content = readFileSync10(filePath);
+    const ext = path16.extname(filePath);
     const mimeTypes = {
       ".js": "application/javascript",
       ".css": "text/css",
@@ -8135,26 +8505,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 = path14.join(studioDistPath, "index.html");
-    if (existsSync9(indexPath)) return c4.html(readFileSync9(indexPath, "utf8"));
+    const indexPath = path16.join(studioDistPath, "index.html");
+    if (existsSync12(indexPath)) return c4.html(readFileSync10(indexPath, "utf8"));
     return c4.notFound();
   });
   return app2;
 }
 function resolveStudioDistDir() {
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path14.dirname(fileURLToPath2(import.meta.url));
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path16.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
     // From src/commands/results/ → sibling apps/studio/dist
-    path14.resolve(currentDir, "../../../../studio/dist"),
+    path16.resolve(currentDir, "../../../../studio/dist"),
     // From dist/ → sibling apps/studio/dist (monorepo dev)
-    path14.resolve(currentDir, "../../studio/dist"),
+    path16.resolve(currentDir, "../../studio/dist"),
     // Bundled inside CLI dist (published package: dist/studio/)
-    path14.resolve(currentDir, "studio"),
+    path16.resolve(currentDir, "studio"),
     // From dist/ in monorepo root context
-    path14.resolve(currentDir, "../../../apps/studio/dist")
+    path16.resolve(currentDir, "../../../apps/studio/dist")
   ];
   for (const candidate of candidates) {
-    if (existsSync9(candidate) && existsSync9(path14.join(candidate, "index.html"))) {
+    if (existsSync12(candidate) && existsSync12(path16.join(candidate, "index.html"))) {
       return candidate;
     }
   }
@@ -8183,7 +8553,11 @@ var resultsServeCommand = command({
     }),
     multi: flag({
       long: "multi",
-      description: "Launch in multi-project dashboard mode"
+      description: "Launch in multi-project dashboard mode (deprecated; use auto-detect or --single)"
+    }),
+    single: flag({
+      long: "single",
+      description: "Force single-project dashboard mode"
     }),
     add: option({
       type: optional(string),
@@ -8199,9 +8573,13 @@ var resultsServeCommand = command({
       type: optional(string),
       long: "discover",
       description: "Scan a directory tree for repos with .agentv/"
+    }),
+    readOnly: flag({
+      long: "read-only",
+      description: "Disable write operations and launch Studio in read-only leaderboard mode"
     })
   },
-  handler: async ({ source, port, dir, multi, add, remove, discover }) => {
+  handler: async ({ source, port, dir, multi, single, add, remove, discover, readOnly }) => {
     const cwd = dir ?? process.cwd();
     const listenPort = port ?? (process.env.PORT ? Number(process.env.PORT) : 3117);
     if (add) {
@@ -8239,7 +8617,10 @@ Discovered ${discovered.length} project(s).`);
       return;
     }
     const registry = loadProjectRegistry();
-    const isMultiProject = multi || registry.projects.length > 0;
+    const { isMultiProject, showMultiWarning } = resolveDashboardMode(registry.projects.length, {
+      multi,
+      single
+    });
     try {
       let results = [];
       let sourceFile;
@@ -8249,7 +8630,7 @@ Discovered ${discovered.length} project(s).`);
       } else {
         const cache = await loadRunCache(cwd);
         const cachedFile = cache ? resolveRunCacheFile(cache) : "";
-        if (cachedFile && existsSync9(cachedFile)) {
+        if (cachedFile && existsSync12(cachedFile)) {
           sourceFile = cachedFile;
           results = loadManifestResults(cachedFile);
         } else {
@@ -8260,8 +8641,16 @@ Discovered ${discovered.length} project(s).`);
           }
         }
       }
-      const resultDir = sourceFile ? path14.dirname(path14.resolve(sourceFile)) : cwd;
-      const app2 = createApp(results, resultDir, cwd, sourceFile);
+      const resultDir = sourceFile ? path16.dirname(path16.resolve(sourceFile)) : cwd;
+      const app2 = createApp(results, resultDir, cwd, sourceFile, {
+        readOnly,
+        multiProjectDashboard: isMultiProject
+      });
+      if (showMultiWarning) {
+        console.warn(
+          "Warning: --multi is deprecated. Studio now auto-detects multi-project mode when multiple projects are registered. Use --single to force the single-project view."
+        );
+      }
       if (isMultiProject) {
         console.log(`Multi-project mode: ${registry.projects.length} project(s) registered`);
       } else if (results.length > 0 && sourceFile) {
@@ -8377,7 +8766,7 @@ var selfCommand = subcommands({
 
 // src/commands/transpile/index.ts
 import { writeFileSync as writeFileSync5 } from "node:fs";
-import path15 from "node:path";
+import path17 from "node:path";
 var transpileCommand = command({
   name: "transpile",
   description: "Convert an EVAL.yaml file to Agent Skills evals.json format",
@@ -8401,7 +8790,7 @@ var transpileCommand = command({
   handler: async ({ input, outDir, stdout }) => {
     let result;
     try {
-      result = transpileEvalYamlFile(path15.resolve(input));
+      result = transpileEvalYamlFile(path17.resolve(input));
     } catch (error) {
       console.error(`Error: ${error.message}`);
       process.exit(1);
@@ -8425,11 +8814,11 @@ var transpileCommand = command({
       process.stdout.write("\n");
       return;
     }
-    const outputDir = outDir ? path15.resolve(outDir) : path15.dirname(path15.resolve(input));
+    const outputDir = outDir ? path17.resolve(outDir) : path17.dirname(path17.resolve(input));
     const fileNames = getOutputFilenames(result);
     for (const [skill, evalsJson] of result.files) {
       const fileName = fileNames.get(skill) ?? "evals.json";
-      const outputPath = path15.join(outputDir, fileName);
+      const outputPath = path17.join(outputDir, fileName);
       writeFileSync5(outputPath, `${JSON.stringify(evalsJson, null, 2)}
 `);
       console.log(`Transpiled to ${outputPath}`);
@@ -8438,8 +8827,8 @@ var transpileCommand = command({
 });
 
 // src/commands/trend/index.ts
-import path16 from "node:path";
-var colors3 = {
+import path18 from "node:path";
+var colors2 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m",
@@ -8449,18 +8838,18 @@ var colors3 = {
   cyan: "\x1B[36m",
   gray: "\x1B[90m"
 };
-var noColor3 = process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
-var c3 = noColor3 ? Object.fromEntries(Object.keys(colors3).map((k) => [k, ""])) : colors3;
-var ansiPattern3 = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
-function stripAnsi4(str) {
-  return str.replace(ansiPattern3, "");
-}
-function padRight3(str, len) {
-  const plainLen = stripAnsi4(str).length;
+var noColor2 = process.env.NO_COLOR !== void 0 || !process.stdout.isTTY;
+var c3 = noColor2 ? Object.fromEntries(Object.keys(colors2).map((k) => [k, ""])) : colors2;
+var ansiPattern2 = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+function stripAnsi3(str) {
+  return str.replace(ansiPattern2, "");
+}
+function padRight4(str, len) {
+  const plainLen = stripAnsi3(str).length;
   return str + " ".repeat(Math.max(0, len - plainLen));
 }
 function padLeft3(str, len) {
-  const plainLen = stripAnsi4(str).length;
+  const plainLen = stripAnsi3(str).length;
   return " ".repeat(Math.max(0, len - plainLen)) + str;
 }
 function formatSignedNumber(value, digits = 3) {
@@ -8488,7 +8877,7 @@ function colorizeSlope(value) {
 }
 function ensureTrendIndexPath(source, cwd) {
   const resolved = resolveResultSourcePath(source, cwd);
-  if (path16.basename(resolved) !== RESULT_INDEX_FILENAME) {
+  if (path18.basename(resolved) !== RESULT_INDEX_FILENAME) {
     throw new Error(
       `Unsupported result source for trend: ${source}. Use a run workspace directory or ${RESULT_INDEX_FILENAME} manifest.`
     );
@@ -8508,7 +8897,7 @@ function resolveTrendSources(cwd, sources, last) {
   if (last < 2) {
     throw new Error("--last must be at least 2");
   }
-  const metas = listResultFiles(cwd).filter((meta) => path16.basename(meta.path) === RESULT_INDEX_FILENAME).slice(0, last);
+  const metas = listResultFiles(cwd).filter((meta) => path18.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/"
@@ -8523,10 +8912,10 @@ function getRunLabel(sourcePath, timestamp) {
   if (timestamp) {
     return timestamp;
   }
-  return path16.basename(path16.dirname(sourcePath));
+  return path18.basename(path18.dirname(sourcePath));
 }
 function getRunSortKey(sourcePath, timestamp) {
-  return timestamp ?? path16.basename(path16.dirname(sourcePath));
+  return timestamp ?? path18.basename(path18.dirname(sourcePath));
 }
 function mean2(values) {
   return values.reduce((sum, value) => sum + value, 0) / values.length;
@@ -8673,14 +9062,14 @@ function formatTrendTable(output) {
     `${c3.bold}Matched Tests:${c3.reset} ${output.summary.matchedTestCount} | ${c3.bold}Verdict:${c3.reset} ${colorizeDirection(output.summary.direction)}`
   );
   lines.push("");
-  const header = `  ${padRight3("Run", runLabelWidth)}  ${padLeft3("Tests", matchWidth)}  ${padLeft3("Mean Score", scoreWidth)}`;
+  const header = `  ${padRight4("Run", runLabelWidth)}  ${padLeft3("Tests", matchWidth)}  ${padLeft3("Mean Score", scoreWidth)}`;
   lines.push(`${c3.dim}${header}${c3.reset}`);
   lines.push(
     `${c3.dim}  ${"\u2500".repeat(runLabelWidth)}  ${"\u2500".repeat(matchWidth)}  ${"\u2500".repeat(scoreWidth)}${c3.reset}`
   );
   for (const run2 of output.runs) {
     lines.push(
-      `  ${padRight3(run2.label, runLabelWidth)}  ${padLeft3(String(run2.matchedTestCount), matchWidth)}  ${padLeft3(run2.meanScore.toFixed(3), scoreWidth)}`
+      `  ${padRight4(run2.label, runLabelWidth)}  ${padLeft3(String(run2.matchedTestCount), matchWidth)}  ${padLeft3(run2.meanScore.toFixed(3), scoreWidth)}`
     );
   }
   lines.push("");
@@ -8781,7 +9170,7 @@ var trendCommand = command({
 });
 
 // src/commands/trim/index.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "node:fs";
 var trimCommand = command({
   name: "trim",
   description: "Trim evaluation results for baseline storage (strips debug/audit fields)",
@@ -8800,7 +9189,7 @@ var trimCommand = command({
   },
   handler: async ({ input, out }) => {
     try {
-      const content = readFileSync10(input, "utf8");
+      const content = readFileSync11(input, "utf8");
       const lines = content.trim().split("\n").filter((line) => line.trim());
       const trimmedLines = lines.map((line) => {
         const record = JSON.parse(line);
@@ -8907,7 +9296,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 path17 from "node:path";
+import path19 from "node:path";
 import fg2 from "fast-glob";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
@@ -8926,7 +9315,7 @@ async function validateFiles(paths) {
   };
 }
 async function validateSingleFile(filePath) {
-  const absolutePath = path17.resolve(filePath);
+  const absolutePath = path19.resolve(filePath);
   const fileType = await detectFileType(absolutePath);
   let result;
   if (fileType === "eval") {
@@ -8951,7 +9340,7 @@ async function validateSingleFile(filePath) {
 async function expandPaths(paths) {
   const expanded = /* @__PURE__ */ new Set();
   for (const inputPath of paths) {
-    const absolutePath = path17.resolve(inputPath);
+    const absolutePath = path19.resolve(inputPath);
     try {
       await access(absolutePath, constants.F_OK);
       const stats = await stat(absolutePath);
@@ -8979,7 +9368,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(path17.normalize(f));
+    for (const f of yamlMatches) expanded.add(path19.normalize(f));
   }
   const sorted = Array.from(expanded);
   sorted.sort();
@@ -8990,7 +9379,7 @@ async function findYamlFiles(dirPath) {
   try {
     const entries2 = await readdir4(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path17.join(dirPath, entry.name);
+      const fullPath = path19.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -9007,7 +9396,7 @@ async function findYamlFiles(dirPath) {
   return results;
 }
 function isYamlFile(filePath) {
-  const ext = path17.extname(filePath).toLowerCase();
+  const ext = path19.extname(filePath).toLowerCase();
   return ext === ".yaml" || ext === ".yml";
 }
 
@@ -9062,9 +9451,9 @@ var validateCommand = command({
 });
 
 // src/commands/workspace/clean.ts
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import { readFile as readFile6, readdir as readdir5, rm } from "node:fs/promises";
-import path18 from "node:path";
+import path20 from "node:path";
 async function confirm(message) {
   const readline2 = await import("node:readline");
   const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
@@ -9091,7 +9480,7 @@ var cleanCommand = command({
   },
   handler: async ({ repo, force }) => {
     const poolRoot = getWorkspacePoolRoot();
-    if (!existsSync10(poolRoot)) {
+    if (!existsSync13(poolRoot)) {
       console.log("No workspace pool entries found.");
       return;
     }
@@ -9100,8 +9489,8 @@ var cleanCommand = command({
       const poolDirs = entries2.filter((e) => e.isDirectory());
       const matchingDirs = [];
       for (const dir of poolDirs) {
-        const poolDir = path18.join(poolRoot, dir.name);
-        const metadataPath = path18.join(poolDir, "metadata.json");
+        const poolDir = path20.join(poolRoot, dir.name);
+        const metadataPath = path20.join(poolDir, "metadata.json");
         try {
           const raw = await readFile6(metadataPath, "utf-8");
           const metadata = JSON.parse(raw);
@@ -9132,7 +9521,7 @@ var cleanCommand = command({
       }
       for (const dir of matchingDirs) {
         await rm(dir, { recursive: true, force: true });
-        console.log(`Removed: ${path18.basename(dir).slice(0, 12)}...`);
+        console.log(`Removed: ${path20.basename(dir).slice(0, 12)}...`);
       }
       console.log("Done.");
     } else {
@@ -9150,7 +9539,7 @@ var cleanCommand = command({
 });
 
 // src/commands/workspace/deps.ts
-import path19 from "node:path";
+import path21 from "node:path";
 var depsCommand = command({
   name: "deps",
   description: "Scan eval files and list git repo dependencies needed by workspaces",
@@ -9174,7 +9563,7 @@ var depsCommand = command({
     const resolvedPaths = await resolveEvalPaths(evalPaths, cwd);
     const result = await scanRepoDeps(resolvedPaths);
     for (const err2 of result.errors) {
-      console.error(`warning: ${path19.relative(cwd, err2.file)}: ${err2.message}`);
+      console.error(`warning: ${path21.relative(cwd, err2.file)}: ${err2.message}`);
     }
     const output = {
       repos: result.repos.map((r) => ({
@@ -9182,7 +9571,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) => path19.relative(cwd, p)) }
+        ...usedBy && { used_by: r.usedBy.map((p) => path21.relative(cwd, p)) }
       }))
     };
     console.log(JSON.stringify(output, null, 2));
@@ -9190,15 +9579,15 @@ var depsCommand = command({
 });
 
 // src/commands/workspace/list.ts
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 import { readFile as readFile7, readdir as readdir6, stat as stat2 } from "node:fs/promises";
-import path20 from "node:path";
+import path22 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 = path20.join(dirPath, entry.name);
+      const fullPath = path22.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(fullPath);
       } else {
@@ -9222,7 +9611,7 @@ var listCommand = command({
   args: {},
   handler: async () => {
     const poolRoot = getWorkspacePoolRoot();
-    if (!existsSync11(poolRoot)) {
+    if (!existsSync14(poolRoot)) {
       console.log("No workspace pool entries found.");
       return;
     }
@@ -9233,11 +9622,11 @@ var listCommand = command({
       return;
     }
     for (const dir of poolDirs) {
-      const poolDir = path20.join(poolRoot, dir.name);
+      const poolDir = path22.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 = path20.join(poolDir, "metadata.json");
+      const metadataPath = path22.join(poolDir, "metadata.json");
       let metadata = null;
       try {
         const raw = await readFile7(metadataPath, "utf-8");
@@ -9284,8 +9673,8 @@ var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var AGENTV_DIR = getAgentvHome();
 var CACHE_FILE = "version-check.json";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/agentv/latest";
-async function getCachedUpdateInfo(path21) {
-  const filePath = path21 ?? join5(AGENTV_DIR, CACHE_FILE);
+async function getCachedUpdateInfo(path23) {
+  const filePath = path23 ?? join5(AGENTV_DIR, CACHE_FILE);
   try {
     const raw = await readFile8(filePath, "utf-8");
     const data = JSON.parse(raw);
@@ -9446,4 +9835,4 @@ export {
   preprocessArgv,
   runCli
 };
-//# sourceMappingURL=chunk-VA64NETD.js.map
+//# sourceMappingURL=chunk-YLVQNF23.js.map