agentv 3.7.0 → 3.8.0

package/dist/{chunk-XGG64VIY.js → chunk-F4UDJ7LG.js}

@@ -301,7 +301,7 @@ var require_dist = __commonJS({
   }
 });
 
-// ../../packages/core/dist/chunk-2IZOTQ25.js
+// ../../packages/core/dist/chunk-3ZS3GCMI.js
 import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
@@ -419,7 +419,11 @@ __export(external_exports2, {
   void: () => voidType
 });
 
-// ../../packages/core/dist/chunk-2IZOTQ25.js
+// ../../packages/core/dist/chunk-3ZS3GCMI.js
+import { readFile as readFile2 } from "node:fs/promises";
+import path3 from "node:path";
+import fg from "fast-glob";
+import { parse as parseYaml } from "yaml";
 var TEST_MESSAGE_ROLE_VALUES = ["system", "user", "assistant", "tool"];
 var TEST_MESSAGE_ROLES = TEST_MESSAGE_ROLE_VALUES;
 var TEST_MESSAGE_ROLE_SET = new Set(TEST_MESSAGE_ROLE_VALUES);
@@ -1595,8 +1599,8 @@ function resolveCliConfig(target, env, evalFilePath) {
   const parseResult = CliTargetInputSchema.safeParse(target, { errorMap: cliErrorMap });
   if (!parseResult.success) {
     const firstError = parseResult.error.errors[0];
-    const path310 = firstError?.path.join(".") || "";
-    const prefix = path310 ? `${target.name} ${path310}: ` : `${target.name}: `;
+    const path45 = firstError?.path.join(".") || "";
+    const prefix = path45 ? `${target.name} ${path45}: ` : `${target.name}: `;
     throw new Error(`${prefix}${firstError?.message}`);
   }
   const normalized = normalizeCliTargetInput(parseResult.data, env, evalFilePath);
@@ -1802,6 +1806,135 @@ function resolveOptionalNumberArray(source, description) {
   }
   return resolved.length > 0 ? resolved : void 0;
 }
