@agentv/core 4.10.0 → 4.11.0

package/dist/index.js

@@ -25,10 +25,17 @@ import {
   resolveDelegatedTargetDefinition,
   resolveFileReference,
   resolveTargetDefinition
-} from "./chunk-BWHUWLGW.js";
+} from "./chunk-5POFMJJ7.js";
+import {
+  execFileWithStdin,
+  execShellWithStdin
+} from "./chunk-3WGHC7LC.js";
 import {
   AgentvProvider
 } from "./chunk-PRNXHNLF.js";
+import {
+  DockerWorkspaceProvider
+} from "./chunk-SDIANPEY.js";
 import {
   OtlpJsonFileExporter
 } from "./chunk-KPSI5CSL.js";
@@ -152,10 +159,10 @@ function mergeExecutionMetrics(computed, metrics) {
 }
 
 // src/evaluation/yaml-parser.ts
-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";
 
 // src/evaluation/input-message-utils.ts
 function flattenInputMessages(messages) {
@@ -441,10 +448,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(
@@ -679,163 +688,74 @@ function parseExecutionDefaults(raw, configPath) {
   }
   return Object.keys(result).length > 0 ? result : void 0;
 }
+function parseResultsConfig(raw, configPath) {
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    logWarning(`Invalid results in ${configPath}, expected object`);
+    return void 0;
+  }
+  const obj = raw;
+  const exportConfig = parseResultsExportConfig(obj.export, configPath);
+  if (!exportConfig) {
+    return void 0;
+  }
+  return { export: exportConfig };
+}
+function parseResultsExportConfig(raw, configPath) {
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  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;
+    }
+    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_YELLOW}Warning: ${message}${ANSI_RESET2}`);
 }
 
 // src/evaluation/loaders/evaluator-parser.ts
+import { readFile as readFile5 } from "node:fs/promises";
 import path5 from "node:path";
+import { parse as parse2 } from "yaml";
 
 // src/evaluation/content-preprocessor.ts
 import { readFile as readFile3 } from "node:fs/promises";
 import path4 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-
-// src/runtime/exec.ts
-function shellEscapePath(value) {
-  if (process.platform === "win32") {
-    return `"${value.replaceAll('"', '""')}"`;
-  }
-  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 Bun !== "undefined") {
-    return execFileWithStdinBun(argv, stdinPayload, options);
-  }
-  return execFileWithStdinNode(argv, stdinPayload, options);
-}
-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);
-    }
-  }
-}
-async function execFileWithStdinNode(argv, stdinPayload, options) {
-  const { spawn: spawn5 } = await import("node:child_process");
-  return new Promise((resolve, 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");
-      resolve({
-        stdout,
-        stderr,
-        exitCode: code ?? 0
-      });
-    });
-    if (child.stdin) {
-      child.stdin.write(stdinPayload);
-      child.stdin.end();
-    }
-  });
-}
-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((resolve, 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);
-        }
-        resolve(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 });
-  }
-}
-
-// src/evaluation/content-preprocessor.ts
 var MIME_TYPE_ALIASES = {
   csv: "text/csv",
   docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
@@ -1076,6 +996,7 @@ function validateTemplateVariables(content, source) {
 // src/evaluation/loaders/evaluator-parser.ts
 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, "-");
@@ -1108,7 +1029,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 resolveFileReference2(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;
   }
@@ -1116,13 +1109,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) {
@@ -1337,8 +1351,16 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId, defa
         );
         continue;
       }
