agentv 4.10.0 → 4.11.2-next.1

package/dist/{chunk-SE73HJZG.js → chunk-FQGY6QXQ.js}

@@ -1,7 +1,17 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  execFileWithStdin,
+  execShellWithStdin
+} from "./chunk-NPVGBFF6.js";
 import {
   require_token_error
 } from "./chunk-HQDCIXVH.js";
+import {
+  SpanStatusCode,
+  context,
+  init_esm,
+  trace
+} from "./chunk-LRULMAAA.js";
 import {
   AISDKError,
   APICallError,
@@ -150,12 +160,6 @@ import {
   withoutTrailingSlash,
   zodSchema
 } from "./chunk-ZKO2LGRR.js";
-import {
-  SpanStatusCode,
-  context,
-  init_esm,
-  trace
-} from "./chunk-LRULMAAA.js";
 import {
   __commonJS,
   __export,
@@ -301,7 +305,7 @@ var require_dist = __commonJS({
   }
 });
 
-// ../../packages/core/dist/chunk-BWHUWLGW.js
+// ../../packages/core/dist/chunk-5POFMJJ7.js
 import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
@@ -419,7 +423,7 @@ __export(external_exports2, {
   void: () => voidType
 });
 
-// ../../packages/core/dist/chunk-BWHUWLGW.js
+// ../../packages/core/dist/chunk-5POFMJJ7.js
 import { readFile as readFile2 } from "node:fs/promises";
 import path3 from "node:path";
 import fg from "fast-glob";
@@ -2308,10 +2312,10 @@ async function expandFileReferences(tests, evalFileDir) {
 }
 
 // ../../packages/core/dist/index.js
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile8 } from "node:fs/promises";
 import path8 from "node:path";
 import micromatch2 from "micromatch";
-import { parse as parse2 } from "yaml";
+import { parse as parse3 } from "yaml";
 import { readFile as readFile3 } from "node:fs/promises";
 import path4 from "node:path";
 import { readFile as readFile22 } from "node:fs/promises";
@@ -2321,20 +2325,22 @@ import { constants as constants2 } from "node:fs";
 import { access as access2 } from "node:fs/promises";
 import path22 from "node:path";
 import { fileURLToPath } from "node:url";
+import { readFile as readFile5 } from "node:fs/promises";
 import path5 from "node:path";
+import { parse as parse2 } from "yaml";
 import { readFile as readFile32 } from "node:fs/promises";
 import path42 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { readFile as readFile4 } from "node:fs/promises";
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 import path7 from "node:path";
 import micromatch from "micromatch";
 import { parse as parseYaml2 } from "yaml";
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import path6 from "node:path";
 import { readFileSync } from "node:fs";
 import path9 from "node:path";
-import { parse as parse3 } from "yaml";
+import { parse as parse4 } from "yaml";
 import { createOpenAI } from "@ai-sdk/openai";
 
 // ../../node_modules/.bun/@openrouter+ai-sdk-provider@2.3.3+3ab978b6804fd9e7/node_modules/@openrouter/ai-sdk-provider/dist/index.mjs
