agentv 4.43.0-next.1 → 5.0.0-next.1

package/dist/{chunk-RFJM2UBD.js → chunk-GZJMODLW.js}

@@ -2,7 +2,7 @@ import { createRequire } from 'node:module'; const require = createRequire(impor
 import {
   execFileWithStdin,
   execShellWithStdin
-} from "./chunk-NPVGBFF6.js";
+} from "./chunk-IJEZFZJR.js";
 import {
   AgentvProvider,
   AnthropicProvider,
@@ -493,8 +493,8 @@ function getErrorMap() {
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path53, errorMaps, issueData } = params;
-  const fullPath = [...path53, ...issueData.path || []];
+  const { data, path: path51, errorMaps, issueData } = params;
+  const fullPath = [...path51, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -610,11 +610,11 @@ var errorUtil;
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path53, key) {
+  constructor(parent, value, path51, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path53;
+    this._path = path51;
     this._key = key;
   }
   get path() {
@@ -4056,19 +4056,26 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../../packages/core/dist/chunk-WSIPYTCH.js
+// ../../packages/core/dist/chunk-LP6SQKR3.js
 import { parse } from "yaml";
-import os from "node:os";
 import path from "node:path";
+import os from "node:os";
+import path2 from "node:path";
 import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
-import path2 from "node:path";
+import path3 from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import path3 from "node:path";
-import { readFile as readFile2, readdir, stat } from "node:fs/promises";
 import path4 from "node:path";
+import { readFile as readFile2, readdir, stat } from "node:fs/promises";
+import path5 from "node:path";
 import fg from "fast-glob";
+import { constants as constants2 } from "node:fs";
+import { access as access2 } from "node:fs/promises";
+import path6 from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFile as readFile3 } from "node:fs/promises";
+import path7 from "node:path";
 var CONTENT_TYPES = /* @__PURE__ */ new Set(["text", "image", "file"]);
 function isContent(value) {
   if (!value || typeof value !== "object") return false;
@@ -4171,13 +4178,40 @@ var PARSE_OPTIONS = { merge: true };
 function parseYamlValue(content) {
   return parse(content, PARSE_OPTIONS);
 }
+var AGENTV_CONFIG_FILE_NAME = "config.yaml";
+var AGENTV_CONFIG_YML_FILE_NAME = "config.yml";
+var AGENTV_LOCAL_CONFIG_FILE_NAME = "config.local.yaml";
+var AGENTV_LOCAL_CONFIG_YML_FILE_NAME = "config.local.yml";
+function getLocalConfigPath(configPath2) {
+  const basename = path.basename(configPath2);
+  const localName = basename === AGENTV_CONFIG_YML_FILE_NAME ? AGENTV_LOCAL_CONFIG_YML_FILE_NAME : AGENTV_LOCAL_CONFIG_FILE_NAME;
+  return path.join(path.dirname(configPath2), localName);
+}
+function isAgentVConfigFileName(basename) {
+  return basename === AGENTV_CONFIG_FILE_NAME || basename === AGENTV_CONFIG_YML_FILE_NAME || basename === AGENTV_LOCAL_CONFIG_FILE_NAME || basename === AGENTV_LOCAL_CONFIG_YML_FILE_NAME;
+}
+function isPlainConfigObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function mergeConfigObjects(base, overlay) {
+  const merged = { ...base };
+  for (const [key, overlayValue] of Object.entries(overlay)) {
+    const baseValue = merged[key];
+    merged[key] = isPlainConfigObject(baseValue) && isPlainConfigObject(overlayValue) ? mergeConfigObjects(baseValue, overlayValue) : overlayValue;
+  }
+  return merged;
+}
 function readEnvPath(name) {
   const value = process.env[name];
   if (!value || value === "undefined") return void 0;
   return value;
 }
 function getAgentvConfigDir() {
-  return readEnvPath("AGENTV_HOME") ?? path.join(os.homedir(), ".agentv");
+  return readEnvPath("AGENTV_HOME") ?? path2.join(os.homedir(), ".agentv");
 }
 function getAgentvHome() {
   return getAgentvConfigDir();
@@ -4186,16 +4220,16 @@ function getAgentvDataDir() {
   return readEnvPath("AGENTV_DATA_DIR") ?? getAgentvConfigDir();
 }
 function getWorkspacesRoot() {
-  return path.join(getAgentvDataDir(), "workspaces");
+  return path2.join(getAgentvDataDir(), "workspaces");
 }
 function getSubagentsRoot() {
-  return path.join(getAgentvDataDir(), "subagents");
+  return path2.join(getAgentvDataDir(), "subagents");
 }
 function getTraceStateRoot() {
-  return path.join(getAgentvDataDir(), "trace-state");
+  return path2.join(getAgentvDataDir(), "trace-state");
 }
 function getWorkspacePoolRoot() {
-  return path.join(getAgentvDataDir(), "workspace-pool");
+  return path2.join(getAgentvDataDir(), "workspace-pool");
 }
 async function fileExists(filePath) {
   try {
@@ -4217,14 +4251,14 @@ async function readJsonFile(filePath) {
   return JSON.parse(content);
 }
 async function findGitRoot(startPath) {
-  let currentDir = path2.dirname(path2.resolve(startPath));
-  const root = path2.parse(currentDir).root;
+  let currentDir = path3.dirname(path3.resolve(startPath));
+  const root = path3.parse(currentDir).root;
   while (currentDir !== root) {
-    const gitPath = path2.join(currentDir, ".git");
+    const gitPath = path3.join(currentDir, ".git");
     if (await fileExists(gitPath)) {
       return currentDir;
     }
-    const parentDir = path2.dirname(currentDir);
+    const parentDir = path3.dirname(currentDir);
     if (parentDir === currentDir) {
       break;
     }
@@ -4235,8 +4269,8 @@ async function findGitRoot(startPath) {
 function buildDirectoryChain(filePath, repoRoot) {
   const directories = [];
   const seen = /* @__PURE__ */ new Set();
-  const boundary = path2.resolve(repoRoot);
-  let current = path2.resolve(path2.dirname(filePath));
+  const boundary = path3.resolve(repoRoot);
+  let current = path3.resolve(path3.dirname(filePath));
   while (current !== void 0) {
     if (!seen.has(current)) {
       directories.push(current);
@@ -4245,7 +4279,7 @@ function buildDirectoryChain(filePath, repoRoot) {
     if (current === boundary) {
       break;
     }
-    const parent = path2.dirname(current);
+    const parent = path3.dirname(current);
     if (parent === current) {
       break;
     }
@@ -4259,16 +4293,16 @@ function buildDirectoryChain(filePath, repoRoot) {
 function buildSearchRoots(evalPath, repoRoot) {
   const uniqueRoots = [];
   const addRoot = (root) => {
-    const normalized = path2.resolve(root);
+    const normalized = path3.resolve(root);
     if (!uniqueRoots.includes(normalized)) {
       uniqueRoots.push(normalized);
     }
   };
-  let currentDir = path2.dirname(evalPath);
+  let currentDir = path3.dirname(evalPath);
   let reachedBoundary = false;
   while (!reachedBoundary) {
     addRoot(currentDir);
-    const parentDir = path2.dirname(currentDir);
+    const parentDir = path3.dirname(currentDir);
     if (currentDir === repoRoot || parentDir === currentDir) {
       reachedBoundary = true;
     } else {
@@ -4286,16 +4320,16 @@ function trimLeadingSeparators(value) {
 async function resolveFileReference(rawValue, searchRoots) {
   const displayPath = trimLeadingSeparators(rawValue);
   const potentialPaths = [];
-  if (path2.isAbsolute(rawValue)) {
-    potentialPaths.push(path2.normalize(rawValue));
+  if (path3.isAbsolute(rawValue)) {
+    potentialPaths.push(path3.normalize(rawValue));
   }
   for (const base of searchRoots) {
-    potentialPaths.push(path2.resolve(base, displayPath));
+    potentialPaths.push(path3.resolve(base, displayPath));
   }
   const attempted = [];
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of potentialPaths) {
-    const absoluteCandidate = path2.resolve(candidate);
+    const absoluteCandidate = path3.resolve(candidate);
     if (seen.has(absoluteCandidate)) {
       continue;
     }
@@ -4478,11 +4512,11 @@ function normalizeCliHealthcheck(input, env, targetName, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !path3.isAbsolute(cwd)) {
-    cwd = path3.resolve(path3.dirname(path3.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !path4.isAbsolute(cwd)) {
+    cwd = path4.resolve(path4.dirname(path4.resolve(evalFilePath)), cwd);
   }
   if (!cwd && evalFilePath) {
-    cwd = path3.dirname(path3.resolve(evalFilePath));
+    cwd = path4.dirname(path4.resolve(evalFilePath));
   }
   return {
     command,
@@ -4499,11 +4533,11 @@ function normalizeCliTargetInput(input, env, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !path3.isAbsolute(cwd)) {
-    cwd = path3.resolve(path3.dirname(path3.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !path4.isAbsolute(cwd)) {
+    cwd = path4.resolve(path4.dirname(path4.resolve(evalFilePath)), cwd);
   }
   if (!cwd && evalFilePath) {
-    cwd = path3.dirname(path3.resolve(evalFilePath));
+    cwd = path4.dirname(path4.resolve(evalFilePath));
   }
   const timeoutSeconds = input.timeout_seconds;
   const timeoutMs = timeoutSeconds !== void 0 ? Math.floor(timeoutSeconds * 1e3) : void 0;
@@ -5547,6 +5581,7 @@ function resolvePiCliConfig(target, env, _evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
+  const piCliSubprovider = normalizePiCliSubprovider(subprovider, baseUrl);
   const tools = resolveOptionalString(toolsSource, env, `${target.name} pi-cli tools`, {
     allowLiteral: true,
     optionalEnv: true
@@ -5570,7 +5605,7 @@ function resolvePiCliConfig(target, env, _evalFilePath) {
   const systemPrompt = typeof systemPromptSource === "string" && systemPromptSource.trim().length > 0 ? systemPromptSource.trim() : void 0;
   return {
     executable,
-    subprovider,
+    subprovider: piCliSubprovider,
     model,
     apiKey,
     baseUrl,
@@ -5585,6 +5620,13 @@ function resolvePiCliConfig(target, env, _evalFilePath) {
     systemPrompt
   };
 }
+function normalizePiCliSubprovider(subprovider, baseUrl) {
+  if (!baseUrl) return subprovider;
+  if (!subprovider || subprovider.toLowerCase() === "openai") {
+    return "azure";
+  }
+  return subprovider;
+}
 function resolveClaudeConfig(target, env, _evalFilePath) {
   const executableSource = target.executable ?? target.command ?? target.binary;
   const modelSource = target.model;
@@ -5635,7 +5677,7 @@ function resolveClaudeConfig(target, env, _evalFilePath) {
   };
 }
 function resolveCcMirrorBinaryPath(variant) {
-  const variantJsonPath = path3.join(homedir(), ".cc-mirror", variant, "variant.json");
+  const variantJsonPath = path4.join(homedir(), ".cc-mirror", variant, "variant.json");
   if (!existsSync(variantJsonPath)) {
     throw new Error(
       `cc-mirror variant "${variant}": ${variantJsonPath} not found. Install the variant or set "executable" explicitly.`
@@ -5721,7 +5763,7 @@ function resolveReplayConfig(target, env, evalFilePath) {
   };
 }
 function resolveReplaySourcePath(sourcePath, evalFilePath) {
-  return evalFilePath && !path3.isAbsolute(sourcePath) ? path3.resolve(path3.dirname(path3.resolve(evalFilePath)), sourcePath) : path3.resolve(sourcePath);
+  return evalFilePath && !path4.isAbsolute(sourcePath) ? path4.resolve(path4.dirname(path4.resolve(evalFilePath)), sourcePath) : path4.resolve(sourcePath);
 }
 function resolveVSCodeConfig(target, env, insiders, _evalFilePath) {
   const executableSource = target.executable;
@@ -5762,8 +5804,8 @@ function resolveCliConfig(target, env, evalFilePath) {
   const parseResult = CliTargetInputSchema.safeParse(target, { errorMap: cliErrorMap });
   if (!parseResult.success) {
     const firstError = parseResult.error.errors[0];
-    const path53 = firstError?.path.join(".") || "";
-    const prefix = path53 ? `${target.name} ${path53}: ` : `${target.name}: `;
+    const path83 = firstError?.path.join(".") || "";
+    const prefix = path83 ? `${target.name} ${path83}: ` : `${target.name}: `;
     throw new Error(`${prefix}${firstError?.message}`);
   }
   const normalized = normalizeCliTargetInput(parseResult.data, env, evalFilePath);
@@ -5784,11 +5826,11 @@ function resolveDiscoveredProviderConfig(target, providerKind, env, evalFilePath
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !path3.isAbsolute(cwd)) {
-    cwd = path3.resolve(path3.dirname(path3.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !path4.isAbsolute(cwd)) {
+    cwd = path4.resolve(path4.dirname(path4.resolve(evalFilePath)), cwd);
   }
   if (!cwd && evalFilePath) {
-    cwd = path3.dirname(path3.resolve(evalFilePath));
+    cwd = path4.dirname(path4.resolve(evalFilePath));
   }
   return {
     command,
@@ -6142,7 +6184,7 @@ function parseJsonlCases(content, filePath) {
   return results;
 }
 async function loadCasesFromFile(filePath) {
-  const ext = path4.extname(filePath).toLowerCase();
+  const ext = path5.extname(filePath).toLowerCase();
   let content;
   try {
     content = await readFile2(filePath, "utf8");
@@ -6169,7 +6211,7 @@ async function loadCasesFromFile(filePath) {
 }
 async function resolveFileReference2(ref, evalFileDir) {
   const rawPath = extractFilePath(ref);
-  const absolutePattern = path4.resolve(evalFileDir, rawPath);
+  const absolutePattern = path5.resolve(evalFileDir, rawPath);
   if (isGlobPattern(rawPath)) {
     const matches = await fg(absolutePattern.replaceAll("\\", "/"), {
       onlyFiles: true,
@@ -6196,10 +6238,10 @@ async function loadCasesFromDirectory(dirPath) {
   const subdirs = entries.filter((e) => e.isDirectory()).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
   const results = [];
   for (const subdir of subdirs) {
-    const subdirPath = path4.join(dirPath, subdir.name);
+    const subdirPath = path5.join(dirPath, subdir.name);
     let caseFilePath;
     for (const filename of ["case.yaml", "case.yml"]) {
-      const candidate = path4.join(subdirPath, filename);
+      const candidate = path5.join(subdirPath, filename);
       try {
         const s = await stat(candidate);
         if (s.isFile()) {
@@ -6235,7 +6277,7 @@ async function loadCasesFromDirectory(dirPath) {
       caseObj.id = subdir.name;
     }
     if (!caseObj.workspace) {
-      const workspaceDirPath = path4.join(subdirPath, "workspace");
+      const workspaceDirPath = path5.join(subdirPath, "workspace");
       try {
         const s = await stat(workspaceDirPath);
         if (s.isDirectory()) {
@@ -6260,18 +6302,172 @@ async function expandFileReferences(tests, evalFileDir) {
   }
   return expanded;
 }
+async function fileExists2(absolutePath) {
+  try {
+    await access2(absolutePath, constants2.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveToAbsolutePath(candidate) {
+  if (candidate instanceof URL) {
+    return candidate.protocol === "file:" ? fileURLToPath(candidate) : candidate.pathname;
+  }
+  if (typeof candidate === "string") {
+    if (candidate.startsWith("file:")) {
+      return fileURLToPath(candidate);
+    }
+    return path6.resolve(candidate);
+  }
+  throw new TypeError("Unsupported repoRoot value. Expected string or URL.");
+}
+function buildDirectoryChain2(filePath, repoRoot) {
+  const directories = [];
+  const seen = /* @__PURE__ */ new Set();
+  const boundary = path6.resolve(repoRoot);
+  let current = path6.resolve(path6.dirname(filePath));
+  while (current !== void 0) {
+    if (!seen.has(current)) {
+      directories.push(current);
+      seen.add(current);
+    }
+    if (current === boundary) {
+      break;
+    }
+    const parent = path6.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  if (!seen.has(boundary)) {
+    directories.push(boundary);
+  }
+  return directories;
+}
+function buildSearchRoots2(evalPath, repoRoot) {
+  const uniqueRoots = [];
+  const addRoot = (root) => {
+    const normalized = path6.resolve(root);
+    if (!uniqueRoots.includes(normalized)) {
+      uniqueRoots.push(normalized);
+    }
+  };
+  let currentDir = path6.dirname(evalPath);
+  let reachedBoundary = false;
+  while (!reachedBoundary) {
+    addRoot(currentDir);
+    const parentDir = path6.dirname(currentDir);
+    if (currentDir === repoRoot || parentDir === currentDir) {
+      reachedBoundary = true;
+    } else {
+      currentDir = parentDir;
+    }
+  }
+  addRoot(repoRoot);
+  addRoot(process.cwd());
+  return uniqueRoots;
+}
+function trimLeadingSeparators2(value) {
+  const trimmed = value.replace(/^[/\\]+/, "");
+  return trimmed.length > 0 ? trimmed : value;
+}
+async function resolveFileReference3(rawValue, searchRoots) {
+  const displayPath = trimLeadingSeparators2(rawValue);
+  const potentialPaths = [];
+  if (path6.isAbsolute(rawValue)) {
+    potentialPaths.push(path6.normalize(rawValue));
+  }
+  for (const base of searchRoots) {
+    potentialPaths.push(path6.resolve(base, displayPath));
+  }
+  const attempted = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of potentialPaths) {
+    const absoluteCandidate = path6.resolve(candidate);
+    if (seen.has(absoluteCandidate)) {
+      continue;
+    }
+    seen.add(absoluteCandidate);
+    attempted.push(absoluteCandidate);
+    if (await fileExists2(absoluteCandidate)) {
+      return { displayPath, resolvedPath: absoluteCandidate, attempted };
+    }
+  }
+  return { displayPath, attempted };
+}
+var PROMPT_MD_FILENAME = "PROMPT.md";
+function asStringArray(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  return value.filter((entry) => typeof entry === "string");
+}
+function basenameForPortablePath(value) {
+  return value.split(/[\\/]/).at(-1) ?? value;
+}
+function isPromptMdPath(value) {
+  return basenameForPortablePath(value) === PROMPT_MD_FILENAME;
+}
+function splitInputFiles(value) {
+  const files = asStringArray(value);
+  if (!files) {
+    return {};
+  }
+  const promptFile = files.find(isPromptMdPath);
+  const remaining = promptFile ? files.filter((file2) => !isPromptMdPath(file2)) : files;
+  return {
+    files,
+    ...promptFile ? { promptFile } : {},
+    ...remaining.length > 0 ? { remainingInputFiles: remaining } : {}
+  };
+}
+async function readPromptFile(promptPath) {
+  return (await readFile3(promptPath, "utf8")).replace(/\r\n/g, "\n");
+}
+async function loadPromptMdFallback(options) {
+  const testSplit = splitInputFiles(options.testInputFiles);
+  const suiteSplit = splitInputFiles(options.suiteInputFiles);
+  const inputFilesSource = testSplit.files ? "test" : suiteSplit.files ? "suite" : void 0;
+  const activeSplit = inputFilesSource === "test" ? testSplit : suiteSplit;
+  if (activeSplit.promptFile) {
+    const resolved = await resolveFileReference3(activeSplit.promptFile, options.searchRoots);
+    if (resolved.resolvedPath) {
+      return {
+        promptText: await readPromptFile(resolved.resolvedPath),
+        promptPath: path7.resolve(resolved.resolvedPath),
+        source: "input_files",
+        ...inputFilesSource ? { inputFilesSource } : {},
+        ...activeSplit.remainingInputFiles ? { remainingInputFiles: activeSplit.remainingInputFiles } : {}
+      };
+    }
+  }
+  const siblingPromptPath = path7.join(
+    path7.dirname(path7.resolve(options.evalFilePath)),
+    PROMPT_MD_FILENAME
+  );
+  if (await fileExists2(siblingPromptPath)) {
+    return {
+      promptText: await readPromptFile(siblingPromptPath),
+      promptPath: siblingPromptPath,
+      source: "sibling"
+    };
+  }
+  return void 0;
+}
 
-// ../../packages/core/dist/chunk-5W7DQNEF.js
-import path51 from "node:path";
+// ../../packages/core/dist/chunk-ZAXCSMNE.js
+import path50 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import { existsSync as existsSync7 } from "node:fs";
-import path50 from "node:path";
+import path49 from "node:path";
 import micromatch4 from "micromatch";
-import { mkdir, readFile as readFile3, writeFile } from "node:fs/promises";
-import path5 from "node:path";
+import { mkdir, readFile as readFile4, writeFile } from "node:fs/promises";
+import path8 from "node:path";
 import { createHash as createHash6, randomUUID as randomUUID10 } from "node:crypto";
-import path48 from "node:path";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
+import path47 from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 import micromatch3 from "micromatch";
 import { mkdtemp, rm, writeFile as writeFile2 } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -6282,22 +6478,22 @@ import fs from "node:fs/promises";
 import path32 from "node:path";
 import { readFile as readFile22 } from "node:fs/promises";
 import path22 from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { createWriteStream } from "node:fs";
 import { mkdir as mkdir2 } from "node:fs/promises";
-import path6 from "node:path";
+import path62 from "node:path";
 import path42 from "node:path";
 import path52 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { createWriteStream as createWriteStream2 } from "node:fs";
 import { mkdir as mkdir3 } from "node:fs/promises";
-import path7 from "node:path";
+import path72 from "node:path";
 import { exec as execWithCallback } from "node:child_process";
 import fs2 from "node:fs/promises";
 import os2 from "node:os";
-import path8 from "node:path";
+import path82 from "node:path";
 import { promisify } from "node:util";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { createWriteStream as createWriteStream3 } from "node:fs";
@@ -6990,10 +7186,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path53) {
-  if (!path53)
+function getElementAtPath(obj, path51) {
+  if (!path51)
     return obj;
-  return path53.reduce((acc, key) => acc?.[key], obj);
+  return path51.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -7313,11 +7509,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path53, issues) {
+function prefixIssues(path51, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path53);
+    iss.path.unshift(path51);
     return iss;
   });
 }
@@ -7454,7 +7650,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path53 = []) => {
+  const processError = (error41, path51 = []) => {
     var _a, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -7464,7 +7660,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path53, ...issue2.path];
+        const fullpath = [...path51, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -7494,9 +7690,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path53) {
+function toDotPath(path51) {
   const segs = [];
-  for (const seg of path53) {
+  for (const seg of path51) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -18926,7 +19122,7 @@ var RequestError = class _RequestError extends Error {
   }
 };
 
-// ../../packages/core/dist/chunk-5W7DQNEF.js
+// ../../packages/core/dist/chunk-ZAXCSMNE.js
 import { exec as execCallback } from "node:child_process";
 import { readdirSync, statSync } from "node:fs";
 import { readFile as readFile32, readdir as readdir2, stat as stat2 } from "node:fs/promises";
@@ -18936,11 +19132,11 @@ import { randomUUID as randomUUID4 } from "node:crypto";
 import { createWriteStream as createWriteStream4, existsSync as existsSync2, readdirSync as readdirSync2 } from "node:fs";
 import { arch, homedir as homedir3, platform } from "node:os";
 import path11 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath22 } from "node:url";
 import { readFile as readFile5 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
 import path14 from "node:path";
-import { readFile as readFile4, readdir as readdir22, stat as stat22 } from "node:fs/promises";
+import { readFile as readFile42, readdir as readdir22, stat as stat22 } from "node:fs/promises";
 import { homedir as homedir32 } from "node:os";
 import path13 from "node:path";
 import { randomUUID as randomUUID6 } from "node:crypto";
@@ -18967,7 +19163,7 @@ import { readFile as readFile7 } from "node:fs/promises";
 import { createHash as createHash3 } from "node:crypto";
 import { createHash as createHash2 } from "node:crypto";
 import { exec as exec2 } from "node:child_process";
-import { constants as constants2, access as access2 } from "node:fs/promises";
+import { constants as constants22, access as access22 } from "node:fs/promises";
 import path29 from "node:path";
 import { promisify as promisify4 } from "node:util";
 import { stat as stat5, writeFile as writeFile7 } from "node:fs/promises";
@@ -19023,28 +19219,24 @@ import { stringify as stringifyYaml } from "yaml";
 import { readdir as readdir7, stat as stat7 } from "node:fs/promises";
 import path39 from "node:path";
 import { readFile as readFile18, stat as stat9 } from "node:fs/promises";
-import path47 from "node:path";
+import path46 from "node:path";
 import micromatch2 from "micromatch";
 import { stringify as stringifyYaml2 } from "yaml";
 import { readFile as readFile12 } from "node:fs/promises";
 import path41 from "node:path";
 import { readFile as readFile13 } from "node:fs/promises";
-import path43 from "node:path";
-import { constants as constants4 } from "node:fs";
-import { access as access4 } from "node:fs/promises";
 import path422 from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { readFile as readFile15 } from "node:fs/promises";
-import path44 from "node:path";
+import path43 from "node:path";
 import { readFile as readFile14 } from "node:fs/promises";
 import { readFile as readFile17 } from "node:fs/promises";
-import path46 from "node:path";
+import path45 from "node:path";
 import micromatch from "micromatch";
 import { readFile as readFile16 } from "node:fs/promises";
-import path45 from "node:path";
+import path44 from "node:path";
 import { createHash as createHash7 } from "node:crypto";
 import { copyFile as copyFile3, mkdir as mkdir18, readFile as readFile20, writeFile as writeFile10 } from "node:fs/promises";
-import path49 from "node:path";
+import path48 from "node:path";
 import { readFile as readFile19 } from "node:fs/promises";
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
@@ -19055,7 +19247,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await readFile3(filePath, "utf8");
+      const data = await readFile4(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -19063,13 +19255,13 @@ var ResponseCache = class {
   }
   async set(key, value) {
     const filePath = this.keyToPath(key);
-    const dir = path5.dirname(filePath);
+    const dir = path8.dirname(filePath);
     await mkdir(dir, { recursive: true });
     await writeFile(filePath, JSON.stringify(value, null, 2), "utf8");
   }
   keyToPath(key) {
     const prefix = key.slice(0, 2);
-    return path5.join(this.cachePath, prefix, `${key}.json`);
+    return path8.join(this.cachePath, prefix, `${key}.json`);
   }
 };
 function shouldEnableCache(params) {
@@ -19737,7 +19929,7 @@ var CodeGrader = class {
       let exitCode = 0;
       let execStderr = "";
       if (context.dockerConfig) {
-        const { DockerWorkspaceProvider } = await import("./docker-workspace-RPPXBT27-B4AQHVWA.js");
+        const { DockerWorkspaceProvider } = await import("./docker-workspace-ZJ2ESVBI-6UDETQII.js");
         const dockerProvider = new DockerWorkspaceProvider(context.dockerConfig);
         const result = await dockerProvider.runGraderInContainer({
           command: [...this.command],
@@ -20012,7 +20204,7 @@ function normalizePreprocessorType(value) {
 }
 function resolveLocalFilePath(value, basePath) {
   if (value.startsWith("file://")) {
-    return fileURLToPath(value);
+    return fileURLToPath2(value);
   }
   if (/^[a-z]+:\/\//i.test(value)) {
     return void 0;
@@ -22757,115 +22949,115 @@ var FieldAccuracyGrader = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path522, match, required: required2 = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path522);
-    const expectedValue = resolvePath(expectedData, path522);
+    const { path: path51, match, required: required2 = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path51);
+    const expectedValue = resolvePath(expectedData, path51);
     if (expectedValue === void 0) {
       return {
-        path: path522,
+        path: path51,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path522}: no expected value`
+        message: `${path51}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required2) {
         return {
-          path: path522,
+          path: path51,
           score: 0,
           weight,
           hit: false,
-          message: `${path522} (required, missing)`
+          message: `${path51} (required, missing)`
         };
       }
       return {
-        path: path522,
+        path: path51,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path522}: optional field missing`
+        message: `${path51}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path522, candidateValue, expectedValue, weight);
+        return this.compareExact(path51, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path522,
+          path51,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path522, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path51, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path522,
+          path: path51,
           score: 0,
           weight,
           hit: false,
-          message: `${path522}: unknown match type "${match}"`
+          message: `${path51}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path522, candidateValue, expectedValue, weight) {
+  compareExact(path51, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path522,
+        path: path51,
         score: 1,
         weight,
         hit: true,
-        message: path522
+        message: path51
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path522,
+        path: path51,
         score: 0,
         weight,
         hit: false,
-        message: `${path522} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path51} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path522,
+      path: path51,
       score: 0,
       weight,
       hit: false,
-      message: `${path522} (value mismatch)`
+      message: `${path51} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path522, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path51, candidateValue, expectedValue, fieldConfig, weight) {
     const { tolerance = 0, relative = false } = fieldConfig;
     const candidateNum = toNumber(candidateValue);
     const expectedNum = toNumber(expectedValue);
     if (candidateNum === null || expectedNum === null) {
       return {
-        path: path522,
+        path: path51,
         score: 0,
         weight,
         hit: false,
-        message: `${path522} (non-numeric value)`
+        message: `${path51} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path522,
+        path: path51,
         score: 0,
         weight,
         hit: false,
-        message: `${path522} (invalid numeric value)`
+        message: `${path51} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -22878,61 +23070,61 @@ var FieldAccuracyGrader = class {
     }
     if (withinTolerance) {
       return {
-        path: path522,
+        path: path51,
         score: 1,
         weight,
         hit: true,
-        message: `${path522} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path51} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path522,
+      path: path51,
       score: 0,
       weight,
       hit: false,
-      message: `${path522} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path51} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path522, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path51, candidateValue, expectedValue, fieldConfig, weight) {
     const formats = fieldConfig.formats ?? DEFAULT_DATE_FORMATS;
     const candidateDate = parseDate(String(candidateValue), formats);
     const expectedDate = parseDate(String(expectedValue), formats);
     if (candidateDate === null) {
       return {
-        path: path522,
+        path: path51,
         score: 0,
         weight,
         hit: false,
-        message: `${path522} (unparseable candidate date)`
+        message: `${path51} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path522,
+        path: path51,
         score: 0,
         weight,
         hit: false,
-        message: `${path522} (unparseable expected date)`
+        message: `${path51} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path522,
+        path: path51,
         score: 1,
         weight,
         hit: true,
-        message: path522
+        message: path51
       };
     }
     return {
-      path: path522,
+      path: path51,
       score: 0,
       weight,
       hit: false,
-      message: `${path522} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path51} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -22965,11 +23157,11 @@ var FieldAccuracyGrader = class {
     };
   }
 };
-function resolvePath(obj, path522) {
-  if (!path522 || !obj) {
+function resolvePath(obj, path51) {
+  if (!path51 || !obj) {
     return void 0;
   }
-  const parts = path522.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path51.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -23500,8 +23692,8 @@ var TokenUsageGrader = class {
     };
   }
 };
-function getNestedValue(obj, path522) {
-  const parts = path522.split(".");
+function getNestedValue(obj, path51) {
+  const parts = path51.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -24602,10 +24794,10 @@ var ClaudeCliProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path6.resolve(cwdOverride);
+      return path62.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path6.resolve(this.config.cwd);
+      return path62.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -24615,7 +24807,7 @@ var ClaudeCliProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path6.resolve(this.config.logDir);
+      return path62.resolve(this.config.logDir);
     }
     return resolveDefaultProviderLogDir("claude-cli", request);
   }
@@ -24631,7 +24823,7 @@ var ClaudeCliProvider = class {
       console.warn(`Skipping Claude CLI stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path6.join(logDir, buildLogFilename(request, this.targetName));
+    const filePath = path62.join(logDir, buildLogFilename(request, this.targetName));
     try {
       const logger = await ClaudeCliStreamLogger.create({
         filePath,
@@ -25091,10 +25283,10 @@ var ClaudeSdkProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path7.resolve(cwdOverride);
+      return path72.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path7.resolve(this.config.cwd);
+      return path72.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -25104,7 +25296,7 @@ var ClaudeSdkProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path7.resolve(this.config.logDir);
+      return path72.resolve(this.config.logDir);
     }
     return resolveDefaultProviderLogDir("claude", request);
   }
@@ -25120,7 +25312,7 @@ var ClaudeSdkProvider = class {
       console.warn(`Skipping Claude stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path7.join(logDir, buildLogFilename2(request, this.targetName));
+    const filePath = path72.join(logDir, buildLogFilename2(request, this.targetName));
     try {
       const logger = await ClaudeStreamLogger.create({
         filePath,
@@ -25807,7 +25999,7 @@ function normalizeInputFiles2(inputFiles) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path8.resolve(inputFile);
+    const absolutePath = path82.resolve(inputFile);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -25821,7 +26013,7 @@ function formatFileList(files, template) {
   const formatter = template ?? "{path}";
   return files.map((filePath) => {
     const escapedPath = shellEscape(filePath);
-    const escapedName = shellEscape(path8.basename(filePath));
+    const escapedName = shellEscape(path82.basename(filePath));
     return formatter.replaceAll("{path}", escapedPath).replaceAll("{basename}", escapedName);
   }).join(" ");
 }
@@ -25845,7 +26037,7 @@ function generateOutputFilePath(evalCaseId, extension = ".json") {
   const safeEvalId = evalCaseId || "unknown";
   const timestamp = Date.now();
   const random = Math.random().toString(36).substring(2, 9);
-  return path8.join(os2.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
+  return path82.join(os2.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
 }
 function formatTimeoutSuffix2(timeoutMs) {
   if (!timeoutMs || timeoutMs <= 0) {
@@ -26481,7 +26673,7 @@ function resolvePlatformCliPath() {
   const binaryName = os22 === "win32" ? "copilot.exe" : "copilot";
   try {
     const resolved = import.meta.resolve(`${packageName}/package.json`);
-    const packageJsonPath = resolved.startsWith("file:") ? fileURLToPath2(resolved) : resolved;
+    const packageJsonPath = resolved.startsWith("file:") ? fileURLToPath22(resolved) : resolved;
     const binaryPath = path11.join(path11.dirname(packageJsonPath), binaryName);
     if (existsSync2(binaryPath)) {
       return binaryPath;
@@ -27463,7 +27655,7 @@ async function discoverCopilotSessions(opts) {
     const workspacePath = path13.join(sessionDir, "workspace.yaml");
     const eventsPath = path13.join(sessionDir, "events.jsonl");
     try {
-      const workspaceContent = await readFile4(workspacePath, "utf8");
+      const workspaceContent = await readFile42(workspacePath, "utf8");
       const workspace = parseYamlValue(workspaceContent) ?? {};
       const cwd = String(workspace.cwd ?? "");
       let updatedAt;
@@ -33317,7 +33509,7 @@ async function locateVSCodeExecutable(candidate) {
   if (includesPathSeparator) {
     const resolved = path29.isAbsolute(candidate) ? candidate : path29.resolve(candidate);
     try {
-      await access2(resolved, constants2.F_OK);
+      await access22(resolved, constants22.F_OK);
       return resolved;
     } catch {
       throw new Error(
@@ -33330,7 +33522,7 @@ async function locateVSCodeExecutable(candidate) {
     const { stdout } = await execAsync4(`${locator} ${candidate}`);
     const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
     if (lines.length > 0 && lines[0]) {
-      await access2(lines[0], constants2.F_OK);
+      await access22(lines[0], constants22.F_OK);
       return lines[0];
     }
   } catch {
@@ -33482,7 +33674,7 @@ function assertTargetDefinition(value, index, filePath) {
   }
   return value;
 }
-async function fileExists2(filePath) {
+async function fileExists3(filePath) {
   try {
     await access32(filePath, constants32.F_OK);
     return true;
@@ -33492,7 +33684,7 @@ async function fileExists2(filePath) {
 }
 async function readTargetDefinitions(filePath) {
   const absolutePath = path30.resolve(filePath);
-  if (!await fileExists2(absolutePath)) {
+  if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
   const raw = await readFile10(absolutePath, "utf8");
@@ -34587,13 +34779,23 @@ var WorkspacePoolManager = class {
   }
 };
 function getProjectsRegistryPath() {
-  return path37.join(getAgentvConfigDir(), "config.yaml");
+  return path37.join(getAgentvConfigDir(), AGENTV_CONFIG_FILE_NAME);
 }
 function readTrimmedString(value) {
   if (typeof value !== "string") return void 0;
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
+var warnedRemovedBackupAndForcePushPolicy = false;
+function warnRemovedBackupAndForcePushPolicy() {
+  if (warnedRemovedBackupAndForcePushPolicy) {
+    return;
+  }
+  warnedRemovedBackupAndForcePushPolicy = true;
+  console.warn(
+    "[agentv] projects[].results.sync.push_conflict_policy: 'backup_and_force_push' is no longer supported and was ignored while loading the project registry. Remove the field or set it to 'block'; AgentV never force-pushes result branches."
+  );
+}
 function fromYaml(raw) {
   if (!raw || typeof raw !== "object") return null;
   const e = raw;
@@ -34637,11 +34839,14 @@ function fromYaml(raw) {
           sync: {
             ...typeof sync.auto_push === "boolean" ? { autoPush: sync.auto_push } : {},
             ...typeof sync.require_push === "boolean" ? { requirePush: sync.require_push } : {},
-            ...sync.push_conflict_policy === "block" || sync.push_conflict_policy === "backup_and_force_push" ? { pushConflictPolicy: sync.push_conflict_policy } : {}
+            ...sync.push_conflict_policy === "block" ? { pushConflictPolicy: sync.push_conflict_policy } : {}
           }
         } : {},
         ...typeof r.branch_prefix === "string" && r.branch_prefix.trim().length > 0 ? { branchPrefix: r.branch_prefix.trim() } : {}
       };
+      if (sync?.push_conflict_policy === "backup_and_force_push") {
+        warnRemovedBackupAndForcePushPolicy();
+      }
     }
   }
   return entry;
@@ -34703,12 +34908,12 @@ function toYaml(entry) {
 }
 function loadProjectRegistry() {
   const registryPath = getProjectsRegistryPath();
-  if (!existsSync4(registryPath)) {
+  const localRegistryPath = getLocalConfigPath(registryPath);
+  if (!existsSync4(registryPath) && !existsSync4(localRegistryPath)) {
     return { projects: [] };
   }
   try {
-    const raw = readFileSync22(registryPath, "utf-8");
-    const parsed = parseYamlValue(raw);
+    const parsed = readMergedHomeConfig(registryPath);
     if (!parsed || typeof parsed !== "object") {
       return { projects: [] };
     }
@@ -34720,7 +34925,7 @@ function loadProjectRegistry() {
   }
 }
 function saveProjectRegistry(registry2) {
-  const registryPath = getProjectsRegistryPath();
+  const registryPath = getProjectsRegistryWritePath();
   const dir = path37.dirname(registryPath);
   if (!existsSync4(dir)) {
     mkdirSync2(dir, { recursive: true });
@@ -34737,6 +34942,17 @@ function readHomeConfig(configPath2) {
     return {};
   }
 }
+function readMergedHomeConfig(configPath2) {
+  const base = readHomeConfig(configPath2);
+  const local = readHomeConfig(getLocalConfigPath(configPath2));
+  return Object.keys(base).length > 0 && Object.keys(local).length > 0 ? mergeConfigObjects(base, local) : Object.keys(local).length > 0 ? local : base;
+}
+function getProjectsRegistryWritePath() {
+  const registryPath = getProjectsRegistryPath();
+  const localRegistryPath = getLocalConfigPath(registryPath);
+  const localConfig = readHomeConfig(localRegistryPath);
+  return Object.prototype.hasOwnProperty.call(localConfig, "projects") ? localRegistryPath : registryPath;
+}
 function deriveProjectId(dirPath, existingIds) {
   const base = path37.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   let candidate = base || "project";
@@ -34898,11 +35114,13 @@ var RepoManager = class {
   progress;
   heartbeatMs;
   timeoutMs;
+  projectConfigDir;
   constructor(verbose = false, options = {}) {
     this.verbose = verbose;
     this.progress = options.progress ?? true;
     this.heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
     this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+    this.projectConfigDir = options.projectConfigDir;
   }
   async runGit(args, opts) {
     const startedAt = Date.now();
@@ -35005,8 +35223,7 @@ ${output}` : ""}`
       });
     });
   }
-  loadConfiguredMirrors() {
-    const filePath = configPath();
+  loadConfiguredMirrorsFrom(filePath) {
     if (!existsSync5(filePath)) return {};
     try {
       const parsed = parseYamlValue(readFileSync3(filePath, "utf-8"));
@@ -35027,6 +35244,50 @@ ${output}` : ""}`
       return {};
     }
   }
+  findProjectAgentvDir() {
+    if (!this.projectConfigDir) return void 0;
+    let current = path38.resolve(this.projectConfigDir);
+    while (true) {
+      const candidateDir = path38.join(current, ".agentv");
+      if (existsSync5(path38.join(candidateDir, "config.yaml")) || existsSync5(path38.join(candidateDir, "config.override.yaml"))) {
+        return candidateDir;
+      }
+      const reachedRepoRoot = existsSync5(path38.join(current, ".git"));
+      const parent = path38.dirname(current);
+      if (reachedRepoRoot || parent === current) return void 0;
+      current = parent;
+    }
+  }
+  mergeConfiguredMirrorLayers(layers) {
+    const mirrorsByRepo = /* @__PURE__ */ new Map();
+    const repoByIdentity = /* @__PURE__ */ new Map();
+    for (const layer of layers) {
+      for (const [repo, localPath] of Object.entries(layer)) {
+        const repoIdentity = normalizeRepoIdentity(repo);
+        const previousRepo = repoByIdentity.get(repoIdentity);
+        if (previousRepo) mirrorsByRepo.delete(previousRepo);
+        repoByIdentity.set(repoIdentity, repo);
+        mirrorsByRepo.set(repo, localPath);
+      }
+    }
+    return Object.fromEntries(mirrorsByRepo);
+  }
+  loadConfiguredMirrors() {
+    const globalMirrors = this.loadConfiguredMirrorsFrom(configPath());
+    const projectAgentvDir = this.findProjectAgentvDir();
+    if (!projectAgentvDir) return globalMirrors;
+    const projectMirrors = this.loadConfiguredMirrorsFrom(
+      path38.join(projectAgentvDir, "config.yaml")
+    );
+    const projectOverrideMirrors = this.loadConfiguredMirrorsFrom(
+      path38.join(projectAgentvDir, "config.override.yaml")
+    );
+    return this.mergeConfiguredMirrorLayers([
+      globalMirrors,
+      projectMirrors,
+      projectOverrideMirrors
+    ]);
+  }
   findConfiguredMirror(repoIdentity) {
     const mirrors = this.loadConfiguredMirrors();
     for (const [repo, localPath] of Object.entries(mirrors)) {
@@ -35548,7 +35809,7 @@ async function prepareSharedWorkspaceSetup(options) {
       const slotsNeeded = workers;
       setupLog(`acquiring ${slotsNeeded} workspace pool slot(s) (pool capacity: ${poolMaxSlots})`);
       poolManager = new WorkspacePoolManager(getWorkspacePoolRoot());
-      const poolRepoManager = new RepoManager(verbose);
+      const poolRepoManager = new RepoManager(verbose, { projectConfigDir: evalDir });
       repoManager = poolRepoManager;
       for (let i = 0; i < slotsNeeded; i++) {
         const slot = await poolManager.acquireWorkspace({
@@ -35597,7 +35858,7 @@ async function prepareSharedWorkspaceSetup(options) {
     const hasReposToMaterialize = !!suiteWorkspace?.repos?.length && !usePool && !isPerTestIsolation;
     const needsRepoMaterialisation = hasReposToMaterialize && (!useStaticWorkspace || staticMaterialised);
     const needsPerRepoCheck = hasReposToMaterialize && useStaticWorkspace && !staticMaterialised && isYamlConfiguredPath;
-    repoManager = repoManager ?? (needsRepoMaterialisation || needsPerRepoCheck ? new RepoManager(verbose) : void 0);
+    repoManager = repoManager ?? (needsRepoMaterialisation || needsPerRepoCheck ? new RepoManager(verbose, { projectConfigDir: evalDir }) : void 0);
     if ((needsRepoMaterialisation || needsPerRepoCheck) && repoManager && sharedWorkspacePath && suiteWorkspace?.repos) {
       try {
         if (needsPerRepoCheck) {
@@ -35635,7 +35896,7 @@ async function prepareSharedWorkspaceSetup(options) {
     const suiteDockerConfig = suiteWorkspace?.docker;
     if (suiteDockerConfig) {
       setupLog(`pulling Docker image: ${suiteDockerConfig.image}`);
-      const { DockerWorkspaceProvider } = await import("./docker-workspace-RPPXBT27-B4AQHVWA.js");
+      const { DockerWorkspaceProvider } = await import("./docker-workspace-ZJ2ESVBI-6UDETQII.js");
       const dockerSetup = new DockerWorkspaceProvider(suiteDockerConfig);
       if (!await dockerSetup.isDockerAvailable()) {
         throw new Error(
@@ -35972,7 +36233,7 @@ async function prepareEvalCaseWorkspace(options) {
       await mkdir17(workspacePath, { recursive: true });
     }
     if (evalCase.workspace?.repos?.length && workspacePath) {
-      const perCaseRepoManager = new RepoManager(setupDebug);
+      const perCaseRepoManager = new RepoManager(setupDebug, { projectConfigDir: evalDir });
       try {
         if (setupDebug) {
           console.log(
@@ -36395,101 +36656,6 @@ function parseAgentSkillsEvals(parsed, source = "evals.json", baseDir) {
   }
   return tests;
 }
-async function fileExists3(absolutePath) {
-  try {
-    await access4(absolutePath, constants4.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function resolveToAbsolutePath(candidate) {
-  if (candidate instanceof URL) {
-    return candidate.protocol === "file:" ? fileURLToPath4(candidate) : candidate.pathname;
-  }
-  if (typeof candidate === "string") {
-    if (candidate.startsWith("file:")) {
-      return fileURLToPath4(candidate);
-    }
-    return path422.resolve(candidate);
-  }
-  throw new TypeError("Unsupported repoRoot value. Expected string or URL.");
-}
-function buildDirectoryChain2(filePath, repoRoot) {
-  const directories = [];
-  const seen = /* @__PURE__ */ new Set();
-  const boundary = path422.resolve(repoRoot);
-  let current = path422.resolve(path422.dirname(filePath));
-  while (current !== void 0) {
-    if (!seen.has(current)) {
-      directories.push(current);
-      seen.add(current);
-    }
-    if (current === boundary) {
-      break;
-    }
-    const parent = path422.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-  if (!seen.has(boundary)) {
-    directories.push(boundary);
-  }
-  return directories;
-}
-function buildSearchRoots2(evalPath, repoRoot) {
-  const uniqueRoots = [];
-  const addRoot = (root) => {
-    const normalized = path422.resolve(root);
-    if (!uniqueRoots.includes(normalized)) {
-      uniqueRoots.push(normalized);
-    }
-  };
-  let currentDir = path422.dirname(evalPath);
-  let reachedBoundary = false;
-  while (!reachedBoundary) {
-    addRoot(currentDir);
-    const parentDir = path422.dirname(currentDir);
-    if (currentDir === repoRoot || parentDir === currentDir) {
-      reachedBoundary = true;
-    } else {
-      currentDir = parentDir;
-    }
-  }
-  addRoot(repoRoot);
-  addRoot(process.cwd());
-  return uniqueRoots;
-}
-function trimLeadingSeparators2(value) {
-  const trimmed = value.replace(/^[/\\]+/, "");
-  return trimmed.length > 0 ? trimmed : value;
-}
-async function resolveFileReference3(rawValue, searchRoots) {
-  const displayPath = trimLeadingSeparators2(rawValue);
-  const potentialPaths = [];
-  if (path422.isAbsolute(rawValue)) {
-    potentialPaths.push(path422.normalize(rawValue));
-  }
-  for (const base of searchRoots) {
-    potentialPaths.push(path422.resolve(base, displayPath));
-  }
-  const attempted = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const candidate of potentialPaths) {
-    const absoluteCandidate = path422.resolve(candidate);
-    if (seen.has(absoluteCandidate)) {
-      continue;
-    }
-    seen.add(absoluteCandidate);
-    attempted.push(absoluteCandidate);
-    if (await fileExists3(absoluteCandidate)) {
-      return { displayPath, resolvedPath: absoluteCandidate, attempted };
-    }
-  }
-  return { displayPath, attempted };
-}
 var ANSI_YELLOW2 = "\x1B[33m";
 var ANSI_RESET22 = "\x1B[0m";
 var DEFAULT_EVAL_PATTERNS = [
@@ -36499,25 +36665,50 @@ var DEFAULT_EVAL_PATTERNS = [
 ];
 async function loadConfig(evalFilePath, repoRoot) {
   const directories = buildDirectoryChain2(evalFilePath, repoRoot);
-  const globalConfigPath = path43.join(getAgentvConfigDir(), "config.yaml");
+  const globalConfigPath = path422.join(getAgentvConfigDir(), AGENTV_CONFIG_FILE_NAME);
   for (const directory of directories) {
-    const configPath2 = path43.join(directory, ".agentv", "config.yaml");
-    if (!await fileExists3(configPath2)) {
+    const configPath2 = path422.join(directory, ".agentv", AGENTV_CONFIG_FILE_NAME);
+    if (!await configPairExists(configPath2)) {
       continue;
     }
-    const config2 = await readConfigFile(configPath2);
-    if (config2) {
-      return config2;
-    }
+    return readConfigFilePair(configPath2);
   }
-  return await fileExists3(globalConfigPath) ? readConfigFile(globalConfigPath) : null;
+  return await configPairExists(globalConfigPath) ? readConfigFilePair(globalConfigPath) : null;
 }
-async function readConfigFile(configPath2) {
+async function configPairExists(configPath2) {
+  return await fileExists2(configPath2) || await fileExists2(getLocalConfigPath(configPath2));
+}
+async function readConfigObjectFile(configPath2) {
+  if (!await fileExists2(configPath2)) {
+    return void 0;
+  }
   try {
     const rawConfig = await readFile13(configPath2, "utf8");
-    const parsed = interpolateEnv(parseYamlValue(rawConfig), process.env);
+    const parsed = parseYamlValue(rawConfig);
+    if (!isPlainConfigObject(parsed)) {
+      logWarning(`Invalid AgentV config format at ${configPath2}`);
+      return void 0;
+    }
+    return parsed;
+  } catch (error40) {
+    logWarning(`Could not read AgentV config at ${configPath2}: ${error40.message}`);
+    return void 0;
+  }
+}
+async function readConfigFilePair(configPath2) {
+  const base = await readConfigObjectFile(configPath2);
+  const local = await readConfigObjectFile(getLocalConfigPath(configPath2));
+  const rawMerged = base && local ? mergeConfigObjects(base, local) : local ?? base;
+  if (!rawMerged) {
+    return null;
+  }
+  return parseConfigObject(rawMerged, local ? getLocalConfigPath(configPath2) : configPath2);
+}
+function parseConfigObject(rawConfig, configPath2) {
+  try {
+    const parsed = interpolateEnv(rawConfig, process.env);
     if (!isJsonObject(parsed)) {
-      logWarning(`Invalid config.yaml format at ${configPath2}`);
+      logWarning(`Invalid AgentV config format at ${configPath2}`);
       return null;
     }
     const config2 = parsed;
@@ -36539,17 +36730,27 @@ async function readConfigFile(configPath2) {
       parsed.execution,
       configPath2
     );
+    const defaultExperiment = parseDefaultExperiment(
+      parsed.default_experiment,
+      configPath2
+    );
+    const experiments = parseExperimentsConfig(
+      parsed.experiments,
+      configPath2
+    );
     const results = parseResultsConfig(parsed.results, configPath2);
     const hooks = parseHooksConfig(parsed.hooks, configPath2);
     return {
       required_version: requiredVersion,
       eval_patterns: evalPatterns,
+      ...defaultExperiment && { default_experiment: defaultExperiment },
+      ...experiments && { experiments },
       execution: executionDefaults,
       results,
       ...hooks && { hooks }
     };
   } catch (error40) {
-    logWarning(`Could not read config.yaml at ${configPath2}: ${error40.message}`);
+    logWarning(`Could not parse AgentV config at ${configPath2}: ${error40.message}`);
     return null;
   }
 }
@@ -36661,58 +36862,6 @@ function extractTargetsFromTestCase(testCase) {
   }
   return void 0;
 }
-var VALID_TRIAL_STRATEGIES = /* @__PURE__ */ new Set([
-  "pass_at_k",
-  "mean",
-  "confidence_interval"
-]);
-function extractTrialsConfig(suite) {
-  const execution = suite.execution;
-  if (!execution || typeof execution !== "object" || Array.isArray(execution)) {
-    return void 0;
-  }
-  const trials = execution.trials;
-  if (!trials || typeof trials !== "object" || Array.isArray(trials)) {
-    return void 0;
-  }
-  const trialsObj = trials;
-  const count = trialsObj.count;
-  if (count === void 0 || count === null) {
-    return void 0;
-  }
-  if (typeof count !== "number" || !Number.isInteger(count) || count < 1) {
-    logWarning(
-      `Invalid trials.count: ${count}, must be a positive integer. Ignoring trials config.`
-    );
-    return void 0;
-  }
-  if (count === 1) {
-    return void 0;
-  }
-  const rawStrategy = trialsObj.strategy;
-  let strategy = "pass_at_k";
-  if (rawStrategy !== void 0 && rawStrategy !== null) {
-    if (typeof rawStrategy !== "string" || !VALID_TRIAL_STRATEGIES.has(rawStrategy)) {
-      logWarning(
-        `Invalid trials.strategy: '${rawStrategy}'. Must be one of: pass_at_k, mean, confidence_interval. Defaulting to pass_at_k.`
-      );
-    } else {
-      strategy = rawStrategy;
-    }
-  }
-  const rawCostLimit = trialsObj.cost_limit_usd ?? trialsObj.costLimitUsd;
-  let costLimitUsd;
-  if (rawCostLimit !== void 0 && rawCostLimit !== null) {
-    if (typeof rawCostLimit === "number" && rawCostLimit > 0) {
-      costLimitUsd = rawCostLimit;
-    } else {
-      logWarning(
-        `Invalid trials.cost_limit_usd: ${rawCostLimit}. Must be a positive number. Ignoring.`
-      );
-    }
-  }
-  return { count, strategy, costLimitUsd };
-}
 function extractCacheConfig(suite) {
   const execution = suite.execution;
   if (!execution || typeof execution !== "object" || Array.isArray(execution)) {
@@ -36843,6 +36992,36 @@ function parseExecutionDefaults(raw, configPath2) {
   }
   return Object.keys(result).length > 0 ? result : void 0;
 }
+function resolveDefaultExperimentReference(config2) {
+  return config2?.experiments?.default ?? config2?.default_experiment;
+}
+function parseDefaultExperiment(raw, configPath2) {
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  const value = readTrimmedString2(raw);
+  if (!value) {
+    logWarning(`Invalid default_experiment in ${configPath2}, expected non-empty string`);
+    return void 0;
+  }
+  return value;
+}
+function parseExperimentsConfig(raw, configPath2) {
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    logWarning(`Invalid experiments in ${configPath2}, expected object`);
+    return void 0;
+  }
+  const obj = raw;
+  const defaultExperiment = readTrimmedString2(obj.default);
+  if (obj.default !== void 0 && !defaultExperiment) {
+    logWarning(`Invalid experiments.default in ${configPath2}, expected non-empty string`);
+    return void 0;
+  }
+  return defaultExperiment ? { default: defaultExperiment } : void 0;
+}
 function isFilesystemPath(p) {
   return p.startsWith("/") || p.startsWith("~/") || p.startsWith("~\\") || p === "~" || /^[A-Za-z]:[/\\]/.test(p);
 }
@@ -37006,16 +37185,20 @@ function parseResultsConfig(raw, configPath2) {
       logWarning(`Invalid results.sync.require_push in ${configPath2}, expected boolean`);
       return void 0;
     }
-    if (syncObj.push_conflict_policy !== void 0 && syncObj.push_conflict_policy !== "block" && syncObj.push_conflict_policy !== "backup_and_force_push") {
+    if (syncObj.push_conflict_policy === "backup_and_force_push") {
       logWarning(
-        `Invalid results.sync.push_conflict_policy in ${configPath2}, expected 'block' or 'backup_and_force_push'`
+        `results.sync.push_conflict_policy: 'backup_and_force_push' in ${configPath2} is no longer supported. Remove the field or set it to 'block'; AgentV never force-pushes result branches.`
       );
       return void 0;
     }
+    if (syncObj.push_conflict_policy !== void 0 && syncObj.push_conflict_policy !== "block") {
+      logWarning(`Invalid results.sync.push_conflict_policy in ${configPath2}, expected 'block'`);
+      return void 0;
+    }
     sync = {
       ...typeof syncObj.auto_push === "boolean" && { auto_push: syncObj.auto_push },
       ...typeof syncObj.require_push === "boolean" && { require_push: syncObj.require_push },
-      ...(syncObj.push_conflict_policy === "block" || syncObj.push_conflict_policy === "backup_and_force_push") && {
+      ...syncObj.push_conflict_policy === "block" && {
         push_conflict_policy: syncObj.push_conflict_policy
       }
     };
@@ -37146,8 +37329,8 @@ function isTemplateReference(value) {
 }
 async function resolveAssertionTemplateReference(include, searchRoots) {
   const templateCandidates = isTemplateReference(include) ? [
-    path44.join(".agentv", "templates", `${include}.yaml`),
-    path44.join(".agentv", "templates", `${include}.yml`)
+    path43.join(".agentv", "templates", `${include}.yaml`),
+    path43.join(".agentv", "templates", `${include}.yml`)
   ] : [include];
   const attempted = [];
   for (const candidate of templateCandidates) {
@@ -37200,10 +37383,10 @@ ${resolved.attempted.map((attempt) => `  Tried: ${attempt}`).join("\n")}` : "";
       `Invalid assertion template file in '${evalId}': ${resolved.resolvedPath} is missing a top-level assertions array`
     );
   }
-  const templateDir = path44.dirname(resolved.resolvedPath);
+  const templateDir = path43.dirname(resolved.resolvedPath);
   const nestedSearchRoots = [
     templateDir,
-    ...searchRoots.filter((root) => path44.resolve(root) !== templateDir)
+    ...searchRoots.filter((root) => path43.resolve(root) !== templateDir)
   ];
   return await expandGraderEntries(assertions, nestedSearchRoots, evalId, {
     depth: nextDepth,
@@ -37264,7 +37447,7 @@ async function collectAssertionTemplateReferencesFromValue(value, searchRoots, e
         references.push({
           kind: "assertion_template",
           displayPath: resolved.displayPath,
-          ...resolved.resolvedPath ? { resolvedPath: path44.resolve(resolved.resolvedPath) } : {}
+          ...resolved.resolvedPath ? { resolvedPath: path43.resolve(resolved.resolvedPath) } : {}
         });
         if (resolved.resolvedPath) {
           if (includeContext.chain.includes(resolved.resolvedPath)) {
@@ -37274,10 +37457,10 @@ async function collectAssertionTemplateReferencesFromValue(value, searchRoots, e
           const content = await readFile15(resolved.resolvedPath, "utf8");
           const parsed = interpolateEnv(parseYamlValue(content), process.env);
           if (isJsonObject2(parsed) && Array.isArray(parsed.assertions)) {
-            const templateDir = path44.dirname(resolved.resolvedPath);
+            const templateDir = path43.dirname(resolved.resolvedPath);
             const nestedSearchRoots = [
               templateDir,
-              ...searchRoots.filter((root) => path44.resolve(root) !== templateDir)
+              ...searchRoots.filter((root) => path43.resolve(root) !== templateDir)
             ];
             references.push(
               ...await collectAssertionTemplateReferencesFromValue(
@@ -37447,7 +37630,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
         }
         command = parseCommandToArgv(trimmed);
       } else {
-        command = asStringArray(
+        command = asStringArray2(
           rawCommand,
           `code-grader command for evaluator '${name}' in '${evalId}'`
         );
@@ -37463,7 +37646,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
       if (cwd) {
         const resolved = await resolveFileReference3(cwd, searchRoots);
         if (resolved.resolvedPath) {
-          resolvedCwd = path44.resolve(resolved.resolvedPath);
+          resolvedCwd = path43.resolve(resolved.resolvedPath);
         } else {
           logWarning2(
             `Code-grader evaluator '${name}' in '${evalId}': cwd not found (${resolved.displayPath})`,
@@ -37653,7 +37836,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
             aggregatorPrompt = fileRef;
             const resolved = await resolveFileReference3(fileRef, searchRoots);
             if (resolved.resolvedPath) {
-              promptPath2 = path44.resolve(resolved.resolvedPath);
+              promptPath2 = path43.resolve(resolved.resolvedPath);
             } else {
               throw new Error(
                 `Composite aggregator in '${evalId}': prompt file not found: ${resolved.displayPath}`
@@ -38323,7 +38506,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
           `${ANSI_YELLOW22}Warning: 'prompt.script' is deprecated in evaluator '${name}' in '${evalId}'. Use 'prompt.command' instead.${ANSI_RESET3}`
         );
       }
-      const commandArray = asStringArray(
+      const commandArray = asStringArray2(
         rawPrompt.command ?? rawPrompt.script,
         `prompt.command for evaluator '${name}' in '${evalId}'`
       );
@@ -38333,7 +38516,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
       const commandPath = commandArray[commandArray.length - 1];
       const resolved = await resolveFileReference3(commandPath, searchRoots);
       if (resolved.resolvedPath) {
-        resolvedPromptScript = [...commandArray.slice(0, -1), path44.resolve(resolved.resolvedPath)];
+        resolvedPromptScript = [...commandArray.slice(0, -1), path43.resolve(resolved.resolvedPath)];
       } else {
         throw new Error(
           `Grader '${name}' in '${evalId}': prompt command file not found: ${resolved.displayPath}`
@@ -38348,7 +38531,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
         prompt = fileRef;
         const resolved = await resolveFileReference3(fileRef, searchRoots);
         if (resolved.resolvedPath) {
-          promptPath = path44.resolve(resolved.resolvedPath);
+          promptPath = path43.resolve(resolved.resolvedPath);
           try {
             await validateCustomPromptContent(promptPath);
           } catch (error40) {
@@ -38487,7 +38670,7 @@ async function parsePreprocessors(rawValue, searchRoots, evaluatorName, evalId)
     if (!type) {
       throw new Error(`Grader '${evaluatorName}' in '${evalId}': preprocessor.type is required`);
     }
-    const command = asStringArray(
+    const command = asStringArray2(
       rawEntry.command,
       `preprocessor command for evaluator '${evaluatorName}' in '${evalId}'`
     );
@@ -38506,7 +38689,7 @@ async function parsePreprocessors(rawValue, searchRoots, evaluatorName, evalId)
     preprocessors.push({
       type,
       command,
-      resolvedCommand: [...command.slice(0, -1), path44.resolve(resolved.resolvedPath)]
+      resolvedCommand: [...command.slice(0, -1), path43.resolve(resolved.resolvedPath)]
     });
   }
   return preprocessors;
@@ -38573,7 +38756,7 @@ function asStringArrayStrict(value) {
   const result = value.filter((v) => typeof v === "string");
   return result.length > 0 ? result : void 0;
 }
-function asStringArray(value, description) {
+function asStringArray2(value, description) {
   if (value === void 0) {
     return void 0;
   }
@@ -38601,10 +38784,10 @@ async function resolveOptionalCommandSource(command, searchRoots) {
     return void 0;
   }
   const resolved = await resolveFileReference3(candidate, searchRoots);
-  return resolved.resolvedPath ? path44.resolve(resolved.resolvedPath) : void 0;
+  return resolved.resolvedPath ? path43.resolve(resolved.resolvedPath) : void 0;
 }
 function looksLikeFilePath(value) {
-  return path44.isAbsolute(value) || value.startsWith(".") || value.includes("/") || value.includes("\\") || /\.[cm]?[jt]sx?$|\.py$|\.sh$|\.bash$|\.rb$|\.go$|\.rs$/i.test(value);
+  return path43.isAbsolute(value) || value.startsWith(".") || value.includes("/") || value.includes("\\") || /\.[cm]?[jt]sx?$|\.py$|\.sh$|\.bash$|\.rb$|\.go$|\.rs$/i.test(value);
 }
 function parseCommandToArgv(command) {
   if (process.platform === "win32") {
@@ -38992,7 +39175,7 @@ var IMAGE_MEDIA_TYPES = {
   ".bmp": "image/bmp"
 };
 function detectImageMediaType(filePath) {
-  const ext = path45.extname(filePath).toLowerCase();
+  const ext = path44.extname(filePath).toLowerCase();
   return IMAGE_MEDIA_TYPES[ext];
 }
 var ANSI_YELLOW3 = "\x1B[33m";
@@ -39056,7 +39239,7 @@ async function processMessages(options) {
             ...cloneJsonObject(rawSegment),
             path: displayPath,
             text: fileContent,
-            resolvedPath: path45.resolve(resolvedPath)
+            resolvedPath: path44.resolve(resolvedPath)
           });
           if (verbose) {
             const label = messageType === "input" ? "[File]" : "[Expected Output File]";
@@ -39180,7 +39363,7 @@ async function processExpectedMessages(options) {
               type: "file",
               path: displayPath,
               text: fileContent,
-              resolvedPath: path45.resolve(resolvedPath)
+              resolvedPath: path44.resolve(resolvedPath)
             });
             if (verbose) {
               console.log(`  [Expected Output File] Found: ${displayPath}`);
@@ -39326,7 +39509,7 @@ function matchesFilter(id, filter) {
   return typeof filter === "string" ? micromatch.isMatch(id, filter) : filter.some((pattern) => micromatch.isMatch(id, pattern));
 }
 function detectFormat(filePath) {
-  const ext = path46.extname(filePath).toLowerCase();
+  const ext = path45.extname(filePath).toLowerCase();
   if (ext === ".jsonl") return "jsonl";
   if (ext === ".yaml" || ext === ".yml") return "yaml";
   if (ext === ".json") return "agent-skills-json";
@@ -39336,10 +39519,10 @@ function detectFormat(filePath) {
   );
 }
 async function loadSidecarMetadata(jsonlPath, verbose) {
-  const dir = path46.dirname(jsonlPath);
-  const base = path46.basename(jsonlPath, ".jsonl");
-  const sidecarPath = path46.join(dir, `${base}.yaml`);
-  if (!await fileExists3(sidecarPath)) {
+  const dir = path45.dirname(jsonlPath);
+  const base = path45.basename(jsonlPath, ".jsonl");
+  const sidecarPath = path45.join(dir, `${base}.yaml`);
+  if (!await fileExists2(sidecarPath)) {
     if (verbose) {
       logWarning4(`Sidecar metadata file not found: ${sidecarPath} (using defaults)`);
     }
@@ -39387,13 +39570,13 @@ function parseJsonlContent(content, filePath) {
 async function loadTestsFromJsonl(evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
   const filterPattern = options?.filter;
-  const absoluteTestPath = path46.resolve(evalFilePath);
+  const absoluteTestPath = path45.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
   const sidecar = await loadSidecarMetadata(absoluteTestPath, verbose);
   const rawFile = await readFile17(absoluteTestPath, "utf8");
   const rawCases = parseJsonlContent(rawFile, evalFilePath);
-  const fallbackSuiteName = path46.basename(absoluteTestPath, ".jsonl") || "eval";
+  const fallbackSuiteName = path45.basename(absoluteTestPath, ".jsonl") || "eval";
   const suiteName = sidecar.name && sidecar.name.trim().length > 0 ? sidecar.name : fallbackSuiteName;
   const globalEvaluator = coerceEvaluator(sidecar.evaluator, "sidecar") ?? "llm-grader";
   const globalExecution = sidecar.execution;
@@ -39790,7 +39973,7 @@ function interpolateRawEvalCase(raw, vars) {
 }
 async function readTestSuiteMetadata(testFilePath) {
   try {
-    const absolutePath = path47.resolve(testFilePath);
+    const absolutePath = path46.resolve(testFilePath);
     const content = await readFile18(absolutePath, "utf8");
     const parsed = interpolateEnv(parseYamlValue(content), process.env);
     if (!isJsonObject(parsed)) {
@@ -39799,8 +39982,7 @@ async function readTestSuiteMetadata(testFilePath) {
     return {
       target: extractTargetFromSuite(parsed),
       targets: extractTargetsFromSuite(parsed),
-      targetRefs: extractTargetRefsFromSuite(parsed),
-      trials: extractTrialsConfig(parsed)
+      targetRefs: extractTargetRefsFromSuite(parsed)
     };
   } catch {
     return {};
@@ -39815,7 +39997,7 @@ async function loadTestSuite(evalFilePath, repoRoot, options) {
     return { tests: await loadTestsFromAgentSkills(evalFilePath) };
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-HQDMXQQV-LBW3N3W6.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-RE43OAGX-AMRCUKBZ.js");
     return loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
   }
   const { tests, parsed, suiteWorkspacePath } = await loadTestsFromYaml(
@@ -39844,7 +40026,7 @@ async function loadTests(evalFilePath, repoRoot, options) {
     return loadTestsFromAgentSkills(evalFilePath);
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-HQDMXQQV-LBW3N3W6.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-RE43OAGX-AMRCUKBZ.js");
     const suite = await loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
     return suite.tests;
   }
@@ -39853,14 +40035,14 @@ async function loadTests(evalFilePath, repoRoot, options) {
 }
 var loadEvalCases = loadTests;
 async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
-  const absoluteTestPath = path47.resolve(evalFilePath);
+  const absoluteTestPath = path46.resolve(evalFilePath);
   const rawFile = await readFile18(absoluteTestPath, "utf8");
   return loadTestsFromParsedYamlValue(parseYamlValue(rawFile), evalFilePath, repoRoot, options);
 }
 async function loadTestsFromParsedYamlValue(rawParsed, evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
   const filterPattern = options?.filter;
-  const absoluteTestPath = path47.resolve(evalFilePath);
+  const absoluteTestPath = path46.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
   const config2 = await loadConfig(absoluteTestPath, repoRootPath);
@@ -39871,7 +40053,7 @@ async function loadTestsFromParsedYamlValue(rawParsed, evalFilePath, repoRoot, o
   }
   const suite = interpolated;
   const suiteNameFromFile = asString5(suite.name)?.trim();
-  const fallbackSuiteName = path47.basename(absoluteTestPath).replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "") || "eval";
+  const fallbackSuiteName = path46.basename(absoluteTestPath).replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "") || "eval";
   const suiteName = suiteNameFromFile && suiteNameFromFile.length > 0 ? suiteNameFromFile : fallbackSuiteName;
   const rawTestCases = resolveTests(suite);
   const globalEvaluator = coerceEvaluator(suite.evaluator, "global") ?? "llm-grader";
@@ -39881,10 +40063,10 @@ async function loadTestsFromParsedYamlValue(rawParsed, evalFilePath, repoRoot, o
     "<suite>",
     absoluteTestPath
   );
-  const evalFileDir = path47.dirname(absoluteTestPath);
+  const evalFileDir = path46.dirname(absoluteTestPath);
   let expandedTestCases;
   if (typeof rawTestCases === "string") {
-    const externalPath = path47.resolve(evalFileDir, rawTestCases);
+    const externalPath = path46.resolve(evalFileDir, rawTestCases);
     let isDir = false;
     try {
       const pathStat = await stat9(externalPath);
@@ -39939,12 +40121,41 @@ async function loadTestsFromParsedYamlValue(rawParsed, evalFilePath, repoRoot, o
     const skipDefaults = caseExecution?.skip_defaults === true;
     const caseThreshold = typeof caseExecution?.threshold === "number" && caseExecution.threshold >= 0 && caseExecution.threshold <= 1 ? caseExecution.threshold : void 0;
     const effectiveSuiteInputFiles = rawSuiteInputFiles && !skipDefaults ? interpolateCaseField(rawSuiteInputFiles, caseVars) : void 0;
-    const testInputMessages = resolveInputMessages(renderedCase, effectiveSuiteInputFiles);
+    let inputCase = renderedCase;
+    let inputSuiteFiles = effectiveSuiteInputFiles;
+    if (renderedCase.input === void 0) {
+      const promptFallback = await loadPromptMdFallback({
+        evalFilePath: absoluteTestPath,
+        searchRoots,
+        testInputFiles: renderedCase.input_files,
+        suiteInputFiles: effectiveSuiteInputFiles
+      });
+      if (promptFallback) {
+        if (promptFallback.inputFilesSource === "test") {
+          const { input_files: _inputFiles, ...caseWithoutInputFiles } = renderedCase;
+          inputCase = {
+            ...caseWithoutInputFiles,
+            input: promptFallback.promptText,
+            ...promptFallback.remainingInputFiles ? { input_files: [...promptFallback.remainingInputFiles] } : {}
+          };
+          inputSuiteFiles = void 0;
+        } else {
+          inputCase = {
+            ...renderedCase,
+            input: promptFallback.promptText
+          };
+          if (promptFallback.inputFilesSource === "suite") {
+            inputSuiteFiles = promptFallback.remainingInputFiles ? [...promptFallback.remainingInputFiles] : void 0;
+          }
+        }
+      }
+    }
+    const testInputMessages = resolveInputMessages(inputCase, inputSuiteFiles);
     const expectedMessages = resolveExpectedMessages(renderedCase) ?? [];
     const hasEvaluationSpec = !!outcome || expectedMessages.length > 0 || renderedCase.assertions !== void 0 || renderedCase.assert !== void 0 || Array.isArray(renderedCase.turns) && renderedCase.turns.length > 0;
     if (!id || !hasEvaluationSpec || !testInputMessages || testInputMessages.length === 0) {
       logError3(
-        `Skipping incomplete test: ${id ?? "unknown"}. Missing required fields: id, input, and at least one of criteria/expected_output/assertions/turns`
+        `Skipping incomplete test: ${id ?? "unknown"}. Missing required fields: id, input or PROMPT.md, and at least one of criteria/expected_output/assertions/turns`
       );
       continue;
     }
@@ -40084,7 +40295,6 @@ function buildEvalSuiteResult(parsed, tests, suiteWorkspacePath) {
   const threshold = extractThreshold(parsed);
   return {
     tests,
-    trials: extractTrialsConfig(parsed),
     targets: extractTargetsFromSuite(parsed),
     targetRefs: extractTargetRefsFromSuite(parsed),
     workers: extractWorkersFromSuite(parsed),
@@ -40206,7 +40416,7 @@ function collectInputSourceReferences(inputMessages) {
       references.push({
         kind: "input_file",
         displayPath,
-        ...typeof segment.resolvedPath === "string" ? { resolvedPath: path47.resolve(segment.resolvedPath) } : {}
+        ...typeof segment.resolvedPath === "string" ? { resolvedPath: path46.resolve(segment.resolvedPath) } : {}
       });
     }
   }
@@ -40279,7 +40489,7 @@ function collectSingleGraderSourceReferences(evaluator) {
       references.push({
         kind: "code_grader_command",
         displayPath: evaluator.aggregator.path,
-        resolvedPath: path47.resolve(evaluator.aggregator.cwd ?? "", evaluator.aggregator.path),
+        resolvedPath: path46.resolve(evaluator.aggregator.cwd ?? "", evaluator.aggregator.path),
         graderName: evaluator.name
       });
     } else if (evaluator.aggregator.type === "llm-grader" && evaluator.aggregator.promptPath) {
@@ -40312,9 +40522,9 @@ function dedupeSourceReferences(references) {
   return deduped;
 }
 function toPortableRelativePath(root, candidate) {
-  const relative = path47.relative(root, candidate);
-  if (relative && !relative.startsWith("..") && !path47.isAbsolute(relative)) {
-    return relative.split(path47.sep).join("/");
+  const relative = path46.relative(root, candidate);
+  if (relative && !relative.startsWith("..") && !path46.isAbsolute(relative)) {
+    return relative.split(path46.sep).join("/");
   }
   return void 0;
 }
@@ -40368,8 +40578,8 @@ function parseWorkspaceScriptConfig(raw, evalFileDir) {
   if (!command) return void 0;
   const timeoutMs = typeof obj.timeout_ms === "number" ? obj.timeout_ms : void 0;
   let cwd = typeof obj.cwd === "string" ? obj.cwd : void 0;
-  if (cwd && !path47.isAbsolute(cwd)) {
-    cwd = path47.resolve(evalFileDir, cwd);
+  if (cwd && !path46.isAbsolute(cwd)) {
+    cwd = path46.resolve(evalFileDir, cwd);
   }
   const config2 = { command };
   if (timeoutMs !== void 0) {
@@ -40407,7 +40617,7 @@ function parseWorkspaceHooksConfig(raw, evalFileDir) {
 }
 async function resolveWorkspaceConfig(raw, evalFileDir) {
   if (typeof raw === "string") {
-    const workspaceFilePath = path47.resolve(evalFileDir, raw);
+    const workspaceFilePath = path46.resolve(evalFileDir, raw);
     let content;
     try {
       content = await readFile18(workspaceFilePath, "utf8");
@@ -40420,7 +40630,7 @@ async function resolveWorkspaceConfig(raw, evalFileDir) {
         `Invalid workspace file format: ${workspaceFilePath} (expected a YAML object)`
       );
     }
-    const workspaceFileDir = path47.dirname(workspaceFilePath);
+    const workspaceFileDir = path46.dirname(workspaceFilePath);
     const resolvedWorkspace = parseWorkspaceConfig(parsed, workspaceFileDir);
     if (resolvedWorkspace) {
       return { ...resolvedWorkspace, workspaceFileDir };
@@ -40454,8 +40664,8 @@ function parseWorkspaceConfig(raw, evalFileDir) {
     throw new Error("workspace.static has been removed. Use workspace.mode='static'.");
   }
   let template = typeof obj.template === "string" ? obj.template : void 0;
-  if (template && !path47.isAbsolute(template)) {
-    template = path47.resolve(evalFileDir, template);
+  if (template && !path46.isAbsolute(template)) {
+    template = path46.resolve(evalFileDir, template);
   }
   const isolation = obj.isolation === "shared" || obj.isolation === "per_test" ? obj.isolation : void 0;
   const repos = Array.isArray(obj.repos) ? obj.repos.map(parseRepoConfig).filter(Boolean) : void 0;
@@ -40593,7 +40803,7 @@ ${detailBlock}${ANSI_RESET6}`);
   }
 }
 function pathFromRoot(root) {
-  return root instanceof URL ? fileURLToPath5(root) : String(root);
+  return root instanceof URL ? fileURLToPath4(root) : String(root);
 }
 function classifyQualityStatus(score, threshold = DEFAULT_THRESHOLD) {
   return score >= threshold ? "ok" : "quality_failure";
@@ -40733,18 +40943,18 @@ function validateDependencyGraph(tests) {
   }
   const visited = /* @__PURE__ */ new Set();
   const visiting = /* @__PURE__ */ new Set();
-  function visit(id, path522) {
+  function visit(id, path51) {
     if (visiting.has(id)) {
-      const cycle = [...path522.slice(path522.indexOf(id)), id];
+      const cycle = [...path51.slice(path51.indexOf(id)), id];
       throw new Error(`Circular dependency detected: ${cycle.join(" \u2192 ")}`);
     }
     if (visited.has(id)) return;
     visiting.add(id);
-    path522.push(id);
+    path51.push(id);
     for (const dep of depMap.get(id) ?? []) {
-      visit(dep, path522);
+      visit(dep, path51);
     }
-    path522.pop();
+    path51.pop();
     visiting.delete(id);
     visited.add(id);
   }
@@ -40850,7 +41060,7 @@ async function gradePreparedEvalCase(options) {
     model
   });
   const evaluatorRegistry = buildEvaluatorRegistry(evaluators, runtime.resolveGraderProvider);
-  const discoveryBaseDir = evalFilePath ? path48.dirname(path48.resolve(evalFilePath)) : process.cwd();
+  const discoveryBaseDir = evalFilePath ? path47.dirname(path47.resolve(evalFilePath)) : process.cwd();
   await discoverAssertions(typeRegistry, discoveryBaseDir);
   await discoverGraders(typeRegistry, discoveryBaseDir);
   let fileChanges;
@@ -41042,7 +41252,7 @@ async function runEvaluation(options) {
   }
   const evaluatorRegistry = buildEvaluatorRegistry(evaluators, resolveGraderProvider);
   const typeRegistry = createBuiltinRegistry();
-  const discoveryBaseDir = evalFilePath ? path48.dirname(path48.resolve(evalFilePath)) : process.cwd();
+  const discoveryBaseDir = evalFilePath ? path47.dirname(path47.resolve(evalFilePath)) : process.cwd();
   const evalDir = discoveryBaseDir;
   await discoverAssertions(typeRegistry, discoveryBaseDir);
   await discoverGraders(typeRegistry, discoveryBaseDir);
@@ -42248,7 +42458,8 @@ async function runEvalCaseWithTrials(options, trialsConfig) {
       costUsd: trialCost,
       executionStatus: result.executionStatus,
       failureStage: result.failureStage,
-      failureReasonCode: result.failureReasonCode
+      failureReasonCode: result.failureReasonCode,
+      result
     };
     trialResults.push(trial);
     if (trialCost !== void 0) {
@@ -42263,7 +42474,7 @@ async function runEvalCaseWithTrials(options, trialsConfig) {
       costLimited = true;
       break;
     }
-    if (trialsConfig.strategy === "pass_at_k" && trialVerdict === "pass") {
+    if (trialsConfig.strategy === "pass_at_k" && trialsConfig.earlyExit !== false && trialVerdict === "pass") {
       break;
     }
   }
@@ -42574,7 +42785,7 @@ async function runEvaluatorList(options) {
     dockerConfig,
     dependencyResults
   };
-  const evalFileDir = evalCase.file_paths[0] ? path48.dirname(evalCase.file_paths[0]) : process.cwd();
+  const evalFileDir = evalCase.file_paths[0] ? path47.dirname(evalCase.file_paths[0]) : process.cwd();
   const dispatchContext = {
     graderProvider,
     targetResolver,
@@ -43649,6 +43860,12 @@ function fromResultArtifactPointerWire(pointer) {
   };
 }
 var TOOL_STATUS_VALUES = ["ok", "error", "timeout", "cancelled", "unknown"];
+var TIMING_SOURCE_VALUES = [
+  "provider_reported",
+  "token_estimated",
+  "aggregate",
+  "unavailable"
+];
 var FILE_READ_KEY_SET = /* @__PURE__ */ new Set([
   "file",
   "filename",
@@ -43719,6 +43936,23 @@ var ReasoningBlockWireSchema = external_exports.object({
   event_id: external_exports.string().optional(),
   content: external_exports.string().optional()
 }).strict();
+var MetricsTimingWireSchema = external_exports.object({
+  total_tokens: external_exports.number().int().nonnegative(),
+  duration_ms: external_exports.number().nonnegative(),
+  total_duration_seconds: external_exports.number().nonnegative(),
+  cost_usd: external_exports.number().nonnegative().nullable(),
+  token_usage: external_exports.object({
+    input: external_exports.number().int().nonnegative(),
+    output: external_exports.number().int().nonnegative(),
+    reasoning: external_exports.number().int().nonnegative()
+  }).strict(),
+  usage_sources: external_exports.object({
+    token_usage: external_exports.enum(TIMING_SOURCE_VALUES),
+    total_tokens: external_exports.enum(TIMING_SOURCE_VALUES),
+    duration: external_exports.enum(TIMING_SOURCE_VALUES),
+    cost: external_exports.enum(TIMING_SOURCE_VALUES)
+  }).strict()
+}).strict();
 var MetricsWireSchema = external_exports.object({
   tool_calls: external_exports.record(external_exports.string(), external_exports.number().int().nonnegative()),
   tool_call_counts: external_exports.record(external_exports.string(), external_exports.number().int().nonnegative()),
@@ -43760,7 +43994,8 @@ var MetricsArtifactWireSchema = external_exports.object({
     grading_path: external_exports.string().optional(),
     timing_path: external_exports.string().optional()
   }).strict(),
-  metrics: MetricsWireSchema
+  metrics: MetricsWireSchema,
+  timing: MetricsTimingWireSchema.optional()
 }).strict();
 function dropUndefined6(value) {
   return Object.fromEntries(
@@ -44346,6 +44581,7 @@ var RESULT_ROW_ALIASES = {
   rawProviderLogPath: "raw_provider_log_path",
   responsePath: "response_path",
   startTime: "start_time",
+  summaryPath: "summary_path",
   targetsPath: "targets_path",
   taskDir: "task_dir",
   testId: "test_id",
@@ -44451,7 +44687,7 @@ function buildSnakeCaseOnlyFieldError(field, context) {
   );
 }
 function looksLikeResultRow(value) {
-  return typeof value.test_id === "string" || Object.hasOwn(value, "score") || Object.hasOwn(value, "trace") || Object.hasOwn(value, "spans") || Object.hasOwn(value, "target") || Object.hasOwn(value, "grading_path") || Object.hasOwn(value, "timing_path");
+  return typeof value.test_id === "string" || Object.hasOwn(value, "score") || Object.hasOwn(value, "trace") || Object.hasOwn(value, "spans") || Object.hasOwn(value, "target") || Object.hasOwn(value, "summary_path") || Object.hasOwn(value, "grading_path") || Object.hasOwn(value, "timing_path");
 }
 function normalizeResultRow(value, context = {}) {
   if (!isRecord6(value)) {
@@ -44480,7 +44716,8 @@ function normalizeResultRow(value, context = {}) {
   return normalized;
 }
 var RESULT_INDEX_FILENAME = "index.jsonl";
-var TIMING_SOURCE_VALUES = [
+var RUN_SUMMARY_FILENAME = "summary.json";
+var TIMING_SOURCE_VALUES2 = [
   "provider_reported",
   "token_estimated",
   "aggregate",
@@ -44504,30 +44741,27 @@ function deduplicateByTestIdTarget(results) {
   return deduped;
 }
 async function aggregateRunDir(runDir, options) {
-  const indexPath = path49.join(runDir, RESULT_INDEX_FILENAME);
+  const indexPath = path48.join(runDir, RESULT_INDEX_FILENAME);
   const content = await readFile20(indexPath, "utf8");
   const allResults = parseJsonlResults(content);
   const results = deduplicateByTestIdTarget(allResults);
-  const timing = buildTimingArtifact(results);
-  const timingPath = path49.join(runDir, "timing.json");
-  await writeFile10(timingPath, `${JSON.stringify(timing, null, 2)}
-`, "utf8");
-  const plannedTestCount = options?.plannedTestCount ?? await readPlannedTestCount(path49.join(runDir, "benchmark.json"));
-  const benchmark = buildBenchmarkArtifact(
+  const plannedTestCount = options?.plannedTestCount ?? await readPlannedTestCount(path48.join(runDir, RUN_SUMMARY_FILENAME));
+  const summary = buildRunSummaryArtifact(
     results,
     options?.evalFile,
     options?.experiment,
-    plannedTestCount
+    plannedTestCount,
+    options?.experimentMetadata
   );
-  const benchmarkPath = path49.join(runDir, "benchmark.json");
-  await writeFile10(benchmarkPath, `${JSON.stringify(benchmark, null, 2)}
+  const summaryPath = path48.join(runDir, RUN_SUMMARY_FILENAME);
+  await writeFile10(summaryPath, `${JSON.stringify(summary, null, 2)}
 `, "utf8");
   const targetSet = new Set(results.map((r) => r.target ?? "unknown"));
-  return { benchmarkPath, timingPath, testCount: results.length, targetCount: targetSet.size };
+  return { summaryPath, testCount: results.length, targetCount: targetSet.size };
 }
-async function readPlannedTestCount(benchmarkPath) {
+async function readPlannedTestCount(summaryPath) {
   try {
-    const raw = await readFile20(benchmarkPath, "utf8");
+    const raw = await readFile20(summaryPath, "utf8");
     const parsed = JSON.parse(raw);
     const value = parsed.metadata?.planned_test_count;
     return typeof value === "number" && Number.isFinite(value) ? value : void 0;
@@ -44637,6 +44871,60 @@ function toIndexScore(score) {
 function toIndexScores(scores) {
   return scores?.map(toIndexScore);
 }
+function trialRunDirName(attempt) {
+  return `run-${attempt + 1}`;
+}
+function hasPersistedTrialRuns(result) {
+  return (result.trials ?? []).some((trial) => trial.result !== void 0);
+}
+function toTrialArtifacts(trials) {
+  if (!trials || trials.length === 0) {
+    return void 0;
+  }
+  return trials.map((trial) => ({
+    attempt: trial.attempt,
+    run_path: trial.result ? trialRunDirName(trial.attempt) : void 0,
+    score: trial.score,
+    verdict: trial.verdict,
+    scores: toIndexScores(trial.scores),
+    error: trial.error,
+    cost_usd: trial.costUsd,
+    execution_status: trial.executionStatus,
+    failure_stage: trial.failureStage,
+    failure_reason_code: trial.failureReasonCode
+  }));
+}
+function toIndexTrialArtifacts(result) {
+  return toTrialArtifacts(result.trials) ?? toTrialArtifacts([singleRunTrial(result)]) ?? [];
+}
+function toTrialAggregationArtifact(aggregation) {
+  if (!aggregation) {
+    return void 0;
+  }
+  switch (aggregation.strategy) {
+    case "pass_at_k":
+      return {
+        strategy: aggregation.strategy,
+        passed_attempts: aggregation.passedAttempts,
+        total_attempts: aggregation.totalAttempts
+      };
+    case "mean":
+      return {
+        strategy: aggregation.strategy,
+        mean: aggregation.mean,
+        min: aggregation.min,
+        max: aggregation.max
+      };
+    case "confidence_interval":
+      return {
+        strategy: aggregation.strategy,
+        mean: aggregation.mean,
+        ci95_lower: aggregation.ci95Lower,
+        ci95_upper: aggregation.ci95Upper,
+        stddev: aggregation.stddev
+      };
+  }
+}
 function dropUndefined7(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
@@ -44658,6 +44946,216 @@ function toIndexRerunSource(value) {
     source_timestamp: value.sourceTimestamp
   });
 }
+function resultDurationSeconds(result) {
+  const durationMs = result.durationMs ?? result.trace?.durationMs ?? result.evalRun?.durationMs ?? 0;
+  return Math.round(durationMs / 1e3 * 1e3) / 1e3;
+}
+function resultDurationMs(result) {
+  const durationMs = result.durationMs ?? result.trace?.durationMs ?? result.evalRun?.durationMs;
+  return typeof durationMs === "number" && Number.isFinite(durationMs) ? durationMs : void 0;
+}
+function roundMillis(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function roundSecondsFromMs(value) {
+  return Math.round(value / 1e3 * 1e3) / 1e3;
+}
+function repeatAttemptResults(result) {
+  const trialResults = (result.trials ?? []).map((trial) => trial.result).filter((trialResult) => trialResult !== void 0);
+  return trialResults.length > 0 ? trialResults : [result];
+}
+function buildRepeatAggregateTimingArtifact(result) {
+  const attemptResults = repeatAttemptResults(result);
+  const timing = buildTimingArtifact(attemptResults);
+  const durationsMs = attemptResults.map(resultDurationMs).filter((durationMs) => durationMs !== void 0);
+  if (durationsMs.length === 0) {
+    return timing;
+  }
+  const stats = computeStats(durationsMs);
+  const minMs = Math.min(...durationsMs);
+  const maxMs = Math.max(...durationsMs);
+  return {
+    ...timing,
+    mean_duration_ms: stats.mean,
+    mean_duration_seconds: roundSecondsFromMs(stats.mean),
+    duration_stats: {
+      count: durationsMs.length,
+      mean_ms: stats.mean,
+      mean_seconds: roundSecondsFromMs(stats.mean),
+      stddev_ms: stats.stddev,
+      stddev_seconds: roundSecondsFromMs(stats.stddev),
+      min_ms: roundMillis(minMs),
+      max_ms: roundMillis(maxMs)
+    }
+  };
+}
+function formatRepeatPassRate(passedRuns, totalRuns) {
+  if (totalRuns === 0) {
+    return "0%";
+  }
+  const percent = Math.round(passedRuns / totalRuns * 1e3) / 10;
+  return `${Number.isInteger(percent) ? percent.toFixed(0) : percent.toFixed(1)}%`;
+}
+function fallbackRepeatFingerprint(result) {
+  return createHash7("sha256").update(
+    JSON.stringify({
+      test_id: result.testId ?? "unknown",
+      target: result.target ?? "unknown",
+      trial_count: result.trials?.length ?? 0,
+      aggregation: result.aggregation
+    })
+  ).digest("hex");
+}
+function buildRepeatCaseSummaryArtifact(result, timing, fingerprint) {
+  const trials = result.trials ?? [];
+  const totalRuns = trials.length > 0 ? trials.length : 1;
+  const passedRuns = trials.length > 0 ? trials.filter((trial) => trial.verdict === "pass").length : result.executionStatus !== "execution_error" && result.score >= DEFAULT_THRESHOLD ? 1 : 0;
+  const fallbackMeanMs = totalRuns > 0 ? roundMillis(timing.duration_ms / totalRuns) : 0;
+  const meanDurationMs = timing.mean_duration_ms ?? fallbackMeanMs;
+  return {
+    total_runs: totalRuns,
+    passed_runs: passedRuns,
+    pass_rate: formatRepeatPassRate(passedRuns, totalRuns),
+    mean_duration_ms: meanDurationMs,
+    mean_duration_seconds: timing.mean_duration_seconds ?? roundSecondsFromMs(meanDurationMs),
+    fingerprint: fingerprint ?? fallbackRepeatFingerprint(result),
+    total_tokens: timing.total_tokens,
+    duration_ms: timing.duration_ms,
+    total_duration_seconds: timing.total_duration_seconds,
+    duration_stats: timing.duration_stats,
+    cost_usd: timing.cost_usd,
+    token_usage: timing.token_usage,
+    usage_sources: timing.usage_sources
+  };
+}
+function toVercelRunStatus(trial, result) {
+  if (trial.executionStatus === "execution_error" || result.executionStatus === "execution_error") {
+    return "error";
+  }
+  return trial.verdict === "pass" ? "passed" : "failed";
+}
+function toFilePathList(entries) {
+  return entries.map((entry) => isRecord7(entry) && typeof entry.path === "string" ? entry.path : void 0).filter((entry) => entry !== void 0);
+}
+function buildVercelRunResultArtifact(params) {
+  const metrics = params.metricsArtifact.metrics;
+  return dropUndefined7({
+    status: toVercelRunStatus(params.trial, params.result),
+    duration_ms: resultDurationMs(params.result),
+    duration_seconds: resultDurationSeconds(params.result),
+    model: params.result.target ?? "unknown",
+    grading_path: "./grading.json",
+    transcript_path: params.hasTranscript ? "./transcript.json" : void 0,
+    transcript_raw_path: params.hasTranscript ? "./transcript-raw.jsonl" : void 0,
+    o11y: {
+      total_turns: metrics.total_turns,
+      tool_calls: metrics.tool_calls,
+      total_tool_calls: metrics.total_tool_calls,
+      web_fetches: metrics.web_fetches,
+      files_read: toFilePathList(metrics.files_read),
+      files_modified: toFilePathList(metrics.files_modified),
+      shell_commands: metrics.shell_commands,
+      errors: metrics.errors,
+      thinking_blocks: metrics.thinking_blocks
+    },
+    output_paths: params.hasOutput ? { answer: "./outputs/answer.md" } : void 0,
+    timing: params.metricsArtifact.timing
+  });
+}
+function singleRunTrial(result) {
+  return {
+    attempt: 0,
+    score: result.score,
+    verdict: result.executionStatus !== "execution_error" && result.score >= DEFAULT_THRESHOLD ? "pass" : "fail",
+    scores: result.scores,
+    error: result.error,
+    costUsd: result.costUsd,
+    executionStatus: result.executionStatus,
+    failureStage: result.failureStage,
+    failureReasonCode: result.failureReasonCode,
+    result
+  };
+}
+function materializedRunTrials(result) {
+  const persisted = (result.trials ?? []).filter((trial) => trial.result !== void 0);
+  return persisted.length > 0 ? persisted : [singleRunTrial(result)];
+}
+async function writeTrialRunArtifacts(params) {
+  const result = params.trial.result;
+  if (!result) {
+    return;
+  }
+  const runDirName = trialRunDirName(params.trial.attempt);
+  const runDir = path48.join(params.parentTestDir, runDirName);
+  const grading = buildGradingArtifact(result, { includeTrials: false });
+  const timing = buildTimingArtifact([result]);
+  const gradingPath = path48.join(runDir, "grading.json");
+  const timingPath = path48.join(runDir, "timing.json");
+  const metricsPath = path48.join(runDir, CANONICAL_METRICS_ARTIFACT_PATH);
+  const outputsDir = path48.join(runDir, "outputs");
+  const answerOutputPath = result.output.length > 0 ? path48.join(outputsDir, "answer.md") : void 0;
+  const attemptRunId = params.runId ? `${params.runId}:${runDirName}` : `${result.testId}:${result.target}:${runDirName}`;
+  const envelope = buildTraceEnvelopeSidecar({
+    result,
+    outputDir: params.outputDir,
+    testDir: runDir,
+    evalPath: resolveEnvelopeEvalPath(result, params.testByTestId, params.evalFile),
+    experiment: params.experiment,
+    runId: attemptRunId,
+    duplicatePolicy: params.duplicatePolicy
+  });
+  const hasTranscript = hasTranscriptProjection(result, envelope);
+  const transcriptPath = hasTranscript ? path48.join(runDir, "transcript.json") : void 0;
+  const transcriptRawPath = hasTranscript ? path48.join(runDir, "transcript-raw.jsonl") : void 0;
+  await mkdir18(runDir, { recursive: true });
+  await writeFile10(gradingPath, `${JSON.stringify(grading, null, 2)}
+`, "utf8");
+  await writeFile10(timingPath, `${JSON.stringify(timing, null, 2)}
+`, "utf8");
+  await mkdir18(outputsDir, { recursive: true });
+  if (answerOutputPath) {
+    await writeFile10(answerOutputPath, result.output, "utf8");
+  }
+  const rawProviderLogSource = rawProviderLogSourcePath(result);
+  if (rawProviderLogSource) {
+    await copyRawProviderLogArtifact(rawProviderLogSource, runDir);
+  }
+  if (transcriptPath && transcriptRawPath) {
+    await writeFile10(
+      transcriptPath,
+      `${JSON.stringify(traceEnvelopeToTranscriptMessages(envelope), null, 2)}
+`,
+      "utf8"
+    );
+    await writeTranscriptJsonl(transcriptRawPath, result, envelope);
+  }
+  const metricsArtifact = await writeMetricsArtifact({
+    filePath: metricsPath,
+    result,
+    envelope,
+    traceArtifactPath: "transcript.json",
+    transcriptArtifactPath: transcriptRawPath ? "transcript-raw.jsonl" : void 0,
+    gradingArtifactPath: "grading.json",
+    timingArtifactPath: "timing.json",
+    timing
+  });
+  await writeFile10(
+    path48.join(runDir, "result.json"),
+    `${JSON.stringify(
+      buildVercelRunResultArtifact({
+        trial: params.trial,
+        result,
+        metricsArtifact,
+        hasTranscript,
+        hasOutput: result.output.length > 0
+      }),
+      null,
+      2
+    )}
+`,
+    "utf8"
+  );
+}
 function toIndexPreparedAttempt(value) {
   if (!isRecord7(value)) {
     return void 0;
@@ -44711,13 +45209,12 @@ function buildExportMetadata(duplicatePolicy, projectionIdentity, options) {
     skipped: options?.skipped
   };
 }
-function buildGradingArtifact(result) {
+function buildGradingArtifact(result, options) {
   const assertions = buildAssertions(result);
   const passed = assertions.filter((e) => e.passed).length;
   const failed = assertions.filter((e) => !e.passed).length;
   const total = assertions.length;
-  const { toolCalls, total: totalToolCalls } = countToolCalls(result);
-  const errorsEncountered = result.error ? 1 : 0;
+  const includeTrials = options?.includeTrials ?? true;
   return {
     assertions,
     summary: {
@@ -44726,17 +45223,14 @@ function buildGradingArtifact(result) {
       total,
       pass_rate: total > 0 ? Math.round(passed / total * 1e3) / 1e3 : 0
     },
-    execution_metrics: {
-      tool_calls: toolCalls,
-      total_tool_calls: totalToolCalls,
-      errors_encountered: errorsEncountered
-    },
     graders: buildEvaluators(result.scores),
     workspace_changes: parseWorkspaceChanges(result.fileChanges),
     conversation: result.conversationId ? {
       turns: result.trace?.messages.filter((message) => message.role === "assistant").length ?? 0,
       conversation_id: result.conversationId
-    } : void 0
+    } : void 0,
+    trials: includeTrials ? toIndexTrialArtifacts(result) : void 0,
+    aggregation: includeTrials ? toTrialAggregationArtifact(result.aggregation) : void 0
   };
 }
 function timingMetadataSource(metadata, sourceKey) {
@@ -44744,7 +45238,7 @@ function timingMetadataSource(metadata, sourceKey) {
   const usageSummary = metadata?.usage_summary;
   const legacyKey = sourceKey === "duration" ? "duration_source" : sourceKey === "cost" ? "cost_source" : "token_usage_source";
   const value = isRecord7(usageSources) ? usageSources[sourceKey] : isRecord7(usageSummary) ? usageSummary[legacyKey] : metadata?.[legacyKey];
-  return typeof value === "string" && TIMING_SOURCE_VALUES.includes(value) ? value : void 0;
+  return typeof value === "string" && TIMING_SOURCE_VALUES2.includes(value) ? value : void 0;
 }
 function sumMessageTokenUsage(messages) {
   let sawUsage = false;
@@ -44835,7 +45329,7 @@ function buildTimingArtifact(results) {
     }
   };
 }
-function buildBenchmarkArtifact(results, evalFile = "", experiment, plannedTestCount) {
+function buildRunSummaryArtifact(results, evalFile = "", experiment, plannedTestCount, experimentMetadata) {
   const targetSet = /* @__PURE__ */ new Set();
   const testIdSet = /* @__PURE__ */ new Set();
   for (const result of results) {
@@ -44908,23 +45402,26 @@ function buildBenchmarkArtifact(results, evalFile = "", experiment, plannedTestC
       targets,
       tests_run: testIds,
       experiment,
+      experiment_config: experimentMetadata,
       planned_test_count: plannedTestCount
     },
     run_summary: runSummary,
     per_grader_summary: perEvaluatorSummary,
+    timing: buildTimingArtifact(results),
     notes
   };
 }
-async function writeInitialBenchmarkArtifact(runDir, options) {
+async function writeInitialRunSummaryArtifact(runDir, options) {
   await mkdir18(runDir, { recursive: true });
-  const stub = buildBenchmarkArtifact(
+  const stub = buildRunSummaryArtifact(
     [],
     options.evalFile,
     options.experiment,
-    options.plannedTestCount
+    options.plannedTestCount,
+    options.experimentMetadata
   );
-  const benchmarkPath = path49.join(runDir, "benchmark.json");
-  await writeFile10(benchmarkPath, `${JSON.stringify(stub, null, 2)}
+  const summaryPath = path48.join(runDir, RUN_SUMMARY_FILENAME);
+  await writeFile10(summaryPath, `${JSON.stringify(stub, null, 2)}
 `, "utf8");
 }
 function buildAggregateGradingArtifact(results) {
@@ -44973,23 +45470,10 @@ function buildArtifactSubdir(result) {
     segments.push(safeArtifactPathSegment(evalSet, "default"));
   }
   segments.push(safeTestId(result.testId));
-  return path49.posix.join(...segments);
-}
-function formatOutputMarkdown(output) {
-  return output.map((msg) => `@[${msg.role}]:
-${String(msg.content ?? "")}`).join("\n\n");
-}
-function extractInput(result) {
-  const input = result.input;
-  if (!input) return null;
-  if (typeof input === "string") return input;
-  if (Array.isArray(input) && input.length > 0) {
-    return formatOutputMarkdown(input);
-  }
-  return null;
+  return path48.posix.join(...segments);
 }
 function toRelativeArtifactPath(outputDir, filePath) {
-  return path49.relative(outputDir, filePath).split(path49.sep).join("/");
+  return path48.relative(outputDir, filePath).split(path48.sep).join("/");
 }
 function findResultSourceTest(result, testByTestId) {
   return testByTestId.get(result.testId ?? "unknown");
@@ -45005,15 +45489,12 @@ function rawProviderLogSourcePath(result) {
   const sourcePath = result.rawProviderLogPath?.trim();
   return sourcePath ? sourcePath : void 0;
 }
-function rawProviderLogArtifactPath(testDir) {
-  return path49.join(testDir, "provider.log");
-}
 async function copyRawProviderLogArtifact(sourcePath, testDir) {
-  const destinationPath = rawProviderLogArtifactPath(testDir);
-  if (path49.resolve(sourcePath) === path49.resolve(destinationPath)) {
+  const destinationPath = path48.join(testDir, "provider.log");
+  if (path48.resolve(sourcePath) === path48.resolve(destinationPath)) {
     return destinationPath;
   }
-  await mkdir18(path49.dirname(destinationPath), { recursive: true });
+  await mkdir18(path48.dirname(destinationPath), { recursive: true });
   await copyFile3(sourcePath, destinationPath);
   return destinationPath;
 }
@@ -45021,14 +45502,13 @@ function buildTraceEnvelopeSidecar(params) {
   const hasTranscript = resultHasExecutionTraceTranscript(params.result);
   return buildTraceEnvelopeFromEvaluationResult(params.result, {
     evalPath: params.evalPath,
-    runId: params.runId ?? path49.basename(params.outputDir),
+    runId: params.runId ?? path48.basename(params.outputDir),
     experiment: params.experiment,
     source: { path: RESULT_INDEX_FILENAME },
     capture: { content: "full", redactionLevel: "none", redactedFields: [] },
     artifacts: {
       trace_path: CANONICAL_TRACE_ARTIFACT_PATH,
       answer_path: params.result.output.length > 0 ? "outputs/answer.md" : void 0,
-      response_path: params.result.output.length > 0 ? "outputs/response.md" : void 0,
       transcript_path: hasTranscript ? CANONICAL_TRANSCRIPT_ARTIFACT_PATH : void 0,
       metrics_path: CANONICAL_METRICS_ARTIFACT_PATH,
       raw_provider_log_path: rawProviderLogSourcePath(params.result) ? "provider.log" : void 0
@@ -45036,59 +45516,6 @@ function buildTraceEnvelopeSidecar(params) {
     duplicatePolicy: params.duplicatePolicy
   });
 }
-async function writeTraceEnvelopeSidecar(params) {
-  const envelope = buildTraceEnvelopeSidecar(params);
-  await writeFile10(
-    path49.join(params.testDir, CANONICAL_TRACE_ARTIFACT_PATH),
-    `${JSON.stringify(toTraceEnvelopeWire(envelope), null, 2)}
-`,
-    "utf8"
-  );
-  return envelope;
-}
-function buildSidecarArtifactKey(family, runRelativePath) {
-  return path49.posix.join(family, runRelativePath);
-}
-async function buildArtifactPointer(params) {
-  const content = await readFile20(params.filePath);
-  const sha256 = createHash7("sha256").update(content).digest("hex");
-  return toResultArtifactPointerWire({
-    ref: AGENTV_RESULTS_ARTIFACTS_REF,
-    key: buildSidecarArtifactKey(params.family, params.runRelativePath),
-    objectVersion: `sha256:${sha256}`,
-    path: params.runRelativePath,
-    sha256,
-    size: content.byteLength,
-    schemaVersion: params.schemaVersion,
-    mediaType: params.mediaType,
-    family: params.family
-  });
-}
-async function buildTracePointer(outputDir, tracePath) {
-  return buildArtifactPointer({
-    filePath: tracePath,
-    runRelativePath: toRelativeArtifactPath(outputDir, tracePath),
-    family: "traces",
-    schemaVersion: EXECUTION_TRACE_SCHEMA_VERSION,
-    mediaType: TRACE_JSON_MEDIA_TYPE
-  });
-}
-async function buildTranscriptPointer(outputDir, transcriptPath) {
-  const pointer = await buildArtifactPointer({
-    filePath: transcriptPath,
-    runRelativePath: toRelativeArtifactPath(outputDir, transcriptPath),
-    family: "transcripts",
-    schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
-    mediaType: TRANSCRIPT_JSONL_MEDIA_TYPE
-  });
-  return pointer;
-}
-async function buildArtifactPointers(params) {
-  return {
-    trace: await buildTracePointer(params.outputDir, params.tracePath),
-    ...params.transcriptPath ? { transcript: await buildTranscriptPointer(params.outputDir, params.transcriptPath) } : {}
-  };
-}
 function buildIndexArtifactEntry(result, options) {
   return {
     timestamp: result.timestamp,
@@ -45104,14 +45531,17 @@ function buildIndexArtifactEntry(result, options) {
     start_time: result.startTime,
     end_time: result.endTime,
     scores: toIndexScores(result.scores),
+    trials: toIndexTrialArtifacts(result),
+    aggregation: toTrialAggregationArtifact(result.aggregation),
     execution_status: result.executionStatus,
     error: result.error,
     failure_stage: result.failureStage,
     failure_reason_code: result.failureReasonCode,
     workspace_path: result.workspacePath,
     artifact_dir: options.artifactDir ? toRelativeArtifactPath(options.outputDir, options.artifactDir) : void 0,
-    grading_path: toRelativeArtifactPath(options.outputDir, options.gradingPath),
-    timing_path: toRelativeArtifactPath(options.outputDir, options.timingPath),
+    grading_path: options.gradingPath ? toRelativeArtifactPath(options.outputDir, options.gradingPath) : void 0,
+    timing_path: options.timingPath ? toRelativeArtifactPath(options.outputDir, options.timingPath) : void 0,
+    summary_path: options.summaryPath ? toRelativeArtifactPath(options.outputDir, options.summaryPath) : void 0,
     output_path: options.outputPath ? toRelativeArtifactPath(options.outputDir, options.outputPath) : void 0,
     answer_path: options.answerPath ? toRelativeArtifactPath(options.outputDir, options.answerPath) : void 0,
     trace_path: options.tracePath ? toRelativeArtifactPath(options.outputDir, options.tracePath) : void 0,
@@ -45119,8 +45549,6 @@ function buildIndexArtifactEntry(result, options) {
     metrics_path: options.metricsPath ? toRelativeArtifactPath(options.outputDir, options.metricsPath) : void 0,
     raw_provider_log_path: options.rawProviderLogPath ? toRelativeArtifactPath(options.outputDir, options.rawProviderLogPath) : void 0,
     artifact_pointers: options.artifactPointers,
-    input_path: options.inputPath ? toRelativeArtifactPath(options.outputDir, options.inputPath) : void 0,
-    response_path: options.responsePath ? toRelativeArtifactPath(options.outputDir, options.responsePath) : void 0,
     ...options.extraIndexFields,
     external_trace: toIndexExternalTrace(result, options.projectionIdentity?.dimensions.runId),
     projection_identity: options.projectionIdentity ? toProjectionIdentityWire(options.projectionIdentity) : void 0,
@@ -45130,10 +45558,10 @@ function buildIndexArtifactEntry(result, options) {
 }
 function buildResultIndexArtifact(result, extraIndexFields, options) {
   const artifactSubdir = buildArtifactSubdir(result);
-  const input = extractInput(result);
   const hasAnswer = result.output.length > 0;
   const hasTranscript = resultHasExecutionTraceTranscript(result);
-  const hasRawProviderLog = rawProviderLogSourcePath(result) !== void 0;
+  const isSingleRun = !hasPersistedTrialRuns(result);
+  const singleRunDir = path48.posix.join(artifactSubdir, trialRunDirName(0));
   return {
     timestamp: result.timestamp,
     test_id: result.testId ?? "unknown",
@@ -45148,23 +45576,22 @@ function buildResultIndexArtifact(result, extraIndexFields, options) {
     start_time: result.startTime,
     end_time: result.endTime,
     scores: toIndexScores(result.scores),
+    trials: toIndexTrialArtifacts(result),
+    aggregation: toTrialAggregationArtifact(result.aggregation),
     execution_status: result.executionStatus,
     error: result.error,
     failure_stage: result.failureStage,
     failure_reason_code: result.failureReasonCode,
     workspace_path: result.workspacePath,
     artifact_dir: artifactSubdir,
-    grading_path: path49.posix.join(artifactSubdir, "grading.json"),
-    timing_path: path49.posix.join(artifactSubdir, "timing.json"),
-    input_path: input ? path49.posix.join(artifactSubdir, "input.md") : void 0,
-    output_path: hasAnswer ? path49.posix.join(artifactSubdir, "outputs", "answer.md") : void 0,
-    answer_path: hasAnswer ? path49.posix.join(artifactSubdir, "outputs", "answer.md") : void 0,
-    trace_path: path49.posix.join(artifactSubdir, CANONICAL_TRACE_ARTIFACT_PATH),
-    transcript_path: hasTranscript ? path49.posix.join(artifactSubdir, CANONICAL_TRANSCRIPT_ARTIFACT_PATH) : void 0,
-    metrics_path: path49.posix.join(artifactSubdir, CANONICAL_METRICS_ARTIFACT_PATH),
-    raw_provider_log_path: hasRawProviderLog ? path49.posix.join(artifactSubdir, "provider.log") : void 0,
+    summary_path: path48.posix.join(artifactSubdir, RUN_SUMMARY_FILENAME),
+    grading_path: isSingleRun ? path48.posix.join(singleRunDir, "grading.json") : void 0,
+    timing_path: isSingleRun ? path48.posix.join(singleRunDir, "timing.json") : void 0,
+    metrics_path: isSingleRun ? path48.posix.join(singleRunDir, CANONICAL_METRICS_ARTIFACT_PATH) : void 0,
+    output_path: isSingleRun && hasAnswer ? path48.posix.join(singleRunDir, "outputs", "answer.md") : void 0,
+    answer_path: isSingleRun && hasAnswer ? path48.posix.join(singleRunDir, "outputs", "answer.md") : void 0,
+    transcript_path: isSingleRun && hasTranscript ? path48.posix.join(singleRunDir, "transcript-raw.jsonl") : void 0,
     artifact_pointers: options?.artifactPointers,
-    response_path: hasAnswer ? path49.posix.join(artifactSubdir, "outputs", "response.md") : void 0,
     ...extraIndexFields,
     external_trace: toIndexExternalTrace(result, options?.projectionIdentity?.dimensions.runId),
     projection_identity: options?.projectionIdentity ? toProjectionIdentityWire(options.projectionIdentity) : void 0,
@@ -45189,15 +45616,20 @@ async function writeTranscriptJsonl(filePath, result, envelope) {
 ` : "";
   await writeFile10(filePath, content, "utf8");
 }
-async function writeMetricsArtifact(params) {
+function buildMetricsArtifactPayload(params) {
   const artifact = buildMetricsArtifact(params.result, params.envelope, {
-    tracePath: CANONICAL_TRACE_ARTIFACT_PATH,
-    transcriptPath: params.transcriptPath ? CANONICAL_TRANSCRIPT_ARTIFACT_PATH : void 0,
-    gradingPath: "grading.json",
-    timingPath: "timing.json"
+    tracePath: params.traceArtifactPath ?? CANONICAL_TRACE_ARTIFACT_PATH,
+    transcriptPath: params.transcriptArtifactPath ?? (params.transcriptPath ? CANONICAL_TRANSCRIPT_ARTIFACT_PATH : void 0),
+    gradingPath: params.gradingArtifactPath ?? "grading.json",
+    timingPath: params.timingArtifactPath === null ? void 0 : params.timingArtifactPath ?? "timing.json"
   });
-  await writeFile10(params.filePath, `${JSON.stringify(artifact, null, 2)}
+  return params.timing ? { ...artifact, timing: params.timing } : artifact;
+}
+async function writeMetricsArtifact(params) {
+  const artifactWithTiming = buildMetricsArtifactPayload(params);
+  await writeFile10(params.filePath, `${JSON.stringify(artifactWithTiming, null, 2)}
 `, "utf8");
+  return artifactWithTiming;
 }
 function indexRecordKey(record2) {
   if (!isRecord7(record2)) {
@@ -45215,7 +45647,7 @@ function projectionIdentityRecordKey(record2) {
   return typeof id === "string" && id.trim().length > 0 ? id : void 0;
 }
 async function readExistingIndexRecords(outputDir) {
-  const indexPath = path49.join(outputDir, RESULT_INDEX_FILENAME);
+  const indexPath = path48.join(outputDir, RESULT_INDEX_FILENAME);
   const content = await readFile20(indexPath, "utf8").catch(() => void 0);
   if (content === void 0) {
     return [];
@@ -45268,7 +45700,7 @@ async function rewriteExistingIndexRecords(outputDir, replacements) {
   if (replacements.length === 0) {
     return;
   }
-  const indexPath = path49.join(outputDir, RESULT_INDEX_FILENAME);
+  const indexPath = path48.join(outputDir, RESULT_INDEX_FILENAME);
   const content = await readFile20(indexPath, "utf8").catch(() => void 0);
   if (content === void 0) {
     return;
@@ -45425,39 +45857,10 @@ async function writePerTestArtifacts(results, outputDir, options) {
   const testByTestId = new Map((options?.sourceTests ?? []).map((test) => [test.id, test]));
   const indexRecords = [];
   for (const result of results) {
-    const grading = buildGradingArtifact(result);
-    const timing = buildTimingArtifact([result]);
     const artifactSubdir = buildArtifactSubdir(result);
-    const testDir = path49.join(outputDir, artifactSubdir);
+    const testDir = path48.join(outputDir, artifactSubdir);
     await mkdir18(testDir, { recursive: true });
-    await writeFile10(
-      path49.join(testDir, "grading.json"),
-      `${JSON.stringify(grading, null, 2)}
-`,
-      "utf8"
-    );
-    await writeFile10(
-      path49.join(testDir, "timing.json"),
-      `${JSON.stringify(timing, null, 2)}
-`,
-      "utf8"
-    );
-    const input = extractInput(result);
-    if (input) {
-      await writeFile10(path49.join(testDir, "input.md"), input, "utf8");
-    }
-    const outputsDir = path49.join(testDir, "outputs");
-    await mkdir18(outputsDir, { recursive: true });
-    if (result.output.length > 0) {
-      await writeFile10(path49.join(outputsDir, "answer.md"), result.output, "utf8");
-      await writeFile10(path49.join(outputsDir, "response.md"), result.output, "utf8");
-    }
-    const rawProviderLogSource = rawProviderLogSourcePath(result);
-    if (rawProviderLogSource) {
-      await copyRawProviderLogArtifact(rawProviderLogSource, testDir);
-    }
-    const tracePath = path49.join(testDir, CANONICAL_TRACE_ARTIFACT_PATH);
-    const envelope = await writeTraceEnvelopeSidecar({
+    const envelope = buildTraceEnvelopeSidecar({
       result,
       outputDir,
       testDir,
@@ -45466,22 +45869,34 @@ async function writePerTestArtifacts(results, outputDir, options) {
       runId: options?.runId,
       duplicatePolicy
     });
-    const transcriptPath = hasTranscriptProjection(result, envelope) ? path49.join(testDir, CANONICAL_TRANSCRIPT_ARTIFACT_PATH) : void 0;
-    if (transcriptPath) {
-      await writeTranscriptJsonl(transcriptPath, result, envelope);
+    const projectionIdentity = envelope.projectionIdentity;
+    if (!projectionIdentity) {
+      throw new Error(`Result ${result.testId ?? "unknown"} is missing projection identity`);
     }
-    const metricsPath = path49.join(testDir, CANONICAL_METRICS_ARTIFACT_PATH);
-    await writeMetricsArtifact({
-      filePath: metricsPath,
-      result,
-      envelope,
-      transcriptPath
-    });
-    const artifactPointers = await buildArtifactPointers({
-      outputDir,
-      tracePath,
-      transcriptPath
-    });
+    const caseSummaryPath = path48.join(testDir, RUN_SUMMARY_FILENAME);
+    const aggregateTiming = buildRepeatAggregateTimingArtifact(result);
+    const summary = buildRepeatCaseSummaryArtifact(result, aggregateTiming, projectionIdentity.id);
+    await writeFile10(caseSummaryPath, `${JSON.stringify(summary, null, 2)}
+`, "utf8");
+    for (const trial of materializedRunTrials(result)) {
+      await writeTrialRunArtifacts({
+        trial,
+        parentTestDir: testDir,
+        outputDir,
+        evalFile: options?.evalFile,
+        experiment: options?.experiment,
+        runId: options?.runId,
+        duplicatePolicy,
+        testByTestId
+      });
+    }
+    const isSingleRun = !hasPersistedTrialRuns(result);
+    const singleRunDir = path48.join(testDir, trialRunDirName(0));
+    const singleAnswerPath = isSingleRun && result.output.length > 0 ? path48.join(singleRunDir, "outputs", "answer.md") : void 0;
+    const singleTranscriptPath = isSingleRun && hasTranscriptProjection(result, envelope) ? path48.join(singleRunDir, "transcript-raw.jsonl") : void 0;
+    const singleGradingPath = isSingleRun ? path48.join(singleRunDir, "grading.json") : void 0;
+    const singleTimingPath = isSingleRun ? path48.join(singleRunDir, "timing.json") : void 0;
+    const singleMetricsPath = isSingleRun ? path48.join(singleRunDir, CANONICAL_METRICS_ARTIFACT_PATH) : void 0;
     const extraIndexFields = await collectAdditionalIndexFields(
       result,
       outputDir,
@@ -45490,10 +45905,19 @@ async function writePerTestArtifacts(results, outputDir, options) {
       options?.additionalArtifacts
     );
     indexRecords.push({
-      ...buildResultIndexArtifact(result, extraIndexFields, {
-        projectionIdentity: envelope.projectionIdentity,
-        duplicatePolicy,
-        artifactPointers
+      ...buildIndexArtifactEntry(result, {
+        outputDir,
+        artifactDir: testDir,
+        summaryPath: caseSummaryPath,
+        gradingPath: singleGradingPath,
+        timingPath: singleTimingPath,
+        metricsPath: singleMetricsPath,
+        outputPath: singleAnswerPath,
+        answerPath: singleAnswerPath,
+        transcriptPath: singleTranscriptPath,
+        extraIndexFields,
+        projectionIdentity,
+        duplicatePolicy
       }),
       experiment: options?.experiment
     });
@@ -45502,9 +45926,8 @@ async function writePerTestArtifacts(results, outputDir, options) {
 }
 async function writeArtifactsFromResults(results, outputDir, options) {
   const testArtifactDir = outputDir;
-  const timingPath = path49.join(outputDir, "timing.json");
-  const benchmarkPath = path49.join(outputDir, "benchmark.json");
-  const indexPath = path49.join(outputDir, RESULT_INDEX_FILENAME);
+  const summaryPath = path48.join(outputDir, RUN_SUMMARY_FILENAME);
+  const indexPath = path48.join(outputDir, RESULT_INDEX_FILENAME);
   await mkdir18(outputDir, { recursive: true });
   const duplicatePolicy = options?.duplicatePolicy ?? "update";
   const existingRecords = await readExistingIndexRecords(outputDir);
@@ -45513,17 +45936,9 @@ async function writeArtifactsFromResults(results, outputDir, options) {
   const testByTestId = new Map((options?.sourceTests ?? []).map((test) => [test.id, test]));
   const emittedIdentityIds = /* @__PURE__ */ new Set();
   const plans = results.map((result) => {
-    const grading = buildGradingArtifact(result);
-    const timing2 = buildTimingArtifact([result]);
     const artifactSubdir = buildArtifactSubdir(result);
-    const testDir = path49.join(outputDir, artifactSubdir);
-    const gradingPath = path49.join(testDir, "grading.json");
-    const perTestTimingPath = path49.join(testDir, "timing.json");
-    const input = extractInput(result);
-    const inputPath = input ? path49.join(testDir, "input.md") : void 0;
-    const outputsDir = path49.join(testDir, "outputs");
-    const answerPath = result.output.length > 0 ? path49.join(outputsDir, "answer.md") : void 0;
-    const responsePath = result.output.length > 0 ? path49.join(outputsDir, "response.md") : void 0;
+    const testDir = path48.join(outputDir, artifactSubdir);
+    const caseSummaryPath = path48.join(testDir, RUN_SUMMARY_FILENAME);
     const envelope = buildTraceEnvelopeSidecar({
       result,
       outputDir,
@@ -45533,35 +45948,29 @@ async function writeArtifactsFromResults(results, outputDir, options) {
       runId: options?.runId,
       duplicatePolicy
     });
-    const transcriptPath = hasTranscriptProjection(result, envelope) ? path49.join(testDir, CANONICAL_TRANSCRIPT_ARTIFACT_PATH) : void 0;
-    const tracePath = path49.join(testDir, CANONICAL_TRACE_ARTIFACT_PATH);
-    const metricsPath = path49.join(testDir, CANONICAL_METRICS_ARTIFACT_PATH);
-    const rawProviderLogSource = rawProviderLogSourcePath(result);
-    const rawProviderLogPath = rawProviderLogSource ? rawProviderLogArtifactPath(testDir) : void 0;
     const projectionIdentity = envelope.projectionIdentity;
     if (!projectionIdentity) {
       throw new Error(`Result ${result.testId ?? "unknown"} is missing projection identity`);
     }
     const identityId = projectionIdentity.id;
+    const isSingleRun = !hasPersistedTrialRuns(result);
+    const singleRunDir = path48.join(testDir, trialRunDirName(0));
+    const singleAnswerPath = isSingleRun && result.output.length > 0 ? path48.join(singleRunDir, "outputs", "answer.md") : void 0;
+    const singleTranscriptPath = isSingleRun && hasTranscriptProjection(result, envelope) ? path48.join(singleRunDir, "transcript-raw.jsonl") : void 0;
+    const singleGradingPath = isSingleRun ? path48.join(singleRunDir, "grading.json") : void 0;
+    const singleTimingPath = isSingleRun ? path48.join(singleRunDir, "timing.json") : void 0;
+    const singleMetricsPath = isSingleRun ? path48.join(singleRunDir, CANONICAL_METRICS_ARTIFACT_PATH) : void 0;
     return {
       result,
-      grading,
-      timing: timing2,
       testDir,
-      gradingPath,
-      perTestTimingPath,
-      input,
-      inputPath,
-      outputsDir,
-      answerPath,
-      responsePath,
-      tracePath,
-      metricsPath,
-      envelope,
+      caseSummaryPath,
       projectionIdentity,
-      transcriptPath,
-      rawProviderLogSource,
-      rawProviderLogPath,
+      isSingleRun,
+      singleAnswerPath,
+      singleTranscriptPath,
+      singleGradingPath,
+      singleTimingPath,
+      singleMetricsPath,
       identityId
     };
   });
@@ -45578,7 +45987,7 @@ async function writeArtifactsFromResults(results, outputDir, options) {
     }
   }
   for (const plan of plans) {
-    const { result, envelope, identityId } = plan;
+    const { result, identityId } = plan;
     const existing = existingByIdentity.get(identityId);
     if (duplicatePolicy === "skip" && existing) {
       indexRecords.push(skippedExistingRecord(existing, plan.projectionIdentity, duplicatePolicy));
@@ -45589,41 +45998,26 @@ async function writeArtifactsFromResults(results, outputDir, options) {
       continue;
     }
     await mkdir18(plan.testDir, { recursive: true });
-    await writeFile10(plan.gradingPath, `${JSON.stringify(plan.grading, null, 2)}
-`, "utf8");
-    await writeFile10(plan.perTestTimingPath, `${JSON.stringify(plan.timing, null, 2)}
-`, "utf8");
-    if (plan.inputPath && plan.input) {
-      await writeFile10(plan.inputPath, plan.input, "utf8");
-    }
-    await mkdir18(plan.outputsDir, { recursive: true });
-    if (plan.answerPath && plan.responsePath) {
-      await writeFile10(plan.answerPath, result.output, "utf8");
-      await writeFile10(plan.responsePath, result.output, "utf8");
-    }
-    if (plan.rawProviderLogSource) {
-      await copyRawProviderLogArtifact(plan.rawProviderLogSource, plan.testDir);
-    }
-    await writeFile10(
-      plan.tracePath,
-      `${JSON.stringify(toTraceEnvelopeWire(envelope), null, 2)}
-`,
-      "utf8"
+    const aggregateTiming = buildRepeatAggregateTimingArtifact(result);
+    const summary2 = buildRepeatCaseSummaryArtifact(
+      result,
+      aggregateTiming,
+      options?.experimentMetadata?.fingerprint ?? plan.projectionIdentity.id
     );
-    if (plan.transcriptPath) {
-      await writeTranscriptJsonl(plan.transcriptPath, result, envelope);
+    await writeFile10(plan.caseSummaryPath, `${JSON.stringify(summary2, null, 2)}
+`, "utf8");
+    for (const trial of materializedRunTrials(result)) {
+      await writeTrialRunArtifacts({
+        trial,
+        parentTestDir: plan.testDir,
+        outputDir,
+        evalFile: options?.evalFile,
+        experiment: options?.experiment,
+        runId: options?.runId,
+        duplicatePolicy,
+        testByTestId
+      });
     }
-    await writeMetricsArtifact({
-      filePath: plan.metricsPath,
-      result,
-      envelope,
-      transcriptPath: plan.transcriptPath
-    });
-    const artifactPointers = await buildArtifactPointers({
-      outputDir,
-      tracePath: plan.tracePath,
-      transcriptPath: plan.transcriptPath
-    });
     const extraIndexFields = await collectAdditionalIndexFields(
       result,
       outputDir,
@@ -45635,17 +46029,13 @@ async function writeArtifactsFromResults(results, outputDir, options) {
       ...buildIndexArtifactEntry(result, {
         outputDir,
         artifactDir: plan.testDir,
-        gradingPath: plan.gradingPath,
-        timingPath: plan.perTestTimingPath,
-        outputPath: plan.answerPath,
-        answerPath: plan.answerPath,
-        tracePath: plan.tracePath,
-        transcriptPath: plan.transcriptPath,
-        metricsPath: plan.metricsPath,
-        artifactPointers,
-        rawProviderLogPath: plan.rawProviderLogPath,
-        inputPath: plan.inputPath,
-        responsePath: plan.responsePath,
+        summaryPath: plan.caseSummaryPath,
+        gradingPath: plan.singleGradingPath,
+        timingPath: plan.singleTimingPath,
+        metricsPath: plan.singleMetricsPath,
+        outputPath: plan.singleAnswerPath,
+        answerPath: plan.singleAnswerPath,
+        transcriptPath: plan.singleTranscriptPath,
         extraIndexFields,
         projectionIdentity: plan.projectionIdentity,
         duplicatePolicy
@@ -45664,20 +46054,18 @@ async function writeArtifactsFromResults(results, outputDir, options) {
     }
     emittedIdentityIds.add(identityId);
   }
-  const timing = buildTimingArtifact(results);
-  await writeFile10(timingPath, `${JSON.stringify(timing, null, 2)}
-`, "utf8");
-  const plannedTestCount = options?.plannedTestCount ?? await readPlannedTestCount(benchmarkPath);
-  const benchmark = buildBenchmarkArtifact(
+  const plannedTestCount = options?.plannedTestCount ?? await readPlannedTestCount(summaryPath);
+  const summary = buildRunSummaryArtifact(
     results,
     options?.evalFile,
     options?.experiment,
-    plannedTestCount
+    plannedTestCount,
+    options?.experimentMetadata
   );
-  await writeFile10(benchmarkPath, `${JSON.stringify(benchmark, null, 2)}
+  await writeFile10(summaryPath, `${JSON.stringify(summary, null, 2)}
 `, "utf8");
   await writeJsonlFile(indexPath, indexRecords);
-  return { testArtifactDir, timingPath, benchmarkPath, indexPath };
+  return { testArtifactDir, summaryPath, indexPath };
 }
 async function evaluate(config2) {
   const startTime = Date.now();
@@ -45724,7 +46112,7 @@ async function evaluate(config2) {
     cliNoCache: false,
     yamlCache: config2.cache === void 0 ? materialized.cache : void 0
   });
-  const cache = cacheEnabled ? new ResponseCache(materialized.cachePath ? path50.resolve(materialized.cachePath) : void 0) : void 0;
+  const cache = cacheEnabled ? new ResponseCache(materialized.cachePath ? path49.resolve(materialized.cachePath) : void 0) : void 0;
   const results = await runEvaluation({
     testFilePath,
     repoRoot,
@@ -45747,16 +46135,15 @@ async function evaluate(config2) {
   });
   const allResults = collectedResults.length > 0 ? collectedResults : [...results];
   const durationMs = Date.now() - startTime;
-  const outputDir = config2.outputDir ? path50.resolve(config2.outputDir) : void 0;
+  const outputDir = config2.outputDir ? path49.resolve(config2.outputDir) : void 0;
   const artifacts = outputDir ? await writeArtifactsFromResults(allResults, outputDir, {
     evalFile: config2.specFile ? testFilePath : "",
     experiment: config2.experiment,
     sourceTests: materialized.tests
-  }).then(({ benchmarkPath, indexPath, timingPath }) => ({
+  }).then(({ summaryPath, indexPath }) => ({
     runDir: outputDir,
-    benchmarkPath,
-    indexPath,
-    timingPath
+    summaryPath,
+    indexPath
   })) : void 0;
   return {
     results: allResults,
@@ -45767,7 +46154,7 @@ async function evaluate(config2) {
 async function materializeEvalConfig(config2, options) {
   const baseDir = options?.baseDir ?? process.cwd();
   const repoRoot = options?.repoRoot ?? await findGitRoot(baseDir) ?? baseDir;
-  const testFilePath = config2.specFile ? path50.resolve(baseDir, config2.specFile) : path50.join(baseDir, "__programmatic__.yaml");
+  const testFilePath = config2.specFile ? path49.resolve(baseDir, config2.specFile) : path49.join(baseDir, "__programmatic__.yaml");
   const effectiveFilter = options?.filter ?? config2.filter;
   if (config2.specFile) {
     const suite = await loadTestSuite(testFilePath, repoRoot, {
@@ -45844,7 +46231,7 @@ function convertAssertions(entries) {
 }
 function buildInlineEvalTests(config2, options) {
   const suiteWorkspace = config2.beforeAll ? { hooks: { before_all: toBeforeAllHook(config2.beforeAll) } } : void 0;
-  const derivedSuiteName = path50.basename(options.testFilePath).replace(/\.eval\.[cm]?ts$/i, "").replace(/\.[cm]?ts$/i, "");
+  const derivedSuiteName = path49.basename(options.testFilePath).replace(/\.eval\.[cm]?ts$/i, "").replace(/\.[cm]?ts$/i, "");
   const suiteName = config2.metadata?.name ?? (derivedSuiteName || "eval");
   return (config2.tests ?? []).filter((test) => !options.filter || matchesFilter4(test.id, options.filter)).map((test) => {
     const isConversation = test.mode === "conversation" || test.turns && test.turns.length > 0;
@@ -45940,10 +46327,10 @@ function computeSummary(results, durationMs, threshold = DEFAULT_THRESHOLD) {
 var TARGET_FILE_CANDIDATES = [".agentv/targets.yaml", ".agentv/targets.yml"];
 async function discoverDefaultTarget(repoRoot) {
   const cwd = process.cwd();
-  const chain = buildDirectoryChain(path50.join(cwd, "_placeholder"), repoRoot);
+  const chain = buildDirectoryChain(path49.join(cwd, "_placeholder"), repoRoot);
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const targetsPath = path50.join(dir, candidate);
+      const targetsPath = path49.join(dir, candidate);
       if (!existsSync7(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
@@ -45960,7 +46347,7 @@ async function loadEnvHierarchy(repoRoot, startPath) {
   const chain = buildDirectoryChain(startPath, repoRoot);
   const envFiles = [];
   for (const dir of chain) {
-    const envPath = path50.join(dir, ".env");
+    const envPath = path49.join(dir, ".env");
     if (existsSync7(envPath)) envFiles.push(envPath);
   }
   for (let i = 0; i < envFiles.length; i++) {
@@ -45988,7 +46375,7 @@ var EXPORT_NAMES = ["default", "config", "evalConfig"];
 var SDK_EVAL_SUITE_SYMBOL = Symbol.for("@agentv/sdk/eval-suite");
 var SDK_TO_EVAL_YAML_OBJECT_SYMBOL = Symbol.for("@agentv/sdk/to-eval-yaml-object");
 async function loadTsEvalFile(filePath) {
-  const absolutePath = path51.resolve(filePath);
+  const absolutePath = path50.resolve(filePath);
   const moduleUrl = pathToFileURL2(absolutePath).href;
   const module = await import(moduleUrl);
   let config2;
@@ -46018,7 +46405,7 @@ async function loadTsEvalSuite(filePath, repoRoot, options) {
   }
   const materialized = await materializeEvalConfig(config2, {
     repoRoot,
-    baseDir: path51.dirname(absolutePath),
+    baseDir: path50.dirname(absolutePath),
     filter: options?.filter,
     category: options?.category
   });
@@ -46071,6 +46458,14 @@ export {
   isGraderKind,
   RUBRIC_OPERATOR_VALUES,
   parseYamlValue,
+  AGENTV_CONFIG_FILE_NAME,
+  AGENTV_CONFIG_YML_FILE_NAME,
+  AGENTV_LOCAL_CONFIG_FILE_NAME,
+  AGENTV_LOCAL_CONFIG_YML_FILE_NAME,
+  getLocalConfigPath,
+  isAgentVConfigFileName,
+  isPlainConfigObject,
+  mergeConfigObjects,
   getAgentvConfigDir,
   getAgentvHome,
   getAgentvDataDir,
@@ -46098,6 +46493,8 @@ export {
   interpolateEnv,
   loadCasesFromFile,
   loadCasesFromDirectory,
+  buildSearchRoots2,
+  loadPromptMdFallback,
   ResponseCache,
   shouldEnableCache,
   shouldSkipCacheForTemperature,
@@ -46303,10 +46700,10 @@ export {
   extractTargetsFromSuite,
   extractWorkersFromSuite,
   extractTargetsFromTestCase,
-  extractTrialsConfig,
   extractCacheConfig,
   extractFailOnError,
   extractThreshold,
+  resolveDefaultExperimentReference,
   resolveResultsConfigForProject,
   detectFormat,
   parseRepoConfig,
@@ -46350,13 +46747,14 @@ export {
   ResultRowSchemaError,
   normalizeResultRow,
   RESULT_INDEX_FILENAME,
+  RUN_SUMMARY_FILENAME,
   buildTestTargetKey,
   deduplicateByTestIdTarget,
   aggregateRunDir,
   buildGradingArtifact,
   buildTimingArtifact,
-  buildBenchmarkArtifact,
-  writeInitialBenchmarkArtifact,
+  buildRunSummaryArtifact,
+  writeInitialRunSummaryArtifact,
   buildAggregateGradingArtifact,
   buildIndexArtifactEntry,
   buildResultIndexArtifact,
@@ -46368,4 +46766,4 @@ export {
   loadTsEvalFile,
   loadTsEvalSuite
 };
-//# sourceMappingURL=chunk-RFJM2UBD.js.map
+//# sourceMappingURL=chunk-GZJMODLW.js.map