+var ENV_VAR_PATTERN = /\$\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
+function interpolateEnv(value, env) {
+  if (typeof value === "string") {
+    return value.replace(ENV_VAR_PATTERN, (_, varName) => env[varName] ?? "");
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => interpolateEnv(item, env));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = interpolateEnv(val, env);
+    }
+    return result;
+  }
+  return value;
+}
+var ANSI_YELLOW = "\x1B[33m";
+var ANSI_RESET = "\x1B[0m";
+var FILE_PROTOCOL = "file://";
+function isFileReference(value) {
+  return typeof value === "string" && value.startsWith(FILE_PROTOCOL);
+}
+function extractFilePath(ref) {
+  return ref.slice(FILE_PROTOCOL.length);
+}
+function isGlobPattern(filePath) {
+  return filePath.includes("*") || filePath.includes("?") || filePath.includes("{");
+}
+function parseYamlCases(content, filePath) {
+  const raw = parseYaml(content);
+  const parsed = interpolateEnv(raw, process.env);
+  if (!Array.isArray(parsed)) {
+    throw new Error(
+      `External test file must contain a YAML array, got ${typeof parsed}: ${filePath}`
+    );
+  }
+  const results = [];
+  for (const item of parsed) {
+    if (!isJsonObject(item)) {
+      throw new Error(`External test file contains non-object entry: ${filePath}`);
+    }
+    results.push(item);
+  }
+  return results;
+}
+function parseJsonlCases(content, filePath) {
+  const lines = content.split("\n");
+  const results = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === "") continue;
+    try {
+      const raw = JSON.parse(line);
+      const parsed = interpolateEnv(raw, process.env);
+      if (!isJsonObject(parsed)) {
+        throw new Error("Expected JSON object");
+      }
+      results.push(parsed);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Malformed JSONL at line ${i + 1}: ${message}
+  File: ${filePath}`);
+    }
+  }
+  return results;
+}
+async function loadCasesFromFile(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  let content;
+  try {
+    content = await readFile2(filePath, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Cannot read external test file: ${filePath}
+  ${message}`);
+  }
+  if (content.trim() === "") {
+    console.warn(
+      `${ANSI_YELLOW}Warning: External test file is empty, skipping: ${filePath}${ANSI_RESET}`
+    );
+    return [];
+  }
+  if (ext === ".yaml" || ext === ".yml") {
+    return parseYamlCases(content, filePath);
+  }
+  if (ext === ".jsonl") {
+    return parseJsonlCases(content, filePath);
+  }
+  throw new Error(
+    `Unsupported external test file format '${ext}': ${filePath}. Supported: .yaml, .yml, .jsonl`
+  );
+}
+async function resolveFileReference2(ref, evalFileDir) {
+  const rawPath = extractFilePath(ref);
+  const absolutePattern = path3.resolve(evalFileDir, rawPath);
+  if (isGlobPattern(rawPath)) {
+    const matches = await fg(absolutePattern.replaceAll("\\", "/"), {
+      onlyFiles: true,
+      absolute: true
+    });
+    if (matches.length === 0) {
+      console.warn(
+        `${ANSI_YELLOW}Warning: Glob pattern matched no files: ${ref} (resolved to ${absolutePattern})${ANSI_RESET}`
+      );
+      return [];
+    }
+    matches.sort();
+    const allCases = [];
+    for (const match of matches) {
+      const cases = await loadCasesFromFile(match);
+      allCases.push(...cases);
+    }
+    return allCases;
+  }
+  return loadCasesFromFile(absolutePattern);
+}
+async function expandFileReferences(tests, evalFileDir) {
+  const expanded = [];
+  for (const entry of tests) {
+    if (isFileReference(entry)) {
+      const cases = await resolveFileReference2(entry, evalFileDir);
+      expanded.push(...cases);
+    } else {
+      expanded.push(entry);
+    }
+  }
+  return expanded;
+}
 var AGENT_PROVIDER_KINDS = [
   "codex",
   "copilot-sdk",
@@ -1876,36 +2009,32 @@ function isAgentProvider(provider) {
 }
 
 // ../../packages/core/dist/index.js
-import { readFile as readFile8 } from "node:fs/promises";
-import path9 from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import path8 from "node:path";
 import micromatch3 from "micromatch";
 import { parse as parse2 } from "yaml";
-import { readFile as readFile2 } from "node:fs/promises";
-import path3 from "node:path";
-import { readFile as readFile22 } from "node:fs/promises";
-import path22 from "node:path";
-import fg from "fast-glob";
-import { parse as parseYaml } from "yaml";
 import { readFile as readFile3 } from "node:fs/promises";
 import path4 from "node:path";
+import { readFile as readFile22 } from "node:fs/promises";
+import path32 from "node:path";
 import micromatch from "micromatch";
 import { parse } from "yaml";
 import { constants as constants2 } from "node:fs";
 import { access as access2 } from "node:fs/promises";
-import path32 from "node:path";
+import path22 from "node:path";
 import { fileURLToPath } from "node:url";
-import path5 from "node:path";
+import path42 from "node:path";
+import { readFile as readFile32 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
+import path6 from "node:path";
+import micromatch2 from "micromatch";
+import { parse as parseYaml2 } from "yaml";
 import { readFile as readFile4 } from "node:fs/promises";
+import path5 from "node:path";
 import { readFile as readFile6 } from "node:fs/promises";
 import path7 from "node:path";
-import micromatch2 from "micromatch";
-import { parse as parseYaml2 } from "yaml";
-import { readFile as readFile5 } from "node:fs/promises";
-import path6 from "node:path";
-import { readFile as readFile7 } from "node:fs/promises";
-import path8 from "node:path";
 import { readFileSync } from "node:fs";
-import path10 from "node:path";
+import path9 from "node:path";
 import { parse as parse3 } from "yaml";
 import { createOpenAI } from "@ai-sdk/openai";
 
@@ -6379,7 +6508,7 @@ function createOpenRouter(options = {}) {
   );
   const createChatModel = (modelId, settings = {}) => new OpenRouterChatLanguageModel(modelId, settings, {
     provider: "openrouter.chat",
-    url: ({ path: path46 }) => `${baseURL}${path46}`,
+    url: ({ path: path45 }) => `${baseURL}${path45}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -6387,7 +6516,7 @@ function createOpenRouter(options = {}) {
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenRouterCompletionLanguageModel(modelId, settings, {
     provider: "openrouter.completion",
-    url: ({ path: path46 }) => `${baseURL}${path46}`,
+    url: ({ path: path45 }) => `${baseURL}${path45}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -6395,14 +6524,14 @@ function createOpenRouter(options = {}) {
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenRouterEmbeddingModel(modelId, settings, {
     provider: "openrouter.embedding",
-    url: ({ path: path46 }) => `${baseURL}${path46}`,
+    url: ({ path: path45 }) => `${baseURL}${path45}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
   });
   const createImageModel = (modelId, settings = {}) => new OpenRouterImageModel(modelId, settings, {
     provider: "openrouter.image",
-    url: ({ path: path46 }) => `${baseURL}${path46}`,
+    url: ({ path: path45 }) => `${baseURL}${path45}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
@@ -12398,24 +12527,24 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { createWriteStream } from "node:fs";
 import { mkdir } from "node:fs/promises";
-import path12 from "node:path";
 import path11 from "node:path";
+import path10 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { createWriteStream as createWriteStream2 } from "node:fs";
 import { mkdir as mkdir2 } from "node:fs/promises";
-import path13 from "node:path";
+import path12 from "node:path";
 import { exec as execWithCallback } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
-import path14 from "node:path";
+import path13 from "node:path";
 import { promisify } from "node:util";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { createWriteStream as createWriteStream3 } from "node:fs";
 import { mkdir as mkdir3 } from "node:fs/promises";
-import path15 from "node:path";
+import path14 from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { mkdir as mkdir4 } from "node:fs/promises";
-import path17 from "node:path";
+import path16 from "node:path";
 import { Readable, Writable } from "node:stream";
 import { spawn as spawn2 } from "node:child_process";
 
@@ -13900,48 +14029,48 @@ var RequestError = class _RequestError extends Error {
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { createWriteStream as createWriteStream4, existsSync, readdirSync } from "node:fs";
 import { arch, platform } from "node:os";
-import path16 from "node:path";
+import path15 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { mkdir as mkdir5 } from "node:fs/promises";
-import path18 from "node:path";
+import path17 from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { createWriteStream as createWriteStream5 } from "node:fs";
 import { mkdir as mkdir6, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path19 from "node:path";
+import path18 from "node:path";
 import { exec as exec2 } from "node:child_process";
 import { constants as constants3, access as access3, stat as stat4 } from "node:fs/promises";
-import path31 from "node:path";
+import path30 from "node:path";
 import { promisify as promisify3 } from "node:util";
 import { stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
-import path29 from "node:path";
+import path28 from "node:path";
 import { constants as constants22 } from "node:fs";
 import { access as access22, mkdir as mkdir7, readdir, rm as rm2, stat } from "node:fs/promises";
+import path19 from "node:path";
 import path20 from "node:path";
 import path21 from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
 import path222 from "node:path";
-import { readFile as readFile9 } from "node:fs/promises";
-import path23 from "node:path";
 import { exec, spawn as spawn4 } from "node:child_process";
 import { mkdir as mkdir8, writeFile as writeFile2 } from "node:fs/promises";
-import path26 from "node:path";
-import { promisify as promisify2 } from "node:util";
 import path25 from "node:path";
-import os2 from "node:os";
+import { promisify as promisify2 } from "node:util";
 import path24 from "node:path";
-import { copyFile, mkdir as mkdir9, readFile as readFile10, readdir as readdir2, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
-import path28 from "node:path";
+import os2 from "node:os";
+import path23 from "node:path";
+import { copyFile, mkdir as mkdir9, readFile as readFile9, readdir as readdir2, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
 import path27 from "node:path";
+import path26 from "node:path";
 import JSON5 from "json5";
 import { writeFile as writeFile5 } from "node:fs/promises";
-import path30 from "node:path";
+import path29 from "node:path";
 import { constants as constants4 } from "node:fs";
-import { access as access4, readFile as readFile11 } from "node:fs/promises";
-import path322 from "node:path";
+import { access as access4, readFile as readFile10 } from "node:fs/promises";
+import path31 from "node:path";
 import { parse as parse4 } from "yaml";
-import path33 from "node:path";
+import path322 from "node:path";
 import fg2 from "fast-glob";
 import { mkdtemp as mkdtemp2, rm as rm3, writeFile as writeFile6 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
@@ -13949,38 +14078,38 @@ import { dirname, join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { createServer } from "node:http";
 import fs2 from "node:fs/promises";
-import path34 from "node:path";
+import path33 from "node:path";
 import { createHash as createHash2, randomUUID as randomUUID8 } from "node:crypto";
 import { copyFile as copyFile2, mkdir as mkdir13, readdir as readdir6, stat as stat7 } from "node:fs/promises";
-import path43 from "node:path";
+import path422 from "node:path";
 import micromatch4 from "micromatch";
+import path34 from "node:path";
 import path35 from "node:path";
+import fg22 from "fast-glob";
 import path36 from "node:path";
 import fg3 from "fast-glob";
-import path37 from "node:path";
-import fg4 from "fast-glob";
 import { exec as execCallback } from "node:child_process";
 import { readdirSync as readdirSync2, statSync } from "node:fs";
-import path38 from "node:path";
+import path37 from "node:path";
 import { promisify as promisify4 } from "node:util";
 import { cp, mkdir as mkdir11, readdir as readdir3, rm as rm4, stat as stat5 } from "node:fs/promises";
-import path39 from "node:path";
+import path38 from "node:path";
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
-import { cp as cp2, mkdir as mkdir12, readFile as readFile12, readdir as readdir4, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
-import path40 from "node:path";
+import { cp as cp2, mkdir as mkdir12, readFile as readFile11, readdir as readdir4, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
+import path39 from "node:path";
 import { promisify as promisify5 } from "node:util";
 import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync3 } from "node:fs";
-import path41 from "node:path";
+import path40 from "node:path";
 import { promisify as promisify6 } from "node:util";
 import { readdir as readdir5, stat as stat6 } from "node:fs/promises";
-import path42 from "node:path";
+import path41 from "node:path";
 import { existsSync as existsSync4 } from "node:fs";
+import path43 from "node:path";
+import { mkdir as mkdir14, readFile as readFile12, writeFile as writeFile8 } from "node:fs/promises";
 import path44 from "node:path";
-import { mkdir as mkdir14, readFile as readFile13, writeFile as writeFile8 } from "node:fs/promises";
-import path45 from "node:path";
 function computeTraceSummary(messages) {
   const toolCallCounts = {};
   const toolDurations = {};
@@ -14097,27 +14226,10 @@ function mergeExecutionMetrics(computed, metrics) {
     endTime: metrics.endTime ?? computed.endTime
   };
 }
-var ENV_VAR_PATTERN = /\$\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
-function interpolateEnv(value, env) {
-  if (typeof value === "string") {
-    return value.replace(ENV_VAR_PATTERN, (_, varName) => env[varName] ?? "");
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => interpolateEnv(item, env));
-  }
-  if (value !== null && typeof value === "object") {
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      result[key] = interpolateEnv(val, env);
-    }
-    return result;
-  }
-  return value;
-}
 var ANSI_RED = "\x1B[31m";
-var ANSI_RESET = "\x1B[0m";
+var ANSI_RESET2 = "\x1B[0m";
 function logError(msg) {
-  console.error(`${ANSI_RED}Error: ${msg}${ANSI_RESET}`);
+  console.error(`${ANSI_RED}Error: ${msg}${ANSI_RESET2}`);
 }
 function isAgentSkillsFormat(parsed) {
   if (typeof parsed !== "object" || parsed === null) return false;
@@ -14125,14 +14237,14 @@ function isAgentSkillsFormat(parsed) {
   return Array.isArray(obj.evals);
 }
 async function loadTestsFromAgentSkills(filePath) {
-  const raw = await readFile2(filePath, "utf8");
+  const raw = await readFile3(filePath, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
     throw new Error(`Invalid Agent Skills evals.json: failed to parse JSON in '${filePath}'`);
   }
-  return parseAgentSkillsEvals(parsed, filePath, path3.dirname(path3.resolve(filePath)));
+  return parseAgentSkillsEvals(parsed, filePath, path4.dirname(path4.resolve(filePath)));
 }
 function parseAgentSkillsEvals(parsed, source = "evals.json", baseDir) {
   if (!isAgentSkillsFormat(parsed)) {
@@ -14170,7 +14282,7 @@ function parseAgentSkillsEvals(parsed, source = "evals.json", baseDir) {
       if (baseDir) {
         metadata.agent_skills_base_dir = baseDir;
         for (const file of evalCase.files) {
-          filePaths.push(path3.resolve(baseDir, file));
+          filePaths.push(path4.resolve(baseDir, file));
         }
       }
     }
@@ -14192,118 +14304,6 @@ function parseAgentSkillsEvals(parsed, source = "evals.json", baseDir) {
   }
   return tests;
 }
-var ANSI_YELLOW = "\x1B[33m";
-var ANSI_RESET2 = "\x1B[0m";
-var FILE_PROTOCOL = "file://";
-function isFileReference(value) {
-  return typeof value === "string" && value.startsWith(FILE_PROTOCOL);
-}
-function extractFilePath(ref) {
-  return ref.slice(FILE_PROTOCOL.length);
-}
-function isGlobPattern(filePath) {
-  return filePath.includes("*") || filePath.includes("?") || filePath.includes("{");
-}
-function parseYamlCases(content, filePath) {
-  const raw = parseYaml(content);
-  const parsed = interpolateEnv(raw, process.env);
-  if (!Array.isArray(parsed)) {
-    throw new Error(
-      `External test file must contain a YAML array, got ${typeof parsed}: ${filePath}`
-    );
-  }
-  const results = [];
-  for (const item of parsed) {
-    if (!isJsonObject(item)) {
-      throw new Error(`External test file contains non-object entry: ${filePath}`);
-    }
-    results.push(item);
-  }
-  return results;
-}
-function parseJsonlCases(content, filePath) {
-  const lines = content.split("\n");
-  const results = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i].trim();
-    if (line === "") continue;
-    try {
-      const raw = JSON.parse(line);
-      const parsed = interpolateEnv(raw, process.env);
-      if (!isJsonObject(parsed)) {
-        throw new Error("Expected JSON object");
-      }
-      results.push(parsed);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Malformed JSONL at line ${i + 1}: ${message}
-  File: ${filePath}`);
-    }
-  }
-  return results;
-}
-async function loadCasesFromFile(filePath) {
-  const ext = path22.extname(filePath).toLowerCase();
-  let content;
-  try {
-    content = await readFile22(filePath, "utf8");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Cannot read external test file: ${filePath}
-  ${message}`);
-  }
-  if (content.trim() === "") {
-    console.warn(
-      `${ANSI_YELLOW}Warning: External test file is empty, skipping: ${filePath}${ANSI_RESET2}`
-    );
-    return [];
-  }
-  if (ext === ".yaml" || ext === ".yml") {
-    return parseYamlCases(content, filePath);
-  }
-  if (ext === ".jsonl") {
-    return parseJsonlCases(content, filePath);
-  }
-  throw new Error(
-    `Unsupported external test file format '${ext}': ${filePath}. Supported: .yaml, .yml, .jsonl`
-  );
-}
-async function resolveFileReference2(ref, evalFileDir) {
-  const rawPath = extractFilePath(ref);
-  const absolutePattern = path22.resolve(evalFileDir, rawPath);
-  if (isGlobPattern(rawPath)) {
-    const matches = await fg(absolutePattern.replaceAll("\\", "/"), {
-      onlyFiles: true,
-      absolute: true
-    });
-    if (matches.length === 0) {
-      console.warn(
-        `${ANSI_YELLOW}Warning: Glob pattern matched no files: ${ref} (resolved to ${absolutePattern})${ANSI_RESET2}`
-      );
-      return [];
-    }
-    matches.sort();
-    const allCases = [];
-    for (const match of matches) {
-      const cases = await loadCasesFromFile(match);
-      allCases.push(...cases);
-    }
-    return allCases;
-  }
-  return loadCasesFromFile(absolutePattern);
-}
-async function expandFileReferences(tests, evalFileDir) {
-  const expanded = [];
-  for (const entry of tests) {
-    if (isFileReference(entry)) {
-      const cases = await resolveFileReference2(entry, evalFileDir);
-      expanded.push(...cases);
-    } else {
-      expanded.push(entry);
-    }
-  }
-  return expanded;
-}
 async function fileExists2(absolutePath) {
   try {
     await access2(absolutePath, constants2.F_OK);
@@ -14320,15 +14320,15 @@ function resolveToAbsolutePath(candidate) {
     if (candidate.startsWith("file:")) {
       return fileURLToPath(candidate);
     }
-    return path32.resolve(candidate);
+    return path22.resolve(candidate);
   }
   throw new TypeError("Unsupported repoRoot value. Expected string or URL.");
 }
 function buildDirectoryChain2(filePath, repoRoot) {
   const directories = [];
   const seen = /* @__PURE__ */ new Set();
-  const boundary = path32.resolve(repoRoot);
-  let current = path32.resolve(path32.dirname(filePath));
+  const boundary = path22.resolve(repoRoot);
+  let current = path22.resolve(path22.dirname(filePath));
   while (current !== void 0) {
     if (!seen.has(current)) {
       directories.push(current);
@@ -14337,7 +14337,7 @@ function buildDirectoryChain2(filePath, repoRoot) {
     if (current === boundary) {
       break;
     }
-    const parent = path32.dirname(current);
+    const parent = path22.dirname(current);
     if (parent === current) {
       break;
     }
@@ -14351,16 +14351,16 @@ function buildDirectoryChain2(filePath, repoRoot) {
 function buildSearchRoots2(evalPath, repoRoot) {
   const uniqueRoots = [];
   const addRoot = (root) => {
-    const normalized = path32.resolve(root);
+    const normalized = path22.resolve(root);
     if (!uniqueRoots.includes(normalized)) {
       uniqueRoots.push(normalized);
     }
   };
-  let currentDir = path32.dirname(evalPath);
+  let currentDir = path22.dirname(evalPath);
   let reachedBoundary = false;
   while (!reachedBoundary) {
     addRoot(currentDir);
-    const parentDir = path32.dirname(currentDir);
+    const parentDir = path22.dirname(currentDir);
     if (currentDir === repoRoot || parentDir === currentDir) {
       reachedBoundary = true;
     } else {
@@ -14375,19 +14375,19 @@ function trimLeadingSeparators2(value) {
   const trimmed = value.replace(/^[/\\]+/, "");
   return trimmed.length > 0 ? trimmed : value;
 }
-async function resolveFileReference3(rawValue, searchRoots) {
+async function resolveFileReference22(rawValue, searchRoots) {
   const displayPath = trimLeadingSeparators2(rawValue);
   const potentialPaths = [];
-  if (path32.isAbsolute(rawValue)) {
-    potentialPaths.push(path32.normalize(rawValue));
+  if (path22.isAbsolute(rawValue)) {
+    potentialPaths.push(path22.normalize(rawValue));
   }
   for (const base of searchRoots) {
-    potentialPaths.push(path32.resolve(base, displayPath));
+    potentialPaths.push(path22.resolve(base, displayPath));
   }
   const attempted = [];
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of potentialPaths) {
-    const absoluteCandidate = path32.resolve(candidate);
+    const absoluteCandidate = path22.resolve(candidate);
     if (seen.has(absoluteCandidate)) {
       continue;
     }
@@ -14400,7 +14400,7 @@ async function resolveFileReference3(rawValue, searchRoots) {
   return { displayPath, attempted };
 }
 var ANSI_YELLOW2 = "\x1B[33m";
-var ANSI_RESET3 = "\x1B[0m";
+var ANSI_RESET22 = "\x1B[0m";
 var DEFAULT_EVAL_PATTERNS = [
   "**/evals/**/*.eval.yaml",
   "**/evals/**/eval.yaml"
@@ -14408,12 +14408,12 @@ var DEFAULT_EVAL_PATTERNS = [
 async function loadConfig(evalFilePath, repoRoot) {
   const directories = buildDirectoryChain2(evalFilePath, repoRoot);
   for (const directory of directories) {
-    const configPath = path4.join(directory, ".agentv", "config.yaml");
+    const configPath = path32.join(directory, ".agentv", "config.yaml");
     if (!await fileExists2(configPath)) {
       continue;
     }
     try {
-      const rawConfig = await readFile3(configPath, "utf8");
+      const rawConfig = await readFile22(configPath, "utf8");
       const parsed = parse(rawConfig);
       if (!isJsonObject(parsed)) {
         logWarning(`Invalid .agentv/config.yaml format at ${configPath}`);
@@ -14650,7 +14650,7 @@ function parseExecutionDefaults(raw, configPath) {
   return Object.keys(result).length > 0 ? result : void 0;
 }
 function logWarning(message) {
-  console.warn(`${ANSI_YELLOW2}Warning: ${message}${ANSI_RESET3}`);
+  console.warn(`${ANSI_YELLOW2}Warning: ${message}${ANSI_RESET22}`);
 }
 var TEMPLATE_VARIABLES = {
   EXPECTED_OUTPUT: "expected_output",
@@ -14667,10 +14667,10 @@ var REQUIRED_TEMPLATE_VARIABLES = /* @__PURE__ */ new Set([
   TEMPLATE_VARIABLES.OUTPUT_TEXT,
   TEMPLATE_VARIABLES.EXPECTED_OUTPUT
 ]);
-var ANSI_YELLOW3 = "\x1B[33m";
-var ANSI_RESET4 = "\x1B[0m";
+var ANSI_YELLOW22 = "\x1B[33m";
+var ANSI_RESET3 = "\x1B[0m";
 async function validateCustomPromptContent(promptPath) {
-  const content = await readFile4(promptPath, "utf8");
+  const content = await readFile32(promptPath, "utf8");
   validateTemplateVariables(content, promptPath);
 }
 function validateTemplateVariables(content, source) {
@@ -14697,14 +14697,14 @@ function validateTemplateVariables(content, source) {
     );
   }
   if (invalidVariables.length > 0) {
-    const warningMessage = `${ANSI_YELLOW3}Warning: Custom evaluator template at ${source}
+    const warningMessage = `${ANSI_YELLOW22}Warning: Custom evaluator template at ${source}
   Contains invalid variables: ${invalidVariables.map((v) => `{{ ${v} }}`).join(", ")}
-  Valid variables: ${Array.from(VALID_TEMPLATE_VARIABLES).map((v) => `{{ ${v} }}`).join(", ")}${ANSI_RESET4}`;
+  Valid variables: ${Array.from(VALID_TEMPLATE_VARIABLES).map((v) => `{{ ${v} }}`).join(", ")}${ANSI_RESET3}`;
     console.warn(warningMessage);
   }
 }
-var ANSI_YELLOW4 = "\x1B[33m";
-var ANSI_RESET5 = "\x1B[0m";
+var ANSI_YELLOW3 = "\x1B[33m";
+var ANSI_RESET4 = "\x1B[0m";
 function normalizeEvaluatorType(type) {
   return type.replace(/_/g, "-");
 }
@@ -14806,7 +14806,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       let command;
       if (rawEvaluator.script !== void 0 && rawEvaluator.command === void 0) {
         console.warn(
-          `${ANSI_YELLOW4}Warning: 'script' is deprecated in evaluator '${name21}' in '${evalId}'. Use 'command' instead.${ANSI_RESET5}`
+          `${ANSI_YELLOW3}Warning: 'script' is deprecated in evaluator '${name21}' in '${evalId}'. Use 'command' instead.${ANSI_RESET4}`
         );
       }
       const rawCommand = rawEvaluator.command ?? rawEvaluator.script;
@@ -14832,9 +14832,9 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       const cwd = asString(rawEvaluator.cwd);
       let resolvedCwd;
       if (cwd) {
-        const resolved = await resolveFileReference3(cwd, searchRoots);
+        const resolved = await resolveFileReference22(cwd, searchRoots);
         if (resolved.resolvedPath) {
-          resolvedCwd = path5.resolve(resolved.resolvedPath);
+          resolvedCwd = path42.resolve(resolved.resolvedPath);
         } else {
           logWarning2(
             `Code-grader evaluator '${name21}' in '${evalId}': cwd not found (${resolved.displayPath})`,
@@ -14990,9 +14990,9 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
         const aggregatorPrompt = asString(rawAggregator.prompt);
         let promptPath2;
         if (aggregatorPrompt) {
-          const resolved = await resolveFileReference3(aggregatorPrompt, searchRoots);
+          const resolved = await resolveFileReference22(aggregatorPrompt, searchRoots);
           if (resolved.resolvedPath) {
-            promptPath2 = path5.resolve(resolved.resolvedPath);
+            promptPath2 = path42.resolve(resolved.resolvedPath);
           }
         }
         aggregator = {
@@ -15549,7 +15549,7 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
     if (isJsonObject2(rawPrompt)) {
       if (rawPrompt.script !== void 0 && rawPrompt.command === void 0) {
         console.warn(
-          `${ANSI_YELLOW4}Warning: 'prompt.script' is deprecated in evaluator '${name21}' in '${evalId}'. Use 'prompt.command' instead.${ANSI_RESET5}`
+          `${ANSI_YELLOW3}Warning: 'prompt.script' is deprecated in evaluator '${name21}' in '${evalId}'. Use 'prompt.command' instead.${ANSI_RESET4}`
         );
       }
       const commandArray = asStringArray(
@@ -15560,9 +15560,9 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
         throw new Error(`Evaluator '${name21}' in '${evalId}': prompt object requires command array`);
       }
       const commandPath = commandArray[commandArray.length - 1];
-      const resolved = await resolveFileReference3(commandPath, searchRoots);
+      const resolved = await resolveFileReference22(commandPath, searchRoots);
       if (resolved.resolvedPath) {
-        resolvedPromptScript = [...commandArray.slice(0, -1), path5.resolve(resolved.resolvedPath)];
+        resolvedPromptScript = [...commandArray.slice(0, -1), path42.resolve(resolved.resolvedPath)];
       } else {
         throw new Error(
           `Evaluator '${name21}' in '${evalId}': prompt command file not found: ${resolved.displayPath}`
@@ -15573,9 +15573,9 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId) {
       }
     } else if (typeof rawPrompt === "string") {
       prompt = rawPrompt;
-      const resolved = await resolveFileReference3(prompt, searchRoots);
+      const resolved = await resolveFileReference22(prompt, searchRoots);
       if (resolved.resolvedPath) {
-        promptPath = path5.resolve(resolved.resolvedPath);
+        promptPath = path42.resolve(resolved.resolvedPath);
         try {
           await validateCustomPromptContent(promptPath);
         } catch (error) {
@@ -15775,10 +15775,10 @@ function warnUnconsumedCriteria(_criteria, _evaluators, _testId) {
 function logWarning2(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
-    console.warn(`${ANSI_YELLOW4}Warning: ${message}
-${detailBlock}${ANSI_RESET5}`);
+    console.warn(`${ANSI_YELLOW3}Warning: ${message}
+${detailBlock}${ANSI_RESET4}`);
   } else {
-    console.warn(`${ANSI_YELLOW4}Warning: ${message}${ANSI_RESET5}`);
+    console.warn(`${ANSI_YELLOW3}Warning: ${message}${ANSI_RESET4}`);
   }
 }
 function parseRequired(value) {
@@ -16083,8 +16083,8 @@ function hasVisibleContent(segments) {
 function asString2(value) {
   return typeof value === "string" ? value : void 0;
 }
-var ANSI_YELLOW5 = "\x1B[33m";
-var ANSI_RESET6 = "\x1B[0m";
+var ANSI_YELLOW4 = "\x1B[33m";
+var ANSI_RESET5 = "\x1B[0m";
 async function processMessages(options) {
   const {
     messages,
@@ -16128,7 +16128,7 @@ async function processMessages(options) {
         if (!rawValue) {
           continue;
         }
-        const { displayPath, resolvedPath, attempted } = await resolveFileReference3(
+        const { displayPath, resolvedPath, attempted } = await resolveFileReference22(
           rawValue,
           searchRoots
         );
@@ -16139,7 +16139,7 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const fileContent = (await readFile5(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+          const fileContent = (await readFile4(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
           const classifyAsGuideline = shouldTreatAsGuideline({
             messageType,
             resolvedPath,
@@ -16148,7 +16148,7 @@ async function processMessages(options) {
             treatFileSegmentsAsGuidelines
           });
           if (classifyAsGuideline && guidelinePaths) {
-            guidelinePaths.push(path6.resolve(resolvedPath));
+            guidelinePaths.push(path5.resolve(resolvedPath));
             if (verbose) {
               console.log(`  [Guideline] Found: ${displayPath}`);
               console.log(`    Resolved to: ${resolvedPath}`);
@@ -16159,7 +16159,7 @@ async function processMessages(options) {
             type: "file",
             path: displayPath,
             text: fileContent,
-            resolvedPath: path6.resolve(resolvedPath)
+            resolvedPath: path5.resolve(resolvedPath)
           });
           if (verbose) {
             const label = messageType === "input" ? "[File]" : "[Expected Output File]";
@@ -16199,7 +16199,7 @@ function shouldTreatAsGuideline(options) {
   if (!guidelinePatterns || guidelinePatterns.length === 0) {
     return false;
   }
-  const relativeToRepo = path6.relative(repoRootPath, resolvedPath);
+  const relativeToRepo = path5.relative(repoRootPath, resolvedPath);
   return isGuidelineFile(relativeToRepo, guidelinePatterns);
 }
 function asString3(value) {
@@ -16227,10 +16227,10 @@ function cloneJsonValue(value) {
 function logWarning3(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
-    console.warn(`${ANSI_YELLOW5}Warning: ${message}
-${detailBlock}${ANSI_RESET6}`);
+    console.warn(`${ANSI_YELLOW4}Warning: ${message}
+${detailBlock}${ANSI_RESET5}`);
   } else {
-    console.warn(`${ANSI_YELLOW5}Warning: ${message}${ANSI_RESET6}`);
+    console.warn(`${ANSI_YELLOW4}Warning: ${message}${ANSI_RESET5}`);
   }
 }
 async function processExpectedMessages(options) {
@@ -16259,7 +16259,7 @@ async function processExpectedMessages(options) {
           if (!rawValue) {
             continue;
           }
-          const { displayPath, resolvedPath, attempted } = await resolveFileReference3(
+          const { displayPath, resolvedPath, attempted } = await resolveFileReference22(
             rawValue,
             searchRoots
           );
@@ -16269,12 +16269,12 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const fileContent = (await readFile5(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+            const fileContent = (await readFile4(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
             processedContent.push({
               type: "file",
               path: displayPath,
               text: fileContent,
-              resolvedPath: path6.resolve(resolvedPath)
+              resolvedPath: path5.resolve(resolvedPath)
             });
             if (verbose) {
               console.log(`  [Expected Output File] Found: ${displayPath}`);
@@ -16367,11 +16367,11 @@ function resolveInputMessages(raw, suiteInputFiles) {
 function resolveExpectedMessages(raw) {
   return expandExpectedOutputShorthand(raw.expected_output);
 }
-var ANSI_YELLOW6 = "\x1B[33m";
+var ANSI_YELLOW5 = "\x1B[33m";
 var ANSI_RED2 = "\x1B[31m";
-var ANSI_RESET7 = "\x1B[0m";
+var ANSI_RESET6 = "\x1B[0m";
 function detectFormat(filePath) {
-  const ext = path7.extname(filePath).toLowerCase();
+  const ext = path6.extname(filePath).toLowerCase();
   if (ext === ".jsonl") return "jsonl";
   if (ext === ".yaml" || ext === ".yml") return "yaml";
   if (ext === ".json") return "agent-skills-json";
@@ -16380,9 +16380,9 @@ function detectFormat(filePath) {
   );
 }
 async function loadSidecarMetadata(jsonlPath, verbose) {
-  const dir = path7.dirname(jsonlPath);
-  const base = path7.basename(jsonlPath, ".jsonl");
-  const sidecarPath = path7.join(dir, `${base}.yaml`);
+  const dir = path6.dirname(jsonlPath);
+  const base = path6.basename(jsonlPath, ".jsonl");
+  const sidecarPath = path6.join(dir, `${base}.yaml`);
   if (!await fileExists2(sidecarPath)) {
     if (verbose) {
       logWarning4(`Sidecar metadata file not found: ${sidecarPath} (using defaults)`);
@@ -16390,7 +16390,7 @@ async function loadSidecarMetadata(jsonlPath, verbose) {
     return {};
   }
   try {
-    const content = await readFile6(sidecarPath, "utf8");
+    const content = await readFile5(sidecarPath, "utf8");
     const parsed = interpolateEnv(parseYaml2(content), process.env);
     if (!isJsonObject(parsed)) {
       logWarning4(`Invalid sidecar metadata format in ${sidecarPath}`);
@@ -16431,15 +16431,15 @@ function parseJsonlContent(content, filePath) {
 async function loadTestsFromJsonl(evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
   const filterPattern = options?.filter;
-  const absoluteTestPath = path7.resolve(evalFilePath);
+  const absoluteTestPath = path6.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
   const config = await loadConfig(absoluteTestPath, repoRootPath);
   const guidelinePatterns = config?.guideline_patterns;
   const sidecar = await loadSidecarMetadata(absoluteTestPath, verbose);
-  const rawFile = await readFile6(absoluteTestPath, "utf8");
+  const rawFile = await readFile5(absoluteTestPath, "utf8");
   const rawCases = parseJsonlContent(rawFile, evalFilePath);
-  const fallbackDataset = path7.basename(absoluteTestPath, ".jsonl") || "eval";
+  const fallbackDataset = path6.basename(absoluteTestPath, ".jsonl") || "eval";
   const datasetName = sidecar.dataset && sidecar.dataset.trim().length > 0 ? sidecar.dataset : fallbackDataset;
   const globalEvaluator = coerceEvaluator(sidecar.evaluator, "sidecar") ?? "llm-grader";
   const globalExecution = sidecar.execution;
@@ -16538,7 +16538,7 @@ async function loadTestsFromJsonl(evalFilePath, repoRoot, options) {
       }
     }
     const allFilePaths = [
-      ...guidelinePaths.map((guidelinePath) => path7.resolve(guidelinePath)),
+      ...guidelinePaths.map((guidelinePath) => path6.resolve(guidelinePath)),
       ...userFilePaths
     ];
     const testCase = {
@@ -16550,7 +16550,7 @@ async function loadTestsFromJsonl(evalFilePath, repoRoot, options) {
       input_segments: inputSegments,
       expected_output: outputSegments,
       reference_answer: referenceAnswer,
-      guideline_paths: guidelinePaths.map((guidelinePath) => path7.resolve(guidelinePath)),
+      guideline_paths: guidelinePaths.map((guidelinePath) => path6.resolve(guidelinePath)),
       guideline_patterns: guidelinePatterns,
       file_paths: allFilePaths,
       criteria: outcome ?? "",
@@ -16581,19 +16581,19 @@ function asString4(value) {
 function logWarning4(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
-    console.warn(`${ANSI_YELLOW6}Warning: ${message}
-${detailBlock}${ANSI_RESET7}`);
+    console.warn(`${ANSI_YELLOW5}Warning: ${message}
+${detailBlock}${ANSI_RESET6}`);
   } else {
-    console.warn(`${ANSI_YELLOW6}Warning: ${message}${ANSI_RESET7}`);
+    console.warn(`${ANSI_YELLOW5}Warning: ${message}${ANSI_RESET6}`);
   }
 }
 function logError2(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
     console.error(`${ANSI_RED2}Error: ${message}
-${detailBlock}${ANSI_RESET7}`);
+${detailBlock}${ANSI_RESET6}`);
   } else {
-    console.error(`${ANSI_RED2}Error: ${message}${ANSI_RESET7}`);
+    console.error(`${ANSI_RED2}Error: ${message}${ANSI_RESET6}`);
   }
 }
 var MetadataSchema = external_exports2.object({
@@ -16623,22 +16623,22 @@ function parseMetadata(suite) {
     requires: suite.requires
   });
 }
-var ANSI_YELLOW7 = "\x1B[33m";
-var ANSI_RESET8 = "\x1B[0m";
+var ANSI_YELLOW6 = "\x1B[33m";
+var ANSI_RESET7 = "\x1B[0m";
 async function buildPromptInputs(testCase, mode = "lm") {
   const guidelineParts = [];
   for (const rawPath of testCase.guideline_paths) {
-    const absolutePath = path8.resolve(rawPath);
+    const absolutePath = path7.resolve(rawPath);
     if (!await fileExists2(absolutePath)) {
       logWarning5(`Could not read guideline file ${absolutePath}: file does not exist`);
       continue;
     }
     try {
-      const content = (await readFile7(absolutePath, "utf8")).replace(/\r\n/g, "\n").trim();
+      const content = (await readFile6(absolutePath, "utf8")).replace(/\r\n/g, "\n").trim();
       guidelineParts.push({
         content,
         isFile: true,
-        displayPath: path8.basename(absolutePath)
+        displayPath: path7.basename(absolutePath)
       });
     } catch (error) {
       logWarning5(`Could not read guideline file ${absolutePath}: ${error.message}`);
@@ -16836,11 +16836,11 @@ function asString5(value) {
   return typeof value === "string" ? value : void 0;
 }
 function logWarning5(message) {
-  console.warn(`${ANSI_YELLOW7}Warning: ${message}${ANSI_RESET8}`);
+  console.warn(`${ANSI_YELLOW6}Warning: ${message}${ANSI_RESET7}`);
 }
-var ANSI_YELLOW8 = "\x1B[33m";
+var ANSI_YELLOW7 = "\x1B[33m";
 var ANSI_RED3 = "\x1B[31m";
-var ANSI_RESET9 = "\x1B[0m";
+var ANSI_RESET8 = "\x1B[0m";
 function resolveTests(suite) {
   if (suite.tests !== void 0) return suite.tests;
   if (suite.eval_cases !== void 0) {
@@ -16855,8 +16855,8 @@ function resolveTests(suite) {
 }
 async function readTestSuiteMetadata(testFilePath) {
   try {
-    const absolutePath = path9.resolve(testFilePath);
-    const content = await readFile8(absolutePath, "utf8");
+    const absolutePath = path8.resolve(testFilePath);
+    const content = await readFile7(absolutePath, "utf8");
     const parsed = interpolateEnv(parse2(content), process.env);
     if (!isJsonObject(parsed)) {
       return {};
@@ -16907,26 +16907,26 @@ var loadEvalCases = loadTests;
 async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
   const filterPattern = options?.filter;
-  const absoluteTestPath = path9.resolve(evalFilePath);
+  const absoluteTestPath = path8.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
   const config = await loadConfig(absoluteTestPath, repoRootPath);
   const guidelinePatterns = config?.guideline_patterns;
-  const rawFile = await readFile8(absoluteTestPath, "utf8");
+  const rawFile = await readFile7(absoluteTestPath, "utf8");
   const interpolated = interpolateEnv(parse2(rawFile), process.env);
   if (!isJsonObject(interpolated)) {
     throw new Error(`Invalid test file format: ${evalFilePath}`);
   }
   const suite = interpolated;
   const datasetNameFromSuite = asString6(suite.dataset)?.trim();
-  const fallbackDataset = path9.basename(absoluteTestPath).replace(/\.ya?ml$/i, "") || "eval";
+  const fallbackDataset = path8.basename(absoluteTestPath).replace(/\.ya?ml$/i, "") || "eval";
   const datasetName = datasetNameFromSuite && datasetNameFromSuite.length > 0 ? datasetNameFromSuite : fallbackDataset;
   const rawTestcases = resolveTests(suite);
   const globalEvaluator = coerceEvaluator(suite.evaluator, "global") ?? "llm-grader";
-  const evalFileDir = path9.dirname(absoluteTestPath);
+  const evalFileDir = path8.dirname(absoluteTestPath);
   let expandedTestcases;
   if (typeof rawTestcases === "string") {
-    const externalPath = path9.resolve(evalFileDir, rawTestcases);
+    const externalPath = path8.resolve(evalFileDir, rawTestcases);
     expandedTestcases = await loadCasesFromFile(externalPath);
   } else if (Array.isArray(rawTestcases)) {
     expandedTestcases = await expandFileReferences(rawTestcases, evalFileDir);
@@ -17047,7 +17047,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
       }
     }
     const allFilePaths = [
-      ...guidelinePaths.map((guidelinePath) => path9.resolve(guidelinePath)),
+      ...guidelinePaths.map((guidelinePath) => path8.resolve(guidelinePath)),
       ...userFilePaths
     ];
     const caseWorkspace = await resolveWorkspaceConfig(evalcase.workspace, evalFileDir);
@@ -17063,7 +17063,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
       input_segments: inputSegments,
       expected_output: outputSegments,
       reference_answer: referenceAnswer,
-      guideline_paths: guidelinePaths.map((guidelinePath) => path9.resolve(guidelinePath)),
+      guideline_paths: guidelinePaths.map((guidelinePath) => path8.resolve(guidelinePath)),
       guideline_patterns: guidelinePatterns,
       file_paths: allFilePaths,
       criteria: outcome ?? "",
@@ -17113,8 +17113,8 @@ function parseWorkspaceScriptConfig(raw, evalFileDir) {
   if (commandArr.length === 0) 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 && !path9.isAbsolute(cwd)) {
-    cwd = path9.resolve(evalFileDir, cwd);
+  if (cwd && !path8.isAbsolute(cwd)) {
+    cwd = path8.resolve(evalFileDir, cwd);
   }
   const config = { command: commandArr };
   if (timeoutMs !== void 0) {
@@ -17204,10 +17204,10 @@ function parseWorkspaceHooksConfig(raw, evalFileDir) {
 }
 async function resolveWorkspaceConfig(raw, evalFileDir) {
   if (typeof raw === "string") {
-    const workspaceFilePath = path9.resolve(evalFileDir, raw);
+    const workspaceFilePath = path8.resolve(evalFileDir, raw);
     let content;
     try {
-      content = await readFile8(workspaceFilePath, "utf8");
+      content = await readFile7(workspaceFilePath, "utf8");
     } catch {
       throw new Error(`Workspace file not found: ${raw} (resolved to ${workspaceFilePath})`);
     }
@@ -17217,7 +17217,7 @@ async function resolveWorkspaceConfig(raw, evalFileDir) {
         `Invalid workspace file format: ${workspaceFilePath} (expected a YAML object)`
       );
     }
-    const workspaceFileDir = path9.dirname(workspaceFilePath);
+    const workspaceFileDir = path8.dirname(workspaceFilePath);
     return parseWorkspaceConfig(parsed, workspaceFileDir);
   }
   return parseWorkspaceConfig(raw, evalFileDir);
@@ -17237,8 +17237,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 && !path9.isAbsolute(template)) {
-    template = path9.resolve(evalFileDir, template);
+  if (template && !path8.isAbsolute(template)) {
+    template = path8.resolve(evalFileDir, template);
   }
   const isolation = obj.isolation === "shared" || obj.isolation === "per_test" ? obj.isolation : void 0;
   const repos = Array.isArray(obj.repos) ? obj.repos.map(parseRepoConfig).filter(Boolean) : void 0;
@@ -17291,19 +17291,19 @@ function asString6(value) {
 function logWarning6(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
-    console.warn(`${ANSI_YELLOW8}Warning: ${message}
-${detailBlock}${ANSI_RESET9}`);
+    console.warn(`${ANSI_YELLOW7}Warning: ${message}
+${detailBlock}${ANSI_RESET8}`);
   } else {
-    console.warn(`${ANSI_YELLOW8}Warning: ${message}${ANSI_RESET9}`);
+    console.warn(`${ANSI_YELLOW7}Warning: ${message}${ANSI_RESET8}`);
   }
 }
 function logError3(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
     console.error(`${ANSI_RED3}Error: ${message}
-${detailBlock}${ANSI_RESET9}`);
+${detailBlock}${ANSI_RESET8}`);
   } else {
-    console.error(`${ANSI_RED3}Error: ${message}${ANSI_RESET9}`);
+    console.error(`${ANSI_RED3}Error: ${message}${ANSI_RESET8}`);
   }
 }
 function codeGraderInstruction(graderName, description) {
@@ -17549,7 +17549,7 @@ function transpileEvalYaml(suite, source = "EVAL.yaml") {
 function transpileEvalYamlFile(evalYamlPath) {
   const content = readFileSync(evalYamlPath, "utf8");
   const parsed = parse3(content);
-  return transpileEvalYaml(parsed, path10.basename(evalYamlPath));
+  return transpileEvalYaml(parsed, path9.basename(evalYamlPath));
 }
 function getOutputFilenames(result) {
   const names = /* @__PURE__ */ new Map();
@@ -18049,7 +18049,7 @@ function normalizeInputFiles(inputFiles) {
   }
   const deduped = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path11.resolve(inputFile);
+    const absolutePath = path10.resolve(inputFile);
     if (!deduped.has(absolutePath)) {
       deduped.set(absolutePath, absolutePath);
     }
@@ -18062,14 +18062,14 @@ function collectGuidelineFiles(inputFiles, guidelinePatterns, overrides) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path11.resolve(inputFile);
+    const absolutePath = path10.resolve(inputFile);
     if (overrides?.has(absolutePath)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
       }
       continue;
     }
-    const normalized = absolutePath.split(path11.sep).join("/");
+    const normalized = absolutePath.split(path10.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -18084,7 +18084,7 @@ function collectInputFiles(inputFiles) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path11.resolve(inputFile);
+    const absolutePath = path10.resolve(inputFile);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -18096,7 +18096,7 @@ function buildMandatoryPrereadBlock(guidelineFiles, inputFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path11.basename(absolutePath);
+    const fileName = path10.basename(absolutePath);
     const fileUri = pathToFileUri(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -18116,7 +18116,7 @@ ${buildList(inputFiles).join("\n")}.`);
   return sections.join("\n");
 }
 function pathToFileUri(filePath) {
-  const absolutePath = path11.isAbsolute(filePath) ? filePath : path11.resolve(filePath);
+  const absolutePath = path10.isAbsolute(filePath) ? filePath : path10.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -18261,10 +18261,10 @@ var ClaudeCliProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path12.resolve(cwdOverride);
+      return path11.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path12.resolve(this.config.cwd);
+      return path11.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -18274,9 +18274,9 @@ var ClaudeCliProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path12.resolve(this.config.logDir);
+      return path11.resolve(this.config.logDir);
     }
-    return path12.join(process.cwd(), ".agentv", "logs", "claude-cli");
+    return path11.join(process.cwd(), ".agentv", "logs", "claude-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -18290,7 +18290,7 @@ var ClaudeCliProvider = class {
       console.warn(`Skipping Claude CLI stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path12.join(logDir, buildLogFilename(request, this.targetName));
+    const filePath = path11.join(logDir, buildLogFilename(request, this.targetName));
     try {
       const logger = await ClaudeCliStreamLogger.create({
         filePath,
@@ -18765,10 +18765,10 @@ var ClaudeSdkProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path13.resolve(cwdOverride);
+      return path12.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path13.resolve(this.config.cwd);
+      return path12.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -18778,9 +18778,9 @@ var ClaudeSdkProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path13.resolve(this.config.logDir);
+      return path12.resolve(this.config.logDir);
     }
-    return path13.join(process.cwd(), ".agentv", "logs", "claude");
+    return path12.join(process.cwd(), ".agentv", "logs", "claude");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -18794,7 +18794,7 @@ var ClaudeSdkProvider = class {
       console.warn(`Skipping Claude stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path13.join(logDir, buildLogFilename2(request, this.targetName));
+    const filePath = path12.join(logDir, buildLogFilename2(request, this.targetName));
     try {
       const logger = await ClaudeStreamLogger.create({
         filePath,
@@ -19498,7 +19498,7 @@ function normalizeInputFiles2(inputFiles) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path14.resolve(inputFile);
+    const absolutePath = path13.resolve(inputFile);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -19512,7 +19512,7 @@ function formatFileList(files, template) {
   const formatter = template ?? "{path}";
   return files.map((filePath) => {
     const escapedPath = shellEscape(filePath);
-    const escapedName = shellEscape(path14.basename(filePath));
+    const escapedName = shellEscape(path13.basename(filePath));
     return formatter.replaceAll("{path}", escapedPath).replaceAll("{basename}", escapedName);
   }).join(" ");
 }
@@ -19536,7 +19536,7 @@ function generateOutputFilePath(evalCaseId, extension = ".json") {
   const safeEvalId = evalCaseId || "unknown";
   const timestamp = Date.now();
   const random = Math.random().toString(36).substring(2, 9);
-  return path14.join(os.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
+  return path13.join(os.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
 }
 function formatTimeoutSuffix2(timeoutMs) {
   if (!timeoutMs || timeoutMs <= 0) {
@@ -19775,10 +19775,10 @@ ${basePrompt}` : basePrompt;
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path15.resolve(cwdOverride);
+      return path14.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path15.resolve(this.config.cwd);
+      return path14.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -19788,9 +19788,9 @@ ${basePrompt}` : basePrompt;
       return void 0;
     }
     if (this.config.logDir) {
-      return path15.resolve(this.config.logDir);
+      return path14.resolve(this.config.logDir);
     }
-    return path15.join(process.cwd(), ".agentv", "logs", "codex");
+    return path14.join(process.cwd(), ".agentv", "logs", "codex");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -19804,7 +19804,7 @@ ${basePrompt}` : basePrompt;
       console.warn(`Skipping Codex SDK stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path15.join(logDir, buildLogFilename3(request, this.targetName));
+    const filePath = path14.join(logDir, buildLogFilename3(request, this.targetName));
     try {
       const logger = await CodexSdkStreamLogger.create({
         filePath,
@@ -20017,7 +20017,7 @@ function resolvePlatformCliPath() {
   try {
     const resolved = import.meta.resolve(`${packageName}/package.json`);
     const packageJsonPath = resolved.startsWith("file:") ? fileURLToPath2(resolved) : resolved;
-    const binaryPath = path16.join(path16.dirname(packageJsonPath), binaryName);
+    const binaryPath = path15.join(path15.dirname(packageJsonPath), binaryName);
     if (existsSync(binaryPath)) {
       return binaryPath;
     }
@@ -20025,7 +20025,7 @@ function resolvePlatformCliPath() {
   }
   let searchDir = process.cwd();
   for (let i = 0; i < 10; i++) {
-    const standardPath = path16.join(
+    const standardPath = path15.join(
       searchDir,
       "node_modules",
       ...packageName.split("/"),
@@ -20034,13 +20034,13 @@ function resolvePlatformCliPath() {
     if (existsSync(standardPath)) {
       return standardPath;
     }
-    const bunDir = path16.join(searchDir, "node_modules", ".bun");
+    const bunDir = path15.join(searchDir, "node_modules", ".bun");
     const prefix = `@github+copilot-${osPart}-${archPart}@`;
     try {
       const entries = readdirSync(bunDir);
       for (const entry of entries) {
         if (entry.startsWith(prefix)) {
-          const candidate = path16.join(
+          const candidate = path15.join(
             bunDir,
             entry,
             "node_modules",
@@ -20055,7 +20055,7 @@ function resolvePlatformCliPath() {
       }
     } catch {
     }
-    const parent = path16.dirname(searchDir);
+    const parent = path15.dirname(searchDir);
     if (parent === searchDir) break;
     searchDir = parent;
   }
@@ -20391,10 +20391,10 @@ var CopilotCliProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path17.resolve(cwdOverride);
+      return path16.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path17.resolve(this.config.cwd);
+      return path16.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -20413,9 +20413,9 @@ var CopilotCliProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path17.resolve(this.config.logDir);
+      return path16.resolve(this.config.logDir);
     }
-    return path17.join(process.cwd(), ".agentv", "logs", "copilot-cli");
+    return path16.join(process.cwd(), ".agentv", "logs", "copilot-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -20429,7 +20429,7 @@ var CopilotCliProvider = class {
       console.warn(`Skipping Copilot CLI stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path17.join(logDir, buildLogFilename4(request, this.targetName, "copilot-cli"));
+    const filePath = path16.join(logDir, buildLogFilename4(request, this.targetName, "copilot-cli"));
     try {
       const logger = await CopilotStreamLogger.create(
         {
@@ -20794,10 +20794,10 @@ var CopilotSdkProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path18.resolve(cwdOverride);
+      return path17.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path18.resolve(this.config.cwd);
+      return path17.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -20806,9 +20806,9 @@ var CopilotSdkProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path18.resolve(this.config.logDir);
+      return path17.resolve(this.config.logDir);
     }
-    return path18.join(process.cwd(), ".agentv", "logs", "copilot-sdk");
+    return path17.join(process.cwd(), ".agentv", "logs", "copilot-sdk");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -20822,7 +20822,7 @@ var CopilotSdkProvider = class {
       console.warn(`Skipping Copilot SDK stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path18.join(logDir, buildLogFilename4(request, this.targetName, "copilot-sdk"));
+    const filePath = path17.join(logDir, buildLogFilename4(request, this.targetName, "copilot-sdk"));
     try {
       const logger = await CopilotStreamLogger.create(
         {
@@ -21241,7 +21241,7 @@ var PiCodingAgentProvider = class {
     const workspaceRoot = await this.createWorkspace();
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
-      const promptFile = path19.join(workspaceRoot, PROMPT_FILENAME);
+      const promptFile = path18.join(workspaceRoot, PROMPT_FILENAME);
       await writeFile(promptFile, request.question, "utf8");
       const args = this.buildPiArgs(request.question, inputFiles, request.captureFileChanges);
       const cwd = this.resolveCwd(workspaceRoot, request.cwd);
@@ -21303,12 +21303,12 @@ var PiCodingAgentProvider = class {
   }
   resolveCwd(workspaceRoot, cwdOverride) {
     if (cwdOverride) {
-      return path19.resolve(cwdOverride);
+      return path18.resolve(cwdOverride);
     }
     if (!this.config.cwd) {
       return workspaceRoot;
     }
-    return path19.resolve(this.config.cwd);
+    return path18.resolve(this.config.cwd);
   }
   buildPiArgs(prompt, inputFiles, _captureFileChanges) {
     const args = [];
@@ -21397,7 +21397,7 @@ ${prompt}` : prompt;
     return env;
   }
   async createWorkspace() {
-    return await mkdtemp(path19.join(tmpdir(), WORKSPACE_PREFIX));
+    return await mkdtemp(path18.join(tmpdir(), WORKSPACE_PREFIX));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
@@ -21407,9 +21407,9 @@ ${prompt}` : prompt;
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return path19.resolve(this.config.logDir);
+      return path18.resolve(this.config.logDir);
     }
-    return path19.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
+    return path18.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -21423,7 +21423,7 @@ ${prompt}` : prompt;
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path19.join(logDir, buildLogFilename5(request, this.targetName));
+    const filePath = path18.join(logDir, buildLogFilename5(request, this.targetName));
     try {
       const logger = await PiStreamLogger.create({
         filePath,
@@ -21933,7 +21933,7 @@ async function readDirEntries(target) {
   const entries = await readdir(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    absolutePath: path20.join(target, entry.name),
+    absolutePath: path19.join(target, entry.name),
     isDirectory: entry.isDirectory()
   }));
 }
@@ -21947,7 +21947,7 @@ async function removeIfExists(target) {
   }
 }
 function pathToFileUri2(filePath) {
-  const absolutePath = path21.isAbsolute(filePath) ? filePath : path21.resolve(filePath);
+  const absolutePath = path20.isAbsolute(filePath) ? filePath : path20.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -22039,8 +22039,8 @@ function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal,
   });
 }
 function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateContent) {
-  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${path222.basename(file)}`).join("\n");
-  const responseList = responseFiles.map((file) => `"${path222.basename(file)}"`).join(", ");
+  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${path21.basename(file)}`).join("\n");
+  const responseList = responseFiles.map((file) => `"${path21.basename(file)}"`).join(", ");
   return renderTemplate2(templateContent, {
     requestFiles: requestLines,
     responseList
@@ -22079,7 +22079,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     try {
-      const content = await readFile9(responseFileFinal, { encoding: "utf8" });
+      const content = await readFile8(responseFileFinal, { encoding: "utf8" });
       if (!silent) {
         process.stdout.write(`${content}
 `);
@@ -22100,7 +22100,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) => path23.basename(file)).join(", ");
+    const fileList = responseFilesFinal.map((file) => path222.basename(file)).join(", ");
     console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
   }
   const deadline = Date.now() + timeoutMs;
@@ -22109,7 +22109,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     while (pending.size > 0) {
       if (Date.now() >= deadline) {
         if (!silent) {
-          const remaining = [...pending].map((f) => path23.basename(f)).join(", ");
+          const remaining = [...pending].map((f) => path222.basename(f)).join(", ");
           console.error(
             `error: timed out after ${Math.round(timeoutMs / 1e3)}s waiting for batch responses. Still pending: ${remaining}`
           );
@@ -22136,7 +22136,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     const maxAttempts = 10;
     while (attempts < maxAttempts) {
       try {
-        const content = await readFile9(file, { encoding: "utf8" });
+        const content = await readFile8(file, { encoding: "utf8" });
         if (!silent) {
           process.stdout.write(`${content}
 `);
@@ -22166,25 +22166,25 @@ function getAgentvHome() {
     }
     return envHome;
   }
-  return path24.join(os2.homedir(), ".agentv");
+  return path23.join(os2.homedir(), ".agentv");
 }
 function getWorkspacesRoot() {
-  return path24.join(getAgentvHome(), "workspaces");
+  return path23.join(getAgentvHome(), "workspaces");
 }
 function getSubagentsRoot() {
-  return path24.join(getAgentvHome(), "subagents");
+  return path23.join(getAgentvHome(), "subagents");
 }
 function getTraceStateRoot() {
-  return path24.join(getAgentvHome(), "trace-state");
+  return path23.join(getAgentvHome(), "trace-state");
 }
 function getWorkspacePoolRoot() {
-  return path24.join(getAgentvHome(), "workspace-pool");
+  return path23.join(getAgentvHome(), "workspace-pool");
 }
 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 path25.join(getSubagentsRoot(), folder);
+  return path24.join(getSubagentsRoot(), folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 var execAsync2 = promisify2(exec);
@@ -22249,11 +22249,11 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     await raceSpawnError(child);
     return true;
   }
-  const aliveFile = path26.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = path25.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const githubAgentsDir = path26.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path25.join(subagentDir, ".github", "agents");
   await mkdir8(githubAgentsDir, { recursive: true });
-  const wakeupDst = path26.join(githubAgentsDir, "wakeup.md");
+  const wakeupDst = path25.join(githubAgentsDir, "wakeup.md");
   await writeFile2(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
   const workspaceChild = spawnVsCode(vscodeCmd, [workspacePath], {
     label: "open-workspace"
@@ -22266,7 +22266,7 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     "chat",
     "-m",
     wakeupChatId,
-    `create a file named .alive in the ${path26.basename(subagentDir)} folder`
+    `create a file named .alive in the ${path25.basename(subagentDir)} folder`
   ];
   const wakeupChild = spawnVsCode(vscodeCmd, chatArgs, { label: "send-wakeup-chat" });
   await raceSpawnError(wakeupChild);
@@ -22281,10 +22281,10 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
   return true;
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
-  const workspacePath = path26.join(subagentDir, `${path26.basename(subagentDir)}.code-workspace`);
-  const messagesDir = path26.join(subagentDir, "messages");
+  const workspacePath = path25.join(subagentDir, `${path25.basename(subagentDir)}.code-workspace`);
+  const messagesDir = path25.join(subagentDir, "messages");
   await mkdir8(messagesDir, { recursive: true });
-  const reqFile = path26.join(messagesDir, `${timestamp}_req.md`);
+  const reqFile = path25.join(messagesDir, `${timestamp}_req.md`);
   await writeFile2(reqFile, requestInstructions, { encoding: "utf8" });
   const reqUri = pathToFileUri2(reqFile);
   const chatArgs = ["-r", "chat", "-m", chatId];
@@ -22292,16 +22292,16 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
     chatArgs.push("-a", attachment);
   }
   chatArgs.push("-a", reqFile);
-  chatArgs.push(`Follow instructions in [${path26.basename(reqFile)}](${reqUri})`);
+  chatArgs.push(`Follow instructions in [${path25.basename(reqFile)}](${reqUri})`);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    path26.basename(subagentDir),
+    path25.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${path26.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${path25.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -22309,8 +22309,8 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
   await raceSpawnError(child);
 }
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
-  const workspacePath = path26.join(subagentDir, `${path26.basename(subagentDir)}.code-workspace`);
-  const messagesDir = path26.join(subagentDir, "messages");
+  const workspacePath = path25.join(subagentDir, `${path25.basename(subagentDir)}.code-workspace`);
+  const messagesDir = path25.join(subagentDir, "messages");
   await mkdir8(messagesDir, { recursive: true });
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
@@ -22319,13 +22319,13 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
   chatArgs.push(chatInstruction);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    path26.basename(subagentDir),
+    path25.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${path26.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${path25.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -22347,10 +22347,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (path27.isAbsolute(folderPath)) {
+    if (path26.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = path27.resolve(templateDir, folderPath);
+    const absolutePath = path26.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -22372,19 +22372,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = path27.isAbsolute(locationPath);
+          const isAbsolute = path26.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = path27.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = path26.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 = (path27.resolve(templateDir, basePath) + patternPath).replace(
+              const resolvedPath = (path26.resolve(templateDir, basePath) + patternPath).replace(
                 /\\/g,
                 "/"
               );
@@ -22423,7 +22423,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 = path28.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = path27.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -22433,7 +22433,7 @@ async function findUnlockedSubagent(subagentRoot) {
 async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = path28.resolve(workspaceTemplate);
+    const workspaceSrc = path27.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
@@ -22441,18 +22441,18 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
     if (!stats.isFile()) {
       throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
     }
-    const templateText = await readFile10(workspaceSrc, "utf8");
+    const templateText = await readFile9(workspaceSrc, "utf8");
     workspaceContent = JSON.parse(templateText);
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${path28.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = path28.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? path28.dirname(path28.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${path27.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = path27.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? path27.dirname(path27.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   let transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
   if (cwd) {
-    const absCwd = path28.resolve(cwd);
+    const absCwd = path27.resolve(cwd);
     const parsed = JSON.parse(transformedContent);
     const alreadyPresent = parsed.folders.some((f) => f.path === absCwd);
     if (!alreadyPresent) {
@@ -22461,35 +22461,35 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
     }
   }
   await writeFile3(workspaceDst, transformedContent, "utf8");
-  const messagesDir = path28.join(subagentDir, "messages");
+  const messagesDir = path27.join(subagentDir, "messages");
   await mkdir9(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = path28.join(subagentDir, "messages");
+  const messagesDir = path27.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
     const files = await readdir2(messagesDir);
     await Promise.all(
       files.map(async (file) => {
-        const target = path28.join(messagesDir, file);
+        const target = path27.join(messagesDir, file);
         await removeIfExists(target);
       })
     );
   }
-  const githubAgentsDir = path28.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path27.join(subagentDir, ".github", "agents");
   if (await pathExists(githubAgentsDir)) {
     const agentFiles = await readdir2(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(path28.join(githubAgentsDir, file)))
+      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(path27.join(githubAgentsDir, file)))
     );
   }
-  const lockFile = path28.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path27.join(subagentDir, DEFAULT_LOCK_NAME);
   await writeFile3(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = path28.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path27.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun, cwd) {
@@ -22509,9 +22509,9 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = path28.join(subagentDir, ".github", "agents");
+    const githubAgentsDir = path27.join(subagentDir, ".github", "agents");
     await mkdir9(githubAgentsDir, { recursive: true });
-    const agentFile = path28.join(githubAgentsDir, `${chatId}.md`);
+    const agentFile = path27.join(githubAgentsDir, `${chatId}.md`);
     try {
       await copyFile(promptFile, agentFile);
     } catch (error) {
@@ -22528,7 +22528,7 @@ async function resolvePromptFile(promptFile) {
   if (!promptFile) {
     return void 0;
   }
-  const resolvedPrompt = path29.resolve(promptFile);
+  const resolvedPrompt = path28.resolve(promptFile);
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
@@ -22544,7 +22544,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = path29.resolve(attachment);
+    const resolvedPath = path28.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -22586,7 +22586,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = path29.basename(subagentDir);
+    const subagentName = path28.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -22614,9 +22614,9 @@ async function dispatchAgentSession(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path29.join(subagentDir, "messages");
-    const responseFileTmp = path29.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = path29.join(messagesDir, `${timestamp}_res.md`);
+    const messagesDir = path28.join(subagentDir, "messages");
+    const responseFileTmp = path28.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = path28.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(
       userQuery,
       responseFileTmp,
@@ -22721,7 +22721,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = path29.basename(subagentDir);
+    subagentName = path28.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -22752,17 +22752,17 @@ async function dispatchBatchAgent(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path29.join(subagentDir, "messages");
+    const messagesDir = path28.join(subagentDir, "messages");
     requestFiles = userQueries.map(
-      (_, index) => path29.join(messagesDir, `${timestamp}_${index}_req.md`)
+      (_, index) => path28.join(messagesDir, `${timestamp}_${index}_req.md`)
     );
     const responseTmpFiles = userQueries.map(
-      (_, index) => path29.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+      (_, index) => path28.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
     );
     responseFilesFinal = userQueries.map(
-      (_, index) => path29.join(messagesDir, `${timestamp}_${index}_res.md`)
+      (_, index) => path28.join(messagesDir, `${timestamp}_${index}_res.md`)
     );
-    const orchestratorFile = path29.join(messagesDir, `${timestamp}_orchestrator.md`);
+    const orchestratorFile = path28.join(messagesDir, `${timestamp}_orchestrator.md`);
     if (!dryRun) {
       await Promise.all(
         userQueries.map((query, index) => {
@@ -22875,7 +22875,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = path30.resolve(targetRoot);
+  const targetPath = path29.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -22895,7 +22895,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = path30.join(entry.absolutePath, lockName);
+      const lockFile = path29.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -22912,10 +22912,10 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const githubAgentsDir = path30.join(subagentDir, ".github", "agents");
-    const lockFile = path30.join(subagentDir, lockName);
-    const workspaceDst = path30.join(subagentDir, `${path30.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path30.join(githubAgentsDir, "wakeup.md");
+    const githubAgentsDir = path29.join(subagentDir, ".github", "agents");
+    const lockFile = path29.join(subagentDir, lockName);
+    const workspaceDst = path29.join(subagentDir, `${path29.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path29.join(githubAgentsDir, "wakeup.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -22953,10 +22953,10 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = path30.join(targetPath, `subagent-${nextIndex}`);
-    const githubAgentsDir = path30.join(subagentDir, ".github", "agents");
-    const workspaceDst = path30.join(subagentDir, `${path30.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path30.join(githubAgentsDir, "wakeup.md");
+    const subagentDir = path29.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = path29.join(subagentDir, ".github", "agents");
+    const workspaceDst = path29.join(subagentDir, `${path29.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path29.join(githubAgentsDir, "wakeup.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
@@ -23142,7 +23142,7 @@ var VSCodeProvider = class {
 async function locateVSCodeExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = path31.isAbsolute(candidate) ? candidate : path31.resolve(candidate);
+    const resolved = path30.isAbsolute(candidate) ? candidate : path30.resolve(candidate);
     try {
       await access3(resolved, constants3.F_OK);
       return resolved;
@@ -23171,7 +23171,7 @@ async function resolveWorkspaceTemplateFile(template) {
     return void 0;
   }
   try {
-    const stats = await stat4(path31.resolve(template));
+    const stats = await stat4(path30.resolve(template));
     return stats.isFile() ? template : void 0;
   } catch {
     return template;
@@ -23197,7 +23197,7 @@ function buildMandatoryPrereadBlock2(guidelineFiles, attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path31.basename(absolutePath);
+    const fileName = path30.basename(absolutePath);
     const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -23222,8 +23222,8 @@ function collectGuidelineFiles2(attachments, guidelinePatterns) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path31.resolve(attachment);
-    const normalized = absolutePath.split(path31.sep).join("/");
+    const absolutePath = path30.resolve(attachment);
+    const normalized = absolutePath.split(path30.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -23238,7 +23238,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path31.resolve(attachment);
+    const absolutePath = path30.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -23246,7 +23246,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri3(filePath) {
-  const absolutePath = path31.isAbsolute(filePath) ? filePath : path31.resolve(filePath);
+  const absolutePath = path30.isAbsolute(filePath) ? filePath : path30.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -23259,7 +23259,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(path31.resolve(attachment));
+    deduped.add(path30.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -23268,7 +23268,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(path31.resolve(inputFile));
+      deduped.add(path30.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -23348,11 +23348,11 @@ async function fileExists3(filePath) {
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = path322.resolve(filePath);
+  const absolutePath = path31.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await readFile11(absolutePath, "utf8");
+  const raw = await readFile10(absolutePath, "utf8");
   const parsed = parse4(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -23369,11 +23369,11 @@ function listTargetNames(definitions) {
 async function discoverProviders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path33.resolve(baseDir);
-  const root = path33.parse(dir).root;
+  let dir = path322.resolve(baseDir);
+  const root = path322.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path33.join(dir, ".agentv", "providers"));
-    dir = path33.dirname(dir);
+    candidateDirs.push(path322.join(dir, ".agentv", "providers"));
+    dir = path322.dirname(dir);
   }
   let files = [];
   for (const providersDir of candidateDirs) {
@@ -23389,7 +23389,7 @@ async function discoverProviders(registry, baseDir) {
   }
   const discoveredKinds = [];
   for (const filePath of files) {
-    const basename = path33.basename(filePath);
+    const basename = path322.basename(filePath);
     const kindName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(kindName)) {
       continue;
@@ -23587,15 +23587,15 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir15, readFile: readFile14, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
+  const { mkdir: mkdir15, readFile: readFile13, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
   const { tmpdir: tmpdir3 } = await import("node:os");
-  const path46 = await import("node:path");
+  const path45 = await import("node:path");
   const { randomUUID: randomUUID9 } = await import("node:crypto");
-  const dir = path46.join(tmpdir3(), `agentv-exec-${randomUUID9()}`);
+  const dir = path45.join(tmpdir3(), `agentv-exec-${randomUUID9()}`);
   await mkdir15(dir, { recursive: true });
-  const stdinPath = path46.join(dir, "stdin.txt");
-  const stdoutPath = path46.join(dir, "stdout.txt");
-  const stderrPath = path46.join(dir, "stderr.txt");
+  const stdinPath = path45.join(dir, "stdin.txt");
+  const stdoutPath = path45.join(dir, "stdout.txt");
+  const stderrPath = path45.join(dir, "stderr.txt");
   await writeFile9(stdinPath, stdinPayload, "utf8");
   const wrappedCommand = process.platform === "win32" ? `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
   const { spawn: spawn5 } = await import("node:child_process");
@@ -23625,8 +23625,8 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
         resolve2(code ?? 0);
       });
     });
-    const stdout = (await readFile14(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile14(stderrPath, "utf8")).replace(/\r\n/g, "\n");
+    const stdout = (await readFile13(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
+    const stderr = (await readFile13(stderrPath, "utf8")).replace(/\r\n/g, "\n");
     return { stdout, stderr, exitCode };
   } finally {
     await rm6(dir, { recursive: true, force: true });
@@ -23937,7 +23937,7 @@ var CodeEvaluator = class {
       outputPath,
       guidelineFiles: context2.evalCase.guideline_paths,
       inputFiles: context2.evalCase.file_paths.filter(
-        (path46) => !context2.evalCase.guideline_paths.includes(path46)
+        (path45) => !context2.evalCase.guideline_paths.includes(path45)
       ),
       input: context2.evalCase.input,
       trace: context2.trace ?? null,
@@ -24892,8 +24892,8 @@ function calculateScoreRangeResult(result, rubrics) {
   };
 }
 function resolveSandboxed(basePath, relativePath) {
-  const resolved = path34.resolve(basePath, relativePath);
-  if (!resolved.startsWith(basePath + path34.sep) && resolved !== basePath) {
+  const resolved = path33.resolve(basePath, relativePath);
+  if (!resolved.startsWith(basePath + path33.sep) && resolved !== basePath) {
     throw new Error(`Path '${relativePath}' is outside the workspace`);
   }
   return resolved;
@@ -24983,11 +24983,11 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
   for (const entry of entries) {
     if (matches.length >= MAX_SEARCH_MATCHES) return;
     if (SEARCH_SKIP_DIRS.has(entry.name)) continue;
-    const fullPath = path34.join(dirPath, entry.name);
+    const fullPath = path33.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       await searchDirectory(fullPath, workspacePath, regex, matches);
     } else if (entry.isFile()) {
-      const ext = path34.extname(entry.name).toLowerCase();
+      const ext = path33.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
         const stat8 = await fs2.stat(fullPath);
@@ -24999,7 +24999,7 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
           regex.lastIndex = 0;
           if (regex.test(lines[i])) {
             matches.push({
-              file: path34.relative(workspacePath, fullPath),
+              file: path33.relative(workspacePath, fullPath),
               line: i + 1,
               text: lines[i].substring(0, 200)
             });
@@ -25626,115 +25626,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path46, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path46);
-    const expectedValue = resolvePath(expectedData, path46);
+    const { path: path45, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path45);
+    const expectedValue = resolvePath(expectedData, path45);
     if (expectedValue === void 0) {
       return {
-        path: path46,
+        path: path45,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path46}: no expected value`
+        message: `${path45}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path46,
+          path: path45,
           score: 0,
           weight,
           hit: false,
-          message: `${path46} (required, missing)`
+          message: `${path45} (required, missing)`
         };
       }
       return {
-        path: path46,
+        path: path45,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path46}: optional field missing`
+        message: `${path45}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path46, candidateValue, expectedValue, weight);
+        return this.compareExact(path45, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path46,
+          path45,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path46, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path45, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path46,
+          path: path45,
           score: 0,
           weight,
           hit: false,
-          message: `${path46}: unknown match type "${match}"`
+          message: `${path45}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path46, candidateValue, expectedValue, weight) {
+  compareExact(path45, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path46,
+        path: path45,
         score: 1,
         weight,
         hit: true,
-        message: path46
+        message: path45
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path46,
+        path: path45,
         score: 0,
         weight,
         hit: false,
-        message: `${path46} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path45} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path46,
+      path: path45,
       score: 0,
       weight,
       hit: false,
-      message: `${path46} (value mismatch)`
+      message: `${path45} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path46, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path45, 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: path46,
+        path: path45,
         score: 0,
         weight,
         hit: false,
-        message: `${path46} (non-numeric value)`
+        message: `${path45} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path46,
+        path: path45,
         score: 0,
         weight,
         hit: false,
-        message: `${path46} (invalid numeric value)`
+        message: `${path45} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -25747,61 +25747,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path46,
+        path: path45,
         score: 1,
         weight,
         hit: true,
-        message: `${path46} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path45} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path46,
+      path: path45,
       score: 0,
       weight,
       hit: false,
-      message: `${path46} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path45} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path46, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path45, 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: path46,
+        path: path45,
         score: 0,
         weight,
         hit: false,
-        message: `${path46} (unparseable candidate date)`
+        message: `${path45} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path46,
+        path: path45,
         score: 0,
         weight,
         hit: false,
-        message: `${path46} (unparseable expected date)`
+        message: `${path45} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path46,
+        path: path45,
         score: 1,
         weight,
         hit: true,
-        message: path46
+        message: path45
       };
     }
     return {
-      path: path46,
+      path: path45,
       score: 0,
       weight,
       hit: false,
-      message: `${path46} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path45} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -25834,11 +25834,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path46) {
-  if (!path46 || !obj) {
+function resolvePath(obj, path45) {
+  if (!path45 || !obj) {
     return void 0;
   }
-  const parts = path46.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path45.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -26288,8 +26288,8 @@ var TokenUsageEvaluator = class {
     };
   }
 };
-function getNestedValue(obj, path46) {
-  const parts = path46.split(".");
+function getNestedValue(obj, path45) {
+  const parts = path45.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -27155,7 +27155,7 @@ async function executePromptTemplate(script, context2, config, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = path35.dirname(scriptPath);
+  const cwd = path34.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();
@@ -27426,16 +27426,16 @@ function createBuiltinRegistry() {
 async function discoverAssertions(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path36.resolve(baseDir);
-  const root = path36.parse(dir).root;
+  let dir = path35.resolve(baseDir);
+  const root = path35.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path36.join(dir, ".agentv", "assertions"));
-    dir = path36.dirname(dir);
+    candidateDirs.push(path35.join(dir, ".agentv", "assertions"));
+    dir = path35.dirname(dir);
   }
   let files = [];
   for (const assertionsDir of candidateDirs) {
     try {
-      const found = await fg3(patterns, {
+      const found = await fg22(patterns, {
         cwd: assertionsDir,
         absolute: true,
         onlyFiles: true
@@ -27446,7 +27446,7 @@ async function discoverAssertions(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = path36.basename(filePath);
+    const basename = path35.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -27465,17 +27465,17 @@ async function discoverAssertions(registry, baseDir) {
 async function discoverGraders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path37.resolve(baseDir);
-  const root = path37.parse(dir).root;
+  let dir = path36.resolve(baseDir);
+  const root = path36.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path37.join(dir, ".agentv", "graders"));
-    candidateDirs.push(path37.join(dir, ".agentv", "judges"));
-    dir = path37.dirname(dir);
+    candidateDirs.push(path36.join(dir, ".agentv", "graders"));
+    candidateDirs.push(path36.join(dir, ".agentv", "judges"));
+    dir = path36.dirname(dir);
   }
   let files = [];
   for (const gradersDir of candidateDirs) {
     try {
-      const found = await fg4(patterns, {
+      const found = await fg3(patterns, {
         cwd: gradersDir,
         absolute: true,
         onlyFiles: true
@@ -27486,7 +27486,7 @@ async function discoverGraders(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = path37.basename(filePath);
+    const basename = path36.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -27672,10 +27672,10 @@ async function stageNestedRepoChanges(workspacePath) {
   }
   for (const entry of entries) {
     if (entry === ".git" || entry === "node_modules") continue;
-    const childPath = path38.join(workspacePath, entry);
+    const childPath = path37.join(workspacePath, entry);
     try {
       if (!statSync(childPath).isDirectory()) continue;
-      if (!statSync(path38.join(childPath, ".git")).isDirectory()) continue;
+      if (!statSync(path37.join(childPath, ".git")).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -27712,14 +27712,14 @@ async function isDirectory(filePath) {
 }
 function getWorkspacePath(evalRunId, caseId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
-  return path39.join(root, evalRunId, caseId);
+  return path38.join(root, evalRunId, caseId);
 }
 async function copyDirectoryRecursive(src, dest) {
   await mkdir11(dest, { recursive: true });
   const entries = await readdir3(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path39.join(src, entry.name);
-    const destPath = path39.join(dest, entry.name);
+    const srcPath = path38.join(src, entry.name);
+    const destPath = path38.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
@@ -27731,7 +27731,7 @@ async function copyDirectoryRecursive(src, dest) {
   }
 }
 async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoot) {
-  const resolvedTemplatePath = path39.resolve(templatePath);
+  const resolvedTemplatePath = path38.resolve(templatePath);
   if (!await fileExists(resolvedTemplatePath)) {
     throw new TemplateNotFoundError(resolvedTemplatePath);
   }
@@ -27780,7 +27780,7 @@ async function cleanupWorkspace(workspacePath) {
 }
 async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
-  const evalDir = path39.join(root, evalRunId);
+  const evalDir = path38.join(root, evalRunId);
   if (await fileExists(evalDir)) {
     await rm4(evalDir, { recursive: true, force: true });
   }
@@ -27837,8 +27837,8 @@ async function copyDirectoryRecursive2(src, dest, skipDirs) {
   await mkdir12(dest, { recursive: true });
   const entries = await readdir4(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path40.join(src, entry.name);
-    const destPath = path40.join(dest, entry.name);
+    const srcPath = path39.join(src, entry.name);
+    const destPath = path39.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
@@ -27871,7 +27871,7 @@ var WorkspacePoolManager = class {
   async acquireWorkspace(options) {
     const { templatePath, repos, maxSlots, repoManager, poolReset } = options;
     const fingerprint = computeWorkspaceFingerprint(repos);
-    const poolDir = path40.join(this.poolRoot, fingerprint);
+    const poolDir = path39.join(this.poolRoot, fingerprint);
     await mkdir12(poolDir, { recursive: true });
     const drifted = await this.checkDrift(poolDir, fingerprint);
     if (drifted) {
@@ -27881,7 +27881,7 @@ var WorkspacePoolManager = class {
       await this.removeAllSlots(poolDir);
     }
     for (let i = 0; i < maxSlots; i++) {
-      const slotPath = path40.join(poolDir, `slot-${i}`);
+      const slotPath = path39.join(poolDir, `slot-${i}`);
       const lockPath = `${slotPath}.lock`;
       const locked = await this.tryLock(lockPath);
       if (!locked) {
@@ -27943,7 +27943,7 @@ var WorkspacePoolManager = class {
           throw err;
         }
         try {
-          const pidStr = await readFile12(lockPath, "utf-8");
+          const pidStr = await readFile11(lockPath, "utf-8");
           const pid = Number.parseInt(pidStr.trim(), 10);
           if (!Number.isNaN(pid)) {
             try {
@@ -27968,9 +27968,9 @@ var WorkspacePoolManager = class {
    * Returns false (no drift) if metadata.json doesn't exist (first use).
    */
   async checkDrift(poolDir, fingerprint) {
-    const metadataPath = path40.join(poolDir, "metadata.json");
+    const metadataPath = path39.join(poolDir, "metadata.json");
     try {
-      const raw = await readFile12(metadataPath, "utf-8");
+      const raw = await readFile11(metadataPath, "utf-8");
       const metadata = JSON.parse(raw);
       return metadata.fingerprint !== fingerprint;
     } catch {
@@ -27985,17 +27985,17 @@ var WorkspacePoolManager = class {
       repos,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await writeFile7(path40.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+    await writeFile7(path39.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 readdir4(poolDir);
     for (const entry of entries) {
       if (entry.startsWith("slot-") && !entry.endsWith(".lock")) {
-        const lockPath = path40.join(poolDir, `${entry}.lock`);
+        const lockPath = path39.join(poolDir, `${entry}.lock`);
         if (existsSync2(lockPath)) {
           try {
-            const pidStr = await readFile12(lockPath, "utf-8");
+            const pidStr = await readFile11(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
             if (!Number.isNaN(pid)) {
               try {
@@ -28008,12 +28008,12 @@ var WorkspacePoolManager = class {
           } catch {
           }
         }
-        await rm5(path40.join(poolDir, entry), { recursive: true, force: true });
+        await rm5(path39.join(poolDir, entry), { recursive: true, force: true });
         await rm5(lockPath, { force: true }).catch(() => {
         });
       }
     }
-    await rm5(path40.join(poolDir, "metadata.json"), { force: true }).catch(() => {
+    await rm5(path39.join(poolDir, "metadata.json"), { force: true }).catch(() => {
     });
   }
   /**
@@ -28023,7 +28023,7 @@ var WorkspacePoolManager = class {
    */
   async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
     for (const repo of repos) {
-      const repoDir = path40.join(slotPath, repo.path);
+      const repoDir = path39.join(slotPath, repo.path);
       if (!existsSync2(repoDir)) {
         continue;
       }
@@ -28144,7 +28144,7 @@ ${lines.join("\n")}`;
    * Handles checkout, ref resolution, ancestor walking, shallow clone, sparse checkout.
    */
   async materialize(repo, workspacePath) {
-    const targetDir = path41.join(workspacePath, repo.path);
+    const targetDir = path40.join(workspacePath, repo.path);
     const sourceUrl = getSourceUrl(repo.source);
     const startedAt = Date.now();
     if (this.verbose) {
@@ -28235,7 +28235,7 @@ ${lines.join("\n")}`;
   async reset(repos, workspacePath, reset) {
     const cleanFlag = reset === "strict" ? "-fdx" : "-fd";
     for (const repo of repos) {
-      const targetDir = path41.join(workspacePath, repo.path);
+      const targetDir = path40.join(workspacePath, repo.path);
       await this.runGit(["reset", "--hard", "HEAD"], { cwd: targetDir });
       await this.runGit(["clean", cleanFlag], { cwd: targetDir });
     }
@@ -28245,11 +28245,11 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (!templatePath) {
     return void 0;
   }
-  const resolved = path42.resolve(templatePath);
+  const resolved = path41.resolve(templatePath);
   const stats = await stat6(resolved);
   if (stats.isFile()) {
     return {
-      dir: path42.dirname(resolved),
+      dir: path41.dirname(resolved),
       workspaceFile: resolved
     };
   }
@@ -28261,14 +28261,14 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (workspaceFiles.length === 1) {
     return {
       dir: resolved,
-      workspaceFile: path42.join(resolved, workspaceFiles[0])
+      workspaceFile: path41.join(resolved, workspaceFiles[0])
     };
   }
   if (workspaceFiles.length > 1) {
     const conventionFile = workspaceFiles.find((f) => f === "template.code-workspace");
     return {
       dir: resolved,
-      workspaceFile: conventionFile ? path42.join(resolved, conventionFile) : void 0
+      workspaceFile: conventionFile ? path41.join(resolved, conventionFile) : void 0
     };
   }
   return { dir: resolved };
@@ -28468,7 +28468,7 @@ async function runEvaluation(options) {
   ];
   const evaluatorRegistry = buildEvaluatorRegistry(evaluators, resolveGraderProvider);
   const typeRegistry = createBuiltinRegistry();
-  const discoveryBaseDir = evalFilePath ? path43.dirname(path43.resolve(evalFilePath)) : process.cwd();
+  const discoveryBaseDir = evalFilePath ? path422.dirname(path422.resolve(evalFilePath)) : process.cwd();
   const evalDir = discoveryBaseDir;
   await discoverAssertions(typeRegistry, discoveryBaseDir);
   await discoverGraders(typeRegistry, discoveryBaseDir);
@@ -28657,7 +28657,7 @@ async function runEvaluation(options) {
   }
   try {
     if (suiteWorkspaceFile && sharedWorkspacePath) {
-      const copiedWorkspaceFile = path43.join(sharedWorkspacePath, path43.basename(suiteWorkspaceFile));
+      const copiedWorkspaceFile = path422.join(sharedWorkspacePath, path422.basename(suiteWorkspaceFile));
       try {
         await stat7(copiedWorkspaceFile);
         suiteWorkspaceFile = copiedWorkspaceFile;
@@ -28770,7 +28770,7 @@ async function runEvaluation(options) {
             dataset: evalCase.dataset,
             score: 0,
             assertions: [],
-            outputText: "",
+            output: [],
             target: target.name,
             error: `Suite budget exceeded ($${cumulativeBudgetCost.toFixed(4)} / $${totalBudgetUsd.toFixed(4)})`,
             budgetExceeded: true,
@@ -28806,7 +28806,7 @@ async function runEvaluation(options) {
             dataset: evalCase.dataset,
             score: 0,
             assertions: [],
-            outputText: "",
+            output: [],
             target: target.name,
             error: errorMsg,
             executionStatus: "execution_error",
@@ -29234,7 +29234,7 @@ async function runEvalCase(options) {
         );
       }
       if (caseWorkspaceFile && workspacePath) {
-        const copiedFile = path43.join(workspacePath, path43.basename(caseWorkspaceFile));
+        const copiedFile = path422.join(workspacePath, path422.basename(caseWorkspaceFile));
         try {
           await stat7(copiedFile);
           caseWorkspaceFile = copiedFile;
@@ -29294,10 +29294,10 @@ async function runEvalCase(options) {
       const files = evalCase.metadata.agent_skills_files;
       if (baseDir && files.length > 0) {
         for (const relPath of files) {
-          const srcPath = path43.resolve(baseDir, relPath);
-          const destPath = path43.resolve(workspacePath, relPath);
+          const srcPath = path422.resolve(baseDir, relPath);
+          const destPath = path422.resolve(workspacePath, relPath);
           try {
-            await mkdir13(path43.dirname(destPath), { recursive: true });
+            await mkdir13(path422.dirname(destPath), { recursive: true });
             await copyFile2(srcPath, destPath);
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -29773,7 +29773,6 @@ async function evaluateCandidate(options) {
     conversationId: evalCase.conversation_id,
     score: score.score,
     assertions: score.assertions,
-    outputText: candidate,
     target: target.name,
     tokenUsage,
     costUsd,
@@ -29784,7 +29783,7 @@ async function evaluateCandidate(options) {
     input,
     scores,
     trace: trace2,
-    output,
+    output: output ?? [{ role: "assistant", content: candidate }],
     fileChanges,
     executionStatus: classifyQualityStatus(score.score)
   };
@@ -29918,7 +29917,7 @@ async function runEvaluatorList(options) {
     fileChanges,
     workspacePath
   };
-  const evalFileDir = evalCase.guideline_paths[0] ? path43.dirname(evalCase.guideline_paths[0]) : process.cwd();
+  const evalFileDir = evalCase.guideline_paths[0] ? path422.dirname(evalCase.guideline_paths[0]) : process.cwd();
   const dispatchContext = {
     graderProvider,
     targetResolver,
@@ -29949,7 +29948,7 @@ async function runEvaluatorList(options) {
         weight,
         verdict: score2.verdict,
         assertions: score2.assertions,
-        evaluatorProviderRequest: score2.evaluatorRawRequest,
+        input: score2.evaluatorRawRequest,
         details: score2.details,
         scores: mapChildResults(score2.scores),
         tokenUsage: score2.tokenUsage,
@@ -30129,7 +30128,7 @@ function buildErrorResult(evalCase, targetName, timestamp, error, promptInputs,
     conversationId: evalCase.conversation_id,
     score: 0,
     assertions: [{ text: `Error: ${message}`, passed: false }],
-    outputText: `Error occurred: ${message}`,
+    output: [{ role: "assistant", content: `Error occurred: ${message}` }],
     target: targetName,
     requests,
     input,
@@ -30173,7 +30172,7 @@ function buildResultInput(promptInputs) {
       content: message.content
     }));
   }
-  return promptInputs.question;
+  return [{ role: "user", content: promptInputs.question }];
 }
 function aggregateEvaluatorTokenUsage(scores) {
   if (!scores || scores.length === 0) return void 0;
@@ -30239,7 +30238,7 @@ function mapChildResults(children) {
     weight: child.weight,
     verdict: child.verdict,
     assertions: child.assertions,
-    evaluatorProviderRequest: child.evaluatorRawRequest,
+    input: child.evaluatorRawRequest,
     scores: mapChildResults(child.scores),
     details: child.details,
     tokenUsage: child.tokenUsage
@@ -30287,7 +30286,7 @@ async function evaluate(config) {
   }
   const gitRoot = await findGitRoot(process.cwd());
   const repoRoot = gitRoot ?? process.cwd();
-  const testFilePath = config.specFile ? path44.resolve(config.specFile) : path44.join(process.cwd(), "__programmatic__.yaml");
+  const testFilePath = config.specFile ? path43.resolve(config.specFile) : path43.join(process.cwd(), "__programmatic__.yaml");
   await loadEnvHierarchy(repoRoot, testFilePath);
   let resolvedTarget;
   let taskProvider;
@@ -30416,10 +30415,10 @@ function computeSummary(results, durationMs) {
 var TARGET_FILE_CANDIDATES = [".agentv/targets.yaml", ".agentv/targets.yml"];
 async function discoverDefaultTarget(repoRoot) {
   const cwd = process.cwd();
-  const chain = buildDirectoryChain(path44.join(cwd, "_placeholder"), repoRoot);
+  const chain = buildDirectoryChain(path43.join(cwd, "_placeholder"), repoRoot);
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const targetsPath = path44.join(dir, candidate);
+      const targetsPath = path43.join(dir, candidate);
       if (!existsSync4(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
@@ -30436,7 +30435,7 @@ async function loadEnvHierarchy(repoRoot, startPath) {
   const chain = buildDirectoryChain(startPath, repoRoot);
   const envFiles = [];
   for (const dir of chain) {
-    const envPath = path44.join(dir, ".env");
+    const envPath = path43.join(dir, ".env");
     if (existsSync4(envPath)) envFiles.push(envPath);
   }
   for (let i = 0; i < envFiles.length; i++) {
@@ -30617,7 +30616,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await readFile13(filePath, "utf8");
+      const data = await readFile12(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -30625,13 +30624,13 @@ var ResponseCache = class {
   }
   async set(key, value) {
     const filePath = this.keyToPath(key);
-    const dir = path45.dirname(filePath);
+    const dir = path44.dirname(filePath);
     await mkdir14(dir, { recursive: true });
     await writeFile8(filePath, JSON.stringify(value, null, 2), "utf8");
   }
   keyToPath(key) {
     const prefix = key.slice(0, 2);
-    return path45.join(this.cachePath, prefix, `${key}.json`);
+    return path44.join(this.cachePath, prefix, `${key}.json`);
   }
 };
 function shouldEnableCache(params) {
@@ -30646,7 +30645,6 @@ function shouldSkipCacheForTemperature(targetConfig) {
   return false;
 }
 var STRIPPED_TOP_LEVEL_FIELDS = /* @__PURE__ */ new Set([
-  "outputText",
   "requests",
   "trace",
   "workspacePath",
@@ -30663,7 +30661,7 @@ var STRIPPED_TOP_LEVEL_FIELDS = /* @__PURE__ */ new Set([
   "startTime",
   "endTime"
 ]);
-var STRIPPED_EVALUATOR_FIELDS = /* @__PURE__ */ new Set(["rawRequest", "evaluatorProviderRequest"]);
+var STRIPPED_EVALUATOR_FIELDS = /* @__PURE__ */ new Set(["rawRequest", "input"]);
 function trimEvaluatorResult(result) {
   const trimmed = {};
   for (const [key, value] of Object.entries(result)) {
@@ -30818,7 +30816,11 @@ var OtelTraceExporter = class {
         rootSpan.setAttribute("agentv.target", result.target);
         if (result.dataset) rootSpan.setAttribute("agentv.dataset", result.dataset);
         rootSpan.setAttribute("agentv.score", result.score);
-        if (captureContent) rootSpan.setAttribute("agentv.output_text", result.outputText);
+        if (captureContent && result.output.length > 0) {
+          const lastMsg = result.output[result.output.length - 1];
+          const text2 = typeof lastMsg.content === "string" ? lastMsg.content : JSON.stringify(lastMsg.content);
+          rootSpan.setAttribute("agentv.output_text", text2);
+        }
         if (result.durationMs != null)
           rootSpan.setAttribute("agentv.trace.duration_ms", result.durationMs);
         if (result.costUsd != null) rootSpan.setAttribute("agentv.trace.cost_usd", result.costUsd);
@@ -31119,6 +31121,8 @@ export {
   resolveFileReference,
   CLI_PLACEHOLDERS,
   resolveTargetDefinition,
+  interpolateEnv,
+  loadCasesFromFile,
   KNOWN_PROVIDERS,
   PROVIDER_ALIASES,
   computeTraceSummary,
@@ -31248,4 +31252,4 @@ export {
   OtelStreamingObserver,
   createAgentKernel
 };
-//# sourceMappingURL=chunk-XGG64VIY.js.map
+//# sourceMappingURL=chunk-F4UDJ7LG.js.map