@agentv/core 4.9.0 → 4.10.0

package/dist/index.js

@@ -25,7 +25,7 @@ import {
   resolveDelegatedTargetDefinition,
   resolveFileReference,
   resolveTargetDefinition
-} from "./chunk-VCVVKCC4.js";
+} from "./chunk-BWHUWLGW.js";
 import {
   AgentvProvider
 } from "./chunk-PRNXHNLF.js";
@@ -152,8 +152,8 @@ function mergeExecutionMetrics(computed, metrics) {
 }
 
 // src/evaluation/yaml-parser.ts
-import { readFile as readFile6 } from "node:fs/promises";
-import path7 from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import path8 from "node:path";
 import micromatch2 from "micromatch";
 import { parse as parse2 } from "yaml";
 
@@ -684,10 +684,318 @@ function logWarning(message) {
 }
 
 // src/evaluation/loaders/evaluator-parser.ts
+import path5 from "node:path";
+
+// src/evaluation/content-preprocessor.ts
+import { readFile as readFile3 } from "node:fs/promises";
 import path4 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/runtime/exec.ts
+function shellEscapePath(value) {
+  if (process.platform === "win32") {
+    return `"${value.replaceAll('"', '""')}"`;
+  }
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+async function execFileWithStdin(argv, stdinPayload, options = {}) {
+  if (argv.length === 0) {
+    throw new Error("Executable argv must include at least one entry");
+  }
+  if (typeof Bun !== "undefined") {
+    return execFileWithStdinBun(argv, stdinPayload, options);
+  }
+  return execFileWithStdinNode(argv, stdinPayload, options);
+}
+async function execFileWithStdinBun(argv, stdinPayload, options) {
+  const command = [...argv];
+  const encoder = new TextEncoder();
+  const proc = Bun.spawn(command, {
+    cwd: options.cwd,
+    stdin: encoder.encode(stdinPayload),
+    stdout: "pipe",
+    stderr: "pipe",
+    // Merge additional env vars with process.env
+    env: options.env ? { ...process.env, ...options.env } : process.env
+  });
+  let timedOut = false;
+  const timeout = options.timeoutMs !== void 0 ? setTimeout(() => {
+    timedOut = true;
+    proc.kill("SIGKILL");
+  }, options.timeoutMs) : void 0;
+  try {
+    const stdoutPromise = proc.stdout ? new Response(proc.stdout).text() : Promise.resolve("");
+    const stderrPromise = proc.stderr ? new Response(proc.stderr).text() : Promise.resolve("");
+    const [stdout, stderr, exitCode] = await Promise.all([
+      stdoutPromise,
+      stderrPromise,
+      proc.exited
+    ]);
+    if (timedOut) {
+      throw new Error(`Process timed out after ${options.timeoutMs}ms`);
+    }
+    return {
+      stdout: stdout.replace(/\r\n/g, "\n"),
+      stderr: stderr.replace(/\r\n/g, "\n"),
+      exitCode
+    };
+  } finally {
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
+    }
+  }
+}
+async function execFileWithStdinNode(argv, stdinPayload, options) {
+  const { spawn: spawn5 } = await import("node:child_process");
+  return new Promise((resolve, reject) => {
+    const [cmd, ...args] = argv;
+    const child = spawn5(cmd, args, {
+      cwd: options.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      // Merge additional env vars with process.env
+      env: options.env ? { ...process.env, ...options.env } : process.env
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
+    child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+    let timedOut = false;
+    const timeout = options.timeoutMs !== void 0 ? setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, options.timeoutMs) : void 0;
+    child.on("error", (error) => {
+      if (timeout !== void 0) clearTimeout(timeout);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (timeout !== void 0) clearTimeout(timeout);
+      if (timedOut) {
+        reject(new Error(`Process timed out after ${options.timeoutMs}ms`));
+        return;
+      }
+      const stdout = Buffer.concat(stdoutChunks).toString("utf8").replace(/\r\n/g, "\n");
+      const stderr = Buffer.concat(stderrChunks).toString("utf8").replace(/\r\n/g, "\n");
+      resolve({
+        stdout,
+        stderr,
+        exitCode: code ?? 0
+      });
+    });
+    if (child.stdin) {
+      child.stdin.write(stdinPayload);
+      child.stdin.end();
+    }
+  });
+}
+async function execShellWithStdin(command, stdinPayload, options = {}) {
+  const { mkdir: mkdir16, readFile: readFile17, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
+  const { tmpdir: tmpdir3 } = await import("node:os");
+  const path52 = await import("node:path");
+  const { randomUUID: randomUUID10 } = await import("node:crypto");
+  const dir = path52.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
+  await mkdir16(dir, { recursive: true });
+  const stdinPath = path52.join(dir, "stdin.txt");
+  const stdoutPath = path52.join(dir, "stdout.txt");
+  const stderrPath = path52.join(dir, "stderr.txt");
+  await writeFile9(stdinPath, stdinPayload, "utf8");
+  const wrappedCommand = process.platform === "win32" ? `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
+  const { spawn: spawn5 } = await import("node:child_process");
+  try {
+    const exitCode = await new Promise((resolve, reject) => {
+      const child = spawn5(wrappedCommand, {
+        shell: true,
+        cwd: options.cwd,
+        stdio: ["ignore", "ignore", "ignore"],
+        // Merge additional env vars with process.env
+        env: options.env ? { ...process.env, ...options.env } : process.env
+      });
+      const timeout = options.timeoutMs ? setTimeout(() => {
+        child.kill();
+        reject(new Error(`Process timed out after ${options.timeoutMs}ms`));
+      }, options.timeoutMs) : void 0;
+      child.on("error", (error) => {
+        if (timeout !== void 0) {
+          clearTimeout(timeout);
+        }
+        reject(error);
+      });
+      child.on("exit", (code) => {
+        if (timeout !== void 0) {
+          clearTimeout(timeout);
+        }
+        resolve(code ?? 0);
+      });
+    });
+    const stdout = (await readFile17(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
+    const stderr = (await readFile17(stderrPath, "utf8")).replace(/\r\n/g, "\n");
+    return { stdout, stderr, exitCode };
+  } finally {
+    await rm6(dir, { recursive: true, force: true });
+  }
+}
+
+// src/evaluation/content-preprocessor.ts
+var MIME_TYPE_ALIASES = {
+  csv: "text/csv",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  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 readFile3(resolvedPath);
+    const text = buffer.toString("utf8").replace(/\r\n/g, "\n");
+    if (buffer.includes(0) || text.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, text), 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(text, warnings) {
+  if (warnings.length === 0) {
+    return text;
+  }
+  const notes = warnings.map(
+    (warning) => `[file preprocessing warning] ${warning.file} (${warning.mediaType}): ${warning.reason}`
+  );
+  return [text, ...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 ? path4.resolve(basePath, value) : path4.resolve(value);
+}
+function formatFileText(filePath, text) {
+  return `[[ file: ${filePath} ]]
+${text}`;
+}
 
 // src/evaluation/validation/prompt-validator.ts
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile4 } from "node:fs/promises";
 
 // src/evaluation/template-variables.ts
 var TEMPLATE_VARIABLES = {
@@ -718,7 +1026,7 @@ var DEPRECATED_TEMPLATE_VARIABLES = /* @__PURE__ */ new Map([
 var ANSI_YELLOW2 = "\x1B[33m";
 var ANSI_RESET3 = "\x1B[0m";
 async function validateCustomPromptContent(promptPath) {
-  const content = await readFile3(promptPath, "utf8");
+  const content = await readFile4(promptPath, "utf8");
   validateTemplateVariables(content, promptPath);
 }
 function validateTemplateVariables(content, source) {
@@ -775,22 +1083,32 @@ 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) {
+async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId, defaultPreprocessors) {
   if (candidateEvaluators === void 0) {
     return void 0;
   }
@@ -855,6 +1173,13 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       continue;
     }
     const negate = rawEvaluator.negate === true ? true : void 0;
+    const mergedPreprocessors = await parseMergedPreprocessors(
+      rawEvaluator.preprocessors,
+      defaultPreprocessors,
+      searchRoots,
+      name,
+      evalId
+    );
     if (isCustomType) {
       const weight2 = validateWeight(rawEvaluator.weight, name, evalId);
       const { required: required2, min_score: min_score2 } = parseRequiredAndMinScore(
@@ -913,7 +1238,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       if (cwd) {
         const resolved = await resolveFileReference2(cwd, searchRoots);
         if (resolved.resolvedPath) {
-          resolvedCwd = path4.resolve(resolved.resolvedPath);
+          resolvedCwd = path5.resolve(resolved.resolvedPath);
         } else {
           logWarning2(
             `Code-grader evaluator '${name}' in '${evalId}': cwd not found (${resolved.displayPath})`,
@@ -959,6 +1284,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
         "cwd",
         "weight",
         "target",
+        "preprocessors",
         "required",
         "negate"
       ]);
@@ -979,6 +1305,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;
@@ -1088,7 +1415,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
             aggregatorPrompt = fileRef;
             const resolved = await resolveFileReference2(fileRef, searchRoots);
             if (resolved.resolvedPath) {
-              promptPath2 = path4.resolve(resolved.resolvedPath);
+              promptPath2 = path5.resolve(resolved.resolvedPath);
             } else {
               throw new Error(
                 `Composite aggregator in '${evalId}': prompt file not found: ${resolved.displayPath}`
@@ -1742,7 +2069,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;
     }
@@ -1767,7 +2095,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       const commandPath = commandArray[commandArray.length - 1];
       const resolved = await resolveFileReference2(commandPath, searchRoots);
       if (resolved.resolvedPath) {
-        resolvedPromptScript = [...commandArray.slice(0, -1), path4.resolve(resolved.resolvedPath)];
+        resolvedPromptScript = [...commandArray.slice(0, -1), path5.resolve(resolved.resolvedPath)];
       } else {
         throw new Error(
           `Evaluator '${name}' in '${evalId}': prompt command file not found: ${resolved.displayPath}`
@@ -1782,7 +2110,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
         prompt = fileRef;
         const resolved = await resolveFileReference2(fileRef, searchRoots);
         if (resolved.resolvedPath) {
-          promptPath = path4.resolve(resolved.resolvedPath);
+          promptPath = path5.resolve(resolved.resolvedPath);
           try {
             await validateCustomPromptContent(promptPath);
           } catch (error) {
@@ -1825,7 +2153,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;
     }
@@ -1850,7 +2179,8 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       "negate",
       "max_steps",
       "maxSteps",
-      "temperature"
+      "temperature",
+      "preprocessors"
     ]);
     const config = {};
     for (const [key, value] of Object.entries(rawEvaluator)) {
@@ -1880,30 +2210,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 resolveFileReference2(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) {
@@ -1936,7 +2306,7 @@ function generateAssertionName(typeValue, rawEvaluator) {
     case "rubrics":
       return "rubrics";
     default:
-      return void 0;
+      return typeValue;
   }
 }
 function coerceEvaluator(candidate, contextId) {
@@ -2294,14 +2664,14 @@ function parseInlineRubrics(rawRubrics) {
 }
 
 // src/evaluation/loaders/jsonl-parser.ts
-import { readFile as readFile5 } from "node:fs/promises";
-import path6 from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import path7 from "node:path";
 import micromatch from "micromatch";
 import { parse as parseYaml } from "yaml";
 
 // src/evaluation/loaders/message-processor.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import path5 from "node:path";
+import { readFile as readFile5 } from "node:fs/promises";
+import path6 from "node:path";
 
 // src/evaluation/formatting/segment-formatter.ts
 function formatFileContents(parts) {
@@ -2367,7 +2737,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";
@@ -2417,12 +2787,12 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const fileContent = (await readFile4(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+          const fileContent = (await readFile5(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]";
@@ -2458,7 +2828,7 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const imageBuffer = await readFile4(resolvedPath);
+          const imageBuffer = await readFile5(resolvedPath);
           const base64 = imageBuffer.toString("base64");
           processedContent.push({
             type: "image",
@@ -2535,12 +2905,12 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const fileContent = (await readFile4(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+            const fileContent = (await readFile5(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}`);
@@ -2575,7 +2945,7 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const imageBuffer = await readFile4(resolvedPath);
+            const imageBuffer = await readFile5(resolvedPath);
             const base64 = imageBuffer.toString("base64");
             processedContent.push({
               type: "image",
@@ -2684,7 +3054,7 @@ function matchesFilter(id, filter) {
   return typeof filter === "string" ? micromatch.isMatch(id, filter) : filter.some((pattern) => micromatch.isMatch(id, pattern));
 }
 function detectFormat(filePath) {
-  const ext = 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";
@@ -2693,9 +3063,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)`);
@@ -2703,7 +3073,7 @@ async function loadSidecarMetadata(jsonlPath, verbose) {
     return {};
   }
   try {
-    const content = await readFile5(sidecarPath, "utf8");
+    const content = await readFile6(sidecarPath, "utf8");
     const parsed = interpolateEnv(parseYaml(content), process.env);
     if (!isJsonObject(parsed)) {
       logWarning4(`Invalid sidecar metadata format in ${sidecarPath}`);
@@ -2744,13 +3114,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 readFile6(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;
@@ -3109,8 +3479,8 @@ function resolveTests(suite) {
 }
 async function readTestSuiteMetadata(testFilePath) {
   try {
-    const absolutePath = path7.resolve(testFilePath);
-    const content = await readFile6(absolutePath, "utf8");
+    const absolutePath = path8.resolve(testFilePath);
+    const content = await readFile7(absolutePath, "utf8");
     const parsed = interpolateEnv(parse2(content), process.env);
     if (!isJsonObject(parsed)) {
       return {};
@@ -3164,25 +3534,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 rawFile = await readFile7(absoluteTestPath, "utf8");
   const interpolated = interpolateEnv(parse2(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);
@@ -3280,7 +3656,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);
@@ -3313,6 +3690,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
       criteria: outcome ?? "",
       evaluator: testCaseEvaluatorKind,
       assertions: evaluators,
+      ...suitePreprocessors ? { preprocessors: suitePreprocessors } : {},
       workspace: mergedWorkspace,
       metadata,
       targets: caseTargets,
@@ -3353,8 +3731,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) {
@@ -3392,10 +3770,10 @@ 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 readFile7(workspaceFilePath, "utf8");
     } catch {
       throw new Error(`Workspace file not found: ${raw} (resolved to ${workspaceFilePath})`);
     }
@@ -3405,7 +3783,7 @@ async function resolveWorkspaceConfig(raw, evalFileDir) {
         `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);
@@ -3425,8 +3803,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;
@@ -3497,7 +3875,7 @@ ${detailBlock}${ANSI_RESET7}`);
 
 // src/evaluation/loaders/eval-yaml-transpiler.ts
 import { readFileSync } from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 import { parse as parse3 } from "yaml";
 function codeGraderInstruction(graderName, description) {
   const desc = description ? ` This grader: ${description}.` : "";
@@ -3738,7 +4116,7 @@ function transpileEvalYaml(suite, source = "EVAL.yaml") {
 function transpileEvalYamlFile(evalYamlPath) {
   const content = readFileSync(evalYamlPath, "utf8");
   const parsed = parse3(content);
-  return transpileEvalYaml(parsed, path8.basename(evalYamlPath));
+  return transpileEvalYaml(parsed, path9.basename(evalYamlPath));
 }
 function getOutputFilenames(result) {
   const names = /* @__PURE__ */ new Map();
@@ -4176,7 +4554,7 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { createWriteStream } from "node:fs";
 import { mkdir } from "node:fs/promises";
-import path10 from "node:path";
+import path11 from "node:path";
 
 // src/evaluation/providers/claude-content.ts
 function toContentArray(content) {
@@ -4275,7 +4653,7 @@ function subscribeToClaudeLogEntries(listener) {
 }
 
 // src/evaluation/providers/preread.ts
-import path9 from "node:path";
+import path10 from "node:path";
 function buildPromptDocument(request, inputFiles) {
   const parts = [];
   const inputFilesList = collectInputFiles(inputFiles);
@@ -4292,7 +4670,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);
     }
@@ -4305,7 +4683,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);
     }
@@ -4317,7 +4695,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})`;
   });
@@ -4333,7 +4711,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}`;
@@ -4481,10 +4859,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;
   }
@@ -4494,9 +4872,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();
@@ -4510,7 +4888,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,
@@ -4812,7 +5190,7 @@ function tryParseJson(line) {
 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";
 var claudeSdkModule = null;
 async function loadClaudeSdk() {
   if (!claudeSdkModule) {
@@ -4973,10 +5351,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;
   }
@@ -4986,9 +5364,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();
@@ -5002,7 +5380,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,
@@ -5190,7 +5568,7 @@ function formatElapsed2(startedAt) {
 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 { z as z2 } from "zod";
 var ToolCallSchema = z2.object({
@@ -5693,7 +6071,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);
     }
@@ -5707,7 +6085,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(" ");
 }
@@ -5731,7 +6109,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) {
@@ -5745,7 +6123,7 @@ function formatTimeoutSuffix2(timeoutMs) {
 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";
 
 // src/evaluation/providers/codex-log-tracker.ts
 var GLOBAL_LOGS_KEY2 = Symbol.for("agentv.codexLogs");
@@ -5980,10 +6358,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;
   }
@@ -5993,9 +6371,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();
@@ -6009,7 +6387,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,
@@ -6153,7 +6531,7 @@ function formatElapsed3(startedAt) {
 // src/evaluation/providers/copilot-cli.ts
 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";
 import * as acp from "@agentclientprotocol/sdk";
@@ -6215,8 +6593,8 @@ function subscribeToCopilotCliLogEntries(listener) {
 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 path15 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolvePlatformCliPath() {
   const os3 = platform();
   const cpu = arch();
@@ -6238,8 +6616,8 @@ function resolvePlatformCliPath() {
   const binaryName = os3 === "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;
     }
@@ -6247,7 +6625,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("/"),
@@ -6256,13 +6634,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",
@@ -6277,7 +6655,7 @@ function resolvePlatformCliPath() {
       }
     } catch {
     }
-    const parent = path14.dirname(searchDir);
+    const parent = path15.dirname(searchDir);
     if (parent === searchDir) break;
     searchDir = parent;
   }
@@ -6621,10 +6999,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;
   }
@@ -6643,9 +7021,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();
@@ -6659,7 +7037,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(
         {
@@ -6752,9 +7130,9 @@ function summarizeAcpEvent(eventType, data) {
 }
 
 // src/evaluation/providers/copilot-log.ts
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
 
 // src/evaluation/providers/copilot-log-parser.ts
 function parseCopilotEvents(eventsJsonl) {
@@ -6886,11 +7264,11 @@ function parseCopilotEvents(eventsJsonl) {
 }
 
 // src/evaluation/providers/copilot-session-discovery.ts
-import { readFile as readFile7, readdir, stat } from "node:fs/promises";
+import { readFile as readFile8, readdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
 import { parse as parseYaml2 } from "yaml";
-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;
@@ -6902,11 +7280,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 readFile8(workspacePath, "utf8");
       const workspace = parseYaml2(workspaceContent) ?? {};
       const cwd = String(workspace.cwd ?? "");
       let updatedAt;
@@ -6965,10 +7343,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 readFile9(eventsPath, "utf8");
     } catch (err) {
       throw new Error(
         `Failed to read Copilot session transcript at ${eventsPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -6987,8 +7365,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({
@@ -7013,7 +7391,7 @@ var CopilotLogProvider = class {
 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";
 
 // src/evaluation/providers/copilot-sdk-log-tracker.ts
 var GLOBAL_LOGS_KEY4 = Symbol.for("agentv.copilotSdkLogs");
@@ -7323,10 +7701,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;
   }
@@ -7335,9 +7713,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();
@@ -7351,7 +7729,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(
         {
@@ -7380,9 +7758,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));
 }
@@ -7466,7 +7844,7 @@ 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";
 
 // src/evaluation/providers/pi-log-tracker.ts
 var GLOBAL_LOGS_KEY5 = Symbol.for("agentv.piLogs");
@@ -7672,7 +8050,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);
@@ -7735,10 +8113,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;
@@ -7844,7 +8222,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 {
@@ -7854,9 +8232,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();
@@ -7870,7 +8248,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,
@@ -8341,8 +8719,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]];
@@ -8421,13 +8799,13 @@ 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 path22 from "node:path";
 import { createInterface } from "node:readline";
