agentv 4.9.1 → 4.11.0

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

@@ -1,7 +1,17 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  execFileWithStdin,
+  execShellWithStdin
+} from "./chunk-NPVGBFF6.js";
 import {
   require_token_error
 } from "./chunk-HQDCIXVH.js";
+import {
+  SpanStatusCode,
+  context,
+  init_esm,
+  trace
+} from "./chunk-LRULMAAA.js";
 import {
   AISDKError,
   APICallError,
@@ -150,12 +160,6 @@ import {
   withoutTrailingSlash,
   zodSchema
 } from "./chunk-ZKO2LGRR.js";
-import {
-  SpanStatusCode,
-  context,
-  init_esm,
-  trace
-} from "./chunk-LRULMAAA.js";
 import {
   __commonJS,
   __export,
@@ -301,7 +305,7 @@ var require_dist = __commonJS({
   }
 });
 
-// ../../packages/core/dist/chunk-VCVVKCC4.js
+// ../../packages/core/dist/chunk-5POFMJJ7.js
 import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
@@ -419,7 +423,7 @@ __export(external_exports2, {
   void: () => voidType
 });
 
-// ../../packages/core/dist/chunk-VCVVKCC4.js
+// ../../packages/core/dist/chunk-5POFMJJ7.js
 import { readFile as readFile2 } from "node:fs/promises";
 import path3 from "node:path";
 import fg from "fast-glob";
@@ -2308,10 +2312,10 @@ async function expandFileReferences(tests, evalFileDir) {
 }
 
 // ../../packages/core/dist/index.js
-import { readFile as readFile6 } from "node:fs/promises";
-import path7 from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import path8 from "node:path";
 import micromatch2 from "micromatch";
-import { parse as parse2 } from "yaml";
+import { parse as parse3 } from "yaml";
 import { readFile as readFile3 } from "node:fs/promises";
 import path4 from "node:path";
 import { readFile as readFile22 } from "node:fs/promises";
@@ -2321,17 +2325,22 @@ import { constants as constants2 } from "node:fs";
 import { access as access2 } from "node:fs/promises";
 import path22 from "node:path";
 import { fileURLToPath } from "node:url";
-import path42 from "node:path";
-import { readFile as readFile32 } from "node:fs/promises";
 import { readFile as readFile5 } from "node:fs/promises";
-import path6 from "node:path";
+import path5 from "node:path";
+import { parse as parse2 } from "yaml";
+import { readFile as readFile32 } from "node:fs/promises";
+import path42 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
+import path7 from "node:path";
 import micromatch from "micromatch";
 import { parse as parseYaml2 } from "yaml";
-import { readFile as readFile4 } from "node:fs/promises";
-import path5 from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import path6 from "node:path";
 import { readFileSync } from "node:fs";
-import path8 from "node:path";
-import { parse as parse3 } from "yaml";
+import path9 from "node:path";
+import { parse as parse4 } from "yaml";
 import { createOpenAI } from "@ai-sdk/openai";
 
 // ../../node_modules/.bun/@openrouter+ai-sdk-provider@2.3.3+3ab978b6804fd9e7/node_modules/@openrouter/ai-sdk-provider/dist/index.mjs
@@ -6941,7 +6950,7 @@ function createOpenRouter(options = {}) {
   );
   const createChatModel = (modelId, settings = {}) => new OpenRouterChatLanguageModel(modelId, settings, {
     provider: "openrouter.chat",
-    url: ({ path: path51 }) => `${baseURL}${path51}`,
+    url: ({ path: path53 }) => `${baseURL}${path53}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -6949,7 +6958,7 @@ function createOpenRouter(options = {}) {
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenRouterCompletionLanguageModel(modelId, settings, {
     provider: "openrouter.completion",
-    url: ({ path: path51 }) => `${baseURL}${path51}`,
+    url: ({ path: path53 }) => `${baseURL}${path53}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -6957,14 +6966,14 @@ function createOpenRouter(options = {}) {
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenRouterEmbeddingModel(modelId, settings, {
     provider: "openrouter.embedding",
-    url: ({ path: path51 }) => `${baseURL}${path51}`,
+    url: ({ path: path53 }) => `${baseURL}${path53}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
   });
   const createImageModel = (modelId, settings = {}) => new OpenRouterImageModel(modelId, settings, {
     provider: "openrouter.image",
-    url: ({ path: path51 }) => `${baseURL}${path51}`,
+    url: ({ path: path53 }) => `${baseURL}${path53}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
@@ -12960,24 +12969,24 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { createWriteStream } from "node:fs";
 import { mkdir } from "node:fs/promises";
+import path11 from "node:path";
 import path10 from "node:path";
-import path9 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { createWriteStream as createWriteStream2 } from "node:fs";
 import { mkdir as mkdir2 } from "node:fs/promises";
-import path11 from "node:path";
+import path12 from "node:path";
 import { exec as execWithCallback } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
-import path12 from "node:path";
+import path13 from "node:path";
 import { promisify } from "node:util";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { createWriteStream as createWriteStream3 } from "node:fs";
 import { mkdir as mkdir3 } from "node:fs/promises";
-import path13 from "node:path";
+import path14 from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { mkdir as mkdir4 } from "node:fs/promises";
-import path15 from "node:path";
+import path16 from "node:path";
 import { Readable, Writable } from "node:stream";
 import { spawn as spawn2 } from "node:child_process";
 
@@ -14462,63 +14471,63 @@ var RequestError = class _RequestError extends Error {
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { createWriteStream as createWriteStream4, existsSync, readdirSync } from "node:fs";
 import { arch, platform } from "node:os";
-import path14 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { readFile as readFile8 } from "node:fs/promises";
+import path15 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { readFile as readFile10 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path17 from "node:path";
-import { readFile as readFile7, readdir, stat } from "node:fs/promises";
+import path18 from "node:path";
+import { readFile as readFile9, readdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
 import { parse as parseYaml22 } from "yaml";
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
 import { mkdir as mkdir5 } from "node:fs/promises";
-import path18 from "node:path";
+import path19 from "node:path";
 import { execSync, spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { accessSync, createWriteStream as createWriteStream5, readFileSync as readFileSync2 } from "node:fs";
 import { mkdir as mkdir6, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path19 from "node:path";
+import path20 from "node:path";
 import { execSync as execSync2 } from "node:child_process";
 import { randomUUID as randomUUID8 } from "node:crypto";
 import { accessSync as accessSync2, createWriteStream as createWriteStream6, mkdirSync } from "node:fs";
 import { mkdir as mkdir7 } from "node:fs/promises";
-import path21 from "node:path";
+import path222 from "node:path";
 import { createInterface } from "node:readline";
-import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
+import { fileURLToPath as fileURLToPath4, pathToFileURL } from "node:url";
 import os2 from "node:os";
-import path20 from "node:path";
+import path21 from "node:path";
 import { exec as exec2 } from "node:child_process";
 import { constants as constants3, access as access3, stat as stat5 } from "node:fs/promises";
-import path322 from "node:path";
+import path33 from "node:path";
 import { promisify as promisify3 } from "node:util";
 import { stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
-import path30 from "node:path";
+import path31 from "node:path";
 import { constants as constants22 } from "node:fs";
 import { access as access22, mkdir as mkdir8, readdir as readdir2, rm as rm2, stat as stat2 } from "node:fs/promises";
-import path222 from "node:path";
 import path23 from "node:path";
 import path24 from "node:path";
-import { readFile as readFile9 } from "node:fs/promises";
 import path25 from "node:path";
+import { readFile as readFile11 } from "node:fs/promises";
+import path26 from "node:path";
 import { exec, spawn as spawn4 } from "node:child_process";
 import { mkdir as mkdir9, writeFile as writeFile2 } from "node:fs/promises";
-import path27 from "node:path";
+import path28 from "node:path";
 import { promisify as promisify2 } from "node:util";
-import path26 from "node:path";
-import { copyFile, mkdir as mkdir10, readFile as readFile10, readdir as readdir3, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
+import path27 from "node:path";
+import { copyFile, mkdir as mkdir10, readFile as readFile12, readdir as readdir3, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
+import path30 from "node:path";
 import path29 from "node:path";
-import path28 from "node:path";
 import JSON5 from "json5";
 import { writeFile as writeFile5 } from "node:fs/promises";
-import path31 from "node:path";
+import path322 from "node:path";
 import { constants as constants4 } from "node:fs";
-import { access as access4, readFile as readFile11 } from "node:fs/promises";
-import path33 from "node:path";
-import { parse as parse4 } from "yaml";
+import { access as access4, readFile as readFile13 } from "node:fs/promises";
 import path34 from "node:path";
+import { parse as parse5 } from "yaml";
+import path35 from "node:path";
 import fg2 from "fast-glob";
 import { mkdtemp as mkdtemp2, rm as rm3, writeFile as writeFile6 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
@@ -14526,52 +14535,58 @@ import { dirname, join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { createServer } from "node:http";
 import fs2 from "node:fs/promises";
-import path35 from "node:path";
+import path36 from "node:path";
 import { createHash as createHash2, randomUUID as randomUUID9 } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
 import { copyFile as copyFile2, mkdir as mkdir14, readdir as readdir7, stat as stat8 } from "node:fs/promises";
-import path44 from "node:path";
+import path45 from "node:path";
 import micromatch3 from "micromatch";
-import path36 from "node:path";
 import path37 from "node:path";
-import fg22 from "fast-glob";
 import path38 from "node:path";
+import fg22 from "fast-glob";
+import path39 from "node:path";
 import fg3 from "fast-glob";
 import { exec as execCallback } from "node:child_process";
 import { readdirSync as readdirSync2, statSync } from "node:fs";
-import path39 from "node:path";
+import path40 from "node:path";
 import { promisify as promisify4 } from "node:util";
 import { cp, mkdir as mkdir12, readdir as readdir4, rm as rm4, stat as stat6 } from "node:fs/promises";
-import path40 from "node:path";
+import path41 from "node:path";
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync as existsSync3 } from "node:fs";
-import { cp as cp2, mkdir as mkdir13, readFile as readFile12, readdir as readdir5, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
-import path41 from "node:path";
+import { cp as cp2, mkdir as mkdir13, readFile as readFile14, readdir as readdir5, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
+import path422 from "node:path";
 import { promisify as promisify5 } from "node:util";
 import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync4 } from "node:fs";
-import path422 from "node:path";
+import path43 from "node:path";
 import { promisify as promisify6 } from "node:util";
 import { readdir as readdir6, stat as stat7 } from "node:fs/promises";
-import path43 from "node:path";
+import path44 from "node:path";
 import { existsSync as existsSync6 } from "node:fs";
-import path45 from "node:path";
-import { readFile as readFile13 } from "node:fs/promises";
 import path46 from "node:path";
-import { parse as parse5 } from "yaml";
-import { mkdir as mkdir15, readFile as readFile14, writeFile as writeFile8 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 import path47 from "node:path";
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync2, writeFileSync } from "node:fs";
+import { parse as parse6 } from "yaml";
+import { mkdir as mkdir15, readFile as readFile16, writeFile as writeFile8 } from "node:fs/promises";
 import path48 from "node:path";
-import { parse as parseYaml3, stringify as stringifyYaml } from "yaml";
-import { readdir as readdir8, stat as stat9 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
+import { execFile as execFile3 } from "node:child_process";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync } from "node:fs";
+import { cp as cp3, mkdtemp as mkdtemp3, readdir as readdir8, rm as rm6, stat as stat9 } from "node:fs/promises";
+import os3 from "node:os";
 import path49 from "node:path";
+import { promisify as promisify7 } from "node:util";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import path50 from "node:path";
+import { parse as parseYaml3, stringify as stringifyYaml } from "yaml";
 import { readdir as readdir9, stat as stat10 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import path51 from "node:path";
+import { readdir as readdir10, stat as stat11 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import path50 from "node:path";
-import { readFile as readFile15 } from "node:fs/promises";
+import path52 from "node:path";
+import { readFile as readFile17 } from "node:fs/promises";
 function computeTraceSummary(messages) {
   const toolCallCounts = {};
   const toolDurations = {};
@@ -14954,10 +14969,12 @@ async function loadConfig(evalFilePath, repoRoot) {
         parsed.execution,
         configPath
       );
+      const results = parseResultsConfig(parsed.results, configPath);
       return {
         required_version: requiredVersion,
         eval_patterns: evalPatterns,
-        execution: executionDefaults
+        execution: executionDefaults,
+        results
       };
     } catch (error) {
       logWarning(
@@ -15192,9 +15209,221 @@ 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_RESET22}`);
 }
+var MIME_TYPE_ALIASES = {
+  csv: "text/csv",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  htm: "text/html",
+  html: "text/html",
+  json: "application/json",
+  markdown: "text/markdown",
+  md: "text/markdown",
+  pdf: "application/pdf",
+  sql: "application/sql",
+  txt: "text/plain",
+  xhtml: "application/xhtml+xml",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  xml: "application/xml",
+  yaml: "application/yaml",
+  yml: "application/yaml"
+};
+var REPLACEMENT_CHAR = "\uFFFD";
+async function extractTextWithPreprocessors(content, preprocessors, options = {}) {
+  if (typeof content === "string") {
+    return { text: content, warnings: [] };
+  }
+  if (!content || content.length === 0) {
+    return { text: "", warnings: [] };
+  }
+  const parts = [];
+  const warnings = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      parts.push(block.text);
+      continue;
+    }
+    if (block.type !== "file") {
+      continue;
+    }
+    const result = await preprocessContentFile(block, preprocessors, options.basePath);
+    if (result.text) {
+      parts.push(result.text);
+    }
+    warnings.push(...result.warnings);
+  }
+  return { text: parts.join("\n"), warnings };
+}
+async function preprocessContentFile(block, preprocessors, basePath) {
+  const mediaType = normalizePreprocessorType(block.media_type);
+  const resolvedPath = resolveLocalFilePath(block.path, basePath);
+  if (!resolvedPath) {
+    return {
+      text: "",
+      warnings: [
+        {
+          file: block.path,
+          mediaType: block.media_type,
+          reason: "remote file paths are not supported for preprocessing"
+        }
+      ]
+    };
+  }
+  const preprocessor = preprocessors?.find(
+    (entry) => normalizePreprocessorType(entry.type) === mediaType
+  );
+  if (preprocessor) {
+    return runContentPreprocessor(block, resolvedPath, preprocessor);
+  }
+  try {
+    const buffer = await readFile32(resolvedPath);
+    const text2 = buffer.toString("utf8").replace(/\r\n/g, "\n");
+    if (buffer.includes(0) || text2.includes(REPLACEMENT_CHAR)) {
+      return {
+        text: "",
+        warnings: [
+          {
+            file: block.path,
+            mediaType: block.media_type,
+            reason: "default UTF-8 read produced binary or invalid text; configure a preprocessor"
+          }
+        ]
+      };
+    }
+    return { text: formatFileText(block.path, text2), warnings: [] };
+  } catch (error) {
+    return {
+      text: "",
+      warnings: [
+        {
+          file: block.path,
+          mediaType: block.media_type,
+          reason: error instanceof Error ? error.message : String(error)
+        }
+      ]
+    };
+  }
+}
+async function runContentPreprocessor(block, resolvedPath, preprocessor) {
+  try {
+    const argv = preprocessor.resolvedCommand ?? preprocessor.command;
+    const { stdout, stderr, exitCode } = await execFileWithStdin(
+      argv,
+      JSON.stringify({
+        path: resolvedPath,
+        original_path: block.path,
+        media_type: block.media_type
+      })
+    );
+    if (exitCode !== 0) {
+      return {
+        text: "",
+        warnings: [
+          {
+            file: block.path,
+            mediaType: block.media_type,
+            reason: stderr.trim() || `preprocessor exited with code ${exitCode}`
+          }
+        ]
+      };
+    }
+    return { text: formatFileText(block.path, stdout.trim()), warnings: [] };
+  } catch (error) {
+    return {
+      text: "",
+      warnings: [
+        {
+          file: block.path,
+          mediaType: block.media_type,
+          reason: error instanceof Error ? error.message : String(error)
+        }
+      ]
+    };
+  }
+}
+function appendPreprocessingWarnings(text2, warnings) {
+  if (warnings.length === 0) {
+    return text2;
+  }
+  const notes = warnings.map(
+    (warning) => `[file preprocessing warning] ${warning.file} (${warning.mediaType}): ${warning.reason}`
+  );
+  return [text2, ...notes].filter((part) => part.length > 0).join("\n");
+}
+function normalizePreprocessorType(value) {
+  const normalized = value.trim().toLowerCase();
+  return MIME_TYPE_ALIASES[normalized] ?? normalized;
+}
+function resolveLocalFilePath(value, basePath) {
+  if (value.startsWith("file://")) {
+    return fileURLToPath2(value);
+  }
+  if (/^[a-z]+:\/\//i.test(value)) {
+    return void 0;
+  }
+  return basePath ? path42.resolve(basePath, value) : path42.resolve(value);
+}
+function formatFileText(filePath, text2) {
+  return `[[ file: ${filePath} ]]
+${text2}`;
+}
 var TEMPLATE_VARIABLES = {
   EXPECTED_OUTPUT: "expected_output",
   CRITERIA: "criteria",
@@ -15221,7 +15450,7 @@ var DEPRECATED_TEMPLATE_VARIABLES = /* @__PURE__ */ new Map([
 var ANSI_YELLOW22 = "\x1B[33m";
 var ANSI_RESET3 = "\x1B[0m";
 async function validateCustomPromptContent(promptPath) {
-  const content = await readFile32(promptPath, "utf8");
+  const content = await readFile4(promptPath, "utf8");
   validateTemplateVariables(content, promptPath);
 }
 function validateTemplateVariables(content, source) {
@@ -15269,6 +15498,7 @@ function validateTemplateVariables(content, source) {
 }
 var ANSI_YELLOW3 = "\x1B[33m";
 var ANSI_RESET4 = "\x1B[0m";
+var MAX_ASSERTION_INCLUDE_DEPTH = 3;
 var PROMPT_FILE_PREFIX = "file://";
 function normalizeEvaluatorType(type) {
   return type.replace(/_/g, "-");
@@ -15276,22 +15506,104 @@ function normalizeEvaluatorType(type) {
 function isDeprecatedJudgeType(type) {
   return type === "code-judge" || type === "llm-judge";
 }
-async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId) {
+async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId, defaultPreprocessors) {
   const execution = rawEvalCase.execution;
   const executionObject = isJsonObject2(execution) ? execution : void 0;
   const caseEvaluators = rawEvalCase.assertions ?? rawEvalCase.assert ?? (executionObject ? executionObject.evaluators : void 0) ?? // deprecated: use assertions
   rawEvalCase.evaluators;
   const skipDefaults = executionObject?.skip_defaults === true;
   const rootEvaluators = skipDefaults ? void 0 : globalExecution?.assertions ?? globalExecution?.assert ?? globalExecution?.evaluators;
-  const parsedCase = await parseEvaluatorList(caseEvaluators, searchRoots, evalId);
-  const parsedRoot = await parseEvaluatorList(rootEvaluators, searchRoots, evalId);
+  const parsedCase = await parseEvaluatorList(
+    caseEvaluators,
+    searchRoots,
+    evalId,
+    defaultPreprocessors
+  );
+  const parsedRoot = await parseEvaluatorList(
+    rootEvaluators,
+    searchRoots,
+    evalId,
+    defaultPreprocessors
+  );
   if (!parsedCase && !parsedRoot) {
     return void 0;
   }
   const evaluators = [...parsedCase ?? [], ...parsedRoot ?? []];
   return evaluators.length > 0 ? evaluators : void 0;
 }
-async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
+function isIncludeEntry(value) {
+  return isJsonObject2(value) && typeof value.include === "string" && Object.keys(value).length === 1;
+}
+function isTemplateReference(value) {
+  return !value.startsWith(".") && !value.includes("/") && !value.includes("\\");
+}
+async function resolveAssertionTemplateReference(include, searchRoots) {
+  const templateCandidates = isTemplateReference(include) ? [
+    path5.join(".agentv", "templates", `${include}.yaml`),
+    path5.join(".agentv", "templates", `${include}.yml`)
+  ] : [include];
+  const attempted = [];
+  for (const candidate of templateCandidates) {
+    const resolved = await resolveFileReference22(candidate, searchRoots);
+    attempted.push(...resolved.attempted);
+    if (resolved.resolvedPath) {
+      return {
+        displayPath: resolved.displayPath,
+        resolvedPath: resolved.resolvedPath,
+        attempted
+      };
+    }
+  }
+  return {
+    displayPath: templateCandidates[0] ?? include,
+    resolvedPath: "",
+    attempted
+  };
+}
+async function loadAssertionTemplateEntries(include, searchRoots, evalId, includeContext) {
+  const nextDepth = includeContext.depth + 1;
+  if (nextDepth > MAX_ASSERTION_INCLUDE_DEPTH) {
+    const chain = [...includeContext.chain, include].join(" -> ");
+    throw new Error(
+      `Assertion template include depth exceeded ${MAX_ASSERTION_INCLUDE_DEPTH} in '${evalId}'. Include chain: ${chain}`
+    );
+  }
+  const resolved = await resolveAssertionTemplateReference(include, searchRoots);
+  if (!resolved.resolvedPath) {
+    const attempted = resolved.attempted.length > 0 ? `
+${resolved.attempted.map((attempt) => `  Tried: ${attempt}`).join("\n")}` : "";
+    throw new Error(
+      `Assertion template not found in '${evalId}': ${resolved.displayPath}${attempted}`
+    );
+  }
+  if (includeContext.chain.includes(resolved.resolvedPath)) {
+    const cycle = [...includeContext.chain, resolved.resolvedPath].join(" -> ");
+    throw new Error(`Assertion template cycle detected in '${evalId}': ${cycle}`);
+  }
+  const content = await readFile5(resolved.resolvedPath, "utf8");
+  const parsed = interpolateEnv(parse2(content), process.env);
+  if (!isJsonObject2(parsed)) {
+    throw new Error(
+      `Invalid assertion template file in '${evalId}': ${resolved.resolvedPath} (expected a YAML object with an assertions array)`
+    );
+  }
+  const assertions = parsed.assertions;
+  if (!Array.isArray(assertions)) {
+    throw new Error(
+      `Invalid assertion template file in '${evalId}': ${resolved.resolvedPath} is missing a top-level assertions array`
+    );
+  }
+  const templateDir = path5.dirname(resolved.resolvedPath);
+  const nestedSearchRoots = [
+    templateDir,
+    ...searchRoots.filter((root) => path5.resolve(root) !== templateDir)
+  ];
+  return await expandEvaluatorEntries(assertions, nestedSearchRoots, evalId, {
+    depth: nextDepth,
+    chain: [...includeContext.chain, resolved.resolvedPath]
+  }) ?? [];
+}
+async function expandEvaluatorEntries(candidateEvaluators, searchRoots, evalId, includeContext = { depth: 0, chain: [] }) {
   if (candidateEvaluators === void 0) {
     return void 0;
   }
@@ -15299,13 +15611,34 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
     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) {
@@ -15356,6 +15689,13 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       continue;
     }
     const negate = rawEvaluator.negate === true ? true : void 0;
+    const mergedPreprocessors = await parseMergedPreprocessors(
+      rawEvaluator.preprocessors,
+      defaultPreprocessors,
+      searchRoots,
+      name21,
+      evalId
+    );
     if (isCustomType) {
       const weight2 = validateWeight(rawEvaluator.weight, name21, evalId);
       const { required: required2, min_score: min_score2 } = parseRequiredAndMinScore(
@@ -15414,7 +15754,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       if (cwd) {
         const resolved = await resolveFileReference22(cwd, searchRoots);
         if (resolved.resolvedPath) {
-          resolvedCwd = path42.resolve(resolved.resolvedPath);
+          resolvedCwd = path5.resolve(resolved.resolvedPath);
         } else {
           logWarning2(
             `Code-grader evaluator '${name21}' in '${evalId}': cwd not found (${resolved.displayPath})`,
@@ -15460,6 +15800,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
         "cwd",
         "weight",
         "target",
+        "preprocessors",
         "required",
         "negate"
       ]);
@@ -15480,6 +15821,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
         ...min_score2 !== void 0 ? { min_score: min_score2 } : {},
         ...negate !== void 0 ? { negate } : {},
         ...Object.keys(config2).length > 0 ? { config: config2 } : {},
+        ...mergedPreprocessors ? { preprocessors: mergedPreprocessors } : {},
         ...targetConfig !== void 0 ? { target: targetConfig } : {}
       });
       continue;
@@ -15511,8 +15853,16 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
         );
         continue;
       }
+      const expandedMembers = await expandEvaluatorEntries(
+        rawMembers,
+        searchRoots,
+        `${evalId}:${name21}`
+      );
+      if (!expandedMembers) {
+        continue;
+      }
       const memberEvaluators = [];
-      for (const rawMember of rawMembers) {
+      for (const rawMember of expandedMembers) {
         if (!isJsonObject2(rawMember)) {
           logWarning2(`Skipping invalid member evaluator in composite '${name21}' (expected object)`);
           continue;
@@ -15589,7 +15939,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
             aggregatorPrompt = fileRef;
             const resolved = await resolveFileReference22(fileRef, searchRoots);
             if (resolved.resolvedPath) {
-              promptPath2 = path42.resolve(resolved.resolvedPath);
+              promptPath2 = path5.resolve(resolved.resolvedPath);
             } else {
               throw new Error(
                 `Composite aggregator in '${evalId}': prompt file not found: ${resolved.displayPath}`
@@ -16243,7 +16593,8 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
         ...weight2 !== void 0 ? { weight: weight2 } : {},
         ...required2 !== void 0 ? { required: required2 } : {},
         ...min_score2 !== void 0 ? { min_score: min_score2 } : {},
-        ...negate !== void 0 ? { negate } : {}
+        ...negate !== void 0 ? { negate } : {},
+        ...mergedPreprocessors ? { preprocessors: mergedPreprocessors } : {}
       });
       continue;
     }
@@ -16268,7 +16619,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       const commandPath = commandArray[commandArray.length - 1];
       const resolved = await resolveFileReference22(commandPath, searchRoots);
       if (resolved.resolvedPath) {
-        resolvedPromptScript = [...commandArray.slice(0, -1), path42.resolve(resolved.resolvedPath)];
+        resolvedPromptScript = [...commandArray.slice(0, -1), path5.resolve(resolved.resolvedPath)];
       } else {
         throw new Error(
           `Evaluator '${name21}' in '${evalId}': prompt command file not found: ${resolved.displayPath}`
@@ -16283,7 +16634,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
         prompt = fileRef;
         const resolved = await resolveFileReference22(fileRef, searchRoots);
         if (resolved.resolvedPath) {
-          promptPath = path42.resolve(resolved.resolvedPath);
+          promptPath = path5.resolve(resolved.resolvedPath);
           try {
             await validateCustomPromptContent(promptPath);
           } catch (error) {
@@ -16326,7 +16677,8 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
         ...weight2 !== void 0 ? { weight: weight2 } : {},
         ...required2 !== void 0 ? { required: required2 } : {},
         ...min_score2 !== void 0 ? { min_score: min_score2 } : {},
-        ...negate !== void 0 ? { negate } : {}
+        ...negate !== void 0 ? { negate } : {},
+        ...mergedPreprocessors ? { preprocessors: mergedPreprocessors } : {}
       });
       continue;
     }
@@ -16351,7 +16703,8 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       "negate",
       "max_steps",
       "maxSteps",
-      "temperature"
+      "temperature",
+      "preprocessors"
     ]);
     const config = {};
     for (const [key, value] of Object.entries(rawEvaluator)) {
@@ -16381,30 +16734,70 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       ...negate !== void 0 ? { negate } : {},
       ...finalConfig ? { config: finalConfig } : {},
       ...llmMaxSteps !== void 0 ? { max_steps: llmMaxSteps } : {},
-      ...llmTemperature !== void 0 ? { temperature: llmTemperature } : {}
+      ...llmTemperature !== void 0 ? { temperature: llmTemperature } : {},
+      ...mergedPreprocessors ? { preprocessors: mergedPreprocessors } : {}
     });
   }
   return evaluators.length > 0 ? evaluators : void 0;
 }
-var ASSERTION_TYPES = /* @__PURE__ */ new Set([
-  "skill-trigger",
-  "contains",
-  "contains-any",
-  "contains-all",
-  "icontains",
-  "icontains-any",
-  "icontains-all",
-  "starts-with",
-  "ends-with",
-  "regex",
-  "is-json",
-  "equals",
-  "rubrics"
-]);
-function generateAssertionName(typeValue, rawEvaluator) {
-  if (!ASSERTION_TYPES.has(typeValue)) {
+async function parseMergedPreprocessors(rawValue, defaultPreprocessors, searchRoots, evaluatorName, evalId) {
+  const parsedDefaults = defaultPreprocessors ?? [];
+  const parsedOverrides = await parsePreprocessors(rawValue, searchRoots, evaluatorName, evalId);
+  if (parsedDefaults.length === 0 && (!parsedOverrides || parsedOverrides.length === 0)) {
+    return void 0;
+  }
+  const merged = /* @__PURE__ */ new Map();
+  for (const entry of parsedDefaults) {
+    merged.set(normalizePreprocessorType(entry.type), entry);
+  }
+  for (const entry of parsedOverrides ?? []) {
+    merged.set(normalizePreprocessorType(entry.type), entry);
+  }
+  return [...merged.values()];
+}
+async function parsePreprocessors(rawValue, searchRoots, evaluatorName, evalId) {
+  if (rawValue === void 0) {
     return void 0;
   }
+  if (!Array.isArray(rawValue)) {
+    throw new Error(`Evaluator '${evaluatorName}' in '${evalId}': preprocessors must be an array`);
+  }
+  const preprocessors = [];
+  for (const rawEntry of rawValue) {
+    if (!isJsonObject2(rawEntry)) {
+      throw new Error(
+        `Evaluator '${evaluatorName}' in '${evalId}': each preprocessor must be an object`
+      );
+    }
+    const type = asString(rawEntry.type)?.trim();
+    if (!type) {
+      throw new Error(`Evaluator '${evaluatorName}' in '${evalId}': preprocessor.type is required`);
+    }
+    const command = asStringArray(
+      rawEntry.command,
+      `preprocessor command for evaluator '${evaluatorName}' in '${evalId}'`
+    );
+    if (!command || command.length === 0) {
+      throw new Error(
+        `Evaluator '${evaluatorName}' in '${evalId}': preprocessor '${type}' requires command`
+      );
+    }
+    const commandPath = command[command.length - 1];
+    const resolved = await resolveFileReference22(commandPath, searchRoots);
+    if (!resolved.resolvedPath) {
+      throw new Error(
+        `Evaluator '${evaluatorName}' in '${evalId}': preprocessor command file not found: ${resolved.displayPath}`
+      );
+    }
+    preprocessors.push({
+      type,
+      command,
+      resolvedCommand: [...command.slice(0, -1), path5.resolve(resolved.resolvedPath)]
+    });
+  }
+  return preprocessors;
+}
+function generateAssertionName(typeValue, rawEvaluator) {
   const value = asString(rawEvaluator.value);
   const arrayValue = Array.isArray(rawEvaluator.value) ? rawEvaluator.value : void 0;
   switch (typeValue) {
@@ -16437,7 +16830,7 @@ function generateAssertionName(typeValue, rawEvaluator) {
     case "rubrics":
       return "rubrics";
     default:
-      return void 0;
+      return typeValue;
   }
 }
 function coerceEvaluator(candidate, contextId) {
@@ -16854,7 +17247,7 @@ var IMAGE_MEDIA_TYPES = {
   ".bmp": "image/bmp"
 };
 function detectImageMediaType(filePath) {
-  const ext = path5.extname(filePath).toLowerCase();
+  const ext = path6.extname(filePath).toLowerCase();
   return IMAGE_MEDIA_TYPES[ext];
 }
 var ANSI_YELLOW4 = "\x1B[33m";
@@ -16904,12 +17297,12 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const fileContent = (await readFile4(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+          const fileContent = (await readFile6(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
           processedContent.push({
             ...cloneJsonObject(rawSegment),
             path: displayPath,
             text: fileContent,
-            resolvedPath: path5.resolve(resolvedPath)
+            resolvedPath: path6.resolve(resolvedPath)
           });
           if (verbose) {
             const label = messageType === "input" ? "[File]" : "[Expected Output File]";
@@ -16945,7 +17338,7 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const imageBuffer = await readFile4(resolvedPath);
+          const imageBuffer = await readFile6(resolvedPath);
           const base64 = imageBuffer.toString("base64");
           processedContent.push({
             type: "image",
@@ -17022,12 +17415,12 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const fileContent = (await readFile4(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+            const fileContent = (await readFile6(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
             processedContent.push({
               type: "file",
               path: displayPath,
               text: fileContent,
-              resolvedPath: path5.resolve(resolvedPath)
+              resolvedPath: path6.resolve(resolvedPath)
             });
             if (verbose) {
               console.log(`  [Expected Output File] Found: ${displayPath}`);
@@ -17062,7 +17455,7 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const imageBuffer = await readFile4(resolvedPath);
+            const imageBuffer = await readFile6(resolvedPath);
             const base64 = imageBuffer.toString("base64");
             processedContent.push({
               type: "image",
@@ -17167,7 +17560,7 @@ function matchesFilter(id, filter2) {
   return typeof filter2 === "string" ? micromatch.isMatch(id, filter2) : filter2.some((pattern) => micromatch.isMatch(id, pattern));
 }
 function detectFormat(filePath) {
-  const ext = path6.extname(filePath).toLowerCase();
+  const ext = path7.extname(filePath).toLowerCase();
   if (ext === ".jsonl") return "jsonl";
   if (ext === ".yaml" || ext === ".yml") return "yaml";
   if (ext === ".json") return "agent-skills-json";
@@ -17176,9 +17569,9 @@ function detectFormat(filePath) {
   );
 }
 async function loadSidecarMetadata(jsonlPath, verbose) {
-  const dir = path6.dirname(jsonlPath);
-  const base = path6.basename(jsonlPath, ".jsonl");
-  const sidecarPath = path6.join(dir, `${base}.yaml`);
+  const dir = path7.dirname(jsonlPath);
+  const base = path7.basename(jsonlPath, ".jsonl");
+  const sidecarPath = path7.join(dir, `${base}.yaml`);
   if (!await fileExists2(sidecarPath)) {
     if (verbose) {
       logWarning4(`Sidecar metadata file not found: ${sidecarPath} (using defaults)`);
@@ -17186,7 +17579,7 @@ async function loadSidecarMetadata(jsonlPath, verbose) {
     return {};
   }
   try {
-    const content = await readFile5(sidecarPath, "utf8");
+    const content = await readFile7(sidecarPath, "utf8");
     const parsed = interpolateEnv(parseYaml2(content), process.env);
     if (!isJsonObject(parsed)) {
       logWarning4(`Invalid sidecar metadata format in ${sidecarPath}`);
@@ -17227,13 +17620,13 @@ function parseJsonlContent(content, filePath) {
 async function loadTestsFromJsonl(evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
   const filterPattern = options?.filter;
-  const absoluteTestPath = path6.resolve(evalFilePath);
+  const absoluteTestPath = path7.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
   const sidecar = await loadSidecarMetadata(absoluteTestPath, verbose);
-  const rawFile = await readFile5(absoluteTestPath, "utf8");
+  const rawFile = await readFile7(absoluteTestPath, "utf8");
   const rawCases = parseJsonlContent(rawFile, evalFilePath);
-  const fallbackSuiteName = path6.basename(absoluteTestPath, ".jsonl") || "eval";
+  const fallbackSuiteName = path7.basename(absoluteTestPath, ".jsonl") || "eval";
   const suiteName = sidecar.name && sidecar.name.trim().length > 0 ? sidecar.name : fallbackSuiteName;
   const globalEvaluator = coerceEvaluator(sidecar.evaluator, "sidecar") ?? "llm-grader";
   const globalExecution = sidecar.execution;
@@ -17408,11 +17801,13 @@ function parseRepoCheckout(raw) {
   if (!isJsonObject(raw)) return void 0;
   const obj = raw;
   const ref = typeof obj.ref === "string" ? obj.ref : void 0;
+  const baseCommit = typeof obj.base_commit === "string" ? obj.base_commit : void 0;
   const resolve2 = obj.resolve === "remote" || obj.resolve === "local" ? obj.resolve : void 0;
   const ancestor = typeof obj.ancestor === "number" ? obj.ancestor : void 0;
-  if (!ref && !resolve2 && ancestor === void 0) return void 0;
+  if (!ref && !baseCommit && !resolve2 && ancestor === void 0) return void 0;
   return {
     ...ref !== void 0 && { ref },
+    ...baseCommit !== void 0 && { base_commit: baseCommit },
     ...resolve2 !== void 0 && { resolve: resolve2 },
     ...ancestor !== void 0 && { ancestor }
   };
@@ -17435,12 +17830,12 @@ function parseRepoConfig(raw) {
   const obj = raw;
   const repoPath = typeof obj.path === "string" ? obj.path : void 0;
   const source = parseRepoSource(obj.source);
-  if (!repoPath || !source) return void 0;
   const checkout = parseRepoCheckout(obj.checkout);
   const clone = parseRepoClone(obj.clone);
+  if (!repoPath && !source && !checkout && !clone) return void 0;
   return {
-    path: repoPath,
-    source,
+    ...repoPath !== void 0 && { path: repoPath },
+    ...source !== void 0 && { source },
     ...checkout !== void 0 && { checkout },
     ...clone !== void 0 && { clone }
   };
@@ -17489,7 +17884,8 @@ ${messageContent}`);
     segmentsByMessage,
     mode
   }) : void 0;
-  return { question, chatPrompt };
+  const systemMessage = extractSystemMessage(testCase.input, segmentsByMessage, mode);
+  return { question, chatPrompt, systemMessage };
 }
 function needsRoleMarkers(messages, processedSegmentsByMessage) {
   if (messages.some((msg) => msg.role === "assistant" || msg.role === "tool")) {
@@ -17503,6 +17899,26 @@ function needsRoleMarkers(messages, processedSegmentsByMessage) {
   }
   return messagesWithContent > 1;
 }
+function extractSystemMessage(messages, segmentsByMessage, mode) {
+  const systemParts = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role !== "system") {
+      break;
+    }
+    const segments = segmentsByMessage[i];
+    const contentParts = [];
+    for (const segment of segments) {
+      const formatted = formatSegment(segment, mode);
+      if (formatted) {
+        contentParts.push(formatted);
+      }
+    }
+    if (contentParts.length > 0) {
+      systemParts.push(contentParts.join("\n"));
+    }
+  }
+  return systemParts.length > 0 ? systemParts.join("\n\n") : void 0;
+}
 function buildChatPromptFromSegments(options) {
   const { messages, segmentsByMessage, systemPrompt, mode = "lm" } = options;
   if (messages.length === 0) {
@@ -17583,9 +17999,9 @@ function resolveTests(suite) {
 }
 async function readTestSuiteMetadata(testFilePath) {
   try {
-    const absolutePath = path7.resolve(testFilePath);
-    const content = await readFile6(absolutePath, "utf8");
-    const parsed = interpolateEnv(parse2(content), process.env);
+    const absolutePath = path8.resolve(testFilePath);
+    const content = await readFile8(absolutePath, "utf8");
+    const parsed = interpolateEnv(parse3(content), process.env);
     if (!isJsonObject(parsed)) {
       return {};
     }
@@ -17638,25 +18054,31 @@ var loadEvalCases = loadTests;
 async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
   const filterPattern = options?.filter;
-  const absoluteTestPath = path7.resolve(evalFilePath);
+  const absoluteTestPath = path8.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
   const config = await loadConfig(absoluteTestPath, repoRootPath);
-  const rawFile = await readFile6(absoluteTestPath, "utf8");
-  const interpolated = interpolateEnv(parse2(rawFile), process.env);
+  const rawFile = await readFile8(absoluteTestPath, "utf8");
+  const interpolated = interpolateEnv(parse3(rawFile), process.env);
   if (!isJsonObject(interpolated)) {
     throw new Error(`Invalid test file format: ${evalFilePath}`);
   }
   const suite = interpolated;
   const suiteNameFromFile = asString5(suite.name)?.trim();
-  const fallbackSuiteName = path7.basename(absoluteTestPath).replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "") || "eval";
+  const fallbackSuiteName = path8.basename(absoluteTestPath).replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "") || "eval";
   const suiteName = suiteNameFromFile && suiteNameFromFile.length > 0 ? suiteNameFromFile : fallbackSuiteName;
   const rawTestCases = resolveTests(suite);
   const globalEvaluator = coerceEvaluator(suite.evaluator, "global") ?? "llm-grader";
-  const evalFileDir = path7.dirname(absoluteTestPath);
+  const suitePreprocessors = await parsePreprocessors(
+    suite.preprocessors,
+    searchRoots,
+    "<suite>",
+    absoluteTestPath
+  );
+  const evalFileDir = path8.dirname(absoluteTestPath);
   let expandedTestCases;
   if (typeof rawTestCases === "string") {
-    const externalPath = path7.resolve(evalFileDir, rawTestCases);
+    const externalPath = path8.resolve(evalFileDir, rawTestCases);
     expandedTestCases = await loadCasesFromFile(externalPath);
   } else if (Array.isArray(rawTestCases)) {
     expandedTestCases = await expandFileReferences(rawTestCases, evalFileDir);
@@ -17754,7 +18176,8 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
         testCaseConfig,
         globalExecution,
         searchRoots,
-        id ?? "unknown"
+        id ?? "unknown",
+        suitePreprocessors
       );
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -17777,7 +18200,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
     const testCase = {
       id,
       suite: suiteName,
-      category: options?.category,
+      category: suite.category ?? options?.category,
       conversation_id: conversationId,
       question,
       input: inputMessages,
@@ -17787,6 +18210,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
       criteria: outcome ?? "",
       evaluator: testCaseEvaluatorKind,
       assertions: evaluators,
+      ...suitePreprocessors ? { preprocessors: suitePreprocessors } : {},
       workspace: mergedWorkspace,
       metadata,
       targets: caseTargets,
@@ -17827,8 +18251,8 @@ function parseWorkspaceScriptConfig(raw, evalFileDir) {
   if (!command) return void 0;
   const timeoutMs = typeof obj.timeout_ms === "number" ? obj.timeout_ms : void 0;
   let cwd = typeof obj.cwd === "string" ? obj.cwd : void 0;
-  if (cwd && !path7.isAbsolute(cwd)) {
-    cwd = path7.resolve(evalFileDir, cwd);
+  if (cwd && !path8.isAbsolute(cwd)) {
+    cwd = path8.resolve(evalFileDir, cwd);
   }
   const config = { command };
   if (timeoutMs !== void 0) {
@@ -17866,20 +18290,20 @@ function parseWorkspaceHooksConfig(raw, evalFileDir) {
 }
 async function resolveWorkspaceConfig(raw, evalFileDir) {
   if (typeof raw === "string") {
-    const workspaceFilePath = path7.resolve(evalFileDir, raw);
+    const workspaceFilePath = path8.resolve(evalFileDir, raw);
     let content;
     try {
-      content = await readFile6(workspaceFilePath, "utf8");
+      content = await readFile8(workspaceFilePath, "utf8");
     } catch {
       throw new Error(`Workspace file not found: ${raw} (resolved to ${workspaceFilePath})`);
     }
-    const parsed = interpolateEnv(parse2(content), process.env);
+    const parsed = interpolateEnv(parse3(content), process.env);
     if (!isJsonObject(parsed)) {
       throw new Error(
         `Invalid workspace file format: ${workspaceFilePath} (expected a YAML object)`
       );
     }
-    const workspaceFileDir = path7.dirname(workspaceFilePath);
+    const workspaceFileDir = path8.dirname(workspaceFilePath);
     return parseWorkspaceConfig(parsed, workspaceFileDir);
   }
   return parseWorkspaceConfig(raw, evalFileDir);
@@ -17899,8 +18323,8 @@ function parseWorkspaceConfig(raw, evalFileDir) {
     throw new Error("workspace.static has been removed. Use workspace.mode='static'.");
   }
   let template = typeof obj.template === "string" ? obj.template : void 0;
-  if (template && !path7.isAbsolute(template)) {
-    template = path7.resolve(evalFileDir, template);
+  if (template && !path8.isAbsolute(template)) {
+    template = path8.resolve(evalFileDir, template);
   }
   const isolation = obj.isolation === "shared" || obj.isolation === "per_test" ? obj.isolation : void 0;
   const repos = Array.isArray(obj.repos) ? obj.repos.map(parseRepoConfig).filter(Boolean) : void 0;
@@ -17908,14 +18332,28 @@ function parseWorkspaceConfig(raw, evalFileDir) {
   const explicitMode = obj.mode === "pooled" || obj.mode === "temp" || obj.mode === "static" ? obj.mode : void 0;
   const workspacePath = typeof obj.path === "string" ? obj.path : void 0;
   const mode = explicitMode ?? (workspacePath ? "static" : void 0);
-  if (!template && !isolation && !repos && !hooks && !mode && !workspacePath) return void 0;
+  const docker = parseDockerWorkspaceConfig(obj.docker);
+  if (!template && !isolation && !repos && !hooks && !mode && !workspacePath && !docker)
+    return void 0;
   return {
     ...template !== void 0 && { template },
     ...isolation !== void 0 && { isolation },
     ...repos !== void 0 && { repos },
     ...hooks !== void 0 && { hooks },
     ...mode !== void 0 && { mode },
-    ...workspacePath !== void 0 && { path: workspacePath }
+    ...workspacePath !== void 0 && { path: workspacePath },
+    ...docker !== void 0 && { docker }
+  };
+}
+function parseDockerWorkspaceConfig(raw) {
+  if (!isJsonObject(raw)) return void 0;
+  const obj = raw;
+  if (typeof obj.image !== "string") return void 0;
+  return {
+    image: obj.image,
+    ...typeof obj.timeout === "number" && { timeout: obj.timeout },
+    ...typeof obj.memory === "string" && { memory: obj.memory },
+    ...typeof obj.cpus === "number" && { cpus: obj.cpus }
   };
 }
 function mergeWorkspaceConfigs(suiteLevel, caseLevel) {
@@ -17944,7 +18382,8 @@ function mergeWorkspaceConfigs(suiteLevel, caseLevel) {
     repos: caseLevel.repos ?? suiteLevel.repos,
     ...hasHooks && { hooks: mergedHooks },
     mode: caseLevel.mode ?? suiteLevel.mode,
-    path: caseLevel.path ?? suiteLevel.path
+    path: caseLevel.path ?? suiteLevel.path,
+    docker: caseLevel.docker ?? suiteLevel.docker
   };
 }
 function asString5(value) {
@@ -18206,8 +18645,8 @@ function transpileEvalYaml(suite, source = "EVAL.yaml") {
 }
 function transpileEvalYamlFile(evalYamlPath) {
   const content = readFileSync(evalYamlPath, "utf8");
-  const parsed = parse3(content);
-  return transpileEvalYaml(parsed, path8.basename(evalYamlPath));
+  const parsed = parse4(content);
+  return transpileEvalYaml(parsed, path9.basename(evalYamlPath));
 }
 function getOutputFilenames(result) {
   const names = /* @__PURE__ */ new Map();
@@ -18739,7 +19178,7 @@ function normalizeInputFiles(inputFiles) {
   }
   const deduped = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path9.resolve(inputFile);
+    const absolutePath = path10.resolve(inputFile);
     if (!deduped.has(absolutePath)) {
       deduped.set(absolutePath, absolutePath);
     }
@@ -18752,7 +19191,7 @@ function collectInputFiles(inputFiles) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path9.resolve(inputFile);
+    const absolutePath = path10.resolve(inputFile);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -18764,7 +19203,7 @@ function buildMandatoryPrereadBlock(inputFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path9.basename(absolutePath);
+    const fileName = path10.basename(absolutePath);
     const fileUri = pathToFileUri(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -18780,7 +19219,7 @@ ${buildList(inputFiles).join("\n")}.`);
   return sections.join("\n");
 }
 function pathToFileUri(filePath) {
-  const absolutePath = path9.isAbsolute(filePath) ? filePath : path9.resolve(filePath);
+  const absolutePath = path10.isAbsolute(filePath) ? filePath : path10.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -18926,10 +19365,10 @@ var ClaudeCliProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path10.resolve(cwdOverride);
+      return path11.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path10.resolve(this.config.cwd);
+      return path11.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -18939,9 +19378,9 @@ var ClaudeCliProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path10.resolve(this.config.logDir);
+      return path11.resolve(this.config.logDir);
     }
-    return path10.join(process.cwd(), ".agentv", "logs", "claude-cli");
+    return path11.join(process.cwd(), ".agentv", "logs", "claude-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -18955,7 +19394,7 @@ var ClaudeCliProvider = class {
       console.warn(`Skipping Claude CLI stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path10.join(logDir, buildLogFilename(request, this.targetName));
+    const filePath = path11.join(logDir, buildLogFilename(request, this.targetName));
     try {
       const logger = await ClaudeCliStreamLogger.create({
         filePath,
@@ -19412,10 +19851,10 @@ var ClaudeSdkProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path11.resolve(cwdOverride);
+      return path12.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path11.resolve(this.config.cwd);
+      return path12.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -19425,9 +19864,9 @@ var ClaudeSdkProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path11.resolve(this.config.logDir);
+      return path12.resolve(this.config.logDir);
     }
-    return path11.join(process.cwd(), ".agentv", "logs", "claude");
+    return path12.join(process.cwd(), ".agentv", "logs", "claude");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -19441,7 +19880,7 @@ var ClaudeSdkProvider = class {
       console.warn(`Skipping Claude stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path11.join(logDir, buildLogFilename2(request, this.targetName));
+    const filePath = path12.join(logDir, buildLogFilename2(request, this.targetName));
     try {
       const logger = await ClaudeStreamLogger.create({
         filePath,
@@ -20124,7 +20563,7 @@ function normalizeInputFiles2(inputFiles) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path12.resolve(inputFile);
+    const absolutePath = path13.resolve(inputFile);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -20138,7 +20577,7 @@ function formatFileList(files, template) {
   const formatter = template ?? "{path}";
   return files.map((filePath) => {
     const escapedPath = shellEscape(filePath);
-    const escapedName = shellEscape(path12.basename(filePath));
+    const escapedName = shellEscape(path13.basename(filePath));
     return formatter.replaceAll("{path}", escapedPath).replaceAll("{basename}", escapedName);
   }).join(" ");
 }
@@ -20162,7 +20601,7 @@ function generateOutputFilePath(evalCaseId, extension = ".json") {
   const safeEvalId = evalCaseId || "unknown";
   const timestamp = Date.now();
   const random = Math.random().toString(36).substring(2, 9);
-  return path12.join(os.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
+  return path13.join(os.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
 }
 function formatTimeoutSuffix2(timeoutMs) {
   if (!timeoutMs || timeoutMs <= 0) {
@@ -20401,10 +20840,10 @@ ${basePrompt}` : basePrompt;
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path13.resolve(cwdOverride);
+      return path14.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path13.resolve(this.config.cwd);
+      return path14.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -20414,9 +20853,9 @@ ${basePrompt}` : basePrompt;
       return void 0;
     }
     if (this.config.logDir) {
-      return path13.resolve(this.config.logDir);
+      return path14.resolve(this.config.logDir);
     }
-    return path13.join(process.cwd(), ".agentv", "logs", "codex");
+    return path14.join(process.cwd(), ".agentv", "logs", "codex");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -20430,7 +20869,7 @@ ${basePrompt}` : basePrompt;
       console.warn(`Skipping Codex SDK stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path13.join(logDir, buildLogFilename3(request, this.targetName));
+    const filePath = path14.join(logDir, buildLogFilename3(request, this.targetName));
     try {
       const logger = await CodexSdkStreamLogger.create({
         filePath,
@@ -20622,7 +21061,7 @@ function subscribeToCopilotCliLogEntries(listener) {
   };
 }
 function resolvePlatformCliPath() {
-  const os3 = platform();
+  const os4 = platform();
   const cpu = arch();
   const platformMap = {
     linux: "linux",
@@ -20633,17 +21072,17 @@ 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:") ? fileURLToPath2(resolved) : resolved;
-    const binaryPath = path14.join(path14.dirname(packageJsonPath), binaryName);
+    const packageJsonPath = resolved.startsWith("file:") ? fileURLToPath3(resolved) : resolved;
+    const binaryPath = path15.join(path15.dirname(packageJsonPath), binaryName);
     if (existsSync(binaryPath)) {
       return binaryPath;
     }
@@ -20651,7 +21090,7 @@ function resolvePlatformCliPath() {
   }
   let searchDir = process.cwd();
   for (let i = 0; i < 10; i++) {
-    const standardPath = path14.join(
+    const standardPath = path15.join(
       searchDir,
       "node_modules",
       ...packageName.split("/"),
@@ -20660,13 +21099,13 @@ function resolvePlatformCliPath() {
     if (existsSync(standardPath)) {
       return standardPath;
     }
-    const bunDir = path14.join(searchDir, "node_modules", ".bun");
+    const bunDir = path15.join(searchDir, "node_modules", ".bun");
     const prefix = `@github+copilot-${osPart}-${archPart}@`;
     try {
       const entries = readdirSync(bunDir);
       for (const entry of entries) {
         if (entry.startsWith(prefix)) {
-          const candidate = path14.join(
+          const candidate = path15.join(
             bunDir,
             entry,
             "node_modules",
@@ -20681,7 +21120,7 @@ function resolvePlatformCliPath() {
       }
     } catch {
     }
-    const parent = path14.dirname(searchDir);
+    const parent = path15.dirname(searchDir);
     if (parent === searchDir) break;
     searchDir = parent;
   }
@@ -21023,10 +21462,10 @@ var CopilotCliProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path15.resolve(cwdOverride);
+      return path16.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path15.resolve(this.config.cwd);
+      return path16.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -21045,9 +21484,9 @@ var CopilotCliProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path15.resolve(this.config.logDir);
+      return path16.resolve(this.config.logDir);
     }
-    return path15.join(process.cwd(), ".agentv", "logs", "copilot-cli");
+    return path16.join(process.cwd(), ".agentv", "logs", "copilot-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -21061,7 +21500,7 @@ var CopilotCliProvider = class {
       console.warn(`Skipping Copilot CLI stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path15.join(logDir, buildLogFilename4(request, this.targetName, "copilot-cli"));
+    const filePath = path16.join(logDir, buildLogFilename4(request, this.targetName, "copilot-cli"));
     try {
       const logger = await CopilotStreamLogger.create(
         {
@@ -21279,7 +21718,7 @@ function parseCopilotEvents(eventsJsonl) {
     durationMs
   };
 }
-var DEFAULT_SESSION_STATE_DIR = () => path16.join(homedir(), ".copilot", "session-state");
+var DEFAULT_SESSION_STATE_DIR = () => path17.join(homedir(), ".copilot", "session-state");
 async function discoverCopilotSessions(opts) {
   const sessionStateDir = opts?.sessionStateDir ?? DEFAULT_SESSION_STATE_DIR();
   const limit = opts?.limit ?? 10;
@@ -21291,11 +21730,11 @@ async function discoverCopilotSessions(opts) {
   }
   const sessions = [];
   for (const entry of entries) {
-    const sessionDir = path16.join(sessionStateDir, entry);
-    const workspacePath = path16.join(sessionDir, "workspace.yaml");
-    const eventsPath = path16.join(sessionDir, "events.jsonl");
+    const sessionDir = path17.join(sessionStateDir, entry);
+    const workspacePath = path17.join(sessionDir, "workspace.yaml");
+    const eventsPath = path17.join(sessionDir, "events.jsonl");
     try {
-      const workspaceContent = await readFile7(workspacePath, "utf8");
+      const workspaceContent = await readFile9(workspacePath, "utf8");
       const workspace = parseYaml22(workspaceContent) ?? {};
       const cwd = String(workspace.cwd ?? "");
       let updatedAt;
@@ -21352,10 +21791,10 @@ var CopilotLogProvider = class {
   }
   async invoke(_request) {
     const sessionDir = await this.resolveSessionDir();
-    const eventsPath = path17.join(sessionDir, "events.jsonl");
+    const eventsPath = path18.join(sessionDir, "events.jsonl");
     let eventsContent;
     try {
-      eventsContent = await readFile8(eventsPath, "utf8");
+      eventsContent = await readFile10(eventsPath, "utf8");
     } catch (err) {
       throw new Error(
         `Failed to read Copilot session transcript at ${eventsPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -21374,8 +21813,8 @@ var CopilotLogProvider = class {
       return this.config.sessionDir;
     }
     if (this.config.sessionId) {
-      const stateDir = this.config.sessionStateDir ?? path17.join(homedir2(), ".copilot", "session-state");
-      return path17.join(stateDir, this.config.sessionId);
+      const stateDir = this.config.sessionStateDir ?? path18.join(homedir2(), ".copilot", "session-state");
+      return path18.join(stateDir, this.config.sessionId);
     }
     if (this.config.discover === "latest") {
       const sessions = await discoverCopilotSessions({
@@ -21700,10 +22139,10 @@ var CopilotSdkProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path18.resolve(cwdOverride);
+      return path19.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path18.resolve(this.config.cwd);
+      return path19.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -21712,9 +22151,9 @@ var CopilotSdkProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path18.resolve(this.config.logDir);
+      return path19.resolve(this.config.logDir);
     }
-    return path18.join(process.cwd(), ".agentv", "logs", "copilot-sdk");
+    return path19.join(process.cwd(), ".agentv", "logs", "copilot-sdk");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -21728,7 +22167,7 @@ var CopilotSdkProvider = class {
       console.warn(`Skipping Copilot SDK stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path18.join(logDir, buildLogFilename4(request, this.targetName, "copilot-sdk"));
+    const filePath = path19.join(logDir, buildLogFilename4(request, this.targetName, "copilot-sdk"));
     try {
       const logger = await CopilotStreamLogger.create(
         {
@@ -21757,9 +22196,9 @@ var CopilotSdkProvider = class {
 };
 function resolveSkillDirectories(cwd) {
   const candidates = [
-    path18.join(cwd, ".claude", "skills"),
-    path18.join(cwd, ".agents", "skills"),
-    path18.join(cwd, ".codex", "skills")
+    path19.join(cwd, ".claude", "skills"),
+    path19.join(cwd, ".agents", "skills"),
+    path19.join(cwd, ".codex", "skills")
   ];
   return candidates.filter((dir) => existsSync2(dir));
 }
@@ -22031,7 +22470,7 @@ var PiCliProvider = class {
     const cwd = this.resolveCwd(workspaceRoot, request.cwd);
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
-      const promptFile = path19.join(cwd, PROMPT_FILENAME);
+      const promptFile = path20.join(cwd, PROMPT_FILENAME);
       await writeFile(promptFile, request.question, "utf8");
       const args = this.buildPiArgs(request.question, inputFiles);
       const result = await this.executePi(args, cwd, request.signal, logger);
@@ -22094,10 +22533,10 @@ var PiCliProvider = class {
   }
   resolveCwd(workspaceRoot, cwdOverride) {
     if (cwdOverride) {
-      return path19.resolve(cwdOverride);
+      return path20.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path19.resolve(this.config.cwd);
+      return path20.resolve(this.config.cwd);
     }
     if (workspaceRoot) {
       return workspaceRoot;
@@ -22203,7 +22642,7 @@ ${prompt}` : prompt;
     return env;
   }
   async createWorkspace() {
-    return await mkdtemp(path19.join(tmpdir(), WORKSPACE_PREFIX));
+    return await mkdtemp(path20.join(tmpdir(), WORKSPACE_PREFIX));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
@@ -22213,9 +22652,9 @@ ${prompt}` : prompt;
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return path19.resolve(this.config.logDir);
+      return path20.resolve(this.config.logDir);
     }
-    return path19.join(process.cwd(), ".agentv", "logs", "pi-cli");
+    return path20.join(process.cwd(), ".agentv", "logs", "pi-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -22229,7 +22668,7 @@ ${prompt}` : prompt;
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path19.join(logDir, buildLogFilename5(request, this.targetName));
+    const filePath = path20.join(logDir, buildLogFilename5(request, this.targetName));
     try {
       const logger = await PiStreamLogger.create({
         filePath,
@@ -22700,8 +23139,8 @@ function resolveWindowsCmd(executable) {
     const content = readFileSync2(cmdPath, "utf-8");
     const match = content.match(/"?%_prog%"?\s+"([^"]+\.js)"/);
     if (match) {
-      const dp0 = path19.dirname(path19.resolve(cmdPath));
-      const scriptPath = match[1].replace(/%dp0%[/\\]?/gi, `${dp0}${path19.sep}`);
+      const dp0 = path20.dirname(path20.resolve(cmdPath));
+      const scriptPath = match[1].replace(/%dp0%[/\\]?/gi, `${dp0}${path20.sep}`);
       try {
         accessSync(scriptPath);
         return ["node", [scriptPath]];
@@ -22784,19 +23223,19 @@ function getAgentvHome() {
     }
     return envHome;
   }
-  return path20.join(os2.homedir(), ".agentv");
+  return path21.join(os2.homedir(), ".agentv");
 }
 function getWorkspacesRoot() {
-  return path20.join(getAgentvHome(), "workspaces");
+  return path21.join(getAgentvHome(), "workspaces");
 }
 function getSubagentsRoot() {
-  return path20.join(getAgentvHome(), "subagents");
+  return path21.join(getAgentvHome(), "subagents");
 }
 function getTraceStateRoot() {
-  return path20.join(getAgentvHome(), "trace-state");
+  return path21.join(getAgentvHome(), "trace-state");
 }
 function getWorkspacePoolRoot() {
-  return path20.join(getAgentvHome(), "workspace-pool");
+  return path21.join(getAgentvHome(), "workspace-pool");
 }
 var piCodingAgentModule = null;
 var piAiModule = null;
@@ -22816,7 +23255,7 @@ async function promptInstall() {
   }
 }
 function findManagedSdkInstallRoot() {
-  return path21.join(getAgentvHome(), "deps", "pi-sdk");
+  return path222.join(getAgentvHome(), "deps", "pi-sdk");
 }
 function resolveGlobalNpmRoot() {
   try {
@@ -22830,7 +23269,7 @@ function resolveGlobalNpmRoot() {
   }
 }
 function buildGlobalModuleEntry(moduleName, globalNpmRoot) {
-  return path21.join(globalNpmRoot, ...moduleName.split("/"), "dist", "index.js");
+  return path222.join(globalNpmRoot, ...moduleName.split("/"), "dist", "index.js");
 }
 function findAccessiblePath(paths) {
   for (const candidate of paths) {
@@ -22856,11 +23295,11 @@ async function tryImportLocalSdkModules() {
 async function tryImportManagedSdkModules() {
   const managedRoot = findManagedSdkInstallRoot();
   const piCodingAgentEntry = findAccessiblePath([
-    path21.join(managedRoot, "node_modules", "@mariozechner", "pi-coding-agent", "dist", "index.js")
+    path222.join(managedRoot, "node_modules", "@mariozechner", "pi-coding-agent", "dist", "index.js")
   ]);
   const piAiEntry = findAccessiblePath([
-    path21.join(managedRoot, "node_modules", "@mariozechner", "pi-ai", "dist", "index.js"),
-    path21.join(
+    path222.join(managedRoot, "node_modules", "@mariozechner", "pi-ai", "dist", "index.js"),
+    path222.join(
       managedRoot,
       "node_modules",
       "@mariozechner",
@@ -22891,7 +23330,7 @@ async function tryImportGlobalSdkModules() {
   ]);
   const piAiEntry = findAccessiblePath([
     buildGlobalModuleEntry("@mariozechner/pi-ai", globalNpmRoot),
-    path21.join(
+    path222.join(
       globalNpmRoot,
       "@mariozechner",
       "pi-coding-agent",
@@ -23192,10 +23631,10 @@ ${fileList}`;
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path21.resolve(cwdOverride);
+      return path222.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path21.resolve(this.config.cwd);
+      return path222.resolve(this.config.cwd);
     }
     return process.cwd();
   }
@@ -23214,9 +23653,9 @@ ${fileList}`;
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return path21.resolve(this.config.logDir);
+      return path222.resolve(this.config.logDir);
     }
-    return path21.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
+    return path222.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -23230,7 +23669,7 @@ ${fileList}`;
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path21.join(logDir, buildLogFilename6(request, this.targetName));
+    const filePath = path222.join(logDir, buildLogFilename6(request, this.targetName));
     try {
       const logger = await PiStreamLogger2.create({
         filePath,
@@ -23454,7 +23893,7 @@ async function readDirEntries(target) {
   const entries = await readdir2(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    absolutePath: path222.join(target, entry.name),
+    absolutePath: path23.join(target, entry.name),
     isDirectory: entry.isDirectory()
   }));
 }
@@ -23468,7 +23907,7 @@ async function removeIfExists(target) {
   }
 }
 function pathToFileUri2(filePath) {
-  const absolutePath = path23.isAbsolute(filePath) ? filePath : path23.resolve(filePath);
+  const absolutePath = path24.isAbsolute(filePath) ? filePath : path24.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -23560,8 +23999,8 @@ function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal,
   });
 }
 function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateContent) {
-  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${path24.basename(file)}`).join("\n");
-  const responseList = responseFiles.map((file) => `"${path24.basename(file)}"`).join(", ");
+  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${path25.basename(file)}`).join("\n");
+  const responseList = responseFiles.map((file) => `"${path25.basename(file)}"`).join(", ");
   return renderTemplate2(templateContent, {
     requestFiles: requestLines,
     responseList
@@ -23600,7 +24039,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     try {
-      const content = await readFile9(responseFileFinal, { encoding: "utf8" });
+      const content = await readFile11(responseFileFinal, { encoding: "utf8" });
       if (!silent) {
         process.stdout.write(`${content}
 `);
@@ -23621,7 +24060,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
 }
 async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, silent = false, timeoutMs = DEFAULT_TIMEOUT_MS) {
   if (!silent) {
-    const fileList = responseFilesFinal.map((file) => path25.basename(file)).join(", ");
+    const fileList = responseFilesFinal.map((file) => path26.basename(file)).join(", ");
     console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
   }
   const deadline = Date.now() + timeoutMs;
@@ -23630,7 +24069,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     while (pending.size > 0) {
       if (Date.now() >= deadline) {
         if (!silent) {
-          const remaining = [...pending].map((f) => path25.basename(f)).join(", ");
+          const remaining = [...pending].map((f) => path26.basename(f)).join(", ");
           console.error(
             `error: timed out after ${Math.round(timeoutMs / 1e3)}s waiting for batch responses. Still pending: ${remaining}`
           );
@@ -23657,7 +24096,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     const maxAttempts = 10;
     while (attempts < maxAttempts) {
       try {
-        const content = await readFile9(file, { encoding: "utf8" });
+        const content = await readFile11(file, { encoding: "utf8" });
         if (!silent) {
           process.stdout.write(`${content}
 `);
@@ -23681,7 +24120,7 @@ var DEFAULT_LOCK_NAME = "subagent.lock";
 var DEFAULT_ALIVE_FILENAME = ".alive";
 function getDefaultSubagentRoot(vscodeCmd = "code") {
   const folder = vscodeCmd === "code-insiders" ? "vscode-insiders-agents" : "vscode-agents";
-  return path26.join(getSubagentsRoot(), folder);
+  return path27.join(getSubagentsRoot(), folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 var execAsync2 = promisify2(exec);
@@ -23746,11 +24185,11 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     await raceSpawnError(child);
     return true;
   }
-  const aliveFile = path27.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = path28.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const githubAgentsDir = path27.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path28.join(subagentDir, ".github", "agents");
   await mkdir9(githubAgentsDir, { recursive: true });
-  const wakeupDst = path27.join(githubAgentsDir, "wakeup.md");
+  const wakeupDst = path28.join(githubAgentsDir, "wakeup.md");
   await writeFile2(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
   const workspaceChild = spawnVsCode(vscodeCmd, [workspacePath], {
     label: "open-workspace"
@@ -23763,7 +24202,7 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     "chat",
     "-m",
     wakeupChatId,
-    `create a file named .alive in the ${path27.basename(subagentDir)} folder`
+    `create a file named .alive in the ${path28.basename(subagentDir)} folder`
   ];
   const wakeupChild = spawnVsCode(vscodeCmd, chatArgs, { label: "send-wakeup-chat" });
   await raceSpawnError(wakeupChild);
@@ -23778,10 +24217,10 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
   return true;
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
-  const workspacePath = path27.join(subagentDir, `${path27.basename(subagentDir)}.code-workspace`);
-  const messagesDir = path27.join(subagentDir, "messages");
+  const workspacePath = path28.join(subagentDir, `${path28.basename(subagentDir)}.code-workspace`);
+  const messagesDir = path28.join(subagentDir, "messages");
   await mkdir9(messagesDir, { recursive: true });
-  const reqFile = path27.join(messagesDir, `${timestamp}_req.md`);
+  const reqFile = path28.join(messagesDir, `${timestamp}_req.md`);
   await writeFile2(reqFile, requestInstructions, { encoding: "utf8" });
   const reqUri = pathToFileUri2(reqFile);
   const chatArgs = ["-r", "chat", "-m", chatId];
@@ -23789,16 +24228,16 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
     chatArgs.push("-a", attachment);
   }
   chatArgs.push("-a", reqFile);
-  chatArgs.push(`Follow instructions in [${path27.basename(reqFile)}](${reqUri})`);
+  chatArgs.push(`Follow instructions in [${path28.basename(reqFile)}](${reqUri})`);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    path27.basename(subagentDir),
+    path28.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${path27.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${path28.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -23806,8 +24245,8 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
   await raceSpawnError(child);
 }
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
-  const workspacePath = path27.join(subagentDir, `${path27.basename(subagentDir)}.code-workspace`);
-  const messagesDir = path27.join(subagentDir, "messages");
+  const workspacePath = path28.join(subagentDir, `${path28.basename(subagentDir)}.code-workspace`);
+  const messagesDir = path28.join(subagentDir, "messages");
   await mkdir9(messagesDir, { recursive: true });
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
@@ -23816,13 +24255,13 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
   chatArgs.push(chatInstruction);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    path27.basename(subagentDir),
+    path28.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${path27.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${path28.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -23844,10 +24283,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (path28.isAbsolute(folderPath)) {
+    if (path29.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = path28.resolve(templateDir, folderPath);
+    const absolutePath = path29.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -23869,19 +24308,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = path28.isAbsolute(locationPath);
+          const isAbsolute = path29.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = path28.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = path29.resolve(templateDir, locationPath).replace(/\\/g, "/");
               transformedMap[resolvedPath] = value;
             } else {
               const basePathEnd = locationPath.lastIndexOf("/", firstGlobIndex);
               const basePath = basePathEnd !== -1 ? locationPath.substring(0, basePathEnd) : ".";
               const patternPath = locationPath.substring(basePathEnd !== -1 ? basePathEnd : 0);
-              const resolvedPath = (path28.resolve(templateDir, basePath) + patternPath).replace(
+              const resolvedPath = (path29.resolve(templateDir, basePath) + patternPath).replace(
                 /\\/g,
                 "/"
               );
@@ -23920,7 +24359,7 @@ async function findUnlockedSubagent(subagentRoot) {
     number: Number.parseInt(entry.name.split("-")[1] ?? "", 10)
   })).filter((entry) => Number.isInteger(entry.number)).sort((a, b) => a.number - b.number);
   for (const subagent of subagents) {
-    const lockFile = path29.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = path30.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -23930,7 +24369,7 @@ async function findUnlockedSubagent(subagentRoot) {
 async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = path29.resolve(workspaceTemplate);
+    const workspaceSrc = path30.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
@@ -23938,18 +24377,18 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
     if (!stats.isFile()) {
       throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
     }
-    const templateText = await readFile10(workspaceSrc, "utf8");
+    const templateText = await readFile12(workspaceSrc, "utf8");
     workspaceContent = JSON.parse(templateText);
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${path29.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = path29.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? path29.dirname(path29.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${path30.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = path30.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? path30.dirname(path30.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   let transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
   if (cwd) {
-    const absCwd = path29.resolve(cwd);
+    const absCwd = path30.resolve(cwd);
     const parsed = JSON.parse(transformedContent);
     const alreadyPresent = parsed.folders.some((f) => f.path === absCwd);
     if (!alreadyPresent) {
@@ -23958,35 +24397,35 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
     }
   }
   await writeFile3(workspaceDst, transformedContent, "utf8");
-  const messagesDir = path29.join(subagentDir, "messages");
+  const messagesDir = path30.join(subagentDir, "messages");
   await mkdir10(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = path29.join(subagentDir, "messages");
+  const messagesDir = path30.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
     const files = await readdir3(messagesDir);
     await Promise.all(
       files.map(async (file) => {
-        const target = path29.join(messagesDir, file);
+        const target = path30.join(messagesDir, file);
         await removeIfExists(target);
       })
     );
   }
-  const githubAgentsDir = path29.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path30.join(subagentDir, ".github", "agents");
   if (await pathExists(githubAgentsDir)) {
     const agentFiles = await readdir3(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(path29.join(githubAgentsDir, file)))
+      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(path30.join(githubAgentsDir, file)))
     );
   }
-  const lockFile = path29.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path30.join(subagentDir, DEFAULT_LOCK_NAME);
   await writeFile3(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = path29.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path30.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun, cwd) {
@@ -24006,9 +24445,9 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = path29.join(subagentDir, ".github", "agents");
+    const githubAgentsDir = path30.join(subagentDir, ".github", "agents");
     await mkdir10(githubAgentsDir, { recursive: true });
-    const agentFile = path29.join(githubAgentsDir, `${chatId}.md`);
+    const agentFile = path30.join(githubAgentsDir, `${chatId}.md`);
     try {
       await copyFile(promptFile, agentFile);
     } catch (error) {
@@ -24025,7 +24464,7 @@ async function resolvePromptFile(promptFile) {
   if (!promptFile) {
     return void 0;
   }
-  const resolvedPrompt = path30.resolve(promptFile);
+  const resolvedPrompt = path31.resolve(promptFile);
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
@@ -24041,7 +24480,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = path30.resolve(attachment);
+    const resolvedPath = path31.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -24083,7 +24522,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = path30.basename(subagentDir);
+    const subagentName = path31.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -24111,9 +24550,9 @@ async function dispatchAgentSession(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path30.join(subagentDir, "messages");
-    const responseFileTmp = path30.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = path30.join(messagesDir, `${timestamp}_res.md`);
+    const messagesDir = path31.join(subagentDir, "messages");
+    const responseFileTmp = path31.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = path31.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(
       userQuery,
       responseFileTmp,
@@ -24218,7 +24657,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = path30.basename(subagentDir);
+    subagentName = path31.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -24249,17 +24688,17 @@ async function dispatchBatchAgent(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path30.join(subagentDir, "messages");
+    const messagesDir = path31.join(subagentDir, "messages");
     requestFiles = userQueries.map(
-      (_, index) => path30.join(messagesDir, `${timestamp}_${index}_req.md`)
+      (_, index) => path31.join(messagesDir, `${timestamp}_${index}_req.md`)
     );
     const responseTmpFiles = userQueries.map(
-      (_, index) => path30.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+      (_, index) => path31.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
     );
     responseFilesFinal = userQueries.map(
-      (_, index) => path30.join(messagesDir, `${timestamp}_${index}_res.md`)
+      (_, index) => path31.join(messagesDir, `${timestamp}_${index}_res.md`)
     );
-    const orchestratorFile = path30.join(messagesDir, `${timestamp}_orchestrator.md`);
+    const orchestratorFile = path31.join(messagesDir, `${timestamp}_orchestrator.md`);
     if (!dryRun) {
       await Promise.all(
         userQueries.map((query, index) => {
@@ -24372,7 +24811,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = path31.resolve(targetRoot);
+  const targetPath = path322.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -24392,7 +24831,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = path31.join(entry.absolutePath, lockName);
+      const lockFile = path322.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -24409,10 +24848,10 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const githubAgentsDir = path31.join(subagentDir, ".github", "agents");
-    const lockFile = path31.join(subagentDir, lockName);
-    const workspaceDst = path31.join(subagentDir, `${path31.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path31.join(githubAgentsDir, "wakeup.md");
+    const githubAgentsDir = path322.join(subagentDir, ".github", "agents");
+    const lockFile = path322.join(subagentDir, lockName);
+    const workspaceDst = path322.join(subagentDir, `${path322.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path322.join(githubAgentsDir, "wakeup.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -24450,10 +24889,10 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = path31.join(targetPath, `subagent-${nextIndex}`);
-    const githubAgentsDir = path31.join(subagentDir, ".github", "agents");
-    const workspaceDst = path31.join(subagentDir, `${path31.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path31.join(githubAgentsDir, "wakeup.md");
+    const subagentDir = path322.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = path322.join(subagentDir, ".github", "agents");
+    const workspaceDst = path322.join(subagentDir, `${path322.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path322.join(githubAgentsDir, "wakeup.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
@@ -24639,7 +25078,7 @@ var VSCodeProvider = class {
 async function locateVSCodeExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = path322.isAbsolute(candidate) ? candidate : path322.resolve(candidate);
+    const resolved = path33.isAbsolute(candidate) ? candidate : path33.resolve(candidate);
     try {
       await access3(resolved, constants3.F_OK);
       return resolved;
@@ -24668,7 +25107,7 @@ async function resolveWorkspaceTemplateFile(template) {
     return void 0;
   }
   try {
-    const stats = await stat5(path322.resolve(template));
+    const stats = await stat5(path33.resolve(template));
     return stats.isFile() ? template : void 0;
   } catch {
     return template;
@@ -24692,7 +25131,7 @@ function buildMandatoryPrereadBlock2(attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path322.basename(absolutePath);
+    const fileName = path33.basename(absolutePath);
     const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -24713,7 +25152,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path322.resolve(attachment);
+    const absolutePath = path33.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -24721,7 +25160,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri3(filePath) {
-  const absolutePath = path322.isAbsolute(filePath) ? filePath : path322.resolve(filePath);
+  const absolutePath = path33.isAbsolute(filePath) ? filePath : path33.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -24734,7 +25173,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(path322.resolve(attachment));
+    deduped.add(path33.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -24743,7 +25182,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(path322.resolve(inputFile));
+      deduped.add(path33.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -24826,12 +25265,12 @@ async function fileExists3(filePath) {
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = path33.resolve(filePath);
+  const absolutePath = path34.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await readFile11(absolutePath, "utf8");
-  const parsed = parse4(raw);
+  const raw = await readFile13(absolutePath, "utf8");
+  const parsed = parse5(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
   }
@@ -24847,11 +25286,11 @@ function listTargetNames(definitions) {
 async function discoverProviders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path34.resolve(baseDir);
-  const root = path34.parse(dir).root;
+  let dir = path35.resolve(baseDir);
+  const root = path35.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path34.join(dir, ".agentv", "providers"));
-    dir = path34.dirname(dir);
+    candidateDirs.push(path35.join(dir, ".agentv", "providers"));
+    dir = path35.dirname(dir);
   }
   let files = [];
   for (const providersDir of candidateDirs) {
@@ -24867,7 +25306,7 @@ async function discoverProviders(registry, baseDir) {
   }
   const discoveredKinds = [];
   for (const filePath of files) {
-    const basename = path34.basename(filePath);
+    const basename = path35.basename(filePath);
     const kindName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(kindName)) {
       continue;
@@ -24983,148 +25422,6 @@ function negateScore(score) {
     }))
   };
 }
-function shellEscapePath(value) {
-  if (process.platform === "win32") {
-    return `"${value.replaceAll('"', '""')}"`;
-  }
-  return `'${value.replaceAll("'", `'"'"'`)}'`;
-}
-async function execFileWithStdin(argv, stdinPayload, options = {}) {
-  if (argv.length === 0) {
-    throw new Error("Executable argv must include at least one entry");
-  }
-  if (typeof Bun !== "undefined") {
-    return execFileWithStdinBun(argv, stdinPayload, options);
-  }
-  return execFileWithStdinNode(argv, stdinPayload, options);
-}
-async function execFileWithStdinBun(argv, stdinPayload, options) {
-  const command = [...argv];
-  const encoder = new TextEncoder();
-  const proc = Bun.spawn(command, {
-    cwd: options.cwd,
-    stdin: encoder.encode(stdinPayload),
-    stdout: "pipe",
-    stderr: "pipe",
-    // Merge additional env vars with process.env
-    env: options.env ? { ...process.env, ...options.env } : process.env
-  });
-  let timedOut = false;
-  const timeout = options.timeoutMs !== void 0 ? setTimeout(() => {
-    timedOut = true;
-    proc.kill("SIGKILL");
-  }, options.timeoutMs) : void 0;
-  try {
-    const stdoutPromise = proc.stdout ? new Response(proc.stdout).text() : Promise.resolve("");
-    const stderrPromise = proc.stderr ? new Response(proc.stderr).text() : Promise.resolve("");
-    const [stdout, stderr, exitCode] = await Promise.all([
-      stdoutPromise,
-      stderrPromise,
-      proc.exited
-    ]);
-    if (timedOut) {
-      throw new Error(`Process timed out after ${options.timeoutMs}ms`);
-    }
-    return {
-      stdout: stdout.replace(/\r\n/g, "\n"),
-      stderr: stderr.replace(/\r\n/g, "\n"),
-      exitCode
-    };
-  } finally {
-    if (timeout !== void 0) {
-      clearTimeout(timeout);
-    }
-  }
-}
-async function execFileWithStdinNode(argv, stdinPayload, options) {
-  const { spawn: spawn5 } = await import("node:child_process");
-  return new Promise((resolve2, reject) => {
-    const [cmd, ...args] = argv;
-    const child = spawn5(cmd, args, {
-      cwd: options.cwd,
-      stdio: ["pipe", "pipe", "pipe"],
-      // Merge additional env vars with process.env
-      env: options.env ? { ...process.env, ...options.env } : process.env
-    });
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
-    child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
-    let timedOut = false;
-    const timeout = options.timeoutMs !== void 0 ? setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGKILL");
-    }, options.timeoutMs) : void 0;
-    child.on("error", (error) => {
-      if (timeout !== void 0) clearTimeout(timeout);
-      reject(error);
-    });
-    child.on("close", (code) => {
-      if (timeout !== void 0) clearTimeout(timeout);
-      if (timedOut) {
-        reject(new Error(`Process timed out after ${options.timeoutMs}ms`));
-        return;
-      }
-      const stdout = Buffer.concat(stdoutChunks).toString("utf8").replace(/\r\n/g, "\n");
-      const stderr = Buffer.concat(stderrChunks).toString("utf8").replace(/\r\n/g, "\n");
-      resolve2({
-        stdout,
-        stderr,
-        exitCode: code ?? 0
-      });
-    });
-    if (child.stdin) {
-      child.stdin.write(stdinPayload);
-      child.stdin.end();
-    }
-  });
-}
-async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir16, readFile: readFile16, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
-  const { tmpdir: tmpdir3 } = await import("node:os");
-  const path51 = await import("node:path");
-  const { randomUUID: randomUUID10 } = await import("node:crypto");
-  const dir = path51.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
-  await mkdir16(dir, { recursive: true });
-  const stdinPath = path51.join(dir, "stdin.txt");
-  const stdoutPath = path51.join(dir, "stdout.txt");
-  const stderrPath = path51.join(dir, "stderr.txt");
-  await writeFile9(stdinPath, stdinPayload, "utf8");
-  const wrappedCommand = process.platform === "win32" ? `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
-  const { spawn: spawn5 } = await import("node:child_process");
-  try {
-    const exitCode = await new Promise((resolve2, reject) => {
-      const child = spawn5(wrappedCommand, {
-        shell: true,
-        cwd: options.cwd,
-        stdio: ["ignore", "ignore", "ignore"],
-        // Merge additional env vars with process.env
-        env: options.env ? { ...process.env, ...options.env } : process.env
-      });
-      const timeout = options.timeoutMs ? setTimeout(() => {
-        child.kill();
-        reject(new Error(`Process timed out after ${options.timeoutMs}ms`));
-      }, options.timeoutMs) : void 0;
-      child.on("error", (error) => {
-        if (timeout !== void 0) {
-          clearTimeout(timeout);
-        }
-        reject(error);
-      });
-      child.on("exit", (code) => {
-        if (timeout !== void 0) {
-          clearTimeout(timeout);
-        }
-        resolve2(code ?? 0);
-      });
-    });
-    const stdout = (await readFile16(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile16(stderrPath, "utf8")).replace(/\r\n/g, "\n");
-    return { stdout, stderr, exitCode };
-  } finally {
-    await rm6(dir, { recursive: true, force: true });
-  }
-}
 var DEFAULT_MAX_CALLS = 50;
 async function createTargetProxy(options) {
   const { defaultProvider, targetResolver, availableTargets, maxCalls } = options;
@@ -25395,6 +25692,16 @@ function toCamelCaseDeep(obj) {
   }
   return obj;
 }
+function getRepoCheckoutRef(checkout) {
+  return checkout?.base_commit ?? checkout?.ref ?? "HEAD";
+}
+function getRepoCheckoutTargets(repos) {
+  if (!repos) return [];
+  return repos.filter((repo) => repo.checkout?.base_commit || repo.checkout?.ref).map((repo) => ({
+    path: repo.path,
+    ref: getRepoCheckoutRef(repo.checkout)
+  }));
+}
 var FILE_BACKED_OUTPUT_THRESHOLD = 5e4;
 var DATA_URI_RE = /^data:([^;]+);base64,(.+)$/s;
 async function materializeContentForGrader(messages, getWorkDir) {
@@ -25528,13 +25835,31 @@ var CodeEvaluator = class {
     const workspaceEnv = context2.workspacePath ? { AGENTV_WORKSPACE_PATH: context2.workspacePath } : void 0;
     const env = proxyEnv || workspaceEnv ? { ...proxyEnv, ...workspaceEnv } : void 0;
     try {
-      const stdout = await executeScript(
-        this.command,
-        inputPayload,
-        this.agentTimeoutMs,
-        this.cwd,
-        env
-      );
+      let stdout;
+      if (context2.dockerConfig) {
+        const { DockerWorkspaceProvider: DockerWorkspaceProvider2 } = await import("./docker-workspace-RPPXBT27-B4AQHVWA.js");
+        const dockerProvider = new DockerWorkspaceProvider2(context2.dockerConfig);
+        const result = await dockerProvider.runGraderInContainer({
+          command: [...this.command],
+          stdin: inputPayload,
+          repoCheckouts: getRepoCheckoutTargets(context2.evalCase.workspace?.repos)
+        });
+        if (result.exitCode !== 0) {
+          const trimmedErr = result.stderr.trim();
+          throw new Error(
+            trimmedErr.length > 0 ? `Code evaluator exited with code ${result.exitCode}: ${trimmedErr}` : `Code evaluator exited with code ${result.exitCode}`
+          );
+        }
+        stdout = result.stdout.trim();
+      } else {
+        stdout = await executeScript(
+          this.command,
+          inputPayload,
+          this.agentTimeoutMs,
+          this.cwd,
+          env
+        );
+      }
       const parsed = parseJsonSafe(stdout);
       const score = clampScore(typeof parsed?.score === "number" ? parsed.score : 0);
       const assertions = Array.isArray(parsed?.assertions) ? parsed.assertions.filter(
@@ -25702,6 +26027,15 @@ var scoreRangeEvaluationSchema = external_exports2.object({
   checks: external_exports2.array(scoreRangeCheckResultSchema).describe("Scores for each rubric criterion"),
   overall_reasoning: external_exports2.string().describe("Overall assessment summary (1-2 sentences)").optional()
 });
+function resolveContentBasePath(context2) {
+  if (context2.workspacePath) {
+    return context2.workspacePath;
+  }
+  if ("config" in context2.target && context2.target.config && typeof context2.target.config === "object" && "cwd" in context2.target.config && typeof context2.target.config.cwd === "string") {
+    return context2.target.config.cwd;
+  }
+  return void 0;
+}
 var LlmGraderEvaluator = class {
   kind = "llm-grader";
   resolveGraderProvider;
@@ -25719,24 +26053,46 @@ var LlmGraderEvaluator = class {
     this.graderTargetProvider = options.graderTargetProvider ?? options.judgeTargetProvider;
   }
   async evaluate(context2) {
+    const preparedContext = await this.prepareContext(context2);
     if (this.graderTargetProvider) {
-      return this.evaluateWithGraderTarget(context2);
+      return this.evaluateWithGraderTarget(preparedContext);
     }
-    const graderProvider = await this.resolveGraderProvider(context2);
+    const graderProvider = await this.resolveGraderProvider(preparedContext);
     if (!graderProvider) {
       throw new Error("No grader provider available for LLM grading");
     }
     if (graderProvider.kind === "agentv") {
-      return this.evaluateBuiltIn(context2, graderProvider);
+      return this.evaluateBuiltIn(preparedContext, graderProvider);
     }
     if (isAgentProvider(graderProvider)) {
-      return this.evaluateWithDelegatedAgent(context2, graderProvider);
+      return this.evaluateWithDelegatedAgent(preparedContext, graderProvider);
     }
-    const config = context2.evaluator;
+    const config = preparedContext.evaluator;
     if (config?.type === "llm-grader" && config.rubrics && config.rubrics.length > 0) {
-      return this.evaluateWithRubrics(context2, graderProvider, config.rubrics);
+      return this.evaluateWithRubrics(preparedContext, graderProvider, config.rubrics);
+    }
+    return this.evaluateFreeform(preparedContext, graderProvider);
+  }
+  async prepareContext(context2) {
+    const config = context2.evaluator;
+    if (config?.type !== "llm-grader" || !context2.output) {
+      return context2;
     }
-    return this.evaluateFreeform(context2, graderProvider);
+    const lastAssistant = [...context2.output].reverse().find((message) => message.role === "assistant" && message.content !== void 0);
+    if (!lastAssistant || typeof lastAssistant.content === "string") {
+      return context2;
+    }
+    const extracted = await extractTextWithPreprocessors(
+      lastAssistant.content,
+      config.preprocessors,
+      {
+        basePath: resolveContentBasePath(context2)
+      }
+    );
+    return {
+      ...context2,
+      candidate: appendPreprocessingWarnings(extracted.text, extracted.warnings)
+    };
   }
   // ---------------------------------------------------------------------------
   // LLM mode (existing)
@@ -26621,8 +26977,8 @@ function toAiSdkImageParts(images) {
   }));
 }
 function resolveSandboxed(basePath, relativePath) {
-  const resolved = path35.resolve(basePath, relativePath);
-  if (!resolved.startsWith(basePath + path35.sep) && resolved !== basePath) {
+  const resolved = path36.resolve(basePath, relativePath);
+  if (!resolved.startsWith(basePath + path36.sep) && resolved !== basePath) {
     throw new Error(`Path '${relativePath}' is outside the workspace`);
   }
   return resolved;
@@ -26655,11 +27011,11 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const stat11 = await fs2.stat(resolved);
-          if (stat11.isDirectory()) {
+          const stat12 = await fs2.stat(resolved);
+          if (stat12.isDirectory()) {
             return { error: `'${input.path}' is a directory, not a file` };
           }
-          const buffer = Buffer.alloc(Math.min(stat11.size, MAX_FILE_SIZE));
+          const buffer = Buffer.alloc(Math.min(stat12.size, MAX_FILE_SIZE));
           const fd = await fs2.open(resolved, "r");
           try {
             await fd.read(buffer, 0, buffer.length, 0);
@@ -26667,8 +27023,8 @@ function createFilesystemTools(workspacePath) {
             await fd.close();
           }
           const content = buffer.toString("utf-8");
-          const truncated = stat11.size > MAX_FILE_SIZE;
-          return { content, truncated, size: stat11.size };
+          const truncated = stat12.size > MAX_FILE_SIZE;
+          return { content, truncated, size: stat12.size };
         } catch (error) {
           return { error: error instanceof Error ? error.message : String(error) };
         }
@@ -26712,15 +27068,15 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
   for (const entry of entries) {
     if (matches.length >= MAX_SEARCH_MATCHES) return;
     if (SEARCH_SKIP_DIRS.has(entry.name)) continue;
-    const fullPath = path35.join(dirPath, entry.name);
+    const fullPath = path36.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       await searchDirectory(fullPath, workspacePath, regex, matches);
     } else if (entry.isFile()) {
-      const ext = path35.extname(entry.name).toLowerCase();
+      const ext = path36.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
-        const stat11 = await fs2.stat(fullPath);
-        if (stat11.size > MAX_FILE_SIZE) continue;
+        const stat12 = await fs2.stat(fullPath);
+        if (stat12.size > MAX_FILE_SIZE) continue;
         const content = await fs2.readFile(fullPath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
@@ -26728,7 +27084,7 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
           regex.lastIndex = 0;
           if (regex.test(lines[i])) {
             matches.push({
-              file: path35.relative(workspacePath, fullPath),
+              file: path36.relative(workspacePath, fullPath),
               line: i + 1,
               text: lines[i].substring(0, 200)
             });
@@ -27353,115 +27709,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path51, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path51);
-    const expectedValue = resolvePath(expectedData, path51);
+    const { path: path53, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path53);
+    const expectedValue = resolvePath(expectedData, path53);
     if (expectedValue === void 0) {
       return {
-        path: path51,
+        path: path53,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path51}: no expected value`
+        message: `${path53}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path51,
+          path: path53,
           score: 0,
           weight,
           hit: false,
-          message: `${path51} (required, missing)`
+          message: `${path53} (required, missing)`
         };
       }
       return {
-        path: path51,
+        path: path53,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path51}: optional field missing`
+        message: `${path53}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path51, candidateValue, expectedValue, weight);
+        return this.compareExact(path53, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path51,
+          path53,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path51, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path53, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path51,
+          path: path53,
           score: 0,
           weight,
           hit: false,
-          message: `${path51}: unknown match type "${match}"`
+          message: `${path53}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path51, candidateValue, expectedValue, weight) {
+  compareExact(path53, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path51,
+        path: path53,
         score: 1,
         weight,
         hit: true,
-        message: path51
+        message: path53
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path51,
+        path: path53,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path53} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path51,
+      path: path53,
       score: 0,
       weight,
       hit: false,
-      message: `${path51} (value mismatch)`
+      message: `${path53} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path51, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path53, candidateValue, expectedValue, fieldConfig, weight) {
     const { tolerance = 0, relative = false } = fieldConfig;
     const candidateNum = toNumber(candidateValue);
     const expectedNum = toNumber(expectedValue);
     if (candidateNum === null || expectedNum === null) {
       return {
-        path: path51,
+        path: path53,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (non-numeric value)`
+        message: `${path53} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path51,
+        path: path53,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (invalid numeric value)`
+        message: `${path53} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -27474,61 +27830,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path51,
+        path: path53,
         score: 1,
         weight,
         hit: true,
-        message: `${path51} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path53} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path51,
+      path: path53,
       score: 0,
       weight,
       hit: false,
-      message: `${path51} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path53} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path51, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path53, candidateValue, expectedValue, fieldConfig, weight) {
     const formats = fieldConfig.formats ?? DEFAULT_DATE_FORMATS;
     const candidateDate = parseDate(String(candidateValue), formats);
     const expectedDate = parseDate(String(expectedValue), formats);
     if (candidateDate === null) {
       return {
-        path: path51,
+        path: path53,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (unparseable candidate date)`
+        message: `${path53} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path51,
+        path: path53,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (unparseable expected date)`
+        message: `${path53} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path51,
+        path: path53,
         score: 1,
         weight,
         hit: true,
-        message: path51
+        message: path53
       };
     }
     return {
-      path: path51,
+      path: path53,
       score: 0,
       weight,
       hit: false,
-      message: `${path51} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path53} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -27561,11 +27917,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path51) {
-  if (!path51 || !obj) {
+function resolvePath(obj, path53) {
+  if (!path53 || !obj) {
     return void 0;
   }
-  const parts = path51.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path53.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -28047,8 +28403,8 @@ var TokenUsageEvaluator = class {
     };
   }
 };
-function getNestedValue(obj, path51) {
-  const parts = path51.split(".");
+function getNestedValue(obj, path53) {
+  const parts = path53.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -28894,6 +29250,15 @@ async function resolveCustomPrompt(promptConfig, context2, timeoutMs) {
   }
   return void 0;
 }
+function containsTemplateVariables(text2) {
+  const variablePattern = /\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g;
+  for (const match of text2.matchAll(variablePattern)) {
+    if (VALID_TEMPLATE_VARIABLES.has(match[1])) {
+      return true;
+    }
+  }
+  return false;
+}
 async function executePromptTemplate(script, context2, config, timeoutMs) {
   const payload = {
     criteria: context2.evalCase.criteria,
@@ -28908,7 +29273,7 @@ async function executePromptTemplate(script, context2, config, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = path36.dirname(scriptPath);
+  const cwd = path37.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();
@@ -28964,9 +29329,20 @@ var llmGraderFactory = (config, context2) => {
         },
         agentTimeoutMs
       );
+      const isFromInlinePrompt = !c.resolvedPromptScript?.length && !c.resolvedPromptPath && !c.promptPath;
+      let evaluatorTemplateOverride;
+      let evalCase = evalContext.evalCase;
+      if (customPrompt) {
+        if (!isFromInlinePrompt || containsTemplateVariables(customPrompt)) {
+          evaluatorTemplateOverride = customPrompt;
+        } else {
+          evalCase = { ...evalCase, criteria: customPrompt };
+        }
+      }
       return evaluator.evaluate({
         ...evalContext,
-        evaluatorTemplateOverride: customPrompt,
+        evalCase,
+        evaluatorTemplateOverride,
         evaluator: c
       });
     }
@@ -29179,11 +29555,11 @@ function createBuiltinRegistry() {
 async function discoverAssertions(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path37.resolve(baseDir);
-  const root = path37.parse(dir).root;
+  let dir = path38.resolve(baseDir);
+  const root = path38.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path37.join(dir, ".agentv", "assertions"));
-    dir = path37.dirname(dir);
+    candidateDirs.push(path38.join(dir, ".agentv", "assertions"));
+    dir = path38.dirname(dir);
   }
   let files = [];
   for (const assertionsDir of candidateDirs) {
@@ -29199,7 +29575,7 @@ async function discoverAssertions(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = path37.basename(filePath);
+    const basename = path38.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -29218,12 +29594,12 @@ async function discoverAssertions(registry, baseDir) {
 async function discoverGraders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path38.resolve(baseDir);
-  const root = path38.parse(dir).root;
+  let dir = path39.resolve(baseDir);
+  const root = path39.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path38.join(dir, ".agentv", "graders"));
-    candidateDirs.push(path38.join(dir, ".agentv", "judges"));
-    dir = path38.dirname(dir);
+    candidateDirs.push(path39.join(dir, ".agentv", "graders"));
+    candidateDirs.push(path39.join(dir, ".agentv", "judges"));
+    dir = path39.dirname(dir);
   }
   let files = [];
   for (const gradersDir of candidateDirs) {
@@ -29239,7 +29615,7 @@ async function discoverGraders(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = path38.basename(filePath);
+    const basename = path39.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -29425,10 +29801,10 @@ async function stageNestedRepoChanges(workspacePath) {
   }
   for (const entry of entries) {
     if (entry === ".git" || entry === "node_modules") continue;
-    const childPath = path39.join(workspacePath, entry);
+    const childPath = path40.join(workspacePath, entry);
     try {
       if (!statSync(childPath).isDirectory()) continue;
-      if (!statSync(path39.join(childPath, ".git")).isDirectory()) continue;
+      if (!statSync(path40.join(childPath, ".git")).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -29465,14 +29841,14 @@ async function isDirectory(filePath) {
 }
 function getWorkspacePath(evalRunId, caseId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
-  return path40.join(root, evalRunId, caseId);
+  return path41.join(root, evalRunId, caseId);
 }
 async function copyDirectoryRecursive(src, dest) {
   await mkdir12(dest, { recursive: true });
   const entries = await readdir4(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path40.join(src, entry.name);
-    const destPath = path40.join(dest, entry.name);
+    const srcPath = path41.join(src, entry.name);
+    const destPath = path41.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
@@ -29484,7 +29860,7 @@ async function copyDirectoryRecursive(src, dest) {
   }
 }
 async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoot) {
-  const resolvedTemplatePath = path40.resolve(templatePath);
+  const resolvedTemplatePath = path41.resolve(templatePath);
   if (!await fileExists(resolvedTemplatePath)) {
     throw new TemplateNotFoundError(resolvedTemplatePath);
   }
@@ -29533,7 +29909,7 @@ async function cleanupWorkspace(workspacePath) {
 }
 async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
-  const evalDir = path40.join(root, evalRunId);
+  const evalDir = path41.join(root, evalRunId);
   if (await fileExists(evalDir)) {
     await rm4(evalDir, { recursive: true, force: true });
   }
@@ -29563,12 +29939,14 @@ async function git(args, opts) {
   return stdout.trim();
 }
 function normalizeRepoForFingerprint(repo) {
-  const source = repo.source.type === "git" ? { type: "git", url: repo.source.url.toLowerCase().replace(/\.git$/, "") } : { type: "local", path: repo.source.path };
-  const result = {
-    path: repo.path,
-    source,
-    ref: repo.checkout?.ref ?? "HEAD"
-  };
+  const result = {};
+  if (repo.path) {
+    result.path = repo.path;
+  }
+  if (repo.source) {
+    result.source = repo.source.type === "git" ? { type: "git", url: repo.source.url.toLowerCase().replace(/\.git$/, "") } : { type: "local", path: repo.source.path };
+  }
+  result.ref = getRepoCheckoutRef(repo.checkout);
   if (repo.clone?.depth !== void 0) {
     result.depth = repo.clone.depth;
   }
@@ -29582,7 +29960,7 @@ function normalizeRepoForFingerprint(repo) {
 }
 function computeWorkspaceFingerprint(repos) {
   const canonical = {
-    repos: [...repos].sort((a, b) => a.path.localeCompare(b.path)).map(normalizeRepoForFingerprint)
+    repos: [...repos].sort((a, b) => (a.path ?? "").localeCompare(b.path ?? "")).map(normalizeRepoForFingerprint)
   };
   return createHash("sha256").update(JSON.stringify(canonical)).digest("hex");
 }
@@ -29590,8 +29968,8 @@ async function copyDirectoryRecursive2(src, dest, skipDirs) {
   await mkdir13(dest, { recursive: true });
   const entries = await readdir5(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path41.join(src, entry.name);
-    const destPath = path41.join(dest, entry.name);
+    const srcPath = path422.join(src, entry.name);
+    const destPath = path422.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
@@ -29624,7 +30002,7 @@ var WorkspacePoolManager = class {
   async acquireWorkspace(options) {
     const { templatePath, repos, maxSlots, repoManager, poolReset } = options;
     const fingerprint = computeWorkspaceFingerprint(repos);
-    const poolDir = path41.join(this.poolRoot, fingerprint);
+    const poolDir = path422.join(this.poolRoot, fingerprint);
     await mkdir13(poolDir, { recursive: true });
     const drifted = await this.checkDrift(poolDir, fingerprint);
     if (drifted) {
@@ -29634,7 +30012,7 @@ var WorkspacePoolManager = class {
       await this.removeAllSlots(poolDir);
     }
     for (let i = 0; i < maxSlots; i++) {
-      const slotPath = path41.join(poolDir, `slot-${i}`);
+      const slotPath = path422.join(poolDir, `slot-${i}`);
       const lockPath = `${slotPath}.lock`;
       const locked = await this.tryLock(lockPath);
       if (!locked) {
@@ -29696,7 +30074,7 @@ var WorkspacePoolManager = class {
           throw err;
         }
         try {
-          const pidStr = await readFile12(lockPath, "utf-8");
+          const pidStr = await readFile14(lockPath, "utf-8");
           const pid = Number.parseInt(pidStr.trim(), 10);
           if (!Number.isNaN(pid)) {
             try {
@@ -29721,9 +30099,9 @@ var WorkspacePoolManager = class {
    * Returns false (no drift) if metadata.json doesn't exist (first use).
    */
   async checkDrift(poolDir, fingerprint) {
-    const metadataPath = path41.join(poolDir, "metadata.json");
+    const metadataPath = path422.join(poolDir, "metadata.json");
     try {
-      const raw = await readFile12(metadataPath, "utf-8");
+      const raw = await readFile14(metadataPath, "utf-8");
       const metadata = JSON.parse(raw);
       return metadata.fingerprint !== fingerprint;
     } catch {
@@ -29738,17 +30116,17 @@ var WorkspacePoolManager = class {
       repos,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await writeFile7(path41.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+    await writeFile7(path422.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 readdir5(poolDir);
     for (const entry of entries) {
       if (entry.startsWith("slot-") && !entry.endsWith(".lock")) {
-        const lockPath = path41.join(poolDir, `${entry}.lock`);
+        const lockPath = path422.join(poolDir, `${entry}.lock`);
         if (existsSync3(lockPath)) {
           try {
-            const pidStr = await readFile12(lockPath, "utf-8");
+            const pidStr = await readFile14(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
             if (!Number.isNaN(pid)) {
               try {
@@ -29761,12 +30139,12 @@ var WorkspacePoolManager = class {
           } catch {
           }
         }
-        await rm5(path41.join(poolDir, entry), { recursive: true, force: true });
+        await rm5(path422.join(poolDir, entry), { recursive: true, force: true });
         await rm5(lockPath, { force: true }).catch(() => {
         });
       }
     }
-    await rm5(path41.join(poolDir, "metadata.json"), { force: true }).catch(() => {
+    await rm5(path422.join(poolDir, "metadata.json"), { force: true }).catch(() => {
     });
   }
   /**
@@ -29776,14 +30154,15 @@ var WorkspacePoolManager = class {
    */
   async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
     for (const repo of repos) {
-      const repoDir = path41.join(slotPath, repo.path);
+      if (!repo.path || !repo.source) continue;
+      const repoDir = path422.join(slotPath, repo.path);
       if (!existsSync3(repoDir)) {
         continue;
       }
       if (poolReset === "none") {
         continue;
       }
-      const ref = repo.checkout?.ref ?? "HEAD";
+      const ref = getRepoCheckoutRef(repo.checkout);
       const resolve2 = repo.checkout?.resolve ?? "remote";
       if (resolve2 === "remote") {
         const fetchArgs = ["fetch", "origin", ref];
@@ -29800,8 +30179,8 @@ var WorkspacePoolManager = class {
     }
     if (templatePath) {
       const repoDirNames = new Set(
-        repos.map((r) => {
-          const normalized = r.path.replace(/^\.\//, "");
+        repos.filter((r) => r.path).map((r) => {
+          const normalized = (r.path ?? "").replace(/^\.\//, "");
           return normalized.split("/")[0];
         })
       );
@@ -29850,17 +30229,17 @@ var RepoManager = class {
   static validateLocalPaths(repos) {
     const errors = [];
     for (const repo of repos) {
-      if (repo.source.type !== "local") continue;
+      if (!repo.source || repo.source.type !== "local") continue;
       const sourcePath = repo.source.path;
       if (!sourcePath || sourcePath.trim() === "") {
         errors.push({
-          repoPath: repo.path,
+          repoPath: repo.path ?? "(none)",
           resolvedSourcePath: sourcePath ?? "",
           reason: "empty_path"
         });
       } else if (!existsSync4(sourcePath)) {
         errors.push({
-          repoPath: repo.path,
+          repoPath: repo.path ?? "(none)",
           resolvedSourcePath: sourcePath,
           reason: "not_found"
         });
@@ -29907,7 +30286,13 @@ ${lines.join("\n")}`;
    * Handles checkout, ref resolution, ancestor walking, shallow clone, sparse checkout.
    */
   async materialize(repo, workspacePath) {
-    const targetDir = path422.join(workspacePath, repo.path);
+    if (!repo.source || !repo.path) {
+      if (this.verbose) {
+        console.log(`[repo] materialize skip path=${repo.path ?? "(none)"} (no source or path)`);
+      }
+      return;
+    }
+    const targetDir = path43.join(workspacePath, repo.path);
     const sourceUrl = getSourceUrl(repo.source);
     const startedAt = Date.now();
     if (this.verbose) {
@@ -29930,7 +30315,7 @@ ${lines.join("\n")}`;
       await this.runGit(["sparse-checkout", "init", "--cone"], { cwd: targetDir });
       await this.runGit(["sparse-checkout", "set", ...repo.clone.sparse], { cwd: targetDir });
     }
-    const ref = repo.checkout?.ref ?? "HEAD";
+    const ref = getRepoCheckoutRef(repo.checkout);
     const resolve2 = repo.checkout?.resolve ?? "remote";
     let resolvedSha;
     if (resolve2 === "remote" && repo.source.type === "git") {
@@ -29982,23 +30367,27 @@ ${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) {
-      const targetDir = path422.join(workspacePath, repo.path);
+      if (!repo.path || !repo.source) continue;
+      const targetDir = path43.join(workspacePath, repo.path);
       await this.runGit(["reset", "--hard", "HEAD"], { cwd: targetDir });
       await this.runGit(["clean", cleanFlag], { cwd: targetDir });
     }
@@ -30008,11 +30397,11 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (!templatePath) {
     return void 0;
   }
-  const resolved = path43.resolve(templatePath);
+  const resolved = path44.resolve(templatePath);
   const stats = await stat7(resolved);
   if (stats.isFile()) {
     return {
-      dir: path43.dirname(resolved),
+      dir: path44.dirname(resolved),
       workspaceFile: resolved
     };
   }
@@ -30024,14 +30413,14 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (workspaceFiles.length === 1) {
     return {
       dir: resolved,
-      workspaceFile: path43.join(resolved, workspaceFiles[0])
+      workspaceFile: path44.join(resolved, workspaceFiles[0])
     };
   }
   if (workspaceFiles.length > 1) {
     const conventionFile = workspaceFiles.find((f) => f === "template.code-workspace");
     return {
       dir: resolved,
-      workspaceFile: conventionFile ? path43.join(resolved, conventionFile) : void 0
+      workspaceFile: conventionFile ? path44.join(resolved, conventionFile) : void 0
     };
   }
   return { dir: resolved };
@@ -30246,7 +30635,7 @@ async function runEvaluation(options) {
   ];
   const evaluatorRegistry = buildEvaluatorRegistry(evaluators, resolveGraderProvider);
   const typeRegistry = createBuiltinRegistry();
-  const discoveryBaseDir = evalFilePath ? path44.dirname(path44.resolve(evalFilePath)) : process.cwd();
+  const discoveryBaseDir = evalFilePath ? path45.dirname(path45.resolve(evalFilePath)) : process.cwd();
   const evalDir = discoveryBaseDir;
   await discoverAssertions(typeRegistry, discoveryBaseDir);
   await discoverGraders(typeRegistry, discoveryBaseDir);
@@ -30313,7 +30702,8 @@ async function runEvaluation(options) {
   for (const ec of filteredEvalCases) {
     if (ec.workspace?.repos) {
       for (const repo of ec.workspace.repos) {
-        const key = `${repo.path}::${repo.source.type === "local" ? repo.source.path : ""}`;
+        if (!repo.source) continue;
+        const key = `${repo.path ?? ""}::${repo.source.type === "local" ? repo.source.path : ""}`;
         if (!allRepos.has(key)) {
           allRepos.set(key, repo);
         }
@@ -30326,7 +30716,7 @@ async function runEvaluation(options) {
       const message = RepoManager.formatValidationErrors(localPathErrors);
       console.warn(`Warning: ${message}`);
       const invalidLocalRepoPaths = new Set(localPathErrors.map((e) => e.repoPath));
-      if (suiteWorkspace?.repos?.some((r) => invalidLocalRepoPaths.has(r.path))) {
+      if (suiteWorkspace?.repos?.some((r) => r.path && invalidLocalRepoPaths.has(r.path))) {
         throw new Error(message);
       }
     }
@@ -30444,7 +30834,7 @@ async function runEvaluation(options) {
   }
   try {
     if (suiteWorkspaceFile && sharedWorkspacePath) {
-      const copiedWorkspaceFile = path44.join(sharedWorkspacePath, path44.basename(suiteWorkspaceFile));
+      const copiedWorkspaceFile = path45.join(sharedWorkspacePath, path45.basename(suiteWorkspaceFile));
       try {
         await stat8(copiedWorkspaceFile);
         suiteWorkspaceFile = copiedWorkspaceFile;
@@ -30459,7 +30849,8 @@ async function runEvaluation(options) {
       try {
         if (needsPerRepoCheck) {
           for (const repo of suiteWorkspace.repos) {
-            const targetDir = path44.join(sharedWorkspacePath, repo.path);
+            if (!repo.path || !repo.source) continue;
+            const targetDir = path45.join(sharedWorkspacePath, repo.path);
             if (existsSync5(targetDir)) {
               setupLog(`reusing existing repo at: ${targetDir}`);
               continue;
@@ -30483,6 +30874,19 @@ async function runEvaluation(options) {
         throw new Error(`Failed to materialize repos: ${message}`);
       }
     }
+    const suiteDockerConfig = suiteWorkspace?.docker;
+    if (suiteDockerConfig) {
+      setupLog(`pulling Docker image: ${suiteDockerConfig.image}`);
+      const { DockerWorkspaceProvider: DockerWorkspaceProvider2 } = await import("./docker-workspace-RPPXBT27-B4AQHVWA.js");
+      const dockerSetup = new DockerWorkspaceProvider2(suiteDockerConfig);
+      if (!await dockerSetup.isDockerAvailable()) {
+        throw new Error(
+          "Docker workspace configured but Docker CLI is not available. Install Docker and ensure it is running."
+        );
+      }
+      await dockerSetup.pullImage();
+      setupLog("Docker image pull complete");
+    }
     const suiteHooksEnabled = hooksEnabled(suiteWorkspace);
     const suiteBeforeAllHook = suiteWorkspace?.hooks?.before_all;
     if (sharedWorkspacePath && suiteHooksEnabled && hasHookCommand(suiteBeforeAllHook)) {
@@ -30843,11 +31247,9 @@ async function runBatchEvaluation(options) {
     const promptInputs = promptInputsList[index];
     return {
       question: promptInputs.question,
+      systemPrompt: promptInputs.systemMessage,
       inputFiles: evalCase.file_paths,
-      evalCaseId: evalCase.id,
-      metadata: {
-        systemPrompt: promptInputs.systemMessage ?? ""
-      }
+      evalCaseId: evalCase.id
     };
   });
   const batchResponse = await provider.invokeBatch?.(batchRequests);
@@ -31046,7 +31448,7 @@ async function runEvalCase(options) {
         );
       }
       if (caseWorkspaceFile && workspacePath) {
-        const copiedFile = path44.join(workspacePath, path44.basename(caseWorkspaceFile));
+        const copiedFile = path45.join(workspacePath, path45.basename(caseWorkspaceFile));
         try {
           await stat8(copiedFile);
           caseWorkspaceFile = copiedFile;
@@ -31108,10 +31510,10 @@ async function runEvalCase(options) {
       const files = evalCase.metadata.agent_skills_files;
       if (baseDir && files.length > 0) {
         for (const relPath of files) {
-          const srcPath = path44.resolve(baseDir, relPath);
-          const destPath = path44.resolve(workspacePath, relPath);
+          const srcPath = path45.resolve(baseDir, relPath);
+          const destPath = path45.resolve(workspacePath, relPath);
           try {
-            await mkdir14(path44.dirname(destPath), { recursive: true });
+            await mkdir14(path45.dirname(destPath), { recursive: true });
             await copyFile2(srcPath, destPath);
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -31378,6 +31780,7 @@ async function runEvalCase(options) {
       availableTargets,
       fileChanges,
       workspacePath,
+      dockerConfig: evalCase.workspace?.docker,
       verbose,
       threshold: evalCase.threshold ?? caseThreshold
     });
@@ -31571,6 +31974,7 @@ async function evaluateCandidate(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     threshold: evalThreshold
   } = options;
   const gradeTimestamp = nowFn();
@@ -31597,6 +32001,7 @@ async function evaluateCandidate(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     threshold: evalThreshold
   });
   const completedAt = nowFn();
@@ -31672,6 +32077,7 @@ async function runEvaluatorsForCase(options) {
     availableTargets,
     fileChanges,
     workspacePath,
+    dockerConfig,
     threshold
   } = options;
   if (evalCase.assertions && evalCase.assertions.length > 0) {
@@ -31699,6 +32105,7 @@ async function runEvaluatorsForCase(options) {
       availableTargets,
       fileChanges,
       workspacePath,
+      dockerConfig,
       threshold
     });
   }
@@ -31707,6 +32114,7 @@ async function runEvaluatorsForCase(options) {
   if (!activeEvaluator) {
     throw new Error(`No evaluator registered for kind '${evaluatorKind}'`);
   }
+  const implicitEvaluator = evaluatorKind === "llm-grader" && !evalCase.assertions ? buildImplicitLlmGraderConfig(evalCase) : void 0;
   const score = await activeEvaluator.evaluate({
     evalCase,
     candidate,
@@ -31726,10 +32134,22 @@ async function runEvaluatorsForCase(options) {
     targetResolver,
     availableTargets,
     fileChanges,
-    workspacePath
+    workspacePath,
+    dockerConfig,
+    ...implicitEvaluator ? { evaluator: implicitEvaluator } : {}
   });
   return { score };
 }
+function buildImplicitLlmGraderConfig(evalCase) {
+  if (!evalCase.preprocessors || evalCase.preprocessors.length === 0) {
+    return void 0;
+  }
+  return {
+    name: "llm-grader",
+    type: "llm-grader",
+    preprocessors: evalCase.preprocessors
+  };
+}
 async function runEvaluatorList(options) {
   const {
     evalCase,
@@ -31754,7 +32174,8 @@ async function runEvaluatorList(options) {
     targetResolver,
     availableTargets,
     fileChanges,
-    workspacePath
+    workspacePath,
+    dockerConfig
   } = options;
   const scored = [];
   const scores = [];
@@ -31777,9 +32198,10 @@ async function runEvaluatorList(options) {
     targetResolver,
     availableTargets,
     fileChanges,
-    workspacePath
+    workspacePath,
+    dockerConfig
   };
-  const evalFileDir = evalCase.file_paths[0] ? path44.dirname(evalCase.file_paths[0]) : process.cwd();
+  const evalFileDir = evalCase.file_paths[0] ? path45.dirname(evalCase.file_paths[0]) : process.cwd();
   const dispatchContext = {
     graderProvider,
     targetResolver,
@@ -31939,13 +32361,11 @@ async function invokeProvider(provider, options) {
     const braintrustSpanIds = streamCallbacks?.getActiveSpanIds?.() ?? void 0;
     return await provider.invoke({
       question: promptInputs.question,
+      systemPrompt: promptInputs.systemMessage,
       chatPrompt: promptInputs.chatPrompt,
       inputFiles: evalCase.file_paths,
       evalCaseId: evalCase.id,
       attempt,
-      metadata: {
-        systemPrompt: promptInputs.systemMessage ?? ""
-      },
       signal: controller.signal,
       cwd,
       workspaceFile,
@@ -32176,7 +32596,7 @@ async function evaluate(config) {
   }
   const gitRoot = await findGitRoot(process.cwd());
   const repoRoot = gitRoot ?? process.cwd();
-  const testFilePath = config.specFile ? path45.resolve(config.specFile) : path45.join(process.cwd(), "__programmatic__.yaml");
+  const testFilePath = config.specFile ? path46.resolve(config.specFile) : path46.join(process.cwd(), "__programmatic__.yaml");
   await loadEnvHierarchy(repoRoot, testFilePath);
   let resolvedTarget;
   let taskProvider;
@@ -32291,10 +32711,10 @@ function computeSummary(results, durationMs, threshold = DEFAULT_THRESHOLD) {
 var TARGET_FILE_CANDIDATES = [".agentv/targets.yaml", ".agentv/targets.yml"];
 async function discoverDefaultTarget(repoRoot) {
   const cwd = process.cwd();
-  const chain = buildDirectoryChain(path45.join(cwd, "_placeholder"), repoRoot);
+  const chain = buildDirectoryChain(path46.join(cwd, "_placeholder"), repoRoot);
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const targetsPath = path45.join(dir, candidate);
+      const targetsPath = path46.join(dir, candidate);
       if (!existsSync6(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
@@ -32307,16 +32727,16 @@ async function discoverDefaultTarget(repoRoot) {
   return null;
 }
 async function loadEnvHierarchy(repoRoot, startPath) {
-  const { readFileSync: readFileSync4 } = await import("node:fs");
+  const { readFileSync: readFileSync5 } = await import("node:fs");
   const chain = buildDirectoryChain(startPath, repoRoot);
   const envFiles = [];
   for (const dir of chain) {
-    const envPath = path45.join(dir, ".env");
+    const envPath = path46.join(dir, ".env");
     if (existsSync6(envPath)) envFiles.push(envPath);
   }
   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;
@@ -32385,12 +32805,12 @@ var CONFIG_FILE_NAMES = [
   ".agentv/config.js"
 ];
 async function loadTsConfig(projectRoot) {
-  const { existsSync: existsSync8 } = await import("node:fs");
+  const { existsSync: existsSync9 } = await import("node:fs");
   const { pathToFileURL: pathToFileURL2 } = await import("node:url");
   const { join: join2 } = await import("node:path");
   for (const fileName of CONFIG_FILE_NAMES) {
     const filePath = join2(projectRoot, fileName);
-    if (!existsSync8(filePath)) {
+    if (!existsSync9(filePath)) {
       continue;
     }
     try {
@@ -32498,7 +32918,7 @@ async function scanRepoDeps(evalFilePaths) {
     try {
       const repos = await extractReposFromEvalFile(filePath);
       for (const repo of repos) {
-        if (repo.source.type !== "git") continue;
+        if (!repo.source || repo.source.type !== "git") continue;
         const ref = repo.checkout?.ref;
         const key = `${normalizeGitUrl(repo.source.url)}\0${ref ?? ""}`;
         const existing = seen.get(key);
@@ -32526,11 +32946,11 @@ async function scanRepoDeps(evalFilePaths) {
   return { repos: [...seen.values()], errors };
 }
 async function extractReposFromEvalFile(filePath) {
-  const content = await readFile13(filePath, "utf8");
-  const parsed = interpolateEnv(parse5(content), process.env);
+  const content = await readFile15(filePath, "utf8");
+  const parsed = interpolateEnv(parse6(content), process.env);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
   const obj = parsed;
-  const evalFileDir = path46.dirname(path46.resolve(filePath));
+  const evalFileDir = path47.dirname(path47.resolve(filePath));
   const repos = [];
   const suiteRepos = await extractReposFromWorkspaceRaw(obj.workspace, evalFileDir);
   repos.push(...suiteRepos);
@@ -32546,9 +32966,9 @@ async function extractReposFromEvalFile(filePath) {
 }
 async function extractReposFromWorkspaceRaw(raw, evalFileDir) {
   if (typeof raw === "string") {
-    const workspaceFilePath = path46.resolve(evalFileDir, raw);
-    const content = await readFile13(workspaceFilePath, "utf8");
-    const parsed = interpolateEnv(parse5(content), process.env);
+    const workspaceFilePath = path47.resolve(evalFileDir, raw);
+    const content = await readFile15(workspaceFilePath, "utf8");
+    const parsed = interpolateEnv(parse6(content), process.env);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
     return extractReposFromObject(parsed);
   }
@@ -32582,7 +33002,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await readFile14(filePath, "utf8");
+      const data = await readFile16(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -32590,13 +33010,13 @@ var ResponseCache = class {
   }
   async set(key, value) {
     const filePath = this.keyToPath(key);
-    const dir = path47.dirname(filePath);
+    const dir = path48.dirname(filePath);
     await mkdir15(dir, { recursive: true });
     await writeFile8(filePath, JSON.stringify(value, null, 2), "utf8");
   }
   keyToPath(key) {
     const prefix = key.slice(0, 2);
-    return path47.join(this.cachePath, prefix, `${key}.json`);
+    return path48.join(this.cachePath, prefix, `${key}.json`);
   }
 };
 function shouldEnableCache(params) {
@@ -32610,16 +33030,289 @@ function shouldSkipCacheForTemperature(targetConfig) {
   }
   return false;
 }
+var execFileAsync3 = promisify7(execFile3);
+function sanitizeRepoSlug(repo) {
+  return repo.trim().replace(/[^A-Za-z0-9._-]+/g, "-");
+}
+function withFriendlyGitHubAuthError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const lower = message.toLowerCase();
+  if (lower.includes("authentication failed") || lower.includes("could not read username") || lower.includes("permission denied") || lower.includes("not logged into any github hosts")) {
+    return new Error(`${message}. Run 'gh auth login' to authenticate.`);
+  }
+  return new Error(message);
+}
+function normalizeResultsExportConfig(config) {
+  return {
+    repo: config.repo.trim(),
+    path: config.path.trim().replace(/^\/+|\/+$/g, ""),
+    auto_push: config.auto_push === true,
+    branch_prefix: config.branch_prefix?.trim() || "eval-results"
+  };
+}
+function resolveResultsRepoUrl(repo) {
+  if (repo.includes("://") || repo.startsWith("git@")) {
+    return repo;
+  }
+  return `https://github.com/${repo}.git`;
+}
+function getResultsRepoCachePaths(repo) {
+  const rootDir = path49.join(getAgentvHome(), "cache", "results-repo", sanitizeRepoSlug(repo));
+  return {
+    rootDir,
+    repoDir: path49.join(rootDir, "repo"),
+    statusFile: path49.join(rootDir, "status.json")
+  };
+}
+function readPersistedStatus(statusFile) {
+  if (!existsSync7(statusFile)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync3(statusFile, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writePersistedStatus(statusFile, status) {
+  mkdirSync2(path49.dirname(statusFile), { recursive: true });
+  writeFileSync(statusFile, `${JSON.stringify(status, null, 2)}
+`, "utf8");
+}
+async function runCommand(executable, args, options) {
+  try {
+    const { stdout, stderr } = await execFileAsync3(executable, [...args], {
+      cwd: options?.cwd,
+      env: process.env
+    });
+    return { stdout, stderr };
+  } catch (error) {
+    if (options?.check === false && error && typeof error === "object") {
+      const execError = error;
+      return {
+        stdout: execError.stdout ?? "",
+        stderr: execError.stderr ?? ""
+      };
+    }
+    throw withFriendlyGitHubAuthError(error);
+  }
+}
+async function runGit(args, options) {
+  return runCommand("git", args, options);
+}
+async function runGh(args, options) {
+  return runCommand("gh", args, options);
+}
+async function resolveDefaultBranch(repoDir) {
+  try {
+    const { stdout } = await runGit(["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd: repoDir });
+    const ref = stdout.trim();
+    const prefix = "refs/remotes/origin/";
+    if (ref.startsWith(prefix)) {
+      return ref.slice(prefix.length);
+    }
+  } catch {
+  }
+  for (const candidate of ["main", "master"]) {
+    try {
+      await runGit(["rev-parse", "--verify", `origin/${candidate}`], { cwd: repoDir });
+      return candidate;
+    } catch {
+    }
+  }
+  return "main";
+}
+async function updateCacheRepo(repoDir, baseBranch) {
+  await runGit(["fetch", "origin", "--prune"], { cwd: repoDir });
+  await runGit(["checkout", baseBranch], { cwd: repoDir });
+  await runGit(["pull", "--ff-only", "origin", baseBranch], { cwd: repoDir });
+}
+function updateStatusFile(config, patch) {
+  const cachePaths = getResultsRepoCachePaths(config.repo);
+  const current = readPersistedStatus(cachePaths.statusFile);
+  writePersistedStatus(cachePaths.statusFile, {
+    ...current,
+    ...patch
+  });
+}
+async function ensureResultsRepoClone(config) {
+  const normalized = normalizeResultsExportConfig(config);
+  const cachePaths = getResultsRepoCachePaths(normalized.repo);
+  mkdirSync2(cachePaths.rootDir, { recursive: true });
+  if (!existsSync7(cachePaths.repoDir)) {
+    try {
+      await runGit([
+        "clone",
+        "--filter=blob:none",
+        resolveResultsRepoUrl(normalized.repo),
+        cachePaths.repoDir
+      ]);
+      return cachePaths.repoDir;
+    } catch (error) {
+      updateStatusFile(normalized, { last_error: withFriendlyGitHubAuthError(error).message });
+      throw withFriendlyGitHubAuthError(error);
+    }
+  }
+  if (!existsSync7(path49.join(cachePaths.repoDir, ".git"))) {
+    throw new Error(`Results repo cache is not a git repository: ${cachePaths.repoDir}`);
+  }
+  return cachePaths.repoDir;
+}
+function getResultsRepoStatus(config) {
+  if (!config) {
+    return {
+      configured: false,
+      available: false,
+      repo: "",
+      cache_dir: ""
+    };
+  }
+  const normalized = normalizeResultsExportConfig(config);
+  const cachePaths = getResultsRepoCachePaths(normalized.repo);
+  const persisted = readPersistedStatus(cachePaths.statusFile);
+  return {
+    configured: true,
+    available: existsSync7(cachePaths.repoDir),
+    repo: normalized.repo,
+    path: normalized.path,
+    auto_push: normalized.auto_push,
+    branch_prefix: normalized.branch_prefix,
+    cache_dir: cachePaths.repoDir,
+    last_synced_at: persisted.last_synced_at,
+    last_error: persisted.last_error
+  };
+}
+async function syncResultsRepo(config) {
+  const normalized = normalizeResultsExportConfig(config);
+  try {
+    const repoDir = await ensureResultsRepoClone(normalized);
+    const baseBranch = await resolveDefaultBranch(repoDir);
+    await updateCacheRepo(repoDir, baseBranch);
+    updateStatusFile(normalized, {
+      last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+      last_error: void 0
+    });
+  } catch (error) {
+    updateStatusFile(normalized, {
+      last_error: withFriendlyGitHubAuthError(error).message
+    });
+    throw withFriendlyGitHubAuthError(error);
+  }
+  return getResultsRepoStatus(normalized);
+}
+async function checkoutResultsRepoBranch(config, branchName) {
+  const normalized = normalizeResultsExportConfig(config);
+  const repoDir = await ensureResultsRepoClone(normalized);
+  const baseBranch = await resolveDefaultBranch(repoDir);
+  await updateCacheRepo(repoDir, baseBranch);
+  await runGit(["checkout", "-B", branchName, `origin/${baseBranch}`], { cwd: repoDir });
+  updateStatusFile(normalized, { last_error: void 0 });
+  return {
+    branchName,
+    baseBranch,
+    repoDir
+  };
+}
+async function prepareResultsRepoBranch(config, branchName) {
+  const normalized = normalizeResultsExportConfig(config);
+  const cloneDir = await ensureResultsRepoClone(normalized);
+  const baseBranch = await resolveDefaultBranch(cloneDir);
+  await updateCacheRepo(cloneDir, baseBranch);
+  const worktreeRoot = await mkdtemp3(path49.join(os3.tmpdir(), "agentv-results-repo-"));
+  const worktreeDir = path49.join(worktreeRoot, "repo");
+  await runGit(["worktree", "add", "-B", branchName, worktreeDir, `origin/${baseBranch}`], {
+    cwd: cloneDir
+  });
+  return {
+    branchName,
+    baseBranch,
+    repoDir: worktreeDir,
+    cleanup: async () => {
+      try {
+        await runGit(["worktree", "remove", "--force", worktreeDir], { cwd: cloneDir });
+      } finally {
+        await rm6(worktreeRoot, { recursive: true, force: true }).catch(() => void 0);
+      }
+    }
+  };
+}
+async function stageResultsArtifacts(params) {
+  rmSync(params.destinationDir, { recursive: true, force: true });
+  mkdirSync2(path49.dirname(params.destinationDir), { recursive: true });
+  await cp3(params.sourceDir, params.destinationDir, { recursive: true });
+}
+function resolveResultsRepoRunsDir(config) {
+  const normalized = normalizeResultsExportConfig(config);
+  return path49.join(
+    getResultsRepoCachePaths(normalized.repo).repoDir,
+    ...normalized.path.split("/")
+  );
+}
+async function directorySizeBytes(targetPath) {
+  const entry = await stat9(targetPath);
+  if (entry.isFile()) {
+    return entry.size;
+  }
+  let total = 0;
+  for (const child of await readdir8(targetPath, { withFileTypes: true })) {
+    total += await directorySizeBytes(path49.join(targetPath, child.name));
+  }
+  return total;
+}
+async function commitAndPushResultsBranch(params) {
+  await runGit(["add", "--all"], { cwd: params.repoDir });
+  const { stdout: diffStdout } = await runGit(["status", "--porcelain"], {
+    cwd: params.repoDir,
+    check: false
+  });
+  if (diffStdout.trim().length === 0) {
+    return false;
+  }
+  await runGit(["commit", "-m", params.commitMessage], { cwd: params.repoDir });
+  await runGit(["push", "-u", "origin", params.branchName], { cwd: params.repoDir });
+  return true;
+}
+async function pushResultsRepoBranch(config, branchName, cwd) {
+  const normalized = normalizeResultsExportConfig(config);
+  await runGit(["push", "-u", "origin", branchName], {
+    cwd: cwd ?? getResultsRepoCachePaths(normalized.repo).repoDir
+  });
+  updateStatusFile(normalized, {
+    last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+    last_error: void 0
+  });
+}
+async function createDraftResultsPr(params) {
+  const { stdout } = await runGh(
+    [
+      "pr",
+      "create",
+      "--draft",
+      "--repo",
+      params.repo,
+      "--base",
+      params.baseBranch,
+      "--head",
+      params.branchName,
+      "--title",
+      params.title,
+      "--body",
+      params.body
+    ],
+    { cwd: params.repoDir }
+  );
+  return stdout.trim();
+}
 function getProjectsRegistryPath() {
-  return path48.join(getAgentvHome(), "projects.yaml");
+  return path50.join(getAgentvHome(), "projects.yaml");
 }
 function loadProjectRegistry() {
   const registryPath = getProjectsRegistryPath();
-  if (!existsSync7(registryPath)) {
+  if (!existsSync8(registryPath)) {
     return { projects: [] };
   }
   try {
-    const raw = readFileSync3(registryPath, "utf-8");
+    const raw = readFileSync4(registryPath, "utf-8");
     const parsed = parseYaml3(raw);
     if (!parsed || !Array.isArray(parsed.projects)) {
       return { projects: [] };
@@ -32631,14 +33324,14 @@ function loadProjectRegistry() {
 }
 function saveProjectRegistry(registry) {
   const registryPath = getProjectsRegistryPath();
-  const dir = path48.dirname(registryPath);
-  if (!existsSync7(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  const dir = path50.dirname(registryPath);
+  if (!existsSync8(dir)) {
+    mkdirSync3(dir, { recursive: true });
   }
-  writeFileSync(registryPath, stringifyYaml(registry), "utf-8");
+  writeFileSync2(registryPath, stringifyYaml(registry), "utf-8");
 }
 function deriveProjectId(dirPath, existingIds) {
-  const base = path48.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const base = path50.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   let candidate = base || "project";
   let suffix = 2;
   while (existingIds.includes(candidate)) {
@@ -32648,11 +33341,11 @@ function deriveProjectId(dirPath, existingIds) {
   return candidate;
 }
 function addProject(projectPath) {
-  const absPath = path48.resolve(projectPath);
-  if (!existsSync7(absPath)) {
+  const absPath = path50.resolve(projectPath);
+  if (!existsSync8(absPath)) {
     throw new Error(`Directory not found: ${absPath}`);
   }
-  if (!existsSync7(path48.join(absPath, ".agentv"))) {
+  if (!existsSync8(path50.join(absPath, ".agentv"))) {
     throw new Error(`No .agentv/ directory found in ${absPath}. Run an evaluation first.`);
   }
   const registry = loadProjectRegistry();
@@ -32666,7 +33359,7 @@ function addProject(projectPath) {
       absPath,
       registry.projects.map((p) => p.id)
     ),
-    name: path48.basename(absPath),
+    name: path50.basename(absPath),
     path: absPath,
     addedAt: now2,
     lastOpenedAt: now2
@@ -32695,14 +33388,14 @@ function touchProject(projectId) {
   }
 }
 function discoverProjects(rootDir, maxDepth = 2) {
-  const absRoot = path48.resolve(rootDir);
-  if (!existsSync7(absRoot) || !statSync2(absRoot).isDirectory()) {
+  const absRoot = path50.resolve(rootDir);
+  if (!existsSync8(absRoot) || !statSync2(absRoot).isDirectory()) {
     return [];
   }
   const results = [];
   function scan(dir, depth) {
     if (depth > maxDepth) return;
-    if (existsSync7(path48.join(dir, ".agentv"))) {
+    if (existsSync8(path50.join(dir, ".agentv"))) {
       results.push(dir);
       return;
     }
@@ -32712,7 +33405,7 @@ function discoverProjects(rootDir, maxDepth = 2) {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-        scan(path48.join(dir, entry.name), depth + 1);
+        scan(path50.join(dir, entry.name), depth + 1);
       }
     } catch {
     }
@@ -32816,8 +33509,8 @@ var OtelTraceExporter = class {
   async init() {
     try {
       const [sdkTraceNode, resourcesMod, semconvMod, api, coreMod] = await Promise.all([
-        import("./src-ML4D2MC2.js"),
-        import("./esm-CZAWIY6F.js"),
+        import("./src-PXDA7QIS.js"),
+        import("./esm-UYZ3HJBU.js"),
         import("./esm-RVQPUGWH.js"),
         import("./esm-R77SNOF5.js"),
         import("./esm-ZADQ4XQH-5LX2IKZV.js").catch(() => null)
@@ -33611,30 +34304,30 @@ function extractResponseItemContent(content) {
   }
   return parts.length > 0 ? parts.join("") : void 0;
 }
-var DEFAULT_SESSIONS_DIR = () => path49.join(homedir3(), ".codex", "sessions");
+var DEFAULT_SESSIONS_DIR = () => path51.join(homedir3(), ".codex", "sessions");
 async function discoverCodexSessions(opts) {
   const sessionsDir = opts?.sessionsDir ?? DEFAULT_SESSIONS_DIR();
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
   const sessions = [];
   let yearDirs;
   try {
-    yearDirs = await readdir8(sessionsDir);
+    yearDirs = await readdir9(sessionsDir);
   } catch {
     return [];
   }
   for (const year of yearDirs) {
-    const yearPath = path49.join(sessionsDir, year);
+    const yearPath = path51.join(sessionsDir, year);
     let monthDirs;
     try {
-      monthDirs = await readdir8(yearPath);
+      monthDirs = await readdir9(yearPath);
     } catch {
       continue;
     }
     for (const month of monthDirs) {
-      const monthPath = path49.join(yearPath, month);
+      const monthPath = path51.join(yearPath, month);
       let dayDirs;
       try {
-        dayDirs = await readdir8(monthPath);
+        dayDirs = await readdir9(monthPath);
       } catch {
         continue;
       }
@@ -33643,22 +34336,22 @@ async function discoverCodexSessions(opts) {
           const dirDate = `${year}-${month}-${day}`;
           if (dirDate !== opts.date) continue;
         }
-        const dayPath = path49.join(monthPath, day);
+        const dayPath = path51.join(monthPath, day);
         let files;
         try {
-          files = await readdir8(dayPath);
+          files = await readdir9(dayPath);
         } catch {
           continue;
         }
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = path49.join(dayPath, file);
+          const filePath = path51.join(dayPath, file);
           const nameWithoutExt = file.replace(/\.jsonl$/, "");
           const parts = nameWithoutExt.split("-");
           const sessionId = parts.length >= 6 ? parts.slice(-5).join("-") : nameWithoutExt;
           let updatedAt;
           try {
-            const fileStat = await stat9(filePath);
+            const fileStat = await stat10(filePath);
             updatedAt = fileStat.mtime;
           } catch {
             updatedAt = /* @__PURE__ */ new Date(0);
@@ -33671,7 +34364,7 @@ async function discoverCodexSessions(opts) {
   sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
   return sessions.slice(0, limit);
 }
-var DEFAULT_PROJECTS_DIR = () => path50.join(homedir4(), ".claude", "projects");
+var DEFAULT_PROJECTS_DIR = () => path52.join(homedir4(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -33680,7 +34373,7 @@ async function discoverClaudeSessions(opts) {
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
   let projectDirs;
   try {
-    projectDirs = await readdir9(projectsDir);
+    projectDirs = await readdir10(projectsDir);
   } catch {
     return [];
   }
@@ -33690,10 +34383,10 @@ async function discoverClaudeSessions(opts) {
   }
   const sessions = [];
   for (const projectDir of projectDirs) {
-    const dirPath = path50.join(projectsDir, projectDir);
+    const dirPath = path52.join(projectsDir, projectDir);
     let entries;
     try {
-      entries = await readdir9(dirPath);
+      entries = await readdir10(dirPath);
     } catch {
       continue;
     }
@@ -33701,10 +34394,10 @@ async function discoverClaudeSessions(opts) {
       if (!entry.endsWith(".jsonl")) continue;
       const sessionId = entry.replace(/\.jsonl$/, "");
       if (opts?.sessionId && sessionId !== opts.sessionId) continue;
-      const filePath = path50.join(dirPath, entry);
+      const filePath = path52.join(dirPath, entry);
       let updatedAt;
       try {
-        const fileStat = await stat10(filePath);
+        const fileStat = await stat11(filePath);
         updatedAt = fileStat.mtime;
       } catch {
         updatedAt = /* @__PURE__ */ new Date(0);
@@ -33745,11 +34438,11 @@ function toTranscriptJsonLine(entry) {
   };
 }
 async function readTranscriptJsonl(filePath) {
-  const text2 = await readFile15(filePath, "utf8");
+  const text2 = await readFile17(filePath, "utf8");
   return text2.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
 }
 async function readTranscriptFile(filePath) {
-  return readFile15(filePath, "utf8");
+  return readFile17(filePath, "utf8");
 }
 var TranscriptProvider = class _TranscriptProvider {
   id;
@@ -33956,6 +34649,20 @@ export {
   ResponseCache,
   shouldEnableCache,
   shouldSkipCacheForTemperature,
+  normalizeResultsExportConfig,
+  resolveResultsRepoUrl,
+  getResultsRepoCachePaths,
+  ensureResultsRepoClone,
+  getResultsRepoStatus,
+  syncResultsRepo,
+  checkoutResultsRepoBranch,
+  prepareResultsRepoBranch,
+  stageResultsArtifacts,
+  resolveResultsRepoRunsDir,
+  directorySizeBytes,
+  commitAndPushResultsBranch,
+  pushResultsRepoBranch,
+  createDraftResultsPr,
   getProjectsRegistryPath,
   loadProjectRegistry,
   saveProjectRegistry,
@@ -33981,4 +34688,4 @@ export {
   TranscriptProvider,
   createAgentKernel
 };
-//# sourceMappingURL=chunk-RHAXSXIY.js.map
+//# sourceMappingURL=chunk-FQGY6QXQ.js.map