+      const expandedMembers = await expandEvaluatorEntries(
+        rawMembers,
+        searchRoots,
+        `${evalId}:${name}`
+      );
+      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 '${name}' (expected object)`);
           continue;
@@ -2664,13 +2686,13 @@ function parseInlineRubrics(rawRubrics) {
 }
 
 // src/evaluation/loaders/jsonl-parser.ts
-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 parseYaml } from "yaml";
 
 // src/evaluation/loaders/message-processor.ts
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import path6 from "node:path";
 
 // src/evaluation/formatting/segment-formatter.ts
@@ -2787,7 +2809,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,
@@ -2828,7 +2850,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",
@@ -2905,7 +2927,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,
@@ -2945,7 +2967,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",
@@ -3073,7 +3095,7 @@ async function loadSidecarMetadata(jsonlPath, verbose) {
     return {};
   }
   try {
-    const content = await readFile6(sidecarPath, "utf8");
+    const content = await readFile7(sidecarPath, "utf8");
     const parsed = interpolateEnv(parseYaml(content), process.env);
     if (!isJsonObject(parsed)) {
       logWarning4(`Invalid sidecar metadata format in ${sidecarPath}`);
@@ -3118,7 +3140,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;
@@ -3300,11 +3322,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 resolve = obj.resolve === "remote" || obj.resolve === "local" ? obj.resolve : void 0;
   const ancestor = typeof obj.ancestor === "number" ? obj.ancestor : void 0;
-  if (!ref && !resolve && ancestor === void 0) return void 0;
+  if (!ref && !baseCommit && !resolve && ancestor === void 0) return void 0;
   return {
     ...ref !== void 0 && { ref },
+    ...baseCommit !== void 0 && { base_commit: baseCommit },
     ...resolve !== void 0 && { resolve },
     ...ancestor !== void 0 && { ancestor }
   };
@@ -3327,12 +3351,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 }
   };
@@ -3383,7 +3407,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")) {
@@ -3397,6 +3422,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) {
@@ -3480,8 +3525,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 {};
     }
@@ -3538,8 +3583,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}`);
   }
@@ -3680,7 +3725,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,
@@ -3773,11 +3818,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)`
@@ -3812,14 +3857,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) {
@@ -3848,7 +3907,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) {
@@ -3876,7 +3936,7 @@ ${detailBlock}${ANSI_RESET7}`);
 // src/evaluation/loaders/eval-yaml-transpiler.ts
 import { readFileSync } from "node:fs";
 import path9 from "node:path";
-import { parse as parse3 } from "yaml";
+import { parse as parse4 } from "yaml";
 function codeGraderInstruction(graderName, description) {
   const desc = description ? ` This grader: ${description}.` : "";
   return `Run \`agentv eval assert ${graderName} --agent-output <agent_output> --agent-input <original_prompt>\` and check the result.${desc} The command accepts --agent-output (the agent's full response text) and --agent-input (the original user prompt). It returns JSON on stdout: {"score": 0-1, "reasoning": "..."}. A score >= 0.5 means pass (exit 0); below 0.5 means fail (exit 1).`;
@@ -4115,7 +4175,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) {
@@ -6596,7 +6656,7 @@ import { arch, platform } from "node:os";
 import path15 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolvePlatformCliPath() {
-  const os3 = platform();
+  const os4 = platform();
   const cpu = arch();
   const platformMap = {
     linux: "linux",
@@ -6607,13 +6667,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;
@@ -7130,7 +7190,7 @@ function summarizeAcpEvent(eventType, data) {
 }
 
 // src/evaluation/providers/copilot-log.ts
-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";
 
@@ -7264,7 +7324,7 @@ function parseCopilotEvents(eventsJsonl) {
 }
 
 // src/evaluation/providers/copilot-session-discovery.ts
-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 parseYaml2 } from "yaml";
@@ -7284,7 +7344,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 = parseYaml2(workspaceContent) ?? {};
       const cwd = String(workspace.cwd ?? "");
       let updatedAt;
@@ -7346,7 +7406,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)}`
@@ -9632,7 +9692,7 @@ function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateCont
 }
 
 // src/evaluation/providers/vscode/dispatch/responseWaiter.ts
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 import path26 from "node:path";
 
 // src/evaluation/providers/vscode/utils/time.ts
@@ -9671,7 +9731,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}
 `);
@@ -9728,7 +9788,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}
 `);
@@ -9913,7 +9973,7 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
 }
 
 // src/evaluation/providers/vscode/dispatch/workspaceManager.ts
-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";
 
 // src/evaluation/providers/vscode/utils/workspace.ts
@@ -10030,7 +10090,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;
@@ -10893,9 +10953,9 @@ total unlocked subagents available: ${result.created.length + result.skippedExis
 
 // src/evaluation/providers/targets-file.ts
 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";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -10938,8 +10998,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`);
   }
