@agentv/core 4.9.0 → 4.10.0

package/dist/index.cjs

@@ -1355,13 +1355,13 @@ function serializeAttributeValue(value) {
   if (Array.isArray(value)) return { arrayValue: { values: value.map(serializeAttributeValue) } };
   return { stringValue: String(value) };
 }
-var import_promises36, import_node_path53, OtlpJsonFileExporter;
+var import_promises37, import_node_path54, OtlpJsonFileExporter;
 var init_otlp_json_file_exporter = __esm({
   "src/observability/otlp-json-file-exporter.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises36 = require("fs/promises");
-    import_node_path53 = require("path");
+    import_promises37 = require("fs/promises");
+    import_node_path54 = require("path");
     OtlpJsonFileExporter = class {
       // biome-ignore lint/suspicious/noExplicitAny: serialized span data
       spans = [];
@@ -1400,7 +1400,7 @@ var init_otlp_json_file_exporter = __esm({
       }
       async flush() {
         if (this.spans.length === 0) return;
-        await (0, import_promises36.mkdir)((0, import_node_path53.dirname)(this.filePath), { recursive: true });
+        await (0, import_promises37.mkdir)((0, import_node_path54.dirname)(this.filePath), { recursive: true });
         const otlpJson = {
           resourceSpans: [
             {
@@ -1829,8 +1829,8 @@ function mergeExecutionMetrics(computed, metrics) {
 
 // src/evaluation/yaml-parser.ts
 init_cjs_shims();
-var import_promises8 = require("fs/promises");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_promises9 = require("fs/promises");
+var import_node_path9 = __toESM(require("path"), 1);
 var import_micromatch2 = __toESM(require("micromatch"), 1);
 var import_yaml4 = require("yaml");
 
@@ -2505,11 +2505,321 @@ function logWarning(message) {
 
 // src/evaluation/loaders/evaluator-parser.ts
 init_cjs_shims();
+var import_node_path6 = __toESM(require("path"), 1);
+
+// src/evaluation/content-preprocessor.ts
+init_cjs_shims();
+var import_promises5 = require("fs/promises");
 var import_node_path5 = __toESM(require("path"), 1);
+var import_node_url2 = require("url");
+
+// src/runtime/exec.ts
+init_cjs_shims();
+function shellEscapePath(value) {
+  if (process.platform === "win32") {
+    return `"${value.replaceAll('"', '""')}"`;
+  }
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+async function execFileWithStdin(argv, stdinPayload, options = {}) {
+  if (argv.length === 0) {
+    throw new Error("Executable argv must include at least one entry");
+  }
+  if (typeof Bun !== "undefined") {
+    return execFileWithStdinBun(argv, stdinPayload, options);
+  }
+  return execFileWithStdinNode(argv, stdinPayload, options);
+}
+async function execFileWithStdinBun(argv, stdinPayload, options) {
+  const command = [...argv];
+  const encoder = new TextEncoder();
+  const proc = Bun.spawn(command, {
+    cwd: options.cwd,
+    stdin: encoder.encode(stdinPayload),
+    stdout: "pipe",
+    stderr: "pipe",
+    // Merge additional env vars with process.env
+    env: options.env ? { ...process.env, ...options.env } : process.env
+  });
+  let timedOut = false;
+  const timeout = options.timeoutMs !== void 0 ? setTimeout(() => {
+    timedOut = true;
+    proc.kill("SIGKILL");
+  }, options.timeoutMs) : void 0;
+  try {
+    const stdoutPromise = proc.stdout ? new Response(proc.stdout).text() : Promise.resolve("");
+    const stderrPromise = proc.stderr ? new Response(proc.stderr).text() : Promise.resolve("");
+    const [stdout, stderr, exitCode] = await Promise.all([
+      stdoutPromise,
+      stderrPromise,
+      proc.exited
+    ]);
+    if (timedOut) {
+      throw new Error(`Process timed out after ${options.timeoutMs}ms`);
+    }
+    return {
+      stdout: stdout.replace(/\r\n/g, "\n"),
+      stderr: stderr.replace(/\r\n/g, "\n"),
+      exitCode
+    };
+  } finally {
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
+    }
+  }
+}
+async function execFileWithStdinNode(argv, stdinPayload, options) {
+  const { spawn: spawn5 } = await import("child_process");
+  return new Promise((resolve, reject) => {
+    const [cmd, ...args] = argv;
+    const child = spawn5(cmd, args, {
+      cwd: options.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      // Merge additional env vars with process.env
+      env: options.env ? { ...process.env, ...options.env } : process.env
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
+    child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+    let timedOut = false;
+    const timeout = options.timeoutMs !== void 0 ? setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, options.timeoutMs) : void 0;
+    child.on("error", (error) => {
+      if (timeout !== void 0) clearTimeout(timeout);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (timeout !== void 0) clearTimeout(timeout);
+      if (timedOut) {
+        reject(new Error(`Process timed out after ${options.timeoutMs}ms`));
+        return;
+      }
+      const stdout = Buffer.concat(stdoutChunks).toString("utf8").replace(/\r\n/g, "\n");
+      const stderr = Buffer.concat(stderrChunks).toString("utf8").replace(/\r\n/g, "\n");
+      resolve({
+        stdout,
+        stderr,
+        exitCode: code ?? 0
+      });
+    });
+    if (child.stdin) {
+      child.stdin.write(stdinPayload);
+      child.stdin.end();
+    }
+  });
+}
+async function execShellWithStdin(command, stdinPayload, options = {}) {
+  const { mkdir: mkdir17, readFile: readFile19, rm: rm6, writeFile: writeFile9 } = await import("fs/promises");
+  const { tmpdir: tmpdir3 } = await import("os");
+  const path55 = await import("path");
+  const { randomUUID: randomUUID10 } = await import("crypto");
+  const dir = path55.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
+  await mkdir17(dir, { recursive: true });
+  const stdinPath = path55.join(dir, "stdin.txt");
+  const stdoutPath = path55.join(dir, "stdout.txt");
+  const stderrPath = path55.join(dir, "stderr.txt");
+  await writeFile9(stdinPath, stdinPayload, "utf8");
+  const wrappedCommand = process.platform === "win32" ? `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
+  const { spawn: spawn5 } = await import("child_process");
+  try {
+    const exitCode = await new Promise((resolve, reject) => {
+      const child = spawn5(wrappedCommand, {
+        shell: true,
+        cwd: options.cwd,
+        stdio: ["ignore", "ignore", "ignore"],
+        // Merge additional env vars with process.env
+        env: options.env ? { ...process.env, ...options.env } : process.env
+      });
+      const timeout = options.timeoutMs ? setTimeout(() => {
+        child.kill();
+        reject(new Error(`Process timed out after ${options.timeoutMs}ms`));
+      }, options.timeoutMs) : void 0;
+      child.on("error", (error) => {
+        if (timeout !== void 0) {
+          clearTimeout(timeout);
+        }
+        reject(error);
+      });
+      child.on("exit", (code) => {
+        if (timeout !== void 0) {
+          clearTimeout(timeout);
+        }
+        resolve(code ?? 0);
+      });
+    });
+    const stdout = (await readFile19(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
+    const stderr = (await readFile19(stderrPath, "utf8")).replace(/\r\n/g, "\n");
+    return { stdout, stderr, exitCode };
+  } finally {
+    await rm6(dir, { recursive: true, force: true });
+  }
+}
+
+// src/evaluation/content-preprocessor.ts
+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 (0, import_promises5.readFile)(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 (0, import_node_url2.fileURLToPath)(value);
+  }
+  if (/^[a-z]+:\/\//i.test(value)) {
+    return void 0;
+  }
+  return basePath ? import_node_path5.default.resolve(basePath, value) : import_node_path5.default.resolve(value);
+}
+function formatFileText(filePath, text) {
+  return `[[ file: ${filePath} ]]
+${text}`;
+}
 
 // src/evaluation/validation/prompt-validator.ts
 init_cjs_shims();
-var import_promises5 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 
 // src/evaluation/template-variables.ts
 init_cjs_shims();
@@ -2541,7 +2851,7 @@ var DEPRECATED_TEMPLATE_VARIABLES = /* @__PURE__ */ new Map([
 var ANSI_YELLOW3 = "\x1B[33m";
 var ANSI_RESET4 = "\x1B[0m";
 async function validateCustomPromptContent(promptPath) {
-  const content = await (0, import_promises5.readFile)(promptPath, "utf8");
+  const content = await (0, import_promises6.readFile)(promptPath, "utf8");
   validateTemplateVariables(content, promptPath);
 }
 function validateTemplateVariables(content, source) {
@@ -2598,22 +2908,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;
   }
@@ -2678,6 +2998,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(
@@ -2736,7 +3063,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       if (cwd) {
         const resolved = await resolveFileReference2(cwd, searchRoots);
         if (resolved.resolvedPath) {
-          resolvedCwd = import_node_path5.default.resolve(resolved.resolvedPath);
+          resolvedCwd = import_node_path6.default.resolve(resolved.resolvedPath);
         } else {
           logWarning2(
             `Code-grader evaluator '${name}' in '${evalId}': cwd not found (${resolved.displayPath})`,
@@ -2782,6 +3109,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
         "cwd",
         "weight",
         "target",
+        "preprocessors",
         "required",
         "negate"
       ]);
@@ -2802,6 +3130,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;
@@ -2911,7 +3240,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
             aggregatorPrompt = fileRef;
             const resolved = await resolveFileReference2(fileRef, searchRoots);
             if (resolved.resolvedPath) {
-              promptPath2 = import_node_path5.default.resolve(resolved.resolvedPath);
+              promptPath2 = import_node_path6.default.resolve(resolved.resolvedPath);
             } else {
               throw new Error(
                 `Composite aggregator in '${evalId}': prompt file not found: ${resolved.displayPath}`
@@ -3565,7 +3894,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;
     }
@@ -3590,7 +3920,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), import_node_path5.default.resolve(resolved.resolvedPath)];
+        resolvedPromptScript = [...commandArray.slice(0, -1), import_node_path6.default.resolve(resolved.resolvedPath)];
       } else {
         throw new Error(
           `Evaluator '${name}' in '${evalId}': prompt command file not found: ${resolved.displayPath}`
@@ -3605,7 +3935,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
         prompt = fileRef;
         const resolved = await resolveFileReference2(fileRef, searchRoots);
         if (resolved.resolvedPath) {
-          promptPath = import_node_path5.default.resolve(resolved.resolvedPath);
+          promptPath = import_node_path6.default.resolve(resolved.resolvedPath);
           try {
             await validateCustomPromptContent(promptPath);
           } catch (error) {
@@ -3648,7 +3978,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;
     }
@@ -3673,7 +4004,8 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       "negate",
       "max_steps",
       "maxSteps",
-      "temperature"
+      "temperature",
+      "preprocessors"
     ]);
     const config = {};
     for (const [key, value] of Object.entries(rawEvaluator)) {
@@ -3703,30 +4035,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), import_node_path6.default.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) {
@@ -3759,7 +4131,7 @@ function generateAssertionName(typeValue, rawEvaluator) {
     case "rubrics":
       return "rubrics";
     default:
-      return void 0;
+      return typeValue;
   }
 }
 function coerceEvaluator(candidate, contextId) {
@@ -4118,15 +4490,15 @@ function parseInlineRubrics(rawRubrics) {
 
 // src/evaluation/loaders/jsonl-parser.ts
 init_cjs_shims();
-var import_promises7 = require("fs/promises");
-var import_node_path7 = __toESM(require("path"), 1);
+var import_promises8 = require("fs/promises");
+var import_node_path8 = __toESM(require("path"), 1);
 var import_micromatch = __toESM(require("micromatch"), 1);
 var import_yaml3 = require("yaml");
 
 // src/evaluation/loaders/message-processor.ts
 init_cjs_shims();
-var import_promises6 = require("fs/promises");
-var import_node_path6 = __toESM(require("path"), 1);
+var import_promises7 = require("fs/promises");
+var import_node_path7 = __toESM(require("path"), 1);
 
 // src/evaluation/formatting/segment-formatter.ts
 init_cjs_shims();
@@ -4193,7 +4565,7 @@ var IMAGE_MEDIA_TYPES = {
   ".bmp": "image/bmp"
 };
 function detectImageMediaType(filePath) {
-  const ext = import_node_path6.default.extname(filePath).toLowerCase();
+  const ext = import_node_path7.default.extname(filePath).toLowerCase();
   return IMAGE_MEDIA_TYPES[ext];
 }
 var ANSI_YELLOW5 = "\x1B[33m";
@@ -4243,12 +4615,12 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const fileContent = (await (0, import_promises6.readFile)(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+          const fileContent = (await (0, import_promises7.readFile)(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
           processedContent.push({
             ...cloneJsonObject(rawSegment),
             path: displayPath,
             text: fileContent,
-            resolvedPath: import_node_path6.default.resolve(resolvedPath)
+            resolvedPath: import_node_path7.default.resolve(resolvedPath)
           });
           if (verbose) {
             const label = messageType === "input" ? "[File]" : "[Expected Output File]";
@@ -4284,7 +4656,7 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const imageBuffer = await (0, import_promises6.readFile)(resolvedPath);
+          const imageBuffer = await (0, import_promises7.readFile)(resolvedPath);
           const base64 = imageBuffer.toString("base64");
           processedContent.push({
             type: "image",
@@ -4361,12 +4733,12 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const fileContent = (await (0, import_promises6.readFile)(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+            const fileContent = (await (0, import_promises7.readFile)(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
             processedContent.push({
               type: "file",
               path: displayPath,
               text: fileContent,
-              resolvedPath: import_node_path6.default.resolve(resolvedPath)
+              resolvedPath: import_node_path7.default.resolve(resolvedPath)
             });
             if (verbose) {
               console.log(`  [Expected Output File] Found: ${displayPath}`);
@@ -4401,7 +4773,7 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const imageBuffer = await (0, import_promises6.readFile)(resolvedPath);
+            const imageBuffer = await (0, import_promises7.readFile)(resolvedPath);
             const base64 = imageBuffer.toString("base64");
             processedContent.push({
               type: "image",
@@ -4511,7 +4883,7 @@ function matchesFilter(id, filter) {
   return typeof filter === "string" ? import_micromatch.default.isMatch(id, filter) : filter.some((pattern) => import_micromatch.default.isMatch(id, pattern));
 }
 function detectFormat(filePath) {
-  const ext = import_node_path7.default.extname(filePath).toLowerCase();
+  const ext = import_node_path8.default.extname(filePath).toLowerCase();
   if (ext === ".jsonl") return "jsonl";
   if (ext === ".yaml" || ext === ".yml") return "yaml";
   if (ext === ".json") return "agent-skills-json";
@@ -4520,9 +4892,9 @@ function detectFormat(filePath) {
   );
 }
 async function loadSidecarMetadata(jsonlPath, verbose) {
-  const dir = import_node_path7.default.dirname(jsonlPath);
-  const base = import_node_path7.default.basename(jsonlPath, ".jsonl");
-  const sidecarPath = import_node_path7.default.join(dir, `${base}.yaml`);
+  const dir = import_node_path8.default.dirname(jsonlPath);
+  const base = import_node_path8.default.basename(jsonlPath, ".jsonl");
+  const sidecarPath = import_node_path8.default.join(dir, `${base}.yaml`);
   if (!await fileExists(sidecarPath)) {
     if (verbose) {
       logWarning4(`Sidecar metadata file not found: ${sidecarPath} (using defaults)`);
@@ -4530,7 +4902,7 @@ async function loadSidecarMetadata(jsonlPath, verbose) {
     return {};
   }
   try {
-    const content = await (0, import_promises7.readFile)(sidecarPath, "utf8");
+    const content = await (0, import_promises8.readFile)(sidecarPath, "utf8");
     const parsed = interpolateEnv((0, import_yaml3.parse)(content), process.env);
     if (!isJsonObject(parsed)) {
       logWarning4(`Invalid sidecar metadata format in ${sidecarPath}`);
@@ -4571,13 +4943,13 @@ function parseJsonlContent(content, filePath) {
 async function loadTestsFromJsonl(evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
   const filterPattern = options?.filter;
-  const absoluteTestPath = import_node_path7.default.resolve(evalFilePath);
+  const absoluteTestPath = import_node_path8.default.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots(absoluteTestPath, repoRootPath);
   const sidecar = await loadSidecarMetadata(absoluteTestPath, verbose);
-  const rawFile = await (0, import_promises7.readFile)(absoluteTestPath, "utf8");
+  const rawFile = await (0, import_promises8.readFile)(absoluteTestPath, "utf8");
   const rawCases = parseJsonlContent(rawFile, evalFilePath);
-  const fallbackSuiteName = import_node_path7.default.basename(absoluteTestPath, ".jsonl") || "eval";
+  const fallbackSuiteName = import_node_path8.default.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;
@@ -4939,8 +5311,8 @@ function resolveTests(suite) {
 }
 async function readTestSuiteMetadata(testFilePath) {
   try {
-    const absolutePath = import_node_path8.default.resolve(testFilePath);
-    const content = await (0, import_promises8.readFile)(absolutePath, "utf8");
+    const absolutePath = import_node_path9.default.resolve(testFilePath);
+    const content = await (0, import_promises9.readFile)(absolutePath, "utf8");
     const parsed = interpolateEnv((0, import_yaml4.parse)(content), process.env);
     if (!isJsonObject(parsed)) {
       return {};
@@ -4994,25 +5366,31 @@ var loadEvalCases = loadTests;
 async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
   const filterPattern = options?.filter;
-  const absoluteTestPath = import_node_path8.default.resolve(evalFilePath);
+  const absoluteTestPath = import_node_path9.default.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots(absoluteTestPath, repoRootPath);
   const config = await loadConfig(absoluteTestPath, repoRootPath);
-  const rawFile = await (0, import_promises8.readFile)(absoluteTestPath, "utf8");
+  const rawFile = await (0, import_promises9.readFile)(absoluteTestPath, "utf8");
   const interpolated = interpolateEnv((0, import_yaml4.parse)(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 = import_node_path8.default.basename(absoluteTestPath).replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "") || "eval";
+  const fallbackSuiteName = import_node_path9.default.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 = import_node_path8.default.dirname(absoluteTestPath);
+  const suitePreprocessors = await parsePreprocessors(
+    suite.preprocessors,
+    searchRoots,
+    "<suite>",
+    absoluteTestPath
+  );
+  const evalFileDir = import_node_path9.default.dirname(absoluteTestPath);
   let expandedTestCases;
   if (typeof rawTestCases === "string") {
-    const externalPath = import_node_path8.default.resolve(evalFileDir, rawTestCases);
+    const externalPath = import_node_path9.default.resolve(evalFileDir, rawTestCases);
     expandedTestCases = await loadCasesFromFile(externalPath);
   } else if (Array.isArray(rawTestCases)) {
     expandedTestCases = await expandFileReferences(rawTestCases, evalFileDir);
@@ -5110,7 +5488,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);
@@ -5143,6 +5522,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
       criteria: outcome ?? "",
       evaluator: testCaseEvaluatorKind,
       assertions: evaluators,
+      ...suitePreprocessors ? { preprocessors: suitePreprocessors } : {},
       workspace: mergedWorkspace,
       metadata,
       targets: caseTargets,
@@ -5183,8 +5563,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 && !import_node_path8.default.isAbsolute(cwd)) {
-    cwd = import_node_path8.default.resolve(evalFileDir, cwd);
+  if (cwd && !import_node_path9.default.isAbsolute(cwd)) {
+    cwd = import_node_path9.default.resolve(evalFileDir, cwd);
   }
   const config = { command };
   if (timeoutMs !== void 0) {
@@ -5222,10 +5602,10 @@ function parseWorkspaceHooksConfig(raw, evalFileDir) {
 }
 async function resolveWorkspaceConfig(raw, evalFileDir) {
   if (typeof raw === "string") {
-    const workspaceFilePath = import_node_path8.default.resolve(evalFileDir, raw);
+    const workspaceFilePath = import_node_path9.default.resolve(evalFileDir, raw);
     let content;
     try {
-      content = await (0, import_promises8.readFile)(workspaceFilePath, "utf8");
+      content = await (0, import_promises9.readFile)(workspaceFilePath, "utf8");
     } catch {
       throw new Error(`Workspace file not found: ${raw} (resolved to ${workspaceFilePath})`);
     }
@@ -5235,7 +5615,7 @@ async function resolveWorkspaceConfig(raw, evalFileDir) {
         `Invalid workspace file format: ${workspaceFilePath} (expected a YAML object)`
       );
     }
-    const workspaceFileDir = import_node_path8.default.dirname(workspaceFilePath);
+    const workspaceFileDir = import_node_path9.default.dirname(workspaceFilePath);
     return parseWorkspaceConfig(parsed, workspaceFileDir);
   }
   return parseWorkspaceConfig(raw, evalFileDir);
@@ -5255,8 +5635,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 && !import_node_path8.default.isAbsolute(template)) {
-    template = import_node_path8.default.resolve(evalFileDir, template);
+  if (template && !import_node_path9.default.isAbsolute(template)) {
+    template = import_node_path9.default.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;
@@ -5328,7 +5708,7 @@ ${detailBlock}${ANSI_RESET8}`);
 // src/evaluation/loaders/eval-yaml-transpiler.ts
 init_cjs_shims();
 var import_node_fs2 = require("fs");
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 var import_yaml5 = require("yaml");
 function codeGraderInstruction(graderName, description) {
   const desc = description ? ` This grader: ${description}.` : "";
@@ -5569,7 +5949,7 @@ function transpileEvalYaml(suite, source = "EVAL.yaml") {
 function transpileEvalYamlFile(evalYamlPath) {
   const content = (0, import_node_fs2.readFileSync)(evalYamlPath, "utf8");
   const parsed = (0, import_yaml5.parse)(content);
-  return transpileEvalYaml(parsed, import_node_path9.default.basename(evalYamlPath));
+  return transpileEvalYaml(parsed, import_node_path10.default.basename(evalYamlPath));
 }
 function getOutputFilenames(result) {
   const names = /* @__PURE__ */ new Map();
@@ -5589,11 +5969,11 @@ function getOutputFilenames(result) {
 // src/evaluation/file-utils.ts
 init_cjs_shims();
 var import_node_fs3 = require("fs");
-var import_promises9 = require("fs/promises");
-var import_node_path10 = __toESM(require("path"), 1);
+var import_promises10 = require("fs/promises");
+var import_node_path11 = __toESM(require("path"), 1);
 async function fileExists2(filePath) {
   try {
-    await (0, import_promises9.access)(filePath, import_node_fs3.constants.F_OK);
+    await (0, import_promises10.access)(filePath, import_node_fs3.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -5603,22 +5983,22 @@ function normalizeLineEndings(content) {
   return content.replace(/\r\n/g, "\n");
 }
 async function readTextFile(filePath) {
-  const content = await (0, import_promises9.readFile)(filePath, "utf8");
+  const content = await (0, import_promises10.readFile)(filePath, "utf8");
   return normalizeLineEndings(content);
 }
 async function readJsonFile(filePath) {
-  const content = await (0, import_promises9.readFile)(filePath, "utf8");
+  const content = await (0, import_promises10.readFile)(filePath, "utf8");
   return JSON.parse(content);
 }
 async function findGitRoot(startPath) {
-  let currentDir = import_node_path10.default.dirname(import_node_path10.default.resolve(startPath));
-  const root = import_node_path10.default.parse(currentDir).root;
+  let currentDir = import_node_path11.default.dirname(import_node_path11.default.resolve(startPath));
+  const root = import_node_path11.default.parse(currentDir).root;
   while (currentDir !== root) {
-    const gitPath = import_node_path10.default.join(currentDir, ".git");
+    const gitPath = import_node_path11.default.join(currentDir, ".git");
     if (await fileExists2(gitPath)) {
       return currentDir;
     }
-    const parentDir = import_node_path10.default.dirname(currentDir);
+    const parentDir = import_node_path11.default.dirname(currentDir);
     if (parentDir === currentDir) {
       break;
     }
@@ -5629,8 +6009,8 @@ async function findGitRoot(startPath) {
 function buildDirectoryChain2(filePath, repoRoot) {
   const directories = [];
   const seen = /* @__PURE__ */ new Set();
-  const boundary = import_node_path10.default.resolve(repoRoot);
-  let current = import_node_path10.default.resolve(import_node_path10.default.dirname(filePath));
+  const boundary = import_node_path11.default.resolve(repoRoot);
+  let current = import_node_path11.default.resolve(import_node_path11.default.dirname(filePath));
   while (current !== void 0) {
     if (!seen.has(current)) {
       directories.push(current);
@@ -5639,7 +6019,7 @@ function buildDirectoryChain2(filePath, repoRoot) {
     if (current === boundary) {
       break;
     }
-    const parent = import_node_path10.default.dirname(current);
+    const parent = import_node_path11.default.dirname(current);
     if (parent === current) {
       break;
     }
@@ -5653,16 +6033,16 @@ function buildDirectoryChain2(filePath, repoRoot) {
 function buildSearchRoots2(evalPath, repoRoot) {
   const uniqueRoots = [];
   const addRoot = (root) => {
-    const normalized = import_node_path10.default.resolve(root);
+    const normalized = import_node_path11.default.resolve(root);
     if (!uniqueRoots.includes(normalized)) {
       uniqueRoots.push(normalized);
     }
   };
-  let currentDir = import_node_path10.default.dirname(evalPath);
+  let currentDir = import_node_path11.default.dirname(evalPath);
   let reachedBoundary = false;
   while (!reachedBoundary) {
     addRoot(currentDir);
-    const parentDir = import_node_path10.default.dirname(currentDir);
+    const parentDir = import_node_path11.default.dirname(currentDir);
     if (currentDir === repoRoot || parentDir === currentDir) {
       reachedBoundary = true;
     } else {
@@ -5680,16 +6060,16 @@ function trimLeadingSeparators2(value) {
 async function resolveFileReference3(rawValue, searchRoots) {
   const displayPath = trimLeadingSeparators2(rawValue);
   const potentialPaths = [];
-  if (import_node_path10.default.isAbsolute(rawValue)) {
-    potentialPaths.push(import_node_path10.default.normalize(rawValue));
+  if (import_node_path11.default.isAbsolute(rawValue)) {
+    potentialPaths.push(import_node_path11.default.normalize(rawValue));
   }
   for (const base of searchRoots) {
-    potentialPaths.push(import_node_path10.default.resolve(base, displayPath));
+    potentialPaths.push(import_node_path11.default.resolve(base, displayPath));
   }
   const attempted = [];
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of potentialPaths) {
-    const absoluteCandidate = import_node_path10.default.resolve(candidate);
+    const absoluteCandidate = import_node_path11.default.resolve(candidate);
     if (seen.has(absoluteCandidate)) {
       continue;
     }
@@ -6128,8 +6508,8 @@ init_cjs_shims();
 var import_node_child_process = require("child_process");
 var import_node_crypto = require("crypto");
 var import_node_fs4 = require("fs");
-var import_promises10 = require("fs/promises");
-var import_node_path12 = __toESM(require("path"), 1);
+var import_promises11 = require("fs/promises");
+var import_node_path13 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/claude-content.ts
 init_cjs_shims();
@@ -6231,7 +6611,7 @@ function subscribeToClaudeLogEntries(listener) {
 
 // src/evaluation/providers/preread.ts
 init_cjs_shims();
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 function buildPromptDocument(request, inputFiles) {
   const parts = [];
   const inputFilesList = collectInputFiles(inputFiles);
@@ -6248,7 +6628,7 @@ function normalizeInputFiles(inputFiles) {
   }
   const deduped = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = import_node_path11.default.resolve(inputFile);
+    const absolutePath = import_node_path12.default.resolve(inputFile);
     if (!deduped.has(absolutePath)) {
       deduped.set(absolutePath, absolutePath);
     }
@@ -6261,7 +6641,7 @@ function collectInputFiles(inputFiles) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = import_node_path11.default.resolve(inputFile);
+    const absolutePath = import_node_path12.default.resolve(inputFile);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -6273,7 +6653,7 @@ function buildMandatoryPrereadBlock(inputFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = import_node_path11.default.basename(absolutePath);
+    const fileName = import_node_path12.default.basename(absolutePath);
     const fileUri = pathToFileUri(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -6289,7 +6669,7 @@ ${buildList(inputFiles).join("\n")}.`);
   return sections.join("\n");
 }
 function pathToFileUri(filePath) {
-  const absolutePath = import_node_path11.default.isAbsolute(filePath) ? filePath : import_node_path11.default.resolve(filePath);
+  const absolutePath = import_node_path12.default.isAbsolute(filePath) ? filePath : import_node_path12.default.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -6437,10 +6817,10 @@ var ClaudeCliProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return import_node_path12.default.resolve(cwdOverride);
+      return import_node_path13.default.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return import_node_path12.default.resolve(this.config.cwd);
+      return import_node_path13.default.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -6450,9 +6830,9 @@ var ClaudeCliProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return import_node_path12.default.resolve(this.config.logDir);
+      return import_node_path13.default.resolve(this.config.logDir);
     }
-    return import_node_path12.default.join(process.cwd(), ".agentv", "logs", "claude-cli");
+    return import_node_path13.default.join(process.cwd(), ".agentv", "logs", "claude-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -6460,13 +6840,13 @@ var ClaudeCliProvider = class {
       return void 0;
     }
     try {
-      await (0, import_promises10.mkdir)(logDir, { recursive: true });
+      await (0, import_promises11.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Claude CLI stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = import_node_path12.default.join(logDir, buildLogFilename(request, this.targetName));
+    const filePath = import_node_path13.default.join(logDir, buildLogFilename(request, this.targetName));
     try {
       const logger = await ClaudeCliStreamLogger.create({
         filePath,
@@ -6768,8 +7148,8 @@ function tryParseJson(line) {
 init_cjs_shims();
 var import_node_crypto2 = require("crypto");
 var import_node_fs5 = require("fs");
-var import_promises11 = require("fs/promises");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_promises12 = require("fs/promises");
+var import_node_path14 = __toESM(require("path"), 1);
 var claudeSdkModule = null;
 async function loadClaudeSdk() {
   if (!claudeSdkModule) {
@@ -6930,10 +7310,10 @@ var ClaudeSdkProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return import_node_path13.default.resolve(cwdOverride);
+      return import_node_path14.default.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return import_node_path13.default.resolve(this.config.cwd);
+      return import_node_path14.default.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -6943,9 +7323,9 @@ var ClaudeSdkProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return import_node_path13.default.resolve(this.config.logDir);
+      return import_node_path14.default.resolve(this.config.logDir);
     }
-    return import_node_path13.default.join(process.cwd(), ".agentv", "logs", "claude");
+    return import_node_path14.default.join(process.cwd(), ".agentv", "logs", "claude");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -6953,13 +7333,13 @@ var ClaudeSdkProvider = class {
       return void 0;
     }
     try {
-      await (0, import_promises11.mkdir)(logDir, { recursive: true });
+      await (0, import_promises12.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Claude stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = import_node_path13.default.join(logDir, buildLogFilename2(request, this.targetName));
+    const filePath = import_node_path14.default.join(logDir, buildLogFilename2(request, this.targetName));
     try {
       const logger = await ClaudeStreamLogger.create({
         filePath,
@@ -7146,9 +7526,9 @@ function formatElapsed2(startedAt) {
 // src/evaluation/providers/cli.ts
 init_cjs_shims();
 var import_node_child_process2 = require("child_process");
-var import_promises12 = __toESM(require("fs/promises"), 1);
+var import_promises13 = __toESM(require("fs/promises"), 1);
 var import_node_os = __toESM(require("os"), 1);
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 var import_node_util = require("util");
 var import_zod2 = require("zod");
 var ToolCallSchema = import_zod2.z.object({
@@ -7545,7 +7925,7 @@ var CliProvider = class {
       throw new Error(`Failed to read output file '${filePath}': ${errorMsg}`);
     } finally {
       if (!this.keepTempFiles) {
-        await import_promises12.default.unlink(filePath).catch(() => {
+        await import_promises13.default.unlink(filePath).catch(() => {
         });
       }
     }
@@ -7625,7 +8005,7 @@ var CliProvider = class {
 async function buildTemplateValues(request, config, outputFilePath) {
   const inputFiles = normalizeInputFiles2(request.inputFiles);
   const promptFilePath = generateOutputFilePath(request.evalCaseId, ".prompt.txt");
-  await import_promises12.default.writeFile(promptFilePath, request.question ?? "", "utf8");
+  await import_promises13.default.writeFile(promptFilePath, request.question ?? "", "utf8");
   return {
     values: {
       PROMPT: shellEscape(request.question ?? ""),
@@ -7642,7 +8022,7 @@ async function cleanupTempFile(filePath, keepTempFiles) {
   if (!filePath || keepTempFiles) {
     return;
   }
-  await import_promises12.default.unlink(filePath).catch(() => {
+  await import_promises13.default.unlink(filePath).catch(() => {
   });
 }
 function normalizeInputFiles2(inputFiles) {
@@ -7651,7 +8031,7 @@ function normalizeInputFiles2(inputFiles) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = import_node_path14.default.resolve(inputFile);
+    const absolutePath = import_node_path15.default.resolve(inputFile);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -7665,7 +8045,7 @@ function formatFileList(files, template) {
   const formatter = template ?? "{path}";
   return files.map((filePath) => {
     const escapedPath = shellEscape(filePath);
-    const escapedName = shellEscape(import_node_path14.default.basename(filePath));
+    const escapedName = shellEscape(import_node_path15.default.basename(filePath));
     return formatter.replaceAll("{path}", escapedPath).replaceAll("{basename}", escapedName);
   }).join(" ");
 }
@@ -7689,7 +8069,7 @@ function generateOutputFilePath(evalCaseId, extension = ".json") {
   const safeEvalId = evalCaseId || "unknown";
   const timestamp = Date.now();
   const random = Math.random().toString(36).substring(2, 9);
-  return import_node_path14.default.join(import_node_os.default.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
+  return import_node_path15.default.join(import_node_os.default.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
 }
 function formatTimeoutSuffix2(timeoutMs) {
   if (!timeoutMs || timeoutMs <= 0) {
@@ -7703,8 +8083,8 @@ function formatTimeoutSuffix2(timeoutMs) {
 init_cjs_shims();
 var import_node_crypto3 = require("crypto");
 var import_node_fs6 = require("fs");
-var import_promises13 = require("fs/promises");
-var import_node_path15 = __toESM(require("path"), 1);
+var import_promises14 = require("fs/promises");
+var import_node_path16 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/codex-log-tracker.ts
 init_cjs_shims();
@@ -7940,10 +8320,10 @@ ${basePrompt}` : basePrompt;
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return import_node_path15.default.resolve(cwdOverride);
+      return import_node_path16.default.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return import_node_path15.default.resolve(this.config.cwd);
+      return import_node_path16.default.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -7953,9 +8333,9 @@ ${basePrompt}` : basePrompt;
       return void 0;
     }
     if (this.config.logDir) {
-      return import_node_path15.default.resolve(this.config.logDir);
+      return import_node_path16.default.resolve(this.config.logDir);
     }
-    return import_node_path15.default.join(process.cwd(), ".agentv", "logs", "codex");
+    return import_node_path16.default.join(process.cwd(), ".agentv", "logs", "codex");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -7963,13 +8343,13 @@ ${basePrompt}` : basePrompt;
       return void 0;
     }
     try {
-      await (0, import_promises13.mkdir)(logDir, { recursive: true });
+      await (0, import_promises14.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Codex SDK stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = import_node_path15.default.join(logDir, buildLogFilename3(request, this.targetName));
+    const filePath = import_node_path16.default.join(logDir, buildLogFilename3(request, this.targetName));
     try {
       const logger = await CodexSdkStreamLogger.create({
         filePath,
@@ -8113,8 +8493,8 @@ function formatElapsed3(startedAt) {
 // src/evaluation/providers/copilot-cli.ts
 init_cjs_shims();
 var import_node_crypto5 = require("crypto");
-var import_promises14 = require("fs/promises");
-var import_node_path17 = __toESM(require("path"), 1);
+var import_promises15 = require("fs/promises");
+var import_node_path18 = __toESM(require("path"), 1);
 var import_node_stream = require("stream");
 var import_node_child_process3 = require("child_process");
 var acp = __toESM(require("@agentclientprotocol/sdk"), 1);
@@ -8178,8 +8558,8 @@ init_cjs_shims();
 var import_node_crypto4 = require("crypto");
 var import_node_fs7 = require("fs");
 var import_node_os2 = require("os");
-var import_node_path16 = __toESM(require("path"), 1);
-var import_node_url2 = require("url");
+var import_node_path17 = __toESM(require("path"), 1);
+var import_node_url3 = require("url");
 var import_meta = {};
 function resolvePlatformCliPath() {
   const os3 = (0, import_node_os2.platform)();
@@ -8202,8 +8582,8 @@ function resolvePlatformCliPath() {
   const binaryName = os3 === "win32" ? "copilot.exe" : "copilot";
   try {
     const resolved = import_meta.resolve(`${packageName}/package.json`);
-    const packageJsonPath = resolved.startsWith("file:") ? (0, import_node_url2.fileURLToPath)(resolved) : resolved;
-    const binaryPath = import_node_path16.default.join(import_node_path16.default.dirname(packageJsonPath), binaryName);
+    const packageJsonPath = resolved.startsWith("file:") ? (0, import_node_url3.fileURLToPath)(resolved) : resolved;
+    const binaryPath = import_node_path17.default.join(import_node_path17.default.dirname(packageJsonPath), binaryName);
     if ((0, import_node_fs7.existsSync)(binaryPath)) {
       return binaryPath;
     }
@@ -8211,7 +8591,7 @@ function resolvePlatformCliPath() {
   }
   let searchDir = process.cwd();
   for (let i = 0; i < 10; i++) {
-    const standardPath = import_node_path16.default.join(
+    const standardPath = import_node_path17.default.join(
       searchDir,
       "node_modules",
       ...packageName.split("/"),
@@ -8220,13 +8600,13 @@ function resolvePlatformCliPath() {
     if ((0, import_node_fs7.existsSync)(standardPath)) {
       return standardPath;
     }
-    const bunDir = import_node_path16.default.join(searchDir, "node_modules", ".bun");
+    const bunDir = import_node_path17.default.join(searchDir, "node_modules", ".bun");
     const prefix = `@github+copilot-${osPart}-${archPart}@`;
     try {
       const entries = (0, import_node_fs7.readdirSync)(bunDir);
       for (const entry of entries) {
         if (entry.startsWith(prefix)) {
-          const candidate = import_node_path16.default.join(
+          const candidate = import_node_path17.default.join(
             bunDir,
             entry,
             "node_modules",
@@ -8241,7 +8621,7 @@ function resolvePlatformCliPath() {
       }
     } catch {
     }
-    const parent = import_node_path16.default.dirname(searchDir);
+    const parent = import_node_path17.default.dirname(searchDir);
     if (parent === searchDir) break;
     searchDir = parent;
   }
@@ -8585,10 +8965,10 @@ var CopilotCliProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return import_node_path17.default.resolve(cwdOverride);
+      return import_node_path18.default.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return import_node_path17.default.resolve(this.config.cwd);
+      return import_node_path18.default.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -8607,9 +8987,9 @@ var CopilotCliProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return import_node_path17.default.resolve(this.config.logDir);
+      return import_node_path18.default.resolve(this.config.logDir);
     }
-    return import_node_path17.default.join(process.cwd(), ".agentv", "logs", "copilot-cli");
+    return import_node_path18.default.join(process.cwd(), ".agentv", "logs", "copilot-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -8617,13 +8997,13 @@ var CopilotCliProvider = class {
       return void 0;
     }
     try {
-      await (0, import_promises14.mkdir)(logDir, { recursive: true });
+      await (0, import_promises15.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Copilot CLI stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = import_node_path17.default.join(logDir, buildLogFilename4(request, this.targetName, "copilot-cli"));
+    const filePath = import_node_path18.default.join(logDir, buildLogFilename4(request, this.targetName, "copilot-cli"));
     try {
       const logger = await CopilotStreamLogger.create(
         {
@@ -8717,9 +9097,9 @@ function summarizeAcpEvent(eventType, data) {
 
 // src/evaluation/providers/copilot-log.ts
 init_cjs_shims();
-var import_promises16 = require("fs/promises");
+var import_promises17 = require("fs/promises");
 var import_node_os4 = require("os");
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_path20 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/copilot-log-parser.ts
 init_cjs_shims();
@@ -8853,32 +9233,32 @@ function parseCopilotEvents(eventsJsonl) {
 
 // src/evaluation/providers/copilot-session-discovery.ts
 init_cjs_shims();
-var import_promises15 = require("fs/promises");
+var import_promises16 = require("fs/promises");
 var import_node_os3 = require("os");
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_path19 = __toESM(require("path"), 1);
 var import_yaml6 = require("yaml");
-var DEFAULT_SESSION_STATE_DIR = () => import_node_path18.default.join((0, import_node_os3.homedir)(), ".copilot", "session-state");
+var DEFAULT_SESSION_STATE_DIR = () => import_node_path19.default.join((0, import_node_os3.homedir)(), ".copilot", "session-state");
 async function discoverCopilotSessions(opts) {
   const sessionStateDir = opts?.sessionStateDir ?? DEFAULT_SESSION_STATE_DIR();
   const limit = opts?.limit ?? 10;
   let entries;
   try {
-    entries = await (0, import_promises15.readdir)(sessionStateDir);
+    entries = await (0, import_promises16.readdir)(sessionStateDir);
   } catch {
     return [];
   }
   const sessions = [];
   for (const entry of entries) {
-    const sessionDir = import_node_path18.default.join(sessionStateDir, entry);
-    const workspacePath = import_node_path18.default.join(sessionDir, "workspace.yaml");
-    const eventsPath = import_node_path18.default.join(sessionDir, "events.jsonl");
+    const sessionDir = import_node_path19.default.join(sessionStateDir, entry);
+    const workspacePath = import_node_path19.default.join(sessionDir, "workspace.yaml");
+    const eventsPath = import_node_path19.default.join(sessionDir, "events.jsonl");
     try {
-      const workspaceContent = await (0, import_promises15.readFile)(workspacePath, "utf8");
+      const workspaceContent = await (0, import_promises16.readFile)(workspacePath, "utf8");
       const workspace = (0, import_yaml6.parse)(workspaceContent) ?? {};
       const cwd = String(workspace.cwd ?? "");
       let updatedAt;
       try {
-        const eventsStat = await (0, import_promises15.stat)(eventsPath);
+        const eventsStat = await (0, import_promises16.stat)(eventsPath);
         updatedAt = eventsStat.mtime;
       } catch {
         updatedAt = /* @__PURE__ */ new Date(0);
@@ -8932,10 +9312,10 @@ var CopilotLogProvider = class {
   }
   async invoke(_request) {
     const sessionDir = await this.resolveSessionDir();
-    const eventsPath = import_node_path19.default.join(sessionDir, "events.jsonl");
+    const eventsPath = import_node_path20.default.join(sessionDir, "events.jsonl");
     let eventsContent;
     try {
-      eventsContent = await (0, import_promises16.readFile)(eventsPath, "utf8");
+      eventsContent = await (0, import_promises17.readFile)(eventsPath, "utf8");
     } catch (err) {
       throw new Error(
         `Failed to read Copilot session transcript at ${eventsPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -8954,8 +9334,8 @@ var CopilotLogProvider = class {
       return this.config.sessionDir;
     }
     if (this.config.sessionId) {
-      const stateDir = this.config.sessionStateDir ?? import_node_path19.default.join((0, import_node_os4.homedir)(), ".copilot", "session-state");
-      return import_node_path19.default.join(stateDir, this.config.sessionId);
+      const stateDir = this.config.sessionStateDir ?? import_node_path20.default.join((0, import_node_os4.homedir)(), ".copilot", "session-state");
+      return import_node_path20.default.join(stateDir, this.config.sessionId);
     }
     if (this.config.discover === "latest") {
       const sessions = await discoverCopilotSessions({
@@ -8980,8 +9360,8 @@ var CopilotLogProvider = class {
 init_cjs_shims();
 var import_node_crypto6 = require("crypto");
 var import_node_fs8 = require("fs");
-var import_promises17 = require("fs/promises");
-var import_node_path20 = __toESM(require("path"), 1);
+var import_promises18 = require("fs/promises");
+var import_node_path21 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/copilot-sdk-log-tracker.ts
 init_cjs_shims();
@@ -9292,10 +9672,10 @@ var CopilotSdkProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return import_node_path20.default.resolve(cwdOverride);
+      return import_node_path21.default.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return import_node_path20.default.resolve(this.config.cwd);
+      return import_node_path21.default.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -9304,9 +9684,9 @@ var CopilotSdkProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return import_node_path20.default.resolve(this.config.logDir);
+      return import_node_path21.default.resolve(this.config.logDir);
     }
-    return import_node_path20.default.join(process.cwd(), ".agentv", "logs", "copilot-sdk");
+    return import_node_path21.default.join(process.cwd(), ".agentv", "logs", "copilot-sdk");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -9314,13 +9694,13 @@ var CopilotSdkProvider = class {
       return void 0;
     }
     try {
-      await (0, import_promises17.mkdir)(logDir, { recursive: true });
+      await (0, import_promises18.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Copilot SDK stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = import_node_path20.default.join(logDir, buildLogFilename4(request, this.targetName, "copilot-sdk"));
+    const filePath = import_node_path21.default.join(logDir, buildLogFilename4(request, this.targetName, "copilot-sdk"));
     try {
       const logger = await CopilotStreamLogger.create(
         {
@@ -9349,9 +9729,9 @@ var CopilotSdkProvider = class {
 };
 function resolveSkillDirectories(cwd) {
   const candidates = [
-    import_node_path20.default.join(cwd, ".claude", "skills"),
-    import_node_path20.default.join(cwd, ".agents", "skills"),
-    import_node_path20.default.join(cwd, ".codex", "skills")
+    import_node_path21.default.join(cwd, ".claude", "skills"),
+    import_node_path21.default.join(cwd, ".agents", "skills"),
+    import_node_path21.default.join(cwd, ".codex", "skills")
   ];
   return candidates.filter((dir) => (0, import_node_fs8.existsSync)(dir));
 }
@@ -9435,9 +9815,9 @@ init_cjs_shims();
 var import_node_child_process4 = require("child_process");
 var import_node_crypto7 = require("crypto");
 var import_node_fs9 = require("fs");
-var import_promises18 = require("fs/promises");
+var import_promises19 = require("fs/promises");
 var import_node_os5 = require("os");
-var import_node_path21 = __toESM(require("path"), 1);
+var import_node_path22 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/pi-log-tracker.ts
 init_cjs_shims();
@@ -9646,8 +10026,8 @@ var PiCliProvider = class {
     const cwd = this.resolveCwd(workspaceRoot, request.cwd);
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
-      const promptFile = import_node_path21.default.join(cwd, PROMPT_FILENAME);
-      await (0, import_promises18.writeFile)(promptFile, request.question, "utf8");
+      const promptFile = import_node_path22.default.join(cwd, PROMPT_FILENAME);
+      await (0, import_promises19.writeFile)(promptFile, request.question, "utf8");
       const args = this.buildPiArgs(request.question, inputFiles);
       const result = await this.executePi(args, cwd, request.signal, logger);
       if (result.timedOut) {
@@ -9709,10 +10089,10 @@ var PiCliProvider = class {
   }
   resolveCwd(workspaceRoot, cwdOverride) {
     if (cwdOverride) {
-      return import_node_path21.default.resolve(cwdOverride);
+      return import_node_path22.default.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return import_node_path21.default.resolve(this.config.cwd);
+      return import_node_path22.default.resolve(this.config.cwd);
     }
     if (workspaceRoot) {
       return workspaceRoot;
@@ -9818,19 +10198,19 @@ ${prompt}` : prompt;
     return env;
   }
   async createWorkspace() {
-    return await (0, import_promises18.mkdtemp)(import_node_path21.default.join((0, import_node_os5.tmpdir)(), WORKSPACE_PREFIX));
+    return await (0, import_promises19.mkdtemp)(import_node_path22.default.join((0, import_node_os5.tmpdir)(), WORKSPACE_PREFIX));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
-      await (0, import_promises18.rm)(workspaceRoot, { recursive: true, force: true });
+      await (0, import_promises19.rm)(workspaceRoot, { recursive: true, force: true });
     } catch {
     }
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return import_node_path21.default.resolve(this.config.logDir);
+      return import_node_path22.default.resolve(this.config.logDir);
     }
-    return import_node_path21.default.join(process.cwd(), ".agentv", "logs", "pi-cli");
+    return import_node_path22.default.join(process.cwd(), ".agentv", "logs", "pi-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -9838,13 +10218,13 @@ ${prompt}` : prompt;
       return void 0;
     }
     try {
-      await (0, import_promises18.mkdir)(logDir, { recursive: true });
+      await (0, import_promises19.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = import_node_path21.default.join(logDir, buildLogFilename5(request, this.targetName));
+    const filePath = import_node_path22.default.join(logDir, buildLogFilename5(request, this.targetName));
     try {
       const logger = await PiStreamLogger.create({
         filePath,
@@ -10315,8 +10695,8 @@ function resolveWindowsCmd(executable) {
     const content = (0, import_node_fs9.readFileSync)(cmdPath, "utf-8");
     const match = content.match(/"?%_prog%"?\s+"([^"]+\.js)"/);
     if (match) {
-      const dp0 = import_node_path21.default.dirname(import_node_path21.default.resolve(cmdPath));
-      const scriptPath = match[1].replace(/%dp0%[/\\]?/gi, `${dp0}${import_node_path21.default.sep}`);
+      const dp0 = import_node_path22.default.dirname(import_node_path22.default.resolve(cmdPath));
+      const scriptPath = match[1].replace(/%dp0%[/\\]?/gi, `${dp0}${import_node_path22.default.sep}`);
       try {
         (0, import_node_fs9.accessSync)(scriptPath);
         return ["node", [scriptPath]];
@@ -10395,15 +10775,15 @@ init_cjs_shims();
 var import_node_child_process5 = require("child_process");
 var import_node_crypto8 = require("crypto");
 var import_node_fs10 = require("fs");
-var import_promises19 = require("fs/promises");
-var import_node_path23 = __toESM(require("path"), 1);
+var import_promises20 = require("fs/promises");
+var import_node_path24 = __toESM(require("path"), 1);
 var import_node_readline = require("readline");
-var import_node_url3 = require("url");
+var import_node_url4 = require("url");
 
 // src/paths.ts
 init_cjs_shims();
 var import_node_os6 = __toESM(require("os"), 1);
-var import_node_path22 = __toESM(require("path"), 1);
+var import_node_path23 = __toESM(require("path"), 1);
 var logged = false;
 function getAgentvHome() {
   const envHome = process.env.AGENTV_HOME;
@@ -10414,19 +10794,19 @@ function getAgentvHome() {
     }
     return envHome;
   }
-  return import_node_path22.default.join(import_node_os6.default.homedir(), ".agentv");
+  return import_node_path23.default.join(import_node_os6.default.homedir(), ".agentv");
 }
 function getWorkspacesRoot() {
-  return import_node_path22.default.join(getAgentvHome(), "workspaces");
+  return import_node_path23.default.join(getAgentvHome(), "workspaces");
 }
 function getSubagentsRoot() {
-  return import_node_path22.default.join(getAgentvHome(), "subagents");
+  return import_node_path23.default.join(getAgentvHome(), "subagents");
 }
 function getTraceStateRoot() {
-  return import_node_path22.default.join(getAgentvHome(), "trace-state");
+  return import_node_path23.default.join(getAgentvHome(), "trace-state");
 }
 function getWorkspacePoolRoot() {
-  return import_node_path22.default.join(getAgentvHome(), "workspace-pool");
+  return import_node_path23.default.join(getAgentvHome(), "workspace-pool");
 }
 
 // src/evaluation/providers/pi-coding-agent.ts
@@ -10448,7 +10828,7 @@ async function promptInstall() {
   }
 }
 function findManagedSdkInstallRoot() {
-  return import_node_path23.default.join(getAgentvHome(), "deps", "pi-sdk");
+  return import_node_path24.default.join(getAgentvHome(), "deps", "pi-sdk");
 }
 function resolveGlobalNpmRoot() {
   try {
@@ -10462,7 +10842,7 @@ function resolveGlobalNpmRoot() {
   }
 }
 function buildGlobalModuleEntry(moduleName, globalNpmRoot) {
-  return import_node_path23.default.join(globalNpmRoot, ...moduleName.split("/"), "dist", "index.js");
+  return import_node_path24.default.join(globalNpmRoot, ...moduleName.split("/"), "dist", "index.js");
 }
 function findAccessiblePath(paths) {
   for (const candidate of paths) {
@@ -10488,11 +10868,11 @@ async function tryImportLocalSdkModules() {
 async function tryImportManagedSdkModules() {
   const managedRoot = findManagedSdkInstallRoot();
   const piCodingAgentEntry = findAccessiblePath([
-    import_node_path23.default.join(managedRoot, "node_modules", "@mariozechner", "pi-coding-agent", "dist", "index.js")
+    import_node_path24.default.join(managedRoot, "node_modules", "@mariozechner", "pi-coding-agent", "dist", "index.js")
   ]);
   const piAiEntry = findAccessiblePath([
-    import_node_path23.default.join(managedRoot, "node_modules", "@mariozechner", "pi-ai", "dist", "index.js"),
-    import_node_path23.default.join(
+    import_node_path24.default.join(managedRoot, "node_modules", "@mariozechner", "pi-ai", "dist", "index.js"),
+    import_node_path24.default.join(
       managedRoot,
       "node_modules",
       "@mariozechner",
@@ -10507,8 +10887,8 @@ async function tryImportManagedSdkModules() {
   if (!piCodingAgentEntry || !piAiEntry) return false;
   try {
     [piCodingAgentModule, piAiModule] = await Promise.all([
-      import((0, import_node_url3.pathToFileURL)(piCodingAgentEntry).href),
-      import((0, import_node_url3.pathToFileURL)(piAiEntry).href)
+      import((0, import_node_url4.pathToFileURL)(piCodingAgentEntry).href),
+      import((0, import_node_url4.pathToFileURL)(piAiEntry).href)
     ]);
     return true;
   } catch {
@@ -10523,7 +10903,7 @@ async function tryImportGlobalSdkModules() {
   ]);
   const piAiEntry = findAccessiblePath([
     buildGlobalModuleEntry("@mariozechner/pi-ai", globalNpmRoot),
-    import_node_path23.default.join(
+    import_node_path24.default.join(
       globalNpmRoot,
       "@mariozechner",
       "pi-coding-agent",
@@ -10537,8 +10917,8 @@ async function tryImportGlobalSdkModules() {
   if (!piCodingAgentEntry || !piAiEntry) return false;
   try {
     [piCodingAgentModule, piAiModule] = await Promise.all([
-      import((0, import_node_url3.pathToFileURL)(piCodingAgentEntry).href),
-      import((0, import_node_url3.pathToFileURL)(piAiEntry).href)
+      import((0, import_node_url4.pathToFileURL)(piCodingAgentEntry).href),
+      import((0, import_node_url4.pathToFileURL)(piAiEntry).href)
     ]);
     return true;
   } catch {
@@ -10824,10 +11204,10 @@ ${fileList}`;
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return import_node_path23.default.resolve(cwdOverride);
+      return import_node_path24.default.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return import_node_path23.default.resolve(this.config.cwd);
+      return import_node_path24.default.resolve(this.config.cwd);
     }
     return process.cwd();
   }
@@ -10846,9 +11226,9 @@ ${fileList}`;
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return import_node_path23.default.resolve(this.config.logDir);
+      return import_node_path24.default.resolve(this.config.logDir);
     }
-    return import_node_path23.default.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
+    return import_node_path24.default.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -10856,13 +11236,13 @@ ${fileList}`;
       return void 0;
     }
     try {
-      await (0, import_promises19.mkdir)(logDir, { recursive: true });
+      await (0, import_promises20.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = import_node_path23.default.join(logDir, buildLogFilename6(request, this.targetName));
+    const filePath = import_node_path24.default.join(logDir, buildLogFilename6(request, this.targetName));
     try {
       const logger = await PiStreamLogger2.create({
         filePath,
@@ -11077,7 +11457,7 @@ var ProviderRegistry = class {
 
 // src/evaluation/providers/targets.ts
 init_cjs_shims();
-var import_node_path24 = __toESM(require("path"), 1);
+var import_node_path25 = __toESM(require("path"), 1);
 var import_zod3 = require("zod");
 var CliHealthcheckHttpInputSchema = import_zod3.z.object({
   url: import_zod3.z.string().min(1, "healthcheck URL is required"),
@@ -11164,11 +11544,11 @@ function normalizeCliHealthcheck(input, env, targetName, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !import_node_path24.default.isAbsolute(cwd)) {
-    cwd = import_node_path24.default.resolve(import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !import_node_path25.default.isAbsolute(cwd)) {
+    cwd = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), cwd);
   }
   if (!cwd && evalFilePath) {
-    cwd = import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath));
+    cwd = import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath));
   }
   return {
     command,
@@ -11191,15 +11571,15 @@ function normalizeCliTargetInput(input, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path24.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path24.default.resolve(import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
   }
   let cwd = resolveOptionalString(input.cwd, env, `${targetName} working directory`, {
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !import_node_path24.default.isAbsolute(cwd)) {
-    cwd = import_node_path24.default.resolve(import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !import_node_path25.default.isAbsolute(cwd)) {
+    cwd = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), cwd);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -11207,7 +11587,7 @@ function normalizeCliTargetInput(input, env, evalFilePath) {
     );
   }
   if (!cwd && !workspaceTemplate && evalFilePath) {
-    cwd = import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath));
+    cwd = import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath));
   }
   const timeoutSeconds = input.timeout_seconds;
   const timeoutMs = timeoutSeconds !== void 0 ? Math.floor(timeoutSeconds * 1e3) : void 0;
@@ -11759,8 +12139,8 @@ function resolveCodexConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path24.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path24.default.resolve(import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -11844,8 +12224,8 @@ function resolveCopilotSdkConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path24.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path24.default.resolve(import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -11961,8 +12341,8 @@ function resolveCopilotCliConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path24.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path24.default.resolve(import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -12055,8 +12435,8 @@ function resolvePiCodingAgentConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path24.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path24.default.resolve(import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -12141,8 +12521,8 @@ function resolvePiCliConfig(target, env, evalFilePath) {
     `${target.name} pi-cli workspace template`,
     { allowLiteral: true, optionalEnv: true }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path24.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path24.default.resolve(import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(`${target.name}: 'cwd' and 'workspace_template' are mutually exclusive.`);
@@ -12196,8 +12576,8 @@ function resolveClaudeConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path24.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path24.default.resolve(import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -12253,8 +12633,8 @@ function resolveVSCodeConfig(target, env, insiders, evalFilePath) {
       optionalEnv: true
     }
   ) : void 0;
-  if (workspaceTemplate && evalFilePath && !import_node_path24.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path24.default.resolve(import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
   }
   const executableSource = target.executable;
   const waitSource = target.wait;
@@ -12295,8 +12675,8 @@ function resolveCliConfig(target, env, evalFilePath) {
   const parseResult = CliTargetInputSchema.safeParse(target, { errorMap: cliErrorMap });
   if (!parseResult.success) {
     const firstError = parseResult.error.errors[0];
-    const path54 = firstError?.path.join(".") || "";
-    const prefix = path54 ? `${target.name} ${path54}: ` : `${target.name}: `;
+    const path55 = firstError?.path.join(".") || "";
+    const prefix = path55 ? `${target.name} ${path55}: ` : `${target.name}: `;
     throw new Error(`${prefix}${firstError?.message}`);
   }
   const normalized = normalizeCliTargetInput(parseResult.data, env, evalFilePath);
@@ -12317,11 +12697,11 @@ function resolveDiscoveredProviderConfig(target, providerKind, env, evalFilePath
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !import_node_path24.default.isAbsolute(cwd)) {
-    cwd = import_node_path24.default.resolve(import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !import_node_path25.default.isAbsolute(cwd)) {
+    cwd = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), cwd);
   }
   if (!cwd && evalFilePath) {
-    cwd = import_node_path24.default.dirname(import_node_path24.default.resolve(evalFilePath));
+    cwd = import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath));
   }
   return {
     command,
@@ -12543,8 +12923,8 @@ function resolveOptionalNumberArray(source, description) {
 // src/evaluation/providers/vscode-provider.ts
 init_cjs_shims();
 var import_node_child_process7 = require("child_process");
-var import_promises26 = require("fs/promises");
-var import_node_path35 = __toESM(require("path"), 1);
+var import_promises27 = require("fs/promises");
+var import_node_path36 = __toESM(require("path"), 1);
 var import_node_util3 = require("util");
 
 // src/evaluation/providers/vscode/index.ts
@@ -12552,36 +12932,36 @@ init_cjs_shims();
 
 // src/evaluation/providers/vscode/dispatch/agentDispatch.ts
 init_cjs_shims();
-var import_promises24 = require("fs/promises");
-var import_node_path33 = __toESM(require("path"), 1);
+var import_promises25 = require("fs/promises");
+var import_node_path34 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/fs.ts
 init_cjs_shims();
 var import_node_fs11 = require("fs");
-var import_promises20 = require("fs/promises");
-var import_node_path25 = __toESM(require("path"), 1);
+var import_promises21 = require("fs/promises");
+var import_node_path26 = __toESM(require("path"), 1);
 async function pathExists(target) {
   try {
-    await (0, import_promises20.access)(target, import_node_fs11.constants.F_OK);
+    await (0, import_promises21.access)(target, import_node_fs11.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function ensureDir(target) {
-  await (0, import_promises20.mkdir)(target, { recursive: true });
+  await (0, import_promises21.mkdir)(target, { recursive: true });
 }
 async function readDirEntries(target) {
-  const entries = await (0, import_promises20.readdir)(target, { withFileTypes: true });
+  const entries = await (0, import_promises21.readdir)(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    absolutePath: import_node_path25.default.join(target, entry.name),
+    absolutePath: import_node_path26.default.join(target, entry.name),
     isDirectory: entry.isDirectory()
   }));
 }
 async function removeIfExists(target) {
   try {
-    await (0, import_promises20.rm)(target, { force: true, recursive: false });
+    await (0, import_promises21.rm)(target, { force: true, recursive: false });
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
@@ -12591,9 +12971,9 @@ async function removeIfExists(target) {
 
 // src/evaluation/providers/vscode/utils/path.ts
 init_cjs_shims();
-var import_node_path26 = __toESM(require("path"), 1);
+var import_node_path27 = __toESM(require("path"), 1);
 function pathToFileUri2(filePath) {
-  const absolutePath = import_node_path26.default.isAbsolute(filePath) ? filePath : import_node_path26.default.resolve(filePath);
+  const absolutePath = import_node_path27.default.isAbsolute(filePath) ? filePath : import_node_path27.default.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -12603,7 +12983,7 @@ function pathToFileUri2(filePath) {
 
 // src/evaluation/providers/vscode/dispatch/promptBuilder.ts
 init_cjs_shims();
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_path28 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/template.ts
 init_cjs_shims();
@@ -12697,8 +13077,8 @@ function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal,
   });
 }
 function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateContent) {
-  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${import_node_path27.default.basename(file)}`).join("\n");
-  const responseList = responseFiles.map((file) => `"${import_node_path27.default.basename(file)}"`).join(", ");
+  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${import_node_path28.default.basename(file)}`).join("\n");
+  const responseList = responseFiles.map((file) => `"${import_node_path28.default.basename(file)}"`).join(", ");
   return renderTemplate2(templateContent, {
     requestFiles: requestLines,
     responseList
@@ -12707,8 +13087,8 @@ function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateCont
 
 // src/evaluation/providers/vscode/dispatch/responseWaiter.ts
 init_cjs_shims();
-var import_promises21 = require("fs/promises");
-var import_node_path28 = __toESM(require("path"), 1);
+var import_promises22 = require("fs/promises");
+var import_node_path29 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/time.ts
 init_cjs_shims();
@@ -12747,7 +13127,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     try {
-      const content = await (0, import_promises21.readFile)(responseFileFinal, { encoding: "utf8" });
+      const content = await (0, import_promises22.readFile)(responseFileFinal, { encoding: "utf8" });
       if (!silent) {
         process.stdout.write(`${content}
 `);
@@ -12768,7 +13148,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) => import_node_path28.default.basename(file)).join(", ");
+    const fileList = responseFilesFinal.map((file) => import_node_path29.default.basename(file)).join(", ");
     console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
   }
   const deadline = Date.now() + timeoutMs;
@@ -12777,7 +13157,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     while (pending.size > 0) {
       if (Date.now() >= deadline) {
         if (!silent) {
-          const remaining = [...pending].map((f) => import_node_path28.default.basename(f)).join(", ");
+          const remaining = [...pending].map((f) => import_node_path29.default.basename(f)).join(", ");
           console.error(
             `error: timed out after ${Math.round(timeoutMs / 1e3)}s waiting for batch responses. Still pending: ${remaining}`
           );
@@ -12804,7 +13184,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     const maxAttempts = 10;
     while (attempts < maxAttempts) {
       try {
-        const content = await (0, import_promises21.readFile)(file, { encoding: "utf8" });
+        const content = await (0, import_promises22.readFile)(file, { encoding: "utf8" });
         if (!silent) {
           process.stdout.write(`${content}
 `);
@@ -12828,18 +13208,18 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
 init_cjs_shims();
 var import_node_child_process6 = require("child_process");
-var import_promises22 = require("fs/promises");
-var import_node_path30 = __toESM(require("path"), 1);
+var import_promises23 = require("fs/promises");
+var import_node_path31 = __toESM(require("path"), 1);
 var import_node_util2 = require("util");
 
 // src/evaluation/providers/vscode/dispatch/constants.ts
 init_cjs_shims();
-var import_node_path29 = __toESM(require("path"), 1);
+var import_node_path30 = __toESM(require("path"), 1);
 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 import_node_path29.default.join(getSubagentsRoot(), folder);
+  return import_node_path30.default.join(getSubagentsRoot(), folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 
@@ -12906,12 +13286,12 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     await raceSpawnError(child);
     return true;
   }
-  const aliveFile = import_node_path30.default.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = import_node_path31.default.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const githubAgentsDir = import_node_path30.default.join(subagentDir, ".github", "agents");
-  await (0, import_promises22.mkdir)(githubAgentsDir, { recursive: true });
-  const wakeupDst = import_node_path30.default.join(githubAgentsDir, "wakeup.md");
-  await (0, import_promises22.writeFile)(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
+  const githubAgentsDir = import_node_path31.default.join(subagentDir, ".github", "agents");
+  await (0, import_promises23.mkdir)(githubAgentsDir, { recursive: true });
+  const wakeupDst = import_node_path31.default.join(githubAgentsDir, "wakeup.md");
+  await (0, import_promises23.writeFile)(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
   const workspaceChild = spawnVsCode(vscodeCmd, [workspacePath], {
     label: "open-workspace"
   });
@@ -12923,7 +13303,7 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     "chat",
     "-m",
     wakeupChatId,
-    `create a file named .alive in the ${import_node_path30.default.basename(subagentDir)} folder`
+    `create a file named .alive in the ${import_node_path31.default.basename(subagentDir)} folder`
   ];
   const wakeupChild = spawnVsCode(vscodeCmd, chatArgs, { label: "send-wakeup-chat" });
   await raceSpawnError(wakeupChild);
@@ -12938,27 +13318,27 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
   return true;
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
-  const workspacePath = import_node_path30.default.join(subagentDir, `${import_node_path30.default.basename(subagentDir)}.code-workspace`);
-  const messagesDir = import_node_path30.default.join(subagentDir, "messages");
-  await (0, import_promises22.mkdir)(messagesDir, { recursive: true });
-  const reqFile = import_node_path30.default.join(messagesDir, `${timestamp}_req.md`);
-  await (0, import_promises22.writeFile)(reqFile, requestInstructions, { encoding: "utf8" });
+  const workspacePath = import_node_path31.default.join(subagentDir, `${import_node_path31.default.basename(subagentDir)}.code-workspace`);
+  const messagesDir = import_node_path31.default.join(subagentDir, "messages");
+  await (0, import_promises23.mkdir)(messagesDir, { recursive: true });
+  const reqFile = import_node_path31.default.join(messagesDir, `${timestamp}_req.md`);
+  await (0, import_promises23.writeFile)(reqFile, requestInstructions, { encoding: "utf8" });
   const reqUri = pathToFileUri2(reqFile);
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
     chatArgs.push("-a", attachment);
   }
   chatArgs.push("-a", reqFile);
-  chatArgs.push(`Follow instructions in [${import_node_path30.default.basename(reqFile)}](${reqUri})`);
+  chatArgs.push(`Follow instructions in [${import_node_path31.default.basename(reqFile)}](${reqUri})`);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    import_node_path30.default.basename(subagentDir),
+    import_node_path31.default.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${import_node_path30.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${import_node_path31.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -12966,9 +13346,9 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
   await raceSpawnError(child);
 }
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
-  const workspacePath = import_node_path30.default.join(subagentDir, `${import_node_path30.default.basename(subagentDir)}.code-workspace`);
-  const messagesDir = import_node_path30.default.join(subagentDir, "messages");
-  await (0, import_promises22.mkdir)(messagesDir, { recursive: true });
+  const workspacePath = import_node_path31.default.join(subagentDir, `${import_node_path31.default.basename(subagentDir)}.code-workspace`);
+  const messagesDir = import_node_path31.default.join(subagentDir, "messages");
+  await (0, import_promises23.mkdir)(messagesDir, { recursive: true });
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
     chatArgs.push("-a", attachment);
@@ -12976,13 +13356,13 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
   chatArgs.push(chatInstruction);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    import_node_path30.default.basename(subagentDir),
+    import_node_path31.default.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${import_node_path30.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${import_node_path31.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -12992,12 +13372,12 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
 
 // src/evaluation/providers/vscode/dispatch/workspaceManager.ts
 init_cjs_shims();
-var import_promises23 = require("fs/promises");
-var import_node_path32 = __toESM(require("path"), 1);
+var import_promises24 = require("fs/promises");
+var import_node_path33 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/workspace.ts
 init_cjs_shims();
-var import_node_path31 = __toESM(require("path"), 1);
+var import_node_path32 = __toESM(require("path"), 1);
 var import_json5 = __toESM(require("json5"), 1);
 function transformWorkspacePaths(workspaceContent, templateDir) {
   let workspace;
@@ -13014,10 +13394,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (import_node_path31.default.isAbsolute(folderPath)) {
+    if (import_node_path32.default.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = import_node_path31.default.resolve(templateDir, folderPath);
+    const absolutePath = import_node_path32.default.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -13039,19 +13419,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = import_node_path31.default.isAbsolute(locationPath);
+          const isAbsolute = import_node_path32.default.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = import_node_path31.default.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = import_node_path32.default.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 = (import_node_path31.default.resolve(templateDir, basePath) + patternPath).replace(
+              const resolvedPath = (import_node_path32.default.resolve(templateDir, basePath) + patternPath).replace(
                 /\\/g,
                 "/"
               );
@@ -13092,7 +13472,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 = import_node_path32.default.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = import_node_path33.default.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -13102,26 +13482,26 @@ async function findUnlockedSubagent(subagentRoot) {
 async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = import_node_path32.default.resolve(workspaceTemplate);
+    const workspaceSrc = import_node_path33.default.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
-    const stats = await (0, import_promises23.stat)(workspaceSrc);
+    const stats = await (0, import_promises24.stat)(workspaceSrc);
     if (!stats.isFile()) {
       throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
     }
-    const templateText = await (0, import_promises23.readFile)(workspaceSrc, "utf8");
+    const templateText = await (0, import_promises24.readFile)(workspaceSrc, "utf8");
     workspaceContent = JSON.parse(templateText);
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${import_node_path32.default.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = import_node_path32.default.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? import_node_path32.default.dirname(import_node_path32.default.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${import_node_path33.default.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = import_node_path33.default.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? import_node_path33.default.dirname(import_node_path33.default.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   let transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
   if (cwd) {
-    const absCwd = import_node_path32.default.resolve(cwd);
+    const absCwd = import_node_path33.default.resolve(cwd);
     const parsed = JSON.parse(transformedContent);
     const alreadyPresent = parsed.folders.some((f) => f.path === absCwd);
     if (!alreadyPresent) {
@@ -13129,36 +13509,36 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
       transformedContent = JSON.stringify(parsed, null, 2);
     }
   }
-  await (0, import_promises23.writeFile)(workspaceDst, transformedContent, "utf8");
-  const messagesDir = import_node_path32.default.join(subagentDir, "messages");
-  await (0, import_promises23.mkdir)(messagesDir, { recursive: true });
+  await (0, import_promises24.writeFile)(workspaceDst, transformedContent, "utf8");
+  const messagesDir = import_node_path33.default.join(subagentDir, "messages");
+  await (0, import_promises24.mkdir)(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = import_node_path32.default.join(subagentDir, "messages");
+  const messagesDir = import_node_path33.default.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
-    const files = await (0, import_promises23.readdir)(messagesDir);
+    const files = await (0, import_promises24.readdir)(messagesDir);
     await Promise.all(
       files.map(async (file) => {
-        const target = import_node_path32.default.join(messagesDir, file);
+        const target = import_node_path33.default.join(messagesDir, file);
         await removeIfExists(target);
       })
     );
   }
-  const githubAgentsDir = import_node_path32.default.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = import_node_path33.default.join(subagentDir, ".github", "agents");
   if (await pathExists(githubAgentsDir)) {
-    const agentFiles = await (0, import_promises23.readdir)(githubAgentsDir);
+    const agentFiles = await (0, import_promises24.readdir)(githubAgentsDir);
     const preservedFiles = /* @__PURE__ */ new Set(["wakeup.md", "subagent.md"]);
     await Promise.all(
-      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(import_node_path32.default.join(githubAgentsDir, file)))
+      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(import_node_path33.default.join(githubAgentsDir, file)))
     );
   }
-  const lockFile = import_node_path32.default.join(subagentDir, DEFAULT_LOCK_NAME);
-  await (0, import_promises23.writeFile)(lockFile, "", { encoding: "utf8" });
+  const lockFile = import_node_path33.default.join(subagentDir, DEFAULT_LOCK_NAME);
+  await (0, import_promises24.writeFile)(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = import_node_path32.default.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = import_node_path33.default.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun, cwd) {
@@ -13178,11 +13558,11 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = import_node_path32.default.join(subagentDir, ".github", "agents");
-    await (0, import_promises23.mkdir)(githubAgentsDir, { recursive: true });
-    const agentFile = import_node_path32.default.join(githubAgentsDir, `${chatId}.md`);
+    const githubAgentsDir = import_node_path33.default.join(subagentDir, ".github", "agents");
+    await (0, import_promises24.mkdir)(githubAgentsDir, { recursive: true });
+    const agentFile = import_node_path33.default.join(githubAgentsDir, `${chatId}.md`);
     try {
-      await (0, import_promises23.copyFile)(promptFile, agentFile);
+      await (0, import_promises24.copyFile)(promptFile, agentFile);
     } catch (error) {
       console.error(`error: Failed to copy prompt file to agent mode: ${error.message}`);
       return 1;
@@ -13199,11 +13579,11 @@ async function resolvePromptFile(promptFile) {
   if (!promptFile) {
     return void 0;
   }
-  const resolvedPrompt = import_node_path33.default.resolve(promptFile);
+  const resolvedPrompt = import_node_path34.default.resolve(promptFile);
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
-  const promptStats = await (0, import_promises24.stat)(resolvedPrompt);
+  const promptStats = await (0, import_promises25.stat)(resolvedPrompt);
   if (!promptStats.isFile()) {
     throw new Error(`Prompt file must be a file, not a directory: ${resolvedPrompt}`);
   }
@@ -13215,7 +13595,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = import_node_path33.default.resolve(attachment);
+    const resolvedPath = import_node_path34.default.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -13257,7 +13637,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = import_node_path33.default.basename(subagentDir);
+    const subagentName = import_node_path34.default.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -13285,9 +13665,9 @@ async function dispatchAgentSession(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = import_node_path33.default.join(subagentDir, "messages");
-    const responseFileTmp = import_node_path33.default.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = import_node_path33.default.join(messagesDir, `${timestamp}_res.md`);
+    const messagesDir = import_node_path34.default.join(subagentDir, "messages");
+    const responseFileTmp = import_node_path34.default.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = import_node_path34.default.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(
       userQuery,
       responseFileTmp,
@@ -13392,7 +13772,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = import_node_path33.default.basename(subagentDir);
+    subagentName = import_node_path34.default.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -13423,24 +13803,24 @@ async function dispatchBatchAgent(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = import_node_path33.default.join(subagentDir, "messages");
+    const messagesDir = import_node_path34.default.join(subagentDir, "messages");
     requestFiles = userQueries.map(
-      (_, index) => import_node_path33.default.join(messagesDir, `${timestamp}_${index}_req.md`)
+      (_, index) => import_node_path34.default.join(messagesDir, `${timestamp}_${index}_req.md`)
     );
     const responseTmpFiles = userQueries.map(
-      (_, index) => import_node_path33.default.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+      (_, index) => import_node_path34.default.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
     );
     responseFilesFinal = userQueries.map(
-      (_, index) => import_node_path33.default.join(messagesDir, `${timestamp}_${index}_res.md`)
+      (_, index) => import_node_path34.default.join(messagesDir, `${timestamp}_${index}_res.md`)
     );
-    const orchestratorFile = import_node_path33.default.join(messagesDir, `${timestamp}_orchestrator.md`);
+    const orchestratorFile = import_node_path34.default.join(messagesDir, `${timestamp}_orchestrator.md`);
     if (!dryRun) {
       await Promise.all(
         userQueries.map((query, index) => {
           const reqFile = requestFiles[index];
           const tmpFile = responseTmpFiles[index];
           const finalFile = responseFilesFinal[index];
-          return (0, import_promises24.writeFile)(
+          return (0, import_promises25.writeFile)(
             reqFile,
             createBatchRequestPrompt(query, tmpFile, finalFile, batchRequestTemplateContent),
             { encoding: "utf8" }
@@ -13452,7 +13832,7 @@ async function dispatchBatchAgent(options) {
         responseFilesFinal,
         orchestratorTemplateContent
       );
-      await (0, import_promises24.writeFile)(orchestratorFile, orchestratorContent, { encoding: "utf8" });
+      await (0, import_promises25.writeFile)(orchestratorFile, orchestratorContent, { encoding: "utf8" });
     }
     const chatAttachments = [orchestratorFile, ...attachments];
     const orchestratorUri = pathToFileUri2(orchestratorFile);
@@ -13519,8 +13899,8 @@ async function dispatchBatchAgent(options) {
 
 // src/evaluation/providers/vscode/dispatch/provision.ts
 init_cjs_shims();
-var import_promises25 = require("fs/promises");
-var import_node_path34 = __toESM(require("path"), 1);
+var import_promises26 = require("fs/promises");
+var import_node_path35 = __toESM(require("path"), 1);
 var DEFAULT_WORKSPACE_TEMPLATE2 = {
   folders: [
     {
@@ -13551,7 +13931,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = import_node_path34.default.resolve(targetRoot);
+  const targetPath = import_node_path35.default.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -13571,7 +13951,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = import_node_path34.default.join(entry.absolutePath, lockName);
+      const lockFile = import_node_path35.default.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -13588,10 +13968,10 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const githubAgentsDir = import_node_path34.default.join(subagentDir, ".github", "agents");
-    const lockFile = import_node_path34.default.join(subagentDir, lockName);
-    const workspaceDst = import_node_path34.default.join(subagentDir, `${import_node_path34.default.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = import_node_path34.default.join(githubAgentsDir, "wakeup.md");
+    const githubAgentsDir = import_node_path35.default.join(subagentDir, ".github", "agents");
+    const lockFile = import_node_path35.default.join(subagentDir, lockName);
+    const workspaceDst = import_node_path35.default.join(subagentDir, `${import_node_path35.default.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = import_node_path35.default.join(githubAgentsDir, "wakeup.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -13600,8 +13980,8 @@ async function provisionSubagents(options) {
       if (!dryRun) {
         await removeIfExists(lockFile);
         await ensureDir(githubAgentsDir);
-        await (0, import_promises25.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await (0, import_promises25.writeFile)(wakeupDst, wakeupContent, "utf8");
+        await (0, import_promises26.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await (0, import_promises26.writeFile)(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       lockedSubagents.delete(subagentDir);
@@ -13611,8 +13991,8 @@ async function provisionSubagents(options) {
     if (!isLocked && force) {
       if (!dryRun) {
         await ensureDir(githubAgentsDir);
-        await (0, import_promises25.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await (0, import_promises25.writeFile)(wakeupDst, wakeupContent, "utf8");
+        await (0, import_promises26.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await (0, import_promises26.writeFile)(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       subagentsProvisioned += 1;
@@ -13620,8 +14000,8 @@ async function provisionSubagents(options) {
     }
     if (!dryRun && !await pathExists(workspaceDst)) {
       await ensureDir(githubAgentsDir);
-      await (0, import_promises25.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await (0, import_promises25.writeFile)(wakeupDst, wakeupContent, "utf8");
+      await (0, import_promises26.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await (0, import_promises26.writeFile)(wakeupDst, wakeupContent, "utf8");
     }
     skippedExisting.push(subagentDir);
     subagentsProvisioned += 1;
@@ -13629,15 +14009,15 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = import_node_path34.default.join(targetPath, `subagent-${nextIndex}`);
-    const githubAgentsDir = import_node_path34.default.join(subagentDir, ".github", "agents");
-    const workspaceDst = import_node_path34.default.join(subagentDir, `${import_node_path34.default.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = import_node_path34.default.join(githubAgentsDir, "wakeup.md");
+    const subagentDir = import_node_path35.default.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = import_node_path35.default.join(subagentDir, ".github", "agents");
+    const workspaceDst = import_node_path35.default.join(subagentDir, `${import_node_path35.default.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = import_node_path35.default.join(githubAgentsDir, "wakeup.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
-      await (0, import_promises25.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await (0, import_promises25.writeFile)(wakeupDst, wakeupContent, "utf8");
+      await (0, import_promises26.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await (0, import_promises26.writeFile)(wakeupDst, wakeupContent, "utf8");
     }
     created.push(subagentDir);
     subagentsProvisioned += 1;
@@ -13823,9 +14203,9 @@ var VSCodeProvider = class {
 async function locateVSCodeExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = import_node_path35.default.isAbsolute(candidate) ? candidate : import_node_path35.default.resolve(candidate);
+    const resolved = import_node_path36.default.isAbsolute(candidate) ? candidate : import_node_path36.default.resolve(candidate);
     try {
-      await (0, import_promises26.access)(resolved, import_promises26.constants.F_OK);
+      await (0, import_promises27.access)(resolved, import_promises27.constants.F_OK);
       return resolved;
     } catch {
       throw new Error(
@@ -13838,7 +14218,7 @@ async function locateVSCodeExecutable(candidate) {
     const { stdout } = await execAsync3(`${locator} ${candidate}`);
     const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
     if (lines.length > 0 && lines[0]) {
-      await (0, import_promises26.access)(lines[0], import_promises26.constants.F_OK);
+      await (0, import_promises27.access)(lines[0], import_promises27.constants.F_OK);
       return lines[0];
     }
   } catch {
@@ -13852,7 +14232,7 @@ async function resolveWorkspaceTemplateFile(template) {
     return void 0;
   }
   try {
-    const stats = await (0, import_promises26.stat)(import_node_path35.default.resolve(template));
+    const stats = await (0, import_promises27.stat)(import_node_path36.default.resolve(template));
     return stats.isFile() ? template : void 0;
   } catch {
     return template;
@@ -13876,7 +14256,7 @@ function buildMandatoryPrereadBlock2(attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = import_node_path35.default.basename(absolutePath);
+    const fileName = import_node_path36.default.basename(absolutePath);
     const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -13897,7 +14277,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = import_node_path35.default.resolve(attachment);
+    const absolutePath = import_node_path36.default.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -13905,7 +14285,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri3(filePath) {
-  const absolutePath = import_node_path35.default.isAbsolute(filePath) ? filePath : import_node_path35.default.resolve(filePath);
+  const absolutePath = import_node_path36.default.isAbsolute(filePath) ? filePath : import_node_path36.default.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -13918,7 +14298,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(import_node_path35.default.resolve(attachment));
+    deduped.add(import_node_path36.default.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -13927,7 +14307,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(import_node_path35.default.resolve(inputFile));
+      deduped.add(import_node_path36.default.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -14021,8 +14401,8 @@ function isAgentProvider(provider) {
 // src/evaluation/providers/targets-file.ts
 init_cjs_shims();
 var import_node_fs12 = require("fs");
-var import_promises27 = require("fs/promises");
-var import_node_path36 = __toESM(require("path"), 1);
+var import_promises28 = require("fs/promises");
+var import_node_path37 = __toESM(require("path"), 1);
 var import_yaml7 = require("yaml");
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -14055,18 +14435,18 @@ function assertTargetDefinition(value, index, filePath) {
 }
 async function fileExists3(filePath) {
   try {
-    await (0, import_promises27.access)(filePath, import_node_fs12.constants.F_OK);
+    await (0, import_promises28.access)(filePath, import_node_fs12.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = import_node_path36.default.resolve(filePath);
+  const absolutePath = import_node_path37.default.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await (0, import_promises27.readFile)(absolutePath, "utf8");
+  const raw = await (0, import_promises28.readFile)(absolutePath, "utf8");
   const parsed = (0, import_yaml7.parse)(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -14083,16 +14463,16 @@ function listTargetNames(definitions) {
 
 // src/evaluation/providers/provider-discovery.ts
 init_cjs_shims();
-var import_node_path37 = __toESM(require("path"), 1);
+var import_node_path38 = __toESM(require("path"), 1);
 var import_fast_glob2 = __toESM(require("fast-glob"), 1);
 async function discoverProviders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = import_node_path37.default.resolve(baseDir);
-  const root = import_node_path37.default.parse(dir).root;
+  let dir = import_node_path38.default.resolve(baseDir);
+  const root = import_node_path38.default.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(import_node_path37.default.join(dir, ".agentv", "providers"));
-    dir = import_node_path37.default.dirname(dir);
+    candidateDirs.push(import_node_path38.default.join(dir, ".agentv", "providers"));
+    dir = import_node_path38.default.dirname(dir);
   }
   let files = [];
   for (const providersDir of candidateDirs) {
@@ -14108,7 +14488,7 @@ async function discoverProviders(registry, baseDir) {
   }
   const discoveredKinds = [];
   for (const filePath of files) {
-    const basename = import_node_path37.default.basename(filePath);
+    const basename = import_node_path38.default.basename(filePath);
     const kindName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(kindName)) {
       continue;
@@ -14238,154 +14618,9 @@ function negateScore(score) {
 
 // src/evaluation/evaluators/code-evaluator.ts
 init_cjs_shims();
-var import_promises28 = require("fs/promises");
+var import_promises29 = require("fs/promises");
 var import_node_os7 = require("os");
-var import_node_path38 = require("path");
-
-// src/runtime/exec.ts
-init_cjs_shims();
-function shellEscapePath(value) {
-  if (process.platform === "win32") {
-    return `"${value.replaceAll('"', '""')}"`;
-  }
-  return `'${value.replaceAll("'", `'"'"'`)}'`;
-}
-async function execFileWithStdin(argv, stdinPayload, options = {}) {
-  if (argv.length === 0) {
-    throw new Error("Executable argv must include at least one entry");
-  }
-  if (typeof Bun !== "undefined") {
-    return execFileWithStdinBun(argv, stdinPayload, options);
-  }
-  return execFileWithStdinNode(argv, stdinPayload, options);
-}
-async function execFileWithStdinBun(argv, stdinPayload, options) {
-  const command = [...argv];
-  const encoder = new TextEncoder();
-  const proc = Bun.spawn(command, {
-    cwd: options.cwd,
-    stdin: encoder.encode(stdinPayload),
-    stdout: "pipe",
-    stderr: "pipe",
-    // Merge additional env vars with process.env
-    env: options.env ? { ...process.env, ...options.env } : process.env
-  });
-  let timedOut = false;
-  const timeout = options.timeoutMs !== void 0 ? setTimeout(() => {
-    timedOut = true;
-    proc.kill("SIGKILL");
-  }, options.timeoutMs) : void 0;
-  try {
-    const stdoutPromise = proc.stdout ? new Response(proc.stdout).text() : Promise.resolve("");
-    const stderrPromise = proc.stderr ? new Response(proc.stderr).text() : Promise.resolve("");
-    const [stdout, stderr, exitCode] = await Promise.all([
-      stdoutPromise,
-      stderrPromise,
-      proc.exited
-    ]);
-    if (timedOut) {
-      throw new Error(`Process timed out after ${options.timeoutMs}ms`);
-    }
-    return {
-      stdout: stdout.replace(/\r\n/g, "\n"),
-      stderr: stderr.replace(/\r\n/g, "\n"),
-      exitCode
-    };
-  } finally {
-    if (timeout !== void 0) {
-      clearTimeout(timeout);
-    }
-  }
-}
-async function execFileWithStdinNode(argv, stdinPayload, options) {
-  const { spawn: spawn5 } = await import("child_process");
-  return new Promise((resolve, reject) => {
-    const [cmd, ...args] = argv;
-    const child = spawn5(cmd, args, {
-      cwd: options.cwd,
-      stdio: ["pipe", "pipe", "pipe"],
-      // Merge additional env vars with process.env
-      env: options.env ? { ...process.env, ...options.env } : process.env
-    });
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
-    child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
-    let timedOut = false;
-    const timeout = options.timeoutMs !== void 0 ? setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGKILL");
-    }, options.timeoutMs) : void 0;
-    child.on("error", (error) => {
-      if (timeout !== void 0) clearTimeout(timeout);
-      reject(error);
-    });
-    child.on("close", (code) => {
-      if (timeout !== void 0) clearTimeout(timeout);
-      if (timedOut) {
-        reject(new Error(`Process timed out after ${options.timeoutMs}ms`));
-        return;
-      }
-      const stdout = Buffer.concat(stdoutChunks).toString("utf8").replace(/\r\n/g, "\n");
-      const stderr = Buffer.concat(stderrChunks).toString("utf8").replace(/\r\n/g, "\n");
-      resolve({
-        stdout,
-        stderr,
-        exitCode: code ?? 0
-      });
-    });
-    if (child.stdin) {
-      child.stdin.write(stdinPayload);
-      child.stdin.end();
-    }
-  });
-}
-async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir17, readFile: readFile18, rm: rm6, writeFile: writeFile9 } = await import("fs/promises");
-  const { tmpdir: tmpdir3 } = await import("os");
-  const path54 = await import("path");
-  const { randomUUID: randomUUID10 } = await import("crypto");
-  const dir = path54.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
-  await mkdir17(dir, { recursive: true });
-  const stdinPath = path54.join(dir, "stdin.txt");
-  const stdoutPath = path54.join(dir, "stdout.txt");
-  const stderrPath = path54.join(dir, "stderr.txt");
-  await writeFile9(stdinPath, stdinPayload, "utf8");
-  const wrappedCommand = process.platform === "win32" ? `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
-  const { spawn: spawn5 } = await import("child_process");
-  try {
-    const exitCode = await new Promise((resolve, reject) => {
-      const child = spawn5(wrappedCommand, {
-        shell: true,
-        cwd: options.cwd,
-        stdio: ["ignore", "ignore", "ignore"],
-        // Merge additional env vars with process.env
-        env: options.env ? { ...process.env, ...options.env } : process.env
-      });
-      const timeout = options.timeoutMs ? setTimeout(() => {
-        child.kill();
-        reject(new Error(`Process timed out after ${options.timeoutMs}ms`));
-      }, options.timeoutMs) : void 0;
-      child.on("error", (error) => {
-        if (timeout !== void 0) {
-          clearTimeout(timeout);
-        }
-        reject(error);
-      });
-      child.on("exit", (code) => {
-        if (timeout !== void 0) {
-          clearTimeout(timeout);
-        }
-        resolve(code ?? 0);
-      });
-    });
-    const stdout = (await readFile18(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile18(stderrPath, "utf8")).replace(/\r\n/g, "\n");
-    return { stdout, stderr, exitCode };
-  } finally {
-    await rm6(dir, { recursive: true, force: true });
-  }
-}
+var import_node_path39 = require("path");
 
 // src/runtime/target-proxy.ts
 init_cjs_shims();
@@ -14706,8 +14941,8 @@ async function materializeContentForGrader(messages, getWorkDir) {
         const [, mediaType, base64Data] = match;
         const ext = mediaType.split("/")[1] === "jpeg" ? "jpg" : mediaType.split("/")[1] ?? "bin";
         const dir = await getWorkDir();
-        const filePath = (0, import_node_path38.join)(dir, `img-${counter++}.${ext}`);
-        await (0, import_promises28.writeFile)(filePath, Buffer.from(base64Data, "base64"));
+        const filePath = (0, import_node_path39.join)(dir, `img-${counter++}.${ext}`);
+        await (0, import_promises29.writeFile)(filePath, Buffer.from(base64Data, "base64"));
         blocks.push({ type: "image", media_type: img.media_type, path: filePath });
       } else {
         blocks.push({ type: "image", media_type: img.media_type, path: img.source });
@@ -14735,7 +14970,7 @@ var CodeEvaluator = class {
     let imageTmpDir;
     const getImageDir = async () => {
       if (!imageTmpDir) {
-        imageTmpDir = await (0, import_promises28.mkdtemp)((0, import_node_path38.join)((0, import_node_os7.tmpdir)(), "agentv-img-"));
+        imageTmpDir = await (0, import_promises29.mkdtemp)((0, import_node_path39.join)((0, import_node_os7.tmpdir)(), "agentv-img-"));
       }
       return imageTmpDir;
     };
@@ -14748,9 +14983,9 @@ var CodeEvaluator = class {
     if (outputForPayload) {
       const serialized = JSON.stringify(outputForPayload);
       if (serialized.length > FILE_BACKED_OUTPUT_THRESHOLD) {
-        const tmpDir = await (0, import_promises28.mkdtemp)((0, import_node_path38.join)((0, import_node_os7.tmpdir)(), "agentv-grader-"));
-        outputPath = (0, import_node_path38.join)(tmpDir, "output.json");
-        await (0, import_promises28.writeFile)(outputPath, serialized);
+        const tmpDir = await (0, import_promises29.mkdtemp)((0, import_node_path39.join)((0, import_node_os7.tmpdir)(), "agentv-grader-"));
+        outputPath = (0, import_node_path39.join)(tmpDir, "output.json");
+        await (0, import_promises29.writeFile)(outputPath, serialized);
         outputForPayload = null;
       }
     }
@@ -14862,11 +15097,11 @@ var CodeEvaluator = class {
         await proxyShutdown();
       }
       if (outputPath) {
-        await (0, import_promises28.rm)((0, import_node_path38.dirname)(outputPath), { recursive: true, force: true }).catch(() => {
+        await (0, import_promises29.rm)((0, import_node_path39.dirname)(outputPath), { recursive: true, force: true }).catch(() => {
         });
       }
       if (imageTmpDir) {
-        await (0, import_promises28.rm)(imageTmpDir, { recursive: true, force: true }).catch(() => {
+        await (0, import_promises29.rm)(imageTmpDir, { recursive: true, force: true }).catch(() => {
         });
       }
     }
@@ -14899,8 +15134,8 @@ var import_ai3 = require("ai");
 
 // src/evaluation/evaluators/llm-grader.ts
 init_cjs_shims();
-var import_promises29 = __toESM(require("fs/promises"), 1);
-var import_node_path39 = __toESM(require("path"), 1);
+var import_promises30 = __toESM(require("fs/promises"), 1);
+var import_node_path40 = __toESM(require("path"), 1);
 var import_ai2 = require("ai");
 var import_zod4 = require("zod");
 var DEFAULT_MAX_STEPS = 10;
@@ -14984,6 +15219,15 @@ var scoreRangeEvaluationSchema = import_zod4.z.object({
   checks: import_zod4.z.array(scoreRangeCheckResultSchema).describe("Scores for each rubric criterion"),
   overall_reasoning: import_zod4.z.string().describe("Overall assessment summary (1-2 sentences)").optional()
 });
+function resolveContentBasePath(context2) {
+  if (context2.workspacePath) {
+    return context2.workspacePath;
+  }
+  if ("config" in context2.target && context2.target.config && typeof context2.target.config === "object" && "cwd" in context2.target.config && typeof context2.target.config.cwd === "string") {
+    return context2.target.config.cwd;
+  }
+  return void 0;
+}
 var LlmGraderEvaluator = class {
   kind = "llm-grader";
   resolveGraderProvider;
@@ -15001,24 +15245,46 @@ var LlmGraderEvaluator = class {
     this.graderTargetProvider = options.graderTargetProvider ?? options.judgeTargetProvider;
   }
   async evaluate(context2) {
+    const preparedContext = await this.prepareContext(context2);
     if (this.graderTargetProvider) {
-      return this.evaluateWithGraderTarget(context2);
+      return this.evaluateWithGraderTarget(preparedContext);
     }
-    const graderProvider = await this.resolveGraderProvider(context2);
+    const graderProvider = await this.resolveGraderProvider(preparedContext);
     if (!graderProvider) {
       throw new Error("No grader provider available for LLM grading");
     }
     if (graderProvider.kind === "agentv") {
-      return this.evaluateBuiltIn(context2, graderProvider);
+      return this.evaluateBuiltIn(preparedContext, graderProvider);
     }
     if (isAgentProvider(graderProvider)) {
-      return this.evaluateWithDelegatedAgent(context2, graderProvider);
+      return this.evaluateWithDelegatedAgent(preparedContext, graderProvider);
     }
-    const config = context2.evaluator;
+    const config = preparedContext.evaluator;
     if (config?.type === "llm-grader" && config.rubrics && config.rubrics.length > 0) {
-      return this.evaluateWithRubrics(context2, graderProvider, config.rubrics);
+      return this.evaluateWithRubrics(preparedContext, graderProvider, config.rubrics);
+    }
+    return this.evaluateFreeform(preparedContext, graderProvider);
+  }
+  async prepareContext(context2) {
+    const config = context2.evaluator;
+    if (config?.type !== "llm-grader" || !context2.output) {
+      return context2;
+    }
+    const lastAssistant = [...context2.output].reverse().find((message) => message.role === "assistant" && message.content !== void 0);
+    if (!lastAssistant || typeof lastAssistant.content === "string") {
+      return context2;
     }
-    return this.evaluateFreeform(context2, graderProvider);
+    const extracted = await extractTextWithPreprocessors(
+      lastAssistant.content,
+      config.preprocessors,
+      {
+        basePath: resolveContentBasePath(context2)
+      }
+    );
+    return {
+      ...context2,
+      candidate: appendPreprocessingWarnings(extracted.text, extracted.warnings)
+    };
   }
   // ---------------------------------------------------------------------------
   // LLM mode (existing)
@@ -15903,8 +16169,8 @@ function toAiSdkImageParts(images) {
   }));
 }
 function resolveSandboxed(basePath, relativePath) {
-  const resolved = import_node_path39.default.resolve(basePath, relativePath);
-  if (!resolved.startsWith(basePath + import_node_path39.default.sep) && resolved !== basePath) {
+  const resolved = import_node_path40.default.resolve(basePath, relativePath);
+  if (!resolved.startsWith(basePath + import_node_path40.default.sep) && resolved !== basePath) {
     throw new Error(`Path '${relativePath}' is outside the workspace`);
   }
   return resolved;
@@ -15919,7 +16185,7 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const entries = await import_promises29.default.readdir(resolved, { withFileTypes: true });
+          const entries = await import_promises30.default.readdir(resolved, { withFileTypes: true });
           return entries.map((e) => ({
             name: e.name,
             type: e.isDirectory() ? "directory" : "file"
@@ -15937,12 +16203,12 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const stat11 = await import_promises29.default.stat(resolved);
+          const stat11 = await import_promises30.default.stat(resolved);
           if (stat11.isDirectory()) {
             return { error: `'${input.path}' is a directory, not a file` };
           }
           const buffer = Buffer.alloc(Math.min(stat11.size, MAX_FILE_SIZE));
-          const fd = await import_promises29.default.open(resolved, "r");
+          const fd = await import_promises30.default.open(resolved, "r");
           try {
             await fd.read(buffer, 0, buffer.length, 0);
           } finally {
@@ -15987,30 +16253,30 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
   if (matches.length >= MAX_SEARCH_MATCHES) return;
   let entries;
   try {
-    entries = await import_promises29.default.readdir(dirPath, { withFileTypes: true });
+    entries = await import_promises30.default.readdir(dirPath, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (matches.length >= MAX_SEARCH_MATCHES) return;
     if (SEARCH_SKIP_DIRS.has(entry.name)) continue;
-    const fullPath = import_node_path39.default.join(dirPath, entry.name);
+    const fullPath = import_node_path40.default.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       await searchDirectory(fullPath, workspacePath, regex, matches);
     } else if (entry.isFile()) {
-      const ext = import_node_path39.default.extname(entry.name).toLowerCase();
+      const ext = import_node_path40.default.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
-        const stat11 = await import_promises29.default.stat(fullPath);
+        const stat11 = await import_promises30.default.stat(fullPath);
         if (stat11.size > MAX_FILE_SIZE) continue;
-        const content = await import_promises29.default.readFile(fullPath, "utf-8");
+        const content = await import_promises30.default.readFile(fullPath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
           if (matches.length >= MAX_SEARCH_MATCHES) return;
           regex.lastIndex = 0;
           if (regex.test(lines[i])) {
             matches.push({
-              file: import_node_path39.default.relative(workspacePath, fullPath),
+              file: import_node_path40.default.relative(workspacePath, fullPath),
               line: i + 1,
               text: lines[i].substring(0, 200)
             });
@@ -16646,115 +16912,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path54, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path54);
-    const expectedValue = resolvePath(expectedData, path54);
+    const { path: path55, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path55);
+    const expectedValue = resolvePath(expectedData, path55);
     if (expectedValue === void 0) {
       return {
-        path: path54,
+        path: path55,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path54}: no expected value`
+        message: `${path55}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path54,
+          path: path55,
           score: 0,
           weight,
           hit: false,
-          message: `${path54} (required, missing)`
+          message: `${path55} (required, missing)`
         };
       }
       return {
-        path: path54,
+        path: path55,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path54}: optional field missing`
+        message: `${path55}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path54, candidateValue, expectedValue, weight);
+        return this.compareExact(path55, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path54,
+          path55,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path54, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path55, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path54,
+          path: path55,
           score: 0,
           weight,
           hit: false,
-          message: `${path54}: unknown match type "${match}"`
+          message: `${path55}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path54, candidateValue, expectedValue, weight) {
+  compareExact(path55, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path54,
+        path: path55,
         score: 1,
         weight,
         hit: true,
-        message: path54
+        message: path55
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path54,
+        path: path55,
         score: 0,
         weight,
         hit: false,
-        message: `${path54} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path55} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path54,
+      path: path55,
       score: 0,
       weight,
       hit: false,
-      message: `${path54} (value mismatch)`
+      message: `${path55} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path54, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path55, 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: path54,
+        path: path55,
         score: 0,
         weight,
         hit: false,
-        message: `${path54} (non-numeric value)`
+        message: `${path55} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path54,
+        path: path55,
         score: 0,
         weight,
         hit: false,
-        message: `${path54} (invalid numeric value)`
+        message: `${path55} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -16767,61 +17033,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path54,
+        path: path55,
         score: 1,
         weight,
         hit: true,
-        message: `${path54} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path55} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path54,
+      path: path55,
       score: 0,
       weight,
       hit: false,
-      message: `${path54} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path55} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path54, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path55, 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: path54,
+        path: path55,
         score: 0,
         weight,
         hit: false,
-        message: `${path54} (unparseable candidate date)`
+        message: `${path55} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path54,
+        path: path55,
         score: 0,
         weight,
         hit: false,
-        message: `${path54} (unparseable expected date)`
+        message: `${path55} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path54,
+        path: path55,
         score: 1,
         weight,
         hit: true,
-        message: path54
+        message: path55
       };
     }
     return {
-      path: path54,
+      path: path55,
       score: 0,
       weight,
       hit: false,
-      message: `${path54} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path55} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -16854,11 +17120,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path54) {
-  if (!path54 || !obj) {
+function resolvePath(obj, path55) {
+  if (!path55 || !obj) {
     return void 0;
   }
-  const parts = path54.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path55.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -17355,8 +17621,8 @@ var TokenUsageEvaluator = class {
 
 // src/evaluation/evaluators/tool-trajectory.ts
 init_cjs_shims();
-function getNestedValue(obj, path54) {
-  const parts = path54.split(".");
+function getNestedValue(obj, path55) {
+  const parts = path55.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -17979,8 +18245,9 @@ function runEqualsAssertion(output, value) {
 // src/evaluation/orchestrator.ts
 init_cjs_shims();
 var import_node_crypto11 = require("crypto");
-var import_promises33 = require("fs/promises");
-var import_node_path48 = __toESM(require("path"), 1);
+var import_node_fs16 = require("fs");
+var import_promises34 = require("fs/promises");
+var import_node_path49 = __toESM(require("path"), 1);
 var import_micromatch3 = __toESM(require("micromatch"), 1);
 
 // ../../node_modules/.bun/p-limit@6.2.0/node_modules/p-limit/index.js
@@ -18207,7 +18474,7 @@ var InlineAssertEvaluator = class {
 
 // src/evaluation/evaluators/prompt-resolution.ts
 init_cjs_shims();
-var import_node_path40 = __toESM(require("path"), 1);
+var import_node_path41 = __toESM(require("path"), 1);
 async function resolveCustomPrompt(promptConfig, context2, timeoutMs) {
   if (promptConfig.resolvedPromptScript && promptConfig.resolvedPromptScript.length > 0) {
     if (!context2) {
@@ -18250,7 +18517,7 @@ async function executePromptTemplate(script, context2, config, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = import_node_path40.default.dirname(scriptPath);
+  const cwd = import_node_path41.default.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();
@@ -18523,16 +18790,16 @@ function createBuiltinRegistry() {
 
 // src/evaluation/registry/assertion-discovery.ts
 init_cjs_shims();
-var import_node_path41 = __toESM(require("path"), 1);
+var import_node_path42 = __toESM(require("path"), 1);
 var import_fast_glob3 = __toESM(require("fast-glob"), 1);
 async function discoverAssertions(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = import_node_path41.default.resolve(baseDir);
-  const root = import_node_path41.default.parse(dir).root;
+  let dir = import_node_path42.default.resolve(baseDir);
+  const root = import_node_path42.default.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(import_node_path41.default.join(dir, ".agentv", "assertions"));
-    dir = import_node_path41.default.dirname(dir);
+    candidateDirs.push(import_node_path42.default.join(dir, ".agentv", "assertions"));
+    dir = import_node_path42.default.dirname(dir);
   }
   let files = [];
   for (const assertionsDir of candidateDirs) {
@@ -18548,7 +18815,7 @@ async function discoverAssertions(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = import_node_path41.default.basename(filePath);
+    const basename = import_node_path42.default.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -18567,17 +18834,17 @@ async function discoverAssertions(registry, baseDir) {
 
 // src/evaluation/registry/grader-discovery.ts
 init_cjs_shims();
-var import_node_path42 = __toESM(require("path"), 1);
+var import_node_path43 = __toESM(require("path"), 1);
 var import_fast_glob4 = __toESM(require("fast-glob"), 1);
 async function discoverGraders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = import_node_path42.default.resolve(baseDir);
-  const root = import_node_path42.default.parse(dir).root;
+  let dir = import_node_path43.default.resolve(baseDir);
+  const root = import_node_path43.default.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(import_node_path42.default.join(dir, ".agentv", "graders"));
-    candidateDirs.push(import_node_path42.default.join(dir, ".agentv", "judges"));
-    dir = import_node_path42.default.dirname(dir);
+    candidateDirs.push(import_node_path43.default.join(dir, ".agentv", "graders"));
+    candidateDirs.push(import_node_path43.default.join(dir, ".agentv", "judges"));
+    dir = import_node_path43.default.dirname(dir);
   }
   let files = [];
   for (const gradersDir of candidateDirs) {
@@ -18593,7 +18860,7 @@ async function discoverGraders(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = import_node_path42.default.basename(filePath);
+    const basename = import_node_path43.default.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -18755,7 +19022,7 @@ function getTCritical(df) {
 init_cjs_shims();
 var import_node_child_process8 = require("child_process");
 var import_node_fs13 = require("fs");
-var import_node_path43 = __toESM(require("path"), 1);
+var import_node_path44 = __toESM(require("path"), 1);
 var import_node_util4 = require("util");
 var execAsync4 = (0, import_node_util4.promisify)(import_node_child_process8.exec);
 function gitExecOpts(workspacePath) {
@@ -18789,10 +19056,10 @@ async function stageNestedRepoChanges(workspacePath) {
   }
   for (const entry of entries) {
     if (entry === ".git" || entry === "node_modules") continue;
-    const childPath = import_node_path43.default.join(workspacePath, entry);
+    const childPath = import_node_path44.default.join(workspacePath, entry);
     try {
       if (!(0, import_node_fs13.statSync)(childPath).isDirectory()) continue;
-      if (!(0, import_node_fs13.statSync)(import_node_path43.default.join(childPath, ".git")).isDirectory()) continue;
+      if (!(0, import_node_fs13.statSync)(import_node_path44.default.join(childPath, ".git")).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -18803,8 +19070,8 @@ async function stageNestedRepoChanges(workspacePath) {
 
 // src/evaluation/workspace/manager.ts
 init_cjs_shims();
-var import_promises30 = require("fs/promises");
-var import_node_path44 = __toESM(require("path"), 1);
+var import_promises31 = require("fs/promises");
+var import_node_path45 = __toESM(require("path"), 1);
 var TemplateNotFoundError = class extends Error {
   constructor(templatePath) {
     super(`Workspace template not found: ${templatePath}`);
@@ -18826,7 +19093,7 @@ var WorkspaceCreationError = class extends Error {
 };
 async function isDirectory(filePath) {
   try {
-    const stats = await (0, import_promises30.stat)(filePath);
+    const stats = await (0, import_promises31.stat)(filePath);
     return stats.isDirectory();
   } catch {
     return false;
@@ -18834,26 +19101,26 @@ async function isDirectory(filePath) {
 }
 function getWorkspacePath(evalRunId, caseId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
-  return import_node_path44.default.join(root, evalRunId, caseId);
+  return import_node_path45.default.join(root, evalRunId, caseId);
 }
 async function copyDirectoryRecursive(src, dest) {
-  await (0, import_promises30.mkdir)(dest, { recursive: true });
-  const entries = await (0, import_promises30.readdir)(src, { withFileTypes: true });
+  await (0, import_promises31.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises31.readdir)(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = import_node_path44.default.join(src, entry.name);
-    const destPath = import_node_path44.default.join(dest, entry.name);
+    const srcPath = import_node_path45.default.join(src, entry.name);
+    const destPath = import_node_path45.default.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
     if (entry.isDirectory()) {
       await copyDirectoryRecursive(srcPath, destPath);
     } else {
-      await (0, import_promises30.cp)(srcPath, destPath, { preserveTimestamps: true });
+      await (0, import_promises31.cp)(srcPath, destPath, { preserveTimestamps: true });
     }
   }
 }
 async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoot) {
-  const resolvedTemplatePath = import_node_path44.default.resolve(templatePath);
+  const resolvedTemplatePath = import_node_path45.default.resolve(templatePath);
   if (!await fileExists2(resolvedTemplatePath)) {
     throw new TemplateNotFoundError(resolvedTemplatePath);
   }
@@ -18863,7 +19130,7 @@ async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoo
   const workspacePath = getWorkspacePath(evalRunId, caseId, workspaceRoot);
   try {
     if (await fileExists2(workspacePath)) {
-      await (0, import_promises30.rm)(workspacePath, { recursive: true, force: true });
+      await (0, import_promises31.rm)(workspacePath, { recursive: true, force: true });
     }
     await copyDirectoryRecursive(resolvedTemplatePath, workspacePath);
     return workspacePath;
@@ -18897,14 +19164,14 @@ async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoo
 }
 async function cleanupWorkspace(workspacePath) {
   if (await fileExists2(workspacePath)) {
-    await (0, import_promises30.rm)(workspacePath, { recursive: true, force: true });
+    await (0, import_promises31.rm)(workspacePath, { recursive: true, force: true });
   }
 }
 async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
-  const evalDir = import_node_path44.default.join(root, evalRunId);
+  const evalDir = import_node_path45.default.join(root, evalRunId);
   if (await fileExists2(evalDir)) {
-    await (0, import_promises30.rm)(evalDir, { recursive: true, force: true });
+    await (0, import_promises31.rm)(evalDir, { recursive: true, force: true });
   }
 }
 
@@ -18913,8 +19180,8 @@ init_cjs_shims();
 var import_node_child_process9 = require("child_process");
 var import_node_crypto10 = require("crypto");
 var import_node_fs14 = require("fs");
-var import_promises31 = require("fs/promises");
-var import_node_path45 = __toESM(require("path"), 1);
+var import_promises32 = require("fs/promises");
+var import_node_path46 = __toESM(require("path"), 1);
 var import_node_util5 = require("util");
 var execFileAsync = (0, import_node_util5.promisify)(import_node_child_process9.execFile);
 function gitEnv() {
@@ -18965,11 +19232,11 @@ function computeWorkspaceFingerprint(repos) {
   return (0, import_node_crypto10.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex");
 }
 async function copyDirectoryRecursive2(src, dest, skipDirs) {
-  await (0, import_promises31.mkdir)(dest, { recursive: true });
-  const entries = await (0, import_promises31.readdir)(src, { withFileTypes: true });
+  await (0, import_promises32.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises32.readdir)(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = import_node_path45.default.join(src, entry.name);
-    const destPath = import_node_path45.default.join(dest, entry.name);
+    const srcPath = import_node_path46.default.join(src, entry.name);
+    const destPath = import_node_path46.default.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
@@ -18979,7 +19246,7 @@ async function copyDirectoryRecursive2(src, dest, skipDirs) {
       }
       await copyDirectoryRecursive2(srcPath, destPath, skipDirs);
     } else {
-      await (0, import_promises31.cp)(srcPath, destPath, { preserveTimestamps: true, force: true });
+      await (0, import_promises32.cp)(srcPath, destPath, { preserveTimestamps: true, force: true });
     }
   }
 }
@@ -19002,8 +19269,8 @@ var WorkspacePoolManager = class {
   async acquireWorkspace(options) {
     const { templatePath, repos, maxSlots, repoManager, poolReset } = options;
     const fingerprint = computeWorkspaceFingerprint(repos);
-    const poolDir = import_node_path45.default.join(this.poolRoot, fingerprint);
-    await (0, import_promises31.mkdir)(poolDir, { recursive: true });
+    const poolDir = import_node_path46.default.join(this.poolRoot, fingerprint);
+    await (0, import_promises32.mkdir)(poolDir, { recursive: true });
     const drifted = await this.checkDrift(poolDir, fingerprint);
     if (drifted) {
       console.warn(
@@ -19012,7 +19279,7 @@ var WorkspacePoolManager = class {
       await this.removeAllSlots(poolDir);
     }
     for (let i = 0; i < maxSlots; i++) {
-      const slotPath = import_node_path45.default.join(poolDir, `slot-${i}`);
+      const slotPath = import_node_path46.default.join(poolDir, `slot-${i}`);
       const lockPath = `${slotPath}.lock`;
       const locked = await this.tryLock(lockPath);
       if (!locked) {
@@ -19030,7 +19297,7 @@ var WorkspacePoolManager = class {
           poolDir
         };
       }
-      await (0, import_promises31.mkdir)(slotPath, { recursive: true });
+      await (0, import_promises32.mkdir)(slotPath, { recursive: true });
       if (templatePath) {
         await copyDirectoryRecursive2(templatePath, slotPath);
       }
@@ -19054,7 +19321,7 @@ var WorkspacePoolManager = class {
   /** Remove lock file to release a slot. */
   async releaseSlot(slot) {
     try {
-      await (0, import_promises31.unlink)(slot.lockPath);
+      await (0, import_promises32.unlink)(slot.lockPath);
     } catch {
     }
   }
@@ -19067,21 +19334,21 @@ var WorkspacePoolManager = class {
   async tryLock(lockPath) {
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
-        await (0, import_promises31.writeFile)(lockPath, String(process.pid), { flag: "wx" });
+        await (0, import_promises32.writeFile)(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code !== "EEXIST") {
           throw err;
         }
         try {
-          const pidStr = await (0, import_promises31.readFile)(lockPath, "utf-8");
+          const pidStr = await (0, import_promises32.readFile)(lockPath, "utf-8");
           const pid = Number.parseInt(pidStr.trim(), 10);
           if (!Number.isNaN(pid)) {
             try {
               process.kill(pid, 0);
               return false;
             } catch {
-              await (0, import_promises31.unlink)(lockPath).catch(() => {
+              await (0, import_promises32.unlink)(lockPath).catch(() => {
               });
               continue;
             }
@@ -19099,9 +19366,9 @@ var WorkspacePoolManager = class {
    * Returns false (no drift) if metadata.json doesn't exist (first use).
    */
   async checkDrift(poolDir, fingerprint) {
-    const metadataPath = import_node_path45.default.join(poolDir, "metadata.json");
+    const metadataPath = import_node_path46.default.join(poolDir, "metadata.json");
     try {
-      const raw = await (0, import_promises31.readFile)(metadataPath, "utf-8");
+      const raw = await (0, import_promises32.readFile)(metadataPath, "utf-8");
       const metadata = JSON.parse(raw);
       return metadata.fingerprint !== fingerprint;
     } catch {
@@ -19116,17 +19383,17 @@ var WorkspacePoolManager = class {
       repos,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await (0, import_promises31.writeFile)(import_node_path45.default.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+    await (0, import_promises32.writeFile)(import_node_path46.default.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
   }
   /** Remove all slot directories and their lock files from a pool directory. */
   async removeAllSlots(poolDir) {
-    const entries = await (0, import_promises31.readdir)(poolDir);
+    const entries = await (0, import_promises32.readdir)(poolDir);
     for (const entry of entries) {
       if (entry.startsWith("slot-") && !entry.endsWith(".lock")) {
-        const lockPath = import_node_path45.default.join(poolDir, `${entry}.lock`);
+        const lockPath = import_node_path46.default.join(poolDir, `${entry}.lock`);
         if ((0, import_node_fs14.existsSync)(lockPath)) {
           try {
-            const pidStr = await (0, import_promises31.readFile)(lockPath, "utf-8");
+            const pidStr = await (0, import_promises32.readFile)(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
             if (!Number.isNaN(pid)) {
               try {
@@ -19139,12 +19406,12 @@ var WorkspacePoolManager = class {
           } catch {
           }
         }
-        await (0, import_promises31.rm)(import_node_path45.default.join(poolDir, entry), { recursive: true, force: true });
-        await (0, import_promises31.rm)(lockPath, { force: true }).catch(() => {
+        await (0, import_promises32.rm)(import_node_path46.default.join(poolDir, entry), { recursive: true, force: true });
+        await (0, import_promises32.rm)(lockPath, { force: true }).catch(() => {
         });
       }
     }
-    await (0, import_promises31.rm)(import_node_path45.default.join(poolDir, "metadata.json"), { force: true }).catch(() => {
+    await (0, import_promises32.rm)(import_node_path46.default.join(poolDir, "metadata.json"), { force: true }).catch(() => {
     });
   }
   /**
@@ -19154,7 +19421,7 @@ var WorkspacePoolManager = class {
    */
   async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
     for (const repo of repos) {
-      const repoDir = import_node_path45.default.join(slotPath, repo.path);
+      const repoDir = import_node_path46.default.join(slotPath, repo.path);
       if (!(0, import_node_fs14.existsSync)(repoDir)) {
         continue;
       }
@@ -19192,7 +19459,7 @@ var WorkspacePoolManager = class {
 init_cjs_shims();
 var import_node_child_process10 = require("child_process");
 var import_node_fs15 = require("fs");
-var import_node_path46 = __toESM(require("path"), 1);
+var import_node_path47 = __toESM(require("path"), 1);
 var import_node_util6 = require("util");
 var execFileAsync2 = (0, import_node_util6.promisify)(import_node_child_process10.execFile);
 var DEFAULT_TIMEOUT_MS2 = 3e5;
@@ -19292,7 +19559,7 @@ ${lines.join("\n")}`;
    * Handles checkout, ref resolution, ancestor walking, shallow clone, sparse checkout.
    */
   async materialize(repo, workspacePath) {
-    const targetDir = import_node_path46.default.join(workspacePath, repo.path);
+    const targetDir = import_node_path47.default.join(workspacePath, repo.path);
     const sourceUrl = getSourceUrl(repo.source);
     const startedAt = Date.now();
     if (this.verbose) {
@@ -19383,7 +19650,7 @@ ${lines.join("\n")}`;
   async reset(repos, workspacePath, reset) {
     const cleanFlag = reset === "strict" ? "-fdx" : "-fd";
     for (const repo of repos) {
-      const targetDir = import_node_path46.default.join(workspacePath, repo.path);
+      const targetDir = import_node_path47.default.join(workspacePath, repo.path);
       await this.runGit(["reset", "--hard", "HEAD"], { cwd: targetDir });
       await this.runGit(["clean", cleanFlag], { cwd: targetDir });
     }
@@ -19392,36 +19659,36 @@ ${lines.join("\n")}`;
 
 // src/evaluation/workspace/resolve.ts
 init_cjs_shims();
-var import_promises32 = require("fs/promises");
-var import_node_path47 = __toESM(require("path"), 1);
+var import_promises33 = require("fs/promises");
+var import_node_path48 = __toESM(require("path"), 1);
 async function resolveWorkspaceTemplate(templatePath) {
   if (!templatePath) {
     return void 0;
   }
-  const resolved = import_node_path47.default.resolve(templatePath);
-  const stats = await (0, import_promises32.stat)(resolved);
+  const resolved = import_node_path48.default.resolve(templatePath);
+  const stats = await (0, import_promises33.stat)(resolved);
   if (stats.isFile()) {
     return {
-      dir: import_node_path47.default.dirname(resolved),
+      dir: import_node_path48.default.dirname(resolved),
       workspaceFile: resolved
     };
   }
   if (!stats.isDirectory()) {
     throw new Error(`workspace template is neither a file nor a directory: ${resolved}`);
   }
-  const entries = await (0, import_promises32.readdir)(resolved);
+  const entries = await (0, import_promises33.readdir)(resolved);
   const workspaceFiles = entries.filter((e) => e.endsWith(".code-workspace"));
   if (workspaceFiles.length === 1) {
     return {
       dir: resolved,
-      workspaceFile: import_node_path47.default.join(resolved, workspaceFiles[0])
+      workspaceFile: import_node_path48.default.join(resolved, workspaceFiles[0])
     };
   }
   if (workspaceFiles.length > 1) {
     const conventionFile = workspaceFiles.find((f) => f === "template.code-workspace");
     return {
       dir: resolved,
-      workspaceFile: conventionFile ? import_node_path47.default.join(resolved, conventionFile) : void 0
+      workspaceFile: conventionFile ? import_node_path48.default.join(resolved, conventionFile) : void 0
     };
   }
   return { dir: resolved };
@@ -19641,7 +19908,7 @@ async function runEvaluation(options) {
   ];
   const evaluatorRegistry = buildEvaluatorRegistry(evaluators, resolveGraderProvider);
   const typeRegistry = createBuiltinRegistry();
-  const discoveryBaseDir = evalFilePath ? import_node_path48.default.dirname(import_node_path48.default.resolve(evalFilePath)) : process.cwd();
+  const discoveryBaseDir = evalFilePath ? import_node_path49.default.dirname(import_node_path49.default.resolve(evalFilePath)) : process.cwd();
   const evalDir = discoveryBaseDir;
   await discoverAssertions(typeRegistry, discoveryBaseDir);
   await discoverGraders(typeRegistry, discoveryBaseDir);
@@ -19780,16 +20047,16 @@ 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 (0, import_promises33.stat)(configuredStaticPath).then(
+    const dirExists = await (0, import_promises34.stat)(configuredStaticPath).then(
       (s) => s.isDirectory(),
       () => false
     );
-    const isEmpty = dirExists ? (await (0, import_promises33.readdir)(configuredStaticPath)).length === 0 : false;
+    const isEmpty = dirExists ? (await (0, import_promises34.readdir)(configuredStaticPath)).length === 0 : false;
     if (isYamlConfiguredPath && (!dirExists || isEmpty)) {
       if (!dirExists) {
-        await (0, import_promises33.mkdir)(configuredStaticPath, { recursive: true });
+        await (0, import_promises34.mkdir)(configuredStaticPath, { recursive: true });
       }
       if (workspaceTemplate) {
         await copyDirectoryRecursive(workspaceTemplate, configuredStaticPath);
@@ -19834,26 +20101,40 @@ async function runEvaluation(options) {
     }
   } else if (suiteWorkspace?.hooks || suiteWorkspace?.repos?.length && !isPerTestIsolation) {
     sharedWorkspacePath = getWorkspacePath(evalRunId, "shared");
-    await (0, import_promises33.mkdir)(sharedWorkspacePath, { recursive: true });
+    await (0, import_promises34.mkdir)(sharedWorkspacePath, { recursive: true });
     setupLog(`created empty shared workspace at: ${sharedWorkspacePath}`);
   }
   try {
     if (suiteWorkspaceFile && sharedWorkspacePath) {
-      const copiedWorkspaceFile = import_node_path48.default.join(sharedWorkspacePath, import_node_path48.default.basename(suiteWorkspaceFile));
+      const copiedWorkspaceFile = import_node_path49.default.join(sharedWorkspacePath, import_node_path49.default.basename(suiteWorkspaceFile));
       try {
-        await (0, import_promises33.stat)(copiedWorkspaceFile);
+        await (0, import_promises34.stat)(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 = import_node_path49.default.join(sharedWorkspacePath, repo.path);
+            if ((0, import_node_fs16.existsSync)(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);
@@ -20427,9 +20708,9 @@ async function runEvalCase(options) {
         );
       }
       if (caseWorkspaceFile && workspacePath) {
-        const copiedFile = import_node_path48.default.join(workspacePath, import_node_path48.default.basename(caseWorkspaceFile));
+        const copiedFile = import_node_path49.default.join(workspacePath, import_node_path49.default.basename(caseWorkspaceFile));
         try {
-          await (0, import_promises33.stat)(copiedFile);
+          await (0, import_promises34.stat)(copiedFile);
           caseWorkspaceFile = copiedFile;
         } catch {
         }
@@ -20437,7 +20718,7 @@ async function runEvalCase(options) {
     }
     if (!workspacePath && (evalCase.workspace?.hooks || evalCase.workspace?.repos?.length) && evalRunId) {
       workspacePath = getWorkspacePath(evalRunId, evalCase.id);
-      await (0, import_promises33.mkdir)(workspacePath, { recursive: true });
+      await (0, import_promises34.mkdir)(workspacePath, { recursive: true });
     }
     if (evalCase.workspace?.repos?.length && workspacePath) {
       const localPathErrors = RepoManager.validateLocalPaths(evalCase.workspace.repos);
@@ -20489,11 +20770,11 @@ async function runEvalCase(options) {
       const files = evalCase.metadata.agent_skills_files;
       if (baseDir && files.length > 0) {
         for (const relPath of files) {
-          const srcPath = import_node_path48.default.resolve(baseDir, relPath);
-          const destPath = import_node_path48.default.resolve(workspacePath, relPath);
+          const srcPath = import_node_path49.default.resolve(baseDir, relPath);
+          const destPath = import_node_path49.default.resolve(workspacePath, relPath);
           try {
-            await (0, import_promises33.mkdir)(import_node_path48.default.dirname(destPath), { recursive: true });
-            await (0, import_promises33.copyFile)(srcPath, destPath);
+            await (0, import_promises34.mkdir)(import_node_path49.default.dirname(destPath), { recursive: true });
+            await (0, import_promises34.copyFile)(srcPath, destPath);
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             return buildErrorResult(
@@ -21088,6 +21369,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,
@@ -21107,10 +21389,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,
@@ -21160,7 +21453,7 @@ async function runEvaluatorList(options) {
     fileChanges,
     workspacePath
   };
-  const evalFileDir = evalCase.file_paths[0] ? import_node_path48.default.dirname(evalCase.file_paths[0]) : process.cwd();
+  const evalFileDir = evalCase.file_paths[0] ? import_node_path49.default.dirname(evalCase.file_paths[0]) : process.cwd();
   const dispatchContext = {
     graderProvider,
     targetResolver,
@@ -21528,8 +21821,8 @@ function computeWeightedMean(entries) {
 
 // src/evaluation/evaluate.ts
 init_cjs_shims();
-var import_node_fs16 = require("fs");
-var import_node_path49 = __toESM(require("path"), 1);
+var import_node_fs17 = require("fs");
+var import_node_path50 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/function-provider.ts
 init_cjs_shims();
@@ -21567,7 +21860,7 @@ async function evaluate(config) {
   }
   const gitRoot = await findGitRoot(process.cwd());
   const repoRoot = gitRoot ?? process.cwd();
-  const testFilePath = config.specFile ? import_node_path49.default.resolve(config.specFile) : import_node_path49.default.join(process.cwd(), "__programmatic__.yaml");
+  const testFilePath = config.specFile ? import_node_path50.default.resolve(config.specFile) : import_node_path50.default.join(process.cwd(), "__programmatic__.yaml");
   await loadEnvHierarchy(repoRoot, testFilePath);
   let resolvedTarget;
   let taskProvider;
@@ -21682,11 +21975,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 = buildDirectoryChain2(import_node_path49.default.join(cwd, "_placeholder"), repoRoot);
+  const chain = buildDirectoryChain2(import_node_path50.default.join(cwd, "_placeholder"), repoRoot);
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const targetsPath = import_node_path49.default.join(dir, candidate);
-      if (!(0, import_node_fs16.existsSync)(targetsPath)) continue;
+      const targetsPath = import_node_path50.default.join(dir, candidate);
+      if (!(0, import_node_fs17.existsSync)(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
         const defaultTarget = definitions.find((d) => d.name === "default");
@@ -21702,8 +21995,8 @@ async function loadEnvHierarchy(repoRoot, startPath) {
   const chain = buildDirectoryChain2(startPath, repoRoot);
   const envFiles = [];
   for (const dir of chain) {
-    const envPath = import_node_path49.default.join(dir, ".env");
-    if ((0, import_node_fs16.existsSync)(envPath)) envFiles.push(envPath);
+    const envPath = import_node_path50.default.join(dir, ".env");
+    if ((0, import_node_fs17.existsSync)(envPath)) envFiles.push(envPath);
   }
   for (let i = 0; i < envFiles.length; i++) {
     try {
@@ -21780,12 +22073,12 @@ var CONFIG_FILE_NAMES = [
   ".agentv/config.js"
 ];
 async function loadTsConfig(projectRoot) {
-  const { existsSync: existsSync7 } = await import("fs");
+  const { existsSync: existsSync8 } = await import("fs");
   const { pathToFileURL: pathToFileURL2 } = await import("url");
   const { join: join2 } = await import("path");
   for (const fileName of CONFIG_FILE_NAMES) {
     const filePath = join2(projectRoot, fileName);
-    if (!existsSync7(filePath)) {
+    if (!existsSync8(filePath)) {
       continue;
     }
     try {
@@ -21890,8 +22183,8 @@ init_cjs_shims();
 
 // src/evaluation/workspace/deps-scanner.ts
 init_cjs_shims();
-var import_promises34 = require("fs/promises");
-var import_node_path50 = __toESM(require("path"), 1);
+var import_promises35 = require("fs/promises");
+var import_node_path51 = __toESM(require("path"), 1);
 var import_yaml8 = require("yaml");
 function normalizeGitUrl(url) {
   let normalized = url.replace(/\.git$/, "");
@@ -21938,11 +22231,11 @@ async function scanRepoDeps(evalFilePaths) {
   return { repos: [...seen.values()], errors };
 }
 async function extractReposFromEvalFile(filePath) {
-  const content = await (0, import_promises34.readFile)(filePath, "utf8");
+  const content = await (0, import_promises35.readFile)(filePath, "utf8");
   const parsed = interpolateEnv((0, import_yaml8.parse)(content), process.env);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
   const obj = parsed;
-  const evalFileDir = import_node_path50.default.dirname(import_node_path50.default.resolve(filePath));
+  const evalFileDir = import_node_path51.default.dirname(import_node_path51.default.resolve(filePath));
   const repos = [];
   const suiteRepos = await extractReposFromWorkspaceRaw(obj.workspace, evalFileDir);
   repos.push(...suiteRepos);
@@ -21958,8 +22251,8 @@ async function extractReposFromEvalFile(filePath) {
 }
 async function extractReposFromWorkspaceRaw(raw, evalFileDir) {
   if (typeof raw === "string") {
-    const workspaceFilePath = import_node_path50.default.resolve(evalFileDir, raw);
-    const content = await (0, import_promises34.readFile)(workspaceFilePath, "utf8");
+    const workspaceFilePath = import_node_path51.default.resolve(evalFileDir, raw);
+    const content = await (0, import_promises35.readFile)(workspaceFilePath, "utf8");
     const parsed = interpolateEnv((0, import_yaml8.parse)(content), process.env);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
     return extractReposFromObject(parsed);
@@ -21988,8 +22281,8 @@ function extractReposFromObject(obj) {
 
 // src/evaluation/cache/response-cache.ts
 init_cjs_shims();
-var import_promises35 = require("fs/promises");
-var import_node_path51 = __toESM(require("path"), 1);
+var import_promises36 = require("fs/promises");
+var import_node_path52 = __toESM(require("path"), 1);
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
   cachePath;
@@ -21999,7 +22292,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await (0, import_promises35.readFile)(filePath, "utf8");
+      const data = await (0, import_promises36.readFile)(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -22007,13 +22300,13 @@ var ResponseCache = class {
   }
   async set(key, value) {
     const filePath = this.keyToPath(key);
-    const dir = import_node_path51.default.dirname(filePath);
-    await (0, import_promises35.mkdir)(dir, { recursive: true });
-    await (0, import_promises35.writeFile)(filePath, JSON.stringify(value, null, 2), "utf8");
+    const dir = import_node_path52.default.dirname(filePath);
+    await (0, import_promises36.mkdir)(dir, { recursive: true });
+    await (0, import_promises36.writeFile)(filePath, JSON.stringify(value, null, 2), "utf8");
   }
   keyToPath(key) {
     const prefix = key.slice(0, 2);
-    return import_node_path51.default.join(this.cachePath, prefix, `${key}.json`);
+    return import_node_path52.default.join(this.cachePath, prefix, `${key}.json`);
   }
 };
 function shouldEnableCache(params) {
@@ -22030,19 +22323,19 @@ function shouldSkipCacheForTemperature(targetConfig) {
 
 // src/projects.ts
 init_cjs_shims();
-var import_node_fs17 = require("fs");
-var import_node_path52 = __toESM(require("path"), 1);
+var import_node_fs18 = require("fs");
+var import_node_path53 = __toESM(require("path"), 1);
 var import_yaml9 = require("yaml");
 function getProjectsRegistryPath() {
-  return import_node_path52.default.join(getAgentvHome(), "projects.yaml");
+  return import_node_path53.default.join(getAgentvHome(), "projects.yaml");
 }
 function loadProjectRegistry() {
   const registryPath = getProjectsRegistryPath();
-  if (!(0, import_node_fs17.existsSync)(registryPath)) {
+  if (!(0, import_node_fs18.existsSync)(registryPath)) {
     return { projects: [] };
   }
   try {
-    const raw = (0, import_node_fs17.readFileSync)(registryPath, "utf-8");
+    const raw = (0, import_node_fs18.readFileSync)(registryPath, "utf-8");
     const parsed = (0, import_yaml9.parse)(raw);
     if (!parsed || !Array.isArray(parsed.projects)) {
       return { projects: [] };
@@ -22054,14 +22347,14 @@ function loadProjectRegistry() {
 }
 function saveProjectRegistry(registry) {
   const registryPath = getProjectsRegistryPath();
-  const dir = import_node_path52.default.dirname(registryPath);
-  if (!(0, import_node_fs17.existsSync)(dir)) {
-    (0, import_node_fs17.mkdirSync)(dir, { recursive: true });
+  const dir = import_node_path53.default.dirname(registryPath);
+  if (!(0, import_node_fs18.existsSync)(dir)) {
+    (0, import_node_fs18.mkdirSync)(dir, { recursive: true });
   }
-  (0, import_node_fs17.writeFileSync)(registryPath, (0, import_yaml9.stringify)(registry), "utf-8");
+  (0, import_node_fs18.writeFileSync)(registryPath, (0, import_yaml9.stringify)(registry), "utf-8");
 }
 function deriveProjectId(dirPath, existingIds) {
-  const base = import_node_path52.default.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const base = import_node_path53.default.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   let candidate = base || "project";
   let suffix = 2;
   while (existingIds.includes(candidate)) {
@@ -22071,11 +22364,11 @@ function deriveProjectId(dirPath, existingIds) {
   return candidate;
 }
 function addProject(projectPath) {
-  const absPath = import_node_path52.default.resolve(projectPath);
-  if (!(0, import_node_fs17.existsSync)(absPath)) {
+  const absPath = import_node_path53.default.resolve(projectPath);
+  if (!(0, import_node_fs18.existsSync)(absPath)) {
     throw new Error(`Directory not found: ${absPath}`);
   }
-  if (!(0, import_node_fs17.existsSync)(import_node_path52.default.join(absPath, ".agentv"))) {
+  if (!(0, import_node_fs18.existsSync)(import_node_path53.default.join(absPath, ".agentv"))) {
     throw new Error(`No .agentv/ directory found in ${absPath}. Run an evaluation first.`);
   }
   const registry = loadProjectRegistry();
@@ -22089,7 +22382,7 @@ function addProject(projectPath) {
       absPath,
       registry.projects.map((p) => p.id)
     ),
-    name: import_node_path52.default.basename(absPath),
+    name: import_node_path53.default.basename(absPath),
     path: absPath,
     addedAt: now,
     lastOpenedAt: now
@@ -22118,24 +22411,24 @@ function touchProject(projectId) {
   }
 }
 function discoverProjects(rootDir, maxDepth = 2) {
-  const absRoot = import_node_path52.default.resolve(rootDir);
-  if (!(0, import_node_fs17.existsSync)(absRoot) || !(0, import_node_fs17.statSync)(absRoot).isDirectory()) {
+  const absRoot = import_node_path53.default.resolve(rootDir);
+  if (!(0, import_node_fs18.existsSync)(absRoot) || !(0, import_node_fs18.statSync)(absRoot).isDirectory()) {
     return [];
   }
   const results = [];
   function scan(dir, depth) {
     if (depth > maxDepth) return;
-    if ((0, import_node_fs17.existsSync)(import_node_path52.default.join(dir, ".agentv"))) {
+    if ((0, import_node_fs18.existsSync)(import_node_path53.default.join(dir, ".agentv"))) {
       results.push(dir);
       return;
     }
     if (depth === maxDepth) return;
     try {
-      const entries = (0, import_node_fs17.readdirSync)(dir, { withFileTypes: true });
+      const entries = (0, import_node_fs18.readdirSync)(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-        scan(import_node_path52.default.join(dir, entry.name), depth + 1);
+        scan(import_node_path53.default.join(dir, entry.name), depth + 1);
       }
     } catch {
     }
@@ -23061,33 +23354,33 @@ function extractResponseItemContent(content) {
 
 // src/import/codex-session-discovery.ts
 init_cjs_shims();
-var import_promises37 = require("fs/promises");
+var import_promises38 = require("fs/promises");
 var import_node_os8 = require("os");
-var import_node_path54 = __toESM(require("path"), 1);
-var DEFAULT_SESSIONS_DIR = () => import_node_path54.default.join((0, import_node_os8.homedir)(), ".codex", "sessions");
+var import_node_path55 = __toESM(require("path"), 1);
+var DEFAULT_SESSIONS_DIR = () => import_node_path55.default.join((0, import_node_os8.homedir)(), ".codex", "sessions");
 async function discoverCodexSessions(opts) {
   const sessionsDir = opts?.sessionsDir ?? DEFAULT_SESSIONS_DIR();
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
   const sessions = [];
   let yearDirs;
   try {
-    yearDirs = await (0, import_promises37.readdir)(sessionsDir);
+    yearDirs = await (0, import_promises38.readdir)(sessionsDir);
   } catch {
     return [];
   }
   for (const year of yearDirs) {
-    const yearPath = import_node_path54.default.join(sessionsDir, year);
+    const yearPath = import_node_path55.default.join(sessionsDir, year);
     let monthDirs;
     try {
-      monthDirs = await (0, import_promises37.readdir)(yearPath);
+      monthDirs = await (0, import_promises38.readdir)(yearPath);
     } catch {
       continue;
     }
     for (const month of monthDirs) {
-      const monthPath = import_node_path54.default.join(yearPath, month);
+      const monthPath = import_node_path55.default.join(yearPath, month);
       let dayDirs;
       try {
-        dayDirs = await (0, import_promises37.readdir)(monthPath);
+        dayDirs = await (0, import_promises38.readdir)(monthPath);
       } catch {
         continue;
       }
@@ -23096,22 +23389,22 @@ async function discoverCodexSessions(opts) {
           const dirDate = `${year}-${month}-${day}`;
           if (dirDate !== opts.date) continue;
         }
-        const dayPath = import_node_path54.default.join(monthPath, day);
+        const dayPath = import_node_path55.default.join(monthPath, day);
         let files;
         try {
-          files = await (0, import_promises37.readdir)(dayPath);
+          files = await (0, import_promises38.readdir)(dayPath);
         } catch {
           continue;
         }
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = import_node_path54.default.join(dayPath, file);
+          const filePath = import_node_path55.default.join(dayPath, file);
           const nameWithoutExt = file.replace(/\.jsonl$/, "");
           const parts = nameWithoutExt.split("-");
           const sessionId = parts.length >= 6 ? parts.slice(-5).join("-") : nameWithoutExt;
           let updatedAt;
           try {
-            const fileStat = await (0, import_promises37.stat)(filePath);
+            const fileStat = await (0, import_promises38.stat)(filePath);
             updatedAt = fileStat.mtime;
           } catch {
             updatedAt = /* @__PURE__ */ new Date(0);
@@ -23127,10 +23420,10 @@ async function discoverCodexSessions(opts) {
 
 // src/import/session-discovery.ts
 init_cjs_shims();
-var import_promises38 = require("fs/promises");
+var import_promises39 = require("fs/promises");
 var import_node_os9 = require("os");
-var import_node_path55 = __toESM(require("path"), 1);
-var DEFAULT_PROJECTS_DIR = () => import_node_path55.default.join((0, import_node_os9.homedir)(), ".claude", "projects");
+var import_node_path56 = __toESM(require("path"), 1);
+var DEFAULT_PROJECTS_DIR = () => import_node_path56.default.join((0, import_node_os9.homedir)(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -23139,7 +23432,7 @@ async function discoverClaudeSessions(opts) {
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
   let projectDirs;
   try {
-    projectDirs = await (0, import_promises38.readdir)(projectsDir);
+    projectDirs = await (0, import_promises39.readdir)(projectsDir);
   } catch {
     return [];
   }
@@ -23149,10 +23442,10 @@ async function discoverClaudeSessions(opts) {
   }
   const sessions = [];
   for (const projectDir of projectDirs) {
-    const dirPath = import_node_path55.default.join(projectsDir, projectDir);
+    const dirPath = import_node_path56.default.join(projectsDir, projectDir);
     let entries;
     try {
-      entries = await (0, import_promises38.readdir)(dirPath);
+      entries = await (0, import_promises39.readdir)(dirPath);
     } catch {
       continue;
     }
@@ -23160,10 +23453,10 @@ async function discoverClaudeSessions(opts) {
       if (!entry.endsWith(".jsonl")) continue;
       const sessionId = entry.replace(/\.jsonl$/, "");
       if (opts?.sessionId && sessionId !== opts.sessionId) continue;
-      const filePath = import_node_path55.default.join(dirPath, entry);
+      const filePath = import_node_path56.default.join(dirPath, entry);
       let updatedAt;
       try {
-        const fileStat = await (0, import_promises38.stat)(filePath);
+        const fileStat = await (0, import_promises39.stat)(filePath);
         updatedAt = fileStat.mtime;
       } catch {
         updatedAt = /* @__PURE__ */ new Date(0);
@@ -23185,7 +23478,7 @@ init_cjs_shims();
 
 // src/import/types.ts
 init_cjs_shims();
-var import_promises39 = require("fs/promises");
+var import_promises40 = require("fs/promises");
 function toTranscriptJsonLine(entry) {
   const firstUserMessage = entry.messages.find((m) => m.role === "user");
   const input = typeof firstUserMessage?.content === "string" ? firstUserMessage.content : "";
@@ -23211,11 +23504,11 @@ function toTranscriptJsonLine(entry) {
   };
 }
 async function readTranscriptJsonl(filePath) {
-  const text = await (0, import_promises39.readFile)(filePath, "utf8");
+  const text = await (0, import_promises40.readFile)(filePath, "utf8");
   return text.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
 }
 async function readTranscriptFile(filePath) {
-  return (0, import_promises39.readFile)(filePath, "utf8");
+  return (0, import_promises40.readFile)(filePath, "utf8");
 }
 
 // src/import/transcript-provider.ts