-import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
+import { fileURLToPath as fileURLToPath4, pathToFileURL } from "node:url";
 
 // src/paths.ts
 import os2 from "node:os";
-import path20 from "node:path";
+import path21 from "node:path";
 var logged = false;
 function getAgentvHome() {
   const envHome = process.env.AGENTV_HOME;
@@ -8438,19 +8816,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");
 }
 
 // src/evaluation/providers/pi-coding-agent.ts
@@ -8472,7 +8850,7 @@ async function promptInstall() {
   }
 }
 function findManagedSdkInstallRoot() {
-  return path21.join(getAgentvHome(), "deps", "pi-sdk");
+  return path22.join(getAgentvHome(), "deps", "pi-sdk");
 }
 function resolveGlobalNpmRoot() {
   try {
@@ -8486,7 +8864,7 @@ function resolveGlobalNpmRoot() {
   }
 }
 function buildGlobalModuleEntry(moduleName, globalNpmRoot) {
-  return path21.join(globalNpmRoot, ...moduleName.split("/"), "dist", "index.js");
+  return path22.join(globalNpmRoot, ...moduleName.split("/"), "dist", "index.js");
 }
 function findAccessiblePath(paths) {
   for (const candidate of paths) {
@@ -8512,11 +8890,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")
+    path22.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(
+    path22.join(managedRoot, "node_modules", "@mariozechner", "pi-ai", "dist", "index.js"),
+    path22.join(
       managedRoot,
       "node_modules",
       "@mariozechner",
@@ -8547,7 +8925,7 @@ async function tryImportGlobalSdkModules() {
   ]);
   const piAiEntry = findAccessiblePath([
     buildGlobalModuleEntry("@mariozechner/pi-ai", globalNpmRoot),
-    path21.join(
+    path22.join(
       globalNpmRoot,
       "@mariozechner",
       "pi-coding-agent",
@@ -8848,10 +9226,10 @@ ${fileList}`;
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path21.resolve(cwdOverride);
+      return path22.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path21.resolve(this.config.cwd);
+      return path22.resolve(this.config.cwd);
     }
     return process.cwd();
   }
@@ -8870,9 +9248,9 @@ ${fileList}`;
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return path21.resolve(this.config.logDir);
+      return path22.resolve(this.config.logDir);
     }
-    return path21.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
+    return path22.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -8886,7 +9264,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 = path22.join(logDir, buildLogFilename6(request, this.targetName));
     try {
       const logger = await PiStreamLogger2.create({
         filePath,
@@ -9101,17 +9479,17 @@ var ProviderRegistry = class {
 // src/evaluation/providers/vscode-provider.ts
 import { exec as exec2 } from "node:child_process";
 import { constants as constants3, access as access3, stat as stat5 } from "node:fs/promises";
-import path32 from "node:path";
+import path33 from "node:path";
 import { promisify as promisify3 } from "node:util";
 
 // src/evaluation/providers/vscode/dispatch/agentDispatch.ts
 import { stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
-import path30 from "node:path";
+import path31 from "node:path";
 
 // src/evaluation/providers/vscode/utils/fs.ts
 import { constants as constants2 } from "node:fs";
 import { access as access2, mkdir as mkdir8, readdir as readdir2, rm as rm2, stat as stat2 } from "node:fs/promises";
-import path22 from "node:path";
+import path23 from "node:path";
 async function pathExists(target) {
   try {
     await access2(target, constants2.F_OK);
@@ -9127,7 +9505,7 @@ async function readDirEntries(target) {
   const entries = await readdir2(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    absolutePath: path22.join(target, entry.name),
+    absolutePath: path23.join(target, entry.name),
     isDirectory: entry.isDirectory()
   }));
 }
@@ -9142,9 +9520,9 @@ async function removeIfExists(target) {
 }
 
 // src/evaluation/providers/vscode/utils/path.ts
-import path23 from "node:path";
+import path24 from "node:path";
 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}`;
@@ -9153,7 +9531,7 @@ function pathToFileUri2(filePath) {
 }
 
 // src/evaluation/providers/vscode/dispatch/promptBuilder.ts
-import path24 from "node:path";
+import path25 from "node:path";
 
 // src/evaluation/providers/vscode/utils/template.ts
 function renderTemplate2(content, variables) {
@@ -9245,8 +9623,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
@@ -9254,8 +9632,8 @@ function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateCont
 }
 
 // src/evaluation/providers/vscode/dispatch/responseWaiter.ts
-import { readFile as readFile9 } from "node:fs/promises";
-import path25 from "node:path";
+import { readFile as readFile10 } from "node:fs/promises";
+import path26 from "node:path";
 
 // src/evaluation/providers/vscode/utils/time.ts
 function sleep2(ms) {
@@ -9293,7 +9671,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 readFile10(responseFileFinal, { encoding: "utf8" });
       if (!silent) {
         process.stdout.write(`${content}
 `);
@@ -9314,7 +9692,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;
@@ -9323,7 +9701,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}`
           );
@@ -9350,7 +9728,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 readFile10(file, { encoding: "utf8" });
         if (!silent) {
           process.stdout.write(`${content}
 `);
@@ -9374,16 +9752,16 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
 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";
 
 // src/evaluation/providers/vscode/dispatch/constants.ts
-import path26 from "node:path";
+import path27 from "node:path";
 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();
 
@@ -9450,11 +9828,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"
@@ -9467,7 +9845,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);
@@ -9482,10 +9860,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];
@@ -9493,16 +9871,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);
@@ -9510,8 +9888,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) {
@@ -9520,13 +9898,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);
@@ -9535,11 +9913,11 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
 }
 
 // src/evaluation/providers/vscode/dispatch/workspaceManager.ts
-import { copyFile, mkdir as mkdir10, readFile as readFile10, readdir as readdir3, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
-import path29 from "node:path";
+import { copyFile, mkdir as mkdir10, readFile as readFile11, readdir as readdir3, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
+import path30 from "node:path";
 
 // src/evaluation/providers/vscode/utils/workspace.ts
-import path28 from "node:path";
+import path29 from "node:path";
 import JSON5 from "json5";
 function transformWorkspacePaths(workspaceContent, templateDir) {
   let workspace;
@@ -9556,10 +9934,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
@@ -9581,19 +9959,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,
                 "/"
               );
@@ -9634,7 +10012,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;
     }
@@ -9644,7 +10022,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}`);
     }
@@ -9652,18 +10030,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 readFile11(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) {
@@ -9672,35 +10050,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) {
@@ -9720,9 +10098,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) {
@@ -9741,7 +10119,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}`);
   }
@@ -9757,7 +10135,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}`);
     }
@@ -9799,7 +10177,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,
@@ -9827,9 +10205,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,
@@ -9934,7 +10312,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,
@@ -9965,17 +10343,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) => {
@@ -10061,7 +10439,7 @@ async function dispatchBatchAgent(options) {
 
 // src/evaluation/providers/vscode/dispatch/provision.ts
 import { writeFile as writeFile5 } from "node:fs/promises";
-import path31 from "node:path";
+import path32 from "node:path";
 var DEFAULT_WORKSPACE_TEMPLATE2 = {
   folders: [
     {
@@ -10092,7 +10470,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 = path32.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -10112,7 +10490,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = path31.join(entry.absolutePath, lockName);
+      const lockFile = path32.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -10129,10 +10507,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 = path32.join(subagentDir, ".github", "agents");
+    const lockFile = path32.join(subagentDir, lockName);
+    const workspaceDst = path32.join(subagentDir, `${path32.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path32.join(githubAgentsDir, "wakeup.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -10170,10 +10548,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 = path32.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = path32.join(subagentDir, ".github", "agents");
+    const workspaceDst = path32.join(subagentDir, `${path32.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path32.join(githubAgentsDir, "wakeup.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
@@ -10363,7 +10741,7 @@ var VSCodeProvider = class {
 async function locateVSCodeExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = path32.isAbsolute(candidate) ? candidate : path32.resolve(candidate);
+    const resolved = path33.isAbsolute(candidate) ? candidate : path33.resolve(candidate);
     try {
       await access3(resolved, constants3.F_OK);
       return resolved;
@@ -10392,7 +10770,7 @@ async function resolveWorkspaceTemplateFile(template) {
     return void 0;
   }
   try {
-    const stats = await stat5(path32.resolve(template));
+    const stats = await stat5(path33.resolve(template));
     return stats.isFile() ? template : void 0;
   } catch {
     return template;
@@ -10416,7 +10794,7 @@ function buildMandatoryPrereadBlock2(attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path32.basename(absolutePath);
+    const fileName = path33.basename(absolutePath);
     const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -10437,7 +10815,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path32.resolve(attachment);
+    const absolutePath = path33.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -10445,7 +10823,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri3(filePath) {
-  const absolutePath = path32.isAbsolute(filePath) ? filePath : path32.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}`;
@@ -10458,7 +10836,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(path32.resolve(attachment));
+    deduped.add(path33.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -10467,7 +10845,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(path32.resolve(inputFile));
+      deduped.add(path33.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -10515,8 +10893,8 @@ total unlocked subagents available: ${result.created.length + result.skippedExis
 
 // src/evaluation/providers/targets-file.ts
 import { constants as constants4 } from "node:fs";
-import { access as access4, readFile as readFile11 } from "node:fs/promises";
-import path33 from "node:path";
+import { access as access4, readFile as readFile12 } from "node:fs/promises";
+import path34 from "node:path";
 import { parse as parse4 } from "yaml";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -10556,11 +10934,11 @@ 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 raw = await readFile12(absolutePath, "utf8");
   const parsed = parse4(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -10576,16 +10954,16 @@ function listTargetNames(definitions) {
 }
 
 // src/evaluation/providers/provider-discovery.ts
-import path34 from "node:path";
+import path35 from "node:path";
 import fg from "fast-glob";
 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) {
@@ -10601,7 +10979,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;
@@ -10727,150 +11105,6 @@ import { mkdtemp as mkdtemp2, rm as rm3, writeFile as writeFile6 } from "node:fs
 import { tmpdir as tmpdir2 } from "node:os";
 import { dirname, join } from "node:path";
 
-// src/runtime/exec.ts
-function shellEscapePath(value) {
-  if (process.platform === "win32") {
-    return `"${value.replaceAll('"', '""')}"`;
-  }
-  return `'${value.replaceAll("'", `'"'"'`)}'`;
-}
-async function execFileWithStdin(argv, stdinPayload, options = {}) {
-  if (argv.length === 0) {
-    throw new Error("Executable argv must include at least one entry");
-  }
-  if (typeof Bun !== "undefined") {
-    return execFileWithStdinBun(argv, stdinPayload, options);
-  }
-  return execFileWithStdinNode(argv, stdinPayload, options);
-}
-async function execFileWithStdinBun(argv, stdinPayload, options) {
-  const command = [...argv];
-  const encoder = new TextEncoder();
-  const proc = Bun.spawn(command, {
-    cwd: options.cwd,
-    stdin: encoder.encode(stdinPayload),
-    stdout: "pipe",
-    stderr: "pipe",
-    // Merge additional env vars with process.env
-    env: options.env ? { ...process.env, ...options.env } : process.env
-  });
-  let timedOut = false;
-  const timeout = options.timeoutMs !== void 0 ? setTimeout(() => {
-    timedOut = true;
-    proc.kill("SIGKILL");
-  }, options.timeoutMs) : void 0;
-  try {
-    const stdoutPromise = proc.stdout ? new Response(proc.stdout).text() : Promise.resolve("");
-    const stderrPromise = proc.stderr ? new Response(proc.stderr).text() : Promise.resolve("");
-    const [stdout, stderr, exitCode] = await Promise.all([
-      stdoutPromise,
-      stderrPromise,
-      proc.exited
-    ]);
-    if (timedOut) {
-      throw new Error(`Process timed out after ${options.timeoutMs}ms`);
-    }
-    return {
-      stdout: stdout.replace(/\r\n/g, "\n"),
-      stderr: stderr.replace(/\r\n/g, "\n"),
-      exitCode
-    };
-  } finally {
-    if (timeout !== void 0) {
-      clearTimeout(timeout);
-    }
-  }
-}
-async function execFileWithStdinNode(argv, stdinPayload, options) {
-  const { spawn: spawn5 } = await import("node:child_process");
-  return new Promise((resolve, reject) => {
-    const [cmd, ...args] = argv;
-    const child = spawn5(cmd, args, {
-      cwd: options.cwd,
-      stdio: ["pipe", "pipe", "pipe"],
-      // Merge additional env vars with process.env
-      env: options.env ? { ...process.env, ...options.env } : process.env
-    });
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
-    child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
-    let timedOut = false;
-    const timeout = options.timeoutMs !== void 0 ? setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGKILL");
-    }, options.timeoutMs) : void 0;
-    child.on("error", (error) => {
-      if (timeout !== void 0) clearTimeout(timeout);
-      reject(error);
-    });
-    child.on("close", (code) => {
-      if (timeout !== void 0) clearTimeout(timeout);
-      if (timedOut) {
-        reject(new Error(`Process timed out after ${options.timeoutMs}ms`));
-        return;
-      }
-      const stdout = Buffer.concat(stdoutChunks).toString("utf8").replace(/\r\n/g, "\n");
-      const stderr = Buffer.concat(stderrChunks).toString("utf8").replace(/\r\n/g, "\n");
-      resolve({
-        stdout,
-        stderr,
-        exitCode: code ?? 0
-      });
-    });
-    if (child.stdin) {
-      child.stdin.write(stdinPayload);
-      child.stdin.end();
-    }
-  });
-}
-async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir16, readFile: 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((resolve, reject) => {
-      const child = spawn5(wrappedCommand, {
-        shell: true,
-        cwd: options.cwd,
-        stdio: ["ignore", "ignore", "ignore"],
-        // Merge additional env vars with process.env
-        env: options.env ? { ...process.env, ...options.env } : process.env
-      });
-      const timeout = options.timeoutMs ? setTimeout(() => {
-        child.kill();
-        reject(new Error(`Process timed out after ${options.timeoutMs}ms`));
-      }, options.timeoutMs) : void 0;
-      child.on("error", (error) => {
-        if (timeout !== void 0) {
-          clearTimeout(timeout);
-        }
-        reject(error);
-      });
-      child.on("exit", (code) => {
-        if (timeout !== void 0) {
-          clearTimeout(timeout);
-        }
-        resolve(code ?? 0);
-      });
-    });
-    const stdout = (await 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 });
-  }
-}
-
 // src/runtime/target-proxy.ts
 import { randomBytes } from "node:crypto";
 import { createServer } from "node:http";
@@ -11380,7 +11614,7 @@ import { generateText as generateText3 } from "ai";
 
 // src/evaluation/evaluators/llm-grader.ts
 import fs2 from "node:fs/promises";
-import path35 from "node:path";
+import path36 from "node:path";
 import { generateText as generateText2, stepCountIs, tool } from "ai";
 import { z as z3 } from "zod";
 var DEFAULT_MAX_STEPS = 10;
@@ -11464,6 +11698,15 @@ var scoreRangeEvaluationSchema = z3.object({
   checks: z3.array(scoreRangeCheckResultSchema).describe("Scores for each rubric criterion"),
   overall_reasoning: z3.string().describe("Overall assessment summary (1-2 sentences)").optional()
 });
+function resolveContentBasePath(context) {
+  if (context.workspacePath) {
+    return context.workspacePath;
+  }
+  if ("config" in context.target && context.target.config && typeof context.target.config === "object" && "cwd" in context.target.config && typeof context.target.config.cwd === "string") {
+    return context.target.config.cwd;
+  }
+  return void 0;
+}
 var LlmGraderEvaluator = class {
   kind = "llm-grader";
   resolveGraderProvider;
@@ -11481,24 +11724,46 @@ var LlmGraderEvaluator = class {
     this.graderTargetProvider = options.graderTargetProvider ?? options.judgeTargetProvider;
   }
   async evaluate(context) {
+    const preparedContext = await this.prepareContext(context);
     if (this.graderTargetProvider) {
-      return this.evaluateWithGraderTarget(context);
+      return this.evaluateWithGraderTarget(preparedContext);
     }
-    const graderProvider = await this.resolveGraderProvider(context);
+    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(context, graderProvider);
+      return this.evaluateBuiltIn(preparedContext, graderProvider);
     }
     if (isAgentProvider(graderProvider)) {
-      return this.evaluateWithDelegatedAgent(context, graderProvider);
+      return this.evaluateWithDelegatedAgent(preparedContext, graderProvider);
     }
-    const config = context.evaluator;
+    const config = preparedContext.evaluator;
     if (config?.type === "llm-grader" && config.rubrics && config.rubrics.length > 0) {
-      return this.evaluateWithRubrics(context, graderProvider, config.rubrics);
+      return this.evaluateWithRubrics(preparedContext, graderProvider, config.rubrics);
+    }
+    return this.evaluateFreeform(preparedContext, graderProvider);
+  }
+  async prepareContext(context) {
+    const config = context.evaluator;
+    if (config?.type !== "llm-grader" || !context.output) {
+      return context;
+    }
+    const lastAssistant = [...context.output].reverse().find((message) => message.role === "assistant" && message.content !== void 0);
+    if (!lastAssistant || typeof lastAssistant.content === "string") {
+      return context;
     }
-    return this.evaluateFreeform(context, graderProvider);
+    const extracted = await extractTextWithPreprocessors(
+      lastAssistant.content,
+      config.preprocessors,
+      {
+        basePath: resolveContentBasePath(context)
+      }
+    );
+    return {
+      ...context,
+      candidate: appendPreprocessingWarnings(extracted.text, extracted.warnings)
+    };
   }
   // ---------------------------------------------------------------------------
   // LLM mode (existing)
@@ -12383,8 +12648,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;
@@ -12474,11 +12739,11 @@ 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);
@@ -12490,7 +12755,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)
             });
@@ -13123,115 +13388,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: path52, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path52);
+    const expectedValue = resolvePath(expectedData, path52);
     if (expectedValue === void 0) {
       return {
-        path: path51,
+        path: path52,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path51}: no expected value`
+        message: `${path52}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path51,
+          path: path52,
           score: 0,
           weight,
           hit: false,
-          message: `${path51} (required, missing)`
+          message: `${path52} (required, missing)`
         };
       }
       return {
-        path: path51,
+        path: path52,
         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: `${path52}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path51, candidateValue, expectedValue, weight);
+        return this.compareExact(path52, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path51,
+          path52,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path51, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path52, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path51,
+          path: path52,
           score: 0,
           weight,
           hit: false,
-          message: `${path51}: unknown match type "${match}"`
+          message: `${path52}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path51, candidateValue, expectedValue, weight) {
+  compareExact(path52, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path51,
+        path: path52,
         score: 1,
         weight,
         hit: true,
-        message: path51
+        message: path52
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path51,
+        path: path52,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path52} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path51,
+      path: path52,
       score: 0,
       weight,
       hit: false,
-      message: `${path51} (value mismatch)`
+      message: `${path52} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path51, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path52, 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: path52,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (non-numeric value)`
+        message: `${path52} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path51,
+        path: path52,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (invalid numeric value)`
+        message: `${path52} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -13244,61 +13509,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path51,
+        path: path52,
         score: 1,
         weight,
         hit: true,
-        message: `${path51} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path52} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path51,
+      path: path52,
       score: 0,
       weight,
       hit: false,