@@ -6944,7 +6950,7 @@ function createOpenRouter(options = {}) {
   );
   const createChatModel = (modelId, settings = {}) => new OpenRouterChatLanguageModel(modelId, settings, {
     provider: "openrouter.chat",
-    url: ({ path: path52 }) => `${baseURL}${path52}`,
+    url: ({ path: path53 }) => `${baseURL}${path53}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -6952,7 +6958,7 @@ function createOpenRouter(options = {}) {
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenRouterCompletionLanguageModel(modelId, settings, {
     provider: "openrouter.completion",
-    url: ({ path: path52 }) => `${baseURL}${path52}`,
+    url: ({ path: path53 }) => `${baseURL}${path53}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -6960,14 +6966,14 @@ function createOpenRouter(options = {}) {
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenRouterEmbeddingModel(modelId, settings, {
     provider: "openrouter.embedding",
-    url: ({ path: path52 }) => `${baseURL}${path52}`,
+    url: ({ path: path53 }) => `${baseURL}${path53}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
   });
   const createImageModel = (modelId, settings = {}) => new OpenRouterImageModel(modelId, settings, {
     provider: "openrouter.image",
-    url: ({ path: path52 }) => `${baseURL}${path52}`,
+    url: ({ path: path53 }) => `${baseURL}${path53}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
@@ -14467,10 +14473,10 @@ import { createWriteStream as createWriteStream4, existsSync, readdirSync } from
 import { arch, platform } from "node:os";
 import path15 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { readFile as readFile9 } from "node:fs/promises";
+import { readFile as readFile10 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import path18 from "node:path";
-import { readFile as readFile8, readdir, stat } from "node:fs/promises";
+import { readFile as readFile9, readdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import path17 from "node:path";
 import { parse as parseYaml22 } from "yaml";
@@ -14504,23 +14510,23 @@ import { access as access22, mkdir as mkdir8, readdir as readdir2, rm as rm2, st
 import path23 from "node:path";
 import path24 from "node:path";
 import path25 from "node:path";
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 import path26 from "node:path";
 import { exec, spawn as spawn4 } from "node:child_process";
 import { mkdir as mkdir9, writeFile as writeFile2 } from "node:fs/promises";
 import path28 from "node:path";
 import { promisify as promisify2 } from "node:util";
 import path27 from "node:path";
-import { copyFile, mkdir as mkdir10, readFile as readFile11, readdir as readdir3, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
+import { copyFile, mkdir as mkdir10, readFile as readFile12, readdir as readdir3, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
 import path30 from "node:path";
 import path29 from "node:path";
 import JSON5 from "json5";
 import { writeFile as writeFile5 } from "node:fs/promises";
 import path322 from "node:path";
 import { constants as constants4 } from "node:fs";
-import { access as access4, readFile as readFile12 } from "node:fs/promises";
+import { access as access4, readFile as readFile13 } from "node:fs/promises";
 import path34 from "node:path";
-import { parse as parse4 } from "yaml";
+import { parse as parse5 } from "yaml";
 import path35 from "node:path";
 import fg2 from "fast-glob";
 import { mkdtemp as mkdtemp2, rm as rm3, writeFile as writeFile6 } from "node:fs/promises";
@@ -14549,7 +14555,7 @@ import path41 from "node:path";
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync as existsSync3 } from "node:fs";
-import { cp as cp2, mkdir as mkdir13, readFile as readFile13, readdir as readdir5, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
+import { cp as cp2, mkdir as mkdir13, readFile as readFile14, readdir as readdir5, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
 import path422 from "node:path";
 import { promisify as promisify5 } from "node:util";
 import { execFile as execFile2 } from "node:child_process";
@@ -14560,21 +14566,27 @@ import { readdir as readdir6, stat as stat7 } from "node:fs/promises";
 import path44 from "node:path";
 import { existsSync as existsSync6 } from "node:fs";
 import path46 from "node:path";
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 import path47 from "node:path";
-import { parse as parse5 } from "yaml";
-import { mkdir as mkdir15, readFile as readFile15, writeFile as writeFile8 } from "node:fs/promises";
+import { parse as parse6 } from "yaml";
+import { mkdir as mkdir15, readFile as readFile16, writeFile as writeFile8 } from "node:fs/promises";
 import path48 from "node:path";
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync2, writeFileSync } from "node:fs";
+import { execFile as execFile3 } from "node:child_process";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync } from "node:fs";
+import { cp as cp3, mkdtemp as mkdtemp3, readdir as readdir8, rm as rm6, stat as stat9 } from "node:fs/promises";
+import os3 from "node:os";
 import path49 from "node:path";
-import { parse as parseYaml3, stringify as stringifyYaml } from "yaml";
-import { readdir as readdir8, stat as stat9 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
+import { promisify as promisify7 } from "node:util";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import path50 from "node:path";
+import { parse as parseYaml3, stringify as stringifyYaml } from "yaml";
 import { readdir as readdir9, stat as stat10 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir3 } from "node:os";
 import path51 from "node:path";
-import { readFile as readFile16 } from "node:fs/promises";
+import { readdir as readdir10, stat as stat11 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import path52 from "node:path";
+import { readFile as readFile17 } from "node:fs/promises";
 function computeTraceSummary(messages) {
   const toolCallCounts = {};
   const toolDurations = {};
@@ -14957,10 +14969,12 @@ async function loadConfig(evalFilePath, repoRoot) {
         parsed.execution,
         configPath
       );
+      const results = parseResultsConfig(parsed.results, configPath);
       return {
         required_version: requiredVersion,
         eval_patterns: evalPatterns,
-        execution: executionDefaults
+        execution: executionDefaults,
+        results
       };
     } catch (error) {
       logWarning(
@@ -15195,150 +15209,63 @@ function parseExecutionDefaults(raw, configPath) {
   }
   return Object.keys(result).length > 0 ? result : void 0;
 }
-function logWarning(message) {
-  console.warn(`${ANSI_YELLOW2}Warning: ${message}${ANSI_RESET22}`);
-}
-function shellEscapePath(value) {
-  if (process.platform === "win32") {
-    return `"${value.replaceAll('"', '""')}"`;
+function parseResultsConfig(raw, configPath) {
+  if (raw === void 0 || raw === null) {
+    return void 0;
   }
-  return `'${value.replaceAll("'", `'"'"'`)}'`;
-}
-async function execFileWithStdin(argv, stdinPayload, options = {}) {
-  if (argv.length === 0) {
-    throw new Error("Executable argv must include at least one entry");
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    logWarning(`Invalid results in ${configPath}, expected object`);
+    return void 0;
   }
-  if (typeof Bun !== "undefined") {
-    return execFileWithStdinBun(argv, stdinPayload, options);
+  const obj = raw;
+  const exportConfig = parseResultsExportConfig(obj.export, configPath);
+  if (!exportConfig) {
+    return void 0;
   }
-  return execFileWithStdinNode(argv, stdinPayload, options);
+  return { export: exportConfig };
 }
-async function execFileWithStdinBun(argv, stdinPayload, options) {
-  const command = [...argv];
-  const encoder = new TextEncoder();
-  const proc = Bun.spawn(command, {
-    cwd: options.cwd,
-    stdin: encoder.encode(stdinPayload),
-    stdout: "pipe",
-    stderr: "pipe",
-    // Merge additional env vars with process.env
-    env: options.env ? { ...process.env, ...options.env } : process.env
-  });
-  let timedOut = false;
-  const timeout = options.timeoutMs !== void 0 ? setTimeout(() => {
-    timedOut = true;
-    proc.kill("SIGKILL");
-  }, options.timeoutMs) : void 0;
-  try {
-    const stdoutPromise = proc.stdout ? new Response(proc.stdout).text() : Promise.resolve("");
-    const stderrPromise = proc.stderr ? new Response(proc.stderr).text() : Promise.resolve("");
-    const [stdout, stderr, exitCode] = await Promise.all([
-      stdoutPromise,
-      stderrPromise,
-      proc.exited
-    ]);
-    if (timedOut) {
-      throw new Error(`Process timed out after ${options.timeoutMs}ms`);
-    }
-    return {
-      stdout: stdout.replace(/\r\n/g, "\n"),
-      stderr: stderr.replace(/\r\n/g, "\n"),
-      exitCode
-    };
-  } finally {
-    if (timeout !== void 0) {
-      clearTimeout(timeout);
-    }
+function parseResultsExportConfig(raw, configPath) {
+  if (raw === void 0 || raw === null) {
+    return void 0;
   }
-}
-async function execFileWithStdinNode(argv, stdinPayload, options) {
-  const { spawn: spawn5 } = await import("node:child_process");
-  return new Promise((resolve2, reject) => {
-    const [cmd, ...args] = argv;
-    const child = spawn5(cmd, args, {
-      cwd: options.cwd,
-      stdio: ["pipe", "pipe", "pipe"],
-      // Merge additional env vars with process.env
-      env: options.env ? { ...process.env, ...options.env } : process.env
-    });
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
-    child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
-    let timedOut = false;
-    const timeout = options.timeoutMs !== void 0 ? setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGKILL");
-    }, options.timeoutMs) : void 0;
-    child.on("error", (error) => {
-      if (timeout !== void 0) clearTimeout(timeout);
-      reject(error);
-    });
-    child.on("close", (code) => {
-      if (timeout !== void 0) clearTimeout(timeout);
-      if (timedOut) {
-        reject(new Error(`Process timed out after ${options.timeoutMs}ms`));
-        return;
-      }
-      const stdout = Buffer.concat(stdoutChunks).toString("utf8").replace(/\r\n/g, "\n");
-      const stderr = Buffer.concat(stderrChunks).toString("utf8").replace(/\r\n/g, "\n");
-      resolve2({
-        stdout,
-        stderr,
-        exitCode: code ?? 0
-      });
-    });
-    if (child.stdin) {
-      child.stdin.write(stdinPayload);
-      child.stdin.end();
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    logWarning(`Invalid results.export in ${configPath}, expected object`);
+    return void 0;
+  }
+  const obj = raw;
+  const repo = typeof obj.repo === "string" ? obj.repo.trim() : "";
+  const exportPath = typeof obj.path === "string" ? obj.path.trim() : "";
+  if (!repo) {
+    logWarning(`Invalid results.export.repo in ${configPath}, expected non-empty string`);
+    return void 0;
+  }
+  if (!exportPath) {
+    logWarning(`Invalid results.export.path in ${configPath}, expected non-empty string`);
+    return void 0;
+  }
+  if (obj.auto_push !== void 0 && typeof obj.auto_push !== "boolean") {
+    logWarning(`Invalid results.export.auto_push in ${configPath}, expected boolean`);
+    return void 0;
+  }
+  let branchPrefix;
+  if (obj.branch_prefix !== void 0) {
+    if (typeof obj.branch_prefix !== "string" || obj.branch_prefix.trim().length === 0) {
+      logWarning(
+        `Invalid results.export.branch_prefix in ${configPath}, expected non-empty string`
+      );
+      return void 0;
     }
-  });
-}
-async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir16, readFile: readFile17, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
-  const { tmpdir: tmpdir3 } = await import("node:os");
-  const path52 = await import("node:path");
-  const { randomUUID: randomUUID10 } = await import("node:crypto");
-  const dir = path52.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
-  await mkdir16(dir, { recursive: true });
-  const stdinPath = path52.join(dir, "stdin.txt");
-  const stdoutPath = path52.join(dir, "stdout.txt");
-  const stderrPath = path52.join(dir, "stderr.txt");
-  await writeFile9(stdinPath, stdinPayload, "utf8");
-  const wrappedCommand = process.platform === "win32" ? `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
-  const { spawn: spawn5 } = await import("node:child_process");
-  try {
-    const exitCode = await new Promise((resolve2, reject) => {
-      const child = spawn5(wrappedCommand, {
-        shell: true,
-        cwd: options.cwd,
-        stdio: ["ignore", "ignore", "ignore"],
-        // Merge additional env vars with process.env
-        env: options.env ? { ...process.env, ...options.env } : process.env
-      });
-      const timeout = options.timeoutMs ? setTimeout(() => {
-        child.kill();
-        reject(new Error(`Process timed out after ${options.timeoutMs}ms`));
-      }, options.timeoutMs) : void 0;
-      child.on("error", (error) => {
-        if (timeout !== void 0) {
-          clearTimeout(timeout);
-        }
-        reject(error);
-      });
-      child.on("exit", (code) => {
-        if (timeout !== void 0) {
-          clearTimeout(timeout);
-        }
-        resolve2(code ?? 0);
-      });
-    });
-    const stdout = (await readFile17(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile17(stderrPath, "utf8")).replace(/\r\n/g, "\n");
-    return { stdout, stderr, exitCode };
-  } finally {
-    await rm6(dir, { recursive: true, force: true });
+    branchPrefix = obj.branch_prefix.trim();
   }
+  return {
+    repo,
+    path: exportPath,
+    ...typeof obj.auto_push === "boolean" && { auto_push: obj.auto_push },
+    ...branchPrefix && { branch_prefix: branchPrefix }
+  };
+}
+function logWarning(message) {
+  console.warn(`${ANSI_YELLOW2}Warning: ${message}${ANSI_RESET22}`);
 }
 var MIME_TYPE_ALIASES = {
   csv: "text/csv",
@@ -15571,6 +15498,7 @@ function validateTemplateVariables(content, source) {
 }
 var ANSI_YELLOW3 = "\x1B[33m";
 var ANSI_RESET4 = "\x1B[0m";
+var MAX_ASSERTION_INCLUDE_DEPTH = 3;
 var PROMPT_FILE_PREFIX = "file://";
 function normalizeEvaluatorType(type) {
   return type.replace(/_/g, "-");
@@ -15603,7 +15531,79 @@ async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId
   const evaluators = [...parsedCase ?? [], ...parsedRoot ?? []];
   return evaluators.length > 0 ? evaluators : void 0;
 }
-async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId, defaultPreprocessors) {
+function isIncludeEntry(value) {
+  return isJsonObject2(value) && typeof value.include === "string" && Object.keys(value).length === 1;
+}
+function isTemplateReference(value) {
+  return !value.startsWith(".") && !value.includes("/") && !value.includes("\\");
+}
+async function resolveAssertionTemplateReference(include, searchRoots) {
+  const templateCandidates = isTemplateReference(include) ? [
+    path5.join(".agentv", "templates", `${include}.yaml`),
+    path5.join(".agentv", "templates", `${include}.yml`)
+  ] : [include];
+  const attempted = [];
+  for (const candidate of templateCandidates) {
+    const resolved = await resolveFileReference22(candidate, searchRoots);
+    attempted.push(...resolved.attempted);
+    if (resolved.resolvedPath) {
+      return {
+        displayPath: resolved.displayPath,
+        resolvedPath: resolved.resolvedPath,
+        attempted
+      };
+    }
+  }
+  return {
+    displayPath: templateCandidates[0] ?? include,
+    resolvedPath: "",
+    attempted
+  };
+}
+async function loadAssertionTemplateEntries(include, searchRoots, evalId, includeContext) {
+  const nextDepth = includeContext.depth + 1;
+  if (nextDepth > MAX_ASSERTION_INCLUDE_DEPTH) {
+    const chain = [...includeContext.chain, include].join(" -> ");
+    throw new Error(
+      `Assertion template include depth exceeded ${MAX_ASSERTION_INCLUDE_DEPTH} in '${evalId}'. Include chain: ${chain}`
+    );
+  }
+  const resolved = await resolveAssertionTemplateReference(include, searchRoots);
+  if (!resolved.resolvedPath) {
+    const attempted = resolved.attempted.length > 0 ? `
+${resolved.attempted.map((attempt) => `  Tried: ${attempt}`).join("\n")}` : "";
+    throw new Error(
+      `Assertion template not found in '${evalId}': ${resolved.displayPath}${attempted}`
+    );
+  }
+  if (includeContext.chain.includes(resolved.resolvedPath)) {
+    const cycle = [...includeContext.chain, resolved.resolvedPath].join(" -> ");
+    throw new Error(`Assertion template cycle detected in '${evalId}': ${cycle}`);
+  }
+  const content = await readFile5(resolved.resolvedPath, "utf8");
+  const parsed = interpolateEnv(parse2(content), process.env);
+  if (!isJsonObject2(parsed)) {
+    throw new Error(
+      `Invalid assertion template file in '${evalId}': ${resolved.resolvedPath} (expected a YAML object with an assertions array)`
+    );
+  }
+  const assertions = parsed.assertions;
+  if (!Array.isArray(assertions)) {
+    throw new Error(
+      `Invalid assertion template file in '${evalId}': ${resolved.resolvedPath} is missing a top-level assertions array`
+    );
+  }
+  const templateDir = path5.dirname(resolved.resolvedPath);
+  const nestedSearchRoots = [
+    templateDir,
+    ...searchRoots.filter((root) => path5.resolve(root) !== templateDir)
+  ];
+  return await expandEvaluatorEntries(assertions, nestedSearchRoots, evalId, {
+    depth: nextDepth,
+    chain: [...includeContext.chain, resolved.resolvedPath]
+  }) ?? [];
+}
+async function expandEvaluatorEntries(candidateEvaluators, searchRoots, evalId, includeContext = { depth: 0, chain: [] }) {
   if (candidateEvaluators === void 0) {
     return void 0;
   }
@@ -15611,13 +15611,34 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId, defa
     logWarning2(`Skipping evaluators for '${evalId}': expected array`);
     return void 0;
   }
-  const firstStringIndex = candidateEvaluators.findIndex((e) => typeof e === "string");
-  const processedEvaluators = firstStringIndex === -1 ? [...candidateEvaluators] : (() => {
+  const expanded = [];
+  for (const rawEvaluator of candidateEvaluators) {
+    if (isIncludeEntry(rawEvaluator)) {
+      const included = await loadAssertionTemplateEntries(
+        rawEvaluator.include,
+        searchRoots,
+        evalId,
+        includeContext
+      );
+      expanded.push(...included);
+      continue;
+    }
+    expanded.push(rawEvaluator);
+  }
+  return expanded;
+}
+async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId, defaultPreprocessors) {
+  const expandedEvaluators = await expandEvaluatorEntries(candidateEvaluators, searchRoots, evalId);
+  if (!expandedEvaluators) {
+    return void 0;
+  }
+  const firstStringIndex = expandedEvaluators.findIndex((e) => typeof e === "string");
+  const processedEvaluators = firstStringIndex === -1 ? [...expandedEvaluators] : (() => {
     const PLACEHOLDER = Symbol("rubric-placeholder");
     const strings = [];
     const result = [];
     let rubricInserted = false;
-    for (const item of candidateEvaluators) {
+    for (const item of expandedEvaluators) {
       if (typeof item === "string") {
         const trimmed = item.trim();
         if (trimmed.length === 0) {
@@ -15832,8 +15853,16 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId, defa
         );
         continue;
       }
+      const expandedMembers = await expandEvaluatorEntries(
+        rawMembers,
+        searchRoots,
+        `${evalId}:${name21}`
+      );
+      if (!expandedMembers) {
+        continue;
+      }
       const memberEvaluators = [];
-      for (const rawMember of rawMembers) {
+      for (const rawMember of expandedMembers) {
         if (!isJsonObject2(rawMember)) {
           logWarning2(`Skipping invalid member evaluator in composite '${name21}' (expected object)`);
           continue;
@@ -17268,7 +17297,7 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const fileContent = (await readFile5(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+          const fileContent = (await readFile6(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
           processedContent.push({
             ...cloneJsonObject(rawSegment),
             path: displayPath,
@@ -17309,7 +17338,7 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const imageBuffer = await readFile5(resolvedPath);
+          const imageBuffer = await readFile6(resolvedPath);
           const base64 = imageBuffer.toString("base64");
           processedContent.push({
             type: "image",
@@ -17386,7 +17415,7 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const fileContent = (await readFile5(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+            const fileContent = (await readFile6(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
             processedContent.push({
               type: "file",
               path: displayPath,
@@ -17426,7 +17455,7 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const imageBuffer = await readFile5(resolvedPath);
+            const imageBuffer = await readFile6(resolvedPath);
             const base64 = imageBuffer.toString("base64");
             processedContent.push({
               type: "image",
@@ -17550,7 +17579,7 @@ async function loadSidecarMetadata(jsonlPath, verbose) {
     return {};
   }
   try {
-    const content = await readFile6(sidecarPath, "utf8");
+    const content = await readFile7(sidecarPath, "utf8");
     const parsed = interpolateEnv(parseYaml2(content), process.env);
     if (!isJsonObject(parsed)) {
       logWarning4(`Invalid sidecar metadata format in ${sidecarPath}`);
@@ -17595,7 +17624,7 @@ async function loadTestsFromJsonl(evalFilePath, repoRoot, options) {
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
   const sidecar = await loadSidecarMetadata(absoluteTestPath, verbose);
-  const rawFile = await readFile6(absoluteTestPath, "utf8");
+  const rawFile = await readFile7(absoluteTestPath, "utf8");
   const rawCases = parseJsonlContent(rawFile, evalFilePath);
   const fallbackSuiteName = path7.basename(absoluteTestPath, ".jsonl") || "eval";
   const suiteName = sidecar.name && sidecar.name.trim().length > 0 ? sidecar.name : fallbackSuiteName;
@@ -17772,11 +17801,13 @@ function parseRepoCheckout(raw) {
   if (!isJsonObject(raw)) return void 0;
   const obj = raw;
   const ref = typeof obj.ref === "string" ? obj.ref : void 0;
+  const baseCommit = typeof obj.base_commit === "string" ? obj.base_commit : void 0;
   const resolve2 = obj.resolve === "remote" || obj.resolve === "local" ? obj.resolve : void 0;
   const ancestor = typeof obj.ancestor === "number" ? obj.ancestor : void 0;
-  if (!ref && !resolve2 && ancestor === void 0) return void 0;
+  if (!ref && !baseCommit && !resolve2 && ancestor === void 0) return void 0;
   return {
     ...ref !== void 0 && { ref },
+    ...baseCommit !== void 0 && { base_commit: baseCommit },
     ...resolve2 !== void 0 && { resolve: resolve2 },
     ...ancestor !== void 0 && { ancestor }
   };
@@ -17799,12 +17830,12 @@ function parseRepoConfig(raw) {
   const obj = raw;
   const repoPath = typeof obj.path === "string" ? obj.path : void 0;
   const source = parseRepoSource(obj.source);
-  if (!repoPath || !source) return void 0;
   const checkout = parseRepoCheckout(obj.checkout);
   const clone = parseRepoClone(obj.clone);
+  if (!repoPath && !source && !checkout && !clone) return void 0;
   return {
-    path: repoPath,
-    source,
+    ...repoPath !== void 0 && { path: repoPath },
+    ...source !== void 0 && { source },
     ...checkout !== void 0 && { checkout },
     ...clone !== void 0 && { clone }
   };
@@ -17853,7 +17884,8 @@ ${messageContent}`);
     segmentsByMessage,
     mode
   }) : void 0;
-  return { question, chatPrompt };
+  const systemMessage = extractSystemMessage(testCase.input, segmentsByMessage, mode);
+  return { question, chatPrompt, systemMessage };
 }
 function needsRoleMarkers(messages, processedSegmentsByMessage) {
   if (messages.some((msg) => msg.role === "assistant" || msg.role === "tool")) {
@@ -17867,6 +17899,26 @@ function needsRoleMarkers(messages, processedSegmentsByMessage) {
   }
   return messagesWithContent > 1;
 }
+function extractSystemMessage(messages, segmentsByMessage, mode) {
+  const systemParts = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role !== "system") {
+      break;
+    }
+    const segments = segmentsByMessage[i];
+    const contentParts = [];
+    for (const segment of segments) {
+      const formatted = formatSegment(segment, mode);
+      if (formatted) {
+        contentParts.push(formatted);
+      }
+    }
+    if (contentParts.length > 0) {
+      systemParts.push(contentParts.join("\n"));
+    }
+  }
+  return systemParts.length > 0 ? systemParts.join("\n\n") : void 0;
+}
 function buildChatPromptFromSegments(options) {
   const { messages, segmentsByMessage, systemPrompt, mode = "lm" } = options;
   if (messages.length === 0) {
@@ -17948,8 +18000,8 @@ function resolveTests(suite) {
 async function readTestSuiteMetadata(testFilePath) {
   try {
     const absolutePath = path8.resolve(testFilePath);
-    const content = await readFile7(absolutePath, "utf8");
-    const parsed = interpolateEnv(parse2(content), process.env);
+    const content = await readFile8(absolutePath, "utf8");
+    const parsed = interpolateEnv(parse3(content), process.env);
     if (!isJsonObject(parsed)) {
       return {};
     }
@@ -18006,8 +18058,8 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
   const config = await loadConfig(absoluteTestPath, repoRootPath);
-  const rawFile = await readFile7(absoluteTestPath, "utf8");
-  const interpolated = interpolateEnv(parse2(rawFile), process.env);
+  const rawFile = await readFile8(absoluteTestPath, "utf8");
+  const interpolated = interpolateEnv(parse3(rawFile), process.env);
   if (!isJsonObject(interpolated)) {
     throw new Error(`Invalid test file format: ${evalFilePath}`);
   }
@@ -18148,7 +18200,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
     const testCase = {
       id,
       suite: suiteName,
-      category: options?.category,
+      category: suite.category ?? options?.category,
       conversation_id: conversationId,
       question,
       input: inputMessages,
@@ -18241,11 +18293,11 @@ async function resolveWorkspaceConfig(raw, evalFileDir) {
     const workspaceFilePath = path8.resolve(evalFileDir, raw);
     let content;
     try {
-      content = await readFile7(workspaceFilePath, "utf8");
+      content = await readFile8(workspaceFilePath, "utf8");
     } catch {
       throw new Error(`Workspace file not found: ${raw} (resolved to ${workspaceFilePath})`);
     }
-    const parsed = interpolateEnv(parse2(content), process.env);
+    const parsed = interpolateEnv(parse3(content), process.env);
     if (!isJsonObject(parsed)) {
       throw new Error(
         `Invalid workspace file format: ${workspaceFilePath} (expected a YAML object)`
@@ -18280,14 +18332,28 @@ function parseWorkspaceConfig(raw, evalFileDir) {
   const explicitMode = obj.mode === "pooled" || obj.mode === "temp" || obj.mode === "static" ? obj.mode : void 0;
   const workspacePath = typeof obj.path === "string" ? obj.path : void 0;
   const mode = explicitMode ?? (workspacePath ? "static" : void 0);
-  if (!template && !isolation && !repos && !hooks && !mode && !workspacePath) return void 0;
+  const docker = parseDockerWorkspaceConfig(obj.docker);
+  if (!template && !isolation && !repos && !hooks && !mode && !workspacePath && !docker)
+    return void 0;
   return {
     ...template !== void 0 && { template },
     ...isolation !== void 0 && { isolation },
     ...repos !== void 0 && { repos },
     ...hooks !== void 0 && { hooks },
     ...mode !== void 0 && { mode },
-    ...workspacePath !== void 0 && { path: workspacePath }
+    ...workspacePath !== void 0 && { path: workspacePath },
+    ...docker !== void 0 && { docker }
+  };
+}
+function parseDockerWorkspaceConfig(raw) {
+  if (!isJsonObject(raw)) return void 0;
+  const obj = raw;
+  if (typeof obj.image !== "string") return void 0;
+  return {
+    image: obj.image,
+    ...typeof obj.timeout === "number" && { timeout: obj.timeout },
+    ...typeof obj.memory === "string" && { memory: obj.memory },
+    ...typeof obj.cpus === "number" && { cpus: obj.cpus }
   };
 }
 function mergeWorkspaceConfigs(suiteLevel, caseLevel) {
@@ -18316,7 +18382,8 @@ function mergeWorkspaceConfigs(suiteLevel, caseLevel) {
     repos: caseLevel.repos ?? suiteLevel.repos,
     ...hasHooks && { hooks: mergedHooks },
     mode: caseLevel.mode ?? suiteLevel.mode,
-    path: caseLevel.path ?? suiteLevel.path
+    path: caseLevel.path ?? suiteLevel.path,
+    docker: caseLevel.docker ?? suiteLevel.docker
   };
 }
 function asString5(value) {
@@ -18578,7 +18645,7 @@ function transpileEvalYaml(suite, source = "EVAL.yaml") {
 }
 function transpileEvalYamlFile(evalYamlPath) {
   const content = readFileSync(evalYamlPath, "utf8");
-  const parsed = parse3(content);
+  const parsed = parse4(content);
   return transpileEvalYaml(parsed, path9.basename(evalYamlPath));
 }
 function getOutputFilenames(result) {
@@ -20994,7 +21061,7 @@ function subscribeToCopilotCliLogEntries(listener) {
   };
 }
 function resolvePlatformCliPath() {
-  const os3 = platform();
+  const os4 = platform();
   const cpu = arch();
   const platformMap = {
     linux: "linux",
@@ -21005,13 +21072,13 @@ function resolvePlatformCliPath() {
     x64: "x64",
     arm64: "arm64"
   };
-  const osPart = platformMap[os3];
+  const osPart = platformMap[os4];
   const archPart = archMap[cpu];
   if (!osPart || !archPart) {
     return void 0;
   }
   const packageName = `@github/copilot-${osPart}-${archPart}`;
-  const binaryName = os3 === "win32" ? "copilot.exe" : "copilot";
+  const binaryName = os4 === "win32" ? "copilot.exe" : "copilot";
   try {
     const resolved = import.meta.resolve(`${packageName}/package.json`);
     const packageJsonPath = resolved.startsWith("file:") ? fileURLToPath3(resolved) : resolved;
@@ -21667,7 +21734,7 @@ async function discoverCopilotSessions(opts) {
     const workspacePath = path17.join(sessionDir, "workspace.yaml");
     const eventsPath = path17.join(sessionDir, "events.jsonl");
     try {
-      const workspaceContent = await readFile8(workspacePath, "utf8");
+      const workspaceContent = await readFile9(workspacePath, "utf8");
       const workspace = parseYaml22(workspaceContent) ?? {};
       const cwd = String(workspace.cwd ?? "");
       let updatedAt;
@@ -21727,7 +21794,7 @@ var CopilotLogProvider = class {
     const eventsPath = path18.join(sessionDir, "events.jsonl");
     let eventsContent;
     try {
-      eventsContent = await readFile9(eventsPath, "utf8");
+      eventsContent = await readFile10(eventsPath, "utf8");
     } catch (err) {
       throw new Error(
         `Failed to read Copilot session transcript at ${eventsPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -23972,7 +24039,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     try {
-      const content = await readFile10(responseFileFinal, { encoding: "utf8" });
+      const content = await readFile11(responseFileFinal, { encoding: "utf8" });
       if (!silent) {
         process.stdout.write(`${content}
 `);
@@ -24029,7 +24096,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     const maxAttempts = 10;
     while (attempts < maxAttempts) {
       try {
-        const content = await readFile10(file, { encoding: "utf8" });
+        const content = await readFile11(file, { encoding: "utf8" });
         if (!silent) {
           process.stdout.write(`${content}
 `);
@@ -24310,7 +24377,7 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
     if (!stats.isFile()) {
       throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
     }
-    const templateText = await readFile11(workspaceSrc, "utf8");
+    const templateText = await readFile12(workspaceSrc, "utf8");
     workspaceContent = JSON.parse(templateText);
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
@@ -25202,8 +25269,8 @@ async function readTargetDefinitions(filePath) {
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await readFile12(absolutePath, "utf8");
-  const parsed = parse4(raw);
+  const raw = await readFile13(absolutePath, "utf8");
+  const parsed = parse5(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
   }
@@ -25625,6 +25692,16 @@ function toCamelCaseDeep(obj) {
   }
   return obj;
 }
+function getRepoCheckoutRef(checkout) {
+  return checkout?.base_commit ?? checkout?.ref ?? "HEAD";
+}
+function getRepoCheckoutTargets(repos) {
+  if (!repos) return [];
+  return repos.filter((repo) => repo.checkout?.base_commit || repo.checkout?.ref).map((repo) => ({
+    path: repo.path,
+    ref: getRepoCheckoutRef(repo.checkout)
+  }));
+}
 var FILE_BACKED_OUTPUT_THRESHOLD = 5e4;
 var DATA_URI_RE = /^data:([^;]+);base64,(.+)$/s;
 async function materializeContentForGrader(messages, getWorkDir) {
@@ -25758,13 +25835,31 @@ var CodeEvaluator = class {
     const workspaceEnv = context2.workspacePath ? { AGENTV_WORKSPACE_PATH: context2.workspacePath } : void 0;
     const env = proxyEnv || workspaceEnv ? { ...proxyEnv, ...workspaceEnv } : void 0;
     try {
-      const stdout = await executeScript(
-        this.command,
-        inputPayload,
-        this.agentTimeoutMs,
-        this.cwd,
-        env
-      );
+      let stdout;
+      if (context2.dockerConfig) {
+        const { DockerWorkspaceProvider: DockerWorkspaceProvider2 } = await import("./docker-workspace-RPPXBT27-B4AQHVWA.js");
+        const dockerProvider = new DockerWorkspaceProvider2(context2.dockerConfig);
+        const result = await dockerProvider.runGraderInContainer({
+          command: [...this.command],
+          stdin: inputPayload,
+          repoCheckouts: getRepoCheckoutTargets(context2.evalCase.workspace?.repos)
+        });
+        if (result.exitCode !== 0) {
+          const trimmedErr = result.stderr.trim();
+          throw new Error(
+            trimmedErr.length > 0 ? `Code evaluator exited with code ${result.exitCode}: ${trimmedErr}` : `Code evaluator exited with code ${result.exitCode}`
+          );
+        }
+        stdout = result.stdout.trim();
+      } else {
+        stdout = await executeScript(
+          this.command,
+          inputPayload,
+          this.agentTimeoutMs,
+          this.cwd,
+          env
+        );
+      }
       const parsed = parseJsonSafe(stdout);
       const score = clampScore(typeof parsed?.score === "number" ? parsed.score : 0);
       const assertions = Array.isArray(parsed?.assertions) ? parsed.assertions.filter(
@@ -26916,11 +27011,11 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const stat11 = await fs2.stat(resolved);
-          if (stat11.isDirectory()) {
+          const stat12 = await fs2.stat(resolved);
+          if (stat12.isDirectory()) {
             return { error: `'${input.path}' is a directory, not a file` };
           }
-          const buffer = Buffer.alloc(Math.min(stat11.size, MAX_FILE_SIZE));
+          const buffer = Buffer.alloc(Math.min(stat12.size, MAX_FILE_SIZE));
           const fd = await fs2.open(resolved, "r");
           try {
             await fd.read(buffer, 0, buffer.length, 0);
@@ -26928,8 +27023,8 @@ function createFilesystemTools(workspacePath) {
             await fd.close();
           }
           const content = buffer.toString("utf-8");
-          const truncated = stat11.size > MAX_FILE_SIZE;
-          return { content, truncated, size: stat11.size };
+          const truncated = stat12.size > MAX_FILE_SIZE;
+          return { content, truncated, size: stat12.size };
         } catch (error) {
           return { error: error instanceof Error ? error.message : String(error) };
         }
@@ -26980,8 +27075,8 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
       const ext = path36.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
-        const stat11 = await fs2.stat(fullPath);
-        if (stat11.size > MAX_FILE_SIZE) continue;
+        const stat12 = await fs2.stat(fullPath);
+        if (stat12.size > MAX_FILE_SIZE) continue;
         const content = await fs2.readFile(fullPath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
@@ -27614,115 +27709,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path52, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path52);
-    const expectedValue = resolvePath(expectedData, path52);
+    const { path: path53, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path53);
+    const expectedValue = resolvePath(expectedData, path53);
     if (expectedValue === void 0) {
       return {
-        path: path52,
+        path: path53,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path52}: no expected value`
+        message: `${path53}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path52,
+          path: path53,
           score: 0,
           weight,
           hit: false,
-          message: `${path52} (required, missing)`
+          message: `${path53} (required, missing)`
         };
       }
       return {
-        path: path52,
+        path: path53,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path52}: optional field missing`
+        message: `${path53}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path52, candidateValue, expectedValue, weight);
+        return this.compareExact(path53, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path52,
+          path53,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path52, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path53, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path52,
+          path: path53,
           score: 0,
           weight,
           hit: false,
-          message: `${path52}: unknown match type "${match}"`
+          message: `${path53}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path52, candidateValue, expectedValue, weight) {
+  compareExact(path53, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path52,
+        path: path53,
         score: 1,
         weight,
         hit: true,
-        message: path52
+        message: path53
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path52,
+        path: path53,
         score: 0,
         weight,
         hit: false,
-        message: `${path52} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path53} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path52,
+      path: path53,
       score: 0,
       weight,
       hit: false,
-      message: `${path52} (value mismatch)`
+      message: `${path53} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path52, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path53, 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: path52,
+        path: path53,
         score: 0,
         weight,
         hit: false,
-        message: `${path52} (non-numeric value)`
+        message: `${path53} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path52,
+        path: path53,
         score: 0,
         weight,
         hit: false,
-        message: `${path52} (invalid numeric value)`
+        message: `${path53} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -27735,61 +27830,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path52,
+        path: path53,
         score: 1,
         weight,
         hit: true,
-        message: `${path52} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path53} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path52,
+      path: path53,
       score: 0,
       weight,
       hit: false,
-      message: `${path52} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path53} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path52, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path53, 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: path52,
+        path: path53,
         score: 0,
         weight,
         hit: false,
-        message: `${path52} (unparseable candidate date)`
+        message: `${path53} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path52,
+        path: path53,
         score: 0,
         weight,
         hit: false,
-        message: `${path52} (unparseable expected date)`
+        message: `${path53} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path52,
+        path: path53,
         score: 1,
         weight,
         hit: true,
-        message: path52
+        message: path53
       };
     }
     return {
-      path: path52,
+      path: path53,
       score: 0,
       weight,
       hit: false,
-      message: `${path52} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path53} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -27822,11 +27917,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path52) {
-  if (!path52 || !obj) {
+function resolvePath(obj, path53) {
+  if (!path53 || !obj) {
     return void 0;
   }
-  const parts = path52.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path53.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -28308,8 +28403,8 @@ var TokenUsageEvaluator = class {
     };
   }
 };
-function getNestedValue(obj, path52) {
-  const parts = path52.split(".");
+function getNestedValue(obj, path53) {
+  const parts = path53.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -29155,6 +29250,15 @@ async function resolveCustomPrompt(promptConfig, context2, timeoutMs) {
   }
   return void 0;
 }
+function containsTemplateVariables(text2) {
+  const variablePattern = /\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g;
+  for (const match of text2.matchAll(variablePattern)) {
+    if (VALID_TEMPLATE_VARIABLES.has(match[1])) {
+      return true;
+    }
+  }
+  return false;
+}
 async function executePromptTemplate(script, context2, config, timeoutMs) {
   const payload = {
     criteria: context2.evalCase.criteria,
@@ -29225,9 +29329,20 @@ var llmGraderFactory = (config, context2) => {
         },
         agentTimeoutMs
       );
+      const isFromInlinePrompt = !c.resolvedPromptScript?.length && !c.resolvedPromptPath && !c.promptPath;
+      let evaluatorTemplateOverride;
+      let evalCase = evalContext.evalCase;
+      if (customPrompt) {
+        if (!isFromInlinePrompt || containsTemplateVariables(customPrompt)) {
+          evaluatorTemplateOverride = customPrompt;
+        } else {
+          evalCase = { ...evalCase, criteria: customPrompt };
+        }
+      }
       return evaluator.evaluate({
         ...evalContext,
-        evaluatorTemplateOverride: customPrompt,
+        evalCase,
+        evaluatorTemplateOverride,
         evaluator: c
       });
     }
@@ -29824,12 +29939,14 @@ async function git(args, opts) {
   return stdout.trim();
 }
 function normalizeRepoForFingerprint(repo) {
-  const source = repo.source.type === "git" ? { type: "git", url: repo.source.url.toLowerCase().replace(/\.git$/, "") } : { type: "local", path: repo.source.path };
-  const result = {
-    path: repo.path,
-    source,
-    ref: repo.checkout?.ref ?? "HEAD"
-  };
+  const result = {};
+  if (repo.path) {
+    result.path = repo.path;
+  }
+  if (repo.source) {
+    result.source = repo.source.type === "git" ? { type: "git", url: repo.source.url.toLowerCase().replace(/\.git$/, "") } : { type: "local", path: repo.source.path };
+  }
+  result.ref = getRepoCheckoutRef(repo.checkout);
   if (repo.clone?.depth !== void 0) {
     result.depth = repo.clone.depth;
   }
@@ -29843,7 +29960,7 @@ function normalizeRepoForFingerprint(repo) {
 }
 function computeWorkspaceFingerprint(repos) {
   const canonical = {
-    repos: [...repos].sort((a, b) => a.path.localeCompare(b.path)).map(normalizeRepoForFingerprint)
+    repos: [...repos].sort((a, b) => (a.path ?? "").localeCompare(b.path ?? "")).map(normalizeRepoForFingerprint)
   };
   return createHash("sha256").update(JSON.stringify(canonical)).digest("hex");
 }
@@ -29957,7 +30074,7 @@ var WorkspacePoolManager = class {
           throw err;
         }
         try {
-          const pidStr = await readFile13(lockPath, "utf-8");
+          const pidStr = await readFile14(lockPath, "utf-8");
           const pid = Number.parseInt(pidStr.trim(), 10);
           if (!Number.isNaN(pid)) {
             try {
@@ -29984,7 +30101,7 @@ var WorkspacePoolManager = class {
   async checkDrift(poolDir, fingerprint) {
     const metadataPath = path422.join(poolDir, "metadata.json");
     try {
-      const raw = await readFile13(metadataPath, "utf-8");
+      const raw = await readFile14(metadataPath, "utf-8");
       const metadata = JSON.parse(raw);
       return metadata.fingerprint !== fingerprint;
     } catch {
@@ -30009,7 +30126,7 @@ var WorkspacePoolManager = class {
         const lockPath = path422.join(poolDir, `${entry}.lock`);
         if (existsSync3(lockPath)) {
           try {
-            const pidStr = await readFile13(lockPath, "utf-8");
+            const pidStr = await readFile14(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
             if (!Number.isNaN(pid)) {
               try {
@@ -30037,6 +30154,7 @@ var WorkspacePoolManager = class {
    */
   async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
     for (const repo of repos) {
+      if (!repo.path || !repo.source) continue;
       const repoDir = path422.join(slotPath, repo.path);
       if (!existsSync3(repoDir)) {
         continue;
@@ -30044,7 +30162,7 @@ var WorkspacePoolManager = class {
       if (poolReset === "none") {
         continue;
       }
-      const ref = repo.checkout?.ref ?? "HEAD";
+      const ref = getRepoCheckoutRef(repo.checkout);
       const resolve2 = repo.checkout?.resolve ?? "remote";
       if (resolve2 === "remote") {
         const fetchArgs = ["fetch", "origin", ref];
@@ -30061,8 +30179,8 @@ var WorkspacePoolManager = class {
     }
     if (templatePath) {
       const repoDirNames = new Set(
-        repos.map((r) => {
-          const normalized = r.path.replace(/^\.\//, "");
+        repos.filter((r) => r.path).map((r) => {
+          const normalized = (r.path ?? "").replace(/^\.\//, "");
           return normalized.split("/")[0];
         })
       );
@@ -30111,17 +30229,17 @@ var RepoManager = class {
   static validateLocalPaths(repos) {
     const errors = [];
     for (const repo of repos) {
-      if (repo.source.type !== "local") continue;
+      if (!repo.source || repo.source.type !== "local") continue;
       const sourcePath = repo.source.path;
       if (!sourcePath || sourcePath.trim() === "") {
         errors.push({
-          repoPath: repo.path,
+          repoPath: repo.path ?? "(none)",
           resolvedSourcePath: sourcePath ?? "",
           reason: "empty_path"
         });
       } else if (!existsSync4(sourcePath)) {
         errors.push({
-          repoPath: repo.path,
+          repoPath: repo.path ?? "(none)",
           resolvedSourcePath: sourcePath,
           reason: "not_found"
         });
@@ -30168,6 +30286,12 @@ ${lines.join("\n")}`;
    * Handles checkout, ref resolution, ancestor walking, shallow clone, sparse checkout.
    */
   async materialize(repo, workspacePath) {
+    if (!repo.source || !repo.path) {
+      if (this.verbose) {
+        console.log(`[repo] materialize skip path=${repo.path ?? "(none)"} (no source or path)`);
+      }
+      return;
+    }
     const targetDir = path43.join(workspacePath, repo.path);
     const sourceUrl = getSourceUrl(repo.source);
     const startedAt = Date.now();
@@ -30191,7 +30315,7 @@ ${lines.join("\n")}`;
       await this.runGit(["sparse-checkout", "init", "--cone"], { cwd: targetDir });
       await this.runGit(["sparse-checkout", "set", ...repo.clone.sparse], { cwd: targetDir });
     }
-    const ref = repo.checkout?.ref ?? "HEAD";
+    const ref = getRepoCheckoutRef(repo.checkout);
     const resolve2 = repo.checkout?.resolve ?? "remote";
     let resolvedSha;
     if (resolve2 === "remote" && repo.source.type === "git") {
@@ -30243,22 +30367,26 @@ ${lines.join("\n")}`;
       );
     }
   }
-  /** Materialize all repos into the workspace. */
+  /** Materialize all repos into the workspace. Skips repos without source (Docker-only repos). */
   async materializeAll(repos, workspacePath) {
+    const materializableRepos = repos.filter((r) => r.source);
     if (this.verbose) {
-      console.log(`[repo] materializeAll count=${repos.length} workspace=${workspacePath}`);
+      console.log(
+        `[repo] materializeAll count=${materializableRepos.length} (${repos.length - materializableRepos.length} skipped, no source) workspace=${workspacePath}`
+      );
     }
-    for (const repo of repos) {
+    for (const repo of materializableRepos) {
       await this.materialize(repo, workspacePath);
     }
     if (this.verbose) {
       console.log("[repo] materializeAll complete");
     }
   }
-  /** Reset repos in workspace to their checkout state. */
+  /** Reset repos in workspace to their checkout state. Skips repos without path or source. */
   async reset(repos, workspacePath, reset) {
     const cleanFlag = reset === "strict" ? "-fdx" : "-fd";
     for (const repo of repos) {
+      if (!repo.path || !repo.source) continue;
       const targetDir = path43.join(workspacePath, repo.path);
       await this.runGit(["reset", "--hard", "HEAD"], { cwd: targetDir });
       await this.runGit(["clean", cleanFlag], { cwd: targetDir });
@@ -30574,7 +30702,8 @@ async function runEvaluation(options) {
   for (const ec of filteredEvalCases) {
     if (ec.workspace?.repos) {
       for (const repo of ec.workspace.repos) {
-        const key = `${repo.path}::${repo.source.type === "local" ? repo.source.path : ""}`;
+        if (!repo.source) continue;
+        const key = `${repo.path ?? ""}::${repo.source.type === "local" ? repo.source.path : ""}`;
         if (!allRepos.has(key)) {
           allRepos.set(key, repo);
         }
@@ -30587,7 +30716,7 @@ async function runEvaluation(options) {
       const message = RepoManager.formatValidationErrors(localPathErrors);
       console.warn(`Warning: ${message}`);
       const invalidLocalRepoPaths = new Set(localPathErrors.map((e) => e.repoPath));
-      if (suiteWorkspace?.repos?.some((r) => invalidLocalRepoPaths.has(r.path))) {
+      if (suiteWorkspace?.repos?.some((r) => r.path && invalidLocalRepoPaths.has(r.path))) {
         throw new Error(message);
       }
     }
@@ -30720,6 +30849,7 @@ async function runEvaluation(options) {
       try {
         if (needsPerRepoCheck) {
           for (const repo of suiteWorkspace.repos) {
+            if (!repo.path || !repo.source) continue;
             const targetDir = path45.join(sharedWorkspacePath, repo.path);
             if (existsSync5(targetDir)) {
               setupLog(`reusing existing repo at: ${targetDir}`);
@@ -30744,6 +30874,19 @@ async function runEvaluation(options) {
         throw new Error(`Failed to materialize repos: ${message}`);
       }
     }
+    const suiteDockerConfig = suiteWorkspace?.docker;
+    if (suiteDockerConfig) {
+      setupLog(`pulling Docker image: ${suiteDockerConfig.image}`);
+      const { DockerWorkspaceProvider: DockerWorkspaceProvider2 } = await import("./docker-workspace-RPPXBT27-B4AQHVWA.js");
+      const dockerSetup = new DockerWorkspaceProvider2(suiteDockerConfig);
+      if (!await dockerSetup.isDockerAvailable()) {
+        throw new Error(
+          "Docker workspace configured but Docker CLI is not available. Install Docker and ensure it is running."
+        );
+      }
+      await dockerSetup.pullImage();
+      setupLog("Docker image pull complete");
+    }
     const suiteHooksEnabled = hooksEnabled(suiteWorkspace);
     const suiteBeforeAllHook = suiteWorkspace?.hooks?.before_all;
     if (sharedWorkspacePath && suiteHooksEnabled && hasHookCommand(suiteBeforeAllHook)) {
@@ -31104,11 +31247,9 @@ async function runBatchEvaluation(options) {
     const promptInputs = promptInputsList[index];
     return {
       question: promptInputs.question,
+      systemPrompt: promptInputs.systemMessage,
       inputFiles: evalCase.file_paths,
-      evalCaseId: evalCase.id,
-      metadata: {
-        systemPrompt: promptInputs.systemMessage ?? ""
-      }
+      evalCaseId: evalCase.id
     };
   });
   const batchResponse = await provider.invokeBatch?.(batchRequests);
@@ -31639,6 +31780,7 @@ async function runEvalCase(options) {
       availableTargets,
       fileChanges,
       workspacePath,
+      dockerConfig: evalCase.workspace?.docker,
       verbose,
       threshold: evalCase.threshold ?? caseThreshold
     });
@@ -31832,6 +31974,7 @@ async function evaluateCandidate(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     threshold: evalThreshold
   } = options;
   const gradeTimestamp = nowFn();
@@ -31858,6 +32001,7 @@ async function evaluateCandidate(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     threshold: evalThreshold
   });
   const completedAt = nowFn();
@@ -31933,6 +32077,7 @@ async function runEvaluatorsForCase(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     threshold
   } = options;
   if (evalCase.assertions && evalCase.assertions.length > 0) {
@@ -31960,6 +32105,7 @@ async function runEvaluatorsForCase(options) {
       availableTargets,
       fileChanges,
       workspacePath,
+      dockerConfig,
       threshold
     });
   }
@@ -31989,6 +32135,7 @@ async function runEvaluatorsForCase(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     ...implicitEvaluator ? { evaluator: implicitEvaluator } : {}
   });
   return { score };
@@ -32027,7 +32174,8 @@ async function runEvaluatorList(options) {
     targetResolver,
     availableTargets,
     fileChanges,
-    workspacePath
+    workspacePath,
+    dockerConfig
   } = options;
   const scored = [];
   const scores = [];
@@ -32050,7 +32198,8 @@ async function runEvaluatorList(options) {
     targetResolver,
     availableTargets,
     fileChanges,
-    workspacePath
+    workspacePath,
+    dockerConfig
   };
   const evalFileDir = evalCase.file_paths[0] ? path45.dirname(evalCase.file_paths[0]) : process.cwd();
   const dispatchContext = {
@@ -32212,13 +32361,11 @@ async function invokeProvider(provider, options) {
     const braintrustSpanIds = streamCallbacks?.getActiveSpanIds?.() ?? void 0;
     return await provider.invoke({
       question: promptInputs.question,
+      systemPrompt: promptInputs.systemMessage,
       chatPrompt: promptInputs.chatPrompt,
       inputFiles: evalCase.file_paths,
       evalCaseId: evalCase.id,
       attempt,
-      metadata: {
-        systemPrompt: promptInputs.systemMessage ?? ""
-      },
       signal: controller.signal,
       cwd,
       workspaceFile,
@@ -32580,7 +32727,7 @@ async function discoverDefaultTarget(repoRoot) {
   return null;
 }
 async function loadEnvHierarchy(repoRoot, startPath) {
-  const { readFileSync: readFileSync4 } = await import("node:fs");
+  const { readFileSync: readFileSync5 } = await import("node:fs");
   const chain = buildDirectoryChain(startPath, repoRoot);
   const envFiles = [];
   for (const dir of chain) {
@@ -32589,7 +32736,7 @@ async function loadEnvHierarchy(repoRoot, startPath) {
   }
   for (let i = 0; i < envFiles.length; i++) {
     try {
-      const content = readFileSync4(envFiles[i], "utf8");
+      const content = readFileSync5(envFiles[i], "utf8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("#")) continue;
@@ -32658,12 +32805,12 @@ var CONFIG_FILE_NAMES = [
   ".agentv/config.js"
 ];
 async function loadTsConfig(projectRoot) {
-  const { existsSync: existsSync8 } = await import("node:fs");
+  const { existsSync: existsSync9 } = await import("node:fs");
   const { pathToFileURL: pathToFileURL2 } = await import("node:url");
   const { join: join2 } = await import("node:path");
   for (const fileName of CONFIG_FILE_NAMES) {
     const filePath = join2(projectRoot, fileName);
-    if (!existsSync8(filePath)) {
+    if (!existsSync9(filePath)) {
       continue;
     }
     try {
@@ -32771,7 +32918,7 @@ async function scanRepoDeps(evalFilePaths) {
     try {
       const repos = await extractReposFromEvalFile(filePath);
       for (const repo of repos) {
-        if (repo.source.type !== "git") continue;
+        if (!repo.source || repo.source.type !== "git") continue;
         const ref = repo.checkout?.ref;
         const key = `${normalizeGitUrl(repo.source.url)}\0${ref ?? ""}`;
         const existing = seen.get(key);
@@ -32799,8 +32946,8 @@ async function scanRepoDeps(evalFilePaths) {
   return { repos: [...seen.values()], errors };
 }
 async function extractReposFromEvalFile(filePath) {
-  const content = await readFile14(filePath, "utf8");
-  const parsed = interpolateEnv(parse5(content), process.env);
+  const content = await readFile15(filePath, "utf8");
+  const parsed = interpolateEnv(parse6(content), process.env);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
   const obj = parsed;
   const evalFileDir = path47.dirname(path47.resolve(filePath));
@@ -32820,8 +32967,8 @@ async function extractReposFromEvalFile(filePath) {
 async function extractReposFromWorkspaceRaw(raw, evalFileDir) {
   if (typeof raw === "string") {
     const workspaceFilePath = path47.resolve(evalFileDir, raw);
-    const content = await readFile14(workspaceFilePath, "utf8");
-    const parsed = interpolateEnv(parse5(content), process.env);
+    const content = await readFile15(workspaceFilePath, "utf8");
+    const parsed = interpolateEnv(parse6(content), process.env);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
     return extractReposFromObject(parsed);
   }
@@ -32855,7 +33002,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await readFile15(filePath, "utf8");
+      const data = await readFile16(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -32883,16 +33030,289 @@ function shouldSkipCacheForTemperature(targetConfig) {
   }
   return false;
 }
+var execFileAsync3 = promisify7(execFile3);
+function sanitizeRepoSlug(repo) {
+  return repo.trim().replace(/[^A-Za-z0-9._-]+/g, "-");
+}
+function withFriendlyGitHubAuthError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const lower = message.toLowerCase();
+  if (lower.includes("authentication failed") || lower.includes("could not read username") || lower.includes("permission denied") || lower.includes("not logged into any github hosts")) {
+    return new Error(`${message}. Run 'gh auth login' to authenticate.`);
+  }
+  return new Error(message);
+}
+function normalizeResultsExportConfig(config) {
+  return {
+    repo: config.repo.trim(),
+    path: config.path.trim().replace(/^\/+|\/+$/g, ""),
+    auto_push: config.auto_push === true,
+    branch_prefix: config.branch_prefix?.trim() || "eval-results"
+  };
+}
+function resolveResultsRepoUrl(repo) {
+  if (repo.includes("://") || repo.startsWith("git@")) {
+    return repo;
+  }
+  return `https://github.com/${repo}.git`;
+}
+function getResultsRepoCachePaths(repo) {
+  const rootDir = path49.join(getAgentvHome(), "cache", "results-repo", sanitizeRepoSlug(repo));
+  return {
+    rootDir,
+    repoDir: path49.join(rootDir, "repo"),
+    statusFile: path49.join(rootDir, "status.json")
+  };
+}
+function readPersistedStatus(statusFile) {
+  if (!existsSync7(statusFile)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync3(statusFile, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writePersistedStatus(statusFile, status) {
+  mkdirSync2(path49.dirname(statusFile), { recursive: true });
+  writeFileSync(statusFile, `${JSON.stringify(status, null, 2)}
+`, "utf8");
+}
+async function runCommand(executable, args, options) {
+  try {
+    const { stdout, stderr } = await execFileAsync3(executable, [...args], {
+      cwd: options?.cwd,
+      env: process.env
+    });
+    return { stdout, stderr };
+  } catch (error) {
+    if (options?.check === false && error && typeof error === "object") {
+      const execError = error;
+      return {
+        stdout: execError.stdout ?? "",
+        stderr: execError.stderr ?? ""
+      };
+    }
+    throw withFriendlyGitHubAuthError(error);
+  }
+}
+async function runGit(args, options) {
+  return runCommand("git", args, options);
+}
+async function runGh(args, options) {
+  return runCommand("gh", args, options);
+}
+async function resolveDefaultBranch(repoDir) {
+  try {
+    const { stdout } = await runGit(["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd: repoDir });
+    const ref = stdout.trim();
+    const prefix = "refs/remotes/origin/";
+    if (ref.startsWith(prefix)) {
+      return ref.slice(prefix.length);
+    }
+  } catch {
+  }
+  for (const candidate of ["main", "master"]) {
+    try {
+      await runGit(["rev-parse", "--verify", `origin/${candidate}`], { cwd: repoDir });
+      return candidate;
+    } catch {
+    }
+  }
+  return "main";
+}
+async function updateCacheRepo(repoDir, baseBranch) {
+  await runGit(["fetch", "origin", "--prune"], { cwd: repoDir });
+  await runGit(["checkout", baseBranch], { cwd: repoDir });
+  await runGit(["pull", "--ff-only", "origin", baseBranch], { cwd: repoDir });
+}
+function updateStatusFile(config, patch) {
+  const cachePaths = getResultsRepoCachePaths(config.repo);
+  const current = readPersistedStatus(cachePaths.statusFile);
+  writePersistedStatus(cachePaths.statusFile, {
+    ...current,
+    ...patch
+  });
+}
+async function ensureResultsRepoClone(config) {
+  const normalized = normalizeResultsExportConfig(config);
+  const cachePaths = getResultsRepoCachePaths(normalized.repo);
+  mkdirSync2(cachePaths.rootDir, { recursive: true });
+  if (!existsSync7(cachePaths.repoDir)) {
+    try {
+      await runGit([
+        "clone",
+        "--filter=blob:none",
+        resolveResultsRepoUrl(normalized.repo),
+        cachePaths.repoDir
+      ]);
+      return cachePaths.repoDir;
+    } catch (error) {
+      updateStatusFile(normalized, { last_error: withFriendlyGitHubAuthError(error).message });
+      throw withFriendlyGitHubAuthError(error);
+    }
+  }
+  if (!existsSync7(path49.join(cachePaths.repoDir, ".git"))) {
+    throw new Error(`Results repo cache is not a git repository: ${cachePaths.repoDir}`);
+  }
+  return cachePaths.repoDir;
+}
+function getResultsRepoStatus(config) {
+  if (!config) {
+    return {
+      configured: false,
+      available: false,
+      repo: "",
+      cache_dir: ""
+    };
+  }
+  const normalized = normalizeResultsExportConfig(config);
+  const cachePaths = getResultsRepoCachePaths(normalized.repo);
+  const persisted = readPersistedStatus(cachePaths.statusFile);
+  return {
+    configured: true,
+    available: existsSync7(cachePaths.repoDir),
+    repo: normalized.repo,
+    path: normalized.path,
+    auto_push: normalized.auto_push,
+    branch_prefix: normalized.branch_prefix,
+    cache_dir: cachePaths.repoDir,
+    last_synced_at: persisted.last_synced_at,
+    last_error: persisted.last_error
+  };
+}
+async function syncResultsRepo(config) {
+  const normalized = normalizeResultsExportConfig(config);
+  try {
+    const repoDir = await ensureResultsRepoClone(normalized);
+    const baseBranch = await resolveDefaultBranch(repoDir);
+    await updateCacheRepo(repoDir, baseBranch);
+    updateStatusFile(normalized, {
+      last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+      last_error: void 0
+    });
+  } catch (error) {
+    updateStatusFile(normalized, {
+      last_error: withFriendlyGitHubAuthError(error).message
+    });
+    throw withFriendlyGitHubAuthError(error);
+  }
+  return getResultsRepoStatus(normalized);
+}
+async function checkoutResultsRepoBranch(config, branchName) {
+  const normalized = normalizeResultsExportConfig(config);
+  const repoDir = await ensureResultsRepoClone(normalized);
+  const baseBranch = await resolveDefaultBranch(repoDir);
+  await updateCacheRepo(repoDir, baseBranch);
+  await runGit(["checkout", "-B", branchName, `origin/${baseBranch}`], { cwd: repoDir });
+  updateStatusFile(normalized, { last_error: void 0 });
+  return {
+    branchName,
+    baseBranch,
+    repoDir
+  };
+}
+async function prepareResultsRepoBranch(config, branchName) {
+  const normalized = normalizeResultsExportConfig(config);
+  const cloneDir = await ensureResultsRepoClone(normalized);
+  const baseBranch = await resolveDefaultBranch(cloneDir);
+  await updateCacheRepo(cloneDir, baseBranch);
+  const worktreeRoot = await mkdtemp3(path49.join(os3.tmpdir(), "agentv-results-repo-"));
+  const worktreeDir = path49.join(worktreeRoot, "repo");
+  await runGit(["worktree", "add", "-B", branchName, worktreeDir, `origin/${baseBranch}`], {
+    cwd: cloneDir
+  });
+  return {
+    branchName,
+    baseBranch,
+    repoDir: worktreeDir,
+    cleanup: async () => {
+      try {
+        await runGit(["worktree", "remove", "--force", worktreeDir], { cwd: cloneDir });
+      } finally {
+        await rm6(worktreeRoot, { recursive: true, force: true }).catch(() => void 0);
+      }
+    }
+  };
+}
+async function stageResultsArtifacts(params) {
+  rmSync(params.destinationDir, { recursive: true, force: true });
+  mkdirSync2(path49.dirname(params.destinationDir), { recursive: true });
+  await cp3(params.sourceDir, params.destinationDir, { recursive: true });
+}
+function resolveResultsRepoRunsDir(config) {
+  const normalized = normalizeResultsExportConfig(config);
+  return path49.join(
+    getResultsRepoCachePaths(normalized.repo).repoDir,
+    ...normalized.path.split("/")
+  );
+}
+async function directorySizeBytes(targetPath) {
+  const entry = await stat9(targetPath);
+  if (entry.isFile()) {
+    return entry.size;
+  }
+  let total = 0;
+  for (const child of await readdir8(targetPath, { withFileTypes: true })) {
+    total += await directorySizeBytes(path49.join(targetPath, child.name));
+  }
+  return total;
+}
+async function commitAndPushResultsBranch(params) {
+  await runGit(["add", "--all"], { cwd: params.repoDir });
+  const { stdout: diffStdout } = await runGit(["status", "--porcelain"], {
+    cwd: params.repoDir,
+    check: false
+  });
+  if (diffStdout.trim().length === 0) {
+    return false;
+  }
+  await runGit(["commit", "-m", params.commitMessage], { cwd: params.repoDir });
+  await runGit(["push", "-u", "origin", params.branchName], { cwd: params.repoDir });
+  return true;
+}
+async function pushResultsRepoBranch(config, branchName, cwd) {
+  const normalized = normalizeResultsExportConfig(config);
+  await runGit(["push", "-u", "origin", branchName], {
+    cwd: cwd ?? getResultsRepoCachePaths(normalized.repo).repoDir
+  });
+  updateStatusFile(normalized, {
+    last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+    last_error: void 0
+  });
+}
+async function createDraftResultsPr(params) {
+  const { stdout } = await runGh(
+    [
+      "pr",
+      "create",
+      "--draft",
+      "--repo",
+      params.repo,
+      "--base",
+      params.baseBranch,
+      "--head",
+      params.branchName,
+      "--title",
+      params.title,
+      "--body",
+      params.body
+    ],
+    { cwd: params.repoDir }
+  );
+  return stdout.trim();
+}
 function getProjectsRegistryPath() {
-  return path49.join(getAgentvHome(), "projects.yaml");
+  return path50.join(getAgentvHome(), "projects.yaml");
 }
 function loadProjectRegistry() {
   const registryPath = getProjectsRegistryPath();
-  if (!existsSync7(registryPath)) {
+  if (!existsSync8(registryPath)) {
     return { projects: [] };
   }
   try {
-    const raw = readFileSync3(registryPath, "utf-8");
+    const raw = readFileSync4(registryPath, "utf-8");
     const parsed = parseYaml3(raw);
     if (!parsed || !Array.isArray(parsed.projects)) {
       return { projects: [] };
@@ -32904,14 +33324,14 @@ function loadProjectRegistry() {
 }
 function saveProjectRegistry(registry) {
   const registryPath = getProjectsRegistryPath();
-  const dir = path49.dirname(registryPath);
-  if (!existsSync7(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  const dir = path50.dirname(registryPath);
+  if (!existsSync8(dir)) {
+    mkdirSync3(dir, { recursive: true });
   }
-  writeFileSync(registryPath, stringifyYaml(registry), "utf-8");
+  writeFileSync2(registryPath, stringifyYaml(registry), "utf-8");
 }
 function deriveProjectId(dirPath, existingIds) {
-  const base = path49.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const base = path50.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   let candidate = base || "project";
   let suffix = 2;
   while (existingIds.includes(candidate)) {
@@ -32921,11 +33341,11 @@ function deriveProjectId(dirPath, existingIds) {
   return candidate;
 }
 function addProject(projectPath) {
-  const absPath = path49.resolve(projectPath);
-  if (!existsSync7(absPath)) {
+  const absPath = path50.resolve(projectPath);
+  if (!existsSync8(absPath)) {
     throw new Error(`Directory not found: ${absPath}`);
   }
-  if (!existsSync7(path49.join(absPath, ".agentv"))) {
+  if (!existsSync8(path50.join(absPath, ".agentv"))) {
     throw new Error(`No .agentv/ directory found in ${absPath}. Run an evaluation first.`);
   }
   const registry = loadProjectRegistry();
@@ -32939,7 +33359,7 @@ function addProject(projectPath) {
       absPath,
       registry.projects.map((p) => p.id)
     ),
-    name: path49.basename(absPath),
+    name: path50.basename(absPath),
     path: absPath,
     addedAt: now2,
     lastOpenedAt: now2
@@ -32968,14 +33388,14 @@ function touchProject(projectId) {
   }
 }
 function discoverProjects(rootDir, maxDepth = 2) {
-  const absRoot = path49.resolve(rootDir);
-  if (!existsSync7(absRoot) || !statSync2(absRoot).isDirectory()) {
+  const absRoot = path50.resolve(rootDir);
+  if (!existsSync8(absRoot) || !statSync2(absRoot).isDirectory()) {
     return [];
   }
   const results = [];
   function scan(dir, depth) {
     if (depth > maxDepth) return;
-    if (existsSync7(path49.join(dir, ".agentv"))) {
+    if (existsSync8(path50.join(dir, ".agentv"))) {
       results.push(dir);
       return;
     }
@@ -32985,7 +33405,7 @@ function discoverProjects(rootDir, maxDepth = 2) {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-        scan(path49.join(dir, entry.name), depth + 1);
+        scan(path50.join(dir, entry.name), depth + 1);
       }
     } catch {
     }
@@ -33089,8 +33509,8 @@ var OtelTraceExporter = class {
   async init() {
     try {
       const [sdkTraceNode, resourcesMod, semconvMod, api, coreMod] = await Promise.all([
-        import("./src-ML4D2MC2.js"),
-        import("./esm-CZAWIY6F.js"),
+        import("./src-PXDA7QIS.js"),
+        import("./esm-UYZ3HJBU.js"),
         import("./esm-RVQPUGWH.js"),
         import("./esm-R77SNOF5.js"),
         import("./esm-ZADQ4XQH-5LX2IKZV.js").catch(() => null)
@@ -33884,30 +34304,30 @@ function extractResponseItemContent(content) {
   }
   return parts.length > 0 ? parts.join("") : void 0;
 }
-var DEFAULT_SESSIONS_DIR = () => path50.join(homedir3(), ".codex", "sessions");
+var DEFAULT_SESSIONS_DIR = () => path51.join(homedir3(), ".codex", "sessions");
 async function discoverCodexSessions(opts) {
   const sessionsDir = opts?.sessionsDir ?? DEFAULT_SESSIONS_DIR();
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
   const sessions = [];
   let yearDirs;
   try {
-    yearDirs = await readdir8(sessionsDir);
+    yearDirs = await readdir9(sessionsDir);
   } catch {
     return [];
   }
   for (const year of yearDirs) {
-    const yearPath = path50.join(sessionsDir, year);
+    const yearPath = path51.join(sessionsDir, year);
     let monthDirs;
     try {
-      monthDirs = await readdir8(yearPath);
+      monthDirs = await readdir9(yearPath);
     } catch {
       continue;
     }
     for (const month of monthDirs) {
-      const monthPath = path50.join(yearPath, month);
+      const monthPath = path51.join(yearPath, month);
       let dayDirs;
       try {
-        dayDirs = await readdir8(monthPath);
+        dayDirs = await readdir9(monthPath);
       } catch {
         continue;
       }
@@ -33916,22 +34336,22 @@ async function discoverCodexSessions(opts) {
           const dirDate = `${year}-${month}-${day}`;
           if (dirDate !== opts.date) continue;
         }
-        const dayPath = path50.join(monthPath, day);
+        const dayPath = path51.join(monthPath, day);
         let files;
         try {
-          files = await readdir8(dayPath);
+          files = await readdir9(dayPath);
         } catch {
           continue;
         }
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = path50.join(dayPath, file);
+          const filePath = path51.join(dayPath, file);
           const nameWithoutExt = file.replace(/\.jsonl$/, "");
           const parts = nameWithoutExt.split("-");
           const sessionId = parts.length >= 6 ? parts.slice(-5).join("-") : nameWithoutExt;
           let updatedAt;
           try {
-            const fileStat = await stat9(filePath);
+            const fileStat = await stat10(filePath);
             updatedAt = fileStat.mtime;
           } catch {
             updatedAt = /* @__PURE__ */ new Date(0);
@@ -33944,7 +34364,7 @@ async function discoverCodexSessions(opts) {
   sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
   return sessions.slice(0, limit);
 }
-var DEFAULT_PROJECTS_DIR = () => path51.join(homedir4(), ".claude", "projects");
+var DEFAULT_PROJECTS_DIR = () => path52.join(homedir4(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -33953,7 +34373,7 @@ async function discoverClaudeSessions(opts) {
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
   let projectDirs;
   try {
-    projectDirs = await readdir9(projectsDir);
+    projectDirs = await readdir10(projectsDir);
   } catch {
     return [];
   }
@@ -33963,10 +34383,10 @@ async function discoverClaudeSessions(opts) {
   }
   const sessions = [];
   for (const projectDir of projectDirs) {
-    const dirPath = path51.join(projectsDir, projectDir);
+    const dirPath = path52.join(projectsDir, projectDir);
     let entries;
     try {
-      entries = await readdir9(dirPath);
+      entries = await readdir10(dirPath);
     } catch {
       continue;
     }
@@ -33974,10 +34394,10 @@ async function discoverClaudeSessions(opts) {
       if (!entry.endsWith(".jsonl")) continue;
       const sessionId = entry.replace(/\.jsonl$/, "");
       if (opts?.sessionId && sessionId !== opts.sessionId) continue;
-      const filePath = path51.join(dirPath, entry);
+      const filePath = path52.join(dirPath, entry);
       let updatedAt;
       try {
-        const fileStat = await stat10(filePath);
+        const fileStat = await stat11(filePath);
         updatedAt = fileStat.mtime;
       } catch {
         updatedAt = /* @__PURE__ */ new Date(0);
@@ -34018,11 +34438,11 @@ function toTranscriptJsonLine(entry) {
   };
 }
 async function readTranscriptJsonl(filePath) {
-  const text2 = await readFile16(filePath, "utf8");
+  const text2 = await readFile17(filePath, "utf8");
   return text2.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
 }
 async function readTranscriptFile(filePath) {
-  return readFile16(filePath, "utf8");
+  return readFile17(filePath, "utf8");
 }
 var TranscriptProvider = class _TranscriptProvider {
   id;
@@ -34229,6 +34649,20 @@ export {
   ResponseCache,
   shouldEnableCache,
   shouldSkipCacheForTemperature,
+  normalizeResultsExportConfig,
+  resolveResultsRepoUrl,
+  getResultsRepoCachePaths,
+  ensureResultsRepoClone,
+  getResultsRepoStatus,
+  syncResultsRepo,
+  checkoutResultsRepoBranch,
+  prepareResultsRepoBranch,
+  stageResultsArtifacts,
+  resolveResultsRepoRunsDir,
+  directorySizeBytes,
+  commitAndPushResultsBranch,
+  pushResultsRepoBranch,
+  createDraftResultsPr,
   getProjectsRegistryPath,
   loadProjectRegistry,
   saveProjectRegistry,
@@ -34254,4 +34688,4 @@ export {
   TranscriptProvider,
   createAgentKernel
 };
-//# sourceMappingURL=chunk-SE73HJZG.js.map
+//# sourceMappingURL=chunk-FQGY6QXQ.js.map