@@ -11381,6 +11441,18 @@ function toCamelCaseDeep(obj) {
   return obj;
 }
 
+// src/evaluation/workspace/repo-checkout.ts
+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)
+  }));
+}
+
 // src/evaluation/evaluators/code-evaluator.ts
 var FILE_BACKED_OUTPUT_THRESHOLD = 5e4;
 var DATA_URI_RE = /^data:([^;]+);base64,(.+)$/s;
@@ -11515,13 +11587,31 @@ var CodeEvaluator = class {
     const workspaceEnv = context.workspacePath ? { AGENTV_WORKSPACE_PATH: context.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 (context.dockerConfig) {
+        const { DockerWorkspaceProvider: DockerWorkspaceProvider2 } = await import("./docker-workspace-RPPXBT27.js");
+        const dockerProvider = new DockerWorkspaceProvider2(context.dockerConfig);
+        const result = await dockerProvider.runGraderInContainer({
+          command: [...this.command],
+          stdin: inputPayload,
+          repoCheckouts: getRepoCheckoutTargets(context.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(
@@ -12682,11 +12772,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);
@@ -12694,8 +12784,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) };
         }
@@ -12746,8 +12836,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++) {
@@ -13388,115 +13478,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);
@@ -13509,61 +13599,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)})`
     };
   }
   /**
@@ -13596,11 +13686,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) {
@@ -14092,8 +14182,8 @@ var TokenUsageEvaluator = class {
 };
 
 // src/evaluation/evaluators/tool-trajectory.ts
-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") {
@@ -14959,6 +15049,15 @@ async function resolveCustomPrompt(promptConfig, context, timeoutMs) {
   }
   return void 0;
 }
+function containsTemplateVariables(text) {
+  const variablePattern = /\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g;
+  for (const match of text.matchAll(variablePattern)) {
+    if (VALID_TEMPLATE_VARIABLES.has(match[1])) {
+      return true;
+    }
+  }
+  return false;
+}
 async function executePromptTemplate(script, context, config, timeoutMs) {
   const payload = {
     criteria: context.evalCase.criteria,
@@ -15031,9 +15130,20 @@ var llmGraderFactory = (config, context) => {
         },
         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
       });
     }
@@ -15630,7 +15740,7 @@ async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
 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 path42 from "node:path";
 import { promisify as promisify5 } from "node:util";
 var execFileAsync = promisify5(execFile);
@@ -15658,12 +15768,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;
   }
@@ -15677,7 +15789,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");
 }
@@ -15791,7 +15903,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 {
@@ -15818,7 +15930,7 @@ var WorkspacePoolManager = class {
   async checkDrift(poolDir, fingerprint) {
     const metadataPath = path42.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 {
@@ -15843,7 +15955,7 @@ var WorkspacePoolManager = class {
         const lockPath = path42.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 {
@@ -15871,6 +15983,7 @@ var WorkspacePoolManager = class {
    */
   async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
     for (const repo of repos) {
+      if (!repo.path || !repo.source) continue;
       const repoDir = path42.join(slotPath, repo.path);
       if (!existsSync3(repoDir)) {
         continue;
@@ -15878,7 +15991,7 @@ var WorkspacePoolManager = class {
       if (poolReset === "none") {
         continue;
       }
-      const ref = repo.checkout?.ref ?? "HEAD";
+      const ref = getRepoCheckoutRef(repo.checkout);
       const resolve = repo.checkout?.resolve ?? "remote";
       if (resolve === "remote") {
         const fetchArgs = ["fetch", "origin", ref];
@@ -15895,8 +16008,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];
         })
       );
@@ -15951,17 +16064,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"
         });
@@ -16008,6 +16121,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();
@@ -16031,7 +16150,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 resolve = repo.checkout?.resolve ?? "remote";
     let resolvedSha;
     if (resolve === "remote" && repo.source.type === "git") {
@@ -16083,22 +16202,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 });
@@ -16422,7 +16545,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);
         }
@@ -16435,7 +16559,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);
       }
     }
@@ -16568,6 +16692,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}`);
@@ -16592,6 +16717,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.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)) {
@@ -16952,11 +17090,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);
@@ -17487,6 +17623,7 @@ async function runEvalCase(options) {
       availableTargets,
       fileChanges,
       workspacePath,
+      dockerConfig: evalCase.workspace?.docker,
       verbose,
       threshold: evalCase.threshold ?? caseThreshold
     });