-      message: `${path51} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path52} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path51, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path52, 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: path52,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (unparseable candidate date)`
+        message: `${path52} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path51,
+        path: path52,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (unparseable expected date)`
+        message: `${path52} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path51,
+        path: path52,
         score: 1,
         weight,
         hit: true,
-        message: path51
+        message: path52
       };
     }
     return {
-      path: path51,
+      path: path52,
       score: 0,
       weight,
       hit: false,
-      message: `${path51} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path52} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -13331,11 +13596,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path51) {
-  if (!path51 || !obj) {
+function resolvePath(obj, path52) {
+  if (!path52 || !obj) {
     return void 0;
   }
-  const parts = path51.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path52.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -13827,8 +14092,8 @@ var TokenUsageEvaluator = class {
 };
 
 // src/evaluation/evaluators/tool-trajectory.ts
-function getNestedValue(obj, path51) {
-  const parts = path51.split(".");
+function getNestedValue(obj, path52) {
+  const parts = path52.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -14449,8 +14714,9 @@ function runEqualsAssertion(output, value) {
 
 // src/evaluation/orchestrator.ts
 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";
 
 // ../../node_modules/.bun/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
@@ -14664,7 +14930,7 @@ var InlineAssertEvaluator = class {
 };
 
 // src/evaluation/evaluators/prompt-resolution.ts
-import path36 from "node:path";
+import path37 from "node:path";
 async function resolveCustomPrompt(promptConfig, context, timeoutMs) {
   if (promptConfig.resolvedPromptScript && promptConfig.resolvedPromptScript.length > 0) {
     if (!context) {
@@ -14707,7 +14973,7 @@ async function executePromptTemplate(script, context, 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();
@@ -14979,16 +15245,16 @@ function createBuiltinRegistry() {
 }
 
 // src/evaluation/registry/assertion-discovery.ts
-import path37 from "node:path";
+import path38 from "node:path";
 import fg2 from "fast-glob";
 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) {
@@ -15004,7 +15270,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;
@@ -15022,17 +15288,17 @@ async function discoverAssertions(registry, baseDir) {
 }
 
 // src/evaluation/registry/grader-discovery.ts
-import path38 from "node:path";
+import path39 from "node:path";
 import fg3 from "fast-glob";
 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) {
@@ -15048,7 +15314,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;
@@ -15208,7 +15474,7 @@ function getTCritical(df) {
 // src/evaluation/workspace/file-changes.ts
 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";
 var execAsync4 = promisify4(execCallback);
 function gitExecOpts(workspacePath) {
@@ -15242,10 +15508,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;
     }
@@ -15256,7 +15522,7 @@ async function stageNestedRepoChanges(workspacePath) {
 
 // src/evaluation/workspace/manager.ts
 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";
 var TemplateNotFoundError = class extends Error {
   constructor(templatePath) {
     super(`Workspace template not found: ${templatePath}`);
@@ -15286,14 +15552,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;
     }
@@ -15305,7 +15571,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);
   }
@@ -15354,7 +15620,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 });
   }
@@ -15364,8 +15630,8 @@ async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync as existsSync3 } from "node:fs";
-import { cp as cp2, mkdir as mkdir13, readFile as 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 readFile13, readdir as readdir5, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
+import path42 from "node:path";
 import { promisify as promisify5 } from "node:util";
 var execFileAsync = promisify5(execFile);
 function gitEnv() {
@@ -15419,8 +15685,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 = path42.join(src, entry.name);
+    const destPath = path42.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
@@ -15453,7 +15719,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 = path42.join(this.poolRoot, fingerprint);
     await mkdir13(poolDir, { recursive: true });
     const drifted = await this.checkDrift(poolDir, fingerprint);
     if (drifted) {
@@ -15463,7 +15729,7 @@ var WorkspacePoolManager = class {
       await this.removeAllSlots(poolDir);
     }
     for (let i = 0; i < maxSlots; i++) {
-      const slotPath = path41.join(poolDir, `slot-${i}`);
+      const slotPath = path42.join(poolDir, `slot-${i}`);
       const lockPath = `${slotPath}.lock`;
       const locked = await this.tryLock(lockPath);
       if (!locked) {
@@ -15525,7 +15791,7 @@ var WorkspacePoolManager = class {
           throw err;
         }
         try {
-          const pidStr = await readFile12(lockPath, "utf-8");
+          const pidStr = await readFile13(lockPath, "utf-8");
           const pid = Number.parseInt(pidStr.trim(), 10);
           if (!Number.isNaN(pid)) {
             try {
@@ -15550,9 +15816,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 = path42.join(poolDir, "metadata.json");
     try {
-      const raw = await readFile12(metadataPath, "utf-8");
+      const raw = await readFile13(metadataPath, "utf-8");
       const metadata = JSON.parse(raw);
       return metadata.fingerprint !== fingerprint;
     } catch {
@@ -15567,17 +15833,17 @@ var WorkspacePoolManager = class {
       repos,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await writeFile7(path41.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+    await writeFile7(path42.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 = path42.join(poolDir, `${entry}.lock`);
         if (existsSync3(lockPath)) {
           try {
-            const pidStr = await readFile12(lockPath, "utf-8");
+            const pidStr = await readFile13(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
             if (!Number.isNaN(pid)) {
               try {
@@ -15590,12 +15856,12 @@ var WorkspacePoolManager = class {
           } catch {
           }
         }
-        await rm5(path41.join(poolDir, entry), { recursive: true, force: true });
+        await rm5(path42.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(path42.join(poolDir, "metadata.json"), { force: true }).catch(() => {
     });
   }
   /**
@@ -15605,7 +15871,7 @@ var WorkspacePoolManager = class {
    */
   async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
     for (const repo of repos) {
-      const repoDir = path41.join(slotPath, repo.path);
+      const repoDir = path42.join(slotPath, repo.path);
       if (!existsSync3(repoDir)) {
         continue;
       }
@@ -15642,7 +15908,7 @@ var WorkspacePoolManager = class {
 // src/evaluation/workspace/repo-manager.ts
 import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync4 } from "node:fs";
-import path42 from "node:path";
+import path43 from "node:path";
 import { promisify as promisify6 } from "node:util";
 var execFileAsync2 = promisify6(execFile2);
 var DEFAULT_TIMEOUT_MS2 = 3e5;
@@ -15742,7 +16008,7 @@ ${lines.join("\n")}`;
    * Handles checkout, ref resolution, ancestor walking, shallow clone, sparse checkout.
    */
   async materialize(repo, workspacePath) {
-    const targetDir = path42.join(workspacePath, repo.path);
+    const targetDir = path43.join(workspacePath, repo.path);
     const sourceUrl = getSourceUrl(repo.source);
     const startedAt = Date.now();
     if (this.verbose) {
@@ -15833,7 +16099,7 @@ ${lines.join("\n")}`;
   async reset(repos, workspacePath, reset) {
     const cleanFlag = reset === "strict" ? "-fdx" : "-fd";
     for (const repo of repos) {
-      const targetDir = path42.join(workspacePath, repo.path);
+      const targetDir = path43.join(workspacePath, repo.path);
       await this.runGit(["reset", "--hard", "HEAD"], { cwd: targetDir });
       await this.runGit(["clean", cleanFlag], { cwd: targetDir });
     }
@@ -15842,16 +16108,16 @@ ${lines.join("\n")}`;
 
 // src/evaluation/workspace/resolve.ts
 import { readdir as readdir6, stat as stat7 } from "node:fs/promises";
-import path43 from "node:path";
+import path44 from "node:path";
 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
     };
   }
@@ -15863,14 +16129,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 };
@@ -16089,7 +16355,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);
@@ -16228,8 +16494,8 @@ async function runEvaluation(options) {
   const poolSlotBaselines = /* @__PURE__ */ new Map();
   const poolMaxSlots = Math.min(configPoolMaxSlots ?? 10, 50);
   let staticMaterialised = false;
+  const isYamlConfiguredPath = !cliWorkspacePath && !!yamlWorkspacePath;
   if (useStaticWorkspace && configuredStaticPath) {
-    const isYamlConfiguredPath = !cliWorkspacePath && !!yamlWorkspacePath;
     const dirExists = await stat8(configuredStaticPath).then(
       (s) => s.isDirectory(),
       () => false
@@ -16287,21 +16553,35 @@ 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;
       } catch {
       }
     }
-    const needsRepoMaterialisation = !!suiteWorkspace?.repos?.length && !usePool && (!useStaticWorkspace || staticMaterialised);
-    const repoManager = needsRepoMaterialisation ? new RepoManager(verbose) : void 0;
-    if (repoManager && sharedWorkspacePath && suiteWorkspace?.repos && !isPerTestIsolation) {
-      setupLog(
-        `materializing ${suiteWorkspace.repos.length} shared repo(s) into ${sharedWorkspacePath}`
-      );
+    const hasReposToMaterialize = !!suiteWorkspace?.repos?.length && !usePool && !isPerTestIsolation;
+    const needsRepoMaterialisation = hasReposToMaterialize && (!useStaticWorkspace || staticMaterialised);
+    const needsPerRepoCheck = hasReposToMaterialize && useStaticWorkspace && !staticMaterialised && isYamlConfiguredPath;
+    const repoManager = needsRepoMaterialisation || needsPerRepoCheck ? new RepoManager(verbose) : void 0;
+    if (repoManager && sharedWorkspacePath && suiteWorkspace?.repos) {
       try {
-        await repoManager.materializeAll(suiteWorkspace.repos, sharedWorkspacePath);
+        if (needsPerRepoCheck) {
+          for (const repo of suiteWorkspace.repos) {
+            const targetDir = path45.join(sharedWorkspacePath, repo.path);
+            if (existsSync5(targetDir)) {
+              setupLog(`reusing existing repo at: ${targetDir}`);
+              continue;
+            }
+            setupLog(`materializing missing repo: ${repo.path}`);
+            await repoManager.materialize(repo, sharedWorkspacePath);
+          }
+        } else {
+          setupLog(
+            `materializing ${suiteWorkspace.repos.length} shared repo(s) into ${sharedWorkspacePath}`
+          );
+          await repoManager.materializeAll(suiteWorkspace.repos, sharedWorkspacePath);
+        }
         setupLog("shared repo materialization complete");
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -16875,7 +17155,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;
@@ -16937,10 +17217,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);
@@ -17536,6 +17816,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,
@@ -17555,10 +17836,21 @@ async function runEvaluatorsForCase(options) {
     targetResolver,
     availableTargets,
     fileChanges,
-    workspacePath
+    workspacePath,
+    ...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,
@@ -17608,7 +17900,7 @@ async function runEvaluatorList(options) {
     fileChanges,
     workspacePath
   };
-  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,
@@ -17975,8 +18267,8 @@ function computeWeightedMean(entries) {
 }
 
 // src/evaluation/evaluate.ts
-import { existsSync as existsSync5 } from "node:fs";
-import path45 from "node:path";
+import { existsSync as existsSync6 } from "node:fs";
+import path46 from "node:path";
 
 // src/evaluation/providers/function-provider.ts
 function createFunctionProvider(taskFn) {
@@ -18013,7 +18305,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;
@@ -18128,11 +18420,11 @@ 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);
-      if (!existsSync5(targetsPath)) continue;
+      const targetsPath = path46.join(dir, candidate);
+      if (!existsSync6(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
         const defaultTarget = definitions.find((d) => d.name === "default");
@@ -18148,8 +18440,8 @@ async function loadEnvHierarchy(repoRoot, startPath) {
   const chain = buildDirectoryChain(startPath, repoRoot);
   const envFiles = [];
   for (const dir of chain) {
-    const envPath = path45.join(dir, ".env");
-    if (existsSync5(envPath)) envFiles.push(envPath);
+    const envPath = path46.join(dir, ".env");
+    if (existsSync6(envPath)) envFiles.push(envPath);
   }
   for (let i = 0; i < envFiles.length; i++) {
     try {
@@ -18225,12 +18517,12 @@ var CONFIG_FILE_NAMES = [
   ".agentv/config.js"
 ];
 async function loadTsConfig(projectRoot) {
-  const { existsSync: existsSync7 } = await import("node:fs");
+  const { existsSync: existsSync8 } = 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 (!existsSync7(filePath)) {
+    if (!existsSync8(filePath)) {
       continue;
     }
     try {
@@ -18327,8 +18619,8 @@ function buildPrompt(criteria, question, referenceAnswer) {
 }
 
 // src/evaluation/workspace/deps-scanner.ts
-import { readFile as readFile13 } from "node:fs/promises";
-import path46 from "node:path";
+import { readFile as readFile14 } from "node:fs/promises";
+import path47 from "node:path";
 import { parse as parse5 } from "yaml";
 function normalizeGitUrl(url) {
   let normalized = url.replace(/\.git$/, "");
@@ -18375,11 +18667,11 @@ async function scanRepoDeps(evalFilePaths) {
   return { repos: [...seen.values()], errors };
 }
 async function extractReposFromEvalFile(filePath) {
-  const content = await readFile13(filePath, "utf8");
+  const content = await readFile14(filePath, "utf8");
   const parsed = interpolateEnv(parse5(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);
@@ -18395,8 +18687,8 @@ 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 workspaceFilePath = path47.resolve(evalFileDir, raw);
+    const content = await readFile14(workspaceFilePath, "utf8");
     const parsed = interpolateEnv(parse5(content), process.env);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
     return extractReposFromObject(parsed);
@@ -18424,8 +18716,8 @@ function extractReposFromObject(obj) {
 }
 
 // src/evaluation/cache/response-cache.ts
-import { mkdir as mkdir15, readFile as readFile14, writeFile as writeFile8 } from "node:fs/promises";
-import path47 from "node:path";
+import { mkdir as mkdir15, readFile as readFile15, writeFile as writeFile8 } from "node:fs/promises";
+import path48 from "node:path";
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
   cachePath;
@@ -18435,7 +18727,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await readFile14(filePath, "utf8");
+      const data = await readFile15(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -18443,13 +18735,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) {
@@ -18465,15 +18757,15 @@ function shouldSkipCacheForTemperature(targetConfig) {
 }
 
 // src/projects.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync2, writeFileSync } from "node:fs";
-import path48 from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync2, writeFileSync } from "node:fs";
+import path49 from "node:path";
 import { parse as parseYaml3, stringify as stringifyYaml } from "yaml";
 function getProjectsRegistryPath() {
-  return path48.join(getAgentvHome(), "projects.yaml");
+  return path49.join(getAgentvHome(), "projects.yaml");
 }
 function loadProjectRegistry() {
   const registryPath = getProjectsRegistryPath();
-  if (!existsSync6(registryPath)) {
+  if (!existsSync7(registryPath)) {
     return { projects: [] };
   }
   try {
@@ -18489,14 +18781,14 @@ function loadProjectRegistry() {
 }
 function saveProjectRegistry(registry) {
   const registryPath = getProjectsRegistryPath();
-  const dir = path48.dirname(registryPath);
-  if (!existsSync6(dir)) {
+  const dir = path49.dirname(registryPath);
+  if (!existsSync7(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   writeFileSync(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 = path49.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   let candidate = base || "project";
   let suffix = 2;
   while (existingIds.includes(candidate)) {
@@ -18506,11 +18798,11 @@ function deriveProjectId(dirPath, existingIds) {
   return candidate;
 }
 function addProject(projectPath) {
-  const absPath = path48.resolve(projectPath);
-  if (!existsSync6(absPath)) {
+  const absPath = path49.resolve(projectPath);
+  if (!existsSync7(absPath)) {
     throw new Error(`Directory not found: ${absPath}`);
   }
-  if (!existsSync6(path48.join(absPath, ".agentv"))) {
+  if (!existsSync7(path49.join(absPath, ".agentv"))) {
     throw new Error(`No .agentv/ directory found in ${absPath}. Run an evaluation first.`);
   }
   const registry = loadProjectRegistry();
@@ -18524,7 +18816,7 @@ function addProject(projectPath) {
       absPath,
       registry.projects.map((p) => p.id)
     ),
-    name: path48.basename(absPath),
+    name: path49.basename(absPath),
     path: absPath,
     addedAt: now,
     lastOpenedAt: now
@@ -18553,14 +18845,14 @@ function touchProject(projectId) {
   }
 }
 function discoverProjects(rootDir, maxDepth = 2) {
-  const absRoot = path48.resolve(rootDir);
-  if (!existsSync6(absRoot) || !statSync2(absRoot).isDirectory()) {
+  const absRoot = path49.resolve(rootDir);
+  if (!existsSync7(absRoot) || !statSync2(absRoot).isDirectory()) {
     return [];
   }
   const results = [];
   function scan(dir, depth) {
     if (depth > maxDepth) return;
-    if (existsSync6(path48.join(dir, ".agentv"))) {
+    if (existsSync7(path49.join(dir, ".agentv"))) {
       results.push(dir);
       return;
     }
@@ -18570,7 +18862,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(path49.join(dir, entry.name), depth + 1);
       }
     } catch {
     }
@@ -19483,8 +19775,8 @@ function extractResponseItemContent(content) {
 // src/import/codex-session-discovery.ts
 import { readdir as readdir8, stat as stat9 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import path49 from "node:path";
-var DEFAULT_SESSIONS_DIR = () => path49.join(homedir3(), ".codex", "sessions");
+import path50 from "node:path";
+var DEFAULT_SESSIONS_DIR = () => path50.join(homedir3(), ".codex", "sessions");
 async function discoverCodexSessions(opts) {
   const sessionsDir = opts?.sessionsDir ?? DEFAULT_SESSIONS_DIR();
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
@@ -19496,7 +19788,7 @@ async function discoverCodexSessions(opts) {
     return [];
   }
   for (const year of yearDirs) {
-    const yearPath = path49.join(sessionsDir, year);
+    const yearPath = path50.join(sessionsDir, year);
     let monthDirs;
     try {
       monthDirs = await readdir8(yearPath);
@@ -19504,7 +19796,7 @@ async function discoverCodexSessions(opts) {
       continue;
     }
     for (const month of monthDirs) {
-      const monthPath = path49.join(yearPath, month);
+      const monthPath = path50.join(yearPath, month);
       let dayDirs;
       try {
         dayDirs = await readdir8(monthPath);
@@ -19516,7 +19808,7 @@ async function discoverCodexSessions(opts) {
           const dirDate = `${year}-${month}-${day}`;
           if (dirDate !== opts.date) continue;
         }
-        const dayPath = path49.join(monthPath, day);
+        const dayPath = path50.join(monthPath, day);
         let files;
         try {
           files = await readdir8(dayPath);
@@ -19525,7 +19817,7 @@ async function discoverCodexSessions(opts) {
         }
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = path49.join(dayPath, file);
+          const filePath = path50.join(dayPath, file);
           const nameWithoutExt = file.replace(/\.jsonl$/, "");
           const parts = nameWithoutExt.split("-");
           const sessionId = parts.length >= 6 ? parts.slice(-5).join("-") : nameWithoutExt;
@@ -19548,8 +19840,8 @@ async function discoverCodexSessions(opts) {
 // src/import/session-discovery.ts
 import { readdir as readdir9, stat as stat10 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import path50 from "node:path";
-var DEFAULT_PROJECTS_DIR = () => path50.join(homedir4(), ".claude", "projects");
+import path51 from "node:path";
+var DEFAULT_PROJECTS_DIR = () => path51.join(homedir4(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -19568,7 +19860,7 @@ async function discoverClaudeSessions(opts) {
   }
   const sessions = [];
   for (const projectDir of projectDirs) {
-    const dirPath = path50.join(projectsDir, projectDir);
+    const dirPath = path51.join(projectsDir, projectDir);
     let entries;
     try {
       entries = await readdir9(dirPath);
@@ -19579,7 +19871,7 @@ 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 = path51.join(dirPath, entry);
       let updatedAt;
       try {
         const fileStat = await stat10(filePath);
@@ -19600,7 +19892,7 @@ async function discoverClaudeSessions(opts) {
 }
 
 // src/import/types.ts
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile16 } from "node:fs/promises";
 function toTranscriptJsonLine(entry) {
   const firstUserMessage = entry.messages.find((m) => m.role === "user");
   const input = typeof firstUserMessage?.content === "string" ? firstUserMessage.content : "";
@@ -19626,11 +19918,11 @@ function toTranscriptJsonLine(entry) {
   };
 }
 async function readTranscriptJsonl(filePath) {
-  const text = await readFile15(filePath, "utf8");
+  const text = await readFile16(filePath, "utf8");
   return text.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
 }
 async function readTranscriptFile(filePath) {
-  return readFile15(filePath, "utf8");
+  return readFile16(filePath, "utf8");
 }
 
 // src/import/transcript-provider.ts