npm - agentv - Versions diffs - 4.42.4 → 4.43.0-next.1 - Mend

agentv 4.42.4 → 4.43.0-next.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (43) hide show

package/dist/{chunk-ISPJY2AX.js → chunk-IFQXBQSY.js} RENAMED Viewed

@@ -3,11 +3,13 @@ import {
   Mutex,
   RESULT_INDEX_FILENAME,
   TARGET_FILE_CANDIDATES,
+  TagRevisionConflictError,
+  assertExpectedTagRevision,
   buildDefaultRunDir,
+  buildDefaultRunDirFromName,
   c,
   clearRemoteRunTags,
   createRunDirName,
-  deleteRunTags,
   detectFileType,
   discoverEvalFiles,
   discoverTargetsFile,
@@ -24,14 +26,19 @@ import {
   getTraceSpans,
   getTraceSummary,
   isRemoteRunId,
+  isReservedResultsNamespace,
   listMergedResultFiles,
   listResultFiles,
   loadEnvFromHierarchy,
   loadLightweightResults,
   loadManifestResults,
+  loadNormalizedResultsConfig,
   loadResultFile,
   loadRunCache,
+  materializeRunState,
   maybeAutoExportRunArtifacts,
+  normalizeExperimentName,
+  normalizeTags,
   package_default,
   padLeft,
   padRight,
@@ -39,6 +46,7 @@ import {
   readRemoteRunTagState,
   readRunTags,
   readTestSuiteTarget,
+  relativeRunPathFromCwd,
   resolveEvalPaths,
   resolveResultSourcePath,
   resolveRunCacheFile,
@@ -56,39 +64,46 @@ import {
   validateTargetsFile,
   validateWorkspacePaths,
   writeRunTags
-} from "./chunk-N6U3GXMF.js";
+} from "./chunk-ROLNQBYU.js";
 import {
   materializeEvalBundle,
   toSnakeCaseDeep as toSnakeCaseDeep2,
   writeArtifactsFromResults as writeArtifactsFromResults2
-} from "./chunk-6SQDBXT7.js";
+} from "./chunk-E2NL57MZ.js";
 import {
   DEFAULT_CATEGORY,
   deriveCategory,
   discoverClaudeSessions,
   discoverCodexSessions,
   getOutputFilenames,
+  normalizeTraceArtifactToTraceSessionResponse,
   parseClaudeSession,
   parseCodexSession,
   prepareEvalWorkspace,
+  readGitResultArtifact,
   runBeforeSessionHook,
   scanRepoDeps,
   syncProjects,
   transpileEvalYamlFile,
   trimBaselineResult
-} from "./chunk-RBOP5X36.js";
+} from "./chunk-5NDSGGMJ.js";
 import {
+  AGENTV_RESULTS_ARTIFACTS_REF,
   DEFAULT_THRESHOLD,
   EXECUTION_TRACE_SCHEMA_VERSION,
   addProject,
   aggregateRunDir,
   buildBenchmarkArtifact,
+  buildResultIndexArtifact,
   buildTestTargetKey,
   buildTimingArtifact,
+  buildTraceEnvelopeFromEvaluationResult,
   buildTraceFromMessages,
   createBuiltinRegistry,
   discoverCopilotSessions,
   executeScript,
+  externalTraceMetadataFromRecord,
+  external_exports,
   getAgentvConfigDir,
   getProject,
   getWorkspacePoolRoot,
@@ -100,6 +115,7 @@ import {
   loadTestSuite,
   normalizeLineEndings,
   normalizeResultRow,
+  omitExternalTraceMetadataKeys,
   parseAgentSkillsEvals,
   parseCopilotEvents,
   parseYamlValue,
@@ -120,14 +136,16 @@ import {
   runRegexAssertion,
   runStartsWithAssertion,
   toCamelCaseDeep,
+  toExternalTraceMetadataWire,
   toSnakeCaseDeep,
+  toTraceEnvelopeWire,
   toTranscriptJsonLines,
   touchProject,
   traceEnvelopeToTraceSummary,
   traceEnvelopeToTranscriptMessages,
   traceFromTranscriptJsonLines,
   writeArtifactsFromResults
-} from "./chunk-ZPFM52HV.js";
+} from "./chunk-RFJM2UBD.js";
 import {
   __commonJS,
   __require,
@@ -888,7 +906,7 @@ var require_src = __commonJS({
 });
 // src/index.ts
-import path35 from "node:path";
+import path36 from "node:path";
 // ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -3320,7 +3338,9 @@ ${STYLES}
 <body>
     <header class="header">
         <div class="header-left">
-            <h1 class="header-title">AgentV</h1>
+            <h1 class="header-title" aria-label="AgentV">
+                <span class="brand-letter" aria-hidden="true">A</span><span class="brand-middle" aria-hidden="true">GENT</span><span class="brand-letter" aria-hidden="true">V</span>
+            </h1>
             <span class="header-subtitle">Evaluation Report</span>
         </div>
         <div class="header-right">${liveIndicator}</div>
@@ -3345,7 +3365,7 @@ var STYLES = `
 *{margin:0;padding:0;box-sizing:border-box}
 :root{
   --bg:#f6f8fa;--surface:#fff;--border:#d0d7de;--border-light:#e8ebee;
-  --text:#1f2328;--text-muted:#656d76;
+  --text:#1f2328;--text-muted:#656d76;--brand-middle:#656d76;
   --primary:#0969da;--primary-bg:#ddf4ff;
   --success:#1a7f37;--success-bg:#dafbe1;
   --danger:#cf222e;--danger-bg:#ffebe9;
@@ -3361,6 +3381,8 @@ body{font-family:var(--font);background:var(--bg);color:var(--text);line-height:
 .header{background:var(--surface);border-bottom:1px solid var(--border);padding:12px 24px;display:flex;align-items:center;justify-content:space-between}
 .header-left{display:flex;align-items:baseline;gap:12px}
 .header-title{font-size:18px;font-weight:600}
+.brand-letter{color:var(--primary)}
+.brand-middle{color:var(--brand-middle)}
 .header-subtitle{font-size:14px;color:var(--text-muted)}
 .live-badge{color:var(--success);font-size:12px;font-weight:600;animation:pulse 2s infinite}
 @keyframes pulse{0%,100%{opacity:1}50%{opacity:.4}}
@@ -4632,7 +4654,7 @@ var evalRunCommand = command({
     resultsRemote: option({
       type: optional(string),
       long: "results-remote",
-      description: "Git remote name for results push/fetch (default: origin)"
+      description: "Advanced compatibility override: local Git remote name for results push/fetch"
     }),
     resultsPush: flag({
       long: "results-push",
@@ -4806,7 +4828,7 @@ var evalRunCommand = command({
   },
   handler: async (args) => {
     if (args.evalPaths.length === 0 && process.stdin.isTTY) {
-      const { launchInteractiveWizard } = await import("./interactive-TNRJEFA2.js");
+      const { launchInteractiveWizard } = await import("./interactive-RE4DXH4A.js");
       await launchInteractiveWizard();
       return;
     }
@@ -4882,15 +4904,701 @@ var evalRunCommand = command({
   }
 });
+// ../../packages/sdk/dist/index.js
+import { stringify as stringifyYaml2 } from "yaml";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { spawn } from "node:child_process";
+import { copyFile, mkdtemp, readFile as readFile2, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import nodePath2 from "node:path";
+var TokenUsageSchema = external_exports.object({
+  input: external_exports.number(),
+  output: external_exports.number(),
+  cached: external_exports.number().optional(),
+  reasoning: external_exports.number().optional()
+});
+var TraceSummarySchema = external_exports.object({
+  eventCount: external_exports.number(),
+  toolCalls: external_exports.record(external_exports.string(), external_exports.number()),
+  errorCount: external_exports.number(),
+  toolDurations: external_exports.record(external_exports.string(), external_exports.array(external_exports.number())).optional(),
+  llmCallCount: external_exports.number().optional()
+});
+var TRACE_SOURCE_KINDS = [
+  "agentv_run",
+  "otlp",
+  "phoenix",
+  "langfuse",
+  "pi_session",
+  "imported_transcript",
+  "compact_transcript"
+];
+var TRACE_EVENT_TYPES = [
+  "message",
+  "model_turn",
+  "tool_call",
+  "tool_result",
+  "final_response",
+  "error"
+];
+var TRACE_TOOL_STATUSES = ["ok", "error", "timeout", "cancelled", "unknown"];
+var TRACE_REDACTION_LEVELS = ["none", "partial", "full"];
+var MetadataSchema = external_exports.record(external_exports.string(), external_exports.unknown());
+var TraceRedactionStateSchema = external_exports.object({
+  level: external_exports.enum(TRACE_REDACTION_LEVELS),
+  fields: external_exports.array(external_exports.string()).optional(),
+  reason: external_exports.string().optional()
+});
+var TraceErrorSchema = external_exports.object({
+  message: external_exports.string(),
+  name: external_exports.string().optional(),
+  code: external_exports.string().optional(),
+  stack: external_exports.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceSourceSchema = external_exports.object({
+  kind: external_exports.enum(TRACE_SOURCE_KINDS),
+  path: external_exports.string().optional(),
+  url: external_exports.string().optional(),
+  provider: external_exports.string().optional(),
+  format: external_exports.string().optional(),
+  version: external_exports.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceSessionSchema = external_exports.object({
+  sessionId: external_exports.string().optional(),
+  conversationId: external_exports.string().optional(),
+  cwd: external_exports.string().optional(),
+  startedAt: external_exports.string().optional(),
+  endedAt: external_exports.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceBranchSchema = external_exports.object({
+  selectedLeafId: external_exports.string().optional(),
+  selectedPathIds: external_exports.array(external_exports.string()).optional(),
+  includedEventIds: external_exports.array(external_exports.string()).optional(),
+  omittedEventIds: external_exports.array(external_exports.string()).optional(),
+  selectionReason: external_exports.string().optional()
+});
+var TraceSourceRefSchema = external_exports.object({
+  eventId: external_exports.string().optional(),
+  messageId: external_exports.string().optional(),
+  spanId: external_exports.string().optional(),
+  traceId: external_exports.string().optional(),
+  rawKind: external_exports.string().optional(),
+  path: external_exports.string().optional(),
+  line: external_exports.number().int().nonnegative().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceRawEvidenceSchema = external_exports.object({
+  kind: external_exports.string(),
+  ref: external_exports.string().optional(),
+  mediaType: external_exports.string().optional(),
+  content: external_exports.unknown().optional(),
+  redacted: external_exports.boolean().optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceMessageSchema = external_exports.object({
+  role: external_exports.string(),
+  name: external_exports.string().optional(),
+  content: external_exports.unknown().optional(),
+  redaction: TraceRedactionStateSchema.optional(),
+  tokenUsage: TokenUsageSchema.optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceModelSchema = external_exports.object({
+  provider: external_exports.string().optional(),
+  name: external_exports.string().optional(),
+  invocationId: external_exports.string().optional(),
+  tokenUsage: TokenUsageSchema.optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceToolSchema = external_exports.object({
+  name: external_exports.string(),
+  callId: external_exports.string().optional(),
+  input: external_exports.unknown().optional(),
+  output: external_exports.unknown().optional(),
+  status: external_exports.enum(TRACE_TOOL_STATUSES).optional(),
+  error: TraceErrorSchema.optional(),
+  redaction: TraceRedactionStateSchema.optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceEventSchema = external_exports.object({
+  eventId: external_exports.string(),
+  parentEventId: external_exports.string().optional(),
+  ordinal: external_exports.number().int().nonnegative(),
+  type: external_exports.enum(TRACE_EVENT_TYPES),
+  timestamp: external_exports.string().optional(),
+  durationMs: external_exports.number().nonnegative().optional(),
+  durationInferred: external_exports.boolean().optional(),
+  turnIndex: external_exports.number().int().nonnegative().optional(),
+  message: TraceMessageSchema.optional(),
+  model: TraceModelSchema.optional(),
+  tool: TraceToolSchema.optional(),
+  error: TraceErrorSchema.optional(),
+  sourceRef: TraceSourceRefSchema.optional(),
+  rawEvidence: external_exports.array(TraceRawEvidenceSchema).optional(),
+  redaction: TraceRedactionStateSchema.optional(),
+  metadata: MetadataSchema.optional()
+});
+var TraceArtifactSchema = external_exports.object({
+  source: TraceSourceSchema,
+  session: TraceSessionSchema,
+  branch: TraceBranchSchema.optional(),
+  events: external_exports.array(TraceEventSchema),
+  tokenUsage: TokenUsageSchema.optional(),
+  costUsd: external_exports.number().optional(),
+  durationMs: external_exports.number().optional(),
+  startedAt: external_exports.string().optional(),
+  endedAt: external_exports.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var ToolCallSchema = external_exports.object({
+  tool: external_exports.string(),
+  input: external_exports.unknown().optional(),
+  output: external_exports.unknown().optional(),
+  id: external_exports.string().optional(),
+  startTime: external_exports.string().optional(),
+  endTime: external_exports.string().optional(),
+  durationMs: external_exports.number().optional()
+});
+var ContentTextSchema = external_exports.object({
+  type: external_exports.literal("text"),
+  text: external_exports.string()
+});
+var ContentImageSchema = external_exports.object({
+  type: external_exports.literal("image"),
+  media_type: external_exports.string(),
+  path: external_exports.string()
+});
+var ContentFileSchema = external_exports.object({
+  type: external_exports.literal("file"),
+  media_type: external_exports.string(),
+  path: external_exports.string()
+});
+var ContentSchema = external_exports.discriminatedUnion("type", [
+  ContentTextSchema,
+  ContentImageSchema,
+  ContentFileSchema
+]);
+var MessageContentBlockSchema = external_exports.union([ContentSchema, external_exports.record(external_exports.unknown())]);
+var MessageSchema = external_exports.object({
+  role: external_exports.enum(["assistant", "user", "system", "tool"]),
+  content: external_exports.union([external_exports.string(), external_exports.array(MessageContentBlockSchema), external_exports.record(external_exports.unknown())]).optional(),
+  toolCalls: external_exports.array(ToolCallSchema).optional(),
+  name: external_exports.string().optional(),
+  startTime: external_exports.string().optional(),
+  endTime: external_exports.string().optional(),
+  durationMs: external_exports.number().optional(),
+  metadata: external_exports.record(external_exports.unknown()).optional()
+});
+var TraceSchema = TraceSummarySchema.extend({
+  messages: external_exports.array(MessageSchema),
+  events: external_exports.array(TraceEventSchema),
+  tokenUsage: TokenUsageSchema.optional(),
+  costUsd: external_exports.number().optional(),
+  durationMs: external_exports.number().optional(),
+  startTime: external_exports.string().optional(),
+  endTime: external_exports.string().optional(),
+  metadata: MetadataSchema.optional()
+});
+var CodeGraderInputSchema = external_exports.object({
+  criteria: external_exports.string(),
+  expectedOutput: external_exports.array(MessageSchema),
+  output: external_exports.string().nullable().optional(),
+  messages: external_exports.array(MessageSchema).optional().default([]),
+  /** Path to a temp file containing the output JSON (used for large payloads). */
+  outputPath: external_exports.string().optional(),
+  inputFiles: external_exports.array(external_exports.string()),
+  input: external_exports.array(MessageSchema),
+  metadata: external_exports.record(external_exports.unknown()).nullable().optional(),
+  trace: TraceSchema.nullable().optional(),
+  traceSummary: TraceSummarySchema.nullable().optional(),
+  tokenUsage: TokenUsageSchema.nullable().optional(),
+  costUsd: external_exports.number().nullable().optional(),
+  durationMs: external_exports.number().nullable().optional(),
+  startTime: external_exports.string().nullable().optional(),
+  endTime: external_exports.string().nullable().optional(),
+  fileChanges: external_exports.string().nullable().optional(),
+  workspacePath: external_exports.string().nullable().optional(),
+  config: external_exports.record(external_exports.unknown()).nullable().optional()
+});
+var CodeGraderResultSchema = external_exports.object({
+  score: external_exports.number().min(0).max(1),
+  assertions: external_exports.array(
+    external_exports.object({
+      text: external_exports.string(),
+      passed: external_exports.boolean(),
+      evidence: external_exports.string().optional()
+    })
+  ).optional().default([]),
+  /** Optional structured details for domain-specific metrics (e.g., TP/TN/FP/FN counts, alignments). */
+  details: external_exports.record(external_exports.unknown()).optional()
+});
+var EVAL_SUITE_SYMBOL = Symbol.for("@agentv/sdk/eval-suite");
+var TO_EVAL_YAML_OBJECT_SYMBOL = Symbol.for("@agentv/sdk/to-eval-yaml-object");
+function withCommon(config, options = {}) {
+  return {
+    ...options.name !== void 0 ? { name: options.name } : {},
+    ...config,
+    ...options.weight !== void 0 ? { weight: options.weight } : {},
+    ...options.required !== void 0 ? { required: options.required } : {},
+    ...options.minScore !== void 0 ? { minScore: options.minScore } : {},
+    ...options.negate !== void 0 ? { negate: options.negate } : {}
+  };
+}
+function containsGrader(value, options) {
+  return withCommon({ type: "contains", value }, options);
+}
+function equalsGrader(value, options) {
+  return withCommon({ type: "equals", value }, options);
+}
+function exactGrader(value, options) {
+  return equalsGrader(value, options);
+}
+function regexGrader(pattern, options = {}) {
+  const value = pattern instanceof RegExp ? pattern.source : pattern;
+  const flags = options.flags ?? (pattern instanceof RegExp ? pattern.flags : void 0);
+  return withCommon(
+    {
+      type: "regex",
+      value,
+      ...flags ? { flags } : {}
+    },
+    options
+  );
+}
+function isJsonGrader(options) {
+  return withCommon({ type: "is-json" }, options);
+}
+function jsonGrader(options) {
+  return isJsonGrader(options);
+}
+function rubricsGrader(criteria, options) {
+  return withCommon({ type: "rubrics", criteria }, options);
+}
+function llmGrader(options = {}) {
+  return withCommon(
+    {
+      type: "llm-grader",
+      ...options.prompt !== void 0 ? { prompt: options.prompt } : {},
+      ...options.rubrics !== void 0 ? { rubrics: options.rubrics } : {},
+      ...options.target !== void 0 ? { target: options.target } : {},
+      ...options.config !== void 0 ? { config: options.config } : {},
+      ...options.maxSteps !== void 0 ? { maxSteps: options.maxSteps } : {},
+      ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+      ...options.preprocessors !== void 0 ? { preprocessors: options.preprocessors } : {}
+    },
+    options
+  );
+}
+function codeGrader(command2, options = {}) {
+  return withCommon(
+    {
+      type: "code-grader",
+      command: command2,
+      ...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+      ...options.target !== void 0 ? { target: options.target } : {},
+      ...options.config !== void 0 ? { config: options.config } : {},
+      ...options.preprocessors !== void 0 ? { preprocessors: options.preprocessors } : {}
+    },
+    options
+  );
+}
+var graders = Object.freeze({
+  contains: containsGrader,
+  equals: equalsGrader,
+  exact: exactGrader,
+  regex: regexGrader,
+  isJson: isJsonGrader,
+  json: jsonGrader,
+  rubrics: rubricsGrader,
+  llmGrader,
+  codeGrader
+});
+function toCamelCase(str) {
+  if (/^[A-Z]/.test(str)) {
+    return str;
+  }
+  return str.replace(/_([a-z0-9])/g, (_, letter) => letter.toUpperCase());
+}
+function toCamelCaseDeep2(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => toCamelCaseDeep2(item));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const camelKey = toCamelCase(key);
+      result[camelKey] = toCamelCaseDeep2(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function enrichInput(input) {
+  return input;
+}
+function readStdin() {
+  return readFileSync3(0, "utf8");
+}
+function clampScore(value) {
+  if (Number.isNaN(value) || !Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, Math.min(1, value));
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+async function runCodeGrader(handler) {
+  try {
+    const stdin = readStdin();
+    const rawInput = JSON.parse(stdin);
+    const camelInput = toCamelCaseDeep2(rawInput);
+    const input = CodeGraderInputSchema.parse(camelInput);
+    if (input.outputPath && (input.output === null || input.output === void 0)) {
+      let cachedOutput;
+      const filePath = input.outputPath;
+      Object.defineProperty(input, "output", {
+        get() {
+          if (cachedOutput === void 0) {
+            cachedOutput = JSON.parse(readFileSync3(filePath, "utf8"));
+          }
+          return cachedOutput;
+        },
+        configurable: true,
+        enumerable: true
+      });
+    }
+    enrichInput(input);
+    const rawResult = await handler(input);
+    const result = CodeGraderResultSchema.parse({
+      ...rawResult,
+      score: clampScore(rawResult.score)
+    });
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    const errorMessage = formatError(error);
+    const errorResult = {
+      score: 0,
+      assertions: [{ text: `Evaluation failed: ${errorMessage}`, passed: false }]
+    };
+    console.log(JSON.stringify(errorResult, null, 2));
+    process.exit(1);
+  }
+}
+function workspacePathFrom2(input) {
+  const workspacePath = input.workspacePath ?? process.env.AGENTV_WORKSPACE_PATH;
+  return workspacePath?.trim() ? workspacePath : void 0;
+}
+function truncate(value, maxLength = 2e3) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength)}
+...(truncated)`;
+}
+function resolveInsideWorkspace(workspacePath, relativePath, label, options = {}) {
+  if (!relativePath.trim()) {
+    throw new Error(`${label} must not be empty.`);
+  }
+  if (nodePath2.isAbsolute(relativePath)) {
+    throw new Error(`${label} must be relative to the workspace: ${relativePath}`);
+  }
+  const root = nodePath2.resolve(workspacePath);
+  const resolvedPath = nodePath2.resolve(root, relativePath);
+  const relativeToRoot = nodePath2.relative(root, resolvedPath);
+  if (relativeToRoot === "" && options.allowRoot === true) {
+    return resolvedPath;
+  }
+  if (relativeToRoot === "" || relativeToRoot.startsWith("..") || nodePath2.isAbsolute(relativeToRoot)) {
+    throw new Error(`${label} must stay inside the workspace: ${relativePath}`);
+  }
+  return resolvedPath;
+}
+function normalizeTestFiles(testFile) {
+  if (testFile === void 0) {
+    return [];
+  }
+  return typeof testFile === "string" ? [testFile] : [...testFile];
+}
+function buildCommand(options, testFiles = normalizeTestFiles(options.testFile)) {
+  if (options.command && options.command.length > 0) {
+    return [...options.command];
+  }
+  const command2 = [...options.vitestCommand ?? ["bunx", "vitest", "run"]];
+  command2.push(...testFiles);
+  return command2;
+}
+function parseJsonObjectFromText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      return JSON.parse(trimmed.slice(start, end + 1));
+    }
+    throw new Error("Vitest output did not contain a JSON object.");
+  }
+}
+function isVitestJsonReport(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.testResults);
+}
+function assertionText(file, assertion2) {
+  const title = assertion2.fullName ?? [...assertion2.ancestorTitles ?? [], assertion2.title].filter(Boolean).join(" ");
+  return title || file.name || "Vitest assertion";
+}
+function vitestReportToCodeGraderResult(report, options = {}) {
+  const assertions = (report.testResults ?? []).flatMap(
+    (file) => (file.assertionResults ?? []).map((item) => {
+      const passed = item.status === "passed";
+      const evidence = item.failureMessages && item.failureMessages.length > 0 ? truncate(item.failureMessages.join("\n\n")) : void 0;
+      return {
+        text: assertionText(file, item),
+        passed,
+        ...evidence !== void 0 ? { evidence } : {}
+      };
+    })
+  );
+  if (assertions.length === 0) {
+    const passed = options.passWithNoTests === true;
+    return CodeGraderResultSchema.parse({
+      score: passed ? 1 : 0,
+      assertions: [{ text: "Vitest reported no tests", passed }],
+      details: {
+        vitest_success: report.success ?? false,
+        num_total_tests: report.numTotalTests ?? 0,
+        num_passed_tests: report.numPassedTests ?? 0,
+        num_failed_tests: report.numFailedTests ?? 0,
+        num_pending_tests: report.numPendingTests ?? 0,
+        num_todo_tests: report.numTodoTests ?? 0
+      }
+    });
+  }
+  const passedCount = assertions.filter((item) => item.passed).length;
+  return CodeGraderResultSchema.parse({
+    score: passedCount / assertions.length,
+    assertions,
+    details: {
+      vitest_success: report.success ?? passedCount === assertions.length,
+      num_total_tests: report.numTotalTests ?? assertions.length,
+      num_passed_tests: report.numPassedTests ?? passedCount,
+      num_failed_tests: report.numFailedTests ?? assertions.length - passedCount,
+      num_pending_tests: report.numPendingTests ?? 0,
+      num_todo_tests: report.numTodoTests ?? 0
+    }
+  });
+}
+function runCommand(command2, options) {
+  if (command2.length === 0) {
+    return Promise.reject(new Error("Vitest command must not be empty."));
+  }
+  return new Promise((resolve3, reject) => {
+    const child = spawn(command2[0], command2.slice(1), {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timeout = options.timeoutMs !== void 0 ? setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+    }, options.timeoutMs) : void 0;
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (exitCode) => {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      if (timedOut) {
+        reject(new Error(`Vitest command timed out after ${options.timeoutMs}ms.`));
+        return;
+      }
+      resolve3({ exitCode, stdout, stderr });
+    });
+  });
+}
+function resolveSourceTestFile(testFileRoot, testFile) {
+  if (!testFile.trim()) {
+    throw new Error("testFile entries must not be empty.");
+  }
+  return nodePath2.isAbsolute(testFile) ? nodePath2.resolve(testFile) : nodePath2.resolve(testFileRoot, testFile);
+}
+async function copyTestFilesIntoWorkspace(testFiles, options, cwd) {
+  if (testFiles.length === 0) {
+    return { testFiles };
+  }
+  const tempDir = await mkdtemp(nodePath2.join(cwd, ".agentv-vitest-"));
+  const testFileRoot = nodePath2.resolve(options.testFileRoot ?? process.cwd());
+  const copiedFiles = await Promise.all(
+    testFiles.map(async (testFile, index) => {
+      const sourcePath = resolveSourceTestFile(testFileRoot, testFile);
+      const destinationPath = nodePath2.join(tempDir, `${index}-${nodePath2.basename(testFile)}`);
+      await copyFile(sourcePath, destinationPath);
+      return nodePath2.relative(cwd, destinationPath);
+    })
+  );
+  return { testFiles: copiedFiles, tempDir };
+}
+async function readVitestReport(commandResult, outputFile) {
+  const rawReport = outputFile !== void 0 ? await readFile2(outputFile, "utf8") : commandResult.stdout;
+  const parsed = parseJsonObjectFromText(rawReport);
+  if (!isVitestJsonReport(parsed)) {
+    throw new Error("Vitest JSON report did not include testResults[].");
+  }
+  return parsed;
+}
+async function runVitestWorkspaceGrader(options, input) {
+  const workspacePath = workspacePathFrom2(input);
+  if (!workspacePath) {
+    return {
+      score: 0,
+      assertions: [
+        {
+          text: "Vitest workspace verifier requires workspace_path",
+          passed: false,
+          evidence: "Configure workspace in the eval YAML so AgentV can pass workspace_path."
+        }
+      ]
+    };
+  }
+  const tempDirs = [];
+  try {
+    const cwd = options.cwd ? resolveInsideWorkspace(workspacePath, options.cwd, "cwd", { allowRoot: true }) : workspacePath;
+    const testFiles = normalizeTestFiles(options.testFile);
+    const preparedTestFiles = options.copyTestFilesToWorkspace === true ? await copyTestFilesIntoWorkspace(testFiles, options, cwd) : { testFiles };
+    if (preparedTestFiles.tempDir) {
+      tempDirs.push(preparedTestFiles.tempDir);
+    }
+    const command2 = buildCommand(options, preparedTestFiles.testFiles);
+    const appendReporterArgs = options.appendReporterArgs ?? options.command === void 0;
+    let outputFile = options.outputFile ? resolveInsideWorkspace(cwd, options.outputFile, "outputFile") : void 0;
+    if (appendReporterArgs) {
+      const tempDir = await mkdtemp(nodePath2.join(tmpdir(), "agentv-vitest-"));
+      tempDirs.push(tempDir);
+      outputFile = nodePath2.join(tempDir, "results.json");
+      command2.push("--reporter=json", `--outputFile=${outputFile}`);
+    }
+    const result = await runCommand(command2, {
+      cwd,
+      timeoutMs: options.timeoutMs,
+      env: {
+        AGENTV_WORKSPACE_PATH: workspacePath,
+        ...outputFile !== void 0 ? { AGENTV_VITEST_JSON_PATH: outputFile } : {},
+        ...options.env
+      }
+    });
+    const report = await readVitestReport(result, outputFile);
+    return vitestReportToCodeGraderResult(report, options);
+  } catch (error) {
+    return {
+      score: 0,
+      assertions: [
+        {
+          text: "Vitest workspace verifier failed to run",
+          passed: false,
+          evidence: error instanceof Error ? error.message : String(error)
+        }
+      ]
+    };
+  } finally {
+    for (const tempDir of tempDirs.reverse()) {
+      await rm(tempDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+}
+// src/commands/eval/commands/vitest.ts
+function parseCommand(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed.split(/\s+/) : void 0;
+}
+var evalVitestCommand = command({
+  name: "vitest",
+  description: "Run Vitest workspace verifier files as an AgentV code-grader protocol adapter",
+  args: {
+    testFiles: restPositionals({
+      type: string,
+      displayName: "test-files",
+      description: "Vitest verifier file(s) to run"
+    }),
+    cwd: option({
+      type: optional(string),
+      long: "cwd",
+      description: "Workspace-relative directory where Vitest should run"
+    }),
+    vitestCommand: option({
+      type: optional(string),
+      long: "vitest-command",
+      description: 'Vitest command to execute, defaults to "bunx vitest run"'
+    }),
+    timeoutMs: option({
+      type: optional(number),
+      long: "timeout-ms",
+      description: "Timeout for the Vitest command in milliseconds"
+    }),
+    inWorkspace: flag({
+      long: "in-workspace",
+      description: "Treat test files as already present in the prepared workspace instead of copying them from the current directory"
+    }),
+    passWithNoTests: flag({
+      long: "pass-with-no-tests",
+      description: "Return score 1 when Vitest reports zero tests"
+    })
+  },
+  handler: async ({ testFiles, cwd, vitestCommand, timeoutMs, inWorkspace, passWithNoTests }) => {
+    await runCodeGrader((input) => {
+      if (testFiles.length === 0) {
+        throw new Error("Provide at least one Vitest verifier file.");
+      }
+      return runVitestWorkspaceGrader(
+        {
+          testFile: testFiles,
+          cwd,
+          vitestCommand: parseCommand(vitestCommand),
+          timeoutMs,
+          passWithNoTests,
+          copyTestFilesToWorkspace: !inWorkspace,
+          testFileRoot: process.cwd()
+        },
+        input
+      );
+    });
+  }
+});
 // src/commands/eval/index.ts
 var evalCommand = subcommands({
   name: "eval",
-  description: "Evaluation commands. Shorthand: `agentv eval <eval-paths...>` aliases `agentv eval run <eval-paths...>`.",
+  description: "Evaluation commands. Shorthand: eval files run with `eval run`; verifier-looking test files run with `eval vitest`.",
   cmds: {
     run: evalRunCommand,
     assert: evalAssertCommand,
     aggregate: evalAggregateCommand,
-    bundle: evalBundleCommand
+    bundle: evalBundleCommand,
+    vitest: evalVitestCommand
   }
 });
@@ -5625,7 +6333,7 @@ function formatDurationMs2(ms) {
 }
 // src/commands/import/copilot.ts
-import { mkdir as mkdir5, readFile as readFile2, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile3, writeFile as writeFile5 } from "node:fs/promises";
 import path11 from "node:path";
 var importCopilotCommand = command({
   name: "copilot",
@@ -5692,7 +6400,7 @@ var importCopilotCommand = command({
       process.exit(1);
     }
     const eventsPath = path11.join(sessionDir, "events.jsonl");
-    const rawJsonl = await readFile2(eventsPath, "utf8");
+    const rawJsonl = await readFile3(eventsPath, "utf8");
     const parsed = parseCopilotEvents(rawJsonl);
     const transcript = {
       messages: parsed.messages,
@@ -5858,11 +6566,11 @@ 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 { mkdir as mkdir6, readFile as readFile4, writeFile as writeFile6 } from "node:fs/promises";
 import path13 from "node:path";
 import fg2 from "fast-glob";
 import JSON5 from "json5";
-import { parse as parseYaml, stringify as stringifyYaml2 } from "yaml";
+import { parse as parseYaml, stringify as stringifyYaml3 } from "yaml";
 var FILE_PREFIX = "file://";
 var PROMPTFOO_COMMENT_PREFIX = "# Converted from promptfoo config: ";
 async function convertPromptfooToAgentvSuite(options) {
@@ -5906,7 +6614,7 @@ async function convertPromptfooToAgentvSuite(options) {
 }
 async function convertPromptfooToAgentvYaml(inputPath) {
   const suite = await convertPromptfooToAgentvSuite({ inputPath });
-  const yaml = stringifyYaml2(suite, {
+  const yaml = stringifyYaml3(suite, {
     indent: 2,
     lineWidth: 0
   });
@@ -5947,7 +6655,7 @@ var importPromptfooCommand = command({
   }
 });
 async function loadPromptfooConfig(filePath) {
-  const content = await readFile3(filePath, "utf8");
+  const content = await readFile4(filePath, "utf8");
   const parsed = parseStructuredText(content, filePath);
   if (!isJsonObject(parsed)) {
     throw new Error(`promptfoo config must be an object: ${filePath}`);
@@ -6030,7 +6738,7 @@ async function loadPromptFromReference(reference, baseDir, identity2) {
   for (let index = 0; index < files.length; index++) {
     const filePath = files[index];
     const ext = path13.extname(filePath).toLowerCase();
-    const raw = await readFile3(filePath, "utf8");
+    const raw = await readFile4(filePath, "utf8");
     if (ext === ".json" || ext === ".json5" || ext === ".jsonc") {
       const parsed = parseStructuredText(raw, filePath);
       if (!Array.isArray(parsed) || !parsed.every(isPromptMessage)) {
@@ -6084,7 +6792,7 @@ async function expandProviderEntry(rawProvider, baseDir) {
       const files = await resolvePromptfooFileReference(rawProvider, baseDir);
       const providers = [];
       for (const filePath of files) {
-        const parsed = parseStructuredText(await readFile3(filePath, "utf8"), filePath);
+        const parsed = parseStructuredText(await readFile4(filePath, "utf8"), filePath);
         if (!isJsonObject(parsed)) {
           throw new Error(`Provider file must be an object: ${filePath}`);
         }
@@ -6123,7 +6831,7 @@ async function loadDefaultTest(rawDefaultTest, baseDir) {
     if (files.length !== 1) {
       throw new Error(`defaultTest must resolve to exactly one file: ${rawDefaultTest}`);
     }
-    const parsed = parseStructuredText(await readFile3(files[0], "utf8"), files[0]);
+    const parsed = parseStructuredText(await readFile4(files[0], "utf8"), files[0]);
     if (!isJsonObject(parsed)) {
       throw new Error(`defaultTest file must contain an object: ${files[0]}`);
     }
@@ -6178,7 +6886,7 @@ async function loadPromptfooTestsFromReference(reference, baseDir) {
         `Unsupported test dataset '${path13.basename(filePath)}': XLSX promptfoo datasets are not imported yet`
       );
     }
-    const content = await readFile3(filePath, "utf8");
+    const content = await readFile4(filePath, "utf8");
     if (ext === ".csv") {
       tests.push(...parseCsvPromptfooTests(content, filePath));
       continue;
@@ -6870,7 +7578,7 @@ 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 { readFileSync as readFileSync4, readdirSync, statSync } from "node:fs";
 import path14 from "node:path";
 import { fileURLToPath } from "node:url";
 function getAgentvTemplates() {
@@ -6879,7 +7587,7 @@ function getAgentvTemplates() {
 function getEnvExampleTemplate() {
   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");
+  const content = readFileSync4(path14.join(templatesBase, ".env.example"), "utf-8");
   return { path: ".env.example", content };
 }
 function getTemplatesFromDir(subdir) {
@@ -6902,7 +7610,7 @@ function readTemplatesRecursively(dir, relativePath) {
     if (stat4.isDirectory()) {
       templates.push(...readTemplatesRecursively(fullPath, entryRelativePath));
     } else {
-      const content = readFileSync3(fullPath, "utf-8");
+      const content = readFileSync4(fullPath, "utf-8");
       templates.push({
         path: entryRelativePath.split(path14.sep).join("/"),
         // Normalize to forward slashes
@@ -7022,7 +7730,7 @@ 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 { existsSync as existsSync4, readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
 import path16 from "node:path";
 function collectIndexFiles(dir) {
   const files = [];
@@ -7040,6 +7748,24 @@ function collectIndexFiles(dir) {
   }
   return files;
 }
+function collectCurrentResultIndexFiles(cwd) {
+  const resultsDir = path16.join(cwd, ".agentv", "results");
+  const files = [];
+  try {
+    const entries2 = readdirSync2(resultsDir, { withFileTypes: true });
+    for (const entry of entries2) {
+      if (isReservedResultsNamespace(entry.name)) continue;
+      const fullPath = path16.join(resultsDir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...collectIndexFiles(fullPath));
+      } else if (entry.name === "index.jsonl") {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
 function extractToolNames(record) {
   const tools = /* @__PURE__ */ new Set();
   const trace = record.trace;
@@ -7062,10 +7788,23 @@ function extractToolNames(record) {
   }
   return [...tools];
 }
+function inferExperimentFromPath(filePath) {
+  const parts = filePath.split(path16.sep);
+  const resultsIdx = parts.lastIndexOf("results");
+  if (resultsIdx === -1) return void 0;
+  const runPath = parts.slice(resultsIdx + 1, -1);
+  if (isReservedResultsNamespace(runPath[0])) return void 0;
+  if (runPath.length < 2) return void 0;
+  const candidate = runPath[0];
+  if (candidate && !/^\d{4}-\d{2}-\d{2}T/.test(candidate)) {
+    return candidate;
+  }
+  return void 0;
+}
 function parseFilterableRecords(filePath) {
   let content;
   try {
-    content = readFileSync4(filePath, "utf8");
+    content = readFileSync5(filePath, "utf8");
   } catch {
     return [];
   }
@@ -7082,14 +7821,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(path16.sep);
-      const runsIdx = parts.indexOf("runs");
-      if (runsIdx !== -1 && parts.length - runsIdx >= 3) {
-        const candidate = parts[runsIdx + 1];
-        if (candidate && !/^\d{4}-\d{2}-\d{2}T/.test(candidate)) {
-          experiment = candidate;
-        }
-      }
+      experiment = inferExperimentFromPath(filePath);
     }
     records.push({
       file: filePath,
@@ -7150,7 +7882,7 @@ function discoverFilterSources(searchPath, cwd) {
     }
     return [resolved];
   }
-  return collectIndexFiles(path16.join(cwd, ".agentv", "results", "runs"));
+  return collectCurrentResultIndexFiles(cwd);
 }
 function formatFilterTable(records) {
   const lines = [];
@@ -7194,7 +7926,7 @@ var inspectFilterCommand = command({
     path: positional({
       type: optional(string),
       displayName: "path",
-      description: "Directory or file to filter (default: .agentv/results/runs/)"
+      description: "Directory or file to filter (default: .agentv/results/)"
     }),
     target: option({
       type: optional(string),
@@ -7286,12 +8018,12 @@ var inspectFilterCommand = command({
 function formatListTable(metas) {
   const lines = [];
   if (metas.length === 0) {
-    lines.push(`${c.yellow}No run workspaces found in .agentv/results/runs/${c.reset}`);
+    lines.push(`${c.yellow}No run workspaces found in .agentv/results/${c.reset}`);
     lines.push(`${c.dim}Run an evaluation first: agentv run <eval-file>${c.reset}`);
     return lines.join("\n");
   }
   lines.push("");
-  lines.push(`${c.bold}Evaluation Runs${c.reset} ${c.dim}(.agentv/results/runs/)${c.reset}`);
+  lines.push(`${c.bold}Evaluation Runs${c.reset} ${c.dim}(.agentv/results/)${c.reset}`);
   lines.push("");
   const maxFileLen = Math.max(4, ...metas.map((m) => m.filename.length));
   const header = `  ${padRight("File", maxFileLen)}  ${padLeft("Tests", 5)}  ${padLeft("Pass", 5)}  ${padLeft("Score", 6)}  ${padLeft("Size", 7)}  Timestamp`;
@@ -7314,7 +8046,7 @@ function formatListTable(metas) {
 }
 var traceListCommand = command({
   name: "list",
-  description: "List recent evaluation run workspaces from .agentv/results/runs/",
+  description: "List recent evaluation run workspaces from .agentv/results/",
   args: {
     limit: option({
       type: optional(number),
@@ -7629,7 +8361,7 @@ 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 { existsSync as existsSync5, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
 import path17 from "node:path";
 function collectJsonlFiles(dir) {
   const files = [];
@@ -7647,6 +8379,24 @@ function collectJsonlFiles(dir) {
   }
   return files;
 }
+function collectCurrentResultJsonlFiles(cwd) {
+  const resultsDir = path17.join(cwd, ".agentv", "results");
+  const files = [];
+  try {
+    const entries2 = readdirSync3(resultsDir, { withFileTypes: true });
+    for (const entry of entries2) {
+      if (isReservedResultsNamespace(entry.name)) continue;
+      const fullPath = path17.join(resultsDir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...collectJsonlFiles(fullPath));
+      } else if (entry.name.endsWith(".jsonl")) {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
 function extractSnippet(text, matchIndex, matchLength, contextChars = 60) {
   const start = Math.max(0, matchIndex - contextChars);
   const end = Math.min(text.length, matchIndex + matchLength + contextChars);
@@ -7659,7 +8409,7 @@ function searchJsonlFile(filePath, regex2, targetFilter, experimentFilter) {
   const matches = [];
   let content;
   try {
-    content = readFileSync5(filePath, "utf8");
+    content = readFileSync6(filePath, "utf8");
   } catch {
     return matches;
   }
@@ -7709,7 +8459,7 @@ function discoverSources(basePath, cwd) {
     return [resolved];
   }
   const sources = [];
-  sources.push(...collectJsonlFiles(path17.join(cwd, ".agentv", "results", "runs")));
+  sources.push(...collectCurrentResultJsonlFiles(cwd));
   sources.push(...collectJsonlFiles(path17.join(cwd, ".agentv", "transcripts")));
   return sources;
 }
@@ -7761,7 +8511,7 @@ var inspectSearchCommand = command({
     path: positional({
       type: optional(string),
       displayName: "path",
-      description: "Directory or file to search (default: .agentv/results/runs/ and .agentv/transcripts/)"
+      description: "Directory or file to search (default: .agentv/results/ and .agentv/transcripts/)"
     }),
     target: option({
       type: optional(string),
@@ -8258,7 +9008,7 @@ var inspectCommand = subcommands({
 // src/commands/pipeline/bench.ts
 import { existsSync as existsSync6 } from "node:fs";
-import { readFile as readFile4, readdir, writeFile as writeFile7 } from "node:fs/promises";
+import { readFile as readFile5, readdir, writeFile as writeFile7 } from "node:fs/promises";
 import { join } from "node:path";
 var evalBenchCommand = command({
   name: "bench",
@@ -8271,7 +9021,7 @@ var evalBenchCommand = command({
     })
   },
   handler: async ({ exportDir }) => {
-    const manifest = JSON.parse(await readFile4(join(exportDir, "manifest.json"), "utf8"));
+    const manifest = JSON.parse(await readFile5(join(exportDir, "manifest.json"), "utf8"));
     const testIds = manifest.test_ids;
     const targetName2 = manifest.target?.name ?? "unknown";
     const suiteName = manifest.suite ?? "";
@@ -8289,7 +9039,7 @@ var evalBenchCommand = command({
       try {
         const resultFiles = (await readdir(codeResultsDir)).filter((f) => f.endsWith(".json"));
         for (const file of resultFiles) {
-          const result = JSON.parse(await readFile4(join(codeResultsDir, file), "utf8"));
+          const result = JSON.parse(await readFile5(join(codeResultsDir, file), "utf8"));
           evaluators.push({
             name: result.name,
             type: result.type ?? "code-grader",
@@ -8307,12 +9057,12 @@ var evalBenchCommand = command({
       try {
         const graderFiles = (await readdir(llmGradersDir)).filter((f) => f.endsWith(".json"));
         for (const file of graderFiles) {
-          const graderMeta = JSON.parse(await readFile4(join(llmGradersDir, file), "utf8"));
+          const graderMeta = JSON.parse(await readFile5(join(llmGradersDir, file), "utf8"));
           const graderName = graderMeta.name;
           const diskResultPath = join(testDir, "llm_grader_results", `${graderName}.json`);
           let llmResult;
           try {
-            llmResult = JSON.parse(await readFile4(diskResultPath, "utf8"));
+            llmResult = JSON.parse(await readFile5(diskResultPath, "utf8"));
           } catch {
           }
           if (llmResult) {
@@ -8370,7 +9120,7 @@ var evalBenchCommand = command({
       const timingPath = join(testDir, "timing.json");
       if (existsSync6(timingPath)) {
         try {
-          const timing = JSON.parse(await readFile4(timingPath, "utf8"));
+          const timing = JSON.parse(await readFile5(timingPath, "utf8"));
           if (typeof timing.execution_status === "string") {
             executionStatus = timing.execution_status;
           }
@@ -8465,7 +9215,7 @@ function computeStats(values) {
 }
 // src/commands/pipeline/grade.ts
-import { mkdir as mkdir7, readFile as readFile5, readdir as readdir2, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir7, readFile as readFile6, readdir as readdir2, writeFile as writeFile8 } from "node:fs/promises";
 import { join as join2 } from "node:path";
 var DEFAULT_CONCURRENCY = 10;
 async function runCodeGraders(tasks, concurrency) {
@@ -8481,7 +9231,7 @@ async function runCodeGraders(tasks, concurrency) {
   const executeGrader = async (task) => {
     const { testDir, resultsDir, graderFile, responseText } = task;
     const graderConfig = JSON.parse(
-      await readFile5(join2(testDir, "code_graders", graderFile), "utf8")
+      await readFile6(join2(testDir, "code_graders", graderFile), "utf8")
     );
     if (graderConfig.command) {
       await executeCodeGrader(graderConfig, task);
@@ -8640,7 +9390,7 @@ var evalGradeCommand = command({
   handler: async ({ exportDir, concurrency }) => {
     const maxWorkers = concurrency ?? DEFAULT_CONCURRENCY;
     const manifestPath = join2(exportDir, "manifest.json");
-    const manifest = JSON.parse(await readFile5(manifestPath, "utf8"));
+    const manifest = JSON.parse(await readFile6(manifestPath, "utf8"));
     const testIds = manifest.test_ids;
     const suiteName = manifest.suite ?? "";
     const safeSuiteName = suiteName ? suiteName.replace(/[\/\\:*?"<>|]/g, "_") : "";
@@ -8658,8 +9408,8 @@ var evalGradeCommand = command({
       }
       if (graderFiles.length === 0) continue;
       await mkdir7(resultsDir, { recursive: true });
-      const responseText = await readFile5(join2(testDir, "response.md"), "utf8");
-      const inputData = JSON.parse(await readFile5(join2(testDir, "input.json"), "utf8"));
+      const responseText = await readFile6(join2(testDir, "response.md"), "utf8");
+      const inputData = JSON.parse(await readFile6(join2(testDir, "input.json"), "utf8"));
       for (const graderFile of graderFiles) {
         tasks.push({ testId, testDir, resultsDir, graderFile, responseText, inputData });
       }
@@ -8670,7 +9420,7 @@ var evalGradeCommand = command({
 });
 // src/commands/pipeline/input.ts
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 import { mkdir as mkdir8, writeFile as writeFile9 } from "node:fs/promises";
 import { dirname, join as join3, relative, resolve } from "node:path";
 var BUILTIN_ASSERTION_TYPES = /* @__PURE__ */ new Set([
@@ -8698,7 +9448,7 @@ var evalInputCommand = command({
     out: option({
       type: optional(string),
       long: "out",
-      description: "Output directory for extracted inputs (default: .agentv/results/runs/<experiment>/<timestamp>)"
+      description: "Output directory for extracted inputs (default: .agentv/results/<experiment>/<timestamp>)"
     }),
     experiment: option({
       type: optional(string),
@@ -8872,7 +9622,7 @@ async function writeGraderConfigs(testDir, assertions, evalDir) {
       let promptContent = "";
       if (config.resolvedPromptPath) {
         try {
-          promptContent = await readFile6(config.resolvedPromptPath, "utf8");
+          promptContent = await readFile7(config.resolvedPromptPath, "utf8");
         } catch {
           promptContent = typeof config.prompt === "string" ? config.prompt : "";
         }
@@ -8921,9 +9671,9 @@ async function writeJson(filePath, data) {
 // src/commands/pipeline/run.ts
 import { exec } from "node:child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync6, unlinkSync } from "node:fs";
-import { mkdir as mkdir9, readFile as readFile7, readdir as readdir3, writeFile as writeFile10 } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { existsSync as existsSync7, readFileSync as readFileSync7, unlinkSync } from "node:fs";
+import { mkdir as mkdir9, readFile as readFile8, readdir as readdir3, writeFile as writeFile10 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
 import { dirname as dirname2, join as join4, relative as relative2, resolve as resolve2 } from "node:path";
 function extractInputText(input) {
   if (!input || input.length === 0) return "";
@@ -8937,7 +9687,7 @@ function loadEnvFile(dir) {
     const candidate = join4(current, ".env");
     if (existsSync7(candidate)) {
       const env2 = {};
-      for (const line of readFileSync6(candidate, "utf8").split("\n")) {
+      for (const line of readFileSync7(candidate, "utf8").split("\n")) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("#")) continue;
         const eqIdx = trimmed.indexOf("=");
@@ -8964,7 +9714,7 @@ var evalRunCommand2 = command({
     out: option({
       type: optional(string),
       long: "out",
-      description: "Output directory for results (default: .agentv/results/runs/<experiment>/<timestamp>)"
+      description: "Output directory for results (default: .agentv/results/<experiment>/<timestamp>)"
     }),
     workers: option({
       type: optional(number),
@@ -9089,7 +9839,7 @@ var evalRunCommand2 = command({
       if (!process.env.AGENTV_RUN_TIMESTAMP) {
         process.env.AGENTV_RUN_TIMESTAMP = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").replace(/\./g, "-");
       }
-      const mergedEnv = { ...process.env, ...envVars };
+      const mergedEnv = { ...process.env, ...envVars, AGENTV_RUN_DIR: outDir };
       const maxWorkers = workers ?? targetWorkers ?? 5;
       let invCompleted = 0;
       const invTotal = testIds.length;
@@ -9101,14 +9851,14 @@ var evalRunCommand2 = command({
       const invokeTarget = async (testId) => {
         const subpath = safeSuiteName ? [safeSuiteName, testId] : [testId];
         const testDir = join4(outDir, ...subpath);
-        const invoke = JSON.parse(await readFile7(join4(testDir, "invoke.json"), "utf8"));
+        const invoke = JSON.parse(await readFile8(join4(testDir, "invoke.json"), "utf8"));
         if (invoke.kind !== "cli") return;
-        const inputData = JSON.parse(await readFile7(join4(testDir, "input.json"), "utf8"));
+        const inputData = JSON.parse(await readFile8(join4(testDir, "input.json"), "utf8"));
         const template = invoke.command;
         const cwd = invoke.cwd;
         const timeoutMs = invoke.timeout_ms ?? 12e4;
-        const promptFile = join4(tmpdir(), `agentv-prompt-${testId}-${Date.now()}.txt`);
-        const outputFile = join4(tmpdir(), `agentv-output-${testId}-${Date.now()}.txt`);
+        const promptFile = join4(tmpdir2(), `agentv-prompt-${testId}-${Date.now()}.txt`);
+        const outputFile = join4(tmpdir2(), `agentv-output-${testId}-${Date.now()}.txt`);
         const inputText = extractInputText(inputData.input);
         await writeFile10(promptFile, inputText, "utf8");
         let rendered = template;
@@ -9135,7 +9885,7 @@ var evalRunCommand2 = command({
           const durationMs = Math.round(performance.now() - start);
           let response;
           if (existsSync7(outputFile)) {
-            response = readFileSync6(outputFile, "utf8");
+            response = readFileSync7(outputFile, "utf8");
           } else {
             response = "ERROR: No output file generated";
           }
@@ -9242,8 +9992,8 @@ Done. Results in ${outDir}`);
       }
       if (graderFiles.length === 0) continue;
       await mkdir9(resultsDir, { recursive: true });
-      const responseText = await readFile7(join4(testDir, "response.md"), "utf8");
-      const inputData = JSON.parse(await readFile7(join4(testDir, "input.json"), "utf8"));
+      const responseText = await readFile8(join4(testDir, "response.md"), "utf8");
+      const inputData = JSON.parse(await readFile8(join4(testDir, "input.json"), "utf8"));
       for (const graderFile of graderFiles) {
         graderTasks.push({ testId, testDir, resultsDir, graderFile, responseText, inputData });
       }
@@ -9294,7 +10044,7 @@ async function writeGraderConfigs2(testDir, assertions, evalDir) {
       let promptContent = "";
       if (config.resolvedPromptPath) {
         try {
-          promptContent = readFileSync6(config.resolvedPromptPath, "utf8");
+          promptContent = readFileSync7(config.resolvedPromptPath, "utf8");
         } catch {
           promptContent = typeof config.prompt === "string" ? config.prompt : "";
         }
@@ -9335,7 +10085,7 @@ var pipelineCommand = subcommands({
 });
 // src/commands/prepare/index.ts
-import { cp, mkdir as mkdir10, rename, rm, writeFile as writeFile11 } from "node:fs/promises";
+import { cp, mkdir as mkdir10, rename, rm as rm2, writeFile as writeFile11 } from "node:fs/promises";
 import path18 from "node:path";
 function setupStatusFromHook(status) {
   if (status === "success") {
@@ -9378,7 +10128,7 @@ async function moveDirectory(sourcePath, destinationPath) {
       throw error;
     }
     await cp(sourcePath, destinationPath, { recursive: true });
-    await rm(sourcePath, { recursive: true, force: true });
+    await rm2(sourcePath, { recursive: true, force: true });
   }
 }
 async function placePreparedWorkspace(prepared, destinationPath) {
@@ -9387,7 +10137,7 @@ async function placePreparedWorkspace(prepared, destinationPath) {
     return destinationPath;
   }
   await mkdir10(path18.dirname(destinationPath), { recursive: true });
-  await rm(destinationPath, { recursive: true, force: true });
+  await rm2(destinationPath, { recursive: true, force: true });
   if (prepared.cleanupPolicy.mode !== "static" && prepared.pool === void 0) {
     await moveDirectory(sourcePath, destinationPath);
     return destinationPath;
@@ -9591,7 +10341,7 @@ import {
   cpSync,
   existsSync as existsSync8,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   statSync as statSync4,
   writeFileSync as writeFileSync3
 } from "node:fs";
@@ -9607,12 +10357,12 @@ function parseJsonlLine(line) {
   return JSON.parse(line);
 }
 function readManifestRecords(manifestPath) {
-  return readFileSync7(manifestPath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map(parseJsonlLine);
+  return readFileSync8(manifestPath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map(parseJsonlLine);
 }
 function readBenchmarkMetadata(manifestPath) {
   try {
     const benchmarkPath = path19.join(path19.dirname(manifestPath), "benchmark.json");
-    const parsed = JSON.parse(readFileSync7(benchmarkPath, "utf8"));
+    const parsed = JSON.parse(readFileSync8(benchmarkPath, "utf8"));
     return {
       timestamp: parsed.metadata?.timestamp,
       displayName: parsed.metadata?.display_name
@@ -9727,10 +10477,10 @@ function sanitizePathSegment(value) {
 function defaultDisplayName(sources) {
   return `Combined run (${sources.map((source) => source.displayName).join(" + ")})`;
 }
-function defaultCombinedRunDir(cwd, startedAt) {
+function defaultCombinedRunDirForExperiment(cwd, experiment, startedAt) {
   const parsed = startedAt ? new Date(startedAt) : void 0;
   const timestamp = parsed && !Number.isNaN(parsed.getTime()) ? createRunDirName(parsed) : sanitizePathSegment(startedAt ?? "unknown-time");
-  return path19.join(cwd, ".agentv", "results", "runs", "combined", timestamp);
+  return buildDefaultRunDirFromName(cwd, experiment, timestamp);
 }
 function uniqueRunDir(baseDir) {
   if (!existsSync8(baseDir)) return baseDir;
@@ -9741,29 +10491,69 @@ function uniqueRunDir(baseDir) {
   return `${baseDir}-${suffix}`;
 }
 function toRunId(cwd, runDir) {
-  const runsRoot = path19.join(cwd, ".agentv", "results", "runs");
-  const relative3 = path19.relative(runsRoot, runDir);
-  if (relative3 === "" || relative3.startsWith("..") || path19.isAbsolute(relative3)) {
+  const relative3 = relativeRunPathFromCwd(cwd, runDir);
+  if (!relative3) {
     return path19.basename(runDir);
   }
-  const parts = relative3.split(path19.sep);
-  return parts.length > 1 ? `${parts[0]}::${parts.slice(1).join(path19.sep)}` : relative3;
+  const parts = relative3.split(path19.posix.sep);
+  if (parts.length <= 1) {
+    return relative3;
+  }
+  const experiment = parts[0];
+  const timestamp = parts.slice(1).join(path19.posix.sep);
+  return experiment === "default" ? timestamp : `${experiment}::${timestamp}`;
+}
+function experimentFromRelativeRunPath(relativeRunPath) {
+  const experiment = relativeRunPath.split(path19.posix.sep).filter(Boolean)[0];
+  return normalizeExperimentName(experiment);
+}
+function resolveCombinedExperiment(sources, requestedExperiment) {
+  const experiments = [...new Set(sources.map((source) => source.experiment))];
+  const normalizedRequested = requestedExperiment?.trim() ? normalizeExperimentName(requestedExperiment) : void 0;
+  if (experiments.length === 1) {
+    const sourceExperiment = experiments[0];
+    if (normalizedRequested === void 0) {
+      return sourceExperiment;
+    }
+    if (normalizedRequested !== sourceExperiment) {
+      throw new Error(`Combined runs from the same experiment must inherit "${sourceExperiment}".`);
+    }
+    return sourceExperiment;
+  }
+  if (normalizedRequested !== void 0) {
+    return normalizedRequested;
+  }
+  throw new Error(
+    `Combining runs from multiple experiments requires an experiment name. Source experiments: ${experiments.sort().join(", ")}`
+  );
 }
 var MANIFEST_PATH_FIELDS = [
+  "artifact_dir",
   "grading_path",
   "timing_path",
   "input_path",
   "output_path",
   "response_path",
+  "trace_path",
+  "transcript_path",
+  "metrics_path",
+  "raw_provider_log_path",
   "task_dir",
   "eval_path",
   "targets_path",
   "files_path",
   "graders_path"
 ];
+var POINTER_FAMILIES = {
+  trace: "traces",
+  transcript: "transcripts"
+};
+function isSafeRelativeArtifactPath(relativePath) {
+  return !path19.isAbsolute(relativePath) && !relativePath.split(/[\\/]+/).includes("..");
+}
 function copyReferencedArtifact(sourceBaseDir, outputDir, sourceIndex, relativePath) {
   if (!relativePath) return void 0;
-  if (path19.isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes("..")) {
+  if (!isSafeRelativeArtifactPath(relativePath)) {
     throw new Error(`Unsafe artifact path in source manifest: ${relativePath}`);
   }
   const sourcePath = path19.join(sourceBaseDir, relativePath);
@@ -9781,9 +10571,49 @@ function copyReferencedArtifact(sourceBaseDir, outputDir, sourceIndex, relativeP
   }
   return rewritten;
 }
-function rewriteAndCopyRecord(row, outputDir) {
+function rewriteArtifactPointer(pointerName, pointer, sourceBaseDir, outputDir, sourceIndex) {
+  if (!pointer) {
+    return void 0;
+  }
+  if (!isSafeRelativeArtifactPath(pointer.path)) {
+    throw new Error(`Unsafe artifact path in source manifest: ${pointer.path}`);
+  }
+  const sourcePath = path19.join(sourceBaseDir, pointer.path);
+  if (!existsSync8(sourcePath)) {
+    return { ...pointer };
+  }
+  const rewrittenPath = copyReferencedArtifact(sourceBaseDir, outputDir, sourceIndex, pointer.path);
+  if (!rewrittenPath) {
+    return { ...pointer };
+  }
+  const family = pointer.family ?? POINTER_FAMILIES[pointerName];
+  return {
+    ...pointer,
+    path: rewrittenPath,
+    key: path19.posix.join(family, rewrittenPath)
+  };
+}
+function rewriteTranscriptArtifactPointer(pointer, sourceBaseDir, outputDir, sourceIndex) {
+  return rewriteArtifactPointer("transcript", pointer, sourceBaseDir, outputDir, sourceIndex);
+}
+function rewriteArtifactPointers(pointers, sourceBaseDir, outputDir, sourceIndex) {
+  if (!pointers) {
+    return void 0;
+  }
+  return {
+    trace: rewriteArtifactPointer("trace", pointers.trace, sourceBaseDir, outputDir, sourceIndex),
+    transcript: rewriteTranscriptArtifactPointer(
+      pointers.transcript,
+      sourceBaseDir,
+      outputDir,
+      sourceIndex
+    )
+  };
+}
+function rewriteAndCopyRecord(row, outputDir, experiment) {
   const sourceBaseDir = path19.dirname(row.source.manifestPath);
   const rewritten = { ...row.record };
+  rewritten.experiment = experiment;
   for (const field of MANIFEST_PATH_FIELDS) {
     rewritten[field] = copyReferencedArtifact(
       sourceBaseDir,
@@ -9792,6 +10622,19 @@ function rewriteAndCopyRecord(row, outputDir) {
       row.record[field]
     );
   }
+  const artifactPointers = rewriteArtifactPointers(
+    row.record.artifact_pointers,
+    sourceBaseDir,
+    outputDir,
+    row.source.index
+  );
+  rewritten.artifact_pointers = artifactPointers;
+  if (row.record.trace_path && rewritten.trace_path === row.record.trace_path && artifactPointers?.trace?.path) {
+    rewritten.trace_path = artifactPointers.trace.path;
+  }
+  if (row.record.transcript_path && rewritten.transcript_path === row.record.transcript_path && artifactPointers?.transcript?.path) {
+    rewritten.transcript_path = artifactPointers.transcript.path;
+  }
   return rewritten;
 }
 function writeJson3(filePath, value) {
@@ -9809,10 +10652,18 @@ function writeJsonl(filePath, records) {
 function buildCombineRunSources(sourcePaths, cwd, options) {
   return sourcePaths.map((sourcePath, index) => {
     const manifestPath = resolveResultSourcePath(sourcePath, cwd);
+    const runDir = path19.dirname(resolveRunManifestPath(manifestPath));
+    const relativeRunPath = relativeRunPathFromCwd(cwd, runDir);
+    if (!relativeRunPath) {
+      throw new Error(
+        `Run workspace is outside the canonical results layout: ${runDir}. Expected .agentv/results/<experiment>/<timestamp>`
+      );
+    }
     return {
-      id: options?.ids?.[index] ?? path19.basename(path19.dirname(manifestPath)),
-      displayName: options?.displayNames?.[index] ?? path19.basename(path19.dirname(manifestPath)),
+      id: options?.ids?.[index] ?? toRunId(cwd, runDir),
+      displayName: options?.displayNames?.[index] ?? path19.basename(runDir),
       manifestPath,
+      experiment: experimentFromRelativeRunPath(relativeRunPath),
       tags: options?.tags?.[index]
     };
   });
@@ -9823,10 +10674,23 @@ function combineRunSources(options) {
   }
   const loadedSources = loadSources(options.sources);
   const startedAt = earliestTimestamp(loadedSources.map((source) => source.startedAt));
+  const experiment = resolveCombinedExperiment(loadedSources, options.experiment);
   const displayName = options.displayName?.trim() || defaultDisplayName(loadedSources);
   const runDir = uniqueRunDir(
-    options.outputDir ? path19.resolve(options.cwd, options.outputDir) : defaultCombinedRunDir(options.cwd, startedAt)
+    options.outputDir ? path19.resolve(options.cwd, options.outputDir) : defaultCombinedRunDirForExperiment(options.cwd, experiment, startedAt)
   );
+  const relativeOutputRunPath = relativeRunPathFromCwd(options.cwd, runDir);
+  if (!relativeOutputRunPath) {
+    throw new Error(
+      `Output run workspace must use .agentv/results/<experiment>/<timestamp>: ${runDir}`
+    );
+  }
+  const outputExperiment = experimentFromRelativeRunPath(relativeOutputRunPath);
+  if (outputExperiment !== experiment) {
+    throw new Error(
+      `Output run workspace experiment "${outputExperiment}" must match combined experiment "${experiment}".`
+    );
+  }
   const { rows, conflicts } = selectRows(
     loadedSources,
     options.duplicatePolicy,
@@ -9838,7 +10702,7 @@ function combineRunSources(options) {
     return left.localeCompare(right);
   });
   mkdirSync2(runDir, { recursive: true });
-  const records = rows.map((row) => rewriteAndCopyRecord(row, runDir));
+  const records = rows.map((row) => rewriteAndCopyRecord(row, runDir, experiment));
   const manifestPath = path19.join(runDir, "index.jsonl");
   writeJsonl(manifestPath, records);
   const timing = buildTimingArtifact(results);
@@ -9851,6 +10715,7 @@ function combineRunSources(options) {
       ...benchmark.metadata,
       timestamp: startedAt ?? benchmark.metadata.timestamp,
       display_name: displayName,
+      experiment,
       combined_from_run_ids: loadedSources.map((source) => source.id),
       combined_from_display_names: loadedSources.map((source) => source.displayName),
       duplicate_policy: options.duplicatePolicy
@@ -9866,6 +10731,7 @@ function combineRunSources(options) {
     benchmarkPath,
     timingPath,
     displayName,
+    experiment,
     combinedFromRunIds: loadedSources.map((source) => source.id),
     duplicateConflicts: conflicts,
     testCount: rows.length,
@@ -9916,8 +10782,22 @@ function parseDuplicatePolicy(policy) {
   }
   return void 0;
 }
-var resultsCombineCommand = command({
-  name: "combine",
+function uniqueSourceExperiments(sources) {
+  return [...new Set(sources.map((source) => source.experiment))].sort();
+}
+async function promptExperimentName(experiments) {
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(
+      `Source runs span experiments (${experiments.join(", ")}). New experiment name: `
+    );
+    return answer.trim() || void 0;
+  } finally {
+    rl.close();
+  }
+}
+var resultsCombineCommand = command({
+  name: "combine",
   description: "Combine two or more partial local run workspaces into a new run workspace",
   args: {
     sources: restPositionals({
@@ -9929,7 +10809,12 @@ var resultsCombineCommand = command({
       type: optional(string),
       long: "output",
       short: "o",
-      description: "Output run workspace directory (defaults to .agentv/results/runs/combined/<earliest-source-time>)"
+      description: "Output run workspace directory (defaults to .agentv/results/<experiment>/<earliest-source-time>)"
+    }),
+    experiment: option({
+      type: optional(string),
+      long: "experiment",
+      description: "Experiment namespace for the combined run. Required when sources span multiple experiments."
     }),
     displayName: option({
       type: optional(string),
@@ -9949,6 +10834,17 @@ var resultsCombineCommand = command({
     }
     const cwd = process.cwd();
     const sources = buildCombineRunSources(args.sources, cwd);
+    const sourceExperiments = uniqueSourceExperiments(sources);
+    let experiment = args.experiment;
+    if (!experiment && sourceExperiments.length > 1 && process.stdin.isTTY && process.stdout.isTTY) {
+      experiment = await promptExperimentName(sourceExperiments);
+    }
+    if (!experiment && sourceExperiments.length > 1) {
+      console.error(
+        `Error: combining runs from multiple experiments requires --experiment <name>. Source experiments: ${sourceExperiments.join(", ")}`
+      );
+      process.exit(1);
+    }
     const duplicatePolicy = defaultDuplicatePolicy(parseDuplicatePolicy(args.duplicatePolicy));
     let promptChoices;
     if (duplicatePolicy === "prompt") {
@@ -9968,6 +10864,7 @@ var resultsCombineCommand = command({
         cwd,
         sources,
         outputDir: args.output,
+        experiment,
         displayName: args.displayName,
         duplicatePolicy,
         promptChoices
@@ -9993,18 +10890,13 @@ import * as readline3 from "node:readline/promises";
 // src/commands/results/delete-run.ts
 import { existsSync as existsSync9, rmSync } from "node:fs";
 import path20 from "node:path";
-function localRunsRoot(cwd) {
-  return path20.resolve(cwd, ".agentv", "results", "runs");
-}
 function assertLocalRunManifest(cwd, manifestPath, runId) {
   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 = path20.dirname(resolvedManifestPath);
-  const runsRoot = localRunsRoot(cwd);
-  const relativeRunDir = path20.relative(runsRoot, runDir);
-  if (relativeRunDir === "" || relativeRunDir.startsWith("..") || path20.isAbsolute(relativeRunDir)) {
+  if (!relativeRunPathFromCwd(cwd, runDir)) {
     throw new Error("Run workspace is outside the local results directory");
   }
   if (!existsSync9(resolvedManifestPath)) {
@@ -10090,14 +10982,249 @@ var resultsDeleteCommand = command({
 });
 // src/commands/results/export.ts
+import { readFileSync as readFileSync9 } from "node:fs";
+import path22 from "node:path";
+// src/commands/results/projection-bundle.ts
+import { createHash } from "node:crypto";
+import { mkdir as mkdir11, writeFile as writeFile12 } from "node:fs/promises";
 import path21 from "node:path";
+var PROJECTION_BUNDLE_FILENAME = "projection_bundle.json";
+var PROJECTION_BUNDLE_SCHEMA_VERSION = "agentv.projection_bundle.v1";
+function dropUndefined(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entryValue]) => entryValue !== void 0)
+  );
+}
+function toPortablePath(filePath, cwd) {
+  const absolutePath = path21.resolve(filePath);
+  const absoluteCwd = path21.resolve(cwd ?? process.cwd());
+  const relative3 = path21.relative(absoluteCwd, absolutePath);
+  const portable = relative3 && !relative3.startsWith("..") && !path21.isAbsolute(relative3) ? relative3 : absolutePath;
+  return portable.split(path21.sep).join("/");
+}
+function stableDate(value) {
+  const parsed = value ? Date.parse(value) : Number.NaN;
+  return Number.isFinite(parsed) ? new Date(parsed) : /* @__PURE__ */ new Date(0);
+}
+function bundleCreatedAt(results) {
+  const timestamps = results.map((result) => stableDate(result.timestamp).toISOString()).sort((a, b) => a.localeCompare(b));
+  return timestamps[0] ?? (/* @__PURE__ */ new Date(0)).toISOString();
+}
+function shortHash(parts, length = 20) {
+  return createHash("sha256").update(parts.join("\n")).digest("hex").slice(0, length);
+}
+function tracePathFor(indexEntry) {
+  return indexEntry.trace_path ?? (indexEntry.artifact_dir ? path21.posix.join(indexEntry.artifact_dir, "trace.json") : void 0);
+}
+function artifactRefs(indexEntry, options) {
+  const metadataRefs = dropUndefined({
+    status: options.status,
+    timing_path: indexEntry.timing_path
+  });
+  if (!options.includeRawContent) {
+    return metadataRefs;
+  }
+  return dropUndefined({
+    ...metadataRefs,
+    artifact_dir: indexEntry.artifact_dir,
+    grading_path: indexEntry.grading_path,
+    input_path: indexEntry.input_path,
+    output_path: indexEntry.output_path,
+    answer_path: indexEntry.answer_path,
+    response_path: indexEntry.response_path,
+    transcript_path: indexEntry.transcript_path,
+    metrics_path: indexEntry.metrics_path,
+    trace_path: tracePathFor(indexEntry),
+    task_dir: indexEntry.task_dir,
+    eval_path: indexEntry.eval_path,
+    targets_path: indexEntry.targets_path,
+    files_path: indexEntry.files_path,
+    graders_path: indexEntry.graders_path
+  });
+}
+function removeTranscriptMessageMetadata(envelope) {
+  return {
+    ...envelope,
+    trace: {
+      ...envelope.trace,
+      spans: envelope.trace.spans.map((span) => ({
+        ...span,
+        events: span.events?.map((event) => {
+          const transcriptMessage = event.attributes?.["agentv.transcript.message"];
+          if (!transcriptMessage || typeof transcriptMessage !== "object" || Array.isArray(transcriptMessage)) {
+            return event;
+          }
+          const { metadata: _metadata, ...safeMessage } = transcriptMessage;
+          return {
+            ...event,
+            attributes: {
+              ...event.attributes,
+              "agentv.transcript.message": safeMessage
+            }
+          };
+        })
+      }))
+    }
+  };
+}
+function safeEnvelope(envelope, options) {
+  if (options.includeRawContent) {
+    return envelope;
+  }
+  const withoutRawEvidence = removeTranscriptMessageMetadata({
+    ...envelope,
+    source: {
+      ...envelope.source,
+      metadata: void 0
+    },
+    artifacts: void 0,
+    scores: envelope.scores?.map(({ evidence: _evidence, ...score }) => score)
+  });
+  return JSON.parse(JSON.stringify(withoutRawEvidence));
+}
+function safeScores(scores, options) {
+  if (!scores) {
+    return void 0;
+  }
+  return options.includeRawContent ? scores : scores.map(({ evidence: _evidence, ...score }) => score);
+}
+function captureOptions(includeRawContent) {
+  return includeRawContent ? { content: "full", redactionLevel: "none", redactedFields: [] } : void 0;
+}
+function rawContent(result) {
+  return dropUndefined({
+    input: result.input,
+    output: result.output,
+    trace_messages: result.trace.messages
+  });
+}
+function buildEntry(result, options, indexRecord) {
+  const includeRawContent = options.includeRawContent ?? false;
+  const sourcePath = toPortablePath(options.sourceFile, options.cwd);
+  const plannedIndexEntry = buildResultIndexArtifact(result);
+  const envelope = buildTraceEnvelopeFromEvaluationResult(result, {
+    evalPath: sourcePath,
+    runId: options.runId,
+    source: { kind: "agentv_run", path: sourcePath, format: "agentv_result" },
+    artifacts: {
+      trace_path: tracePathFor(indexRecord ?? plannedIndexEntry),
+      answer_path: result.output.length > 0 ? "outputs/answer.md" : void 0,
+      response_path: result.output.length > 0 ? "outputs/response.md" : void 0
+    },
+    duplicatePolicy: options.duplicatePolicy,
+    capture: captureOptions(includeRawContent),
+    now: () => stableDate(result.timestamp)
+  });
+  const projectionIdentity = envelope.projectionIdentity;
+  if (!projectionIdentity) {
+    throw new Error(`Result ${result.testId ?? "unknown"} is missing projection identity`);
+  }
+  const indexEntry = indexRecord ?? buildResultIndexArtifact(result, void 0, {
+    projectionIdentity,
+    duplicatePolicy: options.duplicatePolicy
+  });
+  const refs = artifactRefs(indexEntry, {
+    includeRawContent,
+    status: options.artifactRefStatus ?? "planned_export"
+  });
+  const safeEnvelopeWire = safeEnvelope(toTraceEnvelopeWire(envelope), { includeRawContent });
+  const projectionIdentityWire = indexEntry.projection_identity ?? safeEnvelopeWire.projection_identity;
+  if (!projectionIdentityWire) {
+    throw new Error(`Result ${result.testId ?? "unknown"} is missing projection identity`);
+  }
+  const envelopeWire = {
+    ...safeEnvelopeWire,
+    projection_identity: projectionIdentityWire
+  };
+  const scores = safeScores(envelopeWire.scores, { includeRawContent });
+  const feedback = dropUndefined({
+    source: "agentv_grading_artifacts",
+    result_score: result.score,
+    execution_status: result.executionStatus,
+    grading_path: refs.grading_path,
+    timing_path: refs.timing_path,
+    assertion_count: result.assertions?.length ?? 0,
+    scores
+  });
+  return {
+    projection_id: projectionIdentity.id,
+    projection_identity: projectionIdentityWire,
+    eval: envelopeWire.eval,
+    artifact_refs: refs,
+    trace: dropUndefined({
+      format: envelopeWire.trace.format,
+      trace_id: envelopeWire.trace.trace_id,
+      root_span_id: envelopeWire.trace.root_span_id,
+      span_count: envelopeWire.trace.spans.length,
+      envelope_ref: refs.trace_path
+    }),
+    trace_envelope: envelopeWire,
+    feedback,
+    capture: envelopeWire.capture,
+    ...envelopeWire.conversion_warnings ? { conversion_warnings: envelopeWire.conversion_warnings } : {},
+    ...includeRawContent ? { raw_content: rawContent(result) } : {}
+  };
+}
+function buildProjectionBundle(results, options) {
+  if (results.length === 0) {
+    throw new Error(`No results found in ${options.sourceFile}`);
+  }
+  const entries2 = results.map(
+    (result, index) => buildEntry(result, options, options.indexRecords?.[index])
+  );
+  const includeRawContent = options.includeRawContent ?? false;
+  const artifactRefStatus = options.artifactRefStatus ?? "planned_export";
+  const conversionWarnings = entries2.flatMap((entry) => entry.conversion_warnings ?? []);
+  const bundleId = `projection-bundle-${shortHash([
+    PROJECTION_BUNDLE_SCHEMA_VERSION,
+    toPortablePath(options.sourceFile, options.cwd),
+    options.runId,
+    artifactRefStatus,
+    includeRawContent ? "raw" : "metadata",
+    ...entries2.map((entry) => entry.projection_id)
+  ])}`;
+  return {
+    schema_version: PROJECTION_BUNDLE_SCHEMA_VERSION,
+    bundle_id: bundleId,
+    created_at: bundleCreatedAt(results),
+    source: {
+      kind: "agentv_run",
+      path: toPortablePath(options.sourceFile, options.cwd),
+      run_id: options.runId,
+      result_count: results.length
+    },
+    content_policy: {
+      raw_content: includeRawContent ? "included" : "excluded",
+      raw_content_opt_in: includeRawContent,
+      default_capture: includeRawContent ? "full" : "metadata",
+      backend_anonymizer_boundary: "adapter"
+    },
+    capture_summary: entries2[0]?.capture ?? {
+      content: includeRawContent ? "full" : "metadata",
+      redaction_level: includeRawContent ? "none" : "partial"
+    },
+    entries: entries2,
+    ...conversionWarnings.length > 0 ? { conversion_warnings: conversionWarnings } : {}
+  };
+}
+function serializeProjectionBundle(bundle) {
+  return `${JSON.stringify(bundle, null, 2)}
+`;
+}
+async function writeProjectionBundle(bundle, outputDir) {
+  const bundlePath = path21.join(outputDir, PROJECTION_BUNDLE_FILENAME);
+  await mkdir11(outputDir, { recursive: true });
+  await writeFile12(bundlePath, serializeProjectionBundle(bundle), "utf8");
+  return bundlePath;
+}
 // src/commands/results/shared.ts
 import { existsSync as existsSync10 } from "node:fs";
 var sourceArg = positional({
   type: optional(string),
   displayName: "source",
-  description: "Run workspace directory or index.jsonl manifest (defaults to most recent in .agentv/results/runs/)"
+  description: "Run workspace directory or index.jsonl manifest (defaults to most recent in .agentv/results/)"
 });
 async function resolveSourceFile(source, cwd) {
   let sourceFile;
@@ -10116,7 +11243,7 @@ async function resolveSourceFile(source, cwd) {
     } else {
       const metas = listResultFiles(cwd, 1);
       if (metas.length === 0) {
-        console.error("Error: No run workspaces found in .agentv/results/runs/");
+        console.error("Error: No run workspaces found in .agentv/results/");
         console.error("Run an evaluation first: agentv eval <eval-file>");
         process.exit(1);
       }
@@ -10137,32 +11264,52 @@ async function loadResults(source, cwd) {
 // src/commands/results/export.ts
 function deriveOutputDir(cwd, sourceFile) {
-  if (path21.basename(sourceFile) !== RESULT_INDEX_FILENAME) {
+  if (path22.basename(sourceFile) !== RESULT_INDEX_FILENAME) {
     throw new Error(`Expected a run manifest named ${RESULT_INDEX_FILENAME}: ${sourceFile}`);
   }
-  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 path21.join(cwd, ".agentv", "results", "export", ...segments.slice(runsIndex + 1));
+  const runDir = path22.dirname(sourceFile);
+  const segments = path22.normalize(runDir).split(path22.sep).filter(Boolean);
+  const resultsIndex = segments.lastIndexOf("results");
+  if (resultsIndex >= 0 && resultsIndex < segments.length - 2) {
+    const runSegments = segments.slice(resultsIndex + 1);
+    if (!isReservedResultsNamespace(runSegments[0])) {
+      return path22.join(cwd, ".agentv", "results", "export", ...runSegments);
+    }
   }
-  const parentDir = path21.basename(runDir);
+  const parentDir = path22.basename(runDir);
   if (parentDir.startsWith("eval_")) {
-    return path21.join(cwd, ".agentv", "results", "export", parentDir.slice(5));
+    return path22.join(cwd, ".agentv", "results", "export", parentDir.slice(5));
   }
-  return path21.join(cwd, ".agentv", "results", "export", parentDir);
+  return path22.join(cwd, ".agentv", "results", "export", parentDir);
 }
 function deriveExportRunId(sourceFile) {
-  if (path21.basename(sourceFile) === RESULT_INDEX_FILENAME) {
-    return path21.basename(path21.dirname(sourceFile));
+  if (path22.basename(sourceFile) === RESULT_INDEX_FILENAME) {
+    return path22.basename(path22.dirname(sourceFile));
   }
-  return path21.basename(sourceFile, path21.extname(sourceFile));
+  return path22.basename(sourceFile, path22.extname(sourceFile));
 }
 async function loadExportSource(source, cwd) {
   const { sourceFile } = await resolveSourceFile(source, cwd);
   const { results } = await loadResults(source, cwd);
   return { sourceFile, results };
 }
+function readIndexArtifactEntries(indexPath) {
+  return readFileSync9(indexPath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+}
+function buildProjectionBundleFromExportedIndex(options) {
+  const indexPath = path22.join(options.outputDir, RESULT_INDEX_FILENAME);
+  const indexRecords = readIndexArtifactEntries(indexPath);
+  const emittedResults = loadManifestResults(indexPath);
+  return buildProjectionBundle(emittedResults, {
+    sourceFile: options.sourceFile,
+    runId: deriveExportRunId(options.sourceFile),
+    cwd: options.cwd,
+    duplicatePolicy: options.duplicatePolicy,
+    includeRawContent: options.includeRawContent,
+    artifactRefStatus: "emitted",
+    indexRecords
+  });
+}
 var resultsExportCommand = command({
   name: "export",
   description: "Export a run workspace or index.jsonl manifest into a per-test directory structure",
@@ -10170,7 +11317,7 @@ var resultsExportCommand = command({
     source: positional({
       type: optional(string),
       displayName: "source",
-      description: "Run workspace directory or index.jsonl manifest to export (defaults to most recent in .agentv/results/runs/)"
+      description: "Run workspace directory or index.jsonl manifest to export (defaults to most recent in .agentv/results/)"
     }),
     out: option({
       type: optional(string),
@@ -10188,20 +11335,67 @@ var resultsExportCommand = command({
       type: optional(oneOf(["skip", "update", "error"])),
       long: "duplicate-policy",
       description: "How to handle duplicate projection identities in the output: update (default), skip, or error"
+    }),
+    projectionBundle: flag({
+      long: "projection-bundle",
+      description: "Write a local vendor-neutral projection_bundle.json for non-Phoenix adapters; no service calls"
+    }),
+    dryRun: flag({
+      long: "dry-run",
+      description: "Print deterministic projection bundle JSON without writing export artifacts"
+    }),
+    includeRawContent: flag({
+      long: "include-raw-content",
+      description: "Include raw prompt, output, and tool payload content in the projection bundle (off by default)"
     })
   },
-  handler: async ({ source, out, dir, duplicatePolicy }) => {
+  handler: async ({
+    source,
+    out,
+    dir,
+    duplicatePolicy,
+    projectionBundle,
+    dryRun: dryRun2,
+    includeRawContent
+  }) => {
     const cwd = dir ?? process.cwd();
     const policy = duplicatePolicy ?? "update";
+    const shouldWriteProjectionBundle = projectionBundle;
+    const shouldDryRun = dryRun2;
+    const shouldIncludeRawContent = includeRawContent;
     try {
       const { sourceFile, results } = await loadExportSource(source, cwd);
-      const outputDir = out ? path21.isAbsolute(out) ? out : path21.resolve(cwd, out) : deriveOutputDir(cwd, sourceFile);
+      const outputDir = out ? path22.isAbsolute(out) ? out : path22.resolve(cwd, out) : deriveOutputDir(cwd, sourceFile);
+      const buildBundle = () => buildProjectionBundle(results, {
+        sourceFile,
+        runId: deriveExportRunId(sourceFile),
+        cwd,
+        duplicatePolicy: policy,
+        includeRawContent: shouldIncludeRawContent
+      });
+      if (shouldDryRun) {
+        process.stdout.write(serializeProjectionBundle(buildBundle()));
+        return;
+      }
       await writeArtifactsFromResults2(results, outputDir, {
         evalFile: sourceFile,
         runId: deriveExportRunId(sourceFile),
         duplicatePolicy: policy
       });
+      const bundlePath = shouldWriteProjectionBundle ? await writeProjectionBundle(
+        buildProjectionBundleFromExportedIndex({
+          sourceFile,
+          outputDir,
+          cwd,
+          duplicatePolicy: policy,
+          includeRawContent: shouldIncludeRawContent
+        }),
+        outputDir
+      ) : void 0;
       console.log(`Exported ${results.length} test(s) to ${outputDir}`);
+      if (bundlePath) {
+        console.log(`Projection bundle written to ${bundlePath}`);
+      }
       for (const result of results) {
         console.log(`  ${result.testId ?? "unknown"}`);
       }
@@ -10257,8 +11451,8 @@ 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 path22 from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "node:fs";
+import path23 from "node:path";
 // src/commands/results/report-template.ts
 var RESULTS_REPORT_TEMPLATE = `<!DOCTYPE html>
@@ -10281,6 +11475,7 @@ var RESULTS_REPORT_TEMPLATE = `<!DOCTYPE html>
       --text-muted: #9ca3af;
       --text-subtle: #6b7280;
       --heading: #ffffff;
+      --brand-middle: #d1d5db;
       --accent: #22d3ee;
       --accent-weak: rgba(8, 145, 178, 0.2);
       --pass: #34d399;
@@ -10304,6 +11499,7 @@ var RESULTS_REPORT_TEMPLATE = `<!DOCTYPE html>
       --text-muted: #64748b;
       --text-subtle: #94a3b8;
       --heading: #0f172a;
+      --brand-middle: #64748b;
       --accent: #0891b2;
       --accent-weak: rgba(8, 145, 178, 0.1);
       --pass: #16a34a;
@@ -10401,6 +11597,18 @@ var RESULTS_REPORT_TEMPLATE = `<!DOCTYPE html>
       margin: 0;
     }
+    .brand-wordmark {
+      white-space: nowrap;
+    }
+    .brand-letter {
+      color: var(--accent);
+    }
+    .brand-middle {
+      color: var(--brand-middle);
+    }
     .header-subtitle {
       color: var(--text-muted);
       margin: 0;
@@ -11034,7 +12242,7 @@ var RESULTS_REPORT_TEMPLATE = `<!DOCTYPE html>
   <div class="shell">
     <header class="header">
       <div class="header-title-wrap">
-        <div class="eyebrow">AgentV static export</div>
+        <div class="eyebrow"><span class="brand-wordmark" aria-label="AgentV"><span class="brand-letter" aria-hidden="true">A</span><span class="brand-middle" aria-hidden="true">GENT</span><span class="brand-letter" aria-hidden="true">V</span></span> static export</div>
         <h1 class="header-title">Evaluation Report</h1>
         <p class="header-subtitle">Dashboard-themed HTML generated from an existing AgentV results workspace.</p>
       </div>
@@ -11882,25 +13090,25 @@ function normalizeEvalFileLabel(value) {
   if (!trimmed) {
     return void 0;
   }
-  return path22.basename(trimmed).replace(/\.results\.jsonl$/i, "").replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "").replace(/\.jsonl$/i, "");
+  return path23.basename(trimmed).replace(/\.results\.jsonl$/i, "").replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "").replace(/\.jsonl$/i, "");
 }
 function readBenchmarkEvalFile(sourceFile) {
-  const benchmarkPath = path22.join(path22.dirname(sourceFile), "benchmark.json");
+  const benchmarkPath = path23.join(path23.dirname(sourceFile), "benchmark.json");
   if (!existsSync11(benchmarkPath)) {
     return void 0;
   }
   try {
-    const benchmark = JSON.parse(readFileSync8(benchmarkPath, "utf8"));
+    const benchmark = JSON.parse(readFileSync10(benchmarkPath, "utf8"));
     return normalizeEvalFileLabel(benchmark.metadata?.eval_file);
   } catch {
     return void 0;
   }
 }
 function deriveReportPath(sourceFile) {
-  return path22.join(path22.dirname(sourceFile), "report.html");
+  return path23.join(path23.dirname(sourceFile), "report.html");
 }
 function serializeReportResult(result, sourceFile, manifestRecord, benchmarkEvalFile) {
-  const fallbackEvalFile = normalizeEvalFileLabel(manifestRecord?.eval_file) ?? benchmarkEvalFile ?? normalizeEvalFileLabel(result.suite) ?? path22.basename(path22.dirname(sourceFile));
+  const fallbackEvalFile = normalizeEvalFileLabel(manifestRecord?.eval_file) ?? benchmarkEvalFile ?? normalizeEvalFileLabel(result.suite) ?? path23.basename(path23.dirname(sourceFile));
   return {
     timestamp: result.timestamp,
     test_id: result.testId,
@@ -11923,7 +13131,7 @@ function serializeReportResult(result, sourceFile, manifestRecord, benchmarkEval
 async function loadReportSource(source, cwd) {
   const { sourceFile } = await resolveSourceFile(source, cwd);
   const resolvedSourceFile = resolveResultSourcePath(sourceFile, cwd);
-  const content = readFileSync8(resolvedSourceFile, "utf8");
+  const content = readFileSync10(resolvedSourceFile, "utf8");
   const records = parseResultManifest(content);
   const results = loadManifestResults(resolvedSourceFile);
   if (results.length === 0) {
@@ -11948,11 +13156,11 @@ function renderResultsReport(results, sourceFile, records, benchmarkEvalFile) {
 }
 async function writeResultsReport(source, outputPath, cwd) {
   const { sourceFile, results, records, benchmarkEvalFile } = await loadReportSource(source, cwd);
-  const resolvedOutputPath = outputPath ? path22.isAbsolute(outputPath) ? outputPath : path22.resolve(cwd, outputPath) : deriveReportPath(sourceFile);
+  const resolvedOutputPath = outputPath ? path23.isAbsolute(outputPath) ? outputPath : path23.resolve(cwd, outputPath) : deriveReportPath(sourceFile);
   const html = renderResultsReport(results, sourceFile, records, benchmarkEvalFile);
-  mkdirSync3(path22.dirname(resolvedOutputPath), { recursive: true });
+  mkdirSync3(path23.dirname(resolvedOutputPath), { recursive: true });
   writeFileSync4(resolvedOutputPath, html, "utf8");
-  const written = readFileSync8(resolvedOutputPath, "utf8");
+  const written = readFileSync10(resolvedOutputPath, "utf8");
   if (written.includes("__DATA_PLACEHOLDER__")) {
     throw new Error("Report placeholder substitution failed");
   }
@@ -12071,7 +13279,7 @@ var resultsShowCommand = command({
 });
 // src/commands/results/summary.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "node:fs";
 function formatSummary(results, grading) {
   const total = results.length;
   let passed;
@@ -12124,7 +13332,7 @@ var resultsSummaryCommand = command({
       const gradingPath = sourceFile.replace(/\.jsonl$/, ".grading.json");
       if (existsSync12(gradingPath)) {
         try {
-          grading = JSON.parse(readFileSync9(gradingPath, "utf8"));
+          grading = JSON.parse(readFileSync11(gradingPath, "utf8"));
         } catch {
         }
       }
@@ -12137,22 +13345,26 @@ var resultsSummaryCommand = command({
 });
 // src/commands/results/validate.ts
-import { existsSync as existsSync13, readFileSync as readFileSync10, statSync as statSync5 } from "node:fs";
-import path23 from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync12, statSync as statSync5 } from "node:fs";
+import path24 from "node:path";
 function checkDirectoryNaming(runDir) {
-  const dirName = path23.basename(runDir);
-  const pathSegments = path23.normalize(runDir).split(path23.sep).filter(Boolean);
-  const runsIndex = pathSegments.lastIndexOf("runs");
+  const dirName = path24.basename(runDir);
+  const pathSegments = path24.normalize(runDir).split(path24.sep).filter(Boolean);
+  const resultsIndex = pathSegments.lastIndexOf("results");
   const diagnostics = [];
-  if (runsIndex < 0 || runsIndex >= pathSegments.length - 1) {
+  if (resultsIndex >= 0 && pathSegments[resultsIndex + 1] === "runs") {
+    diagnostics.push({
+      severity: "error",
+      message: "The .agentv/results/runs namespace is no longer supported. Expected: .agentv/results/<experiment>/<timestamp>"
+    });
+  } else if (resultsIndex < 0 || resultsIndex > pathSegments.length - 3) {
     diagnostics.push({
       severity: "warning",
-      message: "Directory is not under a 'runs/' tree. Expected: .agentv/results/runs/<experiment>/<run-dir>"
+      message: "Directory is not under the canonical results tree. Expected: .agentv/results/<experiment>/<timestamp>"
     });
   }
   const isNewFormat = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z$/.test(dirName);
-  const isLegacyFormat = /^eval_\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z$/.test(dirName);
-  if (!isNewFormat && !isLegacyFormat) {
+  if (!isNewFormat) {
     diagnostics.push({
       severity: "warning",
       message: `Directory name '${dirName}' does not match the expected pattern '<ISO-timestamp>'. Example: 2026-03-27T12-42-24-429Z`
@@ -12171,14 +13383,14 @@ function validateRunDirectory(runDir) {
   return { diagnostics, entries: entries2 };
 }
 function checkIndexJsonl(runDir) {
-  const indexPath = path23.join(runDir, "index.jsonl");
+  const indexPath = path24.join(runDir, "index.jsonl");
   const diagnostics = [];
   const entries2 = [];
   if (!existsSync13(indexPath)) {
     diagnostics.push({ severity: "error", message: "index.jsonl is missing" });
     return { diagnostics, entries: entries2 };
   }
-  const content = readFileSync10(indexPath, "utf8");
+  const content = readFileSync12(indexPath, "utf8");
   const lines = content.split("\n").filter((l) => l.trim().length > 0);
   if (lines.length === 0) {
     diagnostics.push({ severity: "error", message: "index.jsonl is empty" });
@@ -12270,7 +13482,7 @@ function checkArtifactFiles(runDir, entries2) {
   for (const entry of entries2) {
     const testId = entry.test_id ?? "?";
     if (entry.grading_path) {
-      const gradingPath = path23.join(runDir, entry.grading_path);
+      const gradingPath = path24.join(runDir, entry.grading_path);
       if (!existsSync13(gradingPath)) {
         diagnostics.push({
           severity: "error",
@@ -12278,7 +13490,7 @@ function checkArtifactFiles(runDir, entries2) {
         });
       } else {
         try {
-          const grading = JSON.parse(readFileSync10(gradingPath, "utf8"));
+          const grading = JSON.parse(readFileSync12(gradingPath, "utf8"));
           if (!grading.assertions || !Array.isArray(grading.assertions)) {
             diagnostics.push({
               severity: "error",
@@ -12300,7 +13512,7 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
     if (entry.timing_path) {
-      const timingPath = path23.join(runDir, entry.timing_path);
+      const timingPath = path24.join(runDir, entry.timing_path);
       if (!existsSync13(timingPath)) {
         diagnostics.push({
           severity: "warning",
@@ -12309,7 +13521,7 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
   }
-  const benchmarkPath = path23.join(runDir, "benchmark.json");
+  const benchmarkPath = path24.join(runDir, "benchmark.json");
   if (!existsSync13(benchmarkPath)) {
     diagnostics.push({ severity: "warning", message: "benchmark.json is missing" });
   }
@@ -12326,7 +13538,7 @@ var resultsValidateCommand = command({
     })
   },
   handler: async ({ runDir }) => {
-    const resolvedDir = path23.resolve(runDir);
+    const resolvedDir = path24.resolve(runDir);
     if (!existsSync13(resolvedDir) || !statSync5(resolvedDir).isDirectory()) {
       console.error(`Error: '${runDir}' is not a directory`);
       process.exit(1);
@@ -12371,16 +13583,23 @@ 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 {
+  existsSync as existsSync16,
+  readFileSync as readFileSync14,
+  readdirSync as readdirSync4,
+  realpathSync,
+  statSync as statSync6,
+  writeFileSync as writeFileSync6
+} from "node:fs";
 import { homedir } from "node:os";
-import path26 from "node:path";
+import path27 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 { execFileSync as execFileSync2, spawn as spawn2 } from "node:child_process";
 import { createWriteStream, existsSync as existsSync14, mkdirSync as mkdirSync4 } from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var activeRuns = /* @__PURE__ */ new Map();
 function generateRunId() {
@@ -12400,7 +13619,7 @@ function pruneFinishedRuns() {
 }
 function getActiveRunTarget(indexJsonlPath) {
   for (const run2 of activeRuns.values()) {
-    if (run2.outputDir && path24.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
+    if (run2.outputDir && path25.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
       return run2.target;
     }
   }
@@ -12408,7 +13627,7 @@ function getActiveRunTarget(indexJsonlPath) {
 }
 function getActiveRunStatus(indexJsonlPath) {
   for (const run2 of activeRuns.values()) {
-    if (run2.outputDir && path24.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
+    if (run2.outputDir && path25.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
       return run2.status;
     }
   }
@@ -12418,7 +13637,7 @@ async function discoverTargetsInProject(cwd) {
   const repoRoot = await findRepoRoot(cwd) ?? cwd;
   let targetsFilePath;
   for (const candidate of TARGET_FILE_CANDIDATES) {
-    const fullPath = path24.join(cwd, candidate);
+    const fullPath = path25.join(cwd, candidate);
     if (existsSync14(fullPath)) {
       targetsFilePath = fullPath;
       break;
@@ -12426,7 +13645,7 @@ async function discoverTargetsInProject(cwd) {
   }
   if (!targetsFilePath) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const fullPath = path24.join(repoRoot, candidate);
+      const fullPath = path25.join(repoRoot, candidate);
       if (existsSync14(fullPath)) {
         targetsFilePath = fullPath;
         break;
@@ -12453,7 +13672,25 @@ function validateResumeOptions(req) {
   }
   return void 0;
 }
-function buildCliArgs(req) {
+function parseInitialTags(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    throw new Error("tags must be an array of strings");
+  }
+  return normalizeTags(value);
+}
+function normalizeRunMetadata(req) {
+  const experiment = normalizeExperimentName(req.experiment);
+  const tags = parseInitialTags(req.tags);
+  if ((req.resume || req.rerun_failed) && req.experiment?.trim()) {
+    throw new Error("experiment cannot be changed when resuming an existing run");
+  }
+  if ((req.resume || req.rerun_failed) && tags.length > 0) {
+    throw new Error("initial tags can only be set when creating a new run");
+  }
+  return { experiment, tags };
+}
+function buildCliArgs(req, experiment) {
   const args = ["eval"];
   if (req.suite_filter?.trim()) {
     for (const part of req.suite_filter.split(",")) {
@@ -12472,6 +13709,9 @@ function buildCliArgs(req) {
   if (req.target?.trim()) {
     args.push("--target", req.target.trim());
   }
+  if (experiment && req.experiment?.trim()) {
+    args.push("--experiment", experiment);
+  }
   if (req.threshold !== void 0 && req.threshold !== null) {
     args.push("--threshold", String(req.threshold));
   }
@@ -12500,17 +13740,17 @@ function buildCliPreview(args) {
 }
 function resolveCliPath(cwd) {
   const candidates = [
-    path24.join(cwd, "apps/cli/src/cli.ts"),
-    path24.join(cwd, "apps/cli/dist/cli.js")
+    path25.join(cwd, "apps/cli/src/cli.ts"),
+    path25.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 : path24.dirname(fileURLToPath2(import.meta.url));
-  const fromSrc = path24.resolve(currentDir, "../../cli.ts");
-  const fromDist = path24.resolve(currentDir, "cli.js");
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path25.dirname(fileURLToPath2(import.meta.url));
+  const fromSrc = path25.resolve(currentDir, "../../cli.ts");
+  const fromDist = path25.resolve(currentDir, "cli.js");
   if (existsSync14(fromSrc)) return { binPath: "bun", args: [fromSrc] };
   if (existsSync14(fromDist)) return { binPath: "bun", args: [fromDist] };
   if (isCommandAvailable("agentv")) {
@@ -12529,7 +13769,7 @@ function isCommandAvailable(cmd) {
 function openConsoleLogStream(outputDir) {
   try {
     mkdirSync4(outputDir, { recursive: true });
-    const stream = createWriteStream(path24.join(outputDir, "console.log"), { flags: "w" });
+    const stream = createWriteStream(path25.join(outputDir, "console.log"), { flags: "w" });
     stream.on("error", () => {
     });
     return stream;
@@ -12537,6 +13777,11 @@ function openConsoleLogStream(outputDir) {
     return void 0;
   }
 }
+function writeInitialRunTags(outputDir, tags) {
+  if (tags.length === 0) return;
+  mkdirSync4(outputDir, { recursive: true });
+  writeRunTags(path25.join(outputDir, "index.jsonl"), tags);
+}
 function registerEvalRoutes(app2, getCwd, options) {
   const readOnly = options?.readOnly === true;
   app2.get("/api/eval/discover", async (c4) => {
@@ -12581,12 +13826,18 @@ function registerEvalRoutes(app2, getCwd, options) {
     if (resumeError) {
       return c4.json({ error: resumeError }, 400);
     }
+    let metadata;
+    try {
+      metadata = normalizeRunMetadata(body);
+    } catch (err2) {
+      return c4.json({ error: err2.message }, 400);
+    }
     const cliPaths = resolveCliPath(cwd);
     if (!cliPaths) {
       return c4.json({ error: "Cannot locate agentv CLI entry point" }, 500);
     }
-    const args = buildCliArgs(body);
-    const outputDir = body.output?.trim() ? path24.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
+    const args = buildCliArgs(body, metadata.experiment);
+    const outputDir = body.output?.trim() ? path25.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd, metadata.experiment);
     if (!body.output?.trim()) {
       args.push("--output", outputDir);
     }
@@ -12604,7 +13855,8 @@ function registerEvalRoutes(app2, getCwd, options) {
     };
     activeRuns.set(runId, run2);
     try {
-      const child = spawn(cliPaths.binPath, [...cliPaths.args, ...args], {
+      writeInitialRunTags(outputDir, metadata.tags);
+      const child = spawn2(cliPaths.binPath, [...cliPaths.args, ...args], {
         cwd,
         stdio: ["ignore", "pipe", "pipe"],
         env: { ...process.env },
@@ -12714,7 +13966,13 @@ Process error: ${err2.message}
     } catch {
       return c4.json({ error: "Invalid JSON body" }, 400);
     }
-    const args = buildCliArgs(body);
+    let metadata;
+    try {
+      metadata = normalizeRunMetadata(body);
+    } catch (err2) {
+      return c4.json({ error: err2.message }, 400);
+    }
+    const args = buildCliArgs(body, metadata.experiment);
     return c4.json({ command: buildCliPreview(args) });
   });
   app2.get("/api/projects/:projectId/eval/discover", async (c4) => {
@@ -12759,12 +14017,18 @@ Process error: ${err2.message}
     if (resumeError) {
       return c4.json({ error: resumeError }, 400);
     }
+    let metadata;
+    try {
+      metadata = normalizeRunMetadata(body);
+    } catch (err2) {
+      return c4.json({ error: err2.message }, 400);
+    }
     const cliPaths = resolveCliPath(cwd);
     if (!cliPaths) {
       return c4.json({ error: "Cannot locate agentv CLI entry point" }, 500);
     }
-    const args = buildCliArgs(body);
-    const outputDir = body.output?.trim() ? path24.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
+    const args = buildCliArgs(body, metadata.experiment);
+    const outputDir = body.output?.trim() ? path25.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd, metadata.experiment);
     if (!body.output?.trim()) {
       args.push("--output", outputDir);
     }
@@ -12782,7 +14046,8 @@ Process error: ${err2.message}
     };
     activeRuns.set(runId, run2);
     try {
-      const child = spawn(cliPaths.binPath, [...cliPaths.args, ...args], {
+      writeInitialRunTags(outputDir, metadata.tags);
+      const child = spawn2(cliPaths.binPath, [...cliPaths.args, ...args], {
         cwd,
         stdio: ["ignore", "pipe", "pipe"],
         env: { ...process.env },
@@ -12880,24 +14145,30 @@ Process error: ${err2.message}
     } catch {
       return c4.json({ error: "Invalid JSON body" }, 400);
     }
-    const args = buildCliArgs(body);
+    let metadata;
+    try {
+      metadata = normalizeRunMetadata(body);
+    } catch (err2) {
+      return c4.json({ error: err2.message }, 400);
+    }
+    const args = buildCliArgs(body, metadata.experiment);
     return c4.json({ command: buildCliPreview(args) });
   });
 }
 // src/commands/results/studio-config.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "node:fs";
-import path25 from "node:path";
-import { stringify as stringifyYaml3 } from "yaml";
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync13, writeFileSync as writeFileSync5 } from "node:fs";
+import path26 from "node:path";
+import { stringify as stringifyYaml4 } from "yaml";
 var DEFAULTS = {
   threshold: DEFAULT_THRESHOLD,
   appName: "agentv"
 };
 function loadStudioConfig(agentvDir) {
-  const localConfigPath = path25.join(agentvDir, "config.yaml");
-  const globalConfigPath = path25.join(getAgentvConfigDir(), "config.yaml");
+  const localConfigPath = path26.join(agentvDir, "config.yaml");
+  const globalConfigPath = path26.join(getAgentvConfigDir(), "config.yaml");
   const localConfig = loadParsedConfig(localConfigPath);
-  const globalConfig = path25.resolve(globalConfigPath) === path25.resolve(localConfigPath) ? void 0 : loadParsedConfig(globalConfigPath);
+  const globalConfig = path26.resolve(globalConfigPath) === path26.resolve(localConfigPath) ? void 0 : loadParsedConfig(globalConfigPath);
   const threshold = [
     readThreshold(localConfig?.dashboard),
     readThreshold(localConfig?.studio),
@@ -12914,7 +14185,7 @@ function loadStudioConfig(agentvDir) {
 }
 function loadParsedConfig(configPath) {
   if (!existsSync15(configPath)) return void 0;
-  const raw = readFileSync11(configPath, "utf-8");
+  const raw = readFileSync13(configPath, "utf-8");
   const parsed = parseYamlValue(raw);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
   return parsed;
@@ -12937,10 +14208,10 @@ function saveStudioConfig(agentvDir, config) {
   if (!existsSync15(agentvDir)) {
     mkdirSync5(agentvDir, { recursive: true });
   }
-  const configPath = path25.join(agentvDir, "config.yaml");
+  const configPath = path26.join(agentvDir, "config.yaml");
   let existing = {};
   if (existsSync15(configPath)) {
-    const raw = readFileSync11(configPath, "utf-8");
+    const raw = readFileSync13(configPath, "utf-8");
     const parsed = parseYamlValue(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       existing = parsed;
@@ -12964,20 +14235,20 @@ function saveStudioConfig(agentvDir, config) {
       app_name: config.appName
     }
   };
-  const yamlStr = stringifyYaml3(existing);
+  const yamlStr = stringifyYaml4(existing);
   writeFileSync5(configPath, yamlStr, "utf-8");
 }
 // 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/:",
+  "Run it from a project root, or pass --dir so Dashboard uses <project>/.agentv/results/:",
   "  agentv dashboard --dir <project-dir>",
-  "To browse external results, configure results.repo_url or results.repo_path in config YAML.",
+  "To browse external results, configure results.repo.remote 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);
+  const resolved = path27.isAbsolute(source) ? source : path27.resolve(cwd, source);
   return new Error(
     `Unsupported Dashboard source: ${resolved}
 ${DIRECT_DASHBOARD_SOURCE_GUIDANCE}`
@@ -12989,13 +14260,13 @@ async function resolveSourceFile2(source, cwd) {
   }
   const cache = await loadRunCache(cwd);
   const cachedFile = cache ? resolveRunCacheFile(cache) : "";
-  if (cachedFile && existsSync16(cachedFile)) {
+  if (cachedFile && existsSync16(cachedFile) && relativeRunPathFromCwd(cwd, path27.dirname(cachedFile))) {
     return cachedFile;
   }
   const metas = listResultFiles(cwd, 10);
   if (metas.length === 0) {
     throw new Error(
-      "No run workspaces found in .agentv/results/runs/\nRun an evaluation first: agentv eval <eval-file>"
+      "No run workspaces found in .agentv/results/\nRun an evaluation first: agentv eval <eval-file>"
     );
   }
   if (metas.length > 1) {
@@ -13017,13 +14288,13 @@ function resolveDashboardMode(_projectCount, options) {
 }
 function bootstrapCurrentProject(cwd, options) {
   if (options.single === true) return {};
-  if (!existsSync16(path26.join(cwd, ".agentv"))) return {};
+  if (!existsSync16(path27.join(cwd, ".agentv"))) return {};
   const entry = addProject(cwd);
   touchProject(entry.id);
   return { currentProjectId: entry.id };
 }
 function feedbackPath(resultDir) {
-  return path26.join(resultDir, "feedback.json");
+  return path27.join(resultDir, "feedback.json");
 }
 function readFeedback(cwd) {
   const fp = feedbackPath(cwd);
@@ -13031,7 +14302,7 @@ function readFeedback(cwd) {
     return { reviews: [] };
   }
   try {
-    return JSON.parse(readFileSync12(fp, "utf8"));
+    return JSON.parse(readFileSync14(fp, "utf8"));
   } catch (err2) {
     console.error(`Warning: could not parse ${fp}, starting fresh: ${err2.message}`);
     return { reviews: [] };
@@ -13050,8 +14321,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 = path26.join(dirPath, entry.name);
-    const relPath = path26.relative(relativeTo, fullPath);
+    const fullPath = path27.join(dirPath, entry.name);
+    const relPath = path27.relative(relativeTo, fullPath);
     if (entry.isDirectory()) {
       return {
         name: entry.name,
@@ -13060,11 +14331,71 @@ function buildFileTree(dirPath, relativeTo) {
         children: buildFileTree(fullPath, relativeTo)
       };
     }
-    return { name: entry.name, path: relPath, type: "file" };
+    return {
+      name: entry.name,
+      path: relPath.split(path27.sep).join("/"),
+      type: "file",
+      storage: "local"
+    };
   });
 }
+function flattenFileTree(nodes) {
+  const files = [];
+  for (const node of nodes) {
+    if (node.type === "file") {
+      files.push(node);
+    } else if (node.children) {
+      files.push(...flattenFileTree(node.children));
+    }
+  }
+  return files;
+}
+function ensureCatalogFileNode(root, entry) {
+  const segments = entry.displayPath.split("/").filter(Boolean);
+  if (segments.length === 0) return;
+  let siblings = root;
+  let currentPath = "";
+  for (let i = 0; i < segments.length; i += 1) {
+    const segment = segments[i];
+    if (!segment) continue;
+    currentPath = currentPath ? `${currentPath}/${segment}` : segment;
+    const isFile = i === segments.length - 1;
+    let node = siblings.find((candidate) => candidate.name === segment);
+    if (!node) {
+      node = {
+        name: segment,
+        path: currentPath,
+        type: isFile ? "file" : "dir",
+        ...isFile ? {
+          kind: entry.kind,
+          storage: entry.storage,
+          ...entry.ref && { ref: entry.ref },
+          ...entry.key && { key: entry.key },
+          ...entry.sha256 && { sha256: entry.sha256 },
+          ...entry.mediaType && { media_type: entry.mediaType }
+        } : { children: [] }
+      };
+      siblings.push(node);
+      siblings.sort((a, b) => {
+        if (a.type !== b.type) return a.type === "dir" ? -1 : 1;
+        return a.name.localeCompare(b.name);
+      });
+    }
+    if (isFile) {
+      node.kind = entry.kind;
+      node.storage = entry.storage;
+      if (entry.ref) node.ref = entry.ref;
+      if (entry.key) node.key = entry.key;
+      if (entry.sha256) node.sha256 = entry.sha256;
+      if (entry.mediaType) node.media_type = entry.mediaType;
+      return;
+    }
+    node.children ??= [];
+    siblings = node.children;
+  }
+}
 function inferLanguage(filePath) {
-  const ext = path26.extname(filePath).toLowerCase();
+  const ext = path27.extname(filePath).toLowerCase();
   const langMap = {
     ".json": "json",
     ".jsonl": "json",
@@ -13091,22 +14422,383 @@ function inferLanguage(filePath) {
   return langMap[ext] ?? "plaintext";
 }
 function inferRawContentType(filePath) {
-  const ext = path26.extname(filePath).toLowerCase();
+  const ext = path27.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 path26.basename(filePath).replace(/["\\\r\n]/g, "_");
+  return path27.basename(filePath).replace(/["\\\r\n]/g, "_");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function artifactPointerPath(pointer) {
+  if (typeof pointer === "string") return nonEmptyString(pointer);
+  if (!isRecord2(pointer)) return void 0;
+  return nonEmptyString(pointer.path) ?? nonEmptyString(pointer.artifact_path) ?? nonEmptyString(pointer.relative_path);
+}
+function artifactPointerDescription(pointer) {
+  if (typeof pointer === "string") return pointer;
+  if (!isRecord2(pointer)) return void 0;
+  const ref = nonEmptyString(pointer.ref);
+  const storage = nonEmptyString(pointer.storage);
+  const uri = nonEmptyString(pointer.uri) ?? nonEmptyString(pointer.href);
+  const pointerPath = artifactPointerPath(pointer);
+  const parts = [
+    ref ? `ref ${ref}` : void 0,
+    storage ? `storage ${storage}` : void 0,
+    uri ? `uri ${uri}` : void 0,
+    pointerPath ? `path ${pointerPath}` : void 0
+  ].filter((part) => part !== void 0);
+  return parts.length > 0 ? parts.join(", ") : void 0;
+}
+function artifactPointerRef(pointer) {
+  return isRecord2(pointer) ? nonEmptyString(pointer.ref) : void 0;
+}
+function artifactPointerKey(pointer) {
+  return isRecord2(pointer) ? nonEmptyString(pointer.key) : void 0;
+}
+function artifactPointerSha256(pointer) {
+  return isRecord2(pointer) ? nonEmptyString(pointer.sha256) : void 0;
+}
+function artifactPointerMediaType(pointer) {
+  return isRecord2(pointer) ? nonEmptyString(pointer.media_type) : void 0;
+}
+function artifactPointerObjectVersion(pointer) {
+  return isRecord2(pointer) ? nonEmptyString(pointer.object_version) : void 0;
+}
+function resolveRecordArtifactPointer(record, kind) {
+  const pointer = kind === "transcript" ? record.transcript ?? record.artifacts?.transcript ?? record.artifact_pointers?.transcript : kind === "trace" ? record.artifact_pointers?.trace ?? record.artifacts?.trace : record.artifacts?.answer;
+  const pointerPath = artifactPointerPath(pointer);
+  const description = artifactPointerDescription(pointer);
+  const ref = artifactPointerRef(pointer);
+  const key = artifactPointerKey(pointer);
+  const sha256 = artifactPointerSha256(pointer);
+  const mediaType = artifactPointerMediaType(pointer);
+  const objectVersion = artifactPointerObjectVersion(pointer);
+  if ((kind === "transcript" || kind === "trace") && pointerPath) {
+    return {
+      path: pointerPath,
+      description,
+      ref,
+      ...key && { key },
+      ...sha256 && { sha256 },
+      ...mediaType && { mediaType },
+      ...objectVersion && { objectVersion }
+    };
+  }
+  const recordWithTrace = record;
+  const directPath = kind === "transcript" ? record.transcript_path ?? record.artifacts?.transcript_path : kind === "trace" ? recordWithTrace.trace_path ?? nonEmptyString(record.artifacts?.trace_path) : record.answer_path ?? record.artifacts?.answer_path ?? record.output_path;
+  if (directPath) {
+    return { path: directPath, description: directPath };
+  }
+  if (pointerPath) {
+    return {
+      path: pointerPath,
+      description,
+      ref,
+      ...key && { key },
+      ...sha256 && { sha256 },
+      ...mediaType && { mediaType },
+      ...objectVersion && { objectVersion }
+    };
+  }
+  if (pointer) {
+    return {
+      description,
+      ref,
+      ...key && { key },
+      ...sha256 && { sha256 },
+      ...mediaType && { mediaType },
+      ...objectVersion && { objectVersion },
+      unsupportedReason: description ? `${kind} artifact pointer does not include a local path (${description}).` : `${kind} artifact pointer does not include a local path.`
+    };
+  }
+  return {};
+}
+function resolveRunArtifactPath(baseDir, relativePath) {
+  const absolutePath = path27.resolve(baseDir, relativePath);
+  const resolvedBase = path27.resolve(baseDir);
+  if (!isPathInsideDirectory(resolvedBase, absolutePath)) {
+    return { error: "Artifact path is outside the run workspace." };
+  }
+  return { absolutePath };
+}
+function isPathInsideDirectory(baseDir, candidatePath) {
+  const relative3 = path27.relative(baseDir, candidatePath);
+  return relative3 === "" || !!relative3 && !relative3.startsWith("..") && !path27.isAbsolute(relative3);
+}
+function resolveReadableRunArtifactFile(baseDir, relativePath) {
+  const resolved = resolveRunArtifactPath(baseDir, relativePath);
+  if (!resolved.absolutePath) return { error: resolved.error };
+  let realBase;
+  let realArtifact;
+  try {
+    realBase = realpathSync(baseDir);
+    realArtifact = realpathSync(resolved.absolutePath);
+  } catch {
+    return {};
+  }
+  if (!isPathInsideDirectory(realBase, realArtifact)) {
+    return { error: "Artifact path is outside the run workspace." };
+  }
+  try {
+    if (!statSync6(realArtifact).isFile()) {
+      return {};
+    }
+  } catch {
+    return {};
+  }
+  return { absolutePath: realArtifact };
+}
+function normalizeArtifactRelativePath(relativePath) {
+  const normalized = relativePath.split(path27.sep).join("/");
+  const segments = normalized.split("/").filter(Boolean);
+  if (segments.length === 0 || normalized.startsWith("/") || segments.some((segment) => segment === "..")) {
+    return void 0;
+  }
+  return segments.join("/");
+}
+function relativeRunPathFromNormalizedManifestPath(manifestPath) {
+  const parts = manifestPath.split("/").filter(Boolean);
+  const runsIndex = parts.lastIndexOf("runs");
+  if (runsIndex === -1 || parts.at(-1) !== "index.jsonl") {
+    return void 0;
+  }
+  const runParts = parts.slice(runsIndex + 1, -1);
+  return runParts.length > 0 ? runParts.join("/") : void 0;
+}
+function relativeRunPathFromManifestPath(manifestPath) {
+  return relativeRunPathFromNormalizedManifestPath(manifestPath.split(path27.sep).join("/"));
+}
+function relativeRunPathFromManifest(repoDir, manifestPath) {
+  const relativeManifestPath = path27.relative(repoDir, manifestPath).split(path27.sep).join("/");
+  if (relativeManifestPath.length === 0 || relativeManifestPath === manifestPath || relativeManifestPath.startsWith("../")) {
+    return void 0;
+  }
+  return relativeRunPathFromNormalizedManifestPath(relativeManifestPath);
+}
+function sidecarArtifactKeyForPointer(repoDir, manifestPath, artifact) {
+  const publishedKey = artifact.key ? normalizeArtifactRelativePath(artifact.key) : void 0;
+  if (publishedKey?.startsWith("runs/")) {
+    return publishedKey;
+  }
+  if (!artifact.path) {
+    return publishedKey;
+  }
+  const relativeArtifactPath = normalizeArtifactRelativePath(artifact.path);
+  const relativeRunPath = relativeRunPathFromManifest(repoDir, manifestPath);
+  if (!relativeArtifactPath || !relativeRunPath) {
+    return void 0;
+  }
+  return ["runs", relativeRunPath, relativeArtifactPath].join("/");
+}
+async function readSidecarArtifactText(searchDir, projectId, meta, artifact) {
+  if (artifact.ref !== AGENTV_RESULTS_ARTIFACTS_REF) {
+    return void 0;
+  }
+  const config = await loadNormalizedResultsConfig(searchDir, projectId);
+  if (!config) {
+    return void 0;
+  }
+  const key = sidecarArtifactKeyForPointer(config.path, meta.path, artifact);
+  if (!key) {
+    return void 0;
+  }
+  const bytes = await readGitResultArtifact({
+    repoDir: config.path,
+    key,
+    ref: AGENTV_RESULTS_ARTIFACTS_REF,
+    remote: config.remote,
+    ...artifact.sha256 && { sha256: artifact.sha256 },
+    ...artifact.objectVersion && { objectVersion: artifact.objectVersion }
+  });
+  return bytes?.toString("utf8");
+}
+function addDirectArtifactCatalogEntry(entries2, seen, displayPath, kind) {
+  const normalized = displayPath ? normalizeArtifactRelativePath(displayPath) : void 0;
+  if (!normalized || seen.has(normalized)) return;
+  seen.add(normalized);
+  entries2.push({
+    displayPath: normalized,
+    kind,
+    storage: "local",
+    path: normalized
+  });
+}
+function addPointerArtifactCatalogEntry(entries2, seen, artifact, kind, runPath) {
+  const artifactPath = artifact.path ? normalizeArtifactRelativePath(artifact.path) : void 0;
+  const displayPath = artifactPath ?? displayPathFromArtifactKey(artifact.key, runPath);
+  if (!displayPath || seen.has(displayPath)) return;
+  seen.add(displayPath);
+  entries2.push({
+    displayPath,
+    kind,
+    storage: artifact.ref ? "git" : "local",
+    ...artifactPath && { path: artifactPath },
+    ...artifact.ref && { ref: artifact.ref },
+    ...artifact.key && { key: artifact.key },
+    ...artifact.sha256 && { sha256: artifact.sha256 },
+    ...artifact.mediaType && { mediaType: artifact.mediaType },
+    ...artifact.objectVersion && { objectVersion: artifact.objectVersion }
+  });
+}
+function displayPathFromArtifactKey(key, runPath) {
+  const normalizedKey = key ? normalizeArtifactRelativePath(key) : void 0;
+  if (!normalizedKey) return void 0;
+  if (!runPath) return normalizedKey;
+  const runPrefix = `runs/${runPath}/`;
+  if (!normalizedKey.startsWith(runPrefix)) return normalizedKey;
+  return normalizeArtifactRelativePath(normalizedKey.slice(runPrefix.length)) ?? normalizedKey;
+}
+function buildResultArtifactCatalog(record, options) {
+  const entries2 = [];
+  const seen = /* @__PURE__ */ new Set();
+  const transcript = resolveRecordArtifactPointer(record, "transcript");
+  const trace = resolveRecordArtifactPointer(record, "trace");
+  const answer = resolveRecordArtifactPointer(record, "answer");
+  const recordWithTrace = record;
+  addPointerArtifactCatalogEntry(entries2, seen, transcript, "transcript", options?.runPath);
+  addPointerArtifactCatalogEntry(entries2, seen, trace, "trace", options?.runPath);
+  addPointerArtifactCatalogEntry(entries2, seen, answer, "answer", options?.runPath);
+  addDirectArtifactCatalogEntry(entries2, seen, record.grading_path, "artifact");
+  addDirectArtifactCatalogEntry(entries2, seen, record.timing_path, "artifact");
+  addDirectArtifactCatalogEntry(entries2, seen, record.input_path, "artifact");
+  addDirectArtifactCatalogEntry(entries2, seen, record.output_path, "artifact");
+  addDirectArtifactCatalogEntry(entries2, seen, record.response_path, "artifact");
+  addDirectArtifactCatalogEntry(entries2, seen, record.answer_path, "answer");
+  addDirectArtifactCatalogEntry(entries2, seen, record.transcript_path, "transcript");
+  addDirectArtifactCatalogEntry(entries2, seen, recordWithTrace.trace_path, "trace");
+  addDirectArtifactCatalogEntry(entries2, seen, record.eval_path, "artifact");
+  addDirectArtifactCatalogEntry(entries2, seen, record.targets_path, "artifact");
+  return entries2;
+}
+function resultArtifactTreeRootPaths(record, catalog) {
+  return [
+    ...catalog.filter((entry) => entry.storage === "local").map((entry) => entry.displayPath),
+    record.task_dir,
+    record.files_path,
+    record.graders_path
+  ].filter((p, index, all) => !!p && all.indexOf(p) === index);
+}
+function buildLocalResultArtifactTree(baseDir, record, catalog) {
+  const knownPaths = resultArtifactTreeRootPaths(record, catalog);
+  if (knownPaths.length === 0) return [];
+  const artifactDirs = knownPaths.map((p) => path27.dirname(p));
+  let commonDir = artifactDirs[0];
+  for (const dir of artifactDirs) {
+    while (!dir.startsWith(commonDir)) {
+      commonDir = path27.dirname(commonDir);
+    }
+  }
+  return buildFileTree(path27.join(baseDir, commonDir), baseDir);
+}
+function catalogEntryForDiscoveredLocalFile(nodes, displayPath) {
+  const normalized = normalizeArtifactRelativePath(displayPath);
+  if (!normalized) return void 0;
+  const file = flattenFileTree(nodes).find((node) => node.path === normalized);
+  return file ? { displayPath: normalized, kind: "artifact", storage: "local", path: normalized } : void 0;
+}
+function findArtifactCatalogEntry(catalog, displayPath) {
+  const normalized = normalizeArtifactRelativePath(displayPath);
+  return normalized ? catalog.find((entry) => normalizeArtifactRelativePath(entry.displayPath) === normalized) : void 0;
+}
+function findPointerArtifactCatalogEntry(catalog, artifact, kind, runPath) {
+  const displayPath = (artifact.path ? normalizeArtifactRelativePath(artifact.path) : void 0) ?? displayPathFromArtifactKey(artifact.key, runPath);
+  if (displayPath) {
+    const entry = findArtifactCatalogEntry(catalog, displayPath);
+    if (entry) return entry;
+  }
+  return catalog.find(
+    (entry) => entry.kind === kind && artifact.key !== void 0 && entry.key !== void 0 && entry.key === artifact.key
+  );
+}
+async function readArtifactCatalogEntryText(searchDir, projectId, meta, entry) {
+  const baseDir = path27.dirname(meta.path);
+  if (entry.storage === "local") {
+    const resolved = resolveReadableRunArtifactFile(baseDir, entry.displayPath);
+    if (resolved.error) return { error: resolved.error };
+    if (!resolved.absolutePath) return {};
+    return { content: readFileSync14(resolved.absolutePath, "utf8") };
+  }
+  const localResolved = resolveReadableRunArtifactFile(baseDir, entry.displayPath);
+  if (localResolved.error) return { error: localResolved.error };
+  if (localResolved.absolutePath) {
+    return { content: readFileSync14(localResolved.absolutePath, "utf8") };
+  }
+  if (entry.ref !== AGENTV_RESULTS_ARTIFACTS_REF) {
+    return {};
+  }
+  const content = await readSidecarArtifactText(searchDir, projectId, meta, {
+    path: entry.path ?? entry.displayPath,
+    ref: entry.ref,
+    ...entry.key && { key: entry.key },
+    ...entry.sha256 && { sha256: entry.sha256 },
+    ...entry.objectVersion && { objectVersion: entry.objectVersion }
+  });
+  return { content };
+}
+function artifactFileContentResponse(c4, filePath, fileContent) {
+  if (c4.req.query("raw") === "1" || c4.req.query("download") === "1") {
+    c4.header("Content-Type", inferRawContentType(filePath));
+    if (c4.req.query("download") === "1") {
+      c4.header(
+        "Content-Disposition",
+        `attachment; filename="${contentDispositionFilename(filePath)}"`
+      );
+    }
+    return c4.body(fileContent);
+  }
+  const language = inferLanguage(filePath);
+  return c4.json({ content: fileContent, language });
+}
+function missingTranscriptMessage() {
+  return [
+    "This result does not include canonical transcript.jsonl metadata.",
+    "Dashboard does not parse response.md or markdown transcripts for this view."
+  ].join(" ");
+}
+var TRACE_SESSION_ARTIFACT_RESPONSE_SCHEMA_VERSION = "agentv.dashboard.trace_artifact.v1";
+function traceSessionArtifactResponse(response) {
+  return {
+    schema_version: TRACE_SESSION_ARTIFACT_RESPONSE_SCHEMA_VERSION,
+    ...response
+  };
+}
+function missingTraceMessage() {
+  return [
+    "This result does not include canonical trace.json metadata.",
+    "Dashboard trace sessions require an agentv.trace.v1 sidecar artifact."
+  ].join(" ");
+}
+function parseTraceArtifactJson(content) {
+  try {
+    return { value: JSON.parse(content) };
+  } catch (error) {
+    return {
+      message: `Trace artifact is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
 }
 function stripHeavyFields(results) {
   return results.map((r) => {
-    const { requests, trace, ...rest } = r;
+    const {
+      requests,
+      trace,
+      metadata: rawMetadata,
+      ...rest
+    } = r;
+    const metadata = omitExternalTraceMetadataKeys(rawMetadata);
     const toolCalls = trace?.toolCalls && Object.keys(trace.toolCalls).length > 0 ? trace.toolCalls : void 0;
     const graderDurationMs = (r.scores ?? []).reduce((sum, s) => sum + (s.durationMs ?? 0), 0);
     return {
       ...rest,
+      ...metadata && { metadata },
       ...toolCalls && { _toolCalls: toolCalls },
       ...graderDurationMs > 0 && { _graderDurationMs: graderDurationMs }
     };
@@ -13124,23 +14816,53 @@ function inferExperimentFromRunId(runId) {
   return experiment;
 }
 async function readRunTagFields(searchDir, meta, projectId) {
+  if (meta.on_remote) {
+    const state2 = await readRemoteRunTagState(searchDir, meta, projectId);
+    if (state2) {
+      return {
+        tags: state2.tags,
+        remote_tags: state2.remoteTags,
+        metadata_dirty: state2.dirty,
+        ...state2.dirty && { pending_tags: state2.pendingTags ?? state2.tags },
+        ...materializeRunState({
+          tags: state2.tags,
+          tagRevision: state2.tagRevision,
+          updatedAt: state2.updatedAt
+        })
+      };
+    }
+  }
   if (meta.source === "local") {
     const tagsEntry = readRunTags(meta.path);
-    return tagsEntry ? { tags: tagsEntry.tags } : {};
+    const runState = materializeRunState({
+      tags: tagsEntry?.tags ?? [],
+      tagRevision: tagsEntry?.tag_revision,
+      updatedAt: tagsEntry?.updated_at || void 0
+    });
+    return {
+      ...tagsEntry ? { tags: tagsEntry.tags } : {},
+      ...runState
+    };
   }
   const state = await readRemoteRunTagState(searchDir, meta, projectId);
   if (!state) {
     return {
       tags: [],
       remote_tags: [],
-      metadata_dirty: false
+      metadata_dirty: false,
+      ...materializeRunState({ tags: [] })
     };
   }
   return {
     tags: state.tags,
     remote_tags: state.remoteTags,
     metadata_dirty: state.dirty,
-    ...state.dirty && { pending_tags: state.pendingTags ?? state.tags }
+    ...state.dirty && { pending_tags: state.pendingTags ?? state.tags },
+    ...materializeRunState({
+      tags: state.tags,
+      tagRevision: state.tagRevision,
+      updatedAt: state.updatedAt
+    })
   };
 }
 function remoteTagMutationResponse(state) {
@@ -13149,22 +14871,64 @@ function remoteTagMutationResponse(state) {
     remote_tags: state.remoteTags,
     metadata_dirty: state.dirty,
     ...state.dirty && { pending_tags: state.pendingTags ?? state.tags },
+    ...materializeRunState({
+      tags: state.tags,
+      tagRevision: state.tagRevision,
+      updatedAt: state.updatedAt
+    }),
     updated_at: state.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+function localTagMutationResponse(input) {
+  return materializeRunState({
+    tags: input.tags,
+    tagRevision: input.tagRevision,
+    updatedAt: input.updatedAt
+  });
+}
 function remoteMetadataErrorStatus(error) {
+  if (error instanceof TagRevisionConflictError) {
+    return 409;
+  }
   const message = error instanceof Error ? error.message : String(error);
   if (message.includes("not configured") || message.includes("not a writable git checkout") || message.includes("outside the results repo runs directory")) {
     return 409;
   }
   return 400;
 }
+function tagMutationErrorBody(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (error instanceof TagRevisionConflictError) {
+    return {
+      error: message,
+      expected_tag_revision: error.expectedRevision,
+      current_tag_revision: error.currentRevision
+    };
+  }
+  return { error: message };
+}
+function expectedTagRevisionFromRecord(record) {
+  const raw = record.expected_tag_revision ?? record.tag_revision ?? record.etag;
+  if (raw === void 0) return void 0;
+  if (typeof raw !== "string") {
+    throw new Error("expected_tag_revision must be a string");
+  }
+  return raw;
+}
+function currentLocalTagRevision(manifestPath) {
+  const tagsEntry = readRunTags(manifestPath);
+  return materializeRunState({
+    tags: tagsEntry?.tags ?? [],
+    tagRevision: tagsEntry?.tag_revision,
+    updatedAt: tagsEntry?.updated_at || void 0
+  }).tag_revision;
+}
 async function ensureRunReadable(searchDir, meta, projectId) {
   await ensureRemoteRunAvailable(searchDir, meta, projectId);
 }
 async function loadManifestResultsForMeta(searchDir, meta, projectId) {
   await ensureRunReadable(searchDir, meta, projectId);
-  return loadManifestResults(meta.path);
+  return loadManifestResults(meta.path, { hydrateTranscriptTrace: false });
 }
 async function loadLightweightResultsForMeta(searchDir, meta, projectId) {
   await ensureRunReadable(searchDir, meta, projectId);
@@ -13172,7 +14936,7 @@ async function loadLightweightResultsForMeta(searchDir, meta, projectId) {
 }
 async function parseManifestForMeta(searchDir, meta, projectId) {
   await ensureRunReadable(searchDir, meta, projectId);
-  return parseResultManifest(readFileSync12(meta.path, "utf8"));
+  return parseResultManifest(readFileSync14(meta.path, "utf8"));
 }
 var DEFAULT_RUN_PAGE_LIMIT = 50;
 function parseRunPageLimit(limitParam) {
@@ -13319,12 +15083,12 @@ 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 = path26.join(path26.dirname(meta.path), "console.log");
+  const logPath = path27.join(path27.dirname(meta.path), "console.log");
   if (!existsSync16(logPath)) {
     return c4.json({ error: "Run log not found for this run" }, 404);
   }
   try {
-    const content = readFileSync12(logPath, "utf8");
+    const content = readFileSync14(logPath, "utf8");
     return c4.text(content);
   } catch {
     return c4.json({ error: "Failed to read run log" }, 500);
@@ -13336,11 +15100,12 @@ async function handleRunDetail(c4, { searchDir, projectId }) {
   if (!meta) return c4.json({ error: "Run not found" }, 404);
   try {
     const loaded = await loadManifestResultsForMeta(searchDir, meta, projectId);
+    const records = await parseManifestForMeta(searchDir, meta, projectId);
     const resumeMeta = meta.source === "local" ? deriveResumeMeta(searchDir, meta.path) : {};
     const liveStatus = meta.source === "local" ? getActiveRunStatus(meta.path) : void 0;
     const tagFields = await readRunTagFields(searchDir, meta, projectId);
     return c4.json({
-      results: stripHeavyFields(loaded),
+      results: attachExternalTraceFields(stripHeavyFields(loaded), records),
       source: meta.source,
       source_label: meta.displayName,
       ...tagFields,
@@ -13351,15 +15116,39 @@ async function handleRunDetail(c4, { searchDir, projectId }) {
     return c4.json({ error: "Failed to load run" }, 500);
   }
 }
+function isPhoenixExternalTrace(metadata) {
+  const provider = metadata.provider?.toLowerCase();
+  return provider === void 0 || provider === "phoenix";
+}
+function externalTraceWireFromManifestRecord(record) {
+  if (!record) {
+    return void 0;
+  }
+  const metadata = externalTraceMetadataFromRecord(record) ?? externalTraceMetadataFromRecord(record.metadata);
+  if (!metadata || !isPhoenixExternalTrace(metadata)) {
+    return void 0;
+  }
+  try {
+    return toExternalTraceMetadataWire(metadata);
+  } catch {
+    return void 0;
+  }
+}
+function attachExternalTraceFields(results, records) {
+  return results.map((result, index) => {
+    const externalTrace = externalTraceWireFromManifestRecord(records[index]);
+    return externalTrace ? { ...result, external_trace: externalTrace } : result;
+  });
+}
 function deriveResumeMeta(cwd, manifestPath) {
   const out = {};
-  const runDir = path26.dirname(manifestPath);
-  const relative3 = path26.relative(cwd, runDir);
+  const runDir = path27.dirname(manifestPath);
+  const relative3 = path27.relative(cwd, runDir);
   out.run_dir = relative3 !== "" && !relative3.startsWith("..") ? relative3 : runDir;
   try {
-    const benchmarkPath = path26.join(runDir, "benchmark.json");
+    const benchmarkPath = path27.join(runDir, "benchmark.json");
     if (existsSync16(benchmarkPath)) {
-      const parsed = JSON.parse(readFileSync12(benchmarkPath, "utf8"));
+      const parsed = JSON.parse(readFileSync14(benchmarkPath, "utf8"));
       const evalFile = parsed.metadata?.eval_file;
       if (typeof evalFile === "string" && evalFile.trim()) {
         out.suite_filter = evalFile.trim();
@@ -13494,31 +15283,17 @@ 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 = path26.dirname(meta.path);
-    const knownPaths = [
-      record.grading_path,
-      record.timing_path,
-      record.input_path,
-      record.output_path,
-      record.response_path,
-      record.answer_path,
-      record.transcript_path,
-      record.task_dir,
-      record.eval_path,
-      record.targets_path,
-      record.files_path,
-      record.graders_path
-    ].filter((p) => !!p);
-    if (knownPaths.length === 0) return c4.json({ files: [] });
-    const artifactDirs = knownPaths.map((p) => path26.dirname(p));
-    let commonDir = artifactDirs[0];
-    for (const dir of artifactDirs) {
-      while (!dir.startsWith(commonDir)) {
-        commonDir = path26.dirname(commonDir);
-      }
-    }
-    const artifactAbsDir = path26.join(baseDir, commonDir);
-    const files = buildFileTree(artifactAbsDir, baseDir);
+    const baseDir = path27.dirname(meta.path);
+    const catalog = buildResultArtifactCatalog(record, {
+      runPath: relativeRunPathFromManifestPath(meta.path)
+    });
+    const files = buildLocalResultArtifactTree(baseDir, record, catalog);
+    const localFilePaths = new Set(flattenFileTree(files).map((file) => file.path));
+    for (const entry of catalog) {
+      if (entry.storage === "git" || !localFilePaths.has(entry.displayPath)) {
+        ensureCatalogFileNode(files, entry);
+      }
+    }
     return c4.json({ files });
   } catch {
     return c4.json({ error: "Failed to load file tree" }, 500);
@@ -13526,6 +15301,7 @@ async function handleEvalFiles(c4, { searchDir, projectId }) {
 }
 async function handleEvalFileContent(c4, { searchDir, projectId }) {
   const filename = c4.req.param("filename") ?? "";
+  const evalId = c4.req.param("evalId");
   const meta = await findRunById(searchDir, filename, projectId);
   if (!meta) return c4.json({ error: "Run not found" }, 404);
   const marker = "/files/";
@@ -13539,30 +15315,213 @@ async function handleEvalFileContent(c4, { searchDir, projectId }) {
   }
   if (!filePath) return c4.json({ error: "No file path specified" }, 400);
   await ensureRunReadable(searchDir, meta, projectId);
-  const baseDir = path26.dirname(meta.path);
-  const absolutePath = path26.resolve(baseDir, filePath);
-  if (!absolutePath.startsWith(path26.resolve(baseDir) + path26.sep) && absolutePath !== path26.resolve(baseDir)) {
+  const records = parseResultManifest(readFileSync14(meta.path, "utf8"));
+  const record = records.find((r) => r.test_id === evalId);
+  if (!record) return c4.json({ error: "Eval not found" }, 404);
+  const catalog = buildResultArtifactCatalog(record, {
+    runPath: relativeRunPathFromManifestPath(meta.path)
+  });
+  const entry = findArtifactCatalogEntry(catalog, filePath) ?? catalogEntryForDiscoveredLocalFile(
+    buildLocalResultArtifactTree(path27.dirname(meta.path), record, catalog),
+    filePath
+  );
+  if (!entry) {
+    return c4.json({ error: "File not found" }, 404);
+  }
+  const resolved = await readArtifactCatalogEntryText(searchDir, projectId, meta, entry);
+  if (resolved.error) {
     return c4.json({ error: "Path traversal not allowed" }, 403);
   }
-  if (!existsSync16(absolutePath) || !statSync6(absolutePath).isFile()) {
-    return c4.json({ error: "File not found" }, 404);
+  if (resolved.content === void 0) return c4.json({ error: "File not found" }, 404);
+  return artifactFileContentResponse(c4, entry.displayPath, resolved.content);
+}
+async function handleEvalTraceSession(c4, { searchDir, projectId }) {
+  const filename = c4.req.param("filename") ?? "";
+  const evalId = c4.req.param("evalId");
+  const meta = await findRunById(searchDir, filename, projectId);
+  if (!meta) return c4.json({ error: "Run not found" }, 404);
+  try {
+    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 trace = resolveRecordArtifactPointer(record, "trace");
+    const runPath = relativeRunPathFromManifestPath(meta.path);
+    const traceEntry = findPointerArtifactCatalogEntry(
+      buildResultArtifactCatalog(record, { runPath }),
+      trace,
+      "trace",
+      runPath
+    );
+    if (!traceEntry && !trace.path) {
+      return c4.json(
+        traceSessionArtifactResponse({
+          status: trace.unsupportedReason ? "unsupported" : "missing",
+          message: trace.unsupportedReason ?? missingTraceMessage(),
+          ...trace.description && { pointer: trace.description }
+        })
+      );
+    }
+    if (trace.path && !normalizeArtifactRelativePath(trace.path)) {
+      return c4.json(
+        traceSessionArtifactResponse({
+          status: "rejected",
+          trace_path: trace.path,
+          message: "Artifact path is outside the run workspace.",
+          ...trace.description && { pointer: trace.description }
+        }),
+        403
+      );
+    }
+    if (!traceEntry) {
+      return c4.json(
+        traceSessionArtifactResponse({
+          status: "dangling",
+          ...trace.path && { trace_path: trace.path },
+          message: trace.unsupportedReason ? trace.unsupportedReason : `Trace artifact pointer is present, but ${trace.path} is not available in this run workspace.`,
+          ...trace.description && { pointer: trace.description }
+        })
+      );
+    }
+    const resolvedTrace = await readArtifactCatalogEntryText(
+      searchDir,
+      projectId,
+      meta,
+      traceEntry
+    );
+    if (resolvedTrace.error) {
+      return c4.json(
+        traceSessionArtifactResponse({
+          status: "rejected",
+          trace_path: traceEntry.displayPath,
+          message: resolvedTrace.error,
+          ...trace.description && { pointer: trace.description }
+        }),
+        403
+      );
+    }
+    const content = resolvedTrace.content;
+    if (content === void 0) {
+      const refMessage = trace.ref ? ` on ${trace.ref}` : "";
+      return c4.json(
+        traceSessionArtifactResponse({
+          status: "dangling",
+          trace_path: traceEntry.displayPath,
+          message: `Trace artifact pointer${refMessage} is present, but ${traceEntry.displayPath} is not available in this run workspace.`,
+          ...trace.description && { pointer: trace.description }
+        })
+      );
+    }
+    const parsed = parseTraceArtifactJson(content);
+    if (parsed.message) {
+      return c4.json(
+        traceSessionArtifactResponse({
+          status: "invalid",
+          trace_path: traceEntry.displayPath,
+          message: parsed.message,
+          ...trace.description && { pointer: trace.description }
+        })
+      );
+    }
+    const normalized = normalizeTraceArtifactToTraceSessionResponse(parsed.value, {
+      runId: filename,
+      testId: record.test_id,
+      suite: record.suite,
+      target: record.target,
+      artifactPath: traceEntry.displayPath
+    });
+    if (normalized.status === "unsupported") {
+      return c4.json(
+        traceSessionArtifactResponse({
+          status: "unsupported",
+          trace_path: traceEntry.displayPath,
+          message: normalized.message,
+          ...trace.description && { pointer: trace.description }
+        })
+      );
+    }
+    return c4.json(
+      traceSessionArtifactResponse({
+        status: "ok",
+        trace_path: traceEntry.displayPath,
+        trace_session: normalized.traceSession,
+        ...trace.description && { pointer: trace.description }
+      })
+    );
+  } catch {
+    return c4.json({ error: "Failed to load trace artifact" }, 500);
   }
+}
+async function handleEvalTranscript(c4, { searchDir, projectId }) {
+  const filename = c4.req.param("filename") ?? "";
+  const evalId = c4.req.param("evalId");
+  const meta = await findRunById(searchDir, filename, projectId);
+  if (!meta) return c4.json({ error: "Run not found" }, 404);
   try {
-    const fileContent = readFileSync12(absolutePath, "utf8");
-    if (c4.req.query("raw") === "1" || c4.req.query("download") === "1") {
-      c4.header("Content-Type", inferRawContentType(absolutePath));
-      if (c4.req.query("download") === "1") {
-        c4.header(
-          "Content-Disposition",
-          `attachment; filename="${contentDispositionFilename(absolutePath)}"`
-        );
-      }
-      return c4.body(fileContent);
+    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 transcript = resolveRecordArtifactPointer(record, "transcript");
+    const answer = resolveRecordArtifactPointer(record, "answer");
+    const runPath = relativeRunPathFromManifestPath(meta.path);
+    const catalog = buildResultArtifactCatalog(record, { runPath });
+    const transcriptEntry = findPointerArtifactCatalogEntry(
+      catalog,
+      transcript,
+      "transcript",
+      runPath
+    );
+    const answerEntry = findPointerArtifactCatalogEntry(catalog, answer, "answer", runPath);
+    if (!transcriptEntry && !transcript.path) {
+      return c4.json({
+        status: transcript.unsupportedReason ? "unsupported" : "missing",
+        message: transcript.unsupportedReason ?? missingTranscriptMessage(),
+        ...transcript.description && { pointer: transcript.description }
+      });
+    }
+    if (!transcriptEntry) {
+      return c4.json({
+        status: "dangling",
+        ...transcript.path && { transcript_path: transcript.path },
+        message: transcript.unsupportedReason ? transcript.unsupportedReason : `Transcript artifact pointer is present, but ${transcript.path} is not available in this run workspace.`,
+        ...transcript.description && { pointer: transcript.description }
+      });
     }
-    const language = inferLanguage(absolutePath);
-    return c4.json({ content: fileContent, language });
+    const resolvedTranscript = await readArtifactCatalogEntryText(
+      searchDir,
+      projectId,
+      meta,
+      transcriptEntry
+    );
+    if (resolvedTranscript.error) {
+      return c4.json({
+        status: "dangling",
+        transcript_path: transcriptEntry.displayPath,
+        message: resolvedTranscript.error,
+        ...transcript.description && { pointer: transcript.description }
+      });
+    }
+    const content = resolvedTranscript.content;
+    if (content === void 0) {
+      const refMessage = transcript.ref ? ` on ${transcript.ref}` : "";
+      return c4.json({
+        status: "dangling",
+        transcript_path: transcriptEntry.displayPath,
+        message: `Transcript artifact pointer${refMessage} is present, but ${transcriptEntry.displayPath} is not available in this run workspace.`,
+        ...transcript.description && { pointer: transcript.description }
+      });
+    }
+    const answerContent = answerEntry ? (await readArtifactCatalogEntryText(searchDir, projectId, meta, answerEntry)).content : void 0;
+    return c4.json({
+      status: "ok",
+      transcript_path: transcriptEntry.displayPath,
+      content,
+      language: inferLanguage(transcriptEntry.displayPath),
+      ...answerEntry && { answer_path: answerEntry.displayPath },
+      ...answerContent !== void 0 && { answer_content: answerContent },
+      ...transcript.description && { pointer: transcript.description }
+    });
   } catch {
-    return c4.json({ error: "Failed to read file" }, 500);
+    return c4.json({ error: "Failed to load transcript artifact" }, 500);
   }
 }
 async function handleExperiments(c4, { searchDir, agentvDir, projectId }) {
@@ -13812,7 +15771,7 @@ function handleConfig(c4, { agentvDir, searchDir }, options) {
     threshold: config.threshold,
     app_name: config.appName,
     read_only: options?.readOnly === true,
-    project_name: path26.basename(searchDir),
+    project_name: path27.basename(searchDir),
     project_dashboard: options?.projectDashboard === true,
     ...options?.currentProjectId && { current_project_id: options.currentProjectId }
   });
@@ -13821,7 +15780,7 @@ function handleFeedbackRead(c4, { searchDir }) {
   return c4.json(readFeedback(feedbackStoreDir(searchDir)));
 }
 function feedbackStoreDir(searchDir) {
-  const resultsDir = path26.join(searchDir, ".agentv", "results");
+  const resultsDir = path27.join(searchDir, ".agentv", "results");
   return existsSync16(resultsDir) ? resultsDir : searchDir;
 }
 async function handleFeedbackWrite(c4, resultDir) {
@@ -13865,25 +15824,25 @@ async function handleFeedbackWrite(c4, resultDir) {
 function expandHomePath(inputPath) {
   if (inputPath === "~") return homedir();
   if (inputPath.startsWith("~/") || inputPath.startsWith("~\\")) {
-    return path26.join(homedir(), inputPath.slice(2));
+    return path27.join(homedir(), inputPath.slice(2));
   }
   return inputPath;
 }
 function resolveBrowsePath(inputPath, cwd) {
   const trimmed = inputPath?.trim() ?? "";
   const expanded = trimmed.length > 0 ? expandHomePath(trimmed) : cwd;
-  return path26.resolve(cwd, expanded);
+  return path27.resolve(cwd, expanded);
 }
 function hasAgentvDir(dirPath) {
   try {
-    return statSync6(path26.join(dirPath, ".agentv")).isDirectory();
+    return statSync6(path27.join(dirPath, ".agentv")).isDirectory();
   } catch {
     return false;
   }
 }
 function directoryBrowseEntry(dirPath) {
   return {
-    name: path26.basename(dirPath) || dirPath,
+    name: path27.basename(dirPath) || dirPath,
     path: dirPath,
     hasAgentv: hasAgentvDir(dirPath)
   };
@@ -13905,7 +15864,7 @@ function browseFilesystemDirectories(inputPath, cwd) {
   let entries2;
   try {
     entries2 = readdirSync4(browsePath, { withFileTypes: true }).map((entry) => {
-      const entryPath = path26.join(browsePath, entry.name);
+      const entryPath = path27.join(browsePath, entry.name);
       if (entry.isDirectory()) return directoryBrowseEntry(entryPath);
       if (entry.isSymbolicLink()) {
         try {
@@ -13922,7 +15881,7 @@ function browseFilesystemDirectories(inputPath, cwd) {
   } catch (err2) {
     throw new Error(`Unable to read directory: ${err2.message}`);
   }
-  const parentPath = path26.dirname(browsePath);
+  const parentPath = path27.dirname(browsePath);
   return {
     path: browsePath,
     parentPath: parentPath !== browsePath ? parentPath : void 0,
@@ -13962,36 +15921,82 @@ async function handleRunTagsPut(c4, { searchDir, projectId }) {
   if (!Array.isArray(tags)) {
     return c4.json({ error: "Missing tags array" }, 400);
   }
+  let expectedTagRevision;
+  try {
+    expectedTagRevision = expectedTagRevisionFromRecord(body);
+  } catch (err2) {
+    return c4.json({ error: err2.message }, 400);
+  }
   try {
-    if (meta.source === "remote") {
-      const state = await setRemoteRunTags(searchDir, meta, tags, projectId);
+    if (meta.on_remote) {
+      const state = await setRemoteRunTags(
+        searchDir,
+        meta,
+        tags,
+        projectId,
+        expectedTagRevision
+      );
       return c4.json(remoteTagMutationResponse(state));
     }
+    assertExpectedTagRevision(expectedTagRevision, currentLocalTagRevision(meta.path));
     const entry = writeRunTags(meta.path, tags);
+    const responseState = localTagMutationResponse({
+      tags: entry?.tags ?? [],
+      updatedAt: entry?.updated_at,
+      tagRevision: entry?.tag_revision
+    });
     return c4.json({
       tags: entry?.tags ?? [],
+      ...responseState,
       updated_at: entry?.updated_at ?? (/* @__PURE__ */ new Date()).toISOString()
     });
   } catch (err2) {
-    return c4.json({ error: err2.message }, remoteMetadataErrorStatus(err2));
+    return c4.json(tagMutationErrorBody(err2), remoteMetadataErrorStatus(err2));
   }
 }
 async function handleRunTagsDelete(c4, { searchDir, projectId }) {
   const filename = c4.req.param("filename") ?? "";
   const meta = await findRunById(searchDir, filename, projectId);
   if (!meta) return c4.json({ error: "Run not found" }, 404);
+  let expectedTagRevision;
   try {
-    if (meta.source === "remote") {
-      const state = await clearRemoteRunTags(searchDir, meta, projectId);
+    const text = await c4.req.text();
+    if (text.trim().length > 0) {
+      const body = JSON.parse(text);
+      if (!body || typeof body !== "object") {
+        return c4.json({ error: "Invalid payload" }, 400);
+      }
+      expectedTagRevision = expectedTagRevisionFromRecord(body);
+    }
+  } catch (err2) {
+    return c4.json(
+      { error: err2 instanceof SyntaxError ? "Invalid JSON" : err2.message },
+      400
+    );
+  }
+  try {
+    if (meta.on_remote) {
+      const state = await clearRemoteRunTags(searchDir, meta, projectId, expectedTagRevision);
       return c4.json({
         ok: true,
         ...remoteTagMutationResponse(state)
       });
     }
-    deleteRunTags(meta.path);
-    return c4.json({ ok: true });
+    assertExpectedTagRevision(expectedTagRevision, currentLocalTagRevision(meta.path));
+    const entry = writeRunTags(meta.path, []);
+    const responseState = localTagMutationResponse({
+      tags: entry.tags,
+      updatedAt: entry.updated_at,
+      tagRevision: entry.tag_revision
+    });
+    return c4.json({
+      ok: true,
+      tags: entry.tags,
+      ...responseState,
+      updated_at: entry.updated_at
+    });
   } catch (err2) {
-    return c4.json({ error: err2.message }, remoteMetadataErrorStatus(err2));
+    return c4.json(tagMutationErrorBody(err2), remoteMetadataErrorStatus(err2));
   }
 }
 async function handleRunDelete(c4, { searchDir, projectId }) {
@@ -14011,9 +16016,6 @@ async function handleRunDelete(c4, { searchDir, projectId }) {
     return c4.json({ error: err2.message }, 400);
   }
 }
-function getLocalRunsRoot(searchDir) {
-  return path26.join(searchDir, ".agentv", "results", "runs");
-}
 function validateLocalCompletedRun(searchDir, meta, actionName = "Run combine") {
   if (meta.source === "remote") {
     return { error: `${actionName} is only available for local runs`, status: 400 };
@@ -14021,13 +16023,12 @@ 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 = path26.resolve(meta.path);
-  if (path26.basename(manifestPath) !== "index.jsonl") {
+  const manifestPath = path27.resolve(meta.path);
+  if (path27.basename(manifestPath) !== "index.jsonl") {
     return { error: "Run workspace is invalid", status: 400 };
   }
-  const runDir = path26.dirname(manifestPath);
-  const runsRoot = path26.resolve(getLocalRunsRoot(searchDir));
-  if (runDir !== runsRoot && runDir.startsWith(`${runsRoot}${path26.sep}`) && existsSync16(runDir)) {
+  const runDir = path27.dirname(manifestPath);
+  if (relativeRunPathFromCwd(searchDir, runDir) && existsSync16(runDir)) {
     return { ok: true };
   }
   return { error: "Run workspace is outside the local results directory", status: 400 };
@@ -14058,12 +16059,17 @@ async function handleRunsCombine(c4, { searchDir, projectId }) {
   if (displayNameValue !== void 0 && typeof displayNameValue !== "string") {
     return c4.json({ error: "display_name must be a string" }, 400);
   }
+  const experimentValue = payload.experiment;
+  if (experimentValue !== void 0 && typeof experimentValue !== "string") {
+    return c4.json({ error: "experiment must be a string" }, 400);
+  }
   const duplicatePolicyValue = payload.duplicate_policy;
   const duplicatePolicy = duplicatePolicyValue === void 0 ? "error" : String(duplicatePolicyValue);
   if (duplicatePolicy !== "error" && duplicatePolicy !== "latest") {
     return c4.json({ error: "duplicate_policy must be error or latest" }, 400);
   }
   const displayName = displayNameValue?.trim();
+  const experiment = experimentValue?.trim() || void 0;
   const metas = [];
   for (const runId of runIds) {
     const meta = await findRunById(searchDir, runId, projectId);
@@ -14085,6 +16091,7 @@ async function handleRunsCombine(c4, { searchDir, projectId }) {
     const combined = combineRunSources({
       cwd: searchDir,
       sources,
+      experiment,
       displayName,
       duplicatePolicy
     });
@@ -14094,6 +16101,7 @@ async function handleRunsCombine(c4, { searchDir, projectId }) {
         ok: true,
         run_id: combined.runId,
         display_name: combined.displayName,
+        experiment: combined.experiment,
         combined_from_run_ids: combined.combinedFromRunIds,
         duplicate_conflicts: combined.duplicateConflicts,
         ...tagEntry && { tags: tagEntry.tags }
@@ -14104,12 +16112,16 @@ async function handleRunsCombine(c4, { searchDir, projectId }) {
     if (err2 instanceof CombineDuplicateError) {
       return c4.json({ error: err2.message, duplicates: err2.conflicts }, 409);
     }
-    return c4.json({ error: err2.message }, 500);
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    if (message.includes("requires an experiment name") || message.includes("must inherit") || message.includes("must match combined experiment") || message.includes("Invalid experiment name")) {
+      return c4.json({ error: message }, 400);
+    }
+    return c4.json({ error: message }, 500);
   }
 }
 function createApp(results, resultDir, cwd, sourceFile, options) {
   const searchDir = cwd ?? resultDir;
-  const agentvDir = path26.join(searchDir, ".agentv");
+  const agentvDir = path27.join(searchDir, ".agentv");
   const defaultCtx = { searchDir, agentvDir, projectId: options?.currentProjectId };
   const readOnly = options?.readOnly === true;
   const app2 = new Hono();
@@ -14120,7 +16132,7 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     }
     return handler(c4, {
       searchDir: project.path,
-      agentvDir: path26.join(project.path, ".agentv"),
+      agentvDir: path27.join(project.path, ".agentv"),
       projectId: project.id
     });
   }
@@ -14152,7 +16164,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(path26.join(project.path, ".agentv")).threshold;
+    const threshold = loadStudioConfig(path27.join(project.path, ".agentv")).threshold;
     let passRateSum = 0;
     let executionErrorCount = 0;
     for (const meta of metas) {
@@ -14257,7 +16269,7 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
             if (records.length > 0) {
               const qualitySummary = summarizeQualityResults(
                 records,
-                loadStudioConfig(path26.join(p.path, ".agentv")).threshold
+                loadStudioConfig(path27.join(p.path, ".agentv")).threshold
               );
               target = records[0].target;
               experiment = records[0].experiment ?? experiment;
@@ -14350,6 +16362,14 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     (c4) => handleCategorySuites(c4, defaultCtx)
   );
   app2.get("/api/runs/:filename/evals/:evalId", (c4) => handleEvalDetail(c4, defaultCtx));
+  app2.get(
+    "/api/runs/:filename/evals/:evalId/trace-session",
+    (c4) => handleEvalTraceSession(c4, defaultCtx)
+  );
+  app2.get(
+    "/api/runs/:filename/evals/:evalId/transcript",
+    (c4) => handleEvalTranscript(c4, defaultCtx)
+  );
   app2.get("/api/runs/:filename/evals/:evalId/files", (c4) => handleEvalFiles(c4, defaultCtx));
   app2.get("/api/runs/:filename/evals/:evalId/files/*", (c4) => handleEvalFileContent(c4, defaultCtx));
   app2.get("/api/experiments", (c4) => handleExperiments(c4, defaultCtx));
@@ -14375,11 +16395,11 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
         let testCount = m.testCount;
         let executionErrorCount = 0;
         try {
-          const loaded = await loadManifestResultsForMeta(searchDir, m, defaultCtx.projectId);
-          totalCostUsd = loaded.reduce((sum, r) => sum + (r.costUsd ?? 0), 0);
-          if (loaded.length > 0) {
+          const records = await loadLightweightResultsForMeta(searchDir, m, defaultCtx.projectId);
+          totalCostUsd = records.reduce((sum, r) => sum + (r.costUsd ?? 0), 0);
+          if (records.length > 0) {
             const qualitySummary = summarizeQualityResults(
-              loaded,
+              records,
               loadStudioConfig(agentvDir).threshold
             );
             testCount = qualitySummary.totalCount;
@@ -14467,6 +16487,14 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     "/api/projects/:projectId/runs/:filename/evals/:evalId",
     (c4) => withProject(c4, handleEvalDetail)
   );
+  app2.get(
+    "/api/projects/:projectId/runs/:filename/evals/:evalId/trace-session",
+    (c4) => withProject(c4, handleEvalTraceSession)
+  );
+  app2.get(
+    "/api/projects/:projectId/runs/:filename/evals/:evalId/transcript",
+    (c4) => withProject(c4, handleEvalTranscript)
+  );
   app2.get(
     "/api/projects/:projectId/runs/:filename/evals/:evalId/files",
     (c4) => withProject(c4, handleEvalFiles)
@@ -14501,22 +16529,22 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     { readOnly }
   );
   const studioDistPath = options?.studioDir ?? resolveStudioDistDir();
-  if (!studioDistPath || !existsSync16(path26.join(studioDistPath, "index.html"))) {
+  if (!studioDistPath || !existsSync16(path27.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 = path26.join(studioDistPath, "index.html");
-    if (existsSync16(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
+    const indexPath = path27.join(studioDistPath, "index.html");
+    if (existsSync16(indexPath)) return c4.html(readFileSync14(indexPath, "utf8"));
     return c4.notFound();
   });
   app2.get("/assets/*", (c4) => {
     const assetPath = c4.req.path;
-    const filePath = path26.join(studioDistPath, assetPath);
+    const filePath = path27.join(studioDistPath, assetPath);
     if (!existsSync16(filePath)) return c4.notFound();
-    const content = readFileSync12(filePath);
-    const ext = path26.extname(filePath);
+    const content = readFileSync14(filePath);
+    const ext = path27.extname(filePath);
     const mimeTypes = {
       ".js": "application/javascript",
       ".css": "text/css",
@@ -14537,26 +16565,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 = path26.join(studioDistPath, "index.html");
-    if (existsSync16(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
+    const indexPath = path27.join(studioDistPath, "index.html");
+    if (existsSync16(indexPath)) return c4.html(readFileSync14(indexPath, "utf8"));
     return c4.notFound();
   });
   return app2;
 }
 function resolveStudioDistDir() {
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path26.dirname(fileURLToPath3(import.meta.url));
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path27.dirname(fileURLToPath3(import.meta.url));
   const candidates = [
     // From src/commands/results/ → sibling apps/dashboard/dist
-    path26.resolve(currentDir, "../../../../dashboard/dist"),
+    path27.resolve(currentDir, "../../../../dashboard/dist"),
     // From dist/ → sibling apps/dashboard/dist (monorepo dev)
-    path26.resolve(currentDir, "../../dashboard/dist"),
+    path27.resolve(currentDir, "../../dashboard/dist"),
     // Bundled inside CLI dist (published package: dist/dashboard/)
-    path26.resolve(currentDir, "dashboard"),
+    path27.resolve(currentDir, "dashboard"),
     // From dist/ in monorepo root context
-    path26.resolve(currentDir, "../../../apps/dashboard/dist")
+    path27.resolve(currentDir, "../../../apps/dashboard/dist")
   ];
   for (const candidate of candidates) {
-    if (existsSync16(candidate) && existsSync16(path26.join(candidate, "index.html"))) {
+    if (existsSync16(candidate) && existsSync16(path27.join(candidate, "index.html"))) {
       return candidate;
     }
   }
@@ -14564,7 +16592,7 @@ function resolveStudioDistDir() {
 }
 var resultsServeCommand = command({
   name: "dashboard",
-  description: "Start AgentV Dashboard \u2014 a local dashboard for reviewing evaluation results",
+  description: "Start AgentV Dashboard - the zero-infra local viewer for AgentV-owned result artifacts",
   args: {
     source: positional({
       type: optional(string),
@@ -14626,7 +16654,7 @@ var resultsServeCommand = command({
       return;
     }
     const repoRoot = await findRepoRoot(cwd);
-    const yamlConfig = await loadConfig(path26.join(cwd, "_"), repoRoot);
+    const yamlConfig = await loadConfig(path27.join(cwd, "_"), repoRoot);
     if (yamlConfig?.required_version) {
       await enforceRequiredVersion(yamlConfig.required_version);
     }
@@ -14641,22 +16669,22 @@ var resultsServeCommand = command({
       let sourceFile;
       if (source) {
         sourceFile = await resolveSourceFile2(source, cwd);
-        results = loadManifestResults(sourceFile);
+        results = loadManifestResults(sourceFile, { hydrateTranscriptTrace: false });
       } else {
         const cache = await loadRunCache(cwd);
         const cachedFile = cache ? resolveRunCacheFile(cache) : "";
-        if (cachedFile && existsSync16(cachedFile)) {
+        if (cachedFile && existsSync16(cachedFile) && relativeRunPathFromCwd(cwd, path27.dirname(cachedFile))) {
           sourceFile = cachedFile;
-          results = loadManifestResults(cachedFile);
+          results = loadManifestResults(cachedFile, { hydrateTranscriptTrace: false });
         } else {
           const metas = listResultFiles(cwd, 1);
           if (metas.length > 0) {
             sourceFile = metas[0].path;
-            results = loadManifestResults(metas[0].path);
+            results = loadManifestResults(metas[0].path, { hydrateTranscriptTrace: false });
           }
         }
       }
-      const resultDir = sourceFile ? path26.dirname(path26.resolve(sourceFile)) : cwd;
+      const resultDir = sourceFile ? path27.dirname(path27.resolve(sourceFile)) : cwd;
       const app2 = createApp(results, resultDir, cwd, sourceFile, {
         readOnly,
         projectDashboard,
@@ -14692,26 +16720,26 @@ var resultsServeCommand = command({
 // src/commands/runs/rerun.ts
 import { constants } from "node:fs";
-import { access, readFile as readFile8 } from "node:fs/promises";
-import path27 from "node:path";
+import { access, readFile as readFile9 } from "node:fs/promises";
+import path28 from "node:path";
 import { config as loadDotenv } from "dotenv";
 var TASK_EVAL_FILENAME = "EVAL.yaml";
 var TASK_TARGETS_FILENAME = "targets.yaml";
 var ENV_REF_PATTERN = /\$\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function displayRecord(record) {
   return `${record.test_id ?? "unknown"}@${record.target ?? "unknown"}`;
 }
 function resolveSourcePath(cwd, source) {
-  return path27.isAbsolute(source) ? source : path27.resolve(cwd, source);
+  return path28.isAbsolute(source) ? source : path28.resolve(cwd, source);
 }
 function resolveRelativeRunPath(runDir, relativePath) {
   if (!relativePath || relativePath.trim().length === 0) {
     return void 0;
   }
-  return path27.resolve(runDir, relativePath);
+  return path28.resolve(runDir, relativePath);
 }
 async function ensureFile(filePath, label) {
   try {
@@ -14740,25 +16768,25 @@ function stringArray(value) {
   return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
 }
 function readExecutionTarget(parsedEval) {
-  if (!isRecord2(parsedEval)) {
+  if (!isRecord3(parsedEval)) {
     return void 0;
   }
   const execution = parsedEval.execution;
-  if (isRecord2(execution) && typeof execution.target === "string" && execution.target.length > 0) {
+  if (isRecord3(execution) && typeof execution.target === "string" && execution.target.length > 0) {
     return execution.target;
   }
   return typeof parsedEval.target === "string" && parsedEval.target.length > 0 ? parsedEval.target : void 0;
 }
 async function readTaskTarget(evalPath, fallback) {
-  const raw = await readFile8(evalPath, "utf8");
+  const raw = await readFile9(evalPath, "utf8");
   return readExecutionTarget(parseYamlValue(raw)) ?? fallback;
 }
 async function readTargetDefinitions2(targetsPath) {
-  const parsed = parseYamlValue(await readFile8(targetsPath, "utf8"));
-  if (!isRecord2(parsed) || !Array.isArray(parsed.targets)) {
+  const parsed = parseYamlValue(await readFile9(targetsPath, "utf8"));
+  if (!isRecord3(parsed) || !Array.isArray(parsed.targets)) {
     throw new Error(`Targets file is missing a top-level targets array: ${targetsPath}`);
   }
-  return parsed.targets.filter(isRecord2);
+  return parsed.targets.filter(isRecord3);
 }
 function targetName(definition) {
   return typeof definition.name === "string" && definition.name.trim().length > 0 ? definition.name.trim() : void 0;
@@ -14808,7 +16836,7 @@ function collectEnvRefs(value, names = /* @__PURE__ */ new Set()) {
     }
     return names;
   }
-  if (isRecord2(value)) {
+  if (isRecord3(value)) {
     for (const [key, entry] of Object.entries(value)) {
       if (key === "required_env") {
         for (const required of stringArray(entry)) {
@@ -14869,15 +16897,15 @@ async function validateTargetFile(targetsPath, targetNames, label) {
   }
 }
 function isInsideOrSame(root, candidate) {
-  const relative3 = path27.relative(path27.resolve(root), path27.resolve(candidate));
-  return relative3 === "" || !relative3.startsWith("..") && !path27.isAbsolute(relative3);
+  const relative3 = path28.relative(path28.resolve(root), path28.resolve(candidate));
+  return relative3 === "" || !relative3.startsWith("..") && !path28.isAbsolute(relative3);
 }
 function forbiddenOutputRoots(sourceRunDir, selected) {
   return [
-    path27.resolve(sourceRunDir),
+    path28.resolve(sourceRunDir),
     ...selected.flatMap((bundle) => [
-      path27.resolve(bundle.artifactDir),
-      path27.resolve(bundle.taskDir)
+      path28.resolve(bundle.artifactDir),
+      path28.resolve(bundle.taskDir)
     ])
   ];
 }
@@ -14896,13 +16924,13 @@ function defaultOutputDir(cwd, sourceRunDir, selected, experiment) {
   if (!roots.some((root) => isInsideOrSame(root, candidate))) {
     return candidate;
   }
-  return path27.join(path27.dirname(path27.resolve(sourceRunDir)), `rerun-${createRunDirName()}`);
+  return path28.join(path28.dirname(path28.resolve(sourceRunDir)), `rerun-${createRunDirName()}`);
 }
 async function loadEnvFile2(envFile, cwd, verbose) {
   if (!envFile) {
     return;
   }
-  const resolved = path27.isAbsolute(envFile) ? envFile : path27.resolve(cwd, envFile);
+  const resolved = path28.isAbsolute(envFile) ? envFile : path28.resolve(cwd, envFile);
   await ensureFile(resolved, "Environment file");
   const loaded = loadDotenv({ path: resolved, override: false });
   if (loaded.error) {
@@ -14913,7 +16941,7 @@ async function loadEnvFile2(envFile, cwd, verbose) {
   }
 }
 async function loadSelectedTaskBundles(options) {
-  const content = await readFile8(options.indexPath, "utf8");
+  const content = await readFile9(options.indexPath, "utf8");
   const records = parseResultManifest(content);
   if (records.length === 0) {
     throw new Error(`Run manifest contains no result rows: ${options.indexPath}`);
@@ -14934,8 +16962,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 ? path27.dirname(evalPath) : void 0);
-    const artifactDir = resolveRelativeRunPath(options.sourceRunDir, record.artifact_dir) ?? (taskDir ? path27.dirname(taskDir) : void 0);
+    const taskDir = resolveRelativeRunPath(options.sourceRunDir, record.task_dir) ?? (evalPath ? path28.dirname(evalPath) : void 0);
+    const artifactDir = resolveRelativeRunPath(options.sourceRunDir, record.artifact_dir) ?? (taskDir ? path28.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.`
@@ -14965,14 +16993,14 @@ async function loadSelectedTaskBundles(options) {
 function buildSourceMetadataByEvalFile(sourceRunDir, indexPath, selected) {
   return new Map(
     selected.map((bundle) => [
-      path27.resolve(bundle.evalPath),
+      path28.resolve(bundle.evalPath),
       {
         rerunSource: {
           mode: "rerun",
-          sourceRunDir: path27.resolve(sourceRunDir),
-          sourceIndexPath: path27.resolve(indexPath),
-          sourceArtifactDir: path27.resolve(bundle.artifactDir),
-          sourceTaskDir: path27.resolve(bundle.taskDir),
+          sourceRunDir: path28.resolve(sourceRunDir),
+          sourceIndexPath: path28.resolve(indexPath),
+          sourceArtifactDir: path28.resolve(bundle.artifactDir),
+          sourceTaskDir: path28.resolve(bundle.taskDir),
           sourceTestId: bundle.testId,
           sourceTarget: bundle.sourceTarget,
           sourceTimestamp: bundle.record.timestamp
@@ -15043,7 +17071,7 @@ var runsRerunCommand = command({
   handler: async (args) => {
     const cwd = process.cwd();
     const indexPath = resolveRunManifestPath(resolveSourcePath(cwd, args.runDir));
-    const sourceRunDir = path27.dirname(indexPath);
+    const sourceRunDir = path28.dirname(indexPath);
     await loadEnvFile2(args.envFile, cwd, args.verbose);
     const selected = await loadSelectedTaskBundles({
       indexPath,
@@ -15052,10 +17080,10 @@ var runsRerunCommand = command({
       sourceTargets: args.sourceTarget
     });
     const targetOverrides = args.target;
-    const outputDir = args.output ? path27.resolve(cwd, args.output) : defaultOutputDir(cwd, sourceRunDir, selected, args.experiment);
+    const outputDir = args.output ? path28.resolve(cwd, args.output) : defaultOutputDir(cwd, sourceRunDir, selected, args.experiment);
     assertOutputIsSeparate(outputDir, forbiddenOutputRoots(sourceRunDir, selected));
     if (args.targets) {
-      const overrideTargetsPath = path27.resolve(cwd, args.targets);
+      const overrideTargetsPath = path28.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");
@@ -15079,7 +17107,7 @@ var runsRerunCommand = command({
       testFiles: selected.map((bundle) => bundle.evalPath),
       rawOptions: {
         target: targetOverrides,
-        targets: args.targets ? path27.resolve(cwd, args.targets) : void 0,
+        targets: args.targets ? path28.resolve(cwd, args.targets) : void 0,
         output: outputDir,
         experiment: args.experiment ?? "rerun",
         workers: args.workers,
@@ -15107,7 +17135,7 @@ var runsCommand = subcommands({
 });
 // src/self-update.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync17 } from "node:fs";
 import { get } from "node:https";
 import { basename, dirname as dirname3, join as join5, win32 } from "node:path";
@@ -15146,9 +17174,9 @@ function detectInstallScopeFromPath(scriptPath, cwd = process.cwd()) {
 function detectInstallScope() {
   return detectInstallScopeFromPath(process.argv[1] ?? "");
 }
-function runCommand(cmd, args) {
+function runCommand2(cmd, args) {
   return new Promise((resolve3, reject) => {
-    const child = spawn2(cmd, args, { stdio: ["inherit", "pipe", "inherit"] });
+    const child = spawn3(cmd, args, { stdio: ["inherit", "pipe", "inherit"] });
     let stdout = "";
     child.stdout?.on("data", (data) => {
       process.stdout.write(data);
@@ -15226,13 +17254,13 @@ async function performSelfUpdate(options) {
   const args = getInstallArgs(pm, versionSpec, scope);
   const command2 = resolvePackageManagerCommand(pm, args);
   try {
-    const result = await runCommand(command2.cmd, command2.args);
+    const result = await runCommand2(command2.cmd, command2.args);
     if (result.exitCode !== 0) {
       return { success: false, currentVersion, scope };
     }
     let newVersion;
     try {
-      const versionResult = await runCommand("agentv", ["--version"]);
+      const versionResult = await runCommand2("agentv", ["--version"]);
       newVersion = versionResult.stdout.trim();
     } catch {
     }
@@ -15309,14 +17337,14 @@ var selfCommand = subcommands({
 });
 // src/commands/skills/index.ts
-import { existsSync as existsSync18, readFileSync as readFileSync13, readdirSync as readdirSync5 } from "node:fs";
-import path28 from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync15, readdirSync as readdirSync5 } from "node:fs";
+import path29 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(path28.join(dir, e.name, "SKILL.md"))
+      (e) => e.isDirectory() && existsSync18(path29.join(dir, e.name, "SKILL.md"))
     );
   } catch {
     return false;
@@ -15324,15 +17352,15 @@ function isValidSkillsDir(dir) {
 }
 function findSkillsDir() {
   const selfFile = fileURLToPath4(import.meta.url);
-  let dir = path28.dirname(selfFile);
+  let dir = path29.dirname(selfFile);
   for (let i = 0; i < 6; i++) {
-    const distCandidate = path28.join(dir, "dist", "skills");
+    const distCandidate = path29.join(dir, "dist", "skills");
     if (isValidSkillsDir(distCandidate)) return distCandidate;
-    const repoRootCandidate = path28.join(dir, "skills-data");
+    const repoRootCandidate = path29.join(dir, "skills-data");
     if (isValidSkillsDir(repoRootCandidate)) return repoRootCandidate;
-    const legacyCandidate = path28.join(dir, "skills");
+    const legacyCandidate = path29.join(dir, "skills");
     if (isValidSkillsDir(legacyCandidate)) return legacyCandidate;
-    dir = path28.dirname(dir);
+    dir = path29.dirname(dir);
   }
   return null;
 }
@@ -15351,9 +17379,9 @@ function listSkillNames(skillsDir) {
   return readdirSync5(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
 }
 function readSkillFile(skillDir, relPath) {
-  const full = path28.join(skillDir, relPath);
+  const full = path29.join(skillDir, relPath);
   if (!existsSync18(full)) return null;
-  return readFileSync13(full, "utf-8");
+  return readFileSync15(full, "utf-8");
 }
 function collectDir(dir, prefix = "") {
   const result = {};
@@ -15361,9 +17389,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(path28.join(dir, entry.name), relPath));
+      Object.assign(result, collectDir(path29.join(dir, entry.name), relPath));
     } else {
-      result[relPath] = readFileSync13(path28.join(dir, entry.name), "utf-8");
+      result[relPath] = readFileSync15(path29.join(dir, entry.name), "utf-8");
     }
   }
   return result;
@@ -15373,14 +17401,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 = path28.join(skillsDir, name);
+  const skillDir = path29.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 = path28.join(skillDir, sub);
+    const subDir = path29.join(skillDir, sub);
     const collected = collectDir(subDir, sub);
     Object.assign(files, collected);
   }
@@ -15390,16 +17418,16 @@ 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 = path28.join(skillDir, sub, candidate);
+      const filePath = path29.join(skillDir, sub, candidate);
       if (existsSync18(filePath)) {
-        return { relPath: `${sub}/${candidate}`, content: readFileSync13(filePath, "utf-8") };
+        return { relPath: `${sub}/${candidate}`, content: readFileSync15(filePath, "utf-8") };
       }
     }
   }
   for (const candidate of candidates) {
-    const filePath = path28.join(skillDir, candidate);
+    const filePath = path29.join(skillDir, candidate);
     if (existsSync18(filePath)) {
-      return { relPath: candidate, content: readFileSync13(filePath, "utf-8") };
+      return { relPath: candidate, content: readFileSync15(filePath, "utf-8") };
     }
   }
   return null;
@@ -15407,7 +17435,7 @@ function findRefFile(skillDir, refName) {
 function listRefFiles(skillDir) {
   const out = [];
   for (const sub of listSkillSubdirs(skillDir)) {
-    const subDir = path28.join(skillDir, sub);
+    const subDir = path29.join(skillDir, sub);
     for (const entry of readdirSync5(subDir, { withFileTypes: true })) {
       if (entry.isFile()) out.push(`${sub}/${entry.name}`);
     }
@@ -15491,7 +17519,7 @@ var skillsGetCommand = command({
         }
         process.exit(1);
       }
-      const skillDir = path28.join(skillsDir, name);
+      const skillDir = path29.join(skillsDir, name);
       if (!existsSync18(skillDir)) {
         const msg = `skill '${name}' not found`;
         if (json) {
@@ -15580,7 +17608,7 @@ var skillsPathCommand = command({
   handler: ({ name }) => {
     const skillsDir = requireSkillsDir();
     if (name) {
-      const skillDir = path28.join(skillsDir, name);
+      const skillDir = path29.join(skillsDir, name);
       if (!existsSync18(skillDir)) {
         console.error(`Error: skill '${name}' not found`);
         process.exit(1);
@@ -15603,7 +17631,7 @@ var skillsCommand = subcommands({
 // src/commands/transpile/index.ts
 import { writeFileSync as writeFileSync7 } from "node:fs";
-import path29 from "node:path";
+import path30 from "node:path";
 var transpileCommand = command({
   name: "transpile",
   description: "Convert an EVAL.yaml file to Agent Skills evals.json format",
@@ -15627,7 +17655,7 @@ var transpileCommand = command({
   handler: async ({ input, outDir, stdout }) => {
     let result;
     try {
-      result = transpileEvalYamlFile(path29.resolve(input));
+      result = transpileEvalYamlFile(path30.resolve(input));
     } catch (error) {
       console.error(`Error: ${error.message}`);
       process.exit(1);
@@ -15651,11 +17679,11 @@ var transpileCommand = command({
       process.stdout.write("\n");
       return;
     }
-    const outputDir = outDir ? path29.resolve(outDir) : path29.dirname(path29.resolve(input));
+    const outputDir = outDir ? path30.resolve(outDir) : path30.dirname(path30.resolve(input));
     const fileNames = getOutputFilenames(result);
     for (const [skill, evalsJson] of result.files) {
       const fileName = fileNames.get(skill) ?? "evals.json";
-      const outputPath = path29.join(outputDir, fileName);
+      const outputPath = path30.join(outputDir, fileName);
       writeFileSync7(outputPath, `${JSON.stringify(evalsJson, null, 2)}
 `);
       console.log(`Transpiled to ${outputPath}`);
@@ -15664,7 +17692,7 @@ var transpileCommand = command({
 });
 // src/commands/trend/index.ts
-import path30 from "node:path";
+import path31 from "node:path";
 var colors2 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -15714,7 +17742,7 @@ function colorizeSlope(value) {
 }
 function ensureTrendIndexPath(source, cwd) {
   const resolved = resolveResultSourcePath(source, cwd);
-  if (path30.basename(resolved) !== RESULT_INDEX_FILENAME) {
+  if (path31.basename(resolved) !== RESULT_INDEX_FILENAME) {
     throw new Error(
       `Unsupported result source for trend: ${source}. Use a run workspace directory or ${RESULT_INDEX_FILENAME} manifest.`
     );
@@ -15734,10 +17762,10 @@ function resolveTrendSources(cwd, sources, last) {
   if (last < 2) {
     throw new Error("--last must be at least 2");
   }
-  const metas = listResultFiles(cwd).filter((meta) => path30.basename(meta.path) === RESULT_INDEX_FILENAME).slice(0, last);
+  const metas = listResultFiles(cwd).filter((meta) => path31.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/"
+      "Trend analysis requires at least 2 canonical run workspaces in .agentv/results/"
     );
   }
   return metas.map((meta) => meta.path).reverse();
@@ -15749,10 +17777,10 @@ function getRunLabel(sourcePath, timestamp) {
   if (timestamp) {
     return timestamp;
   }
-  return path30.basename(path30.dirname(sourcePath));
+  return path31.basename(path31.dirname(sourcePath));
 }
 function getRunSortKey(sourcePath, timestamp) {
-  return timestamp ?? path30.basename(path30.dirname(sourcePath));
+  return timestamp ?? path31.basename(path31.dirname(sourcePath));
 }
 function mean2(values) {
   return values.reduce((sum, value) => sum + value, 0) / values.length;
@@ -15931,7 +17959,7 @@ var trendCommand = command({
     last: option({
       type: optional(number),
       long: "last",
-      description: "Use the most recent N runs from .agentv/results/runs/"
+      description: "Use the most recent N runs from .agentv/results/"
     }),
     suite: option({
       type: optional(string),
@@ -16007,7 +18035,7 @@ var trendCommand = command({
 });
 // src/commands/trim/index.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "node:fs";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync8 } from "node:fs";
 var trimCommand = command({
   name: "trim",
   description: "Trim evaluation results for baseline storage (strips debug/audit fields)",
@@ -16026,7 +18054,7 @@ var trimCommand = command({
   },
   handler: async ({ input, out }) => {
     try {
-      const content = readFileSync14(input, "utf8");
+      const content = readFileSync16(input, "utf8");
       const lines = content.trim().split("\n").filter((line) => line.trim());
       const trimmedLines = lines.map((line) => {
         const record = JSON.parse(line);
@@ -16085,12 +18113,12 @@ function formatFileResult(result, useColors) {
   lines.push(`${statusText} ${fileName}`);
   if (result.errors.length > 0) {
     for (const error of result.errors) {
-      lines.push(formatError(error, useColors));
+      lines.push(formatError2(error, useColors));
     }
   }
   return lines.join("\n");
 }
-function formatError(error, useColors) {
+function formatError2(error, useColors) {
   const prefix = error.severity === "error" ? "  \u2717" : "  \u26A0";
   const color = error.severity === "error" ? ANSI_RED : ANSI_YELLOW;
   const coloredPrefix = useColors ? `${color}${prefix}${ANSI_RESET}` : prefix;
@@ -16133,7 +18161,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 path31 from "node:path";
+import path32 from "node:path";
 import fg3 from "fast-glob";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
@@ -16148,7 +18176,7 @@ async function validateFiles(paths) {
   };
 }
 async function validateSingleFile(filePath) {
-  const absolutePath = path31.resolve(filePath);
+  const absolutePath = path32.resolve(filePath);
   const fileType = await detectFileType(absolutePath);
   let result;
   if (fileType === "eval") {
@@ -16192,7 +18220,7 @@ async function validateSingleFile(filePath) {
 async function expandPaths(paths) {
   const expanded = /* @__PURE__ */ new Set();
   for (const inputPath of paths) {
-    const absolutePath = path31.resolve(inputPath);
+    const absolutePath = path32.resolve(inputPath);
     try {
       await access2(absolutePath, constants2.F_OK);
       const stats = await stat2(absolutePath);
@@ -16220,7 +18248,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(path31.normalize(f));
+    for (const f of yamlMatches) expanded.add(path32.normalize(f));
   }
   const sorted = Array.from(expanded);
   sorted.sort();
@@ -16231,7 +18259,7 @@ async function findYamlFiles(dirPath) {
   try {
     const entries2 = await readdir4(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path31.join(dirPath, entry.name);
+      const fullPath = path32.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -16248,11 +18276,11 @@ async function findYamlFiles(dirPath) {
   return results;
 }
 function isYamlFile(filePath) {
-  const ext = path31.extname(filePath).toLowerCase();
+  const ext = path32.extname(filePath).toLowerCase();
   return ext === ".yaml" || ext === ".yml";
 }
 function isEvalYamlFile(filePath) {
-  const lower = path31.basename(filePath).toLowerCase();
+  const lower = path32.basename(filePath).toLowerCase();
   return lower.endsWith(".eval.yaml") || lower.endsWith(".eval.yml");
 }
@@ -16308,8 +18336,8 @@ 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 path32 from "node:path";
+import { readFile as readFile10, readdir as readdir5, rm as rm3 } from "node:fs/promises";
+import path33 from "node:path";
 async function confirm2(message) {
   const readline4 = await import("node:readline");
   const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
@@ -16345,10 +18373,10 @@ var cleanCommand = command({
       const poolDirs = entries2.filter((e) => e.isDirectory());
       const matchingDirs = [];
       for (const dir of poolDirs) {
-        const poolDir = path32.join(poolRoot, dir.name);
-        const metadataPath = path32.join(poolDir, "metadata.json");
+        const poolDir = path33.join(poolRoot, dir.name);
+        const metadataPath = path33.join(poolDir, "metadata.json");
         try {
-          const raw = await readFile9(metadataPath, "utf-8");
+          const raw = await readFile10(metadataPath, "utf-8");
           const metadata = JSON.parse(raw);
           const hasRepo = metadata.repos?.some((r) => {
             const value = r.repo ?? (r.source?.type === "git" ? r.source.url : r.source?.path);
@@ -16374,8 +18402,8 @@ var cleanCommand = command({
         }
       }
       for (const dir of matchingDirs) {
-        await rm2(dir, { recursive: true, force: true });
-        console.log(`Removed: ${path32.basename(dir).slice(0, 12)}...`);
+        await rm3(dir, { recursive: true, force: true });
+        console.log(`Removed: ${path33.basename(dir).slice(0, 12)}...`);
       }
       console.log("Done.");
     } else {
@@ -16386,14 +18414,14 @@ var cleanCommand = command({
           return;
         }
       }
-      await rm2(poolRoot, { recursive: true, force: true });
+      await rm3(poolRoot, { recursive: true, force: true });
       console.log("Workspace pool cleaned.");
     }
   }
 });
 // src/commands/workspace/deps.ts
-import path33 from "node:path";
+import path34 from "node:path";
 var depsCommand = command({
   name: "deps",
   description: "Scan eval files and list git repo dependencies needed by workspaces",
@@ -16417,7 +18445,7 @@ var depsCommand = command({
     const resolvedPaths = await resolveEvalPaths(evalPaths, cwd);
     const result = await scanRepoDeps(resolvedPaths);
     for (const err2 of result.errors) {
-      console.error(`error: ${path33.relative(cwd, err2.file)}: ${err2.message}`);
+      console.error(`error: ${path34.relative(cwd, err2.file)}: ${err2.message}`);
     }
     if (result.errors.length > 0) {
       process.exit(1);
@@ -16428,7 +18456,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) => path33.relative(cwd, p)) }
+        ...usedBy && { used_by: r.usedBy.map((p) => path34.relative(cwd, p)) }
       }))
     };
     console.log(JSON.stringify(output, null, 2));
@@ -16437,14 +18465,14 @@ 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 path34 from "node:path";
+import { readFile as readFile11, readdir as readdir6, stat as stat3 } from "node:fs/promises";
+import path35 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 = path34.join(dirPath, entry.name);
+      const fullPath = path35.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(fullPath);
       } else {
@@ -16479,14 +18507,14 @@ var listCommand = command({
       return;
     }
     for (const dir of poolDirs) {
-      const poolDir = path34.join(poolRoot, dir.name);
+      const poolDir = path35.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 = path34.join(poolDir, "metadata.json");
+      const metadataPath = path35.join(poolDir, "metadata.json");
       let metadata = null;
       try {
-        const raw = await readFile10(metadataPath, "utf-8");
+        const raw = await readFile11(metadataPath, "utf-8");
         metadata = JSON.parse(raw);
       } catch {
       }
@@ -16523,17 +18551,17 @@ var workspaceCommand = subcommands({
 });
 // src/update-check.ts
-import { spawn as spawn3 } from "node:child_process";
-import { readFile as readFile11 } from "node:fs/promises";
+import { spawn as spawn4 } from "node:child_process";
+import { readFile as readFile12 } from "node:fs/promises";
 import { join as join6 } from "node:path";
 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(path36) {
-  const filePath = path36 ?? join6(CONFIG_DIR, CACHE_FILE);
+async function getCachedUpdateInfo(path37) {
+  const filePath = path37 ?? join6(CONFIG_DIR, CACHE_FILE);
   try {
-    const raw = await readFile11(filePath, "utf-8");
+    const raw = await readFile12(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.latestVersion === "string" && typeof data.lastCheckedAt === "string") {
       return data;
@@ -16589,7 +18617,7 @@ function backgroundUpdateCheck(distTag = "latest") {
     }).on('error', () => process.exit()).on('timeout', function() { this.destroy(); process.exit(); });
   `;
   try {
-    const child = spawn3(process.execPath, ["-e", script], {
+    const child = spawn4(process.execPath, ["-e", script], {
       detached: true,
       stdio: "ignore",
       windowsHide: true
@@ -16640,7 +18668,8 @@ var app = subcommands({
     workspace: workspaceCommand
   }
 });
-var EVAL_SUBCOMMANDS = /* @__PURE__ */ new Set(["run", "assert", "aggregate", "bundle"]);
+var EVAL_SUBCOMMANDS = /* @__PURE__ */ new Set(["run", "assert", "aggregate", "bundle", "vitest"]);
+var VITEST_VERIFIER_RE = /(?:^|[/\\])(?:EVAL|[^/\\]+[.-](?:test|spec))\.[cm]?[jt]sx?$/i;
 var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
   "import",
   "inspect",
@@ -16668,6 +18697,12 @@ var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
 function usesDeprecatedStudioAlias(argv) {
   return argv[2] === "studio";
 }
+function shouldRunBeforeSessionHook(argv) {
+  return !(argv[2] === "eval" && argv[3] === "vitest");
+}
+function inferEvalSubcommand(arg) {
+  return arg && VITEST_VERIFIER_RE.test(arg) ? "vitest" : "run";
+}
 function preprocessArgv(argv) {
   const result = [...argv];
   if (result[2] === "studio") {
@@ -16688,7 +18723,7 @@ function preprocessArgv(argv) {
       const isHelp = nextArg === "--help" || nextArg === "-h";
       const isKnownSubcommand = nextArg !== void 0 && EVAL_SUBCOMMANDS.has(nextArg);
       if (!isHelp && !isKnownSubcommand) {
-        result.splice(evalIdx + 1, 0, "run");
+        result.splice(evalIdx + 1, 0, inferEvalSubcommand(nextArg));
       }
     }
   }
@@ -16710,12 +18745,14 @@ ${updateNotice}
       "Warning: `agentv studio` is deprecated and will be removed in a future release. Use `agentv dashboard` instead.\n"
     );
   }
-  const cwd = process.cwd();
-  const repoRoot = await findRepoRoot(cwd);
-  const sessionConfig = await loadConfig(path35.join(cwd, "_"), repoRoot);
-  const beforeSessionCommand = sessionConfig?.hooks?.before_session;
-  if (beforeSessionCommand) {
-    runBeforeSessionHook(beforeSessionCommand);
+  if (shouldRunBeforeSessionHook(processedArgv)) {
+    const cwd = process.cwd();
+    const repoRoot = await findRepoRoot(cwd);
+    const sessionConfig = await loadConfig(path36.join(cwd, "_"), repoRoot);
+    const beforeSessionCommand = sessionConfig?.hooks?.before_session;
+    if (beforeSessionCommand) {
+      runBeforeSessionHook(beforeSessionCommand);
+    }
   }
   await run(binary(app), processedArgv);
 }
@@ -16723,7 +18760,9 @@ ${updateNotice}
 export {
   app,
   usesDeprecatedStudioAlias,
+  shouldRunBeforeSessionHook,
+  inferEvalSubcommand,
   preprocessArgv,
   runCli
 };
-//# sourceMappingURL=chunk-ISPJY2AX.js.map
+//# sourceMappingURL=chunk-IFQXBQSY.js.map