@@ -17680,6 +17817,7 @@ async function evaluateCandidate(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     threshold: evalThreshold
   } = options;
   const gradeTimestamp = nowFn();
@@ -17706,6 +17844,7 @@ async function evaluateCandidate(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     threshold: evalThreshold
   });
   const completedAt = nowFn();
@@ -17781,6 +17920,7 @@ async function runEvaluatorsForCase(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     threshold
   } = options;
   if (evalCase.assertions && evalCase.assertions.length > 0) {
@@ -17808,6 +17948,7 @@ async function runEvaluatorsForCase(options) {
       availableTargets,
       fileChanges,
       workspacePath,
+      dockerConfig,
       threshold
     });
   }
@@ -17837,6 +17978,7 @@ async function runEvaluatorsForCase(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     ...implicitEvaluator ? { evaluator: implicitEvaluator } : {}
   });
   return { score };
@@ -17875,7 +18017,8 @@ async function runEvaluatorList(options) {
     targetResolver,
     availableTargets,
     fileChanges,
-    workspacePath
+    workspacePath,
+    dockerConfig
   } = options;
   const scored = [];
   const scores = [];
@@ -17898,7 +18041,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 = {
@@ -18060,13 +18204,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,
@@ -18436,7 +18578,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) {
@@ -18445,7 +18587,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;
@@ -18517,12 +18659,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 {
@@ -18619,9 +18761,9 @@ function buildPrompt(criteria, question, referenceAnswer) {
 }
 
 // src/evaluation/workspace/deps-scanner.ts
-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 { parse as parse6 } from "yaml";
 function normalizeGitUrl(url) {
   let normalized = url.replace(/\.git$/, "");
   try {
@@ -18639,7 +18781,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);
@@ -18667,8 +18809,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));
@@ -18688,8 +18830,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);
   }
@@ -18716,7 +18858,7 @@ function extractReposFromObject(obj) {
 }
 
 // src/evaluation/cache/response-cache.ts
-import { mkdir as mkdir15, readFile as readFile15, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir15, readFile as readFile16, writeFile as writeFile8 } from "node:fs/promises";
 import path48 from "node:path";
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
@@ -18727,7 +18869,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;
@@ -18756,20 +18898,301 @@ function shouldSkipCacheForTemperature(targetConfig) {
   return false;
 }
 
-// src/projects.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync2, writeFileSync } from "node:fs";
+// src/evaluation/results-repo.ts
+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 { promisify as promisify7 } from "node:util";
+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();
+}
+
+// src/projects.ts
+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";
 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: [] };
@@ -18781,14 +19204,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)) {
@@ -18798,11 +19221,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();
@@ -18816,7 +19239,7 @@ function addProject(projectPath) {
       absPath,
       registry.projects.map((p) => p.id)
     ),
-    name: path49.basename(absPath),
+    name: path50.basename(absPath),
     path: absPath,
     addedAt: now,
     lastOpenedAt: now
@@ -18845,14 +19268,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;
     }
@@ -18862,7 +19285,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 {
     }
@@ -19773,33 +20196,33 @@ function extractResponseItemContent(content) {
 }
 
 // src/import/codex-session-discovery.ts
-import { readdir as readdir8, stat as stat9 } from "node:fs/promises";
+import { readdir as readdir9, stat as stat10 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import path50 from "node:path";
-var DEFAULT_SESSIONS_DIR = () => path50.join(homedir3(), ".codex", "sessions");
+import path51 from "node:path";
+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;
       }
@@ -19808,22 +20231,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);
@@ -19838,10 +20261,10 @@ async function discoverCodexSessions(opts) {
 }
 
 // src/import/session-discovery.ts
-import { readdir as readdir9, stat as stat10 } from "node:fs/promises";
+import { readdir as readdir10, stat as stat11 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import path51 from "node:path";
-var DEFAULT_PROJECTS_DIR = () => path51.join(homedir4(), ".claude", "projects");
+import path52 from "node:path";
+var DEFAULT_PROJECTS_DIR = () => path52.join(homedir4(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -19850,7 +20273,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 [];
   }
@@ -19860,10 +20283,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;
     }
@@ -19871,10 +20294,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);
@@ -19892,7 +20315,7 @@ async function discoverClaudeSessions(opts) {
 }
 
 // src/import/types.ts
-import { readFile as readFile16 } from "node:fs/promises";
+import { readFile as readFile17 } from "node:fs/promises";
 function toTranscriptJsonLine(entry) {
   const firstUserMessage = entry.messages.find((m) => m.role === "user");
   const input = typeof firstUserMessage?.content === "string" ? firstUserMessage.content : "";
@@ -19918,11 +20341,11 @@ function toTranscriptJsonLine(entry) {
   };
 }
 async function readTranscriptJsonl(filePath) {
-  const text = await readFile16(filePath, "utf8");
+  const text = await readFile17(filePath, "utf8");
   return text.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");
 }
 
 // src/import/transcript-provider.ts
@@ -19987,6 +20410,7 @@ export {
   DEFAULT_EXPLORATION_TOOLS,
   DEFAULT_THRESHOLD,
   DeterministicAssertionEvaluator,
+  DockerWorkspaceProvider,
   EvaluatorRegistry,
   ExecutionMetricsEvaluator,
   FieldAccuracyEvaluator,
@@ -20022,9 +20446,11 @@ export {
   buildSearchRoots,
   calculateRubricScore,
   captureFileChanges,
+  checkoutResultsRepoBranch,
   clampScore,
   cleanupEvalWorkspaces,
   cleanupWorkspace,
+  commitAndPushResultsBranch,
   computeTraceSummary,
   computeWorkspaceFingerprint,
   consumeClaudeLogEntries,
@@ -20035,6 +20461,7 @@ export {
   createAgentKernel,
   createBuiltinProviderRegistry,
   createBuiltinRegistry,
+  createDraftResultsPr,
   createProvider,
   createTempWorkspace,
   deepEqual,
@@ -20042,6 +20469,7 @@ export {
   deriveCategory,
   deriveProjectId,
   detectFormat,
+  directorySizeBytes,
   discoverAssertions,
   discoverClaudeSessions,
   discoverCodexSessions,
@@ -20050,6 +20478,7 @@ export {
   discoverGraders as discoverJudges,
   discoverProjects,
   discoverProviders,
+  ensureResultsRepoClone,
   ensureVSCodeSubagents,
   evaluate,
   executeScript,
@@ -20074,6 +20503,8 @@ export {
   getOutputFilenames,
   getProject,
   getProjectsRegistryPath,
+  getResultsRepoCachePaths,
+  getResultsRepoStatus,
   getSubagentsRoot,
   getTextContent,
   getTraceStateRoot,
@@ -20103,12 +20534,15 @@ export {
   mergeExecutionMetrics,
   negateScore,
   normalizeLineEndings,
+  normalizeResultsExportConfig,
   parseAgentSkillsEvals,
   parseClaudeSession,
   parseCodexSession,
   parseCopilotEvents,
   parseJsonFromText,
   parseJsonSafe,
+  prepareResultsRepoBranch,
+  pushResultsRepoBranch,
   readJsonFile,
   readTargetDefinitions,
   readTestSuiteMetadata,
@@ -20119,6 +20553,8 @@ export {
   resolveAndCreateProvider,
   resolveDelegatedTargetDefinition,
   resolveFileReference,
+  resolveResultsRepoRunsDir,
+  resolveResultsRepoUrl,
   resolveTargetDefinition,
   resolveWorkspaceTemplate,
   rubricEvaluationSchema,
@@ -20140,12 +20576,14 @@ export {
   scoreToVerdict,
   shouldEnableCache,
   shouldSkipCacheForTemperature,
+  stageResultsArtifacts,
   subscribeToClaudeLogEntries,
   subscribeToCodexLogEntries,
   subscribeToCopilotCliLogEntries,
   subscribeToCopilotSdkLogEntries,
   subscribeToPiLogEntries,
   substituteVariables,
+  syncResultsRepo,
   toCamelCaseDeep,
   toSnakeCaseDeep,
   toTranscriptJsonLine,