@agentv/core 4.10.0 → 4.11.0

package/dist/index.cjs

@@ -37,6 +37,161 @@ var init_cjs_shims = __esm({
   }
 });
 
+// src/runtime/exec.ts
+var exec_exports = {};
+__export(exec_exports, {
+  execFileWithStdin: () => execFileWithStdin,
+  execShellWithStdin: () => execShellWithStdin
+});
+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("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: mkdir17, readFile: readFile20, rm: rm7, writeFile: writeFile9 } = await import("fs/promises");
+  const { tmpdir: tmpdir3 } = await import("os");
+  const path56 = await import("path");
+  const { randomUUID: randomUUID10 } = await import("crypto");
+  const dir = path56.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
+  await mkdir17(dir, { recursive: true });
+  const stdinPath = path56.join(dir, "stdin.txt");
+  const stdoutPath = path56.join(dir, "stdout.txt");
+  const stderrPath = path56.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("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 readFile20(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
+    const stderr = (await readFile20(stderrPath, "utf8")).replace(/\r\n/g, "\n");
+    return { stdout, stderr, exitCode };
+  } finally {
+    await rm7(dir, { recursive: true, force: true });
+  }
+}
+var init_exec = __esm({
+  "src/runtime/exec.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
 // src/evaluation/providers/agentv-provider.ts
 var agentv_provider_exports = {};
 __export(agentv_provider_exports, {
@@ -109,6 +264,194 @@ var init_agentv_provider = __esm({
   }
 });
 
+// src/evaluation/workspace/docker-workspace.ts
+var docker_workspace_exports = {};
+__export(docker_workspace_exports, {
+  DefaultCommandExecutor: () => DefaultCommandExecutor,
+  DockerWorkspaceProvider: () => DockerWorkspaceProvider
+});
+function buildGitCommand(target, args) {
+  if (!target?.path) {
+    return ["git", ...args];
+  }
+  return ["git", "-C", target.path, ...args];
+}
+var DefaultCommandExecutor, DEFAULT_TIMEOUT_S, DockerWorkspaceProvider;
+var init_docker_workspace = __esm({
+  "src/evaluation/workspace/docker-workspace.ts"() {
+    "use strict";
+    init_cjs_shims();
+    DefaultCommandExecutor = class {
+      async exec(argv, options = {}) {
+        const { execFileWithStdin: execFileWithStdin2 } = await Promise.resolve().then(() => (init_exec(), exec_exports));
+        return execFileWithStdin2(argv, options.stdin ?? "", {
+          timeoutMs: options.timeoutMs
+        });
+      }
+    };
+    DEFAULT_TIMEOUT_S = 1800;
+    DockerWorkspaceProvider = class {
+      config;
+      executor;
+      timeoutMs;
+      constructor(config, executor) {
+        this.config = config;
+        this.executor = executor ?? new DefaultCommandExecutor();
+        this.timeoutMs = (config.timeout ?? DEFAULT_TIMEOUT_S) * 1e3;
+      }
+      /** Check whether the Docker CLI is available on the host. */
+      async isDockerAvailable() {
+        try {
+          const result = await this.executor.exec(
+            ["docker", "version", "--format", "{{.Server.Version}}"],
+            {
+              timeoutMs: 1e4
+            }
+          );
+          return result.exitCode === 0;
+        } catch {
+          return false;
+        }
+      }
+      /** Pull the configured Docker image. No-op if already cached locally. */
+      async pullImage() {
+        const inspectResult = await this.executor.exec(
+          ["docker", "image", "inspect", this.config.image],
+          {
+            timeoutMs: 1e4
+          }
+        );
+        if (inspectResult.exitCode === 0) {
+          return;
+        }
+        const result = await this.executor.exec(["docker", "pull", this.config.image], {
+          timeoutMs: this.timeoutMs
+        });
+        if (result.exitCode !== 0) {
+          throw new Error(`docker pull failed (exit ${result.exitCode}): ${result.stderr.trim()}`);
+        }
+      }
+      /** Create a stopped container from the configured image with resource limits. Returns container ID. */
+      async createContainer() {
+        const argv = ["docker", "create"];
+        if (this.config.memory) {
+          argv.push(`--memory=${this.config.memory}`);
+        }
+        if (this.config.cpus !== void 0) {
+          argv.push(`--cpus=${this.config.cpus}`);
+        }
+        argv.push(this.config.image, "sleep", "infinity");
+        const result = await this.executor.exec(argv, { timeoutMs: 3e4 });
+        if (result.exitCode !== 0) {
+          throw new Error(`docker create failed (exit ${result.exitCode}): ${result.stderr.trim()}`);
+        }
+        return result.stdout.trim();
+      }
+      /** Start a previously created container. */
+      async startContainer(containerId) {
+        const result = await this.executor.exec(["docker", "start", containerId], {
+          timeoutMs: 3e4
+        });
+        if (result.exitCode !== 0) {
+          throw new Error(`docker start failed (exit ${result.exitCode}): ${result.stderr.trim()}`);
+        }
+      }
+      /**
+       * Reset the container checkout to the specified target refs, if any.
+       * This is used for SWE-bench images where the repo state must match the
+       * dataset's base snapshot before grading begins.
+       */
+      async resetContainerCheckout(containerId, repoCheckouts) {
+        if (!repoCheckouts || repoCheckouts.length === 0) {
+          return;
+        }
+        for (const target of repoCheckouts) {
+          const resetResult = await this.execInContainer({
+            containerId,
+            command: buildGitCommand(target, ["reset", "--hard", target.ref])
+          });
+          if (resetResult.exitCode !== 0) {
+            throw new Error(
+              `docker git reset failed (exit ${resetResult.exitCode}): ${resetResult.stderr.trim()}`
+            );
+          }
+          const verifyResult = await this.execInContainer({
+            containerId,
+            command: buildGitCommand(target, ["rev-parse", "HEAD"]),
+            timeoutMs: 3e4
+          });
+          if (verifyResult.exitCode !== 0) {
+            throw new Error(
+              `docker checkout verification failed (exit ${verifyResult.exitCode}): ${verifyResult.stderr.trim()}`
+            );
+          }
+          const head = verifyResult.stdout.trim();
+          if (head !== target.ref) {
+            throw new Error(
+              `docker checkout verification failed: expected ${target.ref} but found ${head || "<empty>"}`
+            );
+          }
+        }
+      }
+      /** Copy a local file or directory into a running container. */
+      async copyToContainer(containerId, localPath, containerPath) {
+        const result = await this.executor.exec(
+          ["docker", "cp", localPath, `${containerId}:${containerPath}`],
+          { timeoutMs: 6e4 }
+        );
+        if (result.exitCode !== 0) {
+          throw new Error(`docker cp failed (exit ${result.exitCode}): ${result.stderr.trim()}`);
+        }
+      }
+      /**
+       * Execute a command inside a running container.
+       * If stdin is provided, it is piped via `docker exec -i`.
+       */
+      async execInContainer(options) {
+        const { containerId, command, timeoutMs, stdin } = options;
+        const argv = ["docker", "exec"];
+        if (stdin !== void 0) {
+          argv.push("-i");
+        }
+        argv.push(containerId, ...command);
+        return this.executor.exec(argv, {
+          timeoutMs: timeoutMs ?? this.timeoutMs,
+          stdin
+        });
+      }
+      /** Force-remove a container (always succeeds, even if container doesn't exist). */
+      async removeContainer(containerId) {
+        try {
+          await this.executor.exec(["docker", "rm", "-f", containerId], {
+            timeoutMs: 3e4
+          });
+        } catch {
+        }
+      }
+      /** Full lifecycle: create → start → exec → cleanup. Convenience for single-command grading. */
+      async runGraderInContainer(options) {
+        const containerId = await this.createContainer();
+        try {
+          await this.startContainer(containerId);
+          await this.resetContainerCheckout(containerId, options.repoCheckouts);
+          if (options.copyFiles) {
+            for (const file of options.copyFiles) {
+              await this.copyToContainer(containerId, file.localPath, file.containerPath);
+            }
+          }
+          return await this.execInContainer({
+            containerId,
+            command: options.command,
+            stdin: options.stdin
+          });
+        } finally {
+          await this.removeContainer(containerId);
+        }
+      }
+    };
+  }
+});
+
 // ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
 function suppressTracing(context2) {
   return context2.setValue(SUPPRESS_TRACING_KEY, true);
@@ -1355,13 +1698,13 @@ function serializeAttributeValue(value) {
   if (Array.isArray(value)) return { arrayValue: { values: value.map(serializeAttributeValue) } };
   return { stringValue: String(value) };
 }
-var import_promises37, import_node_path54, OtlpJsonFileExporter;
+var import_promises39, import_node_path55, OtlpJsonFileExporter;
 var init_otlp_json_file_exporter = __esm({
   "src/observability/otlp-json-file-exporter.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises37 = require("fs/promises");
-    import_node_path54 = require("path");
+    import_promises39 = require("fs/promises");
+    import_node_path55 = require("path");
     OtlpJsonFileExporter = class {
       // biome-ignore lint/suspicious/noExplicitAny: serialized span data
       spans = [];
@@ -1400,7 +1743,7 @@ var init_otlp_json_file_exporter = __esm({
       }
       async flush() {
         if (this.spans.length === 0) return;
-        await (0, import_promises37.mkdir)((0, import_node_path54.dirname)(this.filePath), { recursive: true });
+        await (0, import_promises39.mkdir)((0, import_node_path55.dirname)(this.filePath), { recursive: true });
         const otlpJson = {
           resourceSpans: [
             {
@@ -1434,6 +1777,7 @@ __export(index_exports, {
   DEFAULT_EXPLORATION_TOOLS: () => DEFAULT_EXPLORATION_TOOLS,
   DEFAULT_THRESHOLD: () => DEFAULT_THRESHOLD,
   DeterministicAssertionEvaluator: () => DeterministicAssertionEvaluator,
+  DockerWorkspaceProvider: () => DockerWorkspaceProvider,
   EvaluatorRegistry: () => EvaluatorRegistry,
   ExecutionMetricsEvaluator: () => ExecutionMetricsEvaluator,
   FieldAccuracyEvaluator: () => FieldAccuracyEvaluator,
@@ -1469,9 +1813,11 @@ __export(index_exports, {
   buildSearchRoots: () => buildSearchRoots2,
   calculateRubricScore: () => calculateRubricScore,
   captureFileChanges: () => captureFileChanges,
+  checkoutResultsRepoBranch: () => checkoutResultsRepoBranch,
   clampScore: () => clampScore,
   cleanupEvalWorkspaces: () => cleanupEvalWorkspaces,
   cleanupWorkspace: () => cleanupWorkspace,
+  commitAndPushResultsBranch: () => commitAndPushResultsBranch,
   computeTraceSummary: () => computeTraceSummary,
   computeWorkspaceFingerprint: () => computeWorkspaceFingerprint,
   consumeClaudeLogEntries: () => consumeClaudeLogEntries,
@@ -1482,6 +1828,7 @@ __export(index_exports, {
   createAgentKernel: () => createAgentKernel,
   createBuiltinProviderRegistry: () => createBuiltinProviderRegistry,
   createBuiltinRegistry: () => createBuiltinRegistry,
+  createDraftResultsPr: () => createDraftResultsPr,
   createProvider: () => createProvider,
   createTempWorkspace: () => createTempWorkspace,
   deepEqual: () => deepEqual,
@@ -1489,6 +1836,7 @@ __export(index_exports, {
   deriveCategory: () => deriveCategory,
   deriveProjectId: () => deriveProjectId,
   detectFormat: () => detectFormat,
+  directorySizeBytes: () => directorySizeBytes,
   discoverAssertions: () => discoverAssertions,
   discoverClaudeSessions: () => discoverClaudeSessions,
   discoverCodexSessions: () => discoverCodexSessions,
@@ -1497,6 +1845,7 @@ __export(index_exports, {
   discoverJudges: () => discoverGraders,
   discoverProjects: () => discoverProjects,
   discoverProviders: () => discoverProviders,
+  ensureResultsRepoClone: () => ensureResultsRepoClone,
   ensureVSCodeSubagents: () => ensureVSCodeSubagents,
   evaluate: () => evaluate,
   executeScript: () => executeScript,
@@ -1521,6 +1870,8 @@ __export(index_exports, {
   getOutputFilenames: () => getOutputFilenames,
   getProject: () => getProject,
   getProjectsRegistryPath: () => getProjectsRegistryPath,
+  getResultsRepoCachePaths: () => getResultsRepoCachePaths,
+  getResultsRepoStatus: () => getResultsRepoStatus,
   getSubagentsRoot: () => getSubagentsRoot,
   getTextContent: () => getTextContent,
   getTraceStateRoot: () => getTraceStateRoot,
@@ -1550,12 +1901,15 @@ __export(index_exports, {
   mergeExecutionMetrics: () => mergeExecutionMetrics,
   negateScore: () => negateScore,
   normalizeLineEndings: () => normalizeLineEndings,
+  normalizeResultsExportConfig: () => normalizeResultsExportConfig,
   parseAgentSkillsEvals: () => parseAgentSkillsEvals,
   parseClaudeSession: () => parseClaudeSession,
   parseCodexSession: () => parseCodexSession,
   parseCopilotEvents: () => parseCopilotEvents,
   parseJsonFromText: () => parseJsonFromText,
   parseJsonSafe: () => parseJsonSafe,
+  prepareResultsRepoBranch: () => prepareResultsRepoBranch,
+  pushResultsRepoBranch: () => pushResultsRepoBranch,
   readJsonFile: () => readJsonFile,
   readTargetDefinitions: () => readTargetDefinitions,
   readTestSuiteMetadata: () => readTestSuiteMetadata,
@@ -1566,6 +1920,8 @@ __export(index_exports, {
   resolveAndCreateProvider: () => resolveAndCreateProvider,
   resolveDelegatedTargetDefinition: () => resolveDelegatedTargetDefinition,
   resolveFileReference: () => resolveFileReference3,
+  resolveResultsRepoRunsDir: () => resolveResultsRepoRunsDir,
+  resolveResultsRepoUrl: () => resolveResultsRepoUrl,
   resolveTargetDefinition: () => resolveTargetDefinition,
   resolveWorkspaceTemplate: () => resolveWorkspaceTemplate,
   rubricEvaluationSchema: () => rubricEvaluationSchema,
@@ -1587,12 +1943,14 @@ __export(index_exports, {
   scoreToVerdict: () => scoreToVerdict,
   shouldEnableCache: () => shouldEnableCache,
   shouldSkipCacheForTemperature: () => shouldSkipCacheForTemperature,
+  stageResultsArtifacts: () => stageResultsArtifacts,
   subscribeToClaudeLogEntries: () => subscribeToClaudeLogEntries,
   subscribeToCodexLogEntries: () => subscribeToCodexLogEntries,
   subscribeToCopilotCliLogEntries: () => subscribeToCopilotCliLogEntries,
   subscribeToCopilotSdkLogEntries: () => subscribeToCopilotSdkLogEntries,
   subscribeToPiLogEntries: () => subscribeToPiLogEntries,
   substituteVariables: () => substituteVariables,
+  syncResultsRepo: () => syncResultsRepo,
   toCamelCaseDeep: () => toCamelCaseDeep,
   toSnakeCaseDeep: () => toSnakeCaseDeep,
   toTranscriptJsonLine: () => toTranscriptJsonLine,
@@ -1829,10 +2187,10 @@ function mergeExecutionMetrics(computed, metrics) {
 
 // src/evaluation/yaml-parser.ts
 init_cjs_shims();
-var import_promises9 = require("fs/promises");
+var import_promises10 = require("fs/promises");
 var import_node_path9 = __toESM(require("path"), 1);
 var import_micromatch2 = __toESM(require("micromatch"), 1);
-var import_yaml4 = require("yaml");
+var import_yaml5 = require("yaml");
 
 // src/evaluation/input-message-utils.ts
 init_cjs_shims();
@@ -2261,10 +2619,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(
@@ -2499,166 +2859,77 @@ 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_YELLOW2}Warning: ${message}${ANSI_RESET3}`);
 }
 
 // src/evaluation/loaders/evaluator-parser.ts
 init_cjs_shims();
+var import_promises7 = require("fs/promises");
 var import_node_path6 = __toESM(require("path"), 1);
+var import_yaml3 = require("yaml");
 
 // src/evaluation/content-preprocessor.ts
 init_cjs_shims();
 var import_promises5 = require("fs/promises");
 var import_node_path5 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
-
-// src/runtime/exec.ts
-init_cjs_shims();
-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("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: mkdir17, readFile: readFile19, rm: rm6, writeFile: writeFile9 } = await import("fs/promises");
-  const { tmpdir: tmpdir3 } = await import("os");
-  const path55 = await import("path");
-  const { randomUUID: randomUUID10 } = await import("crypto");
-  const dir = path55.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
-  await mkdir17(dir, { recursive: true });
-  const stdinPath = path55.join(dir, "stdin.txt");
-  const stdoutPath = path55.join(dir, "stdout.txt");
-  const stderrPath = path55.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("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 readFile19(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile19(stderrPath, "utf8")).replace(/\r\n/g, "\n");
-    return { stdout, stderr, exitCode };
-  } finally {
-    await rm6(dir, { recursive: true, force: true });
-  }
-}
-
-// src/evaluation/content-preprocessor.ts
+init_exec();
 var MIME_TYPE_ALIASES = {
   csv: "text/csv",
   docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
@@ -2901,6 +3172,7 @@ function validateTemplateVariables(content, source) {
 // src/evaluation/loaders/evaluator-parser.ts
 var ANSI_YELLOW4 = "\x1B[33m";
 var ANSI_RESET5 = "\x1B[0m";
+var MAX_ASSERTION_INCLUDE_DEPTH = 3;
 var PROMPT_FILE_PREFIX = "file://";
 function normalizeEvaluatorType(type) {
   return type.replace(/_/g, "-");
@@ -2933,7 +3205,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) ? [
+    import_node_path6.default.join(".agentv", "templates", `${include}.yaml`),
+    import_node_path6.default.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 (0, import_promises7.readFile)(resolved.resolvedPath, "utf8");
+  const parsed = interpolateEnv((0, import_yaml3.parse)(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 = import_node_path6.default.dirname(resolved.resolvedPath);
+  const nestedSearchRoots = [
+    templateDir,
+    ...searchRoots.filter((root) => import_node_path6.default.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;
   }
@@ -2941,13 +3285,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) {
@@ -3162,8 +3527,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;
@@ -4490,14 +4863,14 @@ function parseInlineRubrics(rawRubrics) {
 
 // src/evaluation/loaders/jsonl-parser.ts
 init_cjs_shims();
-var import_promises8 = require("fs/promises");
+var import_promises9 = require("fs/promises");
 var import_node_path8 = __toESM(require("path"), 1);
 var import_micromatch = __toESM(require("micromatch"), 1);
-var import_yaml3 = require("yaml");
+var import_yaml4 = require("yaml");
 
 // src/evaluation/loaders/message-processor.ts
 init_cjs_shims();
-var import_promises7 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 var import_node_path7 = __toESM(require("path"), 1);
 
 // src/evaluation/formatting/segment-formatter.ts
@@ -4615,7 +4988,7 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const fileContent = (await (0, import_promises7.readFile)(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+          const fileContent = (await (0, import_promises8.readFile)(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
           processedContent.push({
             ...cloneJsonObject(rawSegment),
             path: displayPath,
@@ -4656,7 +5029,7 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const imageBuffer = await (0, import_promises7.readFile)(resolvedPath);
+          const imageBuffer = await (0, import_promises8.readFile)(resolvedPath);
           const base64 = imageBuffer.toString("base64");
           processedContent.push({
             type: "image",
@@ -4733,7 +5106,7 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const fileContent = (await (0, import_promises7.readFile)(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+            const fileContent = (await (0, import_promises8.readFile)(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
             processedContent.push({
               type: "file",
               path: displayPath,
@@ -4773,7 +5146,7 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const imageBuffer = await (0, import_promises7.readFile)(resolvedPath);
+            const imageBuffer = await (0, import_promises8.readFile)(resolvedPath);
             const base64 = imageBuffer.toString("base64");
             processedContent.push({
               type: "image",
@@ -4902,8 +5275,8 @@ async function loadSidecarMetadata(jsonlPath, verbose) {
     return {};
   }
   try {
-    const content = await (0, import_promises8.readFile)(sidecarPath, "utf8");
-    const parsed = interpolateEnv((0, import_yaml3.parse)(content), process.env);
+    const content = await (0, import_promises9.readFile)(sidecarPath, "utf8");
+    const parsed = interpolateEnv((0, import_yaml4.parse)(content), process.env);
     if (!isJsonObject(parsed)) {
       logWarning4(`Invalid sidecar metadata format in ${sidecarPath}`);
       return {};
@@ -4947,7 +5320,7 @@ async function loadTestsFromJsonl(evalFilePath, repoRoot, options) {
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots(absoluteTestPath, repoRootPath);
   const sidecar = await loadSidecarMetadata(absoluteTestPath, verbose);
-  const rawFile = await (0, import_promises8.readFile)(absoluteTestPath, "utf8");
+  const rawFile = await (0, import_promises9.readFile)(absoluteTestPath, "utf8");
   const rawCases = parseJsonlContent(rawFile, evalFilePath);
   const fallbackSuiteName = import_node_path8.default.basename(absoluteTestPath, ".jsonl") || "eval";
   const suiteName = sidecar.name && sidecar.name.trim().length > 0 ? sidecar.name : fallbackSuiteName;
@@ -5131,11 +5504,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 }
   };
@@ -5158,12 +5533,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 }
   };
@@ -5215,7 +5590,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")) {
@@ -5229,6 +5605,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) {
@@ -5312,8 +5708,8 @@ function resolveTests(suite) {
 async function readTestSuiteMetadata(testFilePath) {
   try {
     const absolutePath = import_node_path9.default.resolve(testFilePath);
-    const content = await (0, import_promises9.readFile)(absolutePath, "utf8");
-    const parsed = interpolateEnv((0, import_yaml4.parse)(content), process.env);
+    const content = await (0, import_promises10.readFile)(absolutePath, "utf8");
+    const parsed = interpolateEnv((0, import_yaml5.parse)(content), process.env);
     if (!isJsonObject(parsed)) {
       return {};
     }
@@ -5370,8 +5766,8 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots(absoluteTestPath, repoRootPath);
   const config = await loadConfig(absoluteTestPath, repoRootPath);
-  const rawFile = await (0, import_promises9.readFile)(absoluteTestPath, "utf8");
-  const interpolated = interpolateEnv((0, import_yaml4.parse)(rawFile), process.env);
+  const rawFile = await (0, import_promises10.readFile)(absoluteTestPath, "utf8");
+  const interpolated = interpolateEnv((0, import_yaml5.parse)(rawFile), process.env);
   if (!isJsonObject(interpolated)) {
     throw new Error(`Invalid test file format: ${evalFilePath}`);
   }
@@ -5512,7 +5908,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,
@@ -5605,11 +6001,11 @@ async function resolveWorkspaceConfig(raw, evalFileDir) {
     const workspaceFilePath = import_node_path9.default.resolve(evalFileDir, raw);
     let content;
     try {
-      content = await (0, import_promises9.readFile)(workspaceFilePath, "utf8");
+      content = await (0, import_promises10.readFile)(workspaceFilePath, "utf8");
     } catch {
       throw new Error(`Workspace file not found: ${raw} (resolved to ${workspaceFilePath})`);
     }
-    const parsed = interpolateEnv((0, import_yaml4.parse)(content), process.env);
+    const parsed = interpolateEnv((0, import_yaml5.parse)(content), process.env);
     if (!isJsonObject(parsed)) {
       throw new Error(
         `Invalid workspace file format: ${workspaceFilePath} (expected a YAML object)`
@@ -5644,14 +6040,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) {
@@ -5680,7 +6090,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) {
@@ -5709,7 +6120,7 @@ ${detailBlock}${ANSI_RESET8}`);
 init_cjs_shims();
 var import_node_fs2 = require("fs");
 var import_node_path10 = __toESM(require("path"), 1);
-var import_yaml5 = require("yaml");
+var import_yaml6 = require("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).`;
@@ -5948,7 +6359,7 @@ function transpileEvalYaml(suite, source = "EVAL.yaml") {
 }
 function transpileEvalYamlFile(evalYamlPath) {
   const content = (0, import_node_fs2.readFileSync)(evalYamlPath, "utf8");
-  const parsed = (0, import_yaml5.parse)(content);
+  const parsed = (0, import_yaml6.parse)(content);
   return transpileEvalYaml(parsed, import_node_path10.default.basename(evalYamlPath));
 }
 function getOutputFilenames(result) {
@@ -5969,11 +6380,11 @@ function getOutputFilenames(result) {
 // src/evaluation/file-utils.ts
 init_cjs_shims();
 var import_node_fs3 = require("fs");
-var import_promises10 = require("fs/promises");
+var import_promises11 = require("fs/promises");
 var import_node_path11 = __toESM(require("path"), 1);
 async function fileExists2(filePath) {
   try {
-    await (0, import_promises10.access)(filePath, import_node_fs3.constants.F_OK);
+    await (0, import_promises11.access)(filePath, import_node_fs3.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -5983,11 +6394,11 @@ function normalizeLineEndings(content) {
   return content.replace(/\r\n/g, "\n");
 }
 async function readTextFile(filePath) {
-  const content = await (0, import_promises10.readFile)(filePath, "utf8");
+  const content = await (0, import_promises11.readFile)(filePath, "utf8");
   return normalizeLineEndings(content);
 }
 async function readJsonFile(filePath) {
-  const content = await (0, import_promises10.readFile)(filePath, "utf8");
+  const content = await (0, import_promises11.readFile)(filePath, "utf8");
   return JSON.parse(content);
 }
 async function findGitRoot(startPath) {
@@ -6508,7 +6919,7 @@ init_cjs_shims();
 var import_node_child_process = require("child_process");
 var import_node_crypto = require("crypto");
 var import_node_fs4 = require("fs");
-var import_promises11 = require("fs/promises");
+var import_promises12 = require("fs/promises");
 var import_node_path13 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/claude-content.ts
@@ -6840,7 +7251,7 @@ var ClaudeCliProvider = class {
       return void 0;
     }
     try {
-      await (0, import_promises11.mkdir)(logDir, { recursive: true });
+      await (0, import_promises12.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Claude CLI stream logging (could not create ${logDir}): ${message}`);
@@ -7148,7 +7559,7 @@ function tryParseJson(line) {
 init_cjs_shims();
 var import_node_crypto2 = require("crypto");
 var import_node_fs5 = require("fs");
-var import_promises12 = require("fs/promises");
+var import_promises13 = require("fs/promises");
 var import_node_path14 = __toESM(require("path"), 1);
 var claudeSdkModule = null;
 async function loadClaudeSdk() {
@@ -7333,7 +7744,7 @@ var ClaudeSdkProvider = class {
       return void 0;
     }
     try {
-      await (0, import_promises12.mkdir)(logDir, { recursive: true });
+      await (0, import_promises13.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Claude stream logging (could not create ${logDir}): ${message}`);
@@ -7526,7 +7937,7 @@ function formatElapsed2(startedAt) {
 // src/evaluation/providers/cli.ts
 init_cjs_shims();
 var import_node_child_process2 = require("child_process");
-var import_promises13 = __toESM(require("fs/promises"), 1);
+var import_promises14 = __toESM(require("fs/promises"), 1);
 var import_node_os = __toESM(require("os"), 1);
 var import_node_path15 = __toESM(require("path"), 1);
 var import_node_util = require("util");
@@ -7925,7 +8336,7 @@ var CliProvider = class {
       throw new Error(`Failed to read output file '${filePath}': ${errorMsg}`);
     } finally {
       if (!this.keepTempFiles) {
-        await import_promises13.default.unlink(filePath).catch(() => {
+        await import_promises14.default.unlink(filePath).catch(() => {
         });
       }
     }
@@ -8005,7 +8416,7 @@ var CliProvider = class {
 async function buildTemplateValues(request, config, outputFilePath) {
   const inputFiles = normalizeInputFiles2(request.inputFiles);
   const promptFilePath = generateOutputFilePath(request.evalCaseId, ".prompt.txt");
-  await import_promises13.default.writeFile(promptFilePath, request.question ?? "", "utf8");
+  await import_promises14.default.writeFile(promptFilePath, request.question ?? "", "utf8");
   return {
     values: {
       PROMPT: shellEscape(request.question ?? ""),
@@ -8022,7 +8433,7 @@ async function cleanupTempFile(filePath, keepTempFiles) {
   if (!filePath || keepTempFiles) {
     return;
   }
-  await import_promises13.default.unlink(filePath).catch(() => {
+  await import_promises14.default.unlink(filePath).catch(() => {
   });
 }
 function normalizeInputFiles2(inputFiles) {
@@ -8083,7 +8494,7 @@ function formatTimeoutSuffix2(timeoutMs) {
 init_cjs_shims();
 var import_node_crypto3 = require("crypto");
 var import_node_fs6 = require("fs");
-var import_promises14 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 var import_node_path16 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/codex-log-tracker.ts
@@ -8343,7 +8754,7 @@ ${basePrompt}` : basePrompt;
       return void 0;
     }
     try {
-      await (0, import_promises14.mkdir)(logDir, { recursive: true });
+      await (0, import_promises15.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Codex SDK stream logging (could not create ${logDir}): ${message}`);
@@ -8493,7 +8904,7 @@ function formatElapsed3(startedAt) {
 // src/evaluation/providers/copilot-cli.ts
 init_cjs_shims();
 var import_node_crypto5 = require("crypto");
-var import_promises15 = require("fs/promises");
+var import_promises16 = require("fs/promises");
 var import_node_path18 = __toESM(require("path"), 1);
 var import_node_stream = require("stream");
 var import_node_child_process3 = require("child_process");
@@ -8562,7 +8973,7 @@ var import_node_path17 = __toESM(require("path"), 1);
 var import_node_url3 = require("url");
 var import_meta = {};
 function resolvePlatformCliPath() {
-  const os3 = (0, import_node_os2.platform)();
+  const os4 = (0, import_node_os2.platform)();
   const cpu = (0, import_node_os2.arch)();
   const platformMap = {
     linux: "linux",
@@ -8573,13 +8984,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:") ? (0, import_node_url3.fileURLToPath)(resolved) : resolved;
@@ -8997,7 +9408,7 @@ var CopilotCliProvider = class {
       return void 0;
     }
     try {
-      await (0, import_promises15.mkdir)(logDir, { recursive: true });
+      await (0, import_promises16.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Copilot CLI stream logging (could not create ${logDir}): ${message}`);
@@ -9097,7 +9508,7 @@ function summarizeAcpEvent(eventType, data) {
 
 // src/evaluation/providers/copilot-log.ts
 init_cjs_shims();
-var import_promises17 = require("fs/promises");
+var import_promises18 = require("fs/promises");
 var import_node_os4 = require("os");
 var import_node_path20 = __toESM(require("path"), 1);
 
@@ -9233,17 +9644,17 @@ function parseCopilotEvents(eventsJsonl) {
 
 // src/evaluation/providers/copilot-session-discovery.ts
 init_cjs_shims();
-var import_promises16 = require("fs/promises");
+var import_promises17 = require("fs/promises");
 var import_node_os3 = require("os");
 var import_node_path19 = __toESM(require("path"), 1);
-var import_yaml6 = require("yaml");
+var import_yaml7 = require("yaml");
 var DEFAULT_SESSION_STATE_DIR = () => import_node_path19.default.join((0, import_node_os3.homedir)(), ".copilot", "session-state");
 async function discoverCopilotSessions(opts) {
   const sessionStateDir = opts?.sessionStateDir ?? DEFAULT_SESSION_STATE_DIR();
   const limit = opts?.limit ?? 10;
   let entries;
   try {
-    entries = await (0, import_promises16.readdir)(sessionStateDir);
+    entries = await (0, import_promises17.readdir)(sessionStateDir);
   } catch {
     return [];
   }
@@ -9253,12 +9664,12 @@ async function discoverCopilotSessions(opts) {
     const workspacePath = import_node_path19.default.join(sessionDir, "workspace.yaml");
     const eventsPath = import_node_path19.default.join(sessionDir, "events.jsonl");
     try {
-      const workspaceContent = await (0, import_promises16.readFile)(workspacePath, "utf8");
-      const workspace = (0, import_yaml6.parse)(workspaceContent) ?? {};
+      const workspaceContent = await (0, import_promises17.readFile)(workspacePath, "utf8");
+      const workspace = (0, import_yaml7.parse)(workspaceContent) ?? {};
       const cwd = String(workspace.cwd ?? "");
       let updatedAt;
       try {
-        const eventsStat = await (0, import_promises16.stat)(eventsPath);
+        const eventsStat = await (0, import_promises17.stat)(eventsPath);
         updatedAt = eventsStat.mtime;
       } catch {
         updatedAt = /* @__PURE__ */ new Date(0);
@@ -9315,7 +9726,7 @@ var CopilotLogProvider = class {
     const eventsPath = import_node_path20.default.join(sessionDir, "events.jsonl");
     let eventsContent;
     try {
-      eventsContent = await (0, import_promises17.readFile)(eventsPath, "utf8");
+      eventsContent = await (0, import_promises18.readFile)(eventsPath, "utf8");
     } catch (err) {
       throw new Error(
         `Failed to read Copilot session transcript at ${eventsPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -9360,7 +9771,7 @@ var CopilotLogProvider = class {
 init_cjs_shims();
 var import_node_crypto6 = require("crypto");
 var import_node_fs8 = require("fs");
-var import_promises18 = require("fs/promises");
+var import_promises19 = require("fs/promises");
 var import_node_path21 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/copilot-sdk-log-tracker.ts
@@ -9694,7 +10105,7 @@ var CopilotSdkProvider = class {
       return void 0;
     }
     try {
-      await (0, import_promises18.mkdir)(logDir, { recursive: true });
+      await (0, import_promises19.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Copilot SDK stream logging (could not create ${logDir}): ${message}`);
@@ -9815,7 +10226,7 @@ init_cjs_shims();
 var import_node_child_process4 = require("child_process");
 var import_node_crypto7 = require("crypto");
 var import_node_fs9 = require("fs");
-var import_promises19 = require("fs/promises");
+var import_promises20 = require("fs/promises");
 var import_node_os5 = require("os");
 var import_node_path22 = __toESM(require("path"), 1);
 
@@ -10027,7 +10438,7 @@ var PiCliProvider = class {
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
       const promptFile = import_node_path22.default.join(cwd, PROMPT_FILENAME);
-      await (0, import_promises19.writeFile)(promptFile, request.question, "utf8");
+      await (0, import_promises20.writeFile)(promptFile, request.question, "utf8");
       const args = this.buildPiArgs(request.question, inputFiles);
       const result = await this.executePi(args, cwd, request.signal, logger);
       if (result.timedOut) {
@@ -10198,11 +10609,11 @@ ${prompt}` : prompt;
     return env;
   }
   async createWorkspace() {
-    return await (0, import_promises19.mkdtemp)(import_node_path22.default.join((0, import_node_os5.tmpdir)(), WORKSPACE_PREFIX));
+    return await (0, import_promises20.mkdtemp)(import_node_path22.default.join((0, import_node_os5.tmpdir)(), WORKSPACE_PREFIX));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
-      await (0, import_promises19.rm)(workspaceRoot, { recursive: true, force: true });
+      await (0, import_promises20.rm)(workspaceRoot, { recursive: true, force: true });
     } catch {
     }
   }
@@ -10218,7 +10629,7 @@ ${prompt}` : prompt;
       return void 0;
     }
     try {
-      await (0, import_promises19.mkdir)(logDir, { recursive: true });
+      await (0, import_promises20.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
@@ -10775,7 +11186,7 @@ init_cjs_shims();
 var import_node_child_process5 = require("child_process");
 var import_node_crypto8 = require("crypto");
 var import_node_fs10 = require("fs");
-var import_promises20 = require("fs/promises");
+var import_promises21 = require("fs/promises");
 var import_node_path24 = __toESM(require("path"), 1);
 var import_node_readline = require("readline");
 var import_node_url4 = require("url");
@@ -11236,7 +11647,7 @@ ${fileList}`;
       return void 0;
     }
     try {
-      await (0, import_promises20.mkdir)(logDir, { recursive: true });
+      await (0, import_promises21.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
@@ -12675,8 +13086,8 @@ function resolveCliConfig(target, env, evalFilePath) {
   const parseResult = CliTargetInputSchema.safeParse(target, { errorMap: cliErrorMap });
   if (!parseResult.success) {
     const firstError = parseResult.error.errors[0];
-    const path55 = firstError?.path.join(".") || "";
-    const prefix = path55 ? `${target.name} ${path55}: ` : `${target.name}: `;
+    const path56 = firstError?.path.join(".") || "";
+    const prefix = path56 ? `${target.name} ${path56}: ` : `${target.name}: `;
     throw new Error(`${prefix}${firstError?.message}`);
   }
   const normalized = normalizeCliTargetInput(parseResult.data, env, evalFilePath);
@@ -12923,7 +13334,7 @@ function resolveOptionalNumberArray(source, description) {
 // src/evaluation/providers/vscode-provider.ts
 init_cjs_shims();
 var import_node_child_process7 = require("child_process");
-var import_promises27 = require("fs/promises");
+var import_promises28 = require("fs/promises");
 var import_node_path36 = __toESM(require("path"), 1);
 var import_node_util3 = require("util");
 
@@ -12932,27 +13343,27 @@ init_cjs_shims();
 
 // src/evaluation/providers/vscode/dispatch/agentDispatch.ts
 init_cjs_shims();
-var import_promises25 = require("fs/promises");
+var import_promises26 = require("fs/promises");
 var import_node_path34 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/fs.ts
 init_cjs_shims();
 var import_node_fs11 = require("fs");
-var import_promises21 = require("fs/promises");
+var import_promises22 = require("fs/promises");
 var import_node_path26 = __toESM(require("path"), 1);
 async function pathExists(target) {
   try {
-    await (0, import_promises21.access)(target, import_node_fs11.constants.F_OK);
+    await (0, import_promises22.access)(target, import_node_fs11.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function ensureDir(target) {
-  await (0, import_promises21.mkdir)(target, { recursive: true });
+  await (0, import_promises22.mkdir)(target, { recursive: true });
 }
 async function readDirEntries(target) {
-  const entries = await (0, import_promises21.readdir)(target, { withFileTypes: true });
+  const entries = await (0, import_promises22.readdir)(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
     absolutePath: import_node_path26.default.join(target, entry.name),
@@ -12961,7 +13372,7 @@ async function readDirEntries(target) {
 }
 async function removeIfExists(target) {
   try {
-    await (0, import_promises21.rm)(target, { force: true, recursive: false });
+    await (0, import_promises22.rm)(target, { force: true, recursive: false });
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
@@ -13087,7 +13498,7 @@ function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateCont
 
 // src/evaluation/providers/vscode/dispatch/responseWaiter.ts
 init_cjs_shims();
-var import_promises22 = require("fs/promises");
+var import_promises23 = require("fs/promises");
 var import_node_path29 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/time.ts
@@ -13127,7 +13538,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     try {
-      const content = await (0, import_promises22.readFile)(responseFileFinal, { encoding: "utf8" });
+      const content = await (0, import_promises23.readFile)(responseFileFinal, { encoding: "utf8" });
       if (!silent) {
         process.stdout.write(`${content}
 `);
@@ -13184,7 +13595,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     const maxAttempts = 10;
     while (attempts < maxAttempts) {
       try {
-        const content = await (0, import_promises22.readFile)(file, { encoding: "utf8" });
+        const content = await (0, import_promises23.readFile)(file, { encoding: "utf8" });
         if (!silent) {
           process.stdout.write(`${content}
 `);
@@ -13208,7 +13619,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
 init_cjs_shims();
 var import_node_child_process6 = require("child_process");
-var import_promises23 = require("fs/promises");
+var import_promises24 = require("fs/promises");
 var import_node_path31 = __toESM(require("path"), 1);
 var import_node_util2 = require("util");
 
@@ -13289,9 +13700,9 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
   const aliveFile = import_node_path31.default.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
   const githubAgentsDir = import_node_path31.default.join(subagentDir, ".github", "agents");
-  await (0, import_promises23.mkdir)(githubAgentsDir, { recursive: true });
+  await (0, import_promises24.mkdir)(githubAgentsDir, { recursive: true });
   const wakeupDst = import_node_path31.default.join(githubAgentsDir, "wakeup.md");
-  await (0, import_promises23.writeFile)(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
+  await (0, import_promises24.writeFile)(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
   const workspaceChild = spawnVsCode(vscodeCmd, [workspacePath], {
     label: "open-workspace"
   });
@@ -13320,9 +13731,9 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
   const workspacePath = import_node_path31.default.join(subagentDir, `${import_node_path31.default.basename(subagentDir)}.code-workspace`);
   const messagesDir = import_node_path31.default.join(subagentDir, "messages");
-  await (0, import_promises23.mkdir)(messagesDir, { recursive: true });
+  await (0, import_promises24.mkdir)(messagesDir, { recursive: true });
   const reqFile = import_node_path31.default.join(messagesDir, `${timestamp}_req.md`);
-  await (0, import_promises23.writeFile)(reqFile, requestInstructions, { encoding: "utf8" });
+  await (0, import_promises24.writeFile)(reqFile, requestInstructions, { encoding: "utf8" });
   const reqUri = pathToFileUri2(reqFile);
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
@@ -13348,7 +13759,7 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
   const workspacePath = import_node_path31.default.join(subagentDir, `${import_node_path31.default.basename(subagentDir)}.code-workspace`);
   const messagesDir = import_node_path31.default.join(subagentDir, "messages");
-  await (0, import_promises23.mkdir)(messagesDir, { recursive: true });
+  await (0, import_promises24.mkdir)(messagesDir, { recursive: true });
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
     chatArgs.push("-a", attachment);
@@ -13372,7 +13783,7 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
 
 // src/evaluation/providers/vscode/dispatch/workspaceManager.ts
 init_cjs_shims();
-var import_promises24 = require("fs/promises");
+var import_promises25 = require("fs/promises");
 var import_node_path33 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/workspace.ts
@@ -13486,11 +13897,11 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
-    const stats = await (0, import_promises24.stat)(workspaceSrc);
+    const stats = await (0, import_promises25.stat)(workspaceSrc);
     if (!stats.isFile()) {
       throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
     }
-    const templateText = await (0, import_promises24.readFile)(workspaceSrc, "utf8");
+    const templateText = await (0, import_promises25.readFile)(workspaceSrc, "utf8");
     workspaceContent = JSON.parse(templateText);
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
@@ -13509,15 +13920,15 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
       transformedContent = JSON.stringify(parsed, null, 2);
     }
   }
-  await (0, import_promises24.writeFile)(workspaceDst, transformedContent, "utf8");
+  await (0, import_promises25.writeFile)(workspaceDst, transformedContent, "utf8");
   const messagesDir = import_node_path33.default.join(subagentDir, "messages");
-  await (0, import_promises24.mkdir)(messagesDir, { recursive: true });
+  await (0, import_promises25.mkdir)(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
   const messagesDir = import_node_path33.default.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
-    const files = await (0, import_promises24.readdir)(messagesDir);
+    const files = await (0, import_promises25.readdir)(messagesDir);
     await Promise.all(
       files.map(async (file) => {
         const target = import_node_path33.default.join(messagesDir, file);
@@ -13527,14 +13938,14 @@ async function createSubagentLock(subagentDir) {
   }
   const githubAgentsDir = import_node_path33.default.join(subagentDir, ".github", "agents");
   if (await pathExists(githubAgentsDir)) {
-    const agentFiles = await (0, import_promises24.readdir)(githubAgentsDir);
+    const agentFiles = await (0, import_promises25.readdir)(githubAgentsDir);
     const preservedFiles = /* @__PURE__ */ new Set(["wakeup.md", "subagent.md"]);
     await Promise.all(
       agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(import_node_path33.default.join(githubAgentsDir, file)))
     );
   }
   const lockFile = import_node_path33.default.join(subagentDir, DEFAULT_LOCK_NAME);
-  await (0, import_promises24.writeFile)(lockFile, "", { encoding: "utf8" });
+  await (0, import_promises25.writeFile)(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
@@ -13559,10 +13970,10 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
   }
   if (promptFile) {
     const githubAgentsDir = import_node_path33.default.join(subagentDir, ".github", "agents");
-    await (0, import_promises24.mkdir)(githubAgentsDir, { recursive: true });
+    await (0, import_promises25.mkdir)(githubAgentsDir, { recursive: true });
     const agentFile = import_node_path33.default.join(githubAgentsDir, `${chatId}.md`);
     try {
-      await (0, import_promises24.copyFile)(promptFile, agentFile);
+      await (0, import_promises25.copyFile)(promptFile, agentFile);
     } catch (error) {
       console.error(`error: Failed to copy prompt file to agent mode: ${error.message}`);
       return 1;
@@ -13583,7 +13994,7 @@ async function resolvePromptFile(promptFile) {
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
-  const promptStats = await (0, import_promises25.stat)(resolvedPrompt);
+  const promptStats = await (0, import_promises26.stat)(resolvedPrompt);
   if (!promptStats.isFile()) {
     throw new Error(`Prompt file must be a file, not a directory: ${resolvedPrompt}`);
   }
@@ -13820,7 +14231,7 @@ async function dispatchBatchAgent(options) {
           const reqFile = requestFiles[index];
           const tmpFile = responseTmpFiles[index];
           const finalFile = responseFilesFinal[index];
-          return (0, import_promises25.writeFile)(
+          return (0, import_promises26.writeFile)(
             reqFile,
             createBatchRequestPrompt(query, tmpFile, finalFile, batchRequestTemplateContent),
             { encoding: "utf8" }
@@ -13832,7 +14243,7 @@ async function dispatchBatchAgent(options) {
         responseFilesFinal,
         orchestratorTemplateContent
       );
-      await (0, import_promises25.writeFile)(orchestratorFile, orchestratorContent, { encoding: "utf8" });
+      await (0, import_promises26.writeFile)(orchestratorFile, orchestratorContent, { encoding: "utf8" });
     }
     const chatAttachments = [orchestratorFile, ...attachments];
     const orchestratorUri = pathToFileUri2(orchestratorFile);
@@ -13899,7 +14310,7 @@ async function dispatchBatchAgent(options) {
 
 // src/evaluation/providers/vscode/dispatch/provision.ts
 init_cjs_shims();
-var import_promises26 = require("fs/promises");
+var import_promises27 = require("fs/promises");
 var import_node_path35 = __toESM(require("path"), 1);
 var DEFAULT_WORKSPACE_TEMPLATE2 = {
   folders: [
@@ -13980,8 +14391,8 @@ async function provisionSubagents(options) {
       if (!dryRun) {
         await removeIfExists(lockFile);
         await ensureDir(githubAgentsDir);
-        await (0, import_promises26.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await (0, import_promises26.writeFile)(wakeupDst, wakeupContent, "utf8");
+        await (0, import_promises27.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await (0, import_promises27.writeFile)(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       lockedSubagents.delete(subagentDir);
@@ -13991,8 +14402,8 @@ async function provisionSubagents(options) {
     if (!isLocked && force) {
       if (!dryRun) {
         await ensureDir(githubAgentsDir);
-        await (0, import_promises26.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await (0, import_promises26.writeFile)(wakeupDst, wakeupContent, "utf8");
+        await (0, import_promises27.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await (0, import_promises27.writeFile)(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       subagentsProvisioned += 1;
@@ -14000,8 +14411,8 @@ async function provisionSubagents(options) {
     }
     if (!dryRun && !await pathExists(workspaceDst)) {
       await ensureDir(githubAgentsDir);
-      await (0, import_promises26.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await (0, import_promises26.writeFile)(wakeupDst, wakeupContent, "utf8");
+      await (0, import_promises27.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await (0, import_promises27.writeFile)(wakeupDst, wakeupContent, "utf8");
     }
     skippedExisting.push(subagentDir);
     subagentsProvisioned += 1;
@@ -14016,8 +14427,8 @@ async function provisionSubagents(options) {
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
-      await (0, import_promises26.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await (0, import_promises26.writeFile)(wakeupDst, wakeupContent, "utf8");
+      await (0, import_promises27.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await (0, import_promises27.writeFile)(wakeupDst, wakeupContent, "utf8");
     }
     created.push(subagentDir);
     subagentsProvisioned += 1;
@@ -14205,7 +14616,7 @@ async function locateVSCodeExecutable(candidate) {
   if (includesPathSeparator) {
     const resolved = import_node_path36.default.isAbsolute(candidate) ? candidate : import_node_path36.default.resolve(candidate);
     try {
-      await (0, import_promises27.access)(resolved, import_promises27.constants.F_OK);
+      await (0, import_promises28.access)(resolved, import_promises28.constants.F_OK);
       return resolved;
     } catch {
       throw new Error(
@@ -14218,7 +14629,7 @@ async function locateVSCodeExecutable(candidate) {
     const { stdout } = await execAsync3(`${locator} ${candidate}`);
     const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
     if (lines.length > 0 && lines[0]) {
-      await (0, import_promises27.access)(lines[0], import_promises27.constants.F_OK);
+      await (0, import_promises28.access)(lines[0], import_promises28.constants.F_OK);
       return lines[0];
     }
   } catch {
@@ -14232,7 +14643,7 @@ async function resolveWorkspaceTemplateFile(template) {
     return void 0;
   }
   try {
-    const stats = await (0, import_promises27.stat)(import_node_path36.default.resolve(template));
+    const stats = await (0, import_promises28.stat)(import_node_path36.default.resolve(template));
     return stats.isFile() ? template : void 0;
   } catch {
     return template;
@@ -14401,9 +14812,9 @@ function isAgentProvider(provider) {
 // src/evaluation/providers/targets-file.ts
 init_cjs_shims();
 var import_node_fs12 = require("fs");
-var import_promises28 = require("fs/promises");
+var import_promises29 = require("fs/promises");
 var import_node_path37 = __toESM(require("path"), 1);
-var import_yaml7 = require("yaml");
+var import_yaml8 = require("yaml");
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -14435,7 +14846,7 @@ function assertTargetDefinition(value, index, filePath) {
 }
 async function fileExists3(filePath) {
   try {
-    await (0, import_promises28.access)(filePath, import_node_fs12.constants.F_OK);
+    await (0, import_promises29.access)(filePath, import_node_fs12.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -14446,8 +14857,8 @@ async function readTargetDefinitions(filePath) {
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await (0, import_promises28.readFile)(absolutePath, "utf8");
-  const parsed = (0, import_yaml7.parse)(raw);
+  const raw = await (0, import_promises29.readFile)(absolutePath, "utf8");
+  const parsed = (0, import_yaml8.parse)(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
   }
@@ -14618,9 +15029,10 @@ function negateScore(score) {
 
 // src/evaluation/evaluators/code-evaluator.ts
 init_cjs_shims();
-var import_promises29 = require("fs/promises");
+var import_promises30 = require("fs/promises");
 var import_node_os7 = require("os");
 var import_node_path39 = require("path");
+init_exec();
 
 // src/runtime/target-proxy.ts
 init_cjs_shims();
@@ -14900,6 +15312,19 @@ function toCamelCaseDeep(obj) {
   return obj;
 }
 
+// src/evaluation/workspace/repo-checkout.ts
+init_cjs_shims();
+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;
@@ -14942,7 +15367,7 @@ async function materializeContentForGrader(messages, getWorkDir) {
         const ext = mediaType.split("/")[1] === "jpeg" ? "jpg" : mediaType.split("/")[1] ?? "bin";
         const dir = await getWorkDir();
         const filePath = (0, import_node_path39.join)(dir, `img-${counter++}.${ext}`);
-        await (0, import_promises29.writeFile)(filePath, Buffer.from(base64Data, "base64"));
+        await (0, import_promises30.writeFile)(filePath, Buffer.from(base64Data, "base64"));
         blocks.push({ type: "image", media_type: img.media_type, path: filePath });
       } else {
         blocks.push({ type: "image", media_type: img.media_type, path: img.source });
@@ -14970,7 +15395,7 @@ var CodeEvaluator = class {
     let imageTmpDir;
     const getImageDir = async () => {
       if (!imageTmpDir) {
-        imageTmpDir = await (0, import_promises29.mkdtemp)((0, import_node_path39.join)((0, import_node_os7.tmpdir)(), "agentv-img-"));
+        imageTmpDir = await (0, import_promises30.mkdtemp)((0, import_node_path39.join)((0, import_node_os7.tmpdir)(), "agentv-img-"));
       }
       return imageTmpDir;
     };
@@ -14983,9 +15408,9 @@ var CodeEvaluator = class {
     if (outputForPayload) {
       const serialized = JSON.stringify(outputForPayload);
       if (serialized.length > FILE_BACKED_OUTPUT_THRESHOLD) {
-        const tmpDir = await (0, import_promises29.mkdtemp)((0, import_node_path39.join)((0, import_node_os7.tmpdir)(), "agentv-grader-"));
+        const tmpDir = await (0, import_promises30.mkdtemp)((0, import_node_path39.join)((0, import_node_os7.tmpdir)(), "agentv-grader-"));
         outputPath = (0, import_node_path39.join)(tmpDir, "output.json");
-        await (0, import_promises29.writeFile)(outputPath, serialized);
+        await (0, import_promises30.writeFile)(outputPath, serialized);
         outputForPayload = null;
       }
     }
@@ -15034,13 +15459,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 Promise.resolve().then(() => (init_docker_workspace(), docker_workspace_exports));
+        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(
@@ -15097,11 +15540,11 @@ var CodeEvaluator = class {
         await proxyShutdown();
       }
       if (outputPath) {
-        await (0, import_promises29.rm)((0, import_node_path39.dirname)(outputPath), { recursive: true, force: true }).catch(() => {
+        await (0, import_promises30.rm)((0, import_node_path39.dirname)(outputPath), { recursive: true, force: true }).catch(() => {
         });
       }
       if (imageTmpDir) {
-        await (0, import_promises29.rm)(imageTmpDir, { recursive: true, force: true }).catch(() => {
+        await (0, import_promises30.rm)(imageTmpDir, { recursive: true, force: true }).catch(() => {
         });
       }
     }
@@ -15134,7 +15577,7 @@ var import_ai3 = require("ai");
 
 // src/evaluation/evaluators/llm-grader.ts
 init_cjs_shims();
-var import_promises30 = __toESM(require("fs/promises"), 1);
+var import_promises31 = __toESM(require("fs/promises"), 1);
 var import_node_path40 = __toESM(require("path"), 1);
 var import_ai2 = require("ai");
 var import_zod4 = require("zod");
@@ -16185,7 +16628,7 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const entries = await import_promises30.default.readdir(resolved, { withFileTypes: true });
+          const entries = await import_promises31.default.readdir(resolved, { withFileTypes: true });
           return entries.map((e) => ({
             name: e.name,
             type: e.isDirectory() ? "directory" : "file"
@@ -16203,20 +16646,20 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const stat11 = await import_promises30.default.stat(resolved);
-          if (stat11.isDirectory()) {
+          const stat12 = await import_promises31.default.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 fd = await import_promises30.default.open(resolved, "r");
+          const buffer = Buffer.alloc(Math.min(stat12.size, MAX_FILE_SIZE));
+          const fd = await import_promises31.default.open(resolved, "r");
           try {
             await fd.read(buffer, 0, buffer.length, 0);
           } finally {
             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) };
         }
@@ -16253,7 +16696,7 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
   if (matches.length >= MAX_SEARCH_MATCHES) return;
   let entries;
   try {
-    entries = await import_promises30.default.readdir(dirPath, { withFileTypes: true });
+    entries = await import_promises31.default.readdir(dirPath, { withFileTypes: true });
   } catch {
     return;
   }
@@ -16267,9 +16710,9 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
       const ext = import_node_path40.default.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
-        const stat11 = await import_promises30.default.stat(fullPath);
-        if (stat11.size > MAX_FILE_SIZE) continue;
-        const content = await import_promises30.default.readFile(fullPath, "utf-8");
+        const stat12 = await import_promises31.default.stat(fullPath);
+        if (stat12.size > MAX_FILE_SIZE) continue;
+        const content = await import_promises31.default.readFile(fullPath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
           if (matches.length >= MAX_SEARCH_MATCHES) return;
@@ -16912,115 +17355,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path55, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path55);
-    const expectedValue = resolvePath(expectedData, path55);
+    const { path: path56, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path56);
+    const expectedValue = resolvePath(expectedData, path56);
     if (expectedValue === void 0) {
       return {
-        path: path55,
+        path: path56,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path55}: no expected value`
+        message: `${path56}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path55,
+          path: path56,
           score: 0,
           weight,
           hit: false,
-          message: `${path55} (required, missing)`
+          message: `${path56} (required, missing)`
         };
       }
       return {
-        path: path55,
+        path: path56,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path55}: optional field missing`
+        message: `${path56}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path55, candidateValue, expectedValue, weight);
+        return this.compareExact(path56, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path55,
+          path56,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path55, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path56, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path55,
+          path: path56,
           score: 0,
           weight,
           hit: false,
-          message: `${path55}: unknown match type "${match}"`
+          message: `${path56}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path55, candidateValue, expectedValue, weight) {
+  compareExact(path56, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path55,
+        path: path56,
         score: 1,
         weight,
         hit: true,
-        message: path55
+        message: path56
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path55,
+        path: path56,
         score: 0,
         weight,
         hit: false,
-        message: `${path55} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path56} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path55,
+      path: path56,
       score: 0,
       weight,
       hit: false,
-      message: `${path55} (value mismatch)`
+      message: `${path56} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path55, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path56, 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: path55,
+        path: path56,
         score: 0,
         weight,
         hit: false,
-        message: `${path55} (non-numeric value)`
+        message: `${path56} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path55,
+        path: path56,
         score: 0,
         weight,
         hit: false,
-        message: `${path55} (invalid numeric value)`
+        message: `${path56} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -17033,61 +17476,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path55,
+        path: path56,
         score: 1,
         weight,
         hit: true,
-        message: `${path55} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path56} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path55,
+      path: path56,
       score: 0,
       weight,
       hit: false,
-      message: `${path55} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path56} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path55, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path56, 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: path55,
+        path: path56,
         score: 0,
         weight,
         hit: false,
-        message: `${path55} (unparseable candidate date)`
+        message: `${path56} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path55,
+        path: path56,
         score: 0,
         weight,
         hit: false,
-        message: `${path55} (unparseable expected date)`
+        message: `${path56} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path55,
+        path: path56,
         score: 1,
         weight,
         hit: true,
-        message: path55
+        message: path56
       };
     }
     return {
-      path: path55,
+      path: path56,
       score: 0,
       weight,
       hit: false,
-      message: `${path55} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path56} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -17120,11 +17563,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path55) {
-  if (!path55 || !obj) {
+function resolvePath(obj, path56) {
+  if (!path56 || !obj) {
     return void 0;
   }
-  const parts = path55.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path56.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -17621,8 +18064,8 @@ var TokenUsageEvaluator = class {
 
 // src/evaluation/evaluators/tool-trajectory.ts
 init_cjs_shims();
-function getNestedValue(obj, path55) {
-  const parts = path55.split(".");
+function getNestedValue(obj, path56) {
+  const parts = path56.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -18246,7 +18689,7 @@ function runEqualsAssertion(output, value) {
 init_cjs_shims();
 var import_node_crypto11 = require("crypto");
 var import_node_fs16 = require("fs");
-var import_promises34 = require("fs/promises");
+var import_promises35 = require("fs/promises");
 var import_node_path49 = __toESM(require("path"), 1);
 var import_micromatch3 = __toESM(require("micromatch"), 1);
 
@@ -18503,6 +18946,15 @@ async function resolveCustomPrompt(promptConfig, context2, 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, context2, config, timeoutMs) {
   const payload = {
     criteria: context2.evalCase.criteria,
@@ -18575,9 +19027,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
       });
     }
@@ -19070,7 +19533,7 @@ async function stageNestedRepoChanges(workspacePath) {
 
 // src/evaluation/workspace/manager.ts
 init_cjs_shims();
-var import_promises31 = require("fs/promises");
+var import_promises32 = require("fs/promises");
 var import_node_path45 = __toESM(require("path"), 1);
 var TemplateNotFoundError = class extends Error {
   constructor(templatePath) {
@@ -19093,7 +19556,7 @@ var WorkspaceCreationError = class extends Error {
 };
 async function isDirectory(filePath) {
   try {
-    const stats = await (0, import_promises31.stat)(filePath);
+    const stats = await (0, import_promises32.stat)(filePath);
     return stats.isDirectory();
   } catch {
     return false;
@@ -19104,8 +19567,8 @@ function getWorkspacePath(evalRunId, caseId, workspaceRoot) {
   return import_node_path45.default.join(root, evalRunId, caseId);
 }
 async function copyDirectoryRecursive(src, dest) {
-  await (0, import_promises31.mkdir)(dest, { recursive: true });
-  const entries = await (0, import_promises31.readdir)(src, { withFileTypes: true });
+  await (0, import_promises32.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises32.readdir)(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = import_node_path45.default.join(src, entry.name);
     const destPath = import_node_path45.default.join(dest, entry.name);
@@ -19115,7 +19578,7 @@ async function copyDirectoryRecursive(src, dest) {
     if (entry.isDirectory()) {
       await copyDirectoryRecursive(srcPath, destPath);
     } else {
-      await (0, import_promises31.cp)(srcPath, destPath, { preserveTimestamps: true });
+      await (0, import_promises32.cp)(srcPath, destPath, { preserveTimestamps: true });
     }
   }
 }
@@ -19130,7 +19593,7 @@ async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoo
   const workspacePath = getWorkspacePath(evalRunId, caseId, workspaceRoot);
   try {
     if (await fileExists2(workspacePath)) {
-      await (0, import_promises31.rm)(workspacePath, { recursive: true, force: true });
+      await (0, import_promises32.rm)(workspacePath, { recursive: true, force: true });
     }
     await copyDirectoryRecursive(resolvedTemplatePath, workspacePath);
     return workspacePath;
@@ -19164,14 +19627,14 @@ async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoo
 }
 async function cleanupWorkspace(workspacePath) {
   if (await fileExists2(workspacePath)) {
-    await (0, import_promises31.rm)(workspacePath, { recursive: true, force: true });
+    await (0, import_promises32.rm)(workspacePath, { recursive: true, force: true });
   }
 }
 async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
   const evalDir = import_node_path45.default.join(root, evalRunId);
   if (await fileExists2(evalDir)) {
-    await (0, import_promises31.rm)(evalDir, { recursive: true, force: true });
+    await (0, import_promises32.rm)(evalDir, { recursive: true, force: true });
   }
 }
 
@@ -19180,7 +19643,7 @@ init_cjs_shims();
 var import_node_child_process9 = require("child_process");
 var import_node_crypto10 = require("crypto");
 var import_node_fs14 = require("fs");
-var import_promises32 = require("fs/promises");
+var import_promises33 = require("fs/promises");
 var import_node_path46 = __toESM(require("path"), 1);
 var import_node_util5 = require("util");
 var execFileAsync = (0, import_node_util5.promisify)(import_node_child_process9.execFile);
@@ -19208,12 +19671,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;
   }
@@ -19227,13 +19692,13 @@ 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 (0, import_node_crypto10.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex");
 }
 async function copyDirectoryRecursive2(src, dest, skipDirs) {
-  await (0, import_promises32.mkdir)(dest, { recursive: true });
-  const entries = await (0, import_promises32.readdir)(src, { withFileTypes: true });
+  await (0, import_promises33.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises33.readdir)(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = import_node_path46.default.join(src, entry.name);
     const destPath = import_node_path46.default.join(dest, entry.name);
@@ -19246,7 +19711,7 @@ async function copyDirectoryRecursive2(src, dest, skipDirs) {
       }
       await copyDirectoryRecursive2(srcPath, destPath, skipDirs);
     } else {
-      await (0, import_promises32.cp)(srcPath, destPath, { preserveTimestamps: true, force: true });
+      await (0, import_promises33.cp)(srcPath, destPath, { preserveTimestamps: true, force: true });
     }
   }
 }
@@ -19270,7 +19735,7 @@ var WorkspacePoolManager = class {
     const { templatePath, repos, maxSlots, repoManager, poolReset } = options;
     const fingerprint = computeWorkspaceFingerprint(repos);
     const poolDir = import_node_path46.default.join(this.poolRoot, fingerprint);
-    await (0, import_promises32.mkdir)(poolDir, { recursive: true });
+    await (0, import_promises33.mkdir)(poolDir, { recursive: true });
     const drifted = await this.checkDrift(poolDir, fingerprint);
     if (drifted) {
       console.warn(
@@ -19297,7 +19762,7 @@ var WorkspacePoolManager = class {
           poolDir
         };
       }
-      await (0, import_promises32.mkdir)(slotPath, { recursive: true });
+      await (0, import_promises33.mkdir)(slotPath, { recursive: true });
       if (templatePath) {
         await copyDirectoryRecursive2(templatePath, slotPath);
       }
@@ -19321,7 +19786,7 @@ var WorkspacePoolManager = class {
   /** Remove lock file to release a slot. */
   async releaseSlot(slot) {
     try {
-      await (0, import_promises32.unlink)(slot.lockPath);
+      await (0, import_promises33.unlink)(slot.lockPath);
     } catch {
     }
   }
@@ -19334,21 +19799,21 @@ var WorkspacePoolManager = class {
   async tryLock(lockPath) {
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
-        await (0, import_promises32.writeFile)(lockPath, String(process.pid), { flag: "wx" });
+        await (0, import_promises33.writeFile)(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code !== "EEXIST") {
           throw err;
         }
         try {
-          const pidStr = await (0, import_promises32.readFile)(lockPath, "utf-8");
+          const pidStr = await (0, import_promises33.readFile)(lockPath, "utf-8");
           const pid = Number.parseInt(pidStr.trim(), 10);
           if (!Number.isNaN(pid)) {
             try {
               process.kill(pid, 0);
               return false;
             } catch {
-              await (0, import_promises32.unlink)(lockPath).catch(() => {
+              await (0, import_promises33.unlink)(lockPath).catch(() => {
               });
               continue;
             }
@@ -19368,7 +19833,7 @@ var WorkspacePoolManager = class {
   async checkDrift(poolDir, fingerprint) {
     const metadataPath = import_node_path46.default.join(poolDir, "metadata.json");
     try {
-      const raw = await (0, import_promises32.readFile)(metadataPath, "utf-8");
+      const raw = await (0, import_promises33.readFile)(metadataPath, "utf-8");
       const metadata = JSON.parse(raw);
       return metadata.fingerprint !== fingerprint;
     } catch {
@@ -19383,17 +19848,17 @@ var WorkspacePoolManager = class {
       repos,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await (0, import_promises32.writeFile)(import_node_path46.default.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+    await (0, import_promises33.writeFile)(import_node_path46.default.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
   }
   /** Remove all slot directories and their lock files from a pool directory. */
   async removeAllSlots(poolDir) {
-    const entries = await (0, import_promises32.readdir)(poolDir);
+    const entries = await (0, import_promises33.readdir)(poolDir);
     for (const entry of entries) {
       if (entry.startsWith("slot-") && !entry.endsWith(".lock")) {
         const lockPath = import_node_path46.default.join(poolDir, `${entry}.lock`);
         if ((0, import_node_fs14.existsSync)(lockPath)) {
           try {
-            const pidStr = await (0, import_promises32.readFile)(lockPath, "utf-8");
+            const pidStr = await (0, import_promises33.readFile)(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
             if (!Number.isNaN(pid)) {
               try {
@@ -19406,12 +19871,12 @@ var WorkspacePoolManager = class {
           } catch {
           }
         }
-        await (0, import_promises32.rm)(import_node_path46.default.join(poolDir, entry), { recursive: true, force: true });
-        await (0, import_promises32.rm)(lockPath, { force: true }).catch(() => {
+        await (0, import_promises33.rm)(import_node_path46.default.join(poolDir, entry), { recursive: true, force: true });
+        await (0, import_promises33.rm)(lockPath, { force: true }).catch(() => {
         });
       }
     }
-    await (0, import_promises32.rm)(import_node_path46.default.join(poolDir, "metadata.json"), { force: true }).catch(() => {
+    await (0, import_promises33.rm)(import_node_path46.default.join(poolDir, "metadata.json"), { force: true }).catch(() => {
     });
   }
   /**
@@ -19421,6 +19886,7 @@ var WorkspacePoolManager = class {
    */
   async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
     for (const repo of repos) {
+      if (!repo.path || !repo.source) continue;
       const repoDir = import_node_path46.default.join(slotPath, repo.path);
       if (!(0, import_node_fs14.existsSync)(repoDir)) {
         continue;
@@ -19428,7 +19894,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];
@@ -19445,8 +19911,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];
         })
       );
@@ -19502,17 +19968,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 (!(0, import_node_fs15.existsSync)(sourcePath)) {
         errors.push({
-          repoPath: repo.path,
+          repoPath: repo.path ?? "(none)",
           resolvedSourcePath: sourcePath,
           reason: "not_found"
         });
@@ -19559,6 +20025,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 = import_node_path47.default.join(workspacePath, repo.path);
     const sourceUrl = getSourceUrl(repo.source);
     const startedAt = Date.now();
@@ -19582,7 +20054,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") {
@@ -19634,22 +20106,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 = import_node_path47.default.join(workspacePath, repo.path);
       await this.runGit(["reset", "--hard", "HEAD"], { cwd: targetDir });
       await this.runGit(["clean", cleanFlag], { cwd: targetDir });
@@ -19659,14 +20135,14 @@ ${lines.join("\n")}`;
 
 // src/evaluation/workspace/resolve.ts
 init_cjs_shims();
-var import_promises33 = require("fs/promises");
+var import_promises34 = require("fs/promises");
 var import_node_path48 = __toESM(require("path"), 1);
 async function resolveWorkspaceTemplate(templatePath) {
   if (!templatePath) {
     return void 0;
   }
   const resolved = import_node_path48.default.resolve(templatePath);
-  const stats = await (0, import_promises33.stat)(resolved);
+  const stats = await (0, import_promises34.stat)(resolved);
   if (stats.isFile()) {
     return {
       dir: import_node_path48.default.dirname(resolved),
@@ -19676,7 +20152,7 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (!stats.isDirectory()) {
     throw new Error(`workspace template is neither a file nor a directory: ${resolved}`);
   }
-  const entries = await (0, import_promises33.readdir)(resolved);
+  const entries = await (0, import_promises34.readdir)(resolved);
   const workspaceFiles = entries.filter((e) => e.endsWith(".code-workspace"));
   if (workspaceFiles.length === 1) {
     return {
@@ -19696,6 +20172,7 @@ async function resolveWorkspaceTemplate(templatePath) {
 
 // src/evaluation/workspace/script-executor.ts
 init_cjs_shims();
+init_exec();
 function interpolateArgs(args, context2) {
   const vars = {
     workspace_path: context2.workspacePath,
@@ -19975,7 +20452,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);
         }
@@ -19988,7 +20466,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);
       }
     }
@@ -20049,14 +20527,14 @@ async function runEvaluation(options) {
   let staticMaterialised = false;
   const isYamlConfiguredPath = !cliWorkspacePath && !!yamlWorkspacePath;
   if (useStaticWorkspace && configuredStaticPath) {
-    const dirExists = await (0, import_promises34.stat)(configuredStaticPath).then(
+    const dirExists = await (0, import_promises35.stat)(configuredStaticPath).then(
       (s) => s.isDirectory(),
       () => false
     );
-    const isEmpty = dirExists ? (await (0, import_promises34.readdir)(configuredStaticPath)).length === 0 : false;
+    const isEmpty = dirExists ? (await (0, import_promises35.readdir)(configuredStaticPath)).length === 0 : false;
     if (isYamlConfiguredPath && (!dirExists || isEmpty)) {
       if (!dirExists) {
-        await (0, import_promises34.mkdir)(configuredStaticPath, { recursive: true });
+        await (0, import_promises35.mkdir)(configuredStaticPath, { recursive: true });
       }
       if (workspaceTemplate) {
         await copyDirectoryRecursive(workspaceTemplate, configuredStaticPath);
@@ -20101,14 +20579,14 @@ async function runEvaluation(options) {
     }
   } else if (suiteWorkspace?.hooks || suiteWorkspace?.repos?.length && !isPerTestIsolation) {
     sharedWorkspacePath = getWorkspacePath(evalRunId, "shared");
-    await (0, import_promises34.mkdir)(sharedWorkspacePath, { recursive: true });
+    await (0, import_promises35.mkdir)(sharedWorkspacePath, { recursive: true });
     setupLog(`created empty shared workspace at: ${sharedWorkspacePath}`);
   }
   try {
     if (suiteWorkspaceFile && sharedWorkspacePath) {
       const copiedWorkspaceFile = import_node_path49.default.join(sharedWorkspacePath, import_node_path49.default.basename(suiteWorkspaceFile));
       try {
-        await (0, import_promises34.stat)(copiedWorkspaceFile);
+        await (0, import_promises35.stat)(copiedWorkspaceFile);
         suiteWorkspaceFile = copiedWorkspaceFile;
       } catch {
       }
@@ -20121,6 +20599,7 @@ async function runEvaluation(options) {
       try {
         if (needsPerRepoCheck) {
           for (const repo of suiteWorkspace.repos) {
+            if (!repo.path || !repo.source) continue;
             const targetDir = import_node_path49.default.join(sharedWorkspacePath, repo.path);
             if ((0, import_node_fs16.existsSync)(targetDir)) {
               setupLog(`reusing existing repo at: ${targetDir}`);
@@ -20145,6 +20624,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 Promise.resolve().then(() => (init_docker_workspace(), docker_workspace_exports));
+      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)) {
@@ -20505,11 +20997,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);
@@ -20710,7 +21200,7 @@ async function runEvalCase(options) {
       if (caseWorkspaceFile && workspacePath) {
         const copiedFile = import_node_path49.default.join(workspacePath, import_node_path49.default.basename(caseWorkspaceFile));
         try {
-          await (0, import_promises34.stat)(copiedFile);
+          await (0, import_promises35.stat)(copiedFile);
           caseWorkspaceFile = copiedFile;
         } catch {
         }
@@ -20718,7 +21208,7 @@ async function runEvalCase(options) {
     }
     if (!workspacePath && (evalCase.workspace?.hooks || evalCase.workspace?.repos?.length) && evalRunId) {
       workspacePath = getWorkspacePath(evalRunId, evalCase.id);
-      await (0, import_promises34.mkdir)(workspacePath, { recursive: true });
+      await (0, import_promises35.mkdir)(workspacePath, { recursive: true });
     }
     if (evalCase.workspace?.repos?.length && workspacePath) {
       const localPathErrors = RepoManager.validateLocalPaths(evalCase.workspace.repos);
@@ -20773,8 +21263,8 @@ async function runEvalCase(options) {
           const srcPath = import_node_path49.default.resolve(baseDir, relPath);
           const destPath = import_node_path49.default.resolve(workspacePath, relPath);
           try {
-            await (0, import_promises34.mkdir)(import_node_path49.default.dirname(destPath), { recursive: true });
-            await (0, import_promises34.copyFile)(srcPath, destPath);
+            await (0, import_promises35.mkdir)(import_node_path49.default.dirname(destPath), { recursive: true });
+            await (0, import_promises35.copyFile)(srcPath, destPath);
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             return buildErrorResult(
@@ -21040,6 +21530,7 @@ async function runEvalCase(options) {
       availableTargets,
       fileChanges,
       workspacePath,
+      dockerConfig: evalCase.workspace?.docker,
       verbose,
       threshold: evalCase.threshold ?? caseThreshold
     });
@@ -21233,6 +21724,7 @@ async function evaluateCandidate(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     threshold: evalThreshold
   } = options;
   const gradeTimestamp = nowFn();
@@ -21259,6 +21751,7 @@ async function evaluateCandidate(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     threshold: evalThreshold
   });
   const completedAt = nowFn();
@@ -21334,6 +21827,7 @@ async function runEvaluatorsForCase(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     threshold
   } = options;
   if (evalCase.assertions && evalCase.assertions.length > 0) {
@@ -21361,6 +21855,7 @@ async function runEvaluatorsForCase(options) {
       availableTargets,
       fileChanges,
       workspacePath,
+      dockerConfig,
       threshold
     });
   }
@@ -21390,6 +21885,7 @@ async function runEvaluatorsForCase(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     ...implicitEvaluator ? { evaluator: implicitEvaluator } : {}
   });
   return { score };
@@ -21428,7 +21924,8 @@ async function runEvaluatorList(options) {
     targetResolver,
     availableTargets,
     fileChanges,
-    workspacePath
+    workspacePath,
+    dockerConfig
   } = options;
   const scored = [];
   const scores = [];
@@ -21451,7 +21948,8 @@ async function runEvaluatorList(options) {
     targetResolver,
     availableTargets,
     fileChanges,
-    workspacePath
+    workspacePath,
+    dockerConfig
   };
   const evalFileDir = evalCase.file_paths[0] ? import_node_path49.default.dirname(evalCase.file_paths[0]) : process.cwd();
   const dispatchContext = {
@@ -21613,13 +22111,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,
@@ -21991,7 +22487,7 @@ async function discoverDefaultTarget(repoRoot) {
   return null;
 }
 async function loadEnvHierarchy(repoRoot, startPath) {
-  const { readFileSync: readFileSync4 } = await import("fs");
+  const { readFileSync: readFileSync5 } = await import("fs");
   const chain = buildDirectoryChain2(startPath, repoRoot);
   const envFiles = [];
   for (const dir of chain) {
@@ -22000,7 +22496,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;
@@ -22073,12 +22569,12 @@ var CONFIG_FILE_NAMES = [
   ".agentv/config.js"
 ];
 async function loadTsConfig(projectRoot) {
-  const { existsSync: existsSync8 } = await import("fs");
+  const { existsSync: existsSync9 } = await import("fs");
   const { pathToFileURL: pathToFileURL2 } = await import("url");
   const { join: join2 } = await import("path");
   for (const fileName of CONFIG_FILE_NAMES) {
     const filePath = join2(projectRoot, fileName);
-    if (!existsSync8(filePath)) {
+    if (!existsSync9(filePath)) {
       continue;
     }
     try {
@@ -22183,9 +22679,9 @@ init_cjs_shims();
 
 // src/evaluation/workspace/deps-scanner.ts
 init_cjs_shims();
-var import_promises35 = require("fs/promises");
+var import_promises36 = require("fs/promises");
 var import_node_path51 = __toESM(require("path"), 1);
-var import_yaml8 = require("yaml");
+var import_yaml9 = require("yaml");
 function normalizeGitUrl(url) {
   let normalized = url.replace(/\.git$/, "");
   try {
@@ -22203,7 +22699,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);
@@ -22231,8 +22727,8 @@ async function scanRepoDeps(evalFilePaths) {
   return { repos: [...seen.values()], errors };
 }
 async function extractReposFromEvalFile(filePath) {
-  const content = await (0, import_promises35.readFile)(filePath, "utf8");
-  const parsed = interpolateEnv((0, import_yaml8.parse)(content), process.env);
+  const content = await (0, import_promises36.readFile)(filePath, "utf8");
+  const parsed = interpolateEnv((0, import_yaml9.parse)(content), process.env);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
   const obj = parsed;
   const evalFileDir = import_node_path51.default.dirname(import_node_path51.default.resolve(filePath));
@@ -22252,8 +22748,8 @@ async function extractReposFromEvalFile(filePath) {
 async function extractReposFromWorkspaceRaw(raw, evalFileDir) {
   if (typeof raw === "string") {
     const workspaceFilePath = import_node_path51.default.resolve(evalFileDir, raw);
-    const content = await (0, import_promises35.readFile)(workspaceFilePath, "utf8");
-    const parsed = interpolateEnv((0, import_yaml8.parse)(content), process.env);
+    const content = await (0, import_promises36.readFile)(workspaceFilePath, "utf8");
+    const parsed = interpolateEnv((0, import_yaml9.parse)(content), process.env);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
     return extractReposFromObject(parsed);
   }
@@ -22279,9 +22775,12 @@ function extractReposFromObject(obj) {
   return result;
 }
 
+// src/evaluation/workspace/index.ts
+init_docker_workspace();
+
 // src/evaluation/cache/response-cache.ts
 init_cjs_shims();
-var import_promises36 = require("fs/promises");
+var import_promises37 = require("fs/promises");
 var import_node_path52 = __toESM(require("path"), 1);
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
@@ -22292,7 +22791,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await (0, import_promises36.readFile)(filePath, "utf8");
+      const data = await (0, import_promises37.readFile)(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -22301,8 +22800,8 @@ var ResponseCache = class {
   async set(key, value) {
     const filePath = this.keyToPath(key);
     const dir = import_node_path52.default.dirname(filePath);
-    await (0, import_promises36.mkdir)(dir, { recursive: true });
-    await (0, import_promises36.writeFile)(filePath, JSON.stringify(value, null, 2), "utf8");
+    await (0, import_promises37.mkdir)(dir, { recursive: true });
+    await (0, import_promises37.writeFile)(filePath, JSON.stringify(value, null, 2), "utf8");
   }
   keyToPath(key) {
     const prefix = key.slice(0, 2);
@@ -22321,22 +22820,304 @@ function shouldSkipCacheForTemperature(targetConfig) {
   return false;
 }
 
-// src/projects.ts
+// src/evaluation/results-repo.ts
 init_cjs_shims();
+var import_node_child_process11 = require("child_process");
 var import_node_fs18 = require("fs");
+var import_promises38 = require("fs/promises");
+var import_node_os8 = __toESM(require("os"), 1);
 var import_node_path53 = __toESM(require("path"), 1);
-var import_yaml9 = require("yaml");
+var import_node_util7 = require("util");
+var execFileAsync3 = (0, import_node_util7.promisify)(import_node_child_process11.execFile);
+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 = import_node_path53.default.join(getAgentvHome(), "cache", "results-repo", sanitizeRepoSlug(repo));
+  return {
+    rootDir,
+    repoDir: import_node_path53.default.join(rootDir, "repo"),
+    statusFile: import_node_path53.default.join(rootDir, "status.json")
+  };
+}
+function readPersistedStatus(statusFile) {
+  if (!(0, import_node_fs18.existsSync)(statusFile)) {
+    return {};
+  }
+  try {
+    return JSON.parse((0, import_node_fs18.readFileSync)(statusFile, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writePersistedStatus(statusFile, status) {
+  (0, import_node_fs18.mkdirSync)(import_node_path53.default.dirname(statusFile), { recursive: true });
+  (0, import_node_fs18.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);
+  (0, import_node_fs18.mkdirSync)(cachePaths.rootDir, { recursive: true });
+  if (!(0, import_node_fs18.existsSync)(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 (!(0, import_node_fs18.existsSync)(import_node_path53.default.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: (0, import_node_fs18.existsSync)(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 (0, import_promises38.mkdtemp)(import_node_path53.default.join(import_node_os8.default.tmpdir(), "agentv-results-repo-"));
+  const worktreeDir = import_node_path53.default.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 (0, import_promises38.rm)(worktreeRoot, { recursive: true, force: true }).catch(() => void 0);
+      }
+    }
+  };
+}
+async function stageResultsArtifacts(params) {
+  (0, import_node_fs18.rmSync)(params.destinationDir, { recursive: true, force: true });
+  (0, import_node_fs18.mkdirSync)(import_node_path53.default.dirname(params.destinationDir), { recursive: true });
+  await (0, import_promises38.cp)(params.sourceDir, params.destinationDir, { recursive: true });
+}
+function resolveResultsRepoRunsDir(config) {
+  const normalized = normalizeResultsExportConfig(config);
+  return import_node_path53.default.join(
+    getResultsRepoCachePaths(normalized.repo).repoDir,
+    ...normalized.path.split("/")
+  );
+}
+async function directorySizeBytes(targetPath) {
+  const entry = await (0, import_promises38.stat)(targetPath);
+  if (entry.isFile()) {
+    return entry.size;
+  }
+  let total = 0;
+  for (const child of await (0, import_promises38.readdir)(targetPath, { withFileTypes: true })) {
+    total += await directorySizeBytes(import_node_path53.default.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
+init_cjs_shims();
+var import_node_fs19 = require("fs");
+var import_node_path54 = __toESM(require("path"), 1);
+var import_yaml10 = require("yaml");
 function getProjectsRegistryPath() {
-  return import_node_path53.default.join(getAgentvHome(), "projects.yaml");
+  return import_node_path54.default.join(getAgentvHome(), "projects.yaml");
 }
 function loadProjectRegistry() {
   const registryPath = getProjectsRegistryPath();
-  if (!(0, import_node_fs18.existsSync)(registryPath)) {
+  if (!(0, import_node_fs19.existsSync)(registryPath)) {
     return { projects: [] };
   }
   try {
-    const raw = (0, import_node_fs18.readFileSync)(registryPath, "utf-8");
-    const parsed = (0, import_yaml9.parse)(raw);
+    const raw = (0, import_node_fs19.readFileSync)(registryPath, "utf-8");
+    const parsed = (0, import_yaml10.parse)(raw);
     if (!parsed || !Array.isArray(parsed.projects)) {
       return { projects: [] };
     }
@@ -22347,14 +23128,14 @@ function loadProjectRegistry() {
 }
 function saveProjectRegistry(registry) {
   const registryPath = getProjectsRegistryPath();
-  const dir = import_node_path53.default.dirname(registryPath);
-  if (!(0, import_node_fs18.existsSync)(dir)) {
-    (0, import_node_fs18.mkdirSync)(dir, { recursive: true });
+  const dir = import_node_path54.default.dirname(registryPath);
+  if (!(0, import_node_fs19.existsSync)(dir)) {
+    (0, import_node_fs19.mkdirSync)(dir, { recursive: true });
   }
-  (0, import_node_fs18.writeFileSync)(registryPath, (0, import_yaml9.stringify)(registry), "utf-8");
+  (0, import_node_fs19.writeFileSync)(registryPath, (0, import_yaml10.stringify)(registry), "utf-8");
 }
 function deriveProjectId(dirPath, existingIds) {
-  const base = import_node_path53.default.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const base = import_node_path54.default.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   let candidate = base || "project";
   let suffix = 2;
   while (existingIds.includes(candidate)) {
@@ -22364,11 +23145,11 @@ function deriveProjectId(dirPath, existingIds) {
   return candidate;
 }
 function addProject(projectPath) {
-  const absPath = import_node_path53.default.resolve(projectPath);
-  if (!(0, import_node_fs18.existsSync)(absPath)) {
+  const absPath = import_node_path54.default.resolve(projectPath);
+  if (!(0, import_node_fs19.existsSync)(absPath)) {
     throw new Error(`Directory not found: ${absPath}`);
   }
-  if (!(0, import_node_fs18.existsSync)(import_node_path53.default.join(absPath, ".agentv"))) {
+  if (!(0, import_node_fs19.existsSync)(import_node_path54.default.join(absPath, ".agentv"))) {
     throw new Error(`No .agentv/ directory found in ${absPath}. Run an evaluation first.`);
   }
   const registry = loadProjectRegistry();
@@ -22382,7 +23163,7 @@ function addProject(projectPath) {
       absPath,
       registry.projects.map((p) => p.id)
     ),
-    name: import_node_path53.default.basename(absPath),
+    name: import_node_path54.default.basename(absPath),
     path: absPath,
     addedAt: now,
     lastOpenedAt: now
@@ -22411,24 +23192,24 @@ function touchProject(projectId) {
   }
 }
 function discoverProjects(rootDir, maxDepth = 2) {
-  const absRoot = import_node_path53.default.resolve(rootDir);
-  if (!(0, import_node_fs18.existsSync)(absRoot) || !(0, import_node_fs18.statSync)(absRoot).isDirectory()) {
+  const absRoot = import_node_path54.default.resolve(rootDir);
+  if (!(0, import_node_fs19.existsSync)(absRoot) || !(0, import_node_fs19.statSync)(absRoot).isDirectory()) {
     return [];
   }
   const results = [];
   function scan(dir, depth) {
     if (depth > maxDepth) return;
-    if ((0, import_node_fs18.existsSync)(import_node_path53.default.join(dir, ".agentv"))) {
+    if ((0, import_node_fs19.existsSync)(import_node_path54.default.join(dir, ".agentv"))) {
       results.push(dir);
       return;
     }
     if (depth === maxDepth) return;
     try {
-      const entries = (0, import_node_fs18.readdirSync)(dir, { withFileTypes: true });
+      const entries = (0, import_node_fs19.readdirSync)(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-        scan(import_node_path53.default.join(dir, entry.name), depth + 1);
+        scan(import_node_path54.default.join(dir, entry.name), depth + 1);
       }
     } catch {
     }
@@ -23354,33 +24135,33 @@ function extractResponseItemContent(content) {
 
 // src/import/codex-session-discovery.ts
 init_cjs_shims();
-var import_promises38 = require("fs/promises");
-var import_node_os8 = require("os");
-var import_node_path55 = __toESM(require("path"), 1);
-var DEFAULT_SESSIONS_DIR = () => import_node_path55.default.join((0, import_node_os8.homedir)(), ".codex", "sessions");
+var import_promises40 = require("fs/promises");
+var import_node_os9 = require("os");
+var import_node_path56 = __toESM(require("path"), 1);
+var DEFAULT_SESSIONS_DIR = () => import_node_path56.default.join((0, import_node_os9.homedir)(), ".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 (0, import_promises38.readdir)(sessionsDir);
+    yearDirs = await (0, import_promises40.readdir)(sessionsDir);
   } catch {
     return [];
   }
   for (const year of yearDirs) {
-    const yearPath = import_node_path55.default.join(sessionsDir, year);
+    const yearPath = import_node_path56.default.join(sessionsDir, year);
     let monthDirs;
     try {
-      monthDirs = await (0, import_promises38.readdir)(yearPath);
+      monthDirs = await (0, import_promises40.readdir)(yearPath);
     } catch {
       continue;
     }
     for (const month of monthDirs) {
-      const monthPath = import_node_path55.default.join(yearPath, month);
+      const monthPath = import_node_path56.default.join(yearPath, month);
       let dayDirs;
       try {
-        dayDirs = await (0, import_promises38.readdir)(monthPath);
+        dayDirs = await (0, import_promises40.readdir)(monthPath);
       } catch {
         continue;
       }
@@ -23389,22 +24170,22 @@ async function discoverCodexSessions(opts) {
           const dirDate = `${year}-${month}-${day}`;
           if (dirDate !== opts.date) continue;
         }
-        const dayPath = import_node_path55.default.join(monthPath, day);
+        const dayPath = import_node_path56.default.join(monthPath, day);
         let files;
         try {
-          files = await (0, import_promises38.readdir)(dayPath);
+          files = await (0, import_promises40.readdir)(dayPath);
         } catch {
           continue;
         }
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = import_node_path55.default.join(dayPath, file);
+          const filePath = import_node_path56.default.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 (0, import_promises38.stat)(filePath);
+            const fileStat = await (0, import_promises40.stat)(filePath);
             updatedAt = fileStat.mtime;
           } catch {
             updatedAt = /* @__PURE__ */ new Date(0);
@@ -23420,10 +24201,10 @@ async function discoverCodexSessions(opts) {
 
 // src/import/session-discovery.ts
 init_cjs_shims();
-var import_promises39 = require("fs/promises");
-var import_node_os9 = require("os");
-var import_node_path56 = __toESM(require("path"), 1);
-var DEFAULT_PROJECTS_DIR = () => import_node_path56.default.join((0, import_node_os9.homedir)(), ".claude", "projects");
+var import_promises41 = require("fs/promises");
+var import_node_os10 = require("os");
+var import_node_path57 = __toESM(require("path"), 1);
+var DEFAULT_PROJECTS_DIR = () => import_node_path57.default.join((0, import_node_os10.homedir)(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -23432,7 +24213,7 @@ async function discoverClaudeSessions(opts) {
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
   let projectDirs;
   try {
-    projectDirs = await (0, import_promises39.readdir)(projectsDir);
+    projectDirs = await (0, import_promises41.readdir)(projectsDir);
   } catch {
     return [];
   }
@@ -23442,10 +24223,10 @@ async function discoverClaudeSessions(opts) {
   }
   const sessions = [];
   for (const projectDir of projectDirs) {
-    const dirPath = import_node_path56.default.join(projectsDir, projectDir);
+    const dirPath = import_node_path57.default.join(projectsDir, projectDir);
     let entries;
     try {
-      entries = await (0, import_promises39.readdir)(dirPath);
+      entries = await (0, import_promises41.readdir)(dirPath);
     } catch {
       continue;
     }
@@ -23453,10 +24234,10 @@ async function discoverClaudeSessions(opts) {
       if (!entry.endsWith(".jsonl")) continue;
       const sessionId = entry.replace(/\.jsonl$/, "");
       if (opts?.sessionId && sessionId !== opts.sessionId) continue;
-      const filePath = import_node_path56.default.join(dirPath, entry);
+      const filePath = import_node_path57.default.join(dirPath, entry);
       let updatedAt;
       try {
-        const fileStat = await (0, import_promises39.stat)(filePath);
+        const fileStat = await (0, import_promises41.stat)(filePath);
         updatedAt = fileStat.mtime;
       } catch {
         updatedAt = /* @__PURE__ */ new Date(0);
@@ -23478,7 +24259,7 @@ init_cjs_shims();
 
 // src/import/types.ts
 init_cjs_shims();
-var import_promises40 = require("fs/promises");
+var import_promises42 = require("fs/promises");
 function toTranscriptJsonLine(entry) {
   const firstUserMessage = entry.messages.find((m) => m.role === "user");
   const input = typeof firstUserMessage?.content === "string" ? firstUserMessage.content : "";
@@ -23504,11 +24285,11 @@ function toTranscriptJsonLine(entry) {
   };
 }
 async function readTranscriptJsonl(filePath) {
-  const text = await (0, import_promises40.readFile)(filePath, "utf8");
+  const text = await (0, import_promises42.readFile)(filePath, "utf8");
   return text.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
 }
 async function readTranscriptFile(filePath) {
-  return (0, import_promises40.readFile)(filePath, "utf8");
+  return (0, import_promises42.readFile)(filePath, "utf8");
 }
 
 // src/import/transcript-provider.ts
@@ -23574,6 +24355,7 @@ function createAgentKernel() {
   DEFAULT_EXPLORATION_TOOLS,
   DEFAULT_THRESHOLD,
   DeterministicAssertionEvaluator,
+  DockerWorkspaceProvider,
   EvaluatorRegistry,
   ExecutionMetricsEvaluator,
   FieldAccuracyEvaluator,
@@ -23609,9 +24391,11 @@ function createAgentKernel() {
   buildSearchRoots,
   calculateRubricScore,
   captureFileChanges,
+  checkoutResultsRepoBranch,
   clampScore,
   cleanupEvalWorkspaces,
   cleanupWorkspace,
+  commitAndPushResultsBranch,
   computeTraceSummary,
   computeWorkspaceFingerprint,
   consumeClaudeLogEntries,
@@ -23622,6 +24406,7 @@ function createAgentKernel() {
   createAgentKernel,
   createBuiltinProviderRegistry,
   createBuiltinRegistry,
+  createDraftResultsPr,
   createProvider,
   createTempWorkspace,
   deepEqual,
@@ -23629,6 +24414,7 @@ function createAgentKernel() {
   deriveCategory,
   deriveProjectId,
   detectFormat,
+  directorySizeBytes,
   discoverAssertions,
   discoverClaudeSessions,
   discoverCodexSessions,
@@ -23637,6 +24423,7 @@ function createAgentKernel() {
   discoverJudges,
   discoverProjects,
   discoverProviders,
+  ensureResultsRepoClone,
   ensureVSCodeSubagents,
   evaluate,
   executeScript,
@@ -23661,6 +24448,8 @@ function createAgentKernel() {
   getOutputFilenames,
   getProject,
   getProjectsRegistryPath,
+  getResultsRepoCachePaths,
+  getResultsRepoStatus,
   getSubagentsRoot,
   getTextContent,
   getTraceStateRoot,
@@ -23690,12 +24479,15 @@ function createAgentKernel() {
   mergeExecutionMetrics,
   negateScore,
   normalizeLineEndings,
+  normalizeResultsExportConfig,
   parseAgentSkillsEvals,
   parseClaudeSession,
   parseCodexSession,
   parseCopilotEvents,
   parseJsonFromText,
   parseJsonSafe,
+  prepareResultsRepoBranch,
+  pushResultsRepoBranch,
   readJsonFile,
   readTargetDefinitions,
   readTestSuiteMetadata,
@@ -23706,6 +24498,8 @@ function createAgentKernel() {
   resolveAndCreateProvider,
   resolveDelegatedTargetDefinition,
   resolveFileReference,
+  resolveResultsRepoRunsDir,
+  resolveResultsRepoUrl,
   resolveTargetDefinition,
   resolveWorkspaceTemplate,
   rubricEvaluationSchema,
@@ -23727,12 +24521,14 @@ function createAgentKernel() {
   scoreToVerdict,
   shouldEnableCache,
   shouldSkipCacheForTemperature,
+  stageResultsArtifacts,
   subscribeToClaudeLogEntries,
   subscribeToCodexLogEntries,
   subscribeToCopilotCliLogEntries,
   subscribeToCopilotSdkLogEntries,
   subscribeToPiLogEntries,
   substituteVariables,
+  syncResultsRepo,
   toCamelCaseDeep,
   toSnakeCaseDeep,
   toTranscriptJsonLine,