agentv 4.41.1 → 4.41.4-next.1

package/dist/{chunk-LXXMQSAR.js → chunk-AHQWZGJE.js}

@@ -10,6 +10,7 @@ import {
   deleteRunTags,
   detectFileType,
   discoverEvalFiles,
+  discoverTargetsFile,
   enforceRequiredVersion,
   ensureRemoteRunAvailable,
   findRepoRoot,
@@ -37,6 +38,7 @@ import {
   parseResultManifest,
   readRemoteRunTagState,
   readRunTags,
+  readTestSuiteTarget,
   resolveEvalPaths,
   resolveResultSourcePath,
   resolveRunCacheFile,
@@ -54,11 +56,12 @@ import {
   validateTargetsFile,
   validateWorkspacePaths,
   writeRunTags
-} from "./chunk-JQ6XRG7X.js";
+} from "./chunk-PC33TGIV.js";
 import {
+  materializeEvalBundle,
   toSnakeCaseDeep as toSnakeCaseDeep2,
   writeArtifactsFromResults as writeArtifactsFromResults2
-} from "./chunk-A4J456KS.js";
+} from "./chunk-VBEWRK44.js";
 import {
   DEFAULT_CATEGORY,
   deriveCategory,
@@ -73,9 +76,10 @@ import {
   syncProjects,
   transpileEvalYamlFile,
   trimBaselineResult
-} from "./chunk-Z45FKRMJ.js";
+} from "./chunk-XDE2ZRII.js";
 import {
   DEFAULT_THRESHOLD,
+  EXECUTION_TRACE_SCHEMA_VERSION,
   addProject,
   aggregateRunDir,
   buildBenchmarkArtifact,
@@ -100,7 +104,9 @@ import {
   parseCopilotEvents,
   parseYamlValue,
   readTargetDefinitions,
+  readTraceEnvelopeReplayRecords,
   readTranscriptFile,
+  readTranscriptJsonl,
   removeProject,
   runContainsAllAssertion,
   runContainsAnyAssertion,
@@ -117,8 +123,11 @@ import {
   toSnakeCaseDeep,
   toTranscriptJsonLines,
   touchProject,
+  traceEnvelopeToTraceSummary,
+  traceEnvelopeToTranscriptMessages,
+  traceFromTranscriptJsonLines,
   writeArtifactsFromResults
-} from "./chunk-ENHX2CCS.js";
+} from "./chunk-QCF3LUI7.js";
 import {
   __commonJS,
   __require,
@@ -879,7 +888,7 @@ var require_src = __commonJS({
 });
 
 // src/index.ts
-import path34 from "node:path";
+import path35 from "node:path";
 
 // ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -3959,7 +3968,7 @@ import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
 import path3 from "node:path";
 var ASSERTION_TEMPLATES = {
   default: `#!/usr/bin/env bun
-import { defineAssertion } from '@agentv/eval';
+import { defineAssertion } from '@agentv/sdk';
 
 export default defineAssertion(({ output }) => {
   // TODO: Implement your assertion logic
@@ -3972,7 +3981,7 @@ export default defineAssertion(({ output }) => {
 });
 `,
   score: `#!/usr/bin/env bun
-import { defineAssertion } from '@agentv/eval';
+import { defineAssertion } from '@agentv/sdk';
 
 export default defineAssertion(({ output }) => {
   // TODO: Implement your scoring logic (0.0 to 1.0)
@@ -4364,6 +4373,201 @@ async function findGraderScript(graderName, startDir) {
   return null;
 }
 
+// src/commands/eval/commands/bundle.ts
+import path7 from "node:path";
+function unique(values) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const trimmed = value.trim();
+    if (!trimmed || seen.has(trimmed)) {
+      continue;
+    }
+    seen.add(trimmed);
+    result.push(trimmed);
+  }
+  return result;
+}
+function targetReferenceNames(target) {
+  const references = [];
+  for (const key of ["use_target", "grader_target", "judge_target"]) {
+    const value = target[key];
+    if (typeof value === "string" && value.trim().length > 0 && !value.includes("${{")) {
+      references.push(value.trim());
+    }
+  }
+  const fallbackTargets = target.fallback_targets;
+  if (Array.isArray(fallbackTargets)) {
+    for (const value of fallbackTargets) {
+      if (typeof value === "string" && value.trim().length > 0 && !value.includes("${{")) {
+        references.push(value.trim());
+      }
+    }
+  }
+  return references;
+}
+function ensureTargetGraph(targetName2, definitions, targetsFilePath) {
+  const byName = new Map(definitions.map((definition) => [definition.name, definition]));
+  const seen = /* @__PURE__ */ new Set();
+  function visit(name, requestedBy) {
+    if (seen.has(name)) {
+      return;
+    }
+    const definition = byName.get(name);
+    if (!definition) {
+      const available = definitions.map((entry) => entry.name).sort().join(", ");
+      const owner = requestedBy ? ` referenced by target '${requestedBy}'` : "";
+      throw new Error(
+        `Target '${name}'${owner} not found in ${targetsFilePath}. Available targets: ${available}`
+      );
+    }
+    seen.add(name);
+    for (const referenceName of targetReferenceNames(definition)) {
+      visit(referenceName, name);
+    }
+  }
+  visit(targetName2);
+}
+function definitionsWithEvalTargetRefs(definitions, targetRefs) {
+  if (!targetRefs) {
+    return definitions;
+  }
+  const result = [...definitions];
+  for (const ref of targetRefs) {
+    if (ref.use_target && !result.some((definition) => definition.name === ref.name)) {
+      result.push({ name: ref.name, use_target: ref.use_target });
+    }
+  }
+  return result;
+}
+function buildBundleExecution(options) {
+  const targetRefsByName = new Map((options.targetRefs ?? []).map((ref) => [ref.name, ref]));
+  const serializeTargetRef = (name) => {
+    const ref = targetRefsByName.get(name);
+    return ref?.hooks || ref?.use_target ? ref : name;
+  };
+  const singleTargetRef = options.targetNames[0] ? targetRefsByName.get(options.targetNames[0]) : void 0;
+  const execution = options.targetNames.length === 1 && !singleTargetRef?.hooks && !singleTargetRef?.use_target ? { target: options.targetNames[0] } : {
+    targets: options.targetNames.map((name) => serializeTargetRef(name))
+  };
+  if (options.workers !== void 0) {
+    execution.workers = options.workers;
+  }
+  if (options.cache !== void 0) {
+    execution.cache = options.cache;
+  }
+  if (options.cachePath !== void 0) {
+    execution.cache_path = options.cachePath;
+  }
+  if (options.budgetUsd !== void 0) {
+    execution.budget_usd = options.budgetUsd;
+  }
+  if (options.threshold !== void 0) {
+    execution.threshold = options.threshold;
+  }
+  return execution;
+}
+var evalBundleCommand = command({
+  name: "bundle",
+  description: "Create a portable self-contained directory for an eval suite",
+  args: {
+    evalPath: positional({
+      type: string,
+      displayName: "eval",
+      description: "Path or glob resolving to one eval file"
+    }),
+    out: option({
+      type: string,
+      long: "out",
+      description: "Portable bundle output directory"
+    }),
+    target: multioption({
+      type: array(string),
+      long: "target",
+      description: "Target name to bundle (repeatable). Defaults to eval target(s) or default."
+    }),
+    targets: option({
+      type: optional(string),
+      long: "targets",
+      description: "Path to targets.yaml (overrides discovery)"
+    })
+  },
+  handler: async (args) => {
+    const cwd = process.cwd();
+    const repoRoot = await findRepoRoot(cwd);
+    const resolvedPaths = await resolveEvalPaths([args.evalPath], cwd);
+    if (resolvedPaths.length !== 1) {
+      throw new Error(
+        `agentv eval bundle requires exactly one eval file, but matched ${resolvedPaths.length}: ${resolvedPaths.join(", ")}`
+      );
+    }
+    const evalFilePath = resolvedPaths[0];
+    await loadEnvFromHierarchy({ testFilePath: evalFilePath, repoRoot, verbose: false });
+    const suite = await loadTestSuite(evalFilePath, repoRoot);
+    if (suite.providerFactory) {
+      throw new Error(
+        "TypeScript evals with task() provider functions cannot be bundled into portable YAML yet."
+      );
+    }
+    let definitions;
+    let targetNames;
+    if (suite.inlineTarget) {
+      definitions = [suite.inlineTarget];
+      targetNames = unique(args.target.length > 0 ? args.target : [suite.inlineTarget.name]);
+    } else {
+      const targetsFilePath = await discoverTargetsFile({
+        explicitPath: args.targets,
+        testFilePath: evalFilePath,
+        repoRoot,
+        cwd
+      });
+      definitions = definitionsWithEvalTargetRefs(
+        await readTargetDefinitions(targetsFilePath),
+        suite.targetRefs
+      );
+      const suiteTarget = await readTestSuiteTarget(evalFilePath);
+      targetNames = unique(
+        args.target.length > 0 ? args.target : suite.targets ?? [suiteTarget ?? "default"]
+      );
+      for (const targetName2 of targetNames) {
+        ensureTargetGraph(targetName2, definitions, targetsFilePath);
+      }
+    }
+    const targetSelections = targetNames.map((targetName2) => ({
+      evalFileAbsolutePath: evalFilePath,
+      targetName: targetName2,
+      definitions
+    }));
+    const paths = await materializeEvalBundle({
+      evalFilePath,
+      tests: suite.tests,
+      targetSelections,
+      outputDir: args.out,
+      cwd,
+      repoRoot,
+      execution: buildBundleExecution({
+        targetNames,
+        targetRefs: suite.targetRefs,
+        workers: suite.workers,
+        cache: suite.cacheConfig?.enabled,
+        cachePath: suite.cacheConfig?.cachePath,
+        budgetUsd: suite.budgetUsd,
+        threshold: suite.threshold
+      })
+    });
+    console.log(`Bundle written to: ${paths.bundleDir}`);
+    console.log(
+      `  Eval: ${path7.relative(paths.bundleDir, paths.evalPath).split(path7.sep).join("/")}`
+    );
+    console.log(
+      `  Targets: ${path7.relative(paths.bundleDir, paths.targetsPath).split(path7.sep).join("/")}`
+    );
+    console.log(
+      `  Manifest: ${path7.relative(paths.bundleDir, paths.manifestPath).split(path7.sep).join("/")}`
+    );
+  }
+});
+
 // src/commands/eval/commands/run.ts
 var evalRunCommand = command({
   name: "eval",
@@ -4602,7 +4806,7 @@ var evalRunCommand = command({
   },
   handler: async (args) => {
     if (args.evalPaths.length === 0 && process.stdin.isTTY) {
-      const { launchInteractiveWizard } = await import("./interactive-OPSG4MPD.js");
+      const { launchInteractiveWizard } = await import("./interactive-VNGVNNRF.js");
       await launchInteractiveWizard();
       return;
     }
@@ -4685,13 +4889,14 @@ var evalCommand = subcommands({
   cmds: {
     run: evalRunCommand,
     assert: evalAssertCommand,
-    aggregate: evalAggregateCommand
+    aggregate: evalAggregateCommand,
+    bundle: evalBundleCommand
   }
 });
 
 // src/commands/grade/index.ts
 import { readFile, stat } from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -4749,8 +4954,10 @@ function fromManifestWire(value, manifestPath) {
   if (setupStatus !== "ok") {
     throw invalidManifest(manifestPath, "field 'setup_status' must be 'ok'");
   }
-  const preparedDir = path7.dirname(manifestPath);
-  const resolveManifestPath = (rawPath) => path7.isAbsolute(rawPath) ? rawPath : path7.resolve(preparedDir, rawPath);
+  const preparedDir = path8.dirname(manifestPath);
+  const resolveManifestPath = (rawPath) => path8.isAbsolute(rawPath) ? rawPath : path8.resolve(preparedDir, rawPath);
+  expectArray(value, "setup_steps", manifestPath);
+  expectArray(value, "repo_pins", manifestPath);
   return {
     schemaVersion: 1,
     evalPath: resolveManifestPath(expectString(value, "eval_path", manifestPath)),
@@ -4759,8 +4966,6 @@ function fromManifestWire(value, manifestPath) {
     workspacePath: resolveManifestPath(expectString(value, "workspace_path", manifestPath)),
     promptPath: resolveManifestPath(expectString(value, "prompt_path", manifestPath)),
     setupStatus,
-    setupSteps: expectArray(value, "setup_steps", manifestPath),
-    repoPins: expectArray(value, "repo_pins", manifestPath),
     baseline: expectBaseline(value.baseline, manifestPath),
     createdAt: expectString(value, "created_at", manifestPath),
     manifestPath,
@@ -4768,12 +4973,12 @@ function fromManifestWire(value, manifestPath) {
   };
 }
 async function resolvePreparedManifestPath(preparedPath) {
-  const resolved = path7.resolve(preparedPath);
+  const resolved = path8.resolve(preparedPath);
   try {
     const stats = await stat(resolved);
-    return stats.isDirectory() ? path7.join(resolved, "agentv_prepare.json") : resolved;
+    return stats.isDirectory() ? path8.join(resolved, "agentv_prepare.json") : resolved;
   } catch {
-    return path7.basename(resolved) === "agentv_prepare.json" ? resolved : path7.join(resolved, "agentv_prepare.json");
+    return path8.basename(resolved) === "agentv_prepare.json" ? resolved : path8.join(resolved, "agentv_prepare.json");
   }
 }
 async function readPreparedManifest(preparedPath) {
@@ -4825,8 +5030,8 @@ async function ensureFileExists(filePath, description) {
   }
 }
 function assertMatchesManifest(options) {
-  const commandEvalPath = path7.resolve(options.evalPath);
-  if (path7.resolve(options.manifest.evalPath) !== commandEvalPath) {
+  const commandEvalPath = path8.resolve(options.evalPath);
+  if (path8.resolve(options.manifest.evalPath) !== commandEvalPath) {
     throw new Error(
       `Prepared manifest eval_path does not match command eval path: ${options.manifest.evalPath} !== ${commandEvalPath}`
     );
@@ -4838,13 +5043,14 @@ function assertMatchesManifest(options) {
   }
   return options.testId ?? options.manifest.testId;
 }
-function toPreparedAttemptMetadata(manifest) {
+function toPreparedAttemptMetadata(manifest, tracePath) {
   return {
     source: "manual",
     manifestPath: manifest.manifestPath,
     preparedDir: manifest.preparedDir,
     workspacePath: manifest.workspacePath,
     promptPath: manifest.promptPath,
+    ...tracePath !== void 0 && { tracePath },
     target: manifest.target,
     preparedAt: manifest.createdAt,
     setupStatus: manifest.setupStatus,
@@ -4860,6 +5066,7 @@ function toCommandOutputWire(result) {
     execution_status: result.executionStatus,
     workspace_path: result.workspacePath,
     manifest_path: result.manifestPath,
+    ...result.tracePath !== void 0 && { trace_path: result.tracePath },
     output_dir: result.outputDir,
     index_path: result.indexPath
   };
@@ -4869,19 +5076,167 @@ function printHumanOutput(result) {
   console.log(`Score: ${result.score.toFixed(3)} (${result.executionStatus})`);
   console.log(`Workspace: ${result.workspacePath}`);
   console.log(`Manifest: ${result.manifestPath}`);
+  if (result.tracePath) {
+    console.log(`Trace: ${result.tracePath}`);
+  }
   console.log(`Artifact workspace: ${result.outputDir}`);
   console.log(`Index: ${result.indexPath}`);
 }
+function isTraceEnvelopeDocument(value) {
+  return isRecord(value) && value.schema_version === EXECUTION_TRACE_SCHEMA_VERSION;
+}
+function isTranscriptJsonLine(value) {
+  return isRecord(value) && typeof value.test_id === "string" && typeof value.target === "string" && typeof value.message_index === "number" && isRecord(value.source);
+}
+function parseFirstJsonLine(raw) {
+  const firstLine = raw.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0);
+  if (!firstLine) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(firstLine);
+  } catch {
+    return void 0;
+  }
+}
+function looksLikeTraceEnvelopeJsonText(trimmed) {
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+    return false;
+  }
+  return trimmed.includes('"schema_version"') && trimmed.includes(JSON.stringify(EXECUTION_TRACE_SCHEMA_VERSION));
+}
+function traceEnvelopeRecordMatchesPreparedAttempt(record, options) {
+  if (record.envelope.eval.testId !== options.testId) {
+    return false;
+  }
+  const sourceTarget = record.envelope.eval.sourceTarget ?? record.envelope.eval.target;
+  return sourceTarget === options.target || record.envelope.eval.target === options.target;
+}
+function selectTraceEnvelopeRecord(records, options) {
+  if (records.length === 0) {
+    throw new Error(`Trace file has no execution trace records: ${options.sourcePath}`);
+  }
+  const matchingTest = records.filter((record) => record.envelope.eval.testId === options.testId);
+  const candidates = matchingTest.filter(
+    (record) => traceEnvelopeRecordMatchesPreparedAttempt(record, options)
+  );
+  if (candidates.length === 1) {
+    return candidates[0];
+  }
+  const detail = candidates.length === 0 ? matchingTest.length === 0 ? `no record matches test_id '${options.testId}'` : `${matchingTest.length} record(s) match test_id '${options.testId}' but none match target '${options.target}'` : `${candidates.length} records match test_id '${options.testId}' and target '${options.target}'`;
+  throw new Error(
+    `Trace file ${options.sourcePath} is ambiguous for prepared grading: ${detail}. Pass a single-record trace file or a file with one matching test/target record.`
+  );
+}
+function traceFromEnvelopeRecord(record) {
+  const summary = traceEnvelopeToTraceSummary(record.envelope);
+  return buildTraceFromMessages({
+    output: traceEnvelopeToTranscriptMessages(record.envelope),
+    summary: summary.trace,
+    tokenUsage: summary.tokenUsage,
+    costUsd: summary.costUsd,
+    durationMs: summary.durationMs,
+    startTime: summary.startTime,
+    endTime: summary.endTime,
+    provider: record.envelope.source.provider,
+    target: record.envelope.eval.target,
+    testId: record.envelope.eval.testId,
+    conversationId: record.envelope.eval.runId,
+    metadata: {
+      trace_source_path: record.sourcePath,
+      trace_source_format: EXECUTION_TRACE_SCHEMA_VERSION,
+      trace_artifact_id: record.envelope.artifactId,
+      ...record.lineNumber !== void 0 && { trace_source_line: record.lineNumber }
+    }
+  });
+}
+function groupTranscriptLinesByTestTarget(lines) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const key = `${line.test_id}\0${line.target}`;
+    const group = groups.get(key) ?? (() => {
+      const created = { testId: line.test_id, target: line.target, lines: [] };
+      groups.set(key, created);
+      return created;
+    })();
+    group.lines.push(line);
+  }
+  return [...groups.values()];
+}
+function selectTranscriptLines(lines, options) {
+  const groups = groupTranscriptLinesByTestTarget(lines);
+  if (groups.length === 0) {
+    throw new Error(`Trace file has no transcript rows: ${options.sourcePath}`);
+  }
+  const matchingTest = groups.filter((group) => group.testId === options.testId);
+  const candidates = matchingTest.filter((group) => group.target === options.target);
+  if (candidates.length === 1) {
+    return candidates[0].lines;
+  }
+  const detail = candidates.length === 0 ? matchingTest.length === 0 ? `no transcript group matches test_id '${options.testId}'` : `${matchingTest.length} transcript group(s) match test_id '${options.testId}' but none match target '${options.target}'` : `${candidates.length} transcript groups match test_id '${options.testId}' and target '${options.target}'`;
+  throw new Error(
+    `Trace file ${options.sourcePath} is ambiguous for prepared grading: ${detail}. Pass a single-session transcript or a transcript with one matching test/target group.`
+  );
+}
+async function readPreparedTrace(tracePath, options) {
+  const sourcePath = path8.resolve(tracePath);
+  const raw = await readFile(sourcePath, "utf8");
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`Trace file is empty: ${sourcePath}`);
+  }
+  const firstLine = parseFirstJsonLine(raw);
+  if (isTraceEnvelopeDocument(firstLine)) {
+    const records = await readTraceEnvelopeReplayRecords(sourcePath);
+    return {
+      sourcePath,
+      trace: traceFromEnvelopeRecord(
+        selectTraceEnvelopeRecord(records, { sourcePath, ...options })
+      )
+    };
+  }
+  if (isTranscriptJsonLine(firstLine)) {
+    const lines = selectTranscriptLines(await readTranscriptJsonl(sourcePath), {
+      sourcePath,
+      ...options
+    });
+    const trace = traceFromTranscriptJsonLines(lines);
+    return {
+      sourcePath,
+      trace: {
+        ...trace,
+        metadata: {
+          ...trace.metadata,
+          trace_source_path: sourcePath,
+          trace_source_format: "agentv.transcript.jsonl"
+        }
+      }
+    };
+  }
+  if (looksLikeTraceEnvelopeJsonText(trimmed)) {
+    const records = await readTraceEnvelopeReplayRecords(sourcePath);
+    return {
+      sourcePath,
+      trace: traceFromEnvelopeRecord(
+        selectTraceEnvelopeRecord(records, { sourcePath, ...options })
+      )
+    };
+  }
+  throw new Error(
+    `Unsupported trace format at ${sourcePath}. Expected agentv.trace.v1 JSON/JSONL or AgentV transcript JSONL.`
+  );
+}
 async function gradePreparedAttempt(options) {
   const manifest = await readPreparedManifest(options.preparedPath);
-  const evalPath = path7.resolve(options.evalPath);
+  const evalPath = path8.resolve(options.evalPath);
   const testId = assertMatchesManifest({ manifest, evalPath, testId: options.testId });
   await ensureDirectoryExists(manifest.workspacePath, "Prepared workspace");
   await ensureFileExists(manifest.promptPath, "Prepared prompt");
-  const evalDir = path7.dirname(evalPath);
+  const preparedTrace = options.tracePath !== void 0 ? await readPreparedTrace(options.tracePath, { testId, target: manifest.target }) : void 0;
+  const evalDir = path8.dirname(evalPath);
   const repoRoot = await findRepoRoot(evalDir);
   await loadEnvFromHierarchy({ testFilePath: evalPath, repoRoot, verbose: !!options.verbose });
-  const category = deriveCategory(path7.relative(process.cwd(), evalPath));
+  const category = deriveCategory(path8.relative(process.cwd(), evalPath));
   const suite = await loadTestSuite(evalPath, repoRoot, { category });
   const test = suite.tests.find((candidate) => candidate.id === testId);
   if (!test) {
@@ -4907,8 +5262,8 @@ async function gradePreparedAttempt(options) {
     ...selection.resolvedTarget,
     name: manifest.target
   };
-  const response = options.responsePath !== void 0 ? await readFile(path7.resolve(options.responsePath), "utf8") : void 0;
-  const runDir = path7.resolve(
+  const response = options.responsePath !== void 0 ? await readFile(path8.resolve(options.responsePath), "utf8") : void 0;
+  const runDir = path8.resolve(
     options.outputDir ?? buildDefaultRunDir(process.cwd(), options.experiment)
   );
   const result = await gradePreparedEvalCase({
@@ -4920,11 +5275,12 @@ async function gradePreparedAttempt(options) {
     workspacePath: manifest.workspacePath,
     baselineCommit: manifest.baseline.commit,
     response,
+    trace: preparedTrace?.trace,
     verbose: options.verbose,
     graderTarget: options.graderTarget,
     model: options.model,
     threshold: options.threshold ?? suite.threshold,
-    preparedAttempt: toPreparedAttemptMetadata(manifest)
+    preparedAttempt: toPreparedAttemptMetadata(manifest, preparedTrace?.sourcePath)
   });
   const artifacts = await writeArtifactsFromResults([result], runDir, {
     evalFile: evalPath,
@@ -4939,6 +5295,7 @@ async function gradePreparedAttempt(options) {
     executionStatus: result.executionStatus,
     workspacePath: manifest.workspacePath,
     manifestPath: manifest.manifestPath,
+    tracePath: preparedTrace?.sourcePath,
     outputDir: runDir,
     indexPath: artifacts.indexPath
   };
@@ -4973,6 +5330,11 @@ var gradeCommand = command({
       long: "response",
       description: "Optional final response text file from the human or external agent"
     }),
+    trace: option({
+      type: optional(string),
+      long: "trace",
+      description: "Optional AgentV trace/session file for trace-aware graders (execution trace JSON/JSONL or transcript JSONL)"
+    }),
     experiment: option({
       type: optional(string),
       long: "experiment",
@@ -5005,6 +5367,7 @@ var gradeCommand = command({
     prepared,
     output,
     response,
+    trace,
     experiment,
     graderTarget,
     model,
@@ -5017,6 +5380,7 @@ var gradeCommand = command({
       preparedPath: prepared,
       outputDir: output,
       responsePath: response,
+      tracePath: trace,
       experiment,
       graderTarget,
       model,
@@ -5033,7 +5397,7 @@ var gradeCommand = command({
 
 // src/commands/import/claude.ts
 import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 var importClaudeCommand = command({
   name: "claude",
   description: "Import a Claude Code session transcript for offline grading",
@@ -5105,8 +5469,8 @@ var importClaudeCommand = command({
     const rawJsonl = await readTranscriptFile(sessionFilePath);
     const transcript = parseClaudeSession(rawJsonl);
     const shortId = (sessionId ?? transcript.source.sessionId).slice(0, 8);
-    const outputPath = output ?? path8.join(".agentv", "transcripts", `claude-${shortId}.jsonl`);
-    await mkdir3(path8.dirname(outputPath), { recursive: true });
+    const outputPath = output ?? path9.join(".agentv", "transcripts", `claude-${shortId}.jsonl`);
+    await mkdir3(path9.dirname(outputPath), { recursive: true });
     const jsonLines = toTranscriptJsonLines(transcript);
     await writeFile3(
       outputPath,
@@ -5150,7 +5514,7 @@ function formatDurationMs(ms) {
 
 // src/commands/import/codex.ts
 import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
-import path9 from "node:path";
+import path10 from "node:path";
 var importCodexCommand = command({
   name: "codex",
   description: "Import a Codex CLI session transcript for offline grading",
@@ -5222,8 +5586,8 @@ var importCodexCommand = command({
     const rawJsonl = await readTranscriptFile(session.filePath);
     const transcript = parseCodexSession(rawJsonl);
     const shortId = session.sessionId.slice(0, 8);
-    const outputPath = output ?? path9.join(".agentv", "transcripts", `codex-${shortId}.jsonl`);
-    await mkdir4(path9.dirname(outputPath), { recursive: true });
+    const outputPath = output ?? path10.join(".agentv", "transcripts", `codex-${shortId}.jsonl`);
+    await mkdir4(path10.dirname(outputPath), { recursive: true });
     const jsonLines = toTranscriptJsonLines(transcript);
     await writeFile4(
       outputPath,
@@ -5262,7 +5626,7 @@ function formatDurationMs2(ms) {
 
 // src/commands/import/copilot.ts
 import { mkdir as mkdir5, readFile as readFile2, writeFile as writeFile5 } from "node:fs/promises";
-import path10 from "node:path";
+import path11 from "node:path";
 var importCopilotCommand = command({
   name: "copilot",
   description: "Import a Copilot CLI session transcript for offline grading",
@@ -5327,7 +5691,7 @@ var importCopilotCommand = command({
       );
       process.exit(1);
     }
-    const eventsPath = path10.join(sessionDir, "events.jsonl");
+    const eventsPath = path11.join(sessionDir, "events.jsonl");
     const rawJsonl = await readFile2(eventsPath, "utf8");
     const parsed = parseCopilotEvents(rawJsonl);
     const transcript = {
@@ -5344,8 +5708,8 @@ var importCopilotCommand = command({
       costUsd: null
     };
     const shortId = resolvedSessionId.slice(0, 8);
-    const outputPath = output ?? path10.join(".agentv", "transcripts", `copilot-${shortId}.jsonl`);
-    await mkdir5(path10.dirname(outputPath), { recursive: true });
+    const outputPath = output ?? path11.join(".agentv", "transcripts", `copilot-${shortId}.jsonl`);
+    await mkdir5(path11.dirname(outputPath), { recursive: true });
     const jsonLines = toTranscriptJsonLines(transcript);
     await writeFile5(
       outputPath,
@@ -5390,12 +5754,12 @@ function formatDurationMs3(ms) {
 // src/commands/import/huggingface.ts
 import { execFile } from "node:child_process";
 import { existsSync as existsSync2 } from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 function findScript() {
   const candidates = [
-    path11.resolve(__dirname, "..", "..", "..", "..", "..", "scripts", "import-huggingface.py"),
-    path11.resolve(__dirname, "..", "..", "..", "..", "scripts", "import-huggingface.py"),
-    path11.resolve(process.cwd(), "scripts", "import-huggingface.py")
+    path12.resolve(__dirname, "..", "..", "..", "..", "..", "scripts", "import-huggingface.py"),
+    path12.resolve(__dirname, "..", "..", "..", "..", "scripts", "import-huggingface.py"),
+    path12.resolve(process.cwd(), "scripts", "import-huggingface.py")
   ];
   for (const candidate of candidates) {
     if (existsSync2(candidate)) return candidate;
@@ -5495,17 +5859,17 @@ Imported ${summary.files_created} eval(s) from ${summary.dataset} \u2192 ${summa
 
 // src/commands/import/promptfoo.ts
 import { mkdir as mkdir6, readFile as readFile3, writeFile as writeFile6 } from "node:fs/promises";
-import path12 from "node:path";
+import path13 from "node:path";
 import fg2 from "fast-glob";
 import JSON5 from "json5";
 import { parse as parseYaml, stringify as stringifyYaml2 } from "yaml";
 var FILE_PREFIX = "file://";
 var PROMPTFOO_COMMENT_PREFIX = "# Converted from promptfoo config: ";
 async function convertPromptfooToAgentvSuite(options) {
-  const absoluteInputPath = path12.resolve(options.inputPath);
-  const configDir = path12.dirname(absoluteInputPath);
+  const absoluteInputPath = path13.resolve(options.inputPath);
+  const configDir = path13.dirname(absoluteInputPath);
   const rawConfig = await loadPromptfooConfig(absoluteInputPath);
-  const suiteName = sanitizeName(path12.basename(absoluteInputPath, path12.extname(absoluteInputPath)));
+  const suiteName = sanitizeName(path13.basename(absoluteInputPath, path13.extname(absoluteInputPath)));
   const prompts = await loadPromptfooPrompts(rawConfig.prompts, configDir);
   if (prompts.length === 0) {
     throw new Error(`promptfoo import requires at least one prompt in ${absoluteInputPath}`);
@@ -5546,7 +5910,7 @@ async function convertPromptfooToAgentvYaml(inputPath) {
     indent: 2,
     lineWidth: 0
   });
-  return `${PROMPTFOO_COMMENT_PREFIX}${path12.resolve(inputPath)}
+  return `${PROMPTFOO_COMMENT_PREFIX}${path13.resolve(inputPath)}
 ${yaml}`;
 }
 var importPromptfooCommand = command({
@@ -5570,14 +5934,14 @@ var importPromptfooCommand = command({
     })
   },
   handler: async ({ input, output, dryRun: dryRun2 }) => {
-    const absoluteInput = path12.resolve(input);
+    const absoluteInput = path13.resolve(input);
     const yaml = await convertPromptfooToAgentvYaml(absoluteInput);
     if (dryRun2) {
       process.stdout.write(yaml);
       return;
     }
-    const outputPath = path12.resolve(output ?? path12.join(path12.dirname(absoluteInput), "EVAL.yaml"));
-    await mkdir6(path12.dirname(outputPath), { recursive: true });
+    const outputPath = path13.resolve(output ?? path13.join(path13.dirname(absoluteInput), "EVAL.yaml"));
+    await mkdir6(path13.dirname(outputPath), { recursive: true });
     await writeFile6(outputPath, yaml, "utf8");
     console.log(`Imported promptfoo config \u2192 ${outputPath}`);
   }
@@ -5591,7 +5955,7 @@ async function loadPromptfooConfig(filePath) {
   return parsed;
 }
 function parseStructuredText(content, filePath) {
-  const ext = path12.extname(filePath).toLowerCase();
+  const ext = path13.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".json5" || ext === ".jsonc") {
     return JSON5.parse(content);
   }
@@ -5665,7 +6029,7 @@ async function loadPromptFromReference(reference, baseDir, identity2) {
   const prompts = [];
   for (let index = 0; index < files.length; index++) {
     const filePath = files[index];
-    const ext = path12.extname(filePath).toLowerCase();
+    const ext = path13.extname(filePath).toLowerCase();
     const raw = await readFile3(filePath, "utf8");
     if (ext === ".json" || ext === ".json5" || ext === ".jsonc") {
       const parsed = parseStructuredText(raw, filePath);
@@ -5808,10 +6172,10 @@ async function loadPromptfooTestsFromReference(reference, baseDir) {
   const files = await resolvePromptfooFileReference(reference, baseDir);
   const tests = [];
   for (const filePath of files) {
-    const ext = path12.extname(stripSheetSuffix(filePath)).toLowerCase();
+    const ext = path13.extname(stripSheetSuffix(filePath)).toLowerCase();
     if (ext === ".xlsx" || ext === ".xls") {
       throw new Error(
-        `Unsupported test dataset '${path12.basename(filePath)}': XLSX promptfoo datasets are not imported yet`
+        `Unsupported test dataset '${path13.basename(filePath)}': XLSX promptfoo datasets are not imported yet`
       );
     }
     const content = await readFile3(filePath, "utf8");
@@ -6409,7 +6773,7 @@ function normalizeAssertionType(rawType) {
 async function resolvePromptfooFileReference(reference, baseDir) {
   const rawPath = reference.slice(FILE_PREFIX.length);
   const [pathWithoutSheet] = rawPath.split("#");
-  const absolutePath = path12.resolve(baseDir, pathWithoutSheet);
+  const absolutePath = path13.resolve(baseDir, pathWithoutSheet);
   const normalizedPattern = absolutePath.replaceAll("\\", "/");
   const matches = await fg2(normalizedPattern, {
     onlyFiles: true,
@@ -6502,29 +6866,29 @@ var importCommand = subcommands({
 
 // src/commands/init/index.ts
 import { existsSync as existsSync3, mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 import * as readline from "node:readline/promises";
 
 // src/templates/index.ts
 import { readFileSync as readFileSync3, readdirSync, statSync } from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 import { fileURLToPath } from "node:url";
 function getAgentvTemplates() {
   return getTemplatesFromDir(".agentv");
 }
 function getEnvExampleTemplate() {
-  const currentDir = path13.dirname(fileURLToPath(import.meta.url));
-  const templatesBase = currentDir.includes(`${path13.sep}dist`) ? path13.join(currentDir, "templates") : currentDir;
-  const content = readFileSync3(path13.join(templatesBase, ".env.example"), "utf-8");
+  const currentDir = path14.dirname(fileURLToPath(import.meta.url));
+  const templatesBase = currentDir.includes(`${path14.sep}dist`) ? path14.join(currentDir, "templates") : currentDir;
+  const content = readFileSync3(path14.join(templatesBase, ".env.example"), "utf-8");
   return { path: ".env.example", content };
 }
 function getTemplatesFromDir(subdir) {
-  const currentDir = path13.dirname(fileURLToPath(import.meta.url));
+  const currentDir = path14.dirname(fileURLToPath(import.meta.url));
   let templatesDir;
-  if (currentDir.includes(`${path13.sep}dist`)) {
-    templatesDir = path13.join(currentDir, "templates", subdir);
+  if (currentDir.includes(`${path14.sep}dist`)) {
+    templatesDir = path14.join(currentDir, "templates", subdir);
   } else {
-    templatesDir = path13.join(currentDir, subdir);
+    templatesDir = path14.join(currentDir, subdir);
   }
   return readTemplatesRecursively(templatesDir, "");
 }
@@ -6532,15 +6896,15 @@ function readTemplatesRecursively(dir, relativePath) {
   const templates = [];
   const entries2 = readdirSync(dir);
   for (const entry of entries2) {
-    const fullPath = path13.join(dir, entry);
+    const fullPath = path14.join(dir, entry);
     const stat4 = statSync(fullPath);
-    const entryRelativePath = relativePath ? path13.join(relativePath, entry) : entry;
+    const entryRelativePath = relativePath ? path14.join(relativePath, entry) : entry;
     if (stat4.isDirectory()) {
       templates.push(...readTemplatesRecursively(fullPath, entryRelativePath));
     } else {
       const content = readFileSync3(fullPath, "utf-8");
       templates.push({
-        path: entryRelativePath.split(path13.sep).join("/"),
+        path: entryRelativePath.split(path14.sep).join("/"),
         // Normalize to forward slashes
         content
       });
@@ -6571,22 +6935,22 @@ async function promptYesNo(message) {
   }
 }
 async function initCommand(options = {}) {
-  const targetPath = path14.resolve(options.targetPath ?? ".");
-  const agentvDir = path14.join(targetPath, ".agentv");
+  const targetPath = path15.resolve(options.targetPath ?? ".");
+  const agentvDir = path15.join(targetPath, ".agentv");
   const otherAgentvTemplates = getAgentvTemplates();
   const envTemplate = getEnvExampleTemplate();
   const existingFiles = [];
   if (envTemplate) {
-    const envFilePath = path14.join(targetPath, ".env.example");
+    const envFilePath = path15.join(targetPath, ".env.example");
     if (existsSync3(envFilePath)) {
       existingFiles.push(".env.example");
     }
   }
   if (existsSync3(agentvDir)) {
     for (const template of otherAgentvTemplates) {
-      const targetFilePath = path14.join(agentvDir, template.path);
+      const targetFilePath = path15.join(agentvDir, template.path);
       if (existsSync3(targetFilePath)) {
-        existingFiles.push(path14.relative(targetPath, targetFilePath));
+        existingFiles.push(path15.relative(targetPath, targetFilePath));
       }
     }
   }
@@ -6608,18 +6972,18 @@ async function initCommand(options = {}) {
     mkdirSync(agentvDir, { recursive: true });
   }
   if (envTemplate) {
-    const envFilePath = path14.join(targetPath, ".env.example");
+    const envFilePath = path15.join(targetPath, ".env.example");
     writeFileSync2(envFilePath, envTemplate.content, "utf-8");
     console.log("Created .env.example");
   }
   for (const template of otherAgentvTemplates) {
-    const targetFilePath = path14.join(agentvDir, template.path);
-    const targetDirPath = path14.dirname(targetFilePath);
+    const targetFilePath = path15.join(agentvDir, template.path);
+    const targetDirPath = path15.dirname(targetFilePath);
     if (!existsSync3(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync2(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path14.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path15.relative(targetPath, targetFilePath)}`);
   }
   console.log("\nAgentV initialized successfully!");
   console.log("\nFiles installed to root:");
@@ -6627,7 +6991,7 @@ async function initCommand(options = {}) {
     console.log("  - .env.example");
   }
   console.log(`
-Files installed to ${path14.relative(targetPath, agentvDir)}:`);
+Files installed to ${path15.relative(targetPath, agentvDir)}:`);
   for (const t of otherAgentvTemplates) {
     console.log(`  - ${t.path}`);
   }
@@ -6659,13 +7023,13 @@ var initCmdTsCommand = command({
 
 // src/commands/inspect/filter.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 function collectIndexFiles(dir) {
   const files = [];
   try {
     const entries2 = readdirSync2(dir, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path15.join(dir, entry.name);
+      const fullPath = path16.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...collectIndexFiles(fullPath));
       } else if (entry.name === "index.jsonl") {
@@ -6718,7 +7082,7 @@ function parseFilterableRecords(filePath) {
     raw = normalizeResultRow(raw, { lineNumber: i + 1, sourceLabel: filePath });
     let experiment = typeof raw.experiment === "string" ? raw.experiment : void 0;
     if (!experiment) {
-      const parts = filePath.split(path15.sep);
+      const parts = filePath.split(path16.sep);
       const runsIdx = parts.indexOf("runs");
       if (runsIdx !== -1 && parts.length - runsIdx >= 3) {
         const candidate = parts[runsIdx + 1];
@@ -6773,7 +7137,7 @@ function buildFilterPredicate(opts) {
 }
 function discoverFilterSources(searchPath, cwd) {
   if (searchPath) {
-    const resolved = path15.isAbsolute(searchPath) ? searchPath : path15.resolve(cwd, searchPath);
+    const resolved = path16.isAbsolute(searchPath) ? searchPath : path16.resolve(cwd, searchPath);
     if (!existsSync4(resolved)) {
       console.error(`${c.red}Error:${c.reset} Path does not exist: ${resolved}`);
       process.exit(1);
@@ -6786,7 +7150,7 @@ function discoverFilterSources(searchPath, cwd) {
     }
     return [resolved];
   }
-  return collectIndexFiles(path15.join(cwd, ".agentv", "results", "runs"));
+  return collectIndexFiles(path16.join(cwd, ".agentv", "results", "runs"));
 }
 function formatFilterTable(records) {
   const lines = [];
@@ -7266,13 +7630,13 @@ var traceScoreCommand = command({
 
 // src/commands/inspect/search.ts
 import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 function collectJsonlFiles(dir) {
   const files = [];
   try {
     const entries2 = readdirSync3(dir, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path16.join(dir, entry.name);
+      const fullPath = path17.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...collectJsonlFiles(fullPath));
       } else if (entry.name.endsWith(".jsonl")) {
@@ -7331,7 +7695,7 @@ function searchJsonlFile(filePath, regex2, targetFilter, experimentFilter) {
 }
 function discoverSources(basePath, cwd) {
   if (basePath) {
-    const resolved = path16.isAbsolute(basePath) ? basePath : path16.resolve(cwd, basePath);
+    const resolved = path17.isAbsolute(basePath) ? basePath : path17.resolve(cwd, basePath);
     if (!existsSync5(resolved)) {
       console.error(`${c.red}Error:${c.reset} Path does not exist: ${resolved}`);
       process.exit(1);
@@ -7345,8 +7709,8 @@ function discoverSources(basePath, cwd) {
     return [resolved];
   }
   const sources = [];
-  sources.push(...collectJsonlFiles(path16.join(cwd, ".agentv", "results", "runs")));
-  sources.push(...collectJsonlFiles(path16.join(cwd, ".agentv", "transcripts")));
+  sources.push(...collectJsonlFiles(path17.join(cwd, ".agentv", "results", "runs")));
+  sources.push(...collectJsonlFiles(path17.join(cwd, ".agentv", "transcripts")));
   return sources;
 }
 function formatSearchResults(matches, pattern) {
@@ -8972,7 +9336,7 @@ var pipelineCommand = subcommands({
 
 // src/commands/prepare/index.ts
 import { cp, mkdir as mkdir10, rename, rm, writeFile as writeFile11 } from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 function setupStatusFromHook(status) {
   if (status === "success") {
     return "ok";
@@ -9019,10 +9383,10 @@ async function moveDirectory(sourcePath, destinationPath) {
 }
 async function placePreparedWorkspace(prepared, destinationPath) {
   const sourcePath = prepared.workspacePath;
-  if (path17.resolve(sourcePath) === path17.resolve(destinationPath)) {
+  if (path18.resolve(sourcePath) === path18.resolve(destinationPath)) {
     return destinationPath;
   }
-  await mkdir10(path17.dirname(destinationPath), { recursive: true });
+  await mkdir10(path18.dirname(destinationPath), { recursive: true });
   await rm(destinationPath, { recursive: true, force: true });
   if (prepared.cleanupPolicy.mode !== "static" && prepared.pool === void 0) {
     await moveDirectory(sourcePath, destinationPath);
@@ -9110,12 +9474,12 @@ async function selectPrepareTarget(options) {
   };
 }
 async function prepareAttempt(options) {
-  const evalPath = path17.resolve(options.evalPath);
-  const outDir = path17.resolve(options.outDir);
-  const evalDir = path17.dirname(evalPath);
+  const evalPath = path18.resolve(options.evalPath);
+  const outDir = path18.resolve(options.outDir);
+  const evalDir = path18.dirname(evalPath);
   const repoRoot = await findRepoRoot(evalDir);
   await loadEnvFromHierarchy({ testFilePath: evalPath, repoRoot, verbose: false });
-  const category = deriveCategory(path17.relative(process.cwd(), evalPath));
+  const category = deriveCategory(path18.relative(process.cwd(), evalPath));
   const suite = await loadTestSuite(evalPath, repoRoot, { category });
   const test = suite.tests.find((candidate) => candidate.id === options.testId);
   if (!test) {
@@ -9140,9 +9504,9 @@ async function prepareAttempt(options) {
     retainOnFailure: "keep"
   });
   await mkdir10(outDir, { recursive: true });
-  const workspacePath = await placePreparedWorkspace(prepared, path17.join(outDir, "workspace"));
-  const promptPath = path17.join(outDir, "prompt.md");
-  const manifestPath = path17.join(outDir, "agentv_prepare.json");
+  const workspacePath = await placePreparedWorkspace(prepared, path18.join(outDir, "workspace"));
+  const promptPath = path18.join(outDir, "prompt.md");
+  const manifestPath = path18.join(outDir, "agentv_prepare.json");
   const prompt = renderPrompt({
     workspacePath,
     target: options.target,
@@ -9231,7 +9595,7 @@ import {
   statSync as statSync4,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import path18 from "node:path";
+import path19 from "node:path";
 var CombineDuplicateError = class extends Error {
   constructor(conflicts) {
     super(`Duplicate result rows found for ${conflicts.length} (test_id, target) pair(s)`);
@@ -9247,7 +9611,7 @@ function readManifestRecords(manifestPath) {
 }
 function readBenchmarkMetadata(manifestPath) {
   try {
-    const benchmarkPath = path18.join(path18.dirname(manifestPath), "benchmark.json");
+    const benchmarkPath = path19.join(path19.dirname(manifestPath), "benchmark.json");
     const parsed = JSON.parse(readFileSync7(benchmarkPath, "utf8"));
     return {
       timestamp: parsed.metadata?.timestamp,
@@ -9366,7 +9730,7 @@ function defaultDisplayName(sources) {
 function defaultCombinedRunDir(cwd, startedAt) {
   const parsed = startedAt ? new Date(startedAt) : void 0;
   const timestamp = parsed && !Number.isNaN(parsed.getTime()) ? createRunDirName(parsed) : sanitizePathSegment(startedAt ?? "unknown-time");
-  return path18.join(cwd, ".agentv", "results", "runs", "combined", timestamp);
+  return path19.join(cwd, ".agentv", "results", "runs", "combined", timestamp);
 }
 function uniqueRunDir(baseDir) {
   if (!existsSync8(baseDir)) return baseDir;
@@ -9377,13 +9741,13 @@ function uniqueRunDir(baseDir) {
   return `${baseDir}-${suffix}`;
 }
 function toRunId(cwd, runDir) {
-  const runsRoot = path18.join(cwd, ".agentv", "results", "runs");
-  const relative3 = path18.relative(runsRoot, runDir);
-  if (relative3 === "" || relative3.startsWith("..") || path18.isAbsolute(relative3)) {
-    return path18.basename(runDir);
+  const runsRoot = path19.join(cwd, ".agentv", "results", "runs");
+  const relative3 = path19.relative(runsRoot, runDir);
+  if (relative3 === "" || relative3.startsWith("..") || path19.isAbsolute(relative3)) {
+    return path19.basename(runDir);
   }
-  const parts = relative3.split(path18.sep);
-  return parts.length > 1 ? `${parts[0]}::${parts.slice(1).join(path18.sep)}` : relative3;
+  const parts = relative3.split(path19.sep);
+  return parts.length > 1 ? `${parts[0]}::${parts.slice(1).join(path19.sep)}` : relative3;
 }
 var MANIFEST_PATH_FIELDS = [
   "grading_path",
@@ -9399,17 +9763,17 @@ var MANIFEST_PATH_FIELDS = [
 ];
 function copyReferencedArtifact(sourceBaseDir, outputDir, sourceIndex, relativePath) {
   if (!relativePath) return void 0;
-  if (path18.isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes("..")) {
+  if (path19.isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes("..")) {
     throw new Error(`Unsafe artifact path in source manifest: ${relativePath}`);
   }
-  const sourcePath = path18.join(sourceBaseDir, relativePath);
+  const sourcePath = path19.join(sourceBaseDir, relativePath);
   if (!existsSync8(sourcePath)) {
     return relativePath;
   }
-  const rewritten = path18.posix.join(`sources/source-${sourceIndex + 1}`, relativePath);
-  const destPath = path18.join(outputDir, rewritten);
+  const rewritten = path19.posix.join(`sources/source-${sourceIndex + 1}`, relativePath);
+  const destPath = path19.join(outputDir, rewritten);
   const sourceStat = statSync4(sourcePath);
-  mkdirSync2(path18.dirname(destPath), { recursive: true });
+  mkdirSync2(path19.dirname(destPath), { recursive: true });
   if (sourceStat.isDirectory()) {
     cpSync(sourcePath, destPath, { recursive: true });
   } else if (sourceStat.isFile()) {
@@ -9418,7 +9782,7 @@ function copyReferencedArtifact(sourceBaseDir, outputDir, sourceIndex, relativeP
   return rewritten;
 }
 function rewriteAndCopyRecord(row, outputDir) {
-  const sourceBaseDir = path18.dirname(row.source.manifestPath);
+  const sourceBaseDir = path19.dirname(row.source.manifestPath);
   const rewritten = { ...row.record };
   for (const field of MANIFEST_PATH_FIELDS) {
     rewritten[field] = copyReferencedArtifact(
@@ -9446,8 +9810,8 @@ function buildCombineRunSources(sourcePaths, cwd, options) {
   return sourcePaths.map((sourcePath, index) => {
     const manifestPath = resolveResultSourcePath(sourcePath, cwd);
     return {
-      id: options?.ids?.[index] ?? path18.basename(path18.dirname(manifestPath)),
-      displayName: options?.displayNames?.[index] ?? path18.basename(path18.dirname(manifestPath)),
+      id: options?.ids?.[index] ?? path19.basename(path19.dirname(manifestPath)),
+      displayName: options?.displayNames?.[index] ?? path19.basename(path19.dirname(manifestPath)),
       manifestPath,
       tags: options?.tags?.[index]
     };
@@ -9461,7 +9825,7 @@ function combineRunSources(options) {
   const startedAt = earliestTimestamp(loadedSources.map((source) => source.startedAt));
   const displayName = options.displayName?.trim() || defaultDisplayName(loadedSources);
   const runDir = uniqueRunDir(
-    options.outputDir ? path18.resolve(options.cwd, options.outputDir) : defaultCombinedRunDir(options.cwd, startedAt)
+    options.outputDir ? path19.resolve(options.cwd, options.outputDir) : defaultCombinedRunDir(options.cwd, startedAt)
   );
   const { rows, conflicts } = selectRows(
     loadedSources,
@@ -9475,10 +9839,10 @@ function combineRunSources(options) {
   });
   mkdirSync2(runDir, { recursive: true });
   const records = rows.map((row) => rewriteAndCopyRecord(row, runDir));
-  const manifestPath = path18.join(runDir, "index.jsonl");
+  const manifestPath = path19.join(runDir, "index.jsonl");
   writeJsonl(manifestPath, records);
   const timing = buildTimingArtifact(results);
-  const timingPath = path18.join(runDir, "timing.json");
+  const timingPath = path19.join(runDir, "timing.json");
   writeJson3(timingPath, timing);
   const benchmark = buildBenchmarkArtifact(results, "", "combined", results.length);
   const benchmarkWithMetadata = {
@@ -9492,7 +9856,7 @@ function combineRunSources(options) {
       duplicate_policy: options.duplicatePolicy
     }
   };
-  const benchmarkPath = path18.join(runDir, "benchmark.json");
+  const benchmarkPath = path19.join(runDir, "benchmark.json");
   writeJson3(benchmarkPath, benchmarkWithMetadata);
   const tags = [...new Set(loadedSources.flatMap((source) => source.tags ?? []))].sort();
   return {
@@ -9628,19 +9992,19 @@ import * as readline3 from "node:readline/promises";
 
 // src/commands/results/delete-run.ts
 import { existsSync as existsSync9, rmSync } from "node:fs";
-import path19 from "node:path";
+import path20 from "node:path";
 function localRunsRoot(cwd) {
-  return path19.resolve(cwd, ".agentv", "results", "runs");
+  return path20.resolve(cwd, ".agentv", "results", "runs");
 }
 function assertLocalRunManifest(cwd, manifestPath, runId) {
-  const resolvedManifestPath = path19.resolve(manifestPath);
-  if (path19.basename(resolvedManifestPath) !== RESULT_INDEX_FILENAME) {
+  const resolvedManifestPath = path20.resolve(manifestPath);
+  if (path20.basename(resolvedManifestPath) !== RESULT_INDEX_FILENAME) {
     throw new Error("Expected a run workspace directory or index.jsonl manifest");
   }
-  const runDir = path19.dirname(resolvedManifestPath);
+  const runDir = path20.dirname(resolvedManifestPath);
   const runsRoot = localRunsRoot(cwd);
-  const relativeRunDir = path19.relative(runsRoot, runDir);
-  if (relativeRunDir === "" || relativeRunDir.startsWith("..") || path19.isAbsolute(relativeRunDir)) {
+  const relativeRunDir = path20.relative(runsRoot, runDir);
+  if (relativeRunDir === "" || relativeRunDir.startsWith("..") || path20.isAbsolute(relativeRunDir)) {
     throw new Error("Run workspace is outside the local results directory");
   }
   if (!existsSync9(resolvedManifestPath)) {
@@ -9726,7 +10090,7 @@ var resultsDeleteCommand = command({
 });
 
 // src/commands/results/export.ts
-import path20 from "node:path";
+import path21 from "node:path";
 
 // src/commands/results/shared.ts
 import { existsSync as existsSync10 } from "node:fs";
@@ -9773,20 +10137,20 @@ async function loadResults(source, cwd) {
 
 // src/commands/results/export.ts
 function deriveOutputDir(cwd, sourceFile) {
-  if (path20.basename(sourceFile) !== RESULT_INDEX_FILENAME) {
+  if (path21.basename(sourceFile) !== RESULT_INDEX_FILENAME) {
     throw new Error(`Expected a run manifest named ${RESULT_INDEX_FILENAME}: ${sourceFile}`);
   }
-  const runDir = path20.dirname(sourceFile);
-  const segments = path20.normalize(runDir).split(path20.sep).filter(Boolean);
+  const runDir = path21.dirname(sourceFile);
+  const segments = path21.normalize(runDir).split(path21.sep).filter(Boolean);
   const runsIndex = segments.lastIndexOf("runs");
   if (runsIndex >= 0 && runsIndex < segments.length - 1) {
-    return path20.join(cwd, ".agentv", "results", "export", ...segments.slice(runsIndex + 1));
+    return path21.join(cwd, ".agentv", "results", "export", ...segments.slice(runsIndex + 1));
   }
-  const parentDir = path20.basename(runDir);
+  const parentDir = path21.basename(runDir);
   if (parentDir.startsWith("eval_")) {
-    return path20.join(cwd, ".agentv", "results", "export", parentDir.slice(5));
+    return path21.join(cwd, ".agentv", "results", "export", parentDir.slice(5));
   }
-  return path20.join(cwd, ".agentv", "results", "export", parentDir);
+  return path21.join(cwd, ".agentv", "results", "export", parentDir);
 }
 async function loadExportSource(source, cwd) {
   const { sourceFile } = await resolveSourceFile(source, cwd);
@@ -9819,7 +10183,7 @@ var resultsExportCommand = command({
     const cwd = dir ?? process.cwd();
     try {
       const { sourceFile, results } = await loadExportSource(source, cwd);
-      const outputDir = out ? path20.isAbsolute(out) ? out : path20.resolve(cwd, out) : deriveOutputDir(cwd, sourceFile);
+      const outputDir = out ? path21.isAbsolute(out) ? out : path21.resolve(cwd, out) : deriveOutputDir(cwd, sourceFile);
       await writeArtifactsFromResults2(results, outputDir, {
         evalFile: sourceFile
       });
@@ -9880,7 +10244,7 @@ var resultsFailuresCommand = command({
 
 // src/commands/results/report.ts
 import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "node:fs";
-import path21 from "node:path";
+import path22 from "node:path";
 
 // src/commands/results/report-template.ts
 var RESULTS_REPORT_TEMPLATE = `<!DOCTYPE html>
@@ -11504,10 +11868,10 @@ function normalizeEvalFileLabel(value) {
   if (!trimmed) {
     return void 0;
   }
-  return path21.basename(trimmed).replace(/\.results\.jsonl$/i, "").replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "").replace(/\.jsonl$/i, "");
+  return path22.basename(trimmed).replace(/\.results\.jsonl$/i, "").replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "").replace(/\.jsonl$/i, "");
 }
 function readBenchmarkEvalFile(sourceFile) {
-  const benchmarkPath = path21.join(path21.dirname(sourceFile), "benchmark.json");
+  const benchmarkPath = path22.join(path22.dirname(sourceFile), "benchmark.json");
   if (!existsSync11(benchmarkPath)) {
     return void 0;
   }
@@ -11519,10 +11883,10 @@ function readBenchmarkEvalFile(sourceFile) {
   }
 }
 function deriveReportPath(sourceFile) {
-  return path21.join(path21.dirname(sourceFile), "report.html");
+  return path22.join(path22.dirname(sourceFile), "report.html");
 }
 function serializeReportResult(result, sourceFile, manifestRecord, benchmarkEvalFile) {
-  const fallbackEvalFile = normalizeEvalFileLabel(manifestRecord?.eval_file) ?? benchmarkEvalFile ?? normalizeEvalFileLabel(result.suite) ?? path21.basename(path21.dirname(sourceFile));
+  const fallbackEvalFile = normalizeEvalFileLabel(manifestRecord?.eval_file) ?? benchmarkEvalFile ?? normalizeEvalFileLabel(result.suite) ?? path22.basename(path22.dirname(sourceFile));
   return {
     timestamp: result.timestamp,
     test_id: result.testId,
@@ -11570,9 +11934,9 @@ function renderResultsReport(results, sourceFile, records, benchmarkEvalFile) {
 }
 async function writeResultsReport(source, outputPath, cwd) {
   const { sourceFile, results, records, benchmarkEvalFile } = await loadReportSource(source, cwd);
-  const resolvedOutputPath = outputPath ? path21.isAbsolute(outputPath) ? outputPath : path21.resolve(cwd, outputPath) : deriveReportPath(sourceFile);
+  const resolvedOutputPath = outputPath ? path22.isAbsolute(outputPath) ? outputPath : path22.resolve(cwd, outputPath) : deriveReportPath(sourceFile);
   const html = renderResultsReport(results, sourceFile, records, benchmarkEvalFile);
-  mkdirSync3(path21.dirname(resolvedOutputPath), { recursive: true });
+  mkdirSync3(path22.dirname(resolvedOutputPath), { recursive: true });
   writeFileSync4(resolvedOutputPath, html, "utf8");
   const written = readFileSync8(resolvedOutputPath, "utf8");
   if (written.includes("__DATA_PLACEHOLDER__")) {
@@ -11760,10 +12124,10 @@ var resultsSummaryCommand = command({
 
 // src/commands/results/validate.ts
 import { existsSync as existsSync13, readFileSync as readFileSync10, statSync as statSync5 } from "node:fs";
-import path22 from "node:path";
+import path23 from "node:path";
 function checkDirectoryNaming(runDir) {
-  const dirName = path22.basename(runDir);
-  const pathSegments = path22.normalize(runDir).split(path22.sep).filter(Boolean);
+  const dirName = path23.basename(runDir);
+  const pathSegments = path23.normalize(runDir).split(path23.sep).filter(Boolean);
   const runsIndex = pathSegments.lastIndexOf("runs");
   const diagnostics = [];
   if (runsIndex < 0 || runsIndex >= pathSegments.length - 1) {
@@ -11793,7 +12157,7 @@ function validateRunDirectory(runDir) {
   return { diagnostics, entries: entries2 };
 }
 function checkIndexJsonl(runDir) {
-  const indexPath = path22.join(runDir, "index.jsonl");
+  const indexPath = path23.join(runDir, "index.jsonl");
   const diagnostics = [];
   const entries2 = [];
   if (!existsSync13(indexPath)) {
@@ -11892,7 +12256,7 @@ function checkArtifactFiles(runDir, entries2) {
   for (const entry of entries2) {
     const testId = entry.test_id ?? "?";
     if (entry.grading_path) {
-      const gradingPath = path22.join(runDir, entry.grading_path);
+      const gradingPath = path23.join(runDir, entry.grading_path);
       if (!existsSync13(gradingPath)) {
         diagnostics.push({
           severity: "error",
@@ -11922,7 +12286,7 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
     if (entry.timing_path) {
-      const timingPath = path22.join(runDir, entry.timing_path);
+      const timingPath = path23.join(runDir, entry.timing_path);
       if (!existsSync13(timingPath)) {
         diagnostics.push({
           severity: "warning",
@@ -11931,7 +12295,7 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
   }
-  const benchmarkPath = path22.join(runDir, "benchmark.json");
+  const benchmarkPath = path23.join(runDir, "benchmark.json");
   if (!existsSync13(benchmarkPath)) {
     diagnostics.push({ severity: "warning", message: "benchmark.json is missing" });
   }
@@ -11948,7 +12312,7 @@ var resultsValidateCommand = command({
     })
   },
   handler: async ({ runDir }) => {
-    const resolvedDir = path22.resolve(runDir);
+    const resolvedDir = path23.resolve(runDir);
     if (!existsSync13(resolvedDir) || !statSync5(resolvedDir).isDirectory()) {
       console.error(`Error: '${runDir}' is not a directory`);
       process.exit(1);
@@ -11994,14 +12358,14 @@ var resultsCommand = subcommands({
 
 // src/commands/results/serve.ts
 import { existsSync as existsSync16, readFileSync as readFileSync12, readdirSync as readdirSync4, statSync as statSync6, writeFileSync as writeFileSync6 } from "node:fs";
-import path25 from "node:path";
+import path26 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { Hono } from "hono";
 
 // src/commands/results/eval-runner.ts
 import { execFileSync as execFileSync2, spawn } from "node:child_process";
 import { createWriteStream, existsSync as existsSync14, mkdirSync as mkdirSync4 } from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var activeRuns = /* @__PURE__ */ new Map();
 function generateRunId() {
@@ -12021,7 +12385,7 @@ function pruneFinishedRuns() {
 }
 function getActiveRunTarget(indexJsonlPath) {
   for (const run2 of activeRuns.values()) {
-    if (run2.outputDir && path23.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
+    if (run2.outputDir && path24.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
       return run2.target;
     }
   }
@@ -12029,7 +12393,7 @@ function getActiveRunTarget(indexJsonlPath) {
 }
 function getActiveRunStatus(indexJsonlPath) {
   for (const run2 of activeRuns.values()) {
-    if (run2.outputDir && path23.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
+    if (run2.outputDir && path24.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
       return run2.status;
     }
   }
@@ -12039,7 +12403,7 @@ async function discoverTargetsInProject(cwd) {
   const repoRoot = await findRepoRoot(cwd) ?? cwd;
   let targetsFilePath;
   for (const candidate of TARGET_FILE_CANDIDATES) {
-    const fullPath = path23.join(cwd, candidate);
+    const fullPath = path24.join(cwd, candidate);
     if (existsSync14(fullPath)) {
       targetsFilePath = fullPath;
       break;
@@ -12047,7 +12411,7 @@ async function discoverTargetsInProject(cwd) {
   }
   if (!targetsFilePath) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const fullPath = path23.join(repoRoot, candidate);
+      const fullPath = path24.join(repoRoot, candidate);
       if (existsSync14(fullPath)) {
         targetsFilePath = fullPath;
         break;
@@ -12121,17 +12485,17 @@ function buildCliPreview(args) {
 }
 function resolveCliPath(cwd) {
   const candidates = [
-    path23.join(cwd, "apps/cli/src/cli.ts"),
-    path23.join(cwd, "apps/cli/dist/cli.js")
+    path24.join(cwd, "apps/cli/src/cli.ts"),
+    path24.join(cwd, "apps/cli/dist/cli.js")
   ];
   for (const c4 of candidates) {
     if (existsSync14(c4)) {
       return { binPath: "bun", args: [c4] };
     }
   }
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path23.dirname(fileURLToPath2(import.meta.url));
-  const fromSrc = path23.resolve(currentDir, "../../cli.ts");
-  const fromDist = path23.resolve(currentDir, "cli.js");
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path24.dirname(fileURLToPath2(import.meta.url));
+  const fromSrc = path24.resolve(currentDir, "../../cli.ts");
+  const fromDist = path24.resolve(currentDir, "cli.js");
   if (existsSync14(fromSrc)) return { binPath: "bun", args: [fromSrc] };
   if (existsSync14(fromDist)) return { binPath: "bun", args: [fromDist] };
   if (isCommandAvailable("agentv")) {
@@ -12150,7 +12514,7 @@ function isCommandAvailable(cmd) {
 function openConsoleLogStream(outputDir) {
   try {
     mkdirSync4(outputDir, { recursive: true });
-    const stream = createWriteStream(path23.join(outputDir, "console.log"), { flags: "w" });
+    const stream = createWriteStream(path24.join(outputDir, "console.log"), { flags: "w" });
     stream.on("error", () => {
     });
     return stream;
@@ -12207,7 +12571,7 @@ function registerEvalRoutes(app2, getCwd, options) {
       return c4.json({ error: "Cannot locate agentv CLI entry point" }, 500);
     }
     const args = buildCliArgs(body);
-    const outputDir = body.output?.trim() ? path23.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
+    const outputDir = body.output?.trim() ? path24.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
     if (!body.output?.trim()) {
       args.push("--output", outputDir);
     }
@@ -12385,7 +12749,7 @@ Process error: ${err2.message}
       return c4.json({ error: "Cannot locate agentv CLI entry point" }, 500);
     }
     const args = buildCliArgs(body);
-    const outputDir = body.output?.trim() ? path23.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
+    const outputDir = body.output?.trim() ? path24.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
     if (!body.output?.trim()) {
       args.push("--output", outputDir);
     }
@@ -12508,17 +12872,17 @@ Process error: ${err2.message}
 
 // src/commands/results/studio-config.ts
 import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 import { stringify as stringifyYaml3 } from "yaml";
 var DEFAULTS = {
   threshold: DEFAULT_THRESHOLD,
   appName: "agentv"
 };
 function loadStudioConfig(agentvDir) {
-  const localConfigPath = path24.join(agentvDir, "config.yaml");
-  const globalConfigPath = path24.join(getAgentvConfigDir(), "config.yaml");
+  const localConfigPath = path25.join(agentvDir, "config.yaml");
+  const globalConfigPath = path25.join(getAgentvConfigDir(), "config.yaml");
   const localConfig = loadParsedConfig(localConfigPath);
-  const globalConfig = path24.resolve(globalConfigPath) === path24.resolve(localConfigPath) ? void 0 : loadParsedConfig(globalConfigPath);
+  const globalConfig = path25.resolve(globalConfigPath) === path25.resolve(localConfigPath) ? void 0 : loadParsedConfig(globalConfigPath);
   const threshold = [
     readThreshold(localConfig?.dashboard),
     readThreshold(localConfig?.studio),
@@ -12558,7 +12922,7 @@ function saveStudioConfig(agentvDir, config) {
   if (!existsSync15(agentvDir)) {
     mkdirSync5(agentvDir, { recursive: true });
   }
-  const configPath = path24.join(agentvDir, "config.yaml");
+  const configPath = path25.join(agentvDir, "config.yaml");
   let existing = {};
   if (existsSync15(configPath)) {
     const raw = readFileSync11(configPath, "utf-8");
@@ -12590,14 +12954,23 @@ function saveStudioConfig(agentvDir, config) {
 }
 
 // src/commands/results/serve.ts
+var DIRECT_DASHBOARD_SOURCE_GUIDANCE = [
+  "Dashboard reads configured project run sources only.",
+  "Run it from a project root, or pass --dir so Dashboard uses <project>/.agentv/results/runs/:",
+  "  agentv dashboard --dir <project-dir>",
+  "To browse external results, configure results.repo_url or results.repo_path in config YAML.",
+  "For a one-off run bundle, use: agentv results report <run-workspace-or-index.jsonl>"
+].join("\n");
+function unsupportedDashboardSourceError(source, cwd) {
+  const resolved = path26.isAbsolute(source) ? source : path26.resolve(cwd, source);
+  return new Error(
+    `Unsupported Dashboard source: ${resolved}
+${DIRECT_DASHBOARD_SOURCE_GUIDANCE}`
+  );
+}
 async function resolveSourceFile2(source, cwd) {
   if (source) {
-    let resolved = resolveResultSourcePath(source, cwd);
-    if (!existsSync16(resolved)) {
-      throw new Error(`Source file not found: ${resolved}`);
-    }
-    resolved = resolveRunManifestPath(resolved);
-    return resolved;
+    throw unsupportedDashboardSourceError(source, cwd);
   }
   const cache = await loadRunCache(cwd);
   const cachedFile = cache ? resolveRunCacheFile(cache) : "";
@@ -12629,13 +13002,13 @@ function resolveDashboardMode(_projectCount, options) {
 }
 function bootstrapCurrentProject(cwd, options) {
   if (options.single === true) return {};
-  if (!existsSync16(path25.join(cwd, ".agentv"))) return {};
+  if (!existsSync16(path26.join(cwd, ".agentv"))) return {};
   const entry = addProject(cwd);
   touchProject(entry.id);
   return { currentProjectId: entry.id };
 }
 function feedbackPath(resultDir) {
-  return path25.join(resultDir, "feedback.json");
+  return path26.join(resultDir, "feedback.json");
 }
 function readFeedback(cwd) {
   const fp = feedbackPath(cwd);
@@ -12662,8 +13035,8 @@ function buildFileTree(dirPath, relativeTo) {
     if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
     return a.name.localeCompare(b.name);
   }).map((entry) => {
-    const fullPath = path25.join(dirPath, entry.name);
-    const relPath = path25.relative(relativeTo, fullPath);
+    const fullPath = path26.join(dirPath, entry.name);
+    const relPath = path26.relative(relativeTo, fullPath);
     if (entry.isDirectory()) {
       return {
         name: entry.name,
@@ -12676,7 +13049,7 @@ function buildFileTree(dirPath, relativeTo) {
   });
 }
 function inferLanguage(filePath) {
-  const ext = path25.extname(filePath).toLowerCase();
+  const ext = path26.extname(filePath).toLowerCase();
   const langMap = {
     ".json": "json",
     ".jsonl": "json",
@@ -12703,14 +13076,14 @@ function inferLanguage(filePath) {
   return langMap[ext] ?? "plaintext";
 }
 function inferRawContentType(filePath) {
-  const ext = path25.extname(filePath).toLowerCase();
+  const ext = path26.extname(filePath).toLowerCase();
   if (ext === ".json") return "application/json; charset=utf-8";
   if (ext === ".jsonl") return "text/plain; charset=utf-8";
   if (ext === ".md") return "text/markdown; charset=utf-8";
   return "text/plain; charset=utf-8";
 }
 function contentDispositionFilename(filePath) {
-  return path25.basename(filePath).replace(/["\\\r\n]/g, "_");
+  return path26.basename(filePath).replace(/["\\\r\n]/g, "_");
 }
 function stripHeavyFields(results) {
   return results.map((r) => {
@@ -12930,7 +13303,7 @@ async function handleRunLog(c4, { searchDir, projectId }) {
   if (meta.source === "remote") {
     return c4.json({ error: "Run log is not available for remote runs" }, 404);
   }
-  const logPath = path25.join(path25.dirname(meta.path), "console.log");
+  const logPath = path26.join(path26.dirname(meta.path), "console.log");
   if (!existsSync16(logPath)) {
     return c4.json({ error: "Run log not found for this run" }, 404);
   }
@@ -12964,11 +13337,11 @@ async function handleRunDetail(c4, { searchDir, projectId }) {
 }
 function deriveResumeMeta(cwd, manifestPath) {
   const out = {};
-  const runDir = path25.dirname(manifestPath);
-  const relative3 = path25.relative(cwd, runDir);
+  const runDir = path26.dirname(manifestPath);
+  const relative3 = path26.relative(cwd, runDir);
   out.run_dir = relative3 !== "" && !relative3.startsWith("..") ? relative3 : runDir;
   try {
-    const benchmarkPath = path25.join(runDir, "benchmark.json");
+    const benchmarkPath = path26.join(runDir, "benchmark.json");
     if (existsSync16(benchmarkPath)) {
       const parsed = JSON.parse(readFileSync12(benchmarkPath, "utf8"));
       const evalFile = parsed.metadata?.eval_file;
@@ -13105,7 +13478,7 @@ async function handleEvalFiles(c4, { searchDir, projectId }) {
     const records = await parseManifestForMeta(searchDir, meta, projectId);
     const record = records.find((r) => r.test_id === evalId);
     if (!record) return c4.json({ error: "Eval not found" }, 404);
-    const baseDir = path25.dirname(meta.path);
+    const baseDir = path26.dirname(meta.path);
     const knownPaths = [
       record.grading_path,
       record.timing_path,
@@ -13121,14 +13494,14 @@ async function handleEvalFiles(c4, { searchDir, projectId }) {
       record.graders_path
     ].filter((p) => !!p);
     if (knownPaths.length === 0) return c4.json({ files: [] });
-    const artifactDirs = knownPaths.map((p) => path25.dirname(p));
+    const artifactDirs = knownPaths.map((p) => path26.dirname(p));
     let commonDir = artifactDirs[0];
     for (const dir of artifactDirs) {
       while (!dir.startsWith(commonDir)) {
-        commonDir = path25.dirname(commonDir);
+        commonDir = path26.dirname(commonDir);
       }
     }
-    const artifactAbsDir = path25.join(baseDir, commonDir);
+    const artifactAbsDir = path26.join(baseDir, commonDir);
     const files = buildFileTree(artifactAbsDir, baseDir);
     return c4.json({ files });
   } catch {
@@ -13150,9 +13523,9 @@ async function handleEvalFileContent(c4, { searchDir, projectId }) {
   }
   if (!filePath) return c4.json({ error: "No file path specified" }, 400);
   await ensureRunReadable(searchDir, meta, projectId);
-  const baseDir = path25.dirname(meta.path);
-  const absolutePath = path25.resolve(baseDir, filePath);
-  if (!absolutePath.startsWith(path25.resolve(baseDir) + path25.sep) && absolutePath !== path25.resolve(baseDir)) {
+  const baseDir = path26.dirname(meta.path);
+  const absolutePath = path26.resolve(baseDir, filePath);
+  if (!absolutePath.startsWith(path26.resolve(baseDir) + path26.sep) && absolutePath !== path26.resolve(baseDir)) {
     return c4.json({ error: "Path traversal not allowed" }, 403);
   }
   if (!existsSync16(absolutePath) || !statSync6(absolutePath).isFile()) {
@@ -13423,13 +13796,13 @@ function handleConfig(c4, { agentvDir, searchDir }, options) {
     threshold: config.threshold,
     app_name: config.appName,
     read_only: options?.readOnly === true,
-    project_name: path25.basename(searchDir),
+    project_name: path26.basename(searchDir),
     project_dashboard: options?.projectDashboard === true,
     ...options?.currentProjectId && { current_project_id: options.currentProjectId }
   });
 }
 function handleFeedbackRead(c4, { searchDir }) {
-  const resultsDir = path25.join(searchDir, ".agentv", "results");
+  const resultsDir = path26.join(searchDir, ".agentv", "results");
   return c4.json(readFeedback(existsSync16(resultsDir) ? resultsDir : searchDir));
 }
 async function handleRunTagsPut(c4, { searchDir, projectId }) {
@@ -13499,7 +13872,7 @@ async function handleRunDelete(c4, { searchDir, projectId }) {
   }
 }
 function getLocalRunsRoot(searchDir) {
-  return path25.join(searchDir, ".agentv", "results", "runs");
+  return path26.join(searchDir, ".agentv", "results", "runs");
 }
 function validateLocalCompletedRun(searchDir, meta, actionName = "Run combine") {
   if (meta.source === "remote") {
@@ -13508,13 +13881,13 @@ function validateLocalCompletedRun(searchDir, meta, actionName = "Run combine")
   if (getActiveRunStatus(meta.path) === "starting" || getActiveRunStatus(meta.path) === "running") {
     return { error: "Run is still active", status: 409 };
   }
-  const manifestPath = path25.resolve(meta.path);
-  if (path25.basename(manifestPath) !== "index.jsonl") {
+  const manifestPath = path26.resolve(meta.path);
+  if (path26.basename(manifestPath) !== "index.jsonl") {
     return { error: "Run workspace is invalid", status: 400 };
   }
-  const runDir = path25.dirname(manifestPath);
-  const runsRoot = path25.resolve(getLocalRunsRoot(searchDir));
-  if (runDir !== runsRoot && runDir.startsWith(`${runsRoot}${path25.sep}`) && existsSync16(runDir)) {
+  const runDir = path26.dirname(manifestPath);
+  const runsRoot = path26.resolve(getLocalRunsRoot(searchDir));
+  if (runDir !== runsRoot && runDir.startsWith(`${runsRoot}${path26.sep}`) && existsSync16(runDir)) {
     return { ok: true };
   }
   return { error: "Run workspace is outside the local results directory", status: 400 };
@@ -13596,7 +13969,7 @@ async function handleRunsCombine(c4, { searchDir, projectId }) {
 }
 function createApp(results, resultDir, cwd, sourceFile, options) {
   const searchDir = cwd ?? resultDir;
-  const agentvDir = path25.join(searchDir, ".agentv");
+  const agentvDir = path26.join(searchDir, ".agentv");
   const defaultCtx = { searchDir, agentvDir, projectId: options?.currentProjectId };
   const readOnly = options?.readOnly === true;
   const app2 = new Hono();
@@ -13607,7 +13980,7 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     }
     return handler(c4, {
       searchDir: project.path,
-      agentvDir: path25.join(project.path, ".agentv"),
+      agentvDir: path26.join(project.path, ".agentv"),
       projectId: project.id
     });
   }
@@ -13639,7 +14012,7 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
   }
   async function summarizeProjectRunMetas(project) {
     const { runs: metas } = await listMergedResultFiles(project.path, void 0, project.id);
-    const threshold = loadStudioConfig(path25.join(project.path, ".agentv")).threshold;
+    const threshold = loadStudioConfig(path26.join(project.path, ".agentv")).threshold;
     let passRateSum = 0;
     let executionErrorCount = 0;
     for (const meta of metas) {
@@ -13735,7 +14108,7 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
             if (records.length > 0) {
               const qualitySummary = summarizeQualityResults(
                 records,
-                loadStudioConfig(path25.join(p.path, ".agentv")).threshold
+                loadStudioConfig(path26.join(p.path, ".agentv")).threshold
               );
               target = records[0].target;
               experiment = records[0].experiment ?? experiment;
@@ -14005,22 +14378,22 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     { readOnly }
   );
   const studioDistPath = options?.studioDir ?? resolveStudioDistDir();
-  if (!studioDistPath || !existsSync16(path25.join(studioDistPath, "index.html"))) {
+  if (!studioDistPath || !existsSync16(path26.join(studioDistPath, "index.html"))) {
     throw new Error(
       'Dashboard dist not found. Run "bun run build" in apps/dashboard/ to build the SPA.'
     );
   }
   app2.get("/", (c4) => {
-    const indexPath = path25.join(studioDistPath, "index.html");
+    const indexPath = path26.join(studioDistPath, "index.html");
     if (existsSync16(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
     return c4.notFound();
   });
   app2.get("/assets/*", (c4) => {
     const assetPath = c4.req.path;
-    const filePath = path25.join(studioDistPath, assetPath);
+    const filePath = path26.join(studioDistPath, assetPath);
     if (!existsSync16(filePath)) return c4.notFound();
     const content = readFileSync12(filePath);
-    const ext = path25.extname(filePath);
+    const ext = path26.extname(filePath);
     const mimeTypes = {
       ".js": "application/javascript",
       ".css": "text/css",
@@ -14041,26 +14414,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 = path25.join(studioDistPath, "index.html");
+    const indexPath = path26.join(studioDistPath, "index.html");
     if (existsSync16(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
     return c4.notFound();
   });
   return app2;
 }
 function resolveStudioDistDir() {
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path25.dirname(fileURLToPath3(import.meta.url));
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path26.dirname(fileURLToPath3(import.meta.url));
   const candidates = [
     // From src/commands/results/ → sibling apps/dashboard/dist
-    path25.resolve(currentDir, "../../../../dashboard/dist"),
+    path26.resolve(currentDir, "../../../../dashboard/dist"),
     // From dist/ → sibling apps/dashboard/dist (monorepo dev)
-    path25.resolve(currentDir, "../../dashboard/dist"),
+    path26.resolve(currentDir, "../../dashboard/dist"),
     // Bundled inside CLI dist (published package: dist/dashboard/)
-    path25.resolve(currentDir, "dashboard"),
+    path26.resolve(currentDir, "dashboard"),
     // From dist/ in monorepo root context
-    path25.resolve(currentDir, "../../../apps/dashboard/dist")
+    path26.resolve(currentDir, "../../../apps/dashboard/dist")
   ];
   for (const candidate of candidates) {
-    if (existsSync16(candidate) && existsSync16(path25.join(candidate, "index.html"))) {
+    if (existsSync16(candidate) && existsSync16(path26.join(candidate, "index.html"))) {
       return candidate;
     }
   }
@@ -14073,7 +14446,7 @@ var resultsServeCommand = command({
     source: positional({
       type: optional(string),
       displayName: "source",
-      description: "Run workspace directory or index.jsonl manifest to serve (defaults to most recent in .agentv/results/runs/)"
+      description: "Legacy direct run source (unsupported); use --dir <project-dir> or results: config"
     }),
     port: option({
       type: optional(number),
@@ -14130,7 +14503,7 @@ var resultsServeCommand = command({
       return;
     }
     const repoRoot = await findRepoRoot(cwd);
-    const yamlConfig = await loadConfig(path25.join(cwd, "_"), repoRoot);
+    const yamlConfig = await loadConfig(path26.join(cwd, "_"), repoRoot);
     if (yamlConfig?.required_version) {
       await enforceRequiredVersion(yamlConfig.required_version);
     }
@@ -14160,7 +14533,7 @@ var resultsServeCommand = command({
           }
         }
       }
-      const resultDir = sourceFile ? path25.dirname(path25.resolve(sourceFile)) : cwd;
+      const resultDir = sourceFile ? path26.dirname(path26.resolve(sourceFile)) : cwd;
       const app2 = createApp(results, resultDir, cwd, sourceFile, {
         readOnly,
         projectDashboard,
@@ -14197,7 +14570,7 @@ var resultsServeCommand = command({
 // src/commands/runs/rerun.ts
 import { constants } from "node:fs";
 import { access, readFile as readFile8 } from "node:fs/promises";
-import path26 from "node:path";
+import path27 from "node:path";
 import { config as loadDotenv } from "dotenv";
 var TASK_EVAL_FILENAME = "EVAL.yaml";
 var TASK_TARGETS_FILENAME = "targets.yaml";
@@ -14209,13 +14582,13 @@ function displayRecord(record) {
   return `${record.test_id ?? "unknown"}@${record.target ?? "unknown"}`;
 }
 function resolveSourcePath(cwd, source) {
-  return path26.isAbsolute(source) ? source : path26.resolve(cwd, source);
+  return path27.isAbsolute(source) ? source : path27.resolve(cwd, source);
 }
 function resolveRelativeRunPath(runDir, relativePath) {
   if (!relativePath || relativePath.trim().length === 0) {
     return void 0;
   }
-  return path26.resolve(runDir, relativePath);
+  return path27.resolve(runDir, relativePath);
 }
 async function ensureFile(filePath, label) {
   try {
@@ -14373,15 +14746,15 @@ async function validateTargetFile(targetsPath, targetNames, label) {
   }
 }
 function isInsideOrSame(root, candidate) {
-  const relative3 = path26.relative(path26.resolve(root), path26.resolve(candidate));
-  return relative3 === "" || !relative3.startsWith("..") && !path26.isAbsolute(relative3);
+  const relative3 = path27.relative(path27.resolve(root), path27.resolve(candidate));
+  return relative3 === "" || !relative3.startsWith("..") && !path27.isAbsolute(relative3);
 }
 function forbiddenOutputRoots(sourceRunDir, selected) {
   return [
-    path26.resolve(sourceRunDir),
+    path27.resolve(sourceRunDir),
     ...selected.flatMap((bundle) => [
-      path26.resolve(bundle.artifactDir),
-      path26.resolve(bundle.taskDir)
+      path27.resolve(bundle.artifactDir),
+      path27.resolve(bundle.taskDir)
     ])
   ];
 }
@@ -14400,13 +14773,13 @@ function defaultOutputDir(cwd, sourceRunDir, selected, experiment) {
   if (!roots.some((root) => isInsideOrSame(root, candidate))) {
     return candidate;
   }
-  return path26.join(path26.dirname(path26.resolve(sourceRunDir)), `rerun-${createRunDirName()}`);
+  return path27.join(path27.dirname(path27.resolve(sourceRunDir)), `rerun-${createRunDirName()}`);
 }
 async function loadEnvFile2(envFile, cwd, verbose) {
   if (!envFile) {
     return;
   }
-  const resolved = path26.isAbsolute(envFile) ? envFile : path26.resolve(cwd, envFile);
+  const resolved = path27.isAbsolute(envFile) ? envFile : path27.resolve(cwd, envFile);
   await ensureFile(resolved, "Environment file");
   const loaded = loadDotenv({ path: resolved, override: false });
   if (loaded.error) {
@@ -14438,8 +14811,8 @@ async function loadSelectedTaskBundles(options) {
       options.sourceRunDir,
       record.task_dir && `${record.task_dir}/${TASK_TARGETS_FILENAME}`
     );
-    const taskDir = resolveRelativeRunPath(options.sourceRunDir, record.task_dir) ?? (evalPath ? path26.dirname(evalPath) : void 0);
-    const artifactDir = resolveRelativeRunPath(options.sourceRunDir, record.artifact_dir) ?? (taskDir ? path26.dirname(taskDir) : void 0);
+    const taskDir = resolveRelativeRunPath(options.sourceRunDir, record.task_dir) ?? (evalPath ? path27.dirname(evalPath) : void 0);
+    const artifactDir = resolveRelativeRunPath(options.sourceRunDir, record.artifact_dir) ?? (taskDir ? path27.dirname(taskDir) : void 0);
     if (!evalPath || !targetsPath || !taskDir || !artifactDir) {
       throw new Error(
         `Selected result ${recordLabel} is missing task bundle paths. Re-run requires task/EVAL.yaml and task/targets.yaml.`
@@ -14469,14 +14842,14 @@ async function loadSelectedTaskBundles(options) {
 function buildSourceMetadataByEvalFile(sourceRunDir, indexPath, selected) {
   return new Map(
     selected.map((bundle) => [
-      path26.resolve(bundle.evalPath),
+      path27.resolve(bundle.evalPath),
       {
         rerunSource: {
           mode: "rerun",
-          sourceRunDir: path26.resolve(sourceRunDir),
-          sourceIndexPath: path26.resolve(indexPath),
-          sourceArtifactDir: path26.resolve(bundle.artifactDir),
-          sourceTaskDir: path26.resolve(bundle.taskDir),
+          sourceRunDir: path27.resolve(sourceRunDir),
+          sourceIndexPath: path27.resolve(indexPath),
+          sourceArtifactDir: path27.resolve(bundle.artifactDir),
+          sourceTaskDir: path27.resolve(bundle.taskDir),
           sourceTestId: bundle.testId,
           sourceTarget: bundle.sourceTarget,
           sourceTimestamp: bundle.record.timestamp
@@ -14547,7 +14920,7 @@ var runsRerunCommand = command({
   handler: async (args) => {
     const cwd = process.cwd();
     const indexPath = resolveRunManifestPath(resolveSourcePath(cwd, args.runDir));
-    const sourceRunDir = path26.dirname(indexPath);
+    const sourceRunDir = path27.dirname(indexPath);
     await loadEnvFile2(args.envFile, cwd, args.verbose);
     const selected = await loadSelectedTaskBundles({
       indexPath,
@@ -14556,10 +14929,10 @@ var runsRerunCommand = command({
       sourceTargets: args.sourceTarget
     });
     const targetOverrides = args.target;
-    const outputDir = args.output ? path26.resolve(cwd, args.output) : defaultOutputDir(cwd, sourceRunDir, selected, args.experiment);
+    const outputDir = args.output ? path27.resolve(cwd, args.output) : defaultOutputDir(cwd, sourceRunDir, selected, args.experiment);
     assertOutputIsSeparate(outputDir, forbiddenOutputRoots(sourceRunDir, selected));
     if (args.targets) {
-      const overrideTargetsPath = path26.resolve(cwd, args.targets);
+      const overrideTargetsPath = path27.resolve(cwd, args.targets);
       await ensureFile(overrideTargetsPath, "Target override");
       const targetNames = targetOverrides.length > 0 ? targetOverrides : selected.map((bundle) => bundle.taskTarget);
       await validateTargetFile(overrideTargetsPath, targetNames, "Target override");
@@ -14583,7 +14956,7 @@ var runsRerunCommand = command({
       testFiles: selected.map((bundle) => bundle.evalPath),
       rawOptions: {
         target: targetOverrides,
-        targets: args.targets ? path26.resolve(cwd, args.targets) : void 0,
+        targets: args.targets ? path27.resolve(cwd, args.targets) : void 0,
         output: outputDir,
         experiment: args.experiment ?? "rerun",
         workers: args.workers,
@@ -14814,13 +15187,13 @@ var selfCommand = subcommands({
 
 // src/commands/skills/index.ts
 import { existsSync as existsSync18, readFileSync as readFileSync13, readdirSync as readdirSync5 } from "node:fs";
-import path27 from "node:path";
+import path28 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function isValidSkillsDir(dir) {
   if (!existsSync18(dir)) return false;
   try {
     return readdirSync5(dir, { withFileTypes: true }).some(
-      (e) => e.isDirectory() && existsSync18(path27.join(dir, e.name, "SKILL.md"))
+      (e) => e.isDirectory() && existsSync18(path28.join(dir, e.name, "SKILL.md"))
     );
   } catch {
     return false;
@@ -14828,15 +15201,15 @@ function isValidSkillsDir(dir) {
 }
 function findSkillsDir() {
   const selfFile = fileURLToPath4(import.meta.url);
-  let dir = path27.dirname(selfFile);
+  let dir = path28.dirname(selfFile);
   for (let i = 0; i < 6; i++) {
-    const distCandidate = path27.join(dir, "dist", "skills");
+    const distCandidate = path28.join(dir, "dist", "skills");
     if (isValidSkillsDir(distCandidate)) return distCandidate;
-    const repoRootCandidate = path27.join(dir, "skills-data");
+    const repoRootCandidate = path28.join(dir, "skills-data");
     if (isValidSkillsDir(repoRootCandidate)) return repoRootCandidate;
-    const legacyCandidate = path27.join(dir, "skills");
+    const legacyCandidate = path28.join(dir, "skills");
     if (isValidSkillsDir(legacyCandidate)) return legacyCandidate;
-    dir = path27.dirname(dir);
+    dir = path28.dirname(dir);
   }
   return null;
 }
@@ -14855,7 +15228,7 @@ function listSkillNames(skillsDir) {
   return readdirSync5(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
 }
 function readSkillFile(skillDir, relPath) {
-  const full = path27.join(skillDir, relPath);
+  const full = path28.join(skillDir, relPath);
   if (!existsSync18(full)) return null;
   return readFileSync13(full, "utf-8");
 }
@@ -14865,9 +15238,9 @@ function collectDir(dir, prefix = "") {
   for (const entry of readdirSync5(dir, { withFileTypes: true })) {
     const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
-      Object.assign(result, collectDir(path27.join(dir, entry.name), relPath));
+      Object.assign(result, collectDir(path28.join(dir, entry.name), relPath));
     } else {
-      result[relPath] = readFileSync13(path27.join(dir, entry.name), "utf-8");
+      result[relPath] = readFileSync13(path28.join(dir, entry.name), "utf-8");
     }
   }
   return result;
@@ -14877,14 +15250,14 @@ function listSkillSubdirs(skillDir) {
   return readdirSync5(skillDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
 }
 function readSkill(skillsDir, name, full) {
-  const skillDir = path27.join(skillsDir, name);
+  const skillDir = path28.join(skillsDir, name);
   if (!existsSync18(skillDir)) return null;
   const content = readSkillFile(skillDir, "SKILL.md");
   if (content === null) return null;
   if (!full) return { name, content };
   const files = {};
   for (const sub of listSkillSubdirs(skillDir)) {
-    const subDir = path27.join(skillDir, sub);
+    const subDir = path28.join(skillDir, sub);
     const collected = collectDir(subDir, sub);
     Object.assign(files, collected);
   }
@@ -14894,14 +15267,14 @@ function findRefFile(skillDir, refName) {
   const candidates = refName.endsWith(".md") ? [refName] : [refName, `${refName}.md`];
   for (const sub of listSkillSubdirs(skillDir)) {
     for (const candidate of candidates) {
-      const filePath = path27.join(skillDir, sub, candidate);
+      const filePath = path28.join(skillDir, sub, candidate);
       if (existsSync18(filePath)) {
         return { relPath: `${sub}/${candidate}`, content: readFileSync13(filePath, "utf-8") };
       }
     }
   }
   for (const candidate of candidates) {
-    const filePath = path27.join(skillDir, candidate);
+    const filePath = path28.join(skillDir, candidate);
     if (existsSync18(filePath)) {
       return { relPath: candidate, content: readFileSync13(filePath, "utf-8") };
     }
@@ -14911,7 +15284,7 @@ function findRefFile(skillDir, refName) {
 function listRefFiles(skillDir) {
   const out = [];
   for (const sub of listSkillSubdirs(skillDir)) {
-    const subDir = path27.join(skillDir, sub);
+    const subDir = path28.join(skillDir, sub);
     for (const entry of readdirSync5(subDir, { withFileTypes: true })) {
       if (entry.isFile()) out.push(`${sub}/${entry.name}`);
     }
@@ -14995,7 +15368,7 @@ var skillsGetCommand = command({
         }
         process.exit(1);
       }
-      const skillDir = path27.join(skillsDir, name);
+      const skillDir = path28.join(skillsDir, name);
       if (!existsSync18(skillDir)) {
         const msg = `skill '${name}' not found`;
         if (json) {
@@ -15084,7 +15457,7 @@ var skillsPathCommand = command({
   handler: ({ name }) => {
     const skillsDir = requireSkillsDir();
     if (name) {
-      const skillDir = path27.join(skillsDir, name);
+      const skillDir = path28.join(skillsDir, name);
       if (!existsSync18(skillDir)) {
         console.error(`Error: skill '${name}' not found`);
         process.exit(1);
@@ -15107,7 +15480,7 @@ var skillsCommand = subcommands({
 
 // src/commands/transpile/index.ts
 import { writeFileSync as writeFileSync7 } from "node:fs";
-import path28 from "node:path";
+import path29 from "node:path";
 var transpileCommand = command({
   name: "transpile",
   description: "Convert an EVAL.yaml file to Agent Skills evals.json format",
@@ -15131,7 +15504,7 @@ var transpileCommand = command({
   handler: async ({ input, outDir, stdout }) => {
     let result;
     try {
-      result = transpileEvalYamlFile(path28.resolve(input));
+      result = transpileEvalYamlFile(path29.resolve(input));
     } catch (error) {
       console.error(`Error: ${error.message}`);
       process.exit(1);
@@ -15155,11 +15528,11 @@ var transpileCommand = command({
       process.stdout.write("\n");
       return;
     }
-    const outputDir = outDir ? path28.resolve(outDir) : path28.dirname(path28.resolve(input));
+    const outputDir = outDir ? path29.resolve(outDir) : path29.dirname(path29.resolve(input));
     const fileNames = getOutputFilenames(result);
     for (const [skill, evalsJson] of result.files) {
       const fileName = fileNames.get(skill) ?? "evals.json";
-      const outputPath = path28.join(outputDir, fileName);
+      const outputPath = path29.join(outputDir, fileName);
       writeFileSync7(outputPath, `${JSON.stringify(evalsJson, null, 2)}
 `);
       console.log(`Transpiled to ${outputPath}`);
@@ -15168,7 +15541,7 @@ var transpileCommand = command({
 });
 
 // src/commands/trend/index.ts
-import path29 from "node:path";
+import path30 from "node:path";
 var colors2 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -15218,7 +15591,7 @@ function colorizeSlope(value) {
 }
 function ensureTrendIndexPath(source, cwd) {
   const resolved = resolveResultSourcePath(source, cwd);
-  if (path29.basename(resolved) !== RESULT_INDEX_FILENAME) {
+  if (path30.basename(resolved) !== RESULT_INDEX_FILENAME) {
     throw new Error(
       `Unsupported result source for trend: ${source}. Use a run workspace directory or ${RESULT_INDEX_FILENAME} manifest.`
     );
@@ -15238,7 +15611,7 @@ function resolveTrendSources(cwd, sources, last) {
   if (last < 2) {
     throw new Error("--last must be at least 2");
   }
-  const metas = listResultFiles(cwd).filter((meta) => path29.basename(meta.path) === RESULT_INDEX_FILENAME).slice(0, last);
+  const metas = listResultFiles(cwd).filter((meta) => path30.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/"
@@ -15253,10 +15626,10 @@ function getRunLabel(sourcePath, timestamp) {
   if (timestamp) {
     return timestamp;
   }
-  return path29.basename(path29.dirname(sourcePath));
+  return path30.basename(path30.dirname(sourcePath));
 }
 function getRunSortKey(sourcePath, timestamp) {
-  return timestamp ?? path29.basename(path29.dirname(sourcePath));
+  return timestamp ?? path30.basename(path30.dirname(sourcePath));
 }
 function mean2(values) {
   return values.reduce((sum, value) => sum + value, 0) / values.length;
@@ -15637,7 +16010,7 @@ function isTTY() {
 // src/commands/validate/validate-files.ts
 import { constants as constants2 } from "node:fs";
 import { access as access2, readdir as readdir4, stat as stat2 } from "node:fs/promises";
-import path30 from "node:path";
+import path31 from "node:path";
 import fg3 from "fast-glob";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
@@ -15652,7 +16025,7 @@ async function validateFiles(paths) {
   };
 }
 async function validateSingleFile(filePath) {
-  const absolutePath = path30.resolve(filePath);
+  const absolutePath = path31.resolve(filePath);
   const fileType = await detectFileType(absolutePath);
   let result;
   if (fileType === "eval") {
@@ -15696,7 +16069,7 @@ async function validateSingleFile(filePath) {
 async function expandPaths(paths) {
   const expanded = /* @__PURE__ */ new Set();
   for (const inputPath of paths) {
-    const absolutePath = path30.resolve(inputPath);
+    const absolutePath = path31.resolve(inputPath);
     try {
       await access2(absolutePath, constants2.F_OK);
       const stats = await stat2(absolutePath);
@@ -15724,7 +16097,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(path30.normalize(f));
+    for (const f of yamlMatches) expanded.add(path31.normalize(f));
   }
   const sorted = Array.from(expanded);
   sorted.sort();
@@ -15735,7 +16108,7 @@ async function findYamlFiles(dirPath) {
   try {
     const entries2 = await readdir4(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path30.join(dirPath, entry.name);
+      const fullPath = path31.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -15752,11 +16125,11 @@ async function findYamlFiles(dirPath) {
   return results;
 }
 function isYamlFile(filePath) {
-  const ext = path30.extname(filePath).toLowerCase();
+  const ext = path31.extname(filePath).toLowerCase();
   return ext === ".yaml" || ext === ".yml";
 }
 function isEvalYamlFile(filePath) {
-  const lower = path30.basename(filePath).toLowerCase();
+  const lower = path31.basename(filePath).toLowerCase();
   return lower.endsWith(".eval.yaml") || lower.endsWith(".eval.yml");
 }
 
@@ -15813,7 +16186,7 @@ var validateCommand = command({
 // src/commands/workspace/clean.ts
 import { existsSync as existsSync19 } from "node:fs";
 import { readFile as readFile9, readdir as readdir5, rm as rm2 } from "node:fs/promises";
-import path31 from "node:path";
+import path32 from "node:path";
 async function confirm2(message) {
   const readline4 = await import("node:readline");
   const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
@@ -15849,8 +16222,8 @@ var cleanCommand = command({
       const poolDirs = entries2.filter((e) => e.isDirectory());
       const matchingDirs = [];
       for (const dir of poolDirs) {
-        const poolDir = path31.join(poolRoot, dir.name);
-        const metadataPath = path31.join(poolDir, "metadata.json");
+        const poolDir = path32.join(poolRoot, dir.name);
+        const metadataPath = path32.join(poolDir, "metadata.json");
         try {
           const raw = await readFile9(metadataPath, "utf-8");
           const metadata = JSON.parse(raw);
@@ -15879,7 +16252,7 @@ var cleanCommand = command({
       }
       for (const dir of matchingDirs) {
         await rm2(dir, { recursive: true, force: true });
-        console.log(`Removed: ${path31.basename(dir).slice(0, 12)}...`);
+        console.log(`Removed: ${path32.basename(dir).slice(0, 12)}...`);
       }
       console.log("Done.");
     } else {
@@ -15897,7 +16270,7 @@ var cleanCommand = command({
 });
 
 // src/commands/workspace/deps.ts
-import path32 from "node:path";
+import path33 from "node:path";
 var depsCommand = command({
   name: "deps",
   description: "Scan eval files and list git repo dependencies needed by workspaces",
@@ -15921,7 +16294,7 @@ var depsCommand = command({
     const resolvedPaths = await resolveEvalPaths(evalPaths, cwd);
     const result = await scanRepoDeps(resolvedPaths);
     for (const err2 of result.errors) {
-      console.error(`error: ${path32.relative(cwd, err2.file)}: ${err2.message}`);
+      console.error(`error: ${path33.relative(cwd, err2.file)}: ${err2.message}`);
     }
     if (result.errors.length > 0) {
       process.exit(1);
@@ -15932,7 +16305,7 @@ var depsCommand = command({
         ...r.ref !== void 0 && { ref: r.ref },
         ...r.sparse !== void 0 && { sparse: r.sparse },
         ...r.ancestor !== void 0 && { ancestor: r.ancestor },
-        ...usedBy && { used_by: r.usedBy.map((p) => path32.relative(cwd, p)) }
+        ...usedBy && { used_by: r.usedBy.map((p) => path33.relative(cwd, p)) }
       }))
     };
     console.log(JSON.stringify(output, null, 2));
@@ -15942,13 +16315,13 @@ var depsCommand = command({
 // src/commands/workspace/list.ts
 import { existsSync as existsSync20 } from "node:fs";
 import { readFile as readFile10, readdir as readdir6, stat as stat3 } from "node:fs/promises";
-import path33 from "node:path";
+import path34 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 = path33.join(dirPath, entry.name);
+      const fullPath = path34.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(fullPath);
       } else {
@@ -15983,11 +16356,11 @@ var listCommand = command({
       return;
     }
     for (const dir of poolDirs) {
-      const poolDir = path33.join(poolRoot, dir.name);
+      const poolDir = path34.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 = path33.join(poolDir, "metadata.json");
+      const metadataPath = path34.join(poolDir, "metadata.json");
       let metadata = null;
       try {
         const raw = await readFile10(metadataPath, "utf-8");
@@ -16034,8 +16407,8 @@ var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var CONFIG_DIR = getAgentvConfigDir();
 var CACHE_FILE = "version-check.json";
 var NPM_REGISTRY_BASE2 = "https://registry.npmjs.org/agentv/";
-async function getCachedUpdateInfo(path35) {
-  const filePath = path35 ?? join6(CONFIG_DIR, CACHE_FILE);
+async function getCachedUpdateInfo(path36) {
+  const filePath = path36 ?? join6(CONFIG_DIR, CACHE_FILE);
   try {
     const raw = await readFile11(filePath, "utf-8");
     const data = JSON.parse(raw);
@@ -16144,7 +16517,7 @@ var app = subcommands({
     workspace: workspaceCommand
   }
 });
-var EVAL_SUBCOMMANDS = /* @__PURE__ */ new Set(["run", "assert", "aggregate"]);
+var EVAL_SUBCOMMANDS = /* @__PURE__ */ new Set(["run", "assert", "aggregate", "bundle"]);
 var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
   "import",
   "inspect",
@@ -16216,7 +16589,7 @@ ${updateNotice}
   }
   const cwd = process.cwd();
   const repoRoot = await findRepoRoot(cwd);
-  const sessionConfig = await loadConfig(path34.join(cwd, "_"), repoRoot);
+  const sessionConfig = await loadConfig(path35.join(cwd, "_"), repoRoot);
   const beforeSessionCommand = sessionConfig?.hooks?.before_session;
   if (beforeSessionCommand) {
     runBeforeSessionHook(beforeSessionCommand);
@@ -16230,4 +16603,4 @@ export {
   preprocessArgv,
   runCli
 };
-//# sourceMappingURL=chunk-LXXMQSAR.js.map
+//# sourceMappingURL=chunk-AHQWZGJE.js.map