agentv 0.10.1 → 0.13.0

package/dist/{chunk-72BHGHIT.js → chunk-WMO5PVPX.js}

@@ -588,9 +588,9 @@ import { readFileSync as readFileSync2 } from "node:fs";
 // src/commands/eval/index.ts
 import fg from "fast-glob";
 import { stat as stat3 } from "node:fs/promises";
-import path15 from "node:path";
+import path19 from "node:path";
 
-// ../../packages/core/dist/chunk-YQBJAT5I.js
+// ../../packages/core/dist/chunk-U3GEJ3K7.js
 import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
@@ -1073,8 +1073,8 @@ function getErrorMap() {
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path19, errorMaps, issueData } = params;
-  const fullPath = [...path19, ...issueData.path || []];
+  const { data, path: path25, errorMaps, issueData } = params;
+  const fullPath = [...path25, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -1190,11 +1190,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path19, key2) {
+  constructor(parent, value, path25, key2) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path19;
+    this._path = path25;
     this._key = key2;
   }
   get path() {
@@ -4636,7 +4636,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../../packages/core/dist/chunk-YQBJAT5I.js
+// ../../packages/core/dist/chunk-U3GEJ3K7.js
 async function fileExists(filePath) {
   try {
     await access(filePath, constants.F_OK);
@@ -5288,12 +5288,21 @@ function isAgentProvider(provider) {
 }
 
 // ../../packages/core/dist/index.js
+import { readFile as readFile4 } from "node:fs/promises";
+import path62 from "node:path";
+import { parse as parse22 } from "yaml";
 import micromatch from "micromatch";
+import { readFile as readFile3 } from "node:fs/promises";
+import path22 from "node:path";
+import { parse as parse3 } from "yaml";
 import { constants as constants3 } from "node:fs";
-import { access as access3, readFile as readFile3 } from "node:fs/promises";
+import { access as access3 } from "node:fs/promises";
 import path8 from "node:path";
-import { fileURLToPath } from "node:url";
-import { parse as parse3 } from "yaml";
+import path32 from "node:path";
+import { readFile as readFile22 } from "node:fs/promises";
+import path42 from "node:path";
+import { readFile as readFile32 } from "node:fs/promises";
+import path52 from "node:path";
 
 // ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
 var _globalThis = typeof globalThis === "object" ? globalThis : global;
@@ -9747,17 +9756,17 @@ var $a = new Error("Agent definition is the prompt you give to the LLM for the a
 import { exec as execWithCallback } from "node:child_process";
 import fs from "node:fs/promises";
 import os2 from "node:os";
-import path22 from "node:path";
+import path72 from "node:path";
 import { promisify as promisify2 } from "node:util";
 import { exec as execCallback, spawn as spawn2 } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { constants as constants22, createWriteStream } from "node:fs";
 import { access as access22, mkdtemp, mkdir as mkdir3, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path42 from "node:path";
+import path9 from "node:path";
 import { promisify as promisify22 } from "node:util";
-import path32 from "node:path";
-import path52 from "node:path";
+import path82 from "node:path";
+import path10 from "node:path";
 
 // ../../node_modules/.pnpm/subagent@0.4.7/node_modules/subagent/dist/vscode/agentDispatch.js
 import { exec, spawn } from "child_process";
@@ -11696,13 +11705,12 @@ async function provisionSubagents(options) {
 
 // ../../packages/core/dist/index.js
 import { constants as constants32 } from "node:fs";
-import { access as access32, readFile as readFile22 } from "node:fs/promises";
-import path62 from "node:path";
-import { parse as parse22 } from "yaml";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { createHash, randomUUID as randomUUID3 } from "node:crypto";
+import { access as access32, readFile as readFile5 } from "node:fs/promises";
+import path11 from "node:path";
+import { parse as parse32 } from "yaml";
+import { createHash, randomUUID as randomUUID2 } from "node:crypto";
 import { mkdir as mkdir22, writeFile as writeFile22 } from "node:fs/promises";
-import path72 from "node:path";
+import path12 from "node:path";
 var TEST_MESSAGE_ROLE_VALUES = ["system", "user", "assistant", "tool"];
 var TEST_MESSAGE_ROLE_SET = new Set(TEST_MESSAGE_ROLE_VALUES);
 function isTestMessageRole(value) {
@@ -11747,42 +11755,179 @@ var EVALUATOR_KIND_SET = new Set(EVALUATOR_KIND_VALUES);
 function isEvaluatorKind(value) {
   return typeof value === "string" && EVALUATOR_KIND_SET.has(value);
 }
-var CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
-var ANSI_YELLOW = "\x1B[33m";
-var ANSI_RESET = "\x1B[0m";
-var SCHEMA_EVAL_V2 = "agentv-eval-v2";
-var SCHEMA_CONFIG_V2 = "agentv-config-v2";
-async function readTestSuiteMetadata(testFilePath) {
-  try {
-    const absolutePath = path8.resolve(testFilePath);
-    const content = await readFile3(absolutePath, "utf8");
-    const parsed = parse3(content);
-    if (!isJsonObject(parsed)) {
-      return {};
+function extractCodeBlocks(segments) {
+  const CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
+  const codeBlocks = [];
+  for (const segment of segments) {
+    const typeValue = segment["type"];
+    if (typeof typeValue !== "string" || typeValue !== "text") {
+      continue;
     }
-    return { target: extractTargetFromSuite(parsed) };
+    const textValue = segment["value"];
+    if (typeof textValue !== "string") {
+      continue;
+    }
+    const matches = textValue.match(CODE_BLOCK_PATTERN);
+    if (matches) {
+      codeBlocks.push(...matches);
+    }
+  }
+  return codeBlocks;
+}
+function formatFileContents(parts) {
+  const fileCount = parts.filter((p) => p.isFile).length;
+  if (fileCount > 0) {
+    return parts.map((part) => {
+      if (part.isFile && part.displayPath) {
+        return `<file path="${part.displayPath}">
+${part.content}
+</file>`;
+      }
+      return part.content;
+    }).join("\n\n");
+  }
+  return parts.map((p) => p.content).join(" ");
+}
+function formatSegment(segment) {
+  const type = asString(segment.type);
+  if (type === "text") {
+    return asString(segment.value);
+  }
+  if (type === "guideline_ref") {
+    const refPath = asString(segment.path);
+    return refPath ? `<Attached: ${refPath}>` : void 0;
+  }
+  if (type === "file") {
+    const text = asString(segment.text);
+    const filePath = asString(segment.path);
+    if (text && filePath) {
+      return formatFileContents([{ content: text.trim(), isFile: true, displayPath: filePath }]);
+    }
+  }
+  return void 0;
+}
+function hasVisibleContent(segments) {
+  return segments.some((segment) => {
+    const type = asString(segment.type);
+    if (type === "text") {
+      const value = asString(segment.value);
+      return value !== void 0 && value.trim().length > 0;
+    }
+    if (type === "guideline_ref") {
+      return false;
+    }
+    if (type === "file") {
+      const text = asString(segment.text);
+      return text !== void 0 && text.trim().length > 0;
+    }
+    return false;
+  });
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+async function fileExists2(absolutePath) {
+  try {
+    await access3(absolutePath, constants3.F_OK);
+    return true;
   } catch {
-    return {};
+    return false;
   }
 }
-function extractTargetFromSuite(suite) {
-  const execution = suite.execution;
-  if (execution && typeof execution === "object" && !Array.isArray(execution)) {
-    const executionTarget = execution.target;
-    if (typeof executionTarget === "string" && executionTarget.trim().length > 0) {
-      return executionTarget.trim();
+function resolveToAbsolutePath(candidate) {
+  if (candidate instanceof URL) {
+    return new URL(candidate).pathname;
+  }
+  if (typeof candidate === "string") {
+    if (candidate.startsWith("file://")) {
+      return new URL(candidate).pathname;
     }
+    return path8.resolve(candidate);
   }
-  const targetValue = suite.target;
-  if (typeof targetValue === "string" && targetValue.trim().length > 0) {
-    return targetValue.trim();
+  throw new TypeError("Unsupported repoRoot value. Expected string or URL.");
+}
+function buildDirectoryChain2(filePath, repoRoot) {
+  const directories = [];
+  const seen = /* @__PURE__ */ new Set();
+  const boundary = path8.resolve(repoRoot);
+  let current = path8.resolve(path8.dirname(filePath));
+  while (current !== void 0) {
+    if (!seen.has(current)) {
+      directories.push(current);
+      seen.add(current);
+    }
+    if (current === boundary) {
+      break;
+    }
+    const parent = path8.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
   }
-  return void 0;
+  if (!seen.has(boundary)) {
+    directories.push(boundary);
+  }
+  return directories;
+}
+function buildSearchRoots2(evalPath, repoRoot) {
+  const uniqueRoots = [];
+  const addRoot = (root2) => {
+    const normalized = path8.resolve(root2);
+    if (!uniqueRoots.includes(normalized)) {
+      uniqueRoots.push(normalized);
+    }
+  };
+  let currentDir = path8.dirname(evalPath);
+  let reachedBoundary = false;
+  while (!reachedBoundary) {
+    addRoot(currentDir);
+    const parentDir = path8.dirname(currentDir);
+    if (currentDir === repoRoot || parentDir === currentDir) {
+      reachedBoundary = true;
+    } else {
+      currentDir = parentDir;
+    }
+  }
+  addRoot(repoRoot);
+  addRoot(process.cwd());
+  return uniqueRoots;
+}
+function trimLeadingSeparators2(value) {
+  const trimmed = value.replace(/^[/\\]+/, "");
+  return trimmed.length > 0 ? trimmed : value;
+}
+async function resolveFileReference2(rawValue, searchRoots) {
+  const displayPath = trimLeadingSeparators2(rawValue);
+  const potentialPaths = [];
+  if (path8.isAbsolute(rawValue)) {
+    potentialPaths.push(path8.normalize(rawValue));
+  }
+  for (const base of searchRoots) {
+    potentialPaths.push(path8.resolve(base, displayPath));
+  }
+  const attempted = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of potentialPaths) {
+    const absoluteCandidate = path8.resolve(candidate);
+    if (seen.has(absoluteCandidate)) {
+      continue;
+    }
+    seen.add(absoluteCandidate);
+    attempted.push(absoluteCandidate);
+    if (await fileExists2(absoluteCandidate)) {
+      return { displayPath, resolvedPath: absoluteCandidate, attempted };
+    }
+  }
+  return { displayPath, attempted };
 }
+var SCHEMA_CONFIG_V2 = "agentv-config-v2";
+var ANSI_YELLOW = "\x1B[33m";
+var ANSI_RESET = "\x1B[0m";
 async function loadConfig(evalFilePath, repoRoot) {
-  const directories = buildDirectoryChain(evalFilePath, repoRoot);
+  const directories = buildDirectoryChain2(evalFilePath, repoRoot);
   for (const directory of directories) {
-    const configPath = path8.join(directory, ".agentv", "config.yaml");
+    const configPath = path22.join(directory, ".agentv", "config.yaml");
     if (!await fileExists2(configPath)) {
       continue;
     }
@@ -11825,71 +11970,174 @@ function isGuidelineFile(filePath, patterns) {
   const patternsToUse = patterns ?? [];
   return micromatch.isMatch(normalized, patternsToUse);
 }
-function extractCodeBlocks(segments) {
-  const codeBlocks = [];
-  for (const segment of segments) {
-    const typeValue = segment["type"];
-    if (typeof typeValue !== "string" || typeValue !== "text") {
-      continue;
-    }
-    const textValue = segment["value"];
-    if (typeof textValue !== "string") {
-      continue;
-    }
-    const matches = textValue.match(CODE_BLOCK_PATTERN);
-    if (matches) {
-      codeBlocks.push(...matches);
+function extractTargetFromSuite(suite) {
+  const execution = suite.execution;
+  if (execution && typeof execution === "object" && !Array.isArray(execution)) {
+    const executionTarget = execution.target;
+    if (typeof executionTarget === "string" && executionTarget.trim().length > 0) {
+      return executionTarget.trim();
     }
   }
-  return codeBlocks;
+  const targetValue = suite.target;
+  if (typeof targetValue === "string" && targetValue.trim().length > 0) {
+    return targetValue.trim();
+  }
+  return void 0;
 }
-async function processMessages(options) {
-  const {
-    messages,
-    searchRoots,
-    repoRootPath,
-    guidelinePatterns,
-    guidelinePaths,
-    textParts,
-    messageType,
-    verbose
-  } = options;
-  const segments = [];
-  for (const message of messages) {
-    const content = message.content;
-    if (typeof content === "string") {
-      segments.push({ type: "text", value: content });
-      if (textParts) {
-        textParts.push(content);
-      }
+function logWarning(message) {
+  console.warn(`${ANSI_YELLOW}Warning: ${message}${ANSI_RESET}`);
+}
+var ANSI_YELLOW2 = "\x1B[33m";
+var ANSI_RESET2 = "\x1B[0m";
+async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId) {
+  const execution = rawEvalCase.execution;
+  const candidateEvaluators = isJsonObject2(execution) ? execution.evaluators ?? rawEvalCase.evaluators : rawEvalCase.evaluators ?? globalExecution?.evaluators;
+  if (candidateEvaluators === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(candidateEvaluators)) {
+    logWarning2(`Skipping evaluators for '${evalId}': expected array`);
+    return void 0;
+  }
+  const evaluators = [];
+  for (const rawEvaluator of candidateEvaluators) {
+    if (!isJsonObject2(rawEvaluator)) {
+      logWarning2(`Skipping invalid evaluator entry for '${evalId}' (expected object)`);
       continue;
     }
-    for (const rawSegment of content) {
-      if (!isJsonObject(rawSegment)) {
+    const name = asString2(rawEvaluator.name);
+    const typeValue = rawEvaluator.type;
+    if (!name || !isEvaluatorKind(typeValue)) {
+      logWarning2(`Skipping evaluator with invalid name/type in '${evalId}'`);
+      continue;
+    }
+    if (typeValue === "code") {
+      const script = asString2(rawEvaluator.script);
+      if (!script) {
+        logWarning2(`Skipping code evaluator '${name}' in '${evalId}': missing script`);
         continue;
       }
-      const segmentType = asString(rawSegment.type);
-      if (segmentType === "file") {
-        const rawValue = asString(rawSegment.value);
-        if (!rawValue) {
-          continue;
+      const cwd = asString2(rawEvaluator.cwd);
+      let resolvedCwd;
+      if (cwd) {
+        const resolved = await resolveFileReference2(cwd, searchRoots);
+        if (resolved.resolvedPath) {
+          resolvedCwd = path32.resolve(resolved.resolvedPath);
+        } else {
+          logWarning2(
+            `Code evaluator '${name}' in '${evalId}': cwd not found (${resolved.displayPath})`,
+            resolved.attempted.length > 0 ? resolved.attempted.map((attempt) => `  Tried: ${attempt}`) : void 0
+          );
         }
-        const { displayPath, resolvedPath, attempted } = await resolveFileReference(
-          rawValue,
-          searchRoots
-        );
-        if (!resolvedPath) {
-          const attempts = attempted.length ? ["  Tried:", ...attempted.map((candidate) => `    ${candidate}`)] : void 0;
+      } else {
+        resolvedCwd = searchRoots[0];
+      }
+      evaluators.push({
+        name,
+        type: "code",
+        script,
+        cwd,
+        resolvedCwd
+      });
+      continue;
+    }
+    const prompt = asString2(rawEvaluator.prompt);
+    let promptPath;
+    if (prompt) {
+      const resolved = await resolveFileReference2(prompt, searchRoots);
+      if (resolved.resolvedPath) {
+        promptPath = path32.resolve(resolved.resolvedPath);
+      } else {
+        logWarning2(
+          `Inline prompt used for evaluator '${name}' in '${evalId}' (file not found: ${resolved.displayPath})`,
+          resolved.attempted.length > 0 ? resolved.attempted.map((attempt) => `  Tried: ${attempt}`) : void 0
+        );
+      }
+    }
+    const _model = asString2(rawEvaluator.model);
+    evaluators.push({
+      name,
+      type: "llm_judge",
+      prompt,
+      promptPath
+    });
+  }
+  return evaluators.length > 0 ? evaluators : void 0;
+}
+function coerceEvaluator(candidate, contextId) {
+  if (typeof candidate !== "string") {
+    return void 0;
+  }
+  if (isEvaluatorKind(candidate)) {
+    return candidate;
+  }
+  logWarning2(`Unknown evaluator '${candidate}' in ${contextId}, falling back to default`);
+  return void 0;
+}
+function asString2(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function isJsonObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function logWarning2(message, details) {
+  if (details && details.length > 0) {
+    const detailBlock = details.join("\n");
+    console.warn(`${ANSI_YELLOW2}Warning: ${message}
+${detailBlock}${ANSI_RESET2}`);
+  } else {
+    console.warn(`${ANSI_YELLOW2}Warning: ${message}${ANSI_RESET2}`);
+  }
+}
+var ANSI_YELLOW3 = "\x1B[33m";
+var ANSI_RESET3 = "\x1B[0m";
+async function processMessages(options) {
+  const {
+    messages,
+    searchRoots,
+    repoRootPath,
+    guidelinePatterns,
+    guidelinePaths,
+    textParts,
+    messageType,
+    verbose
+  } = options;
+  const segments = [];
+  for (const message of messages) {
+    const content = message.content;
+    if (typeof content === "string") {
+      segments.push({ type: "text", value: content });
+      if (textParts) {
+        textParts.push(content);
+      }
+      continue;
+    }
+    for (const rawSegment of content) {
+      if (!isJsonObject(rawSegment)) {
+        continue;
+      }
+      const segmentType = asString3(rawSegment.type);
+      if (segmentType === "file") {
+        const rawValue = asString3(rawSegment.value);
+        if (!rawValue) {
+          continue;
+        }
+        const { displayPath, resolvedPath, attempted } = await resolveFileReference2(
+          rawValue,
+          searchRoots
+        );
+        if (!resolvedPath) {
+          const attempts = attempted.length ? ["  Tried:", ...attempted.map((candidate) => `    ${candidate}`)] : void 0;
           const context2 = messageType === "input" ? "" : " in expected_messages";
-          logWarning(`File not found${context2}: ${displayPath}`, attempts);
+          logWarning3(`File not found${context2}: ${displayPath}`, attempts);
           continue;
         }
         try {
-          const fileContent = (await readFile3(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+          const fileContent = (await readFile22(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
           if (messageType === "input" && guidelinePatterns && guidelinePaths) {
-            const relativeToRepo = path8.relative(repoRootPath, resolvedPath);
+            const relativeToRepo = path42.relative(repoRootPath, resolvedPath);
             if (isGuidelineFile(relativeToRepo, guidelinePatterns)) {
-              guidelinePaths.push(path8.resolve(resolvedPath));
+              guidelinePaths.push(path42.resolve(resolvedPath));
               if (verbose) {
                 console.log(`  [Guideline] Found: ${displayPath}`);
                 console.log(`    Resolved to: ${resolvedPath}`);
@@ -11901,7 +12149,7 @@ async function processMessages(options) {
             type: "file",
             path: displayPath,
             text: fileContent,
-            resolvedPath: path8.resolve(resolvedPath)
+            resolvedPath: path42.resolve(resolvedPath)
           });
           if (verbose) {
             const label = messageType === "input" ? "[File]" : "[Expected Output File]";
@@ -11910,7 +12158,7 @@ async function processMessages(options) {
           }
         } catch (error) {
           const context2 = messageType === "input" ? "" : " expected output";
-          logWarning(`Could not read${context2} file ${resolvedPath}: ${error.message}`);
+          logWarning3(`Could not read${context2} file ${resolvedPath}: ${error.message}`);
         }
         continue;
       }
@@ -11924,202 +12172,116 @@ async function processMessages(options) {
   }
   return segments;
 }
-async function loadEvalCases(evalFilePath, repoRoot, options) {
-  const verbose = options?.verbose ?? false;
-  const evalIdFilter = options?.evalId;
-  const absoluteTestPath = path8.resolve(evalFilePath);
-  if (!await fileExists2(absoluteTestPath)) {
-    throw new Error(`Test file not found: ${evalFilePath}`);
-  }
-  const repoRootPath = resolveToAbsolutePath(repoRoot);
-  const searchRoots = buildSearchRoots(absoluteTestPath, repoRootPath);
-  const config = await loadConfig(absoluteTestPath, repoRootPath);
-  const guidelinePatterns = config?.guideline_patterns;
-  const rawFile = await readFile3(absoluteTestPath, "utf8");
-  const parsed = parse3(rawFile);
-  if (!isJsonObject(parsed)) {
-    throw new Error(`Invalid test file format: ${evalFilePath}`);
-  }
-  const suite = parsed;
-  const datasetNameFromSuite = asString(suite.dataset)?.trim();
-  const fallbackDataset = path8.basename(absoluteTestPath).replace(/\.ya?ml$/i, "") || "eval";
-  const datasetName = datasetNameFromSuite && datasetNameFromSuite.length > 0 ? datasetNameFromSuite : fallbackDataset;
-  const schema = suite.$schema;
-  if (schema !== SCHEMA_EVAL_V2) {
-    const message = typeof schema === "string" ? `Invalid $schema value '${schema}' in ${evalFilePath}. Expected '${SCHEMA_EVAL_V2}'` : `Missing required field '$schema' in ${evalFilePath}.
-Please add '$schema: ${SCHEMA_EVAL_V2}' at the top of the file.`;
-    throw new Error(message);
+async function resolveAssistantContent(content, searchRoots, verbose) {
+  if (typeof content === "string") {
+    return content;
   }
-  const rawTestcases = suite.evalcases;
-  if (!Array.isArray(rawTestcases)) {
-    throw new Error(`Invalid test file format: ${evalFilePath} - missing 'evalcases' field`);
+  if (!content) {
+    return "";
   }
-  const globalEvaluator = coerceEvaluator(suite.evaluator, "global") ?? "llm_judge";
-  const globalExecution = isJsonObject(suite.execution) ? suite.execution : void 0;
-  const globalTarget = asString(globalExecution?.target) ?? asString(suite.target);
-  const results = [];
-  for (const rawEvalcase of rawTestcases) {
-    if (!isJsonObject(rawEvalcase)) {
-      logWarning("Skipping invalid eval case entry (expected object)");
+  const parts = [];
+  for (const entry of content) {
+    if (typeof entry === "string") {
+      parts.push({ content: entry, isFile: false });
       continue;
     }
-    const evalcase = rawEvalcase;
-    const id = asString(evalcase.id);
-    if (evalIdFilter && id !== evalIdFilter) {
+    if (!isJsonObject(entry)) {
       continue;
     }
-    const conversationId = asString(evalcase.conversation_id);
-    const outcome = asString(evalcase.outcome);
-    const inputMessagesValue = evalcase.input_messages;
-    const expectedMessagesValue = evalcase.expected_messages;
-    if (!id || !outcome || !Array.isArray(inputMessagesValue)) {
-      logWarning(`Skipping incomplete eval case: ${id ?? "unknown"}`);
+    const segmentType = asString3(entry.type);
+    if (segmentType === "file") {
+      const rawValue = asString3(entry.value);
+      if (!rawValue) {
+        continue;
+      }
+      const { displayPath, resolvedPath, attempted } = await resolveFileReference2(
+        rawValue,
+        searchRoots
+      );
+      if (!resolvedPath) {
+        const attempts = attempted.length ? ["  Tried:", ...attempted.map((candidate) => `    ${candidate}`)] : void 0;
+        logWarning3(`File not found in expected_messages: ${displayPath}`, attempts);
+        continue;
+      }
+      try {
+        const fileContent = (await readFile22(resolvedPath, "utf8")).replace(/\r\n/g, "\n").trim();
+        parts.push({ content: fileContent, isFile: true, displayPath });
+        if (verbose) {
+          console.log(`  [Expected Assistant File] Found: ${displayPath}`);
+          console.log(`    Resolved to: ${resolvedPath}`);
+        }
+      } catch (error) {
+        logWarning3(`Could not read file ${resolvedPath}: ${error.message}`);
+      }
       continue;
     }
-    const hasExpectedMessages = Array.isArray(expectedMessagesValue) && expectedMessagesValue.length > 0;
-    const inputMessages = inputMessagesValue.filter((msg) => isTestMessage(msg));
-    const expectedMessages = hasExpectedMessages ? expectedMessagesValue.filter((msg) => isTestMessage(msg)) : [];
-    if (hasExpectedMessages && expectedMessages.length === 0) {
-      logWarning(`No valid expected message found for eval case: ${id}`);
+    const textValue = asString3(entry.text);
+    if (typeof textValue === "string") {
+      parts.push({ content: textValue, isFile: false });
       continue;
     }
-    if (expectedMessages.length > 1) {
-      logWarning(`Multiple expected messages found for eval case: ${id}, using first`);
-    }
-    const guidelinePaths = [];
-    const inputTextParts = [];
-    const inputSegments = await processMessages({
-      messages: inputMessages,
-      searchRoots,
-      repoRootPath,
-      guidelinePatterns,
-      guidelinePaths,
-      textParts: inputTextParts,
-      messageType: "input",
-      verbose
-    });
-    const outputSegments = hasExpectedMessages ? await processMessages({
-      messages: expectedMessages,
-      searchRoots,
-      repoRootPath,
-      guidelinePatterns,
-      messageType: "output",
-      verbose
-    }) : [];
-    const codeSnippets = extractCodeBlocks(inputSegments);
-    const expectedContent = expectedMessages[0]?.content;
-    const referenceAnswer = expectedContent ? await resolveAssistantContent(expectedContent, searchRoots, verbose) : "";
-    const question = inputTextParts.map((part) => part.trim()).filter((part) => part.length > 0).join(" ");
-    const evalCaseEvaluatorKind = coerceEvaluator(evalcase.evaluator, id) ?? globalEvaluator;
-    const evaluators = await parseEvaluators(evalcase, globalExecution, searchRoots, id ?? "unknown");
-    const userFilePaths = [];
-    for (const segment of inputSegments) {
-      if (segment.type === "file" && typeof segment.resolvedPath === "string") {
-        userFilePaths.push(segment.resolvedPath);
-      }
-    }
-    const allFilePaths = [
-      ...guidelinePaths.map((guidelinePath) => path8.resolve(guidelinePath)),
-      ...userFilePaths
-    ];
-    const testCase = {
-      id,
-      dataset: datasetName,
-      conversation_id: conversationId,
-      question,
-      input_messages: inputMessages,
-      input_segments: inputSegments,
-      output_segments: outputSegments,
-      reference_answer: referenceAnswer,
-      guideline_paths: guidelinePaths.map((guidelinePath) => path8.resolve(guidelinePath)),
-      guideline_patterns: guidelinePatterns,
-      file_paths: allFilePaths,
-      code_snippets: codeSnippets,
-      expected_outcome: outcome,
-      evaluator: evalCaseEvaluatorKind,
-      evaluators
-    };
-    if (verbose) {
-      console.log(`
-[Eval Case: ${id}]`);
-      if (testCase.guideline_paths.length > 0) {
-        console.log(`  Guidelines used: ${testCase.guideline_paths.length}`);
-        for (const guidelinePath of testCase.guideline_paths) {
-          console.log(`    - ${guidelinePath}`);
-        }
-      } else {
-        console.log("  No guidelines found");
-      }
+    const valueValue = asString3(entry.value);
+    if (typeof valueValue === "string") {
+      parts.push({ content: valueValue, isFile: false });
+      continue;
     }
-    results.push(testCase);
+    parts.push({ content: JSON.stringify(entry), isFile: false });
   }
-  return results;
+  return formatFileContents(parts);
 }
-function needsRoleMarkers(messages, processedSegmentsByMessage) {
-  if (messages.some((msg) => msg.role === "assistant" || msg.role === "tool")) {
-    return true;
-  }
-  let messagesWithContent = 0;
-  for (const segments of processedSegmentsByMessage) {
-    if (hasVisibleContent(segments)) {
-      messagesWithContent++;
-    }
-  }
-  return messagesWithContent > 1;
+function asString3(value) {
+  return typeof value === "string" ? value : void 0;
 }
-function hasVisibleContent(segments) {
-  return segments.some((segment) => {
-    const type = asString(segment.type);
-    if (type === "text") {
-      const value = asString(segment.value);
-      return value !== void 0 && value.trim().length > 0;
-    }
-    if (type === "guideline_ref") {
-      return false;
-    }
-    if (type === "file") {
-      const text = asString(segment.text);
-      return text !== void 0 && text.trim().length > 0;
-    }
-    return false;
-  });
+function cloneJsonObject(source2) {
+  const entries = Object.entries(source2).map(([key2, value]) => [key2, cloneJsonValue(value)]);
+  return Object.fromEntries(entries);
 }
-function formatSegment(segment) {
-  const type = asString(segment.type);
-  if (type === "text") {
-    return asString(segment.value);
+function cloneJsonValue(value) {
+  if (value === null) {
+    return null;
   }
-  if (type === "guideline_ref") {
-    const refPath = asString(segment.path);
-    return refPath ? `<Attached: ${refPath}>` : void 0;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
   }
-  if (type === "file") {
-    const text = asString(segment.text);
-    const filePath = asString(segment.path);
-    if (text && filePath) {
-      return `=== ${filePath} ===
-${text}`;
-    }
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneJsonValue(item));
   }
-  return void 0;
+  if (typeof value === "object") {
+    return cloneJsonObject(value);
+  }
+  return value;
 }
+function logWarning3(message, details) {
+  if (details && details.length > 0) {
+    const detailBlock = details.join("\n");
+    console.warn(`${ANSI_YELLOW3}Warning: ${message}
+${detailBlock}${ANSI_RESET3}`);
+  } else {
+    console.warn(`${ANSI_YELLOW3}Warning: ${message}${ANSI_RESET3}`);
+  }
+}
+var ANSI_YELLOW4 = "\x1B[33m";
+var ANSI_RESET4 = "\x1B[0m";
 async function buildPromptInputs(testCase) {
-  const guidelineContents = [];
+  const guidelineParts = [];
   for (const rawPath of testCase.guideline_paths) {
-    const absolutePath = path8.resolve(rawPath);
+    const absolutePath = path52.resolve(rawPath);
     if (!await fileExists2(absolutePath)) {
-      logWarning(`Could not read guideline file ${absolutePath}: file does not exist`);
+      logWarning4(`Could not read guideline file ${absolutePath}: file does not exist`);
       continue;
     }
     try {
-      const content = (await readFile3(absolutePath, "utf8")).replace(/\r\n/g, "\n");
-      guidelineContents.push(`=== ${path8.basename(absolutePath)} ===
-${content}`);
+      const content = (await readFile32(absolutePath, "utf8")).replace(/\r\n/g, "\n").trim();
+      guidelineParts.push({
+        content,
+        isFile: true,
+        displayPath: path52.basename(absolutePath)
+      });
     } catch (error) {
-      logWarning(`Could not read guideline file ${absolutePath}: ${error.message}`);
+      logWarning4(`Could not read guideline file ${absolutePath}: ${error.message}`);
     }
   }
-  const guidelines = guidelineContents.map((part) => part.trim()).filter((part) => part.length > 0).join("\n\n");
+  const guidelines = formatFileContents(guidelineParts);
   const segmentsByMessage = [];
   const fileContentsByPath = /* @__PURE__ */ new Map();
   for (const segment of testCase.input_segments) {
@@ -12140,9 +12302,9 @@ ${content}`);
             messageSegments.push({ type: "text", value: segment });
           }
         } else if (isJsonObject(segment)) {
-          const type = asString(segment.type);
+          const type = asString4(segment.type);
           if (type === "file") {
-            const value = asString(segment.value);
+            const value = asString4(segment.value);
             if (!value) continue;
             if (testCase.guideline_patterns && isGuidelineFile(value, testCase.guideline_patterns)) {
               messageSegments.push({ type: "guideline_ref", path: value });
@@ -12153,7 +12315,7 @@ ${content}`);
               messageSegments.push({ type: "file", text: fileText, path: value });
             }
           } else if (type === "text") {
-            const textValue = asString(segment.value);
+            const textValue = asString4(segment.value);
             if (textValue && textValue.trim().length > 0) {
               messageSegments.push({ type: "text", value: textValue });
             }
@@ -12209,6 +12371,18 @@ ${messageContent}`);
   }) : void 0;
   return { question, guidelines, chatPrompt };
 }
+function needsRoleMarkers(messages, processedSegmentsByMessage) {
+  if (messages.some((msg) => msg.role === "assistant" || msg.role === "tool")) {
+    return true;
+  }
+  let messagesWithContent = 0;
+  for (const segments of processedSegmentsByMessage) {
+    if (hasVisibleContent(segments)) {
+      messagesWithContent++;
+    }
+  }
+  return messagesWithContent > 1;
+}
 function buildChatPromptFromSegments(options) {
   const { messages, segmentsByMessage, guidelinePatterns, guidelineContent, systemPrompt } = options;
   if (messages.length === 0) {
@@ -12259,217 +12433,189 @@ ${guidelineContent.trim()}`);
       name = "tool";
     }
     for (const segment of segments) {
-      if (segment.type === "guideline_ref") {
-        continue;
-      }
-      const formatted = formatSegment(segment);
-      if (formatted) {
-        const isGuidelineRef = segment.type === "file" && typeof segment.path === "string" && guidelinePatterns && isGuidelineFile(segment.path, guidelinePatterns);
-        if (isGuidelineRef) {
-          continue;
-        }
-        contentParts.push(formatted);
-      }
-    }
-    if (contentParts.length === 0) {
-      continue;
-    }
-    chatPrompt.push({
-      role,
-      content: contentParts.join("\n"),
-      ...name ? { name } : {}
-    });
-  }
-  return chatPrompt.length > 0 ? chatPrompt : void 0;
-}
-async function fileExists2(absolutePath) {
-  try {
-    await access3(absolutePath, constants3.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function resolveToAbsolutePath(candidate) {
-  if (candidate instanceof URL) {
-    return fileURLToPath(candidate);
-  }
-  if (typeof candidate === "string") {
-    if (candidate.startsWith("file://")) {
-      return fileURLToPath(new URL(candidate));
-    }
-    return path8.resolve(candidate);
-  }
-  throw new TypeError("Unsupported repoRoot value. Expected string or URL.");
-}
-function asString(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function cloneJsonObject(source2) {
-  const entries = Object.entries(source2).map(([key2, value]) => [key2, cloneJsonValue(value)]);
-  return Object.fromEntries(entries);
-}
-function cloneJsonValue(value) {
-  if (value === null) {
-    return null;
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => cloneJsonValue(item));
-  }
-  return cloneJsonObject(value);
-}
-async function resolveAssistantContent(content, searchRoots, verbose) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (!content) {
-    return "";
-  }
-  const parts = [];
-  for (const entry of content) {
-    if (typeof entry === "string") {
-      parts.push(entry);
-      continue;
-    }
-    if (!isJsonObject(entry)) {
-      continue;
-    }
-    const segmentType = asString(entry.type);
-    if (segmentType === "file") {
-      const rawValue = asString(entry.value);
-      if (!rawValue) {
-        continue;
-      }
-      const { displayPath, resolvedPath, attempted } = await resolveFileReference(
-        rawValue,
-        searchRoots
-      );
-      if (!resolvedPath) {
-        const attempts = attempted.length ? ["  Tried:", ...attempted.map((candidate) => `    ${candidate}`)] : void 0;
-        logWarning(`File not found in expected_messages: ${displayPath}`, attempts);
+      if (segment.type === "guideline_ref") {
         continue;
       }
-      try {
-        const fileContent = (await readFile3(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
-        parts.push(fileContent);
-        if (verbose) {
-          console.log(`  [Expected Assistant File] Found: ${displayPath}`);
-          console.log(`    Resolved to: ${resolvedPath}`);
+      const formatted = formatSegment(segment);
+      if (formatted) {
+        const isGuidelineRef = segment.type === "file" && typeof segment.path === "string" && guidelinePatterns && isGuidelineFile(segment.path, guidelinePatterns);
+        if (isGuidelineRef) {
+          continue;
         }
-      } catch (error) {
-        logWarning(`Could not read file ${resolvedPath}: ${error.message}`);
+        contentParts.push(formatted);
       }
-      continue;
     }
-    const textValue = asString(entry.text);
-    if (typeof textValue === "string") {
-      parts.push(textValue);
+    if (contentParts.length === 0) {
       continue;
     }
-    const valueValue = asString(entry.value);
-    if (typeof valueValue === "string") {
-      parts.push(valueValue);
-      continue;
+    chatPrompt.push({
+      role,
+      content: contentParts.join("\n"),
+      ...name ? { name } : {}
+    });
+  }
+  return chatPrompt.length > 0 ? chatPrompt : void 0;
+}
+function asString4(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function logWarning4(message) {
+  console.warn(`${ANSI_YELLOW4}Warning: ${message}${ANSI_RESET4}`);
+}
+var ANSI_YELLOW5 = "\x1B[33m";
+var ANSI_RESET5 = "\x1B[0m";
+var SCHEMA_EVAL_V2 = "agentv-eval-v2";
+async function readTestSuiteMetadata(testFilePath) {
+  try {
+    const absolutePath = path62.resolve(testFilePath);
+    const content = await readFile4(absolutePath, "utf8");
+    const parsed = parse22(content);
+    if (!isJsonObject(parsed)) {
+      return {};
     }
-    parts.push(JSON.stringify(entry));
+    return { target: extractTargetFromSuite(parsed) };
+  } catch {
+    return {};
   }
-  return parts.join(" ");
 }
-async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId) {
-  const execution = rawEvalCase.execution;
-  const candidateEvaluators = isJsonObject(execution) ? execution.evaluators ?? rawEvalCase.evaluators : rawEvalCase.evaluators ?? globalExecution?.evaluators;
-  if (candidateEvaluators === void 0) {
-    return void 0;
+async function loadEvalCases(evalFilePath, repoRoot, options) {
+  const verbose = options?.verbose ?? false;
+  const evalIdFilter = options?.evalId;
+  const absoluteTestPath = path62.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 readFile4(absoluteTestPath, "utf8");
+  const parsed = parse22(rawFile);
+  if (!isJsonObject(parsed)) {
+    throw new Error(`Invalid test file format: ${evalFilePath}`);
   }
-  if (!Array.isArray(candidateEvaluators)) {
-    logWarning(`Skipping evaluators for '${evalId}': expected array`);
-    return void 0;
+  const suite = parsed;
+  const datasetNameFromSuite = asString5(suite.dataset)?.trim();
+  const fallbackDataset = path62.basename(absoluteTestPath).replace(/\.ya?ml$/i, "") || "eval";
+  const datasetName = datasetNameFromSuite && datasetNameFromSuite.length > 0 ? datasetNameFromSuite : fallbackDataset;
+  const schema = suite.$schema;
+  if (schema !== SCHEMA_EVAL_V2) {
+    const message = typeof schema === "string" ? `Invalid $schema value '${schema}' in ${evalFilePath}. Expected '${SCHEMA_EVAL_V2}'` : `Missing required field '$schema' in ${evalFilePath}.
+Please add '$schema: ${SCHEMA_EVAL_V2}' at the top of the file.`;
+    throw new Error(message);
   }
-  const evaluators = [];
-  for (const rawEvaluator of candidateEvaluators) {
-    if (!isJsonObject(rawEvaluator)) {
-      logWarning(`Skipping invalid evaluator entry for '${evalId}' (expected object)`);
+  const rawTestcases = suite.evalcases;
+  if (!Array.isArray(rawTestcases)) {
+    throw new Error(`Invalid test file format: ${evalFilePath} - missing 'evalcases' field`);
+  }
+  const globalEvaluator = coerceEvaluator(suite.evaluator, "global") ?? "llm_judge";
+  const globalExecution = isJsonObject(suite.execution) ? suite.execution : void 0;
+  const _globalTarget = asString5(globalExecution?.target) ?? asString5(suite.target);
+  const results = [];
+  for (const rawEvalcase of rawTestcases) {
+    if (!isJsonObject(rawEvalcase)) {
+      logWarning5("Skipping invalid eval case entry (expected object)");
       continue;
     }
-    const name = asString(rawEvaluator.name);
-    const typeValue = rawEvaluator.type;
-    if (!name || !isEvaluatorKind(typeValue)) {
-      logWarning(`Skipping evaluator with invalid name/type in '${evalId}'`);
+    const evalcase = rawEvalcase;
+    const id = asString5(evalcase.id);
+    if (evalIdFilter && id !== evalIdFilter) {
       continue;
     }
-    if (typeValue === "code") {
-      const script = asString(rawEvaluator.script);
-      if (!script) {
-        logWarning(`Skipping code evaluator '${name}' in '${evalId}': missing script`);
-        continue;
-      }
-      const cwd = asString(rawEvaluator.cwd);
-      let resolvedCwd;
-      if (cwd) {
-        const resolved = await resolveFileReference(cwd, searchRoots);
-        if (resolved.resolvedPath) {
-          resolvedCwd = path8.resolve(resolved.resolvedPath);
-        } else {
-          logWarning(
-            `Code evaluator '${name}' in '${evalId}': cwd not found (${resolved.displayPath})`,
-            resolved.attempted.length > 0 ? resolved.attempted.map((attempt) => `  Tried: ${attempt}`) : void 0
-          );
-        }
-      } else {
-        resolvedCwd = searchRoots[0];
-      }
-      evaluators.push({
-        name,
-        type: "code",
-        script,
-        cwd,
-        resolvedCwd
-      });
+    const conversationId = asString5(evalcase.conversation_id);
+    const outcome = asString5(evalcase.outcome);
+    const inputMessagesValue = evalcase.input_messages;
+    const expectedMessagesValue = evalcase.expected_messages;
+    if (!id || !outcome || !Array.isArray(inputMessagesValue)) {
+      logWarning5(`Skipping incomplete eval case: ${id ?? "unknown"}`);
       continue;
     }
-    const prompt = asString(rawEvaluator.prompt);
-    let promptPath;
-    if (prompt) {
-      const resolved = await resolveFileReference(prompt, searchRoots);
-      if (resolved.resolvedPath) {
-        promptPath = path8.resolve(resolved.resolvedPath);
+    const hasExpectedMessages = Array.isArray(expectedMessagesValue) && expectedMessagesValue.length > 0;
+    const inputMessages = inputMessagesValue.filter((msg) => isTestMessage(msg));
+    const expectedMessages = hasExpectedMessages ? expectedMessagesValue.filter((msg) => isTestMessage(msg)) : [];
+    if (hasExpectedMessages && expectedMessages.length === 0) {
+      logWarning5(`No valid expected message found for eval case: ${id}`);
+      continue;
+    }
+    if (expectedMessages.length > 1) {
+      logWarning5(`Multiple expected messages found for eval case: ${id}, using first`);
+    }
+    const guidelinePaths = [];
+    const inputTextParts = [];
+    const inputSegments = await processMessages({
+      messages: inputMessages,
+      searchRoots,
+      repoRootPath,
+      guidelinePatterns,
+      guidelinePaths,
+      textParts: inputTextParts,
+      messageType: "input",
+      verbose
+    });
+    const outputSegments = hasExpectedMessages ? await processMessages({
+      messages: expectedMessages,
+      searchRoots,
+      repoRootPath,
+      guidelinePatterns,
+      messageType: "output",
+      verbose
+    }) : [];
+    const codeSnippets = extractCodeBlocks(inputSegments);
+    const expectedContent = expectedMessages[0]?.content;
+    const referenceAnswer = expectedContent ? await resolveAssistantContent(expectedContent, searchRoots, verbose) : "";
+    const question = inputTextParts.map((part) => part.trim()).filter((part) => part.length > 0).join(" ");
+    const evalCaseEvaluatorKind = coerceEvaluator(evalcase.evaluator, id) ?? globalEvaluator;
+    const evaluators = await parseEvaluators(evalcase, globalExecution, searchRoots, id ?? "unknown");
+    const userFilePaths = [];
+    for (const segment of inputSegments) {
+      if (segment.type === "file" && typeof segment.resolvedPath === "string") {
+        userFilePaths.push(segment.resolvedPath);
+      }
+    }
+    const allFilePaths = [
+      ...guidelinePaths.map((guidelinePath) => path62.resolve(guidelinePath)),
+      ...userFilePaths
+    ];
+    const testCase = {
+      id,
+      dataset: datasetName,
+      conversation_id: conversationId,
+      question,
+      input_messages: inputMessages,
+      input_segments: inputSegments,
+      output_segments: outputSegments,
+      reference_answer: referenceAnswer,
+      guideline_paths: guidelinePaths.map((guidelinePath) => path62.resolve(guidelinePath)),
+      guideline_patterns: guidelinePatterns,
+      file_paths: allFilePaths,
+      code_snippets: codeSnippets,
+      expected_outcome: outcome,
+      evaluator: evalCaseEvaluatorKind,
+      evaluators
+    };
+    if (verbose) {
+      console.log(`
+[Eval Case: ${id}]`);
+      if (testCase.guideline_paths.length > 0) {
+        console.log(`  Guidelines used: ${testCase.guideline_paths.length}`);
+        for (const guidelinePath of testCase.guideline_paths) {
+          console.log(`    - ${guidelinePath}`);
+        }
       } else {
-        logWarning(
-          `Inline prompt used for evaluator '${name}' in '${evalId}' (file not found: ${resolved.displayPath})`,
-          resolved.attempted.length > 0 ? resolved.attempted.map((attempt) => `  Tried: ${attempt}`) : void 0
-        );
+        console.log("  No guidelines found");
       }
     }
-    const model = asString(rawEvaluator.model);
-    evaluators.push({
-      name,
-      type: "llm_judge",
-      prompt,
-      promptPath
-    });
+    results.push(testCase);
   }
-  return evaluators.length > 0 ? evaluators : void 0;
+  return results;
 }
-function coerceEvaluator(candidate, contextId) {
-  if (typeof candidate !== "string") {
-    return void 0;
-  }
-  if (isEvaluatorKind(candidate)) {
-    return candidate;
-  }
-  logWarning(`Unknown evaluator '${candidate}' in ${contextId}, falling back to default`);
-  return void 0;
+function asString5(value) {
+  return typeof value === "string" ? value : void 0;
 }
-function logWarning(message, details) {
+function logWarning5(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
-    console.warn(`${ANSI_YELLOW}Warning: ${message}
-${detailBlock}${ANSI_RESET}`);
+    console.warn(`${ANSI_YELLOW5}Warning: ${message}
+${detailBlock}${ANSI_RESET5}`);
   } else {
-    console.warn(`${ANSI_YELLOW}Warning: ${message}${ANSI_RESET}`);
+    console.warn(`${ANSI_YELLOW5}Warning: ${message}${ANSI_RESET5}`);
   }
 }
 var DEFAULT_SYSTEM_PROMPT = "You are a careful assistant. Follow all provided instructions and do not fabricate results.";
@@ -12498,9 +12644,8 @@ function buildChatPrompt(request) {
 }
 function resolveSystemContent(request) {
   const systemSegments = [];
-  const metadataSystemPrompt = typeof request.metadata?.systemPrompt === "string" ? request.metadata.systemPrompt : void 0;
-  if (metadataSystemPrompt && metadataSystemPrompt.trim().length > 0) {
-    systemSegments.push(metadataSystemPrompt.trim());
+  if (request.systemPrompt && request.systemPrompt.trim().length > 0) {
+    systemSegments.push(request.systemPrompt.trim());
   } else {
     systemSegments.push(DEFAULT_SYSTEM_PROMPT);
   }
@@ -12925,7 +13070,7 @@ function normalizeInputFiles(inputFiles) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path22.resolve(inputFile);
+    const absolutePath = path72.resolve(inputFile);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -12939,7 +13084,7 @@ function formatFileList(files, template) {
   const formatter = template ?? "{path}";
   return files.map((filePath) => {
     const escapedPath = shellEscape(filePath);
-    const escapedName = shellEscape(path22.basename(filePath));
+    const escapedName = shellEscape(path72.basename(filePath));
     return formatter.replaceAll("{path}", escapedPath).replaceAll("{basename}", escapedName);
   }).join(" ");
 }
@@ -12963,7 +13108,7 @@ function generateOutputFilePath(evalCaseId) {
   const safeEvalId = evalCaseId || "unknown";
   const timestamp = Date.now();
   const random = Math.random().toString(36).substring(2, 9);
-  return path22.join(os2.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}.json`);
+  return path72.join(os2.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}.json`);
 }
 function formatTimeoutSuffix(timeoutMs) {
   if (!timeoutMs || timeoutMs <= 0) {
@@ -13040,7 +13185,7 @@ function normalizeInputFiles2(inputFiles) {
   }
   const deduped = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path32.resolve(inputFile);
+    const absolutePath = path82.resolve(inputFile);
     if (!deduped.has(absolutePath)) {
       deduped.set(absolutePath, absolutePath);
     }
@@ -13053,14 +13198,14 @@ function collectGuidelineFiles(inputFiles, guidelinePatterns, overrides) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path32.resolve(inputFile);
+    const absolutePath = path82.resolve(inputFile);
     if (overrides?.has(absolutePath)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
       }
       continue;
     }
-    const normalized = absolutePath.split(path32.sep).join("/");
+    const normalized = absolutePath.split(path82.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -13075,7 +13220,7 @@ function collectInputFiles(inputFiles) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path32.resolve(inputFile);
+    const absolutePath = path82.resolve(inputFile);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -13087,7 +13232,7 @@ function buildMandatoryPrereadBlock(guidelineFiles, inputFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path32.basename(absolutePath);
+    const fileName = path82.basename(absolutePath);
     const fileUri = pathToFileUri2(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -13107,7 +13252,7 @@ ${buildList(inputFiles).join("\n")}.`);
   return sections.join("\n");
 }
 function pathToFileUri2(filePath) {
-  const absolutePath = path32.isAbsolute(filePath) ? filePath : path32.resolve(filePath);
+  const absolutePath = path82.isAbsolute(filePath) ? filePath : path82.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -13143,7 +13288,7 @@ var CodexProvider = class {
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
       const promptContent = buildPromptDocument(request, inputFiles);
-      const promptFile = path42.join(workspaceRoot, PROMPT_FILENAME);
+      const promptFile = path9.join(workspaceRoot, PROMPT_FILENAME);
       await writeFile3(promptFile, promptContent, "utf8");
       const args = this.buildCodexArgs();
       const cwd = this.resolveCwd(workspaceRoot);
@@ -13193,7 +13338,7 @@ var CodexProvider = class {
     if (!this.config.cwd) {
       return workspaceRoot;
     }
-    return path42.resolve(this.config.cwd);
+    return path9.resolve(this.config.cwd);
   }
   buildCodexArgs() {
     const args = ["--ask-for-approval", "never", "exec", "--json", "--color", "never", "--skip-git-repo-check"];
@@ -13227,7 +13372,7 @@ var CodexProvider = class {
     }
   }
   async createWorkspace() {
-    return await mkdtemp(path42.join(tmpdir(), WORKSPACE_PREFIX));
+    return await mkdtemp(path9.join(tmpdir(), WORKSPACE_PREFIX));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
@@ -13241,9 +13386,9 @@ var CodexProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path42.resolve(this.config.logDir);
+      return path9.resolve(this.config.logDir);
     }
-    return path42.join(process.cwd(), ".agentv", "logs", "codex");
+    return path9.join(process.cwd(), ".agentv", "logs", "codex");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -13257,7 +13402,7 @@ var CodexProvider = class {
       console.warn(`Skipping Codex stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path42.join(logDir, buildLogFilename(request, this.targetName));
+    const filePath = path9.join(logDir, buildLogFilename(request, this.targetName));
     try {
       const logger = await CodexStreamLogger.create({
         filePath,
@@ -13472,7 +13617,7 @@ function tryParseJsonValue(rawLine) {
 async function locateExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = path42.isAbsolute(candidate) ? candidate : path42.resolve(candidate);
+    const resolved = path9.isAbsolute(candidate) ? candidate : path9.resolve(candidate);
     const executablePath = await ensureWindowsExecutableVariant(resolved);
     await access22(executablePath, constants22.F_OK);
     return executablePath;
@@ -13926,6 +14071,9 @@ var VSCodeProvider = class {
 };
 function buildPromptDocument2(request, attachments, guidelinePatterns) {
   const parts = [];
+  if (request.systemPrompt && request.systemPrompt.trim().length > 0) {
+    parts.push(request.systemPrompt.trim());
+  }
   const guidelineFiles = collectGuidelineFiles2(attachments, guidelinePatterns);
   const attachmentFiles = collectAttachmentFiles(attachments);
   const nonGuidelineAttachments = attachmentFiles.filter(
@@ -13943,7 +14091,7 @@ function buildMandatoryPrereadBlock2(guidelineFiles, attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path52.basename(absolutePath);
+    const fileName = path10.basename(absolutePath);
     const fileUri = pathToFileUri22(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -13968,8 +14116,8 @@ function collectGuidelineFiles2(attachments, guidelinePatterns) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path52.resolve(attachment);
-    const normalized = absolutePath.split(path52.sep).join("/");
+    const absolutePath = path10.resolve(attachment);
+    const normalized = absolutePath.split(path10.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -13984,7 +14132,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path52.resolve(attachment);
+    const absolutePath = path10.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -13992,7 +14140,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri22(filePath) {
-  const absolutePath = path52.isAbsolute(filePath) ? filePath : path52.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}`;
@@ -14005,7 +14153,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(path52.resolve(attachment));
+    deduped.add(path10.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -14014,7 +14162,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(path52.resolve(inputFile));
+      deduped.add(path10.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -14111,12 +14259,12 @@ async function fileExists3(filePath) {
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = path62.resolve(filePath);
+  const absolutePath = path11.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await readFile22(absolutePath, "utf8");
-  const parsed = parse22(raw);
+  const raw = await readFile5(absolutePath, "utf8");
+  const parsed = parse32(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with '$schema' and 'targets' fields`);
   }
@@ -14151,17 +14299,34 @@ function createProvider(target) {
     }
   }
 }
+var DEFAULT_EVALUATOR_TEMPLATE = `You are an expert evaluator. Your goal is to grade the candidate_answer based on how well it achieves the expected_outcome for the original task.
+
+Use the reference_answer as a gold standard for a high-quality response (if provided). The candidate_answer does not need to match it verbatim, but should capture the key points and follow the same spirit.
+
+Be concise and focused in your evaluation. Provide succinct, specific feedback rather than verbose explanations.
+
+[[ ## expected_outcome ## ]]
+{{expected_outcome}}
+
+[[ ## question ## ]]
+{{question}}
+
+[[ ## reference_answer ## ]]
+{{reference_answer}}
+
+[[ ## candidate_answer ## ]]
+{{candidate_answer}}`;
 var LlmJudgeEvaluator = class {
   kind = "llm_judge";
   resolveJudgeProvider;
   maxOutputTokens;
   temperature;
-  customPrompt;
+  evaluatorTemplate;
   constructor(options) {
     this.resolveJudgeProvider = options.resolveJudgeProvider;
     this.maxOutputTokens = options.maxOutputTokens;
     this.temperature = options.temperature;
-    this.customPrompt = options.customPrompt;
+    this.evaluatorTemplate = options.evaluatorTemplate;
   }
   async evaluate(context2) {
     const judgeProvider = await this.resolveJudgeProvider(context2);
@@ -14171,26 +14336,21 @@ var LlmJudgeEvaluator = class {
     return this.evaluateWithPrompt(context2, judgeProvider);
   }
   async evaluateWithPrompt(context2, judgeProvider) {
-    const hasReferenceAnswer = hasNonEmptyReferenceAnswer(context2.evalCase);
     const formattedQuestion = context2.promptInputs.question && context2.promptInputs.question.trim().length > 0 ? context2.promptInputs.question : context2.evalCase.question;
-    let prompt = buildQualityPrompt(context2.evalCase, context2.candidate, formattedQuestion);
-    let systemPrompt = context2.systemPrompt ?? this.customPrompt ?? buildSystemPrompt(hasReferenceAnswer);
-    if (systemPrompt && hasTemplateVariables(systemPrompt)) {
-      const variables = {
-        input_messages: JSON.stringify(context2.evalCase.input_segments, null, 2),
-        output_messages: JSON.stringify(context2.evalCase.output_segments, null, 2),
-        candidate_answer: context2.candidate,
-        reference_answer: context2.evalCase.reference_answer ?? "",
-        expected_outcome: context2.evalCase.expected_outcome,
-        question: formattedQuestion
-      };
-      prompt = substituteVariables(systemPrompt, variables);
-      systemPrompt = buildSystemPrompt(hasReferenceAnswer);
-    }
-    const metadata = systemPrompt !== void 0 ? { systemPrompt } : {};
+    const variables = {
+      input_messages: JSON.stringify(context2.evalCase.input_segments, null, 2),
+      output_messages: JSON.stringify(context2.evalCase.output_segments, null, 2),
+      candidate_answer: context2.candidate.trim(),
+      reference_answer: (context2.evalCase.reference_answer ?? "").trim(),
+      expected_outcome: context2.evalCase.expected_outcome.trim(),
+      question: formattedQuestion.trim()
+    };
+    const systemPrompt = buildOutputSchema();
+    const evaluatorTemplate = context2.evaluatorTemplateOverride ?? this.evaluatorTemplate ?? DEFAULT_EVALUATOR_TEMPLATE;
+    const userPrompt = substituteVariables(evaluatorTemplate, variables);
     const response = await judgeProvider.invoke({
-      question: prompt,
-      metadata,
+      question: userPrompt,
+      systemPrompt,
       evalCaseId: context2.evalCase.id,
       attempt: context2.attempt,
       maxOutputTokens: this.maxOutputTokens,
@@ -14203,11 +14363,9 @@ var LlmJudgeEvaluator = class {
     const reasoning = parsed.reasoning ?? response.reasoning;
     const expectedAspectCount = Math.max(hits.length + misses.length, 1);
     const evaluatorRawRequest = {
-      id: randomUUID2(),
-      provider: judgeProvider.id,
-      prompt,
-      target: context2.target.name,
-      ...systemPrompt !== void 0 && { systemPrompt }
+      userPrompt,
+      systemPrompt,
+      target: judgeProvider.targetName
     };
     return {
       score,
@@ -14219,20 +14377,8 @@ var LlmJudgeEvaluator = class {
     };
   }
 };
-function buildSystemPrompt(hasReferenceAnswer) {
-  const basePrompt = [
-    "You are an expert evaluator. Your goal is to grade the candidate_answer based on how well it achieves the expected_outcome for the original task.",
-    ""
-  ];
-  if (hasReferenceAnswer) {
-    basePrompt.push(
-      "Use the reference_answer as a gold standard for a high-quality response. The candidate_answer does not need to match it verbatim, but should capture the key points and follow the same spirit.",
-      ""
-    );
-  }
-  basePrompt.push(
-    "Be concise and focused in your evaluation. Provide succinct, specific feedback rather than verbose explanations.",
-    "",
+function buildOutputSchema() {
+  return [
     "You must respond with a single JSON object matching this schema:",
     "",
     "{",
@@ -14241,30 +14387,7 @@ function buildSystemPrompt(hasReferenceAnswer) {
     '  "misses": [<array of strings, max 4 items, brief specific failures or omissions, empty if none>],',
     '  "reasoning": "<string, concise explanation for the score, 1-2 sentences max>"',
     "}"
-  );
-  return basePrompt.join("\n");
-}
-function buildQualityPrompt(evalCase, candidate, question) {
-  const parts = [
-    "[[ ## expected_outcome ## ]]",
-    evalCase.expected_outcome.trim(),
-    "",
-    "[[ ## question ## ]]",
-    question.trim(),
-    ""
-  ];
-  if (hasNonEmptyReferenceAnswer(evalCase)) {
-    parts.push(
-      "[[ ## reference_answer ## ]]",
-      evalCase.reference_answer.trim(),
-      ""
-    );
-  }
-  parts.push(
-    "[[ ## candidate_answer ## ]]",
-    candidate.trim()
-  );
-  return parts.join("\n");
+  ].join("\n");
 }
 function clampScore(value) {
   if (Number.isNaN(value) || !Number.isFinite(value)) {
@@ -14346,9 +14469,6 @@ function extractJsonBlob(text) {
 function isNonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
-function hasNonEmptyReferenceAnswer(evalCase) {
-  return evalCase.reference_answer !== void 0 && evalCase.reference_answer.trim().length > 0;
-}
 var CodeEvaluator = class {
   kind = "code";
   script;
@@ -14454,11 +14574,8 @@ function parseJsonSafe(payload) {
     return void 0;
   }
 }
-function hasTemplateVariables(text) {
-  return /\$\{[a-zA-Z0-9_]+\}/.test(text);
-}
 function substituteVariables(template, variables) {
-  return template.replace(/\$\{([a-zA-Z0-9_]+)\}/g, (match, varName) => {
+  return template.replace(/\{\{([a-zA-Z0-9_]+)\}\}/g, (match, varName) => {
     return variables[varName] ?? match;
   });
 }
@@ -15018,6 +15135,7 @@ async function evaluateCandidate(options) {
     }
   }
   return {
+    timestamp: completedAt.toISOString(),
     eval_id: evalCase.id,
     dataset: evalCase.dataset,
     conversation_id: evalCase.conversation_id,
@@ -15025,14 +15143,12 @@ async function evaluateCandidate(options) {
     hits: score.hits,
     misses: score.misses,
     candidate_answer: candidate,
-    expected_aspect_count: score.expectedAspectCount,
     target: target.name,
-    timestamp: completedAt.toISOString(),
     reasoning: score.reasoning,
     raw_aspects: score.rawAspects,
     agent_provider_request: agentProviderRequest,
     lm_provider_request: lmProviderRequest,
-    evaluator_raw_request: evaluatorResults ? void 0 : score.evaluatorRawRequest,
+    evaluator_provider_request: evaluatorResults ? void 0 : score.evaluatorRawRequest,
     evaluator_results: evaluatorResults
   };
 }
@@ -15109,7 +15225,7 @@ async function runEvaluatorList(options) {
           hits: score2.hits,
           misses: score2.misses,
           reasoning: score2.reasoning,
-          evaluator_raw_request: score2.evaluatorRawRequest
+          evaluator_provider_request: score2.evaluatorRawRequest
         });
         continue;
       }
@@ -15136,7 +15252,7 @@ async function runEvaluatorList(options) {
           hits: score2.hits,
           misses: score2.misses,
           reasoning: score2.reasoning,
-          evaluator_raw_request: score2.evaluatorRawRequest
+          evaluator_provider_request: score2.evaluatorRawRequest
         });
         continue;
       }
@@ -15189,7 +15305,7 @@ async function runLlmJudgeEvaluator(options) {
     promptInputs,
     now,
     judgeProvider,
-    systemPrompt: customPrompt,
+    evaluatorTemplateOverride: customPrompt,
     evaluator: config
   });
 }
@@ -15230,8 +15346,8 @@ function buildEvaluatorRegistry(overrides, resolveJudgeProvider) {
 async function dumpPrompt(directory, evalCase, promptInputs) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const filename = `${timestamp}_${sanitizeFilename(evalCase.id)}.json`;
-  const filePath = path72.resolve(directory, filename);
-  await mkdir22(path72.dirname(filePath), { recursive: true });
+  const filePath = path12.resolve(directory, filename);
+  await mkdir22(path12.dirname(filePath), { recursive: true });
   const payload = {
     eval_id: evalCase.id,
     question: promptInputs.question,
@@ -15245,7 +15361,7 @@ function sanitizeFilename(value) {
     return "prompt";
   }
   const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "_");
-  return sanitized.length > 0 ? sanitized : randomUUID3();
+  return sanitized.length > 0 ? sanitized : randomUUID2();
 }
 async function invokeProvider(provider, options) {
   const { evalCase, promptInputs, attempt, agentTimeoutMs, signal } = options;
@@ -15301,6 +15417,7 @@ function buildErrorResult(evalCase, targetName, timestamp, error, promptInputs,
     }
   }
   return {
+    timestamp: timestamp.toISOString(),
     eval_id: evalCase.id,
     dataset: evalCase.dataset,
     conversation_id: evalCase.conversation_id,
@@ -15308,9 +15425,7 @@ function buildErrorResult(evalCase, targetName, timestamp, error, promptInputs,
     hits: [],
     misses: [`Error: ${message}`],
     candidate_answer: `Error occurred: ${message}`,
-    expected_aspect_count: 0,
     target: targetName,
-    timestamp: timestamp.toISOString(),
     raw_aspects: [],
     agent_provider_request: agentProviderRequest,
     lm_provider_request: lmProviderRequest,
@@ -15352,19 +15467,19 @@ function createAgentKernel() {
 // src/commands/eval/run-eval.ts
 import { constants as constants6 } from "node:fs";
 import { access as access6, mkdir as mkdir6 } from "node:fs/promises";
-import path14 from "node:path";
+import path18 from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/commands/eval/env.ts
 import { config as loadDotenv } from "dotenv";
 import { constants as constants4 } from "node:fs";
 import { access as access4 } from "node:fs/promises";
-import path9 from "node:path";
+import path13 from "node:path";
 function uniqueDirs(directories) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const dir of directories) {
-    const absolute = path9.resolve(dir);
+    const absolute = path13.resolve(dir);
     if (seen.has(absolute)) {
       continue;
     }
@@ -15383,14 +15498,14 @@ async function fileExists4(filePath) {
 }
 function collectAncestorDirectories(start, boundary) {
   const directories = [];
-  const boundaryDir = path9.resolve(boundary);
-  let current = path9.resolve(start);
+  const boundaryDir = path13.resolve(boundary);
+  let current = path13.resolve(start);
   while (current !== void 0) {
     directories.push(current);
     if (current === boundaryDir) {
       break;
     }
-    const parent = path9.dirname(current);
+    const parent = path13.dirname(current);
     if (parent === current) {
       break;
     }
@@ -15400,7 +15515,7 @@ function collectAncestorDirectories(start, boundary) {
 }
 async function loadEnvFromHierarchy(options) {
   const { testFilePath, repoRoot, verbose } = options;
-  const testDir = path9.dirname(path9.resolve(testFilePath));
+  const testDir = path13.dirname(path13.resolve(testFilePath));
   const cwd = process.cwd();
   const searchDirs = uniqueDirs([
     ...collectAncestorDirectories(testDir, repoRoot),
@@ -15408,7 +15523,7 @@ async function loadEnvFromHierarchy(options) {
     cwd
   ]);
   for (const dir of searchDirs) {
-    const candidate = path9.join(dir, ".env");
+    const candidate = path13.join(dir, ".env");
     if (await fileExists4(candidate)) {
       loadDotenv({ path: candidate, override: false });
       if (verbose) {
@@ -15632,7 +15747,7 @@ var Mutex = class {
 // src/commands/eval/jsonl-writer.ts
 import { createWriteStream as createWriteStream2 } from "node:fs";
 import { mkdir as mkdir4 } from "node:fs/promises";
-import path10 from "node:path";
+import path14 from "node:path";
 import { finished } from "node:stream/promises";
 var JsonlWriter = class _JsonlWriter {
   stream;
@@ -15642,7 +15757,7 @@ var JsonlWriter = class _JsonlWriter {
     this.stream = stream;
   }
   static async open(filePath) {
-    await mkdir4(path10.dirname(filePath), { recursive: true });
+    await mkdir4(path14.dirname(filePath), { recursive: true });
     const stream = createWriteStream2(filePath, { flags: "w", encoding: "utf8" });
     return new _JsonlWriter(stream);
   }
@@ -15674,7 +15789,7 @@ var JsonlWriter = class _JsonlWriter {
 // src/commands/eval/yaml-writer.ts
 import { createWriteStream as createWriteStream3 } from "node:fs";
 import { mkdir as mkdir5 } from "node:fs/promises";
-import path11 from "node:path";
+import path15 from "node:path";
 import { finished as finished2 } from "node:stream/promises";
 import { stringify as stringifyYaml } from "yaml";
 var YamlWriter = class _YamlWriter {
@@ -15686,7 +15801,7 @@ var YamlWriter = class _YamlWriter {
     this.stream = stream;
   }
   static async open(filePath) {
-    await mkdir5(path11.dirname(filePath), { recursive: true });
+    await mkdir5(path15.dirname(filePath), { recursive: true });
     const stream = createWriteStream3(filePath, { flags: "w", encoding: "utf8" });
     return new _YamlWriter(stream);
   }
@@ -15808,12 +15923,12 @@ var ProgressDisplay = class {
   }
   addLogPaths(paths) {
     const newPaths = [];
-    for (const path19 of paths) {
-      if (this.logPathSet.has(path19)) {
+    for (const path25 of paths) {
+      if (this.logPathSet.has(path25)) {
         continue;
       }
-      this.logPathSet.add(path19);
-      newPaths.push(path19);
+      this.logPathSet.add(path25);
+      newPaths.push(path25);
     }
     if (newPaths.length === 0) {
       return;
@@ -15829,8 +15944,8 @@ var ProgressDisplay = class {
       this.hasPrintedLogHeader = true;
     }
     const startIndex = this.logPaths.length - newPaths.length;
-    newPaths.forEach((path19, offset) => {
-      console.log(`${startIndex + offset + 1}. ${path19}`);
+    newPaths.forEach((path25, offset) => {
+      console.log(`${startIndex + offset + 1}. ${path25}`);
     });
   }
   scheduleRender() {
@@ -15878,8 +15993,8 @@ var ProgressDisplay = class {
     if (this.logPaths.length > 0) {
       lines.push("");
       lines.push("Codex CLI logs:");
-      this.logPaths.forEach((path19, index) => {
-        lines.push(`${index + 1}. ${path19}`);
+      this.logPaths.forEach((path25, index) => {
+        lines.push(`${index + 1}. ${path25}`);
       });
     }
     const rowCount = this.getRenderedRowCount(lines);
@@ -16084,17 +16199,17 @@ function formatEvaluationSummary(summary) {
 }
 
 // ../../packages/core/dist/evaluation/validation/index.js
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import { parse as parse4 } from "yaml";
 import { readFile as readFile23 } from "node:fs/promises";
-import path12 from "node:path";
+import path16 from "node:path";
 import { parse as parse23 } from "yaml";
-import { readFile as readFile32 } from "node:fs/promises";
+import { readFile as readFile33 } from "node:fs/promises";
 import path23 from "node:path";
-import { parse as parse32 } from "yaml";
+import { parse as parse33 } from "yaml";
 import { readFile as readFile42 } from "node:fs/promises";
 import { parse as parse42 } from "yaml";
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile52 } from "node:fs/promises";
 import path33 from "node:path";
 import { parse as parse5 } from "yaml";
 var SCHEMA_EVAL_V22 = "agentv-eval-v2";
@@ -16102,7 +16217,7 @@ var SCHEMA_TARGETS_V2 = "agentv-targets-v2.2";
 var SCHEMA_CONFIG_V22 = "agentv-config-v2";
 async function detectFileType(filePath) {
   try {
-    const content = await readFile4(filePath, "utf8");
+    const content = await readFile6(filePath, "utf8");
     const parsed = parse4(content);
     if (typeof parsed !== "object" || parsed === null) {
       return "unknown";
@@ -16132,7 +16247,7 @@ function isObject(value) {
 }
 async function validateEvalFile(filePath) {
   const errors = [];
-  const absolutePath = path12.resolve(filePath);
+  const absolutePath = path16.resolve(filePath);
   let parsed;
   try {
     const content = await readFile23(absolutePath, "utf8");
@@ -16497,8 +16612,8 @@ async function validateTargetsFile(filePath) {
   const absolutePath = path23.resolve(filePath);
   let parsed;
   try {
-    const content = await readFile32(absolutePath, "utf8");
-    parsed = parse32(content);
+    const content = await readFile33(absolutePath, "utf8");
+    parsed = parse33(content);
   } catch (error) {
     errors.push({
       severity: "error",
@@ -16849,7 +16964,7 @@ async function validateFileReferences(evalFilePath) {
   const searchRoots = buildSearchRoots(absolutePath, gitRoot);
   let parsed;
   try {
-    const content = await readFile5(absolutePath, "utf8");
+    const content = await readFile52(absolutePath, "utf8");
     parsed = parse5(content);
   } catch {
     return errors;
@@ -16919,7 +17034,7 @@ async function validateMessagesFileRefs(messages, location, searchRoots, filePat
         });
       } else {
         try {
-          const fileContent = await readFile5(resolvedPath, "utf8");
+          const fileContent = await readFile52(resolvedPath, "utf8");
           if (fileContent.trim().length === 0) {
             errors.push({
               severity: "warning",
@@ -16944,16 +17059,16 @@ async function validateMessagesFileRefs(messages, location, searchRoots, filePat
 // src/commands/eval/targets.ts
 import { constants as constants5 } from "node:fs";
 import { access as access5 } from "node:fs/promises";
-import path13 from "node:path";
+import path17 from "node:path";
 var TARGET_FILE_CANDIDATES = [
   "targets.yaml",
   "targets.yml",
-  path13.join(".agentv", "targets.yaml"),
-  path13.join(".agentv", "targets.yml")
+  path17.join(".agentv", "targets.yaml"),
+  path17.join(".agentv", "targets.yml")
 ];
-var ANSI_YELLOW2 = "\x1B[33m";
+var ANSI_YELLOW6 = "\x1B[33m";
 var ANSI_RED = "\x1B[31m";
-var ANSI_RESET2 = "\x1B[0m";
+var ANSI_RESET6 = "\x1B[0m";
 function isTTY() {
   return process.stdout.isTTY ?? false;
 }
@@ -16972,12 +17087,12 @@ async function readTestSuiteTarget(testFilePath) {
 async function discoverTargetsFile(options) {
   const { explicitPath, testFilePath, repoRoot, cwd } = options;
   if (explicitPath) {
-    const resolvedExplicit = path13.resolve(explicitPath);
+    const resolvedExplicit = path17.resolve(explicitPath);
     if (await fileExists5(resolvedExplicit)) {
       return resolvedExplicit;
     }
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const nested = path13.join(resolvedExplicit, candidate);
+      const nested = path17.join(resolvedExplicit, candidate);
       if (await fileExists5(nested)) {
         return nested;
       }
@@ -16985,13 +17100,13 @@ async function discoverTargetsFile(options) {
     throw new Error(`targets.yaml not found at provided path: ${resolvedExplicit}`);
   }
   const directories = [...buildDirectoryChain(testFilePath, repoRoot)];
-  const resolvedCwd = path13.resolve(cwd);
+  const resolvedCwd = path17.resolve(cwd);
   if (!directories.includes(resolvedCwd)) {
     directories.push(resolvedCwd);
   }
   for (const directory of directories) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const fullPath = path13.join(directory, candidate);
+      const fullPath = path17.join(directory, candidate);
       if (await fileExists5(fullPath)) {
         return fullPath;
       }
@@ -17026,8 +17141,8 @@ async function selectTarget(options) {
 Warnings in ${targetsFilePath}:`);
     for (const warning of warnings) {
       const location = warning.location ? ` [${warning.location}]` : "";
-      const prefix = useColors ? `${ANSI_YELLOW2}  \u26A0${ANSI_RESET2}` : "  \u26A0";
-      const message = useColors ? `${ANSI_YELLOW2}${warning.message}${ANSI_RESET2}` : warning.message;
+      const prefix = useColors ? `${ANSI_YELLOW6}  \u26A0${ANSI_RESET6}` : "  \u26A0";
+      const message = useColors ? `${ANSI_YELLOW6}${warning.message}${ANSI_RESET6}` : warning.message;
       console.warn(`${prefix}${location} ${message}`);
     }
     console.warn("");
@@ -17038,8 +17153,8 @@ Warnings in ${targetsFilePath}:`);
 Errors in ${targetsFilePath}:`);
     for (const error of errors) {
       const location = error.location ? ` [${error.location}]` : "";
-      const prefix = useColors ? `${ANSI_RED}  \u2717${ANSI_RESET2}` : "  \u2717";
-      const message = useColors ? `${ANSI_RED}${error.message}${ANSI_RESET2}` : error.message;
+      const prefix = useColors ? `${ANSI_RED}  \u2717${ANSI_RESET6}` : "  \u2717";
+      const message = useColors ? `${ANSI_RED}${error.message}${ANSI_RESET6}` : error.message;
       console.error(`${prefix}${location} ${message}`);
     }
     throw new Error(`Targets file validation failed with ${errors.length} error(s)`);
@@ -17143,15 +17258,15 @@ async function ensureFileExists(filePath, description) {
   }
 }
 async function findRepoRoot(start) {
-  const fallback = path14.resolve(start);
+  const fallback = path18.resolve(start);
   let current = fallback;
   while (current !== void 0) {
-    const candidate = path14.join(current, ".git");
+    const candidate = path18.join(current, ".git");
     try {
       await access6(candidate, constants6.F_OK);
       return current;
     } catch {
-      const parent = path14.dirname(current);
+      const parent = path18.dirname(current);
       if (parent === current) {
         break;
       }
@@ -17164,16 +17279,16 @@ function buildDefaultOutputPath(cwd, format) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const baseName = "eval";
   const extension = getDefaultExtension(format);
-  return path14.join(cwd, ".agentv", "results", `${baseName}_${timestamp}${extension}`);
+  return path18.join(cwd, ".agentv", "results", `${baseName}_${timestamp}${extension}`);
 }
 function resolvePromptDirectory(option, cwd) {
   if (option === void 0) {
     return void 0;
   }
   if (typeof option === "string" && option.trim().length > 0) {
-    return path14.resolve(cwd, option);
+    return path18.resolve(cwd, option);
   }
-  return path14.join(cwd, ".agentv", "prompts");
+  return path18.join(cwd, ".agentv", "prompts");
 }
 function createEvaluationCache() {
   const store = /* @__PURE__ */ new Map();
@@ -17198,7 +17313,7 @@ function createProgressReporter(maxWorkers) {
   };
 }
 function makeEvalKey(testFilePath, evalId) {
-  return `${path14.resolve(testFilePath)}::${evalId}`;
+  return `${path18.resolve(testFilePath)}::${evalId}`;
 }
 function createDisplayIdTracker() {
   const map = /* @__PURE__ */ new Map();
@@ -17351,7 +17466,7 @@ async function runEvalCommand(input) {
   if (options.verbose) {
     console.log(`Repository root: ${repoRoot}`);
   }
-  const outputPath = options.outPath ? path14.resolve(options.outPath) : buildDefaultOutputPath(cwd, options.format);
+  const outputPath = options.outPath ? path18.resolve(options.outPath) : buildDefaultOutputPath(cwd, options.format);
   console.log(`Output path: ${outputPath}`);
   const outputWriter = await createOutputWriter(outputPath, options.format);
   const cache = options.cache ? createEvaluationCache() : void 0;
@@ -17359,7 +17474,7 @@ async function runEvalCommand(input) {
   const allResults = [];
   let lastPromptDumpDir;
   const seenEvalCases = /* @__PURE__ */ new Set();
-  const resolvedTestFiles = input.testFiles.map((file) => path14.resolve(file));
+  const resolvedTestFiles = input.testFiles.map((file) => path18.resolve(file));
   const displayIdTracker = createDisplayIdTracker();
   const totalWorkers = options.workers ?? DEFAULT_WORKERS;
   const fileConcurrency = Math.min(Math.max(1, totalWorkers), Math.max(1, resolvedTestFiles.length));
@@ -17451,7 +17566,7 @@ async function resolveEvaluationRunner() {
   if (!overridePath) {
     return runEvaluation;
   }
-  const resolved = path14.isAbsolute(overridePath) ? overridePath : path14.resolve(process.cwd(), overridePath);
+  const resolved = path18.isAbsolute(overridePath) ? overridePath : path18.resolve(process.cwd(), overridePath);
   const moduleUrl = pathToFileURL(resolved).href;
   const mod = await import(moduleUrl);
   const candidate = mod.runEvaluation;
@@ -17522,7 +17637,7 @@ async function resolveEvalPaths(evalPaths, cwd) {
   const unmatched = [];
   const results = /* @__PURE__ */ new Set();
   for (const pattern of normalizedInputs) {
-    const candidatePath = path15.isAbsolute(pattern) ? path15.normalize(pattern) : path15.resolve(cwd, pattern);
+    const candidatePath = path19.isAbsolute(pattern) ? path19.normalize(pattern) : path19.resolve(cwd, pattern);
     try {
       const stats = await stat3(candidatePath);
       if (stats.isFile() && /\.ya?ml$/i.test(candidatePath)) {
@@ -17545,7 +17660,7 @@ async function resolveEvalPaths(evalPaths, cwd) {
       unmatched.push(pattern);
       continue;
     }
-    yamlMatches.forEach((filePath) => results.add(path15.normalize(filePath)));
+    yamlMatches.forEach((filePath) => results.add(path19.normalize(filePath)));
   }
   if (unmatched.length > 0) {
     throw new Error(
@@ -17561,27 +17676,30 @@ async function resolveEvalPaths(evalPaths, cwd) {
 
 // src/commands/init/index.ts
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import path17 from "node:path";
+import path21 from "node:path";
 import * as readline from "node:readline/promises";
 
 // src/templates/index.ts
 import { readFileSync, readdirSync, statSync } from "node:fs";
-import path16 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import path20 from "node:path";
+import { fileURLToPath } from "node:url";
 var TemplateManager = class {
   static getGithubTemplates() {
-    return this.getTemplatesFromDir("github");
+    return this.getTemplatesFromDir(".github");
   }
   static getAgentvTemplates() {
-    return this.getTemplatesFromDir("agentv");
+    return this.getTemplatesFromDir(".agentv");
+  }
+  static getClaudeTemplates() {
+    return this.getTemplatesFromDir(".claude");
   }
   static getTemplatesFromDir(subdir) {
-    const currentDir = path16.dirname(fileURLToPath2(import.meta.url));
+    const currentDir = path20.dirname(fileURLToPath(import.meta.url));
     let templatesDir;
-    if (currentDir.includes(path16.sep + "dist")) {
-      templatesDir = path16.join(currentDir, "templates", subdir);
+    if (currentDir.includes(path20.sep + "dist")) {
+      templatesDir = path20.join(currentDir, "templates", subdir);
     } else {
-      templatesDir = path16.join(currentDir, subdir);
+      templatesDir = path20.join(currentDir, subdir);
     }
     return this.readTemplatesRecursively(templatesDir, "");
   }
@@ -17589,15 +17707,15 @@ var TemplateManager = class {
     const templates = [];
     const entries = readdirSync(dir);
     for (const entry of entries) {
-      const fullPath = path16.join(dir, entry);
+      const fullPath = path20.join(dir, entry);
       const stat5 = statSync(fullPath);
-      const entryRelativePath = relativePath ? path16.join(relativePath, entry) : entry;
+      const entryRelativePath = relativePath ? path20.join(relativePath, entry) : entry;
       if (stat5.isDirectory()) {
         templates.push(...this.readTemplatesRecursively(fullPath, entryRelativePath));
       } else {
         const content = readFileSync(fullPath, "utf-8");
         templates.push({
-          path: entryRelativePath.split(path16.sep).join("/"),
+          path: entryRelativePath.split(path20.sep).join("/"),
           // Normalize to forward slashes
           content
         });
@@ -17621,25 +17739,35 @@ async function promptYesNo(message) {
   }
 }
 async function initCommand(options = {}) {
-  const targetPath = path17.resolve(options.targetPath ?? ".");
-  const githubDir = path17.join(targetPath, ".github");
-  const agentvDir = path17.join(targetPath, ".agentv");
+  const targetPath = path21.resolve(options.targetPath ?? ".");
+  const githubDir = path21.join(targetPath, ".github");
+  const agentvDir = path21.join(targetPath, ".agentv");
+  const claudeDir = path21.join(targetPath, ".claude");
   const githubTemplates = TemplateManager.getGithubTemplates();
   const agentvTemplates = TemplateManager.getAgentvTemplates();
+  const claudeTemplates = TemplateManager.getClaudeTemplates();
   const existingFiles = [];
   if (existsSync(githubDir)) {
     for (const template of githubTemplates) {
-      const targetFilePath = path17.join(githubDir, template.path);
+      const targetFilePath = path21.join(githubDir, template.path);
       if (existsSync(targetFilePath)) {
-        existingFiles.push(path17.relative(targetPath, targetFilePath));
+        existingFiles.push(path21.relative(targetPath, targetFilePath));
       }
     }
   }
   if (existsSync(agentvDir)) {
     for (const template of agentvTemplates) {
-      const targetFilePath = path17.join(agentvDir, template.path);
+      const targetFilePath = path21.join(agentvDir, template.path);
+      if (existsSync(targetFilePath)) {
+        existingFiles.push(path21.relative(targetPath, targetFilePath));
+      }
+    }
+  }
+  if (existsSync(claudeDir)) {
+    for (const template of claudeTemplates) {
+      const targetFilePath = path21.join(claudeDir, template.path);
       if (existsSync(targetFilePath)) {
-        existingFiles.push(path17.relative(targetPath, targetFilePath));
+        existingFiles.push(path21.relative(targetPath, targetFilePath));
       }
     }
   }
@@ -17660,31 +17788,46 @@ async function initCommand(options = {}) {
   if (!existsSync(agentvDir)) {
     mkdirSync(agentvDir, { recursive: true });
   }
+  if (!existsSync(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true });
+  }
   for (const template of githubTemplates) {
-    const targetFilePath = path17.join(githubDir, template.path);
-    const targetDirPath = path17.dirname(targetFilePath);
+    const targetFilePath = path21.join(githubDir, template.path);
+    const targetDirPath = path21.dirname(targetFilePath);
     if (!existsSync(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path17.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path21.relative(targetPath, targetFilePath)}`);
   }
   for (const template of agentvTemplates) {
-    const targetFilePath = path17.join(agentvDir, template.path);
-    const targetDirPath = path17.dirname(targetFilePath);
+    const targetFilePath = path21.join(agentvDir, template.path);
+    const targetDirPath = path21.dirname(targetFilePath);
+    if (!existsSync(targetDirPath)) {
+      mkdirSync(targetDirPath, { recursive: true });
+    }
+    writeFileSync(targetFilePath, template.content, "utf-8");
+    console.log(`Created ${path21.relative(targetPath, targetFilePath)}`);
+  }
+  for (const template of claudeTemplates) {
+    const targetFilePath = path21.join(claudeDir, template.path);
+    const targetDirPath = path21.dirname(targetFilePath);
     if (!existsSync(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path17.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path21.relative(targetPath, targetFilePath)}`);
   }
   console.log("\nAgentV initialized successfully!");
   console.log(`
-Files installed to ${path17.relative(targetPath, githubDir)}:`);
+Files installed to ${path21.relative(targetPath, githubDir)}:`);
   githubTemplates.forEach((t) => console.log(`  - ${t.path}`));
   console.log(`
-Files installed to ${path17.relative(targetPath, agentvDir)}:`);
+Files installed to ${path21.relative(targetPath, agentvDir)}:`);
   agentvTemplates.forEach((t) => console.log(`  - ${t.path}`));
+  console.log(`
+Files installed to ${path21.relative(targetPath, claudeDir)}:`);
+  claudeTemplates.forEach((t) => console.log(`  - ${t.path}`));
   console.log("\nYou can now:");
   console.log("  1. Edit .agentv/.env with your API credentials");
   console.log("  2. Configure targets in .agentv/targets.yaml");
@@ -17702,11 +17845,11 @@ function registerStatusCommand(program) {
 
 // src/commands/validate/format-output.ts
 var ANSI_RED2 = "\x1B[31m";
-var ANSI_YELLOW3 = "\x1B[33m";
+var ANSI_YELLOW7 = "\x1B[33m";
 var ANSI_GREEN = "\x1B[32m";
 var ANSI_CYAN = "\x1B[36m";
 var ANSI_BOLD = "\x1B[1m";
-var ANSI_RESET3 = "\x1B[0m";
+var ANSI_RESET7 = "\x1B[0m";
 function formatSummary(summary, useColors) {
   const lines = [];
   lines.push("");
@@ -17722,7 +17865,7 @@ function formatSummary(summary, useColors) {
 }
 function formatHeader(text, useColors) {
   if (useColors) {
-    return `${ANSI_BOLD}${ANSI_CYAN}${text}${ANSI_RESET3}`;
+    return `${ANSI_BOLD}${ANSI_CYAN}${text}${ANSI_RESET7}`;
   }
   return text;
 }
@@ -17730,7 +17873,7 @@ function formatFileResult(result, useColors) {
   const lines = [];
   const status = result.valid ? "\u2713" : "\u2717";
   const statusColor = result.valid ? ANSI_GREEN : ANSI_RED2;
-  const statusText = useColors ? `${statusColor}${status}${ANSI_RESET3}` : status;
+  const statusText = useColors ? `${statusColor}${status}${ANSI_RESET7}` : status;
   const fileName = result.filePath;
   lines.push(`${statusText} ${fileName}`);
   if (result.errors.length > 0) {
@@ -17742,8 +17885,8 @@ function formatFileResult(result, useColors) {
 }
 function formatError(error, useColors) {
   const prefix = error.severity === "error" ? "  \u2717" : "  \u26A0";
-  const color = error.severity === "error" ? ANSI_RED2 : ANSI_YELLOW3;
-  const coloredPrefix = useColors ? `${color}${prefix}${ANSI_RESET3}` : prefix;
+  const color = error.severity === "error" ? ANSI_RED2 : ANSI_YELLOW7;
+  const coloredPrefix = useColors ? `${color}${prefix}${ANSI_RESET7}` : prefix;
   const location = error.location ? ` [${error.location}]` : "";
   return `${coloredPrefix}${location} ${error.message}`;
 }
@@ -17756,15 +17899,15 @@ function formatStats(summary, useColors) {
     (r) => r.errors.some((e) => e.severity === "warning")
   ).length;
   if (useColors) {
-    lines.push(`${ANSI_BOLD}${totalText}${ANSI_RESET3}`);
-    lines.push(`${ANSI_GREEN}${validText}${ANSI_RESET3}`);
+    lines.push(`${ANSI_BOLD}${totalText}${ANSI_RESET7}`);
+    lines.push(`${ANSI_GREEN}${validText}${ANSI_RESET7}`);
     if (summary.invalidFiles > 0) {
-      lines.push(`${ANSI_RED2}${invalidText}${ANSI_RESET3}`);
+      lines.push(`${ANSI_RED2}${invalidText}${ANSI_RESET7}`);
     } else {
       lines.push(invalidText);
     }
     if (filesWithWarnings > 0) {
-      lines.push(`${ANSI_YELLOW3}Files with warnings: ${filesWithWarnings}${ANSI_RESET3}`);
+      lines.push(`${ANSI_YELLOW7}Files with warnings: ${filesWithWarnings}${ANSI_RESET7}`);
     }
   } else {
     lines.push(totalText);
@@ -17783,7 +17926,7 @@ function isTTY2() {
 // src/commands/validate/validate-files.ts
 import { constants as constants7 } from "node:fs";
 import { access as access7, readdir as readdir3, stat as stat4 } from "node:fs/promises";
-import path18 from "node:path";
+import path24 from "node:path";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
   const results = [];
@@ -17801,7 +17944,7 @@ async function validateFiles(paths) {
   };
 }
 async function validateSingleFile(filePath) {
-  const absolutePath = path18.resolve(filePath);
+  const absolutePath = path24.resolve(filePath);
   const fileType = await detectFileType(absolutePath);
   if (fileType === "unknown") {
     return {
@@ -17840,7 +17983,7 @@ async function validateSingleFile(filePath) {
 async function expandPaths(paths) {
   const expanded = [];
   for (const inputPath of paths) {
-    const absolutePath = path18.resolve(inputPath);
+    const absolutePath = path24.resolve(inputPath);
     try {
       await access7(absolutePath, constants7.F_OK);
     } catch {
@@ -17864,7 +18007,7 @@ async function findYamlFiles(dirPath) {
   try {
     const entries = await readdir3(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path18.join(dirPath, entry.name);
+      const fullPath = path24.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -17881,7 +18024,7 @@ async function findYamlFiles(dirPath) {
   return results;
 }
 function isYamlFile(filePath) {
-  const ext = path18.extname(filePath).toLowerCase();
+  const ext = path24.extname(filePath).toLowerCase();
   return ext === ".yaml" || ext === ".yml";
 }
 
@@ -17938,4 +18081,4 @@ export {
   createProgram,
   runCli
 };
-//# sourceMappingURL=chunk-72BHGHIT.js.map
+//# sourceMappingURL=chunk-WMO5PVPX.js.map