agentv 2.19.0 → 3.1.0

package/dist/chunk-4MSAOMCC.js

@@ -1,3338 +0,0 @@
-import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
-import {
-  CLI_PLACEHOLDERS,
-  KNOWN_PROVIDERS,
-  PROVIDER_ALIASES,
-  ResponseCache,
-  buildDirectoryChain,
-  buildSearchRoots,
-  ensureVSCodeSubagents,
-  findGitRoot,
-  isEvaluatorKind,
-  listTargetNames,
-  loadConfig,
-  loadTestSuite,
-  loadTsConfig,
-  normalizeLineEndings,
-  readTargetDefinitions,
-  readTestSuiteMetadata,
-  resolveFileReference,
-  resolveTargetDefinition,
-  runEvaluation,
-  shouldEnableCache,
-  shouldSkipCacheForTemperature,
-  subscribeToCodexLogEntries,
-  subscribeToCopilotCliLogEntries,
-  subscribeToCopilotSdkLogEntries,
-  subscribeToPiLogEntries
-} from "./chunk-XTYMR4I5.js";
-
-// package.json
-var package_default = {
-  name: "agentv",
-  version: "2.19.0",
-  description: "CLI entry point for AgentV",
-  type: "module",
-  repository: {
-    type: "git",
-    url: "https://github.com/EntityProcess/agentv.git"
-  },
-  homepage: "https://github.com/EntityProcess/agentv#readme",
-  bugs: {
-    url: "https://github.com/EntityProcess/agentv/issues"
-  },
-  bin: {
-    agentv: "./dist/cli.js"
-  },
-  files: ["dist", "README.md"],
-  scripts: {
-    dev: "bun src/cli.ts",
-    build: "tsup && bun run copy-readme",
-    "copy-readme": `bun -e "import { cpSync } from 'fs'; cpSync('../../README.md', 'README.md')"`,
-    prepublishOnly: "bun run copy-readme",
-    typecheck: "tsc --noEmit",
-    lint: "biome check .",
-    format: "biome format --write .",
-    fix: "biome check --write .",
-    test: "bun test",
-    "test:watch": "bun test --watch"
-  },
-  dependencies: {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.49",
-    "@github/copilot-sdk": "^0.1.25",
-    "@inquirer/prompts": "^8.2.1",
-    "@mariozechner/pi-agent-core": "^0.54.2",
-    "@mariozechner/pi-ai": "^0.54.2",
-    "@openai/codex-sdk": "^0.104.0",
-    "cmd-ts": "^0.14.3",
-    dotenv: "^16.4.5",
-    "fast-glob": "^3.3.3",
-    json5: "^2.2.3",
-    micromatch: "^4.0.8",
-    semver: "^7.7.4",
-    yaml: "^2.6.1"
-  },
-  devDependencies: {
-    "@agentv/core": "workspace:*",
-    "@types/semver": "^7.7.1",
-    execa: "^9.3.0"
-  }
-};
-
-// src/commands/eval/shared.ts
-import { constants } from "node:fs";
-import { access, stat } from "node:fs/promises";
-import path from "node:path";
-import fg from "fast-glob";
-async function resolveEvalPaths(evalPaths, cwd) {
-  const normalizedInputs = evalPaths.map((value) => value?.trim()).filter((value) => value);
-  if (normalizedInputs.length === 0) {
-    throw new Error("No eval paths provided.");
-  }
-  const unmatched = [];
-  const results = /* @__PURE__ */ new Set();
-  for (const pattern of normalizedInputs) {
-    const candidatePath = path.isAbsolute(pattern) ? path.normalize(pattern) : path.resolve(cwd, pattern);
-    try {
-      const stats = await stat(candidatePath);
-      if (stats.isFile() && /\.(ya?ml|jsonl)$/i.test(candidatePath)) {
-        results.add(candidatePath);
-        continue;
-      }
-    } catch {
-    }
-    const globPattern = pattern.includes("\\") ? pattern.replace(/\\/g, "/") : pattern;
-    const matches = await fg(globPattern, {
-      cwd,
-      absolute: true,
-      onlyFiles: true,
-      unique: true,
-      dot: true,
-      followSymbolicLinks: true
-    });
-    const yamlMatches = matches.filter((filePath) => /\.(ya?ml|jsonl)$/i.test(filePath));
-    if (yamlMatches.length === 0) {
-      unmatched.push(pattern);
-      continue;
-    }
-    for (const filePath of yamlMatches) {
-      results.add(path.normalize(filePath));
-    }
-  }
-  if (unmatched.length > 0) {
-    throw new Error(
-      `No eval files matched: ${unmatched.join(
-        ", "
-      )}. Provide YAML or JSONL paths or globs (e.g., "evals/**/*.yaml", "evals/**/*.jsonl").`
-    );
-  }
-  const sorted = Array.from(results);
-  sorted.sort();
-  return sorted;
-}
-async function findRepoRoot(start) {
-  const fallback = path.resolve(start);
-  let current = fallback;
-  while (current !== void 0) {
-    const candidate = path.join(current, ".git");
-    try {
-      await access(candidate, constants.F_OK);
-      return current;
-    } catch {
-      const parent = path.dirname(current);
-      if (parent === current) {
-        break;
-      }
-      current = parent;
-    }
-  }
-  return fallback;
-}
-
-// src/utils/targets.ts
-import { constants as constants2 } from "node:fs";
-import { access as access2 } from "node:fs/promises";
-import path2 from "node:path";
-var TARGET_FILE_CANDIDATES = [
-  "targets.yaml",
-  "targets.yml",
-  path2.join(".agentv", "targets.yaml"),
-  path2.join(".agentv", "targets.yml")
-];
-async function fileExists(filePath) {
-  try {
-    await access2(filePath, constants2.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function discoverTargetsFile(options) {
-  const { explicitPath, testFilePath, repoRoot, cwd } = options;
-  if (explicitPath) {
-    const resolvedExplicit = path2.resolve(explicitPath);
-    if (await fileExists(resolvedExplicit)) {
-      return resolvedExplicit;
-    }
-    for (const candidate of TARGET_FILE_CANDIDATES) {
-      const nested = path2.join(resolvedExplicit, candidate);
-      if (await fileExists(nested)) {
-        return nested;
-      }
-    }
-    throw new Error(`targets.yaml not found at provided path: ${resolvedExplicit}`);
-  }
-  const directories = [...buildDirectoryChain(testFilePath, repoRoot)];
-  const resolvedCwd = path2.resolve(cwd);
-  if (!directories.includes(resolvedCwd)) {
-    directories.push(resolvedCwd);
-  }
-  for (const directory of directories) {
-    for (const candidate of TARGET_FILE_CANDIDATES) {
-      const fullPath = path2.join(directory, candidate);
-      if (await fileExists(fullPath)) {
-        return fullPath;
-      }
-    }
-  }
-  throw new Error("Unable to locate targets.yaml. Use --targets to specify the file explicitly.");
-}
-
-// src/commands/eval/run-eval.ts
-import { constants as constants4 } from "node:fs";
-import { access as access4 } from "node:fs/promises";
-import path10 from "node:path";
-import { pathToFileURL } from "node:url";
-
-// src/version-check.ts
-import { satisfies, validRange } from "semver";
-var ANSI_YELLOW = "\x1B[33m";
-var ANSI_RED = "\x1B[31m";
-var ANSI_RESET = "\x1B[0m";
-function checkVersion(requiredVersion) {
-  const currentVersion = package_default.version;
-  if (!requiredVersion.trim() || !validRange(requiredVersion)) {
-    throw new Error(
-      `Invalid required_version "${requiredVersion}" in .agentv/config.yaml. Must be a valid semver range (e.g., ">=2.11.0", "^2.11.0").`
-    );
-  }
-  return {
-    satisfied: satisfies(currentVersion, requiredVersion),
-    currentVersion,
-    requiredRange: requiredVersion
-  };
-}
-async function enforceRequiredVersion(requiredVersion, options) {
-  let result;
-  try {
-    result = checkVersion(requiredVersion);
-  } catch (err) {
-    console.error(`${ANSI_RED}Error: ${err.message}${ANSI_RESET}`);
-    process.exit(1);
-  }
-  if (result.satisfied) {
-    return;
-  }
-  const warning = `${ANSI_YELLOW}Warning: This project requires agentv ${result.requiredRange} but you have ${result.currentVersion}.${ANSI_RESET}
-  Run \`agentv self update\` to upgrade.`;
-  if (options?.strict) {
-    console.error(warning);
-    console.error(
-      `${ANSI_RED}Aborting: --strict mode requires the installed version to satisfy the required range.${ANSI_RESET}`
-    );
-    process.exit(1);
-  }
-  if (process.stdin.isTTY && process.stdout.isTTY) {
-    console.warn(warning);
-    const shouldContinue = await promptContinue();
-    if (!shouldContinue) {
-      process.exit(1);
-    }
-  } else {
-    process.stderr.write(`${warning}
-`);
-  }
-}
-async function promptContinue() {
-  const { confirm } = await import("@inquirer/prompts");
-  return confirm({ message: "Continue anyway?", default: false });
-}
-
-// src/commands/eval/env.ts
-import { constants as constants3 } from "node:fs";
-import { access as access3 } from "node:fs/promises";
-import path3 from "node:path";
-import { config as loadDotenv } from "dotenv";
-function uniqueDirs(directories) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const dir of directories) {
-    const absolute = path3.resolve(dir);
-    if (seen.has(absolute)) {
-      continue;
-    }
-    seen.add(absolute);
-    result.push(absolute);
-  }
-  return result;
-}
-async function fileExists2(filePath) {
-  try {
-    await access3(filePath, constants3.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function collectAncestorDirectories(start, boundary) {
-  const directories = [];
-  const boundaryDir = path3.resolve(boundary);
-  let current = path3.resolve(start);
-  while (current !== void 0) {
-    directories.push(current);
-    if (current === boundaryDir) {
-      break;
-    }
-    const parent = path3.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-  return directories;
-}
-async function loadEnvFromHierarchy(options) {
-  const { testFilePath, repoRoot, verbose } = options;
-  const testDir = path3.dirname(path3.resolve(testFilePath));
-  const cwd = process.cwd();
-  const searchDirs = uniqueDirs([...collectAncestorDirectories(testDir, repoRoot), repoRoot, cwd]);
-  const envFiles = [];
-  for (const dir of searchDirs) {
-    const candidate = path3.join(dir, ".env");
-    if (await fileExists2(candidate)) {
-      envFiles.push(candidate);
-    }
-  }
-  if (envFiles.length === 0) {
-    if (verbose) {
-      console.log("No .env file found in hierarchy");
-    }
-    return void 0;
-  }
-  for (let i = envFiles.length - 1; i >= 0; i--) {
-    const envFile = envFiles[i];
-    loadDotenv({ path: envFile, override: false });
-    if (verbose) {
-      console.log(`Loaded environment from: ${envFile}`);
-    }
-  }
-  return envFiles[0];
-}
-
-// src/commands/eval/output-writer.ts
-import path8 from "node:path";
-
-// src/commands/eval/json-writer.ts
-import { mkdir, writeFile } from "node:fs/promises";
-import path4 from "node:path";
-
-// src/utils/case-conversion.ts
-function toSnakeCase(str) {
-  if (/^[A-Z]/.test(str)) {
-    return str;
-  }
-  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-function toSnakeCaseDeep(obj) {
-  if (obj === null || obj === void 0) {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => toSnakeCaseDeep(item));
-  }
-  if (typeof obj === "object") {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      const snakeKey = toSnakeCase(key);
-      result[snakeKey] = toSnakeCaseDeep(value);
-    }
-    return result;
-  }
-  return obj;
-}
-
-// src/commands/eval/json-writer.ts
-var JsonWriter = class _JsonWriter {
-  filePath;
-  results = [];
-  closed = false;
-  constructor(filePath) {
-    this.filePath = filePath;
-  }
-  static async open(filePath) {
-    await mkdir(path4.dirname(filePath), { recursive: true });
-    return new _JsonWriter(filePath);
-  }
-  async append(result) {
-    if (this.closed) {
-      throw new Error("Cannot write to closed JSON writer");
-    }
-    this.results.push(result);
-  }
-  async close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    const passed = this.results.filter((r) => r.score >= 0.5).length;
-    const failed = this.results.length - passed;
-    const total = this.results.length;
-    const output = {
-      stats: {
-        total,
-        passed,
-        failed,
-        passRate: total > 0 ? passed / total : 0
-      },
-      results: this.results
-    };
-    const snakeCaseOutput = toSnakeCaseDeep(output);
-    await writeFile(this.filePath, `${JSON.stringify(snakeCaseOutput, null, 2)}
-`, "utf8");
-  }
-};
-
-// src/commands/eval/jsonl-writer.ts
-import { createWriteStream } from "node:fs";
-import { mkdir as mkdir2 } from "node:fs/promises";
-import path5 from "node:path";
-import { finished } from "node:stream/promises";
-
-// ../../node_modules/.bun/async-mutex@0.5.0/node_modules/async-mutex/index.mjs
-var E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
-var E_ALREADY_LOCKED = new Error("mutex already locked");
-var E_CANCELED = new Error("request for lock canceled");
-var __awaiter$2 = function(thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve) {
-      resolve(value);
-    });
-  }
-  return new (P || (P = Promise))(function(resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-var Semaphore = class {
-  constructor(_value, _cancelError = E_CANCELED) {
-    this._value = _value;
-    this._cancelError = _cancelError;
-    this._queue = [];
-    this._weightedWaiters = [];
-  }
-  acquire(weight = 1, priority = 0) {
-    if (weight <= 0)
-      throw new Error(`invalid weight ${weight}: must be positive`);
-    return new Promise((resolve, reject) => {
-      const task = { resolve, reject, weight, priority };
-      const i = findIndexFromEnd(this._queue, (other) => priority <= other.priority);
-      if (i === -1 && weight <= this._value) {
-        this._dispatchItem(task);
-      } else {
-        this._queue.splice(i + 1, 0, task);
-      }
-    });
-  }
-  runExclusive(callback_1) {
-    return __awaiter$2(this, arguments, void 0, function* (callback, weight = 1, priority = 0) {
-      const [value, release] = yield this.acquire(weight, priority);
-      try {
-        return yield callback(value);
-      } finally {
-        release();
-      }
-    });
-  }
-  waitForUnlock(weight = 1, priority = 0) {
-    if (weight <= 0)
-      throw new Error(`invalid weight ${weight}: must be positive`);
-    if (this._couldLockImmediately(weight, priority)) {
-      return Promise.resolve();
-    } else {
-      return new Promise((resolve) => {
-        if (!this._weightedWaiters[weight - 1])
-          this._weightedWaiters[weight - 1] = [];
-        insertSorted(this._weightedWaiters[weight - 1], { resolve, priority });
-      });
-    }
-  }
-  isLocked() {
-    return this._value <= 0;
-  }
-  getValue() {
-    return this._value;
-  }
-  setValue(value) {
-    this._value = value;
-    this._dispatchQueue();
-  }
-  release(weight = 1) {
-    if (weight <= 0)
-      throw new Error(`invalid weight ${weight}: must be positive`);
-    this._value += weight;
-    this._dispatchQueue();
-  }
-  cancel() {
-    this._queue.forEach((entry) => entry.reject(this._cancelError));
-    this._queue = [];
-  }
-  _dispatchQueue() {
-    this._drainUnlockWaiters();
-    while (this._queue.length > 0 && this._queue[0].weight <= this._value) {
-      this._dispatchItem(this._queue.shift());
-      this._drainUnlockWaiters();
-    }
-  }
-  _dispatchItem(item) {
-    const previousValue = this._value;
-    this._value -= item.weight;
-    item.resolve([previousValue, this._newReleaser(item.weight)]);
-  }
-  _newReleaser(weight) {
-    let called = false;
-    return () => {
-      if (called)
-        return;
-      called = true;
-      this.release(weight);
-    };
-  }
-  _drainUnlockWaiters() {
-    if (this._queue.length === 0) {
-      for (let weight = this._value; weight > 0; weight--) {
-        const waiters = this._weightedWaiters[weight - 1];
-        if (!waiters)
-          continue;
-        waiters.forEach((waiter) => waiter.resolve());
-        this._weightedWaiters[weight - 1] = [];
-      }
-    } else {
-      const queuedPriority = this._queue[0].priority;
-      for (let weight = this._value; weight > 0; weight--) {
-        const waiters = this._weightedWaiters[weight - 1];
-        if (!waiters)
-          continue;
-        const i = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);
-        (i === -1 ? waiters : waiters.splice(0, i)).forEach((waiter) => waiter.resolve());
-      }
-    }
-  }
-  _couldLockImmediately(weight, priority) {
-    return (this._queue.length === 0 || this._queue[0].priority < priority) && weight <= this._value;
-  }
-};
-function insertSorted(a, v) {
-  const i = findIndexFromEnd(a, (other) => v.priority <= other.priority);
-  a.splice(i + 1, 0, v);
-}
-function findIndexFromEnd(a, predicate) {
-  for (let i = a.length - 1; i >= 0; i--) {
-    if (predicate(a[i])) {
-      return i;
-    }
-  }
-  return -1;
-}
-var __awaiter$1 = function(thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve) {
-      resolve(value);
-    });
-  }
-  return new (P || (P = Promise))(function(resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-var Mutex = class {
-  constructor(cancelError) {
-    this._semaphore = new Semaphore(1, cancelError);
-  }
-  acquire() {
-    return __awaiter$1(this, arguments, void 0, function* (priority = 0) {
-      const [, releaser] = yield this._semaphore.acquire(1, priority);
-      return releaser;
-    });
-  }
-  runExclusive(callback, priority = 0) {
-    return this._semaphore.runExclusive(() => callback(), 1, priority);
-  }
-  isLocked() {
-    return this._semaphore.isLocked();
-  }
-  waitForUnlock(priority = 0) {
-    return this._semaphore.waitForUnlock(1, priority);
-  }
-  release() {
-    if (this._semaphore.isLocked())
-      this._semaphore.release();
-  }
-  cancel() {
-    return this._semaphore.cancel();
-  }
-};
-
-// src/commands/eval/jsonl-writer.ts
-var JsonlWriter = class _JsonlWriter {
-  stream;
-  mutex = new Mutex();
-  closed = false;
-  constructor(stream) {
-    this.stream = stream;
-  }
-  static async open(filePath) {
-    await mkdir2(path5.dirname(filePath), { recursive: true });
-    const stream = createWriteStream(filePath, { flags: "w", encoding: "utf8" });
-    return new _JsonlWriter(stream);
-  }
-  async append(record) {
-    await this.mutex.runExclusive(async () => {
-      if (this.closed) {
-        throw new Error("Cannot write to closed JSONL writer");
-      }
-      const snakeCaseRecord = toSnakeCaseDeep(record);
-      const line = `${JSON.stringify(snakeCaseRecord)}
-`;
-      if (!this.stream.write(line)) {
-        await new Promise((resolve, reject) => {
-          this.stream.once("drain", resolve);
-          this.stream.once("error", reject);
-        });
-      }
-    });
-  }
-  async close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    this.stream.end();
-    await finished(this.stream);
-  }
-};
-
-// src/commands/eval/junit-writer.ts
-import { mkdir as mkdir3, writeFile as writeFile2 } from "node:fs/promises";
-import path6 from "node:path";
-function escapeXml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-var JunitWriter = class _JunitWriter {
-  filePath;
-  results = [];
-  closed = false;
-  constructor(filePath) {
-    this.filePath = filePath;
-  }
-  static async open(filePath) {
-    await mkdir3(path6.dirname(filePath), { recursive: true });
-    return new _JunitWriter(filePath);
-  }
-  async append(result) {
-    if (this.closed) {
-      throw new Error("Cannot write to closed JUnit writer");
-    }
-    this.results.push(result);
-  }
-  async close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    const grouped = /* @__PURE__ */ new Map();
-    for (const result of this.results) {
-      const suite = result.dataset ?? "default";
-      const existing = grouped.get(suite);
-      if (existing) {
-        existing.push(result);
-      } else {
-        grouped.set(suite, [result]);
-      }
-    }
-    const suiteXmls = [];
-    for (const [suiteName, results] of grouped) {
-      const failures = results.filter((r) => r.score < 0.5).length;
-      const errors = results.filter((r) => r.error !== void 0).length;
-      const testCases = results.map((r) => {
-        const time = r.durationMs ? (r.durationMs / 1e3).toFixed(3) : "0.000";
-        let inner = "";
-        if (r.error) {
-          inner = `
-      <error message="${escapeXml(r.error)}">${escapeXml(r.error)}</error>
-    `;
-        } else if (r.score < 0.5) {
-          const message = `score=${r.score.toFixed(3)}`;
-          const detail = [
-            `Score: ${r.score.toFixed(3)}`,
-            r.reasoning ? `Reasoning: ${r.reasoning}` : "",
-            r.misses.length > 0 ? `Misses: ${r.misses.join(", ")}` : ""
-          ].filter(Boolean).join("\n");
-          inner = `
-      <failure message="${escapeXml(message)}">${escapeXml(detail)}</failure>
-    `;
-        }
-        return `    <testcase name="${escapeXml(r.testId)}" classname="${escapeXml(suiteName)}" time="${time}">${inner}</testcase>`;
-      });
-      suiteXmls.push(
-        `  <testsuite name="${escapeXml(suiteName)}" tests="${results.length}" failures="${failures}" errors="${errors}">
-${testCases.join("\n")}
-  </testsuite>`
-      );
-    }
-    const totalTests = this.results.length;
-    const totalFailures = this.results.filter((r) => r.score < 0.5).length;
-    const totalErrors = this.results.filter((r) => r.error !== void 0).length;
-    const xml = `<?xml version="1.0" encoding="UTF-8"?>
-<testsuites tests="${totalTests}" failures="${totalFailures}" errors="${totalErrors}">
-${suiteXmls.join("\n")}
-</testsuites>
-`;
-    await writeFile2(this.filePath, xml, "utf8");
-  }
-};
-
-// src/commands/eval/yaml-writer.ts
-import { createWriteStream as createWriteStream2 } from "node:fs";
-import { mkdir as mkdir4 } from "node:fs/promises";
-import path7 from "node:path";
-import { finished as finished2 } from "node:stream/promises";
-import { stringify as stringifyYaml } from "yaml";
-var YamlWriter = class _YamlWriter {
-  stream;
-  mutex = new Mutex();
-  closed = false;
-  isFirst = true;
-  constructor(stream) {
-    this.stream = stream;
-  }
-  static async open(filePath) {
-    await mkdir4(path7.dirname(filePath), { recursive: true });
-    const stream = createWriteStream2(filePath, { flags: "w", encoding: "utf8" });
-    return new _YamlWriter(stream);
-  }
-  async append(record) {
-    await this.mutex.runExclusive(async () => {
-      if (this.closed) {
-        throw new Error("Cannot write to closed YAML writer");
-      }
-      const snakeCaseRecord = toSnakeCaseDeep(record);
-      const yamlDoc = stringifyYaml(snakeCaseRecord, {
-        indent: 2,
-        lineWidth: 0
-        // Disable line wrapping
-        // Let YAML library choose appropriate string style based on content
-        // (will use block literal for multiline strings with actual newlines)
-      });
-      const normalizedYaml = normalizeLineEndings(yamlDoc);
-      const separator = this.isFirst ? "---\n" : "\n---\n";
-      this.isFirst = false;
-      const content = `${separator}${normalizedYaml}`;
-      if (!this.stream.write(content)) {
-        await new Promise((resolve, reject) => {
-          this.stream.once("drain", resolve);
-          this.stream.once("error", reject);
-        });
-      }
-    });
-  }
-  async close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    this.stream.end();
-    await finished2(this.stream);
-  }
-};
-
-// src/commands/eval/output-writer.ts
-async function createOutputWriter(filePath, format) {
-  switch (format) {
-    case "jsonl":
-      return JsonlWriter.open(filePath);
-    case "yaml":
-      return YamlWriter.open(filePath);
-    default: {
-      const exhaustiveCheck = format;
-      throw new Error(`Unsupported output format: ${exhaustiveCheck}`);
-    }
-  }
-}
-function getDefaultExtension(format) {
-  switch (format) {
-    case "jsonl":
-      return ".jsonl";
-    case "yaml":
-      return ".yaml";
-    default: {
-      const exhaustiveCheck = format;
-      throw new Error(`Unsupported output format: ${exhaustiveCheck}`);
-    }
-  }
-}
-var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".jsonl", ".json", ".xml", ".yaml", ".yml"]);
-function createWriterFromPath(filePath) {
-  const ext = path8.extname(filePath).toLowerCase();
-  switch (ext) {
-    case ".jsonl":
-      return JsonlWriter.open(filePath);
-    case ".json":
-      return JsonWriter.open(filePath);
-    case ".xml":
-      return JunitWriter.open(filePath);
-    case ".yaml":
-    case ".yml":
-      return YamlWriter.open(filePath);
-    default:
-      throw new Error(
-        `Unsupported output file extension "${ext}". Supported: ${[...SUPPORTED_EXTENSIONS].join(", ")}`
-      );
-  }
-}
-async function createMultiWriter(filePaths) {
-  const writers = await Promise.all(filePaths.map((fp) => createWriterFromPath(fp)));
-  return {
-    async append(result) {
-      await Promise.all(writers.map((w) => w.append(result)));
-    },
-    async close() {
-      await Promise.all(writers.map((w) => w.close()));
-    }
-  };
-}
-
-// src/commands/eval/progress-display.ts
-var ProgressDisplay = class {
-  workers = /* @__PURE__ */ new Map();
-  totalTests = 0;
-  completedTests = 0;
-  logPaths = [];
-  logPathSet = /* @__PURE__ */ new Set();
-  hasPrintedLogHeader = false;
-  started = false;
-  finished = false;
-  verbose;
-  constructor(_maxWorkers, options) {
-    this.verbose = options?.verbose ?? false;
-  }
-  isInteractiveMode() {
-    return false;
-  }
-  start() {
-    this.started = true;
-    this.finished = false;
-  }
-  setTotalTests(count) {
-    this.totalTests = count;
-  }
-  updateWorker(progress) {
-    const previous = this.workers.get(progress.workerId);
-    this.workers.set(progress.workerId, progress);
-    if (progress.status === "completed" || progress.status === "failed") {
-      this.completedTests++;
-    }
-    const targetSuffix = progress.targetLabel ? ` | ${progress.targetLabel}` : "";
-    const countPrefix = `${this.completedTests}/${this.totalTests}`;
-    switch (progress.status) {
-      case "pending":
-        if (this.verbose && !previous) {
-          console.log(`${countPrefix}   \u23F3 ${progress.testId}${targetSuffix}`);
-        }
-        break;
-      case "running":
-        if (!previous || previous.status === "pending") {
-          console.log(`${countPrefix}   \u{1F504} ${progress.testId}${targetSuffix}`);
-        }
-        break;
-      case "completed":
-        console.log(`${countPrefix}   \u2705 ${progress.testId}${targetSuffix}`);
-        break;
-      case "failed":
-        console.log(
-          `${countPrefix}   \u274C ${progress.testId}${targetSuffix}${progress.error ? `: ${progress.error}` : ""}`
-        );
-        break;
-    }
-  }
-  addLogPaths(paths, provider) {
-    const newPaths = [];
-    for (const path11 of paths) {
-      if (this.logPathSet.has(path11)) {
-        continue;
-      }
-      this.logPathSet.add(path11);
-      newPaths.push(path11);
-    }
-    if (newPaths.length === 0) {
-      return;
-    }
-    this.logPaths.push(...newPaths);
-    if (!this.hasPrintedLogHeader) {
-      console.log("");
-      const label = provider === "pi" ? "Pi Coding Agent" : provider === "copilot" ? "Copilot CLI" : "Codex CLI";
-      console.log(`${label} logs:`);
-      this.hasPrintedLogHeader = true;
-    }
-    const startIndex = this.logPaths.length - newPaths.length;
-    newPaths.forEach((path11, offset) => {
-      console.log(`${startIndex + offset + 1}. ${path11}`);
-    });
-  }
-  finish() {
-    this.finished = true;
-    console.log("");
-  }
-  clear() {
-  }
-};
-
-// src/commands/eval/retry-errors.ts
-import { createReadStream } from "node:fs";
-import { createInterface } from "node:readline";
-async function loadErrorTestIds(jsonlPath) {
-  const ids = [];
-  const rl = createInterface({
-    input: createReadStream(jsonlPath),
-    crlfDelay: Number.POSITIVE_INFINITY
-  });
-  for await (const line of rl) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (parsed.executionStatus === "execution_error" && parsed.testId) {
-        ids.push(parsed.testId);
-      }
-    } catch {
-    }
-  }
-  return [...new Set(ids)];
-}
-async function loadNonErrorResults(jsonlPath) {
-  const results = [];
-  const rl = createInterface({
-    input: createReadStream(jsonlPath),
-    crlfDelay: Number.POSITIVE_INFINITY
-  });
-  for await (const line of rl) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (!parsed.testId || parsed.score === void 0) continue;
-      if (parsed.executionStatus !== "execution_error") {
-        results.push(parsed);
-      }
-    } catch {
-    }
-  }
-  return results;
-}
-
-// src/commands/eval/statistics.ts
-var HISTOGRAM_BREAKPOINTS = [0, 0.2, 0.4, 0.6, 0.8, 1];
-function computeMean(values) {
-  if (values.length === 0) {
-    return 0;
-  }
-  const sum = values.reduce((acc, value) => acc + value, 0);
-  return sum / values.length;
-}
-function computeMedian(values) {
-  if (values.length === 0) {
-    return 0;
-  }
-  const sorted = [...values].sort((a, b) => a - b);
-  const mid = Math.floor(sorted.length / 2);
-  if (sorted.length % 2 === 0) {
-    return (sorted[mid - 1] + sorted[mid]) / 2;
-  }
-  return sorted[mid];
-}
-function computeStandardDeviation(values) {
-  if (values.length < 2) {
-    return void 0;
-  }
-  const mean = computeMean(values);
-  const variance = values.reduce((acc, value) => acc + (value - mean) ** 2, 0) / (values.length - 1);
-  return Math.sqrt(variance);
-}
-function buildHistogram(values) {
-  const bins = [];
-  for (let index = 0; index < HISTOGRAM_BREAKPOINTS.length - 1; index += 1) {
-    bins.push({
-      range: [HISTOGRAM_BREAKPOINTS[index], HISTOGRAM_BREAKPOINTS[index + 1]],
-      count: 0
-    });
-  }
-  for (const value of values) {
-    for (const bin of bins) {
-      const [start, end] = bin.range;
-      const isLastBin = end === HISTOGRAM_BREAKPOINTS[HISTOGRAM_BREAKPOINTS.length - 1];
-      const withinRange = isLastBin ? value >= start && value <= end : value >= start && value < end + 1e-9;
-      if (withinRange) {
-        bin.count += 1;
-        break;
-      }
-    }
-  }
-  return bins;
-}
-function calculateEvaluationSummary(results) {
-  const total = results.length;
-  const errors = results.filter((result) => result.error !== void 0).map((result) => ({ testId: result.testId, error: result.error }));
-  const errorCount = errors.length;
-  if (total === 0) {
-    return {
-      total: 0,
-      mean: 0,
-      median: 0,
-      min: 0,
-      max: 0,
-      standardDeviation: void 0,
-      histogram: buildHistogram([]),
-      topResults: [],
-      bottomResults: [],
-      errorCount: 0,
-      errors: [],
-      executionErrorCount: 0,
-      qualityFailureCount: 0,
-      passedCount: 0,
-      byFailureStage: {},
-      byFailureReason: {}
-    };
-  }
-  const executionErrors = results.filter((r) => r.executionStatus === "execution_error");
-  const qualityResults = results.filter((r) => r.executionStatus !== "execution_error");
-  const qualityScores = qualityResults.map((r) => r.score);
-  const mean = computeMean(qualityScores);
-  const median = computeMedian(qualityScores);
-  const min = qualityScores.length > 0 ? Math.min(...qualityScores) : 0;
-  const max = qualityScores.length > 0 ? Math.max(...qualityScores) : 0;
-  const standardDeviation = computeStandardDeviation(qualityScores);
-  const histogram = buildHistogram(qualityScores);
-  const sortedResults = [...qualityResults].sort((a, b) => b.score - a.score);
-  const topResults = sortedResults.slice(0, Math.min(3, sortedResults.length));
-  const bottomResults = sortedResults.slice(-Math.min(3, sortedResults.length));
-  const executionErrorCount = executionErrors.length;
-  const qualityFailureCount = results.filter((r) => r.executionStatus === "quality_failure").length;
-  const passedCount = results.filter((r) => r.executionStatus === "ok").length;
-  const byFailureStage = {};
-  const byFailureReason = {};
-  for (const result of executionErrors) {
-    if (result.failureStage) {
-      byFailureStage[result.failureStage] = (byFailureStage[result.failureStage] ?? 0) + 1;
-    }
-    if (result.failureReasonCode) {
-      byFailureReason[result.failureReasonCode] = (byFailureReason[result.failureReasonCode] ?? 0) + 1;
-    }
-  }
-  return {
-    total,
-    mean,
-    median,
-    min,
-    max,
-    standardDeviation,
-    histogram,
-    topResults,
-    bottomResults,
-    errorCount,
-    errors,
-    executionErrorCount,
-    qualityFailureCount,
-    passedCount,
-    byFailureStage,
-    byFailureReason
-  };
-}
-function formatScore(value) {
-  return value.toFixed(3);
-}
-function formatEvaluationSummary(summary) {
-  if (summary.total === 0) {
-    return "\nNo results to summarize";
-  }
-  const lines = [];
-  if (summary.errorCount > 0) {
-    lines.push("\n==================================================");
-    lines.push("EXECUTION ERRORS");
-    lines.push("==================================================");
-    for (const error of summary.errors) {
-      lines.push(`
-\u274C ${error.testId}`);
-      lines.push(`   ${error.error}`);
-    }
-    lines.push("");
-  }
-  lines.push("\n==================================================");
-  lines.push("EVALUATION SUMMARY");
-  lines.push("==================================================");
-  lines.push(`Total tests: ${summary.total}`);
-  lines.push(`Passed: ${summary.passedCount}`);
-  if (summary.qualityFailureCount > 0) {
-    lines.push(`Quality failures: ${summary.qualityFailureCount}`);
-  }
-  if (summary.executionErrorCount > 0) {
-    lines.push(`Execution errors: ${summary.executionErrorCount}`);
-  }
-  if (summary.executionErrorCount > 0) {
-    const qualityCount = summary.total - summary.executionErrorCount;
-    lines.push(
-      `Mean score: ${formatScore(summary.mean)} (${qualityCount} quality tests, ${summary.executionErrorCount} execution errors excluded)`
-    );
-  } else {
-    lines.push(`Mean score: ${formatScore(summary.mean)}`);
-  }
-  lines.push(`Median score: ${formatScore(summary.median)}`);
-  lines.push(`Min score: ${formatScore(summary.min)}`);
-  lines.push(`Max score: ${formatScore(summary.max)}`);
-  if (typeof summary.standardDeviation === "number") {
-    lines.push(`Std deviation: ${formatScore(summary.standardDeviation)}`);
-  }
-  lines.push("\nScore distribution:");
-  for (const bin of summary.histogram) {
-    const [start, end] = bin.range;
-    lines.push(`  ${start.toFixed(1)}-${end.toFixed(1)}: ${bin.count}`);
-  }
-  lines.push("\nTop performing tests:");
-  summary.topResults.forEach((result, index) => {
-    lines.push(`  ${index + 1}. ${result.testId}: ${formatScore(result.score)}`);
-  });
-  lines.push("\nLowest performing tests:");
-  summary.bottomResults.forEach((result, index) => {
-    lines.push(`  ${index + 1}. ${result.testId}: ${formatScore(result.score)}`);
-  });
-  const failureStageEntries = Object.entries(summary.byFailureStage);
-  if (failureStageEntries.length > 0) {
-    lines.push("\nExecution errors by stage:");
-    for (const [stage, count] of failureStageEntries) {
-      lines.push(`  ${stage}: ${count}`);
-    }
-  }
-  const failureReasonEntries = Object.entries(summary.byFailureReason);
-  if (failureReasonEntries.length > 0) {
-    lines.push("\nExecution errors by reason:");
-    for (const [reason, count] of failureReasonEntries) {
-      lines.push(`  ${reason}: ${count}`);
-    }
-  }
-  return lines.join("\n");
-}
-function formatMatrixSummary(results) {
-  const targetSet = /* @__PURE__ */ new Set();
-  const testIdSet = /* @__PURE__ */ new Set();
-  for (const result of results) {
-    targetSet.add(result.target);
-    testIdSet.add(result.testId);
-  }
-  const targets = [...targetSet].sort();
-  const testIds = [...testIdSet].sort();
-  if (targets.length < 2) {
-    return "";
-  }
-  const scoreMap = /* @__PURE__ */ new Map();
-  for (const result of results) {
-    if (!scoreMap.has(result.testId)) {
-      scoreMap.set(result.testId, /* @__PURE__ */ new Map());
-    }
-    scoreMap.get(result.testId)?.set(result.target, result.score);
-  }
-  const lines = [];
-  lines.push("\n==================================================");
-  lines.push("MATRIX RESULTS (tests \xD7 targets)");
-  lines.push("==================================================");
-  const testIdColWidth = Math.max(7, ...testIds.map((id) => id.length));
-  const targetColWidth = Math.max(7, ...targets.map((t) => t.length));
-  const header = `${"Test".padEnd(testIdColWidth)}  ${targets.map((t) => t.padEnd(targetColWidth)).join("  ")}`;
-  lines.push(header);
-  lines.push("-".repeat(header.length));
-  for (const testId of testIds) {
-    const cells = targets.map((target) => {
-      const score = scoreMap.get(testId)?.get(target);
-      return score !== void 0 ? formatScore(score).padEnd(targetColWidth) : "-".padEnd(targetColWidth);
-    });
-    lines.push(`${testId.padEnd(testIdColWidth)}  ${cells.join("  ")}`);
-  }
-  lines.push("-".repeat(header.length));
-  const avgCells = targets.map((target) => {
-    const scores = results.filter((r) => r.target === target).map((r) => r.score);
-    const avg = scores.length > 0 ? scores.reduce((a, b) => a + b, 0) / scores.length : 0;
-    return formatScore(avg).padEnd(targetColWidth);
-  });
-  lines.push(`${"Average".padEnd(testIdColWidth)}  ${avgCells.join("  ")}`);
-  return lines.join("\n");
-}
-
-// ../../packages/core/dist/evaluation/validation/index.js
-import { readFile } from "node:fs/promises";
-import path9 from "node:path";
-import { parse } from "yaml";
-import { readFile as readFile2 } from "node:fs/promises";
-import path22 from "node:path";
-import { parse as parse2 } from "yaml";
-import { readFile as readFile3 } from "node:fs/promises";
-import path32 from "node:path";
-import { parse as parse3 } from "yaml";
-import { readFile as readFile4 } from "node:fs/promises";
-import { parse as parse4 } from "yaml";
-import { readFile as readFile5 } from "node:fs/promises";
-import path42 from "node:path";
-import { parse as parse5 } from "yaml";
-var SCHEMA_EVAL_V2 = "agentv-eval-v2";
-var SCHEMA_TARGETS_V2 = "agentv-targets-v2.2";
-var SCHEMA_CONFIG_V2 = "agentv-config-v2";
-async function detectFileType(filePath) {
-  try {
-    const content = await readFile(filePath, "utf8");
-    const parsed = parse(content);
-    if (typeof parsed !== "object" || parsed === null) {
-      return inferFileTypeFromPath(filePath);
-    }
-    const record = parsed;
-    const schema = record.$schema;
-    if (typeof schema !== "string") {
-      return inferFileTypeFromPath(filePath);
-    }
-    switch (schema) {
-      case SCHEMA_EVAL_V2:
-        return "eval";
-      case SCHEMA_TARGETS_V2:
-        return "targets";
-      case SCHEMA_CONFIG_V2:
-        return "config";
-      default:
-        return inferFileTypeFromPath(filePath);
-    }
-  } catch {
-    return inferFileTypeFromPath(filePath);
-  }
-}
-function inferFileTypeFromPath(filePath) {
-  const normalized = path9.normalize(filePath).replace(/\\/g, "/");
-  const basename = path9.basename(filePath);
-  if (normalized.includes("/.agentv/")) {
-    if (basename === "config.yaml" || basename === "config.yml") {
-      return "config";
-    }
-    if (basename === "targets.yaml" || basename === "targets.yml") {
-      return "targets";
-    }
-  }
-  return "eval";
-}
-var ASSERTION_TYPES_WITH_STRING_VALUE = /* @__PURE__ */ new Set([
-  "contains",
-  "icontains",
-  "starts-with",
-  "ends-with",
-  "equals",
-  "regex"
-]);
-var ASSERTION_TYPES_WITH_ARRAY_VALUE = /* @__PURE__ */ new Set([
-  "contains-any",
-  "contains-all",
-  "icontains-any",
-  "icontains-all"
-]);
-var VALID_TEST_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml", ".jsonl"]);
-var NAME_PATTERN = /^[a-z0-9-]+$/;
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-async function validateEvalFile(filePath) {
-  const errors = [];
-  const absolutePath = path22.resolve(filePath);
-  let parsed;
-  try {
-    const content = await readFile2(absolutePath, "utf8");
-    parsed = parse2(content);
-  } catch (error) {
-    errors.push({
-      severity: "error",
-      filePath: absolutePath,
-      message: `Failed to parse YAML: ${error.message}`
-    });
-    return {
-      valid: false,
-      filePath: absolutePath,
-      fileType: "eval",
-      errors
-    };
-  }
-  if (!isObject(parsed)) {
-    errors.push({
-      severity: "error",
-      filePath: absolutePath,
-      message: "File must contain a YAML object"
-    });
-    return {
-      valid: false,
-      filePath: absolutePath,
-      fileType: "eval",
-      errors
-    };
-  }
-  validateMetadata(parsed, absolutePath, errors);
-  const suiteInput = parsed.input;
-  if (suiteInput !== void 0) {
-    if (typeof suiteInput === "string") {
-    } else if (Array.isArray(suiteInput)) {
-      validateMessages(suiteInput, "input", absolutePath, errors);
-    } else {
-      errors.push({
-        severity: "error",
-        filePath: absolutePath,
-        location: "input",
-        message: "Invalid suite-level 'input' field (must be a string or array of messages)"
-      });
-    }
-  }
-  let cases = parsed.tests;
-  if (cases === void 0 && "eval_cases" in parsed) {
-    cases = parsed.eval_cases;
-    errors.push({
-      severity: "warning",
-      filePath: absolutePath,
-      location: "eval_cases",
-      message: "'eval_cases' is deprecated. Use 'tests' instead."
-    });
-  }
-  if (cases === void 0 && "evalcases" in parsed) {
-    cases = parsed.evalcases;
-    errors.push({
-      severity: "warning",
-      filePath: absolutePath,
-      location: "evalcases",
-      message: "'evalcases' is deprecated. Use 'tests' instead."
-    });
-  }
-  if (typeof cases === "string") {
-    validateTestsStringPath(cases, absolutePath, errors);
-    return {
-      valid: errors.filter((e) => e.severity === "error").length === 0,
-      filePath: absolutePath,
-      fileType: "eval",
-      errors
-    };
-  }
-  if (!Array.isArray(cases)) {
-    errors.push({
-      severity: "error",
-      filePath: absolutePath,
-      location: "tests",
-      message: "Missing or invalid 'tests' field (must be an array or a file path string)"
-    });
-    return {
-      valid: errors.length === 0,
-      filePath: absolutePath,
-      fileType: "eval",
-      errors
-    };
-  }
-  for (let i = 0; i < cases.length; i++) {
-    const evalCase = cases[i];
-    const location = `tests[${i}]`;
-    if (!isObject(evalCase)) {
-      errors.push({
-        severity: "error",
-        filePath: absolutePath,
-        location,
-        message: "Eval case must be an object"
-      });
-      continue;
-    }
-    const id = evalCase.id;
-    if (typeof id !== "string" || id.trim().length === 0) {
-      errors.push({
-        severity: "error",
-        filePath: absolutePath,
-        location: `${location}.id`,
-        message: "Missing or invalid 'id' field (must be a non-empty string)"
-      });
-    }
-    let criteria = evalCase.criteria;
-    if (criteria === void 0 && "expected_outcome" in evalCase) {
-      criteria = evalCase.expected_outcome;
-      errors.push({
-        severity: "warning",
-        filePath: absolutePath,
-        location: `${location}.expected_outcome`,
-        message: "'expected_outcome' is deprecated. Use 'criteria' instead."
-      });
-    }
-    if (criteria !== void 0 && (typeof criteria !== "string" || criteria.trim().length === 0)) {
-      errors.push({
-        severity: "error",
-        filePath: absolutePath,
-        location: `${location}.criteria`,
-        message: "Invalid 'criteria' field (must be a non-empty string if provided)"
-      });
-    }
-    const inputField = evalCase.input;
-    if (inputField !== void 0) {
-      if (typeof inputField === "string") {
-      } else if (Array.isArray(inputField)) {
-        validateMessages(inputField, `${location}.input`, absolutePath, errors);
-      } else {
-        errors.push({
-          severity: "error",
-          filePath: absolutePath,
-          location: `${location}.input`,
-          message: "Invalid 'input' field (must be a string or array of messages)"
-        });
-      }
-    } else {
-      errors.push({
-        severity: "error",
-        filePath: absolutePath,
-        location: `${location}.input`,
-        message: "Missing 'input' field (must be a string or array of messages)"
-      });
-    }
-    const expectedOutputField = evalCase.expected_output;
-    if (expectedOutputField !== void 0) {
-      if (typeof expectedOutputField === "string") {
-      } else if (Array.isArray(expectedOutputField)) {
-        if (expectedOutputField.length > 0 && isObject(expectedOutputField[0]) && "role" in expectedOutputField[0]) {
-          validateMessages(
-            expectedOutputField,
-            `${location}.expected_output`,
-            absolutePath,
-            errors
-          );
-        }
-      } else if (isObject(expectedOutputField)) {
-      } else {
-        errors.push({
-          severity: "error",
-          filePath: absolutePath,
-          location: `${location}.expected_output`,
-          message: "Invalid 'expected_output' field (must be a string, object, or array)"
-        });
-      }
-    }
-    const assertField = evalCase.assert;
-    if (assertField !== void 0) {
-      validateAssertArray(assertField, location, absolutePath, errors);
-    }
-  }
-  if (isObject(parsed.workspace)) {
-    validateWorkspaceRepoConfig(parsed.workspace, absolutePath, errors);
-  }
-  return {
-    valid: errors.filter((e) => e.severity === "error").length === 0,
-    filePath: absolutePath,
-    fileType: "eval",
-    errors
-  };
-}
-function validateWorkspaceRepoConfig(workspace, filePath, errors) {
-  const repos = workspace.repos;
-  const hooks = workspace.hooks;
-  const afterEachHook = isObject(hooks) ? hooks.after_each : void 0;
-  const isolation = workspace.isolation;
-  if (Array.isArray(repos)) {
-    for (const repo of repos) {
-      if (!isObject(repo)) continue;
-      const checkout = repo.checkout;
-      const clone = repo.clone;
-      if (isObject(checkout) && isObject(clone)) {
-        const ancestor = checkout.ancestor;
-        const depth = clone.depth;
-        if (typeof ancestor === "number" && typeof depth === "number" && depth < ancestor + 1) {
-          errors.push({
-            severity: "warning",
-            filePath,
-            location: `workspace.repos[path=${repo.path}]`,
-            message: `clone.depth (${depth}) may be insufficient for checkout.ancestor (${ancestor}). Recommend depth >= ${ancestor + 1}.`
-          });
-        }
-      }
-    }
-  }
-  if (isObject(afterEachHook) && afterEachHook.reset && afterEachHook.reset !== "none") {
-    if (!Array.isArray(repos) || repos.length === 0) {
-      errors.push({
-        severity: "warning",
-        filePath,
-        location: "workspace.hooks.after_each",
-        message: `hooks.after_each.reset '${afterEachHook.reset}' has no effect without repos.`
-      });
-    }
-  }
-  if (isObject(afterEachHook) && afterEachHook.reset && isolation === "per_test") {
-    errors.push({
-      severity: "warning",
-      filePath,
-      location: "workspace.hooks.after_each",
-      message: "hooks.after_each.reset is redundant with isolation: per_test (each test gets a fresh workspace)."
-    });
-  }
-}
-function validateMessages(messages, location, filePath, errors) {
-  for (let i = 0; i < messages.length; i++) {
-    const message = messages[i];
-    const msgLocation = `${location}[${i}]`;
-    if (!isObject(message)) {
-      errors.push({
-        severity: "error",
-        filePath,
-        location: msgLocation,
-        message: "Message must be an object"
-      });
-      continue;
-    }
-    const role = message.role;
-    const validRoles = ["system", "user", "assistant"];
-    if (!validRoles.includes(role)) {
-      errors.push({
-        severity: "error",
-        filePath,
-        location: `${msgLocation}.role`,
-        message: `Invalid role '${role}'. Must be one of: ${validRoles.join(", ")}`
-      });
-    }
-    const content = message.content;
-    if (typeof content === "string") {
-      validateContentForRoleMarkers(content, `${msgLocation}.content`, filePath, errors);
-    } else if (Array.isArray(content)) {
-      for (let j = 0; j < content.length; j++) {
-        const contentItem = content[j];
-        const contentLocation = `${msgLocation}.content[${j}]`;
-        if (typeof contentItem === "string") {
-          validateContentForRoleMarkers(contentItem, contentLocation, filePath, errors);
-        } else if (isObject(contentItem)) {
-          const type = contentItem.type;
-          if (typeof type !== "string") {
-            errors.push({
-              severity: "error",
-              filePath,
-              location: `${contentLocation}.type`,
-              message: "Content object must have a 'type' field"
-            });
-          }
-          if (type === "text") {
-            const value = contentItem.value;
-            if (typeof value !== "string") {
-              errors.push({
-                severity: "error",
-                filePath,
-                location: `${contentLocation}.value`,
-                message: "Content with type 'text' must have a 'value' field"
-              });
-            } else {
-              validateContentForRoleMarkers(value, `${contentLocation}.value`, filePath, errors);
-            }
-          }
-        } else {
-          errors.push({
-            severity: "error",
-            filePath,
-            location: contentLocation,
-            message: "Content array items must be strings or objects"
-          });
-        }
-      }
-    } else {
-      errors.push({
-        severity: "error",
-        filePath,
-        location: `${msgLocation}.content`,
-        message: "Missing or invalid 'content' field (must be a string or array)"
-      });
-    }
-  }
-}
-function validateMetadata(parsed, filePath, errors) {
-  const name = parsed.name;
-  if (name !== void 0) {
-    if (typeof name === "string") {
-      if (!NAME_PATTERN.test(name)) {
-        errors.push({
-          severity: "warning",
-          filePath,
-          location: "name",
-          message: `Invalid 'name' format '${name}'. Must match pattern /^[a-z0-9-]+$/ (lowercase alphanumeric with hyphens).`
-        });
-      }
-    }
-    if (!("description" in parsed) || parsed.description === void 0) {
-      errors.push({
-        severity: "warning",
-        filePath,
-        location: "name",
-        message: "When 'name' is present, 'description' should also be provided."
-      });
-    }
-  }
-}
-function validateTestsStringPath(testsPath, filePath, errors) {
-  const ext = path22.extname(testsPath);
-  if (!VALID_TEST_FILE_EXTENSIONS.has(ext)) {
-    errors.push({
-      severity: "warning",
-      filePath,
-      location: "tests",
-      message: `Unsupported file extension '${ext}' for tests path '${testsPath}'. Supported extensions: ${[...VALID_TEST_FILE_EXTENSIONS].join(", ")}`
-    });
-  }
-}
-function validateAssertArray(assertField, parentLocation, filePath, errors) {
-  if (!Array.isArray(assertField)) {
-    errors.push({
-      severity: "warning",
-      filePath,
-      location: `${parentLocation}.assert`,
-      message: "'assert' must be an array of assertion objects."
-    });
-    return;
-  }
-  for (let i = 0; i < assertField.length; i++) {
-    const item = assertField[i];
-    const location = `${parentLocation}.assert[${i}]`;
-    if (!isObject(item)) {
-      errors.push({
-        severity: "warning",
-        filePath,
-        location,
-        message: "Assertion item must be an object with a type field."
-      });
-      continue;
-    }
-    const rawTypeValue = item.type;
-    if (rawTypeValue === void 0 || typeof rawTypeValue !== "string") {
-      errors.push({
-        severity: "warning",
-        filePath,
-        location: `${location}.type`,
-        message: "Assertion item is missing a 'type' field."
-      });
-      continue;
-    }
-    const typeValue = rawTypeValue.replace(/_/g, "-");
-    if (!isEvaluatorKind(typeValue)) {
-      errors.push({
-        severity: "warning",
-        filePath,
-        location: `${location}.type`,
-        message: `Unknown assertion type '${rawTypeValue}'.`
-      });
-      continue;
-    }
-    if (ASSERTION_TYPES_WITH_STRING_VALUE.has(typeValue)) {
-      const value = item.value;
-      if (value === void 0 || typeof value !== "string") {
-        errors.push({
-          severity: "warning",
-          filePath,
-          location: `${location}.value`,
-          message: `Assertion type '${typeValue}' requires a 'value' field (string).`
-        });
-        continue;
-      }
-      if (typeValue === "regex") {
-        try {
-          new RegExp(value);
-        } catch {
-          errors.push({
-            severity: "warning",
-            filePath,
-            location: `${location}.value`,
-            message: `Invalid regex pattern '${value}': not a valid regular expression.`
-          });
-        }
-      }
-    }
-    if (ASSERTION_TYPES_WITH_ARRAY_VALUE.has(typeValue)) {
-      const value = item.value;
-      if (!Array.isArray(value) || value.length === 0) {
-        errors.push({
-          severity: "warning",
-          filePath,
-          location: `${location}.value`,
-          message: `Assertion type '${typeValue}' requires a 'value' field (non-empty string array).`
-        });
-        continue;
-      }
-    }
-    const required = item.required;
-    if (required !== void 0) {
-      validateRequiredField(required, location, filePath, errors);
-    }
-  }
-}
-function validateRequiredField(required, parentLocation, filePath, errors) {
-  if (typeof required === "boolean") {
-    return;
-  }
-  if (typeof required === "number") {
-    if (required <= 0 || required > 1) {
-      errors.push({
-        severity: "warning",
-        filePath,
-        location: `${parentLocation}.required`,
-        message: `Invalid 'required' value ${required}. When a number, it must be between 0 (exclusive) and 1 (inclusive).`
-      });
-    }
-    return;
-  }
-  errors.push({
-    severity: "warning",
-    filePath,
-    location: `${parentLocation}.required`,
-    message: `Invalid 'required' value. Must be a boolean or a number between 0 (exclusive) and 1 (inclusive).`
-  });
-}
-function validateContentForRoleMarkers(content, location, filePath, errors) {
-  const markers = ["@[System]:", "@[User]:", "@[Assistant]:", "@[Tool]:"];
-  for (const marker of markers) {
-    if (content.toLowerCase().includes(marker.toLowerCase())) {
-      errors.push({
-        severity: "warning",
-        filePath,
-        location,
-        message: `Content contains potential role marker '${marker}'. This may confuse agentic providers or cause prompt injection.`
-      });
-    }
-  }
-}
-function isObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var COMMON_SETTINGS = /* @__PURE__ */ new Set(["provider_batching", "providerBatching"]);
-var RETRY_SETTINGS = /* @__PURE__ */ new Set([
-  "max_retries",
-  "maxRetries",
-  "retry_initial_delay_ms",
-  "retryInitialDelayMs",
-  "retry_max_delay_ms",
-  "retryMaxDelayMs",
-  "retry_backoff_factor",
-  "retryBackoffFactor",
-  "retry_status_codes",
-  "retryStatusCodes"
-]);
-var AZURE_SETTINGS = /* @__PURE__ */ new Set([
-  ...COMMON_SETTINGS,
-  ...RETRY_SETTINGS,
-  "endpoint",
-  "resource",
-  "resourceName",
-  "api_key",
-  "apiKey",
-  "deployment",
-  "deploymentName",
-  "model",
-  "version",
-  "api_version",
-  "temperature",
-  "max_output_tokens",
-  "maxTokens"
-]);
-var ANTHROPIC_SETTINGS = /* @__PURE__ */ new Set([
-  ...COMMON_SETTINGS,
-  ...RETRY_SETTINGS,
-  "api_key",
-  "apiKey",
-  "model",
-  "deployment",
-  "variant",
-  "temperature",
-  "max_output_tokens",
-  "maxTokens",
-  "thinking_budget",
-  "thinkingBudget"
-]);
-var GEMINI_SETTINGS = /* @__PURE__ */ new Set([
-  ...COMMON_SETTINGS,
-  ...RETRY_SETTINGS,
-  "api_key",
-  "apiKey",
-  "model",
-  "deployment",
-  "variant",
-  "temperature",
-  "max_output_tokens",
-  "maxTokens"
-]);
-var CODEX_SETTINGS = /* @__PURE__ */ new Set([
-  ...COMMON_SETTINGS,
-  "model",
-  "executable",
-  "command",
-  "binary",
-  "args",
-  "arguments",
-  "cwd",
-  "timeout_seconds",
-  "timeoutSeconds",
-  "log_dir",
-  "logDir",
-  "log_directory",
-  "logDirectory",
-  "log_format",
-  "logFormat",
-  "log_output_format",
-  "logOutputFormat",
-  "system_prompt",
-  "systemPrompt",
-  "workspace_template",
-  "workspaceTemplate"
-]);
-var COPILOT_SDK_SETTINGS = /* @__PURE__ */ new Set([
-  ...COMMON_SETTINGS,
-  "cli_url",
-  "cliUrl",
-  "cli_path",
-  "cliPath",
-  "github_token",
-  "githubToken",
-  "model",
-  "cwd",
-  "timeout_seconds",
-  "timeoutSeconds",
-  "log_dir",
-  "logDir",
-  "log_format",
-  "logFormat",
-  "system_prompt",
-  "systemPrompt",
-  "workspace_template",
-  "workspaceTemplate"
-]);
-var COPILOT_CLI_SETTINGS = /* @__PURE__ */ new Set([
-  ...COMMON_SETTINGS,
-  "executable",
-  "command",
-  "binary",
-  "args",
-  "arguments",
-  "model",
-  "cwd",
-  "timeout_seconds",
-  "timeoutSeconds",
-  "log_dir",
-  "logDir",
-  "log_format",
-  "logFormat",
-  "system_prompt",
-  "systemPrompt",
-  "workspace_template",
-  "workspaceTemplate"
-]);
-var VSCODE_SETTINGS = /* @__PURE__ */ new Set([
-  ...COMMON_SETTINGS,
-  "executable",
-  "workspace_template",
-  "workspaceTemplate",
-  "wait",
-  "dry_run",
-  "dryRun",
-  "subagent_root",
-  "subagentRoot",
-  "timeout_seconds",
-  "timeoutSeconds"
-]);
-var MOCK_SETTINGS = /* @__PURE__ */ new Set([
-  ...COMMON_SETTINGS,
-  "response",
-  "delayMs",
-  "delayMinMs",
-  "delayMaxMs",
-  "trace"
-  // For testing tool-trajectory evaluator
-]);
-var CLAUDE_SETTINGS = /* @__PURE__ */ new Set([
-  ...COMMON_SETTINGS,
-  "model",
-  "cwd",
-  "timeout_seconds",
-  "timeoutSeconds",
-  "log_dir",
-  "logDir",
-  "log_directory",
-  "logDirectory",
-  "log_format",
-  "logFormat",
-  "log_output_format",
-  "logOutputFormat",
-  "system_prompt",
-  "systemPrompt",
-  "workspace_template",
-  "workspaceTemplate",
-  "max_turns",
-  "maxTurns",
-  "max_budget_usd",
-  "maxBudgetUsd"
-]);
-function getKnownSettings(provider) {
-  const normalizedProvider = provider.toLowerCase();
-  switch (normalizedProvider) {
-    case "azure":
-    case "azure-openai":
-      return AZURE_SETTINGS;
-    case "anthropic":
-      return ANTHROPIC_SETTINGS;
-    case "gemini":
-    case "google":
-    case "google-gemini":
-      return GEMINI_SETTINGS;
-    case "codex":
-    case "codex-cli":
-      return CODEX_SETTINGS;
-    case "copilot-sdk":
-    case "copilot_sdk":
-      return COPILOT_SDK_SETTINGS;
-    case "copilot":
-    case "copilot-cli":
-      return COPILOT_CLI_SETTINGS;
-    case "claude":
-    case "claude-code":
-    case "claude-sdk":
-      return CLAUDE_SETTINGS;
-    case "vscode":
-    case "vscode-insiders":
-      return VSCODE_SETTINGS;
-    case "mock":
-      return MOCK_SETTINGS;
-    case "cli":
-      return null;
-    default:
-      return null;
-  }
-}
-function validateUnknownSettings(target, provider, absolutePath, location, errors) {
-  const removedTargetFields = /* @__PURE__ */ new Set(["workspace_template", "workspaceTemplate"]);
-  const knownSettings = getKnownSettings(provider);
-  if (!knownSettings) {
-    return;
-  }
-  const baseFields = /* @__PURE__ */ new Set(["name", "provider", "judge_target", "workers", "$schema", "targets"]);
-  for (const key of Object.keys(target)) {
-    if (removedTargetFields.has(key)) {
-      errors.push({
-        severity: "error",
-        filePath: absolutePath,
-        location: `${location}.${key}`,
-        message: "target-level workspace_template has been removed. Use eval-level workspace.template."
-      });
-      continue;
-    }
-    if (!baseFields.has(key) && !knownSettings.has(key)) {
-      errors.push({
-        severity: "warning",
-        filePath: absolutePath,
-        location: `${location}.${key}`,
-        message: `Unknown setting '${key}' for ${provider} provider. This property will be ignored.`
-      });
-    }
-  }
-}
-async function validateTargetsFile(filePath) {
-  const errors = [];
-  const absolutePath = path32.resolve(filePath);
-  let parsed;
-  try {
-    const content = await readFile3(absolutePath, "utf8");
-    parsed = parse3(content);
-  } catch (error) {
-    errors.push({
-      severity: "error",
-      filePath: absolutePath,
-      message: `Failed to parse YAML: ${error.message}`
-    });
-    return {
-      valid: false,
-      filePath: absolutePath,
-      fileType: "targets",
-      errors
-    };
-  }
-  function validateCliSettings(target, absolutePath2, location, errors2) {
-    const command = target.command;
-    if (typeof command !== "string" || command.trim().length === 0) {
-      errors2.push({
-        severity: "error",
-        filePath: absolutePath2,
-        location: `${location}.command`,
-        message: "CLI provider requires 'command' as a non-empty string"
-      });
-    } else {
-      recordUnknownPlaceholders(command, absolutePath2, `${location}.command`, errors2);
-    }
-    const healthcheck = target.healthcheck;
-    if (healthcheck !== void 0) {
-      validateCliHealthcheck(healthcheck, absolutePath2, `${location}.healthcheck`, errors2);
-    }
-  }
-  function validateCliHealthcheck(healthcheck, absolutePath2, location, errors2) {
-    if (!isObject2(healthcheck)) {
-      errors2.push({
-        severity: "error",
-        filePath: absolutePath2,
-        location,
-        message: "'healthcheck' must be an object when provided"
-      });
-      return;
-    }
-    const timeoutSeconds = healthcheck.timeout_seconds ?? healthcheck.timeoutSeconds;
-    if (timeoutSeconds !== void 0) {
-      const numericTimeout = Number(timeoutSeconds);
-      if (!Number.isFinite(numericTimeout) || numericTimeout <= 0) {
-        errors2.push({
-          severity: "error",
-          filePath: absolutePath2,
-          location: `${location}.timeoutSeconds`,
-          message: "healthcheck.timeoutSeconds must be a positive number when provided"
-        });
-      }
-    }
-    const hasUrl = typeof healthcheck.url === "string" && healthcheck.url.trim().length > 0;
-    const hasCommand = typeof healthcheck.command === "string" && healthcheck.command.trim().length > 0;
-    if (!hasUrl && !hasCommand) {
-      errors2.push({
-        severity: "error",
-        filePath: absolutePath2,
-        location,
-        message: "healthcheck must have either 'url' (HTTP) or 'command' (command)"
-      });
-      return;
-    }
-    if (hasUrl) {
-      return;
-    }
-    recordUnknownPlaceholders(
-      healthcheck.command,
-      absolutePath2,
-      `${location}.command`,
-      errors2
-    );
-    const cwd = healthcheck.cwd;
-    if (cwd !== void 0 && typeof cwd !== "string") {
-      errors2.push({
-        severity: "error",
-        filePath: absolutePath2,
-        location: `${location}.cwd`,
-        message: "healthcheck.cwd must be a string when provided"
-      });
-    }
-  }
-  function recordUnknownPlaceholders(template, absolutePath2, location, errors2) {
-    const placeholders = extractPlaceholders(template);
-    for (const placeholder of placeholders) {
-      if (!CLI_PLACEHOLDERS.has(placeholder)) {
-        errors2.push({
-          severity: "error",
-          filePath: absolutePath2,
-          location,
-          message: `Unknown CLI placeholder '{${placeholder}}'. Supported placeholders: ${Array.from(CLI_PLACEHOLDERS).join(", ")}`
-        });
-      }
-    }
-  }
-  function extractPlaceholders(template) {
-    const matches = template.matchAll(/\{([A-Z_]+)\}/g);
-    const result = [];
-    for (const match of matches) {
-      const placeholder = match[1];
-      if (placeholder) {
-        result.push(placeholder);
-      }
-    }
-    return result;
-  }
-  if (!isObject2(parsed)) {
-    errors.push({
-      severity: "error",
-      filePath: absolutePath,
-      message: "File must contain a YAML object"
-    });
-    return {
-      valid: false,
-      filePath: absolutePath,
-      fileType: "targets",
-      errors
-    };
-  }
-  const targets = parsed.targets;
-  if (!Array.isArray(targets)) {
-    errors.push({
-      severity: "error",
-      filePath: absolutePath,
-      location: "targets",
-      message: "Missing or invalid 'targets' field (must be an array)"
-    });
-    return {
-      valid: errors.length === 0,
-      filePath: absolutePath,
-      fileType: "targets",
-      errors
-    };
-  }
-  const knownProviders = [...KNOWN_PROVIDERS, ...PROVIDER_ALIASES];
-  for (let i = 0; i < targets.length; i++) {
-    const target = targets[i];
-    const location = `targets[${i}]`;
-    if (!isObject2(target)) {
-      errors.push({
-        severity: "error",
-        filePath: absolutePath,
-        location,
-        message: "Target must be an object"
-      });
-      continue;
-    }
-    const name = target.name;
-    if (typeof name !== "string" || name.trim().length === 0) {
-      errors.push({
-        severity: "error",
-        filePath: absolutePath,
-        location: `${location}.name`,
-        message: "Missing or invalid 'name' field (must be a non-empty string)"
-      });
-    }
-    const provider = target.provider;
-    const providerValue = typeof provider === "string" ? provider.trim().toLowerCase() : void 0;
-    if (typeof provider !== "string" || provider.trim().length === 0) {
-      errors.push({
-        severity: "error",
-        filePath: absolutePath,
-        location: `${location}.provider`,
-        message: "Missing or invalid 'provider' field (must be a non-empty string)"
-      });
-    } else if (!knownProviders.includes(provider)) {
-      errors.push({
-        severity: "warning",
-        filePath: absolutePath,
-        location: `${location}.provider`,
-        message: `Unknown provider '${provider}'. Known providers: ${knownProviders.join(", ")}`
-      });
-    }
-    if (providerValue === "cli") {
-      validateCliSettings(target, absolutePath, location, errors);
-    }
-    if (typeof provider === "string") {
-      validateUnknownSettings(target, provider, absolutePath, location, errors);
-    }
-    const judgeTarget = target.judge_target;
-    if (judgeTarget !== void 0 && typeof judgeTarget !== "string") {
-      errors.push({
-        severity: "error",
-        filePath: absolutePath,
-        location: `${location}.judge_target`,
-        message: "Invalid 'judge_target' field (must be a string)"
-      });
-    }
-  }
-  return {
-    valid: errors.filter((e) => e.severity === "error").length === 0,
-    filePath: absolutePath,
-    fileType: "targets",
-    errors
-  };
-}
-async function validateConfigFile(filePath) {
-  const errors = [];
-  try {
-    const content = await readFile4(filePath, "utf8");
-    const parsed = parse4(content);
-    if (typeof parsed !== "object" || parsed === null) {
-      errors.push({
-        severity: "error",
-        filePath,
-        message: "Config file must contain a valid YAML object"
-      });
-      return { valid: false, filePath, fileType: "config", errors };
-    }
-    const config = parsed;
-    const guidelinePatterns = config.guideline_patterns;
-    if (guidelinePatterns !== void 0) {
-      if (!Array.isArray(guidelinePatterns)) {
-        errors.push({
-          severity: "error",
-          filePath,
-          location: "guideline_patterns",
-          message: "Field 'guideline_patterns' must be an array"
-        });
-      } else if (!guidelinePatterns.every((p) => typeof p === "string")) {
-        errors.push({
-          severity: "error",
-          filePath,
-          location: "guideline_patterns",
-          message: "All entries in 'guideline_patterns' must be strings"
-        });
-      } else if (guidelinePatterns.length === 0) {
-        errors.push({
-          severity: "warning",
-          filePath,
-          location: "guideline_patterns",
-          message: "Field 'guideline_patterns' is empty. Consider removing it or adding patterns."
-        });
-      }
-    }
-    const evalPatterns = config.eval_patterns;
-    if (evalPatterns !== void 0) {
-      if (!Array.isArray(evalPatterns)) {
-        errors.push({
-          severity: "error",
-          filePath,
-          location: "eval_patterns",
-          message: "Field 'eval_patterns' must be an array"
-        });
-      } else if (!evalPatterns.every((p) => typeof p === "string")) {
-        errors.push({
-          severity: "error",
-          filePath,
-          location: "eval_patterns",
-          message: "All entries in 'eval_patterns' must be strings"
-        });
-      } else if (evalPatterns.length === 0) {
-        errors.push({
-          severity: "warning",
-          filePath,
-          location: "eval_patterns",
-          message: "Field 'eval_patterns' is empty. Consider removing it or adding patterns."
-        });
-      }
-    }
-    const allowedFields = /* @__PURE__ */ new Set(["$schema", "guideline_patterns", "eval_patterns"]);
-    const unexpectedFields = Object.keys(config).filter((key) => !allowedFields.has(key));
-    if (unexpectedFields.length > 0) {
-      errors.push({
-        severity: "warning",
-        filePath,
-        message: `Unexpected fields: ${unexpectedFields.join(", ")}`
-      });
-    }
-    return {
-      valid: errors.filter((e) => e.severity === "error").length === 0,
-      filePath,
-      fileType: "config",
-      errors
-    };
-  } catch (error) {
-    errors.push({
-      severity: "error",
-      filePath,
-      message: `Failed to parse config file: ${error.message}`
-    });
-    return { valid: false, filePath, fileType: "config", errors };
-  }
-}
-function isObject3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-async function validateFileReferences(evalFilePath) {
-  const errors = [];
-  const absolutePath = path42.resolve(evalFilePath);
-  const gitRoot = await findGitRoot(absolutePath);
-  if (!gitRoot) {
-    errors.push({
-      severity: "error",
-      filePath: absolutePath,
-      message: "Cannot validate file references: git repository root not found"
-    });
-    return errors;
-  }
-  const searchRoots = buildSearchRoots(absolutePath, gitRoot);
-  let parsed;
-  try {
-    const content = await readFile5(absolutePath, "utf8");
-    parsed = parse5(content);
-  } catch {
-    return errors;
-  }
-  if (!isObject3(parsed)) {
-    return errors;
-  }
-  let cases = parsed.tests;
-  if (cases === void 0 && "eval_cases" in parsed) {
-    cases = parsed.eval_cases;
-  }
-  if (cases === void 0 && "evalcases" in parsed) {
-    cases = parsed.evalcases;
-  }
-  if (!Array.isArray(cases)) {
-    return errors;
-  }
-  for (let i = 0; i < cases.length; i++) {
-    const evalCase = cases[i];
-    if (!isObject3(evalCase)) {
-      continue;
-    }
-    const inputField = evalCase.input;
-    if (Array.isArray(inputField)) {
-      await validateMessagesFileRefs(
-        inputField,
-        `tests[${i}].input`,
-        searchRoots,
-        absolutePath,
-        errors
-      );
-    }
-    const expectedOutputField = evalCase.expected_output;
-    if (Array.isArray(expectedOutputField)) {
-      await validateMessagesFileRefs(
-        expectedOutputField,
-        `tests[${i}].expected_output`,
-        searchRoots,
-        absolutePath,
-        errors
-      );
-    }
-  }
-  return errors;
-}
-async function validateMessagesFileRefs(messages, location, searchRoots, filePath, errors) {
-  for (let i = 0; i < messages.length; i++) {
-    const message = messages[i];
-    if (!isObject3(message)) {
-      continue;
-    }
-    const content = message.content;
-    if (typeof content === "string") {
-      continue;
-    }
-    if (!Array.isArray(content)) {
-      continue;
-    }
-    for (let j = 0; j < content.length; j++) {
-      const contentItem = content[j];
-      if (!isObject3(contentItem)) {
-        continue;
-      }
-      const type = contentItem.type;
-      if (type !== "file") {
-        continue;
-      }
-      const value = contentItem.value;
-      if (typeof value !== "string") {
-        errors.push({
-          severity: "error",
-          filePath,
-          location: `${location}[${i}].content[${j}].value`,
-          message: "File reference must have a 'value' field with the file path"
-        });
-        continue;
-      }
-      const { resolvedPath } = await resolveFileReference(value, searchRoots);
-      if (!resolvedPath) {
-        errors.push({
-          severity: "error",
-          filePath,
-          location: `${location}[${i}].content[${j}]`,
-          message: `Referenced file not found: ${value}`
-        });
-      } else {
-        try {
-          const fileContent = await readFile5(resolvedPath, "utf8");
-          if (fileContent.trim().length === 0) {
-            errors.push({
-              severity: "warning",
-              filePath,
-              location: `${location}[${i}].content[${j}]`,
-              message: `Referenced file is empty: ${value}`
-            });
-          }
-        } catch (error) {
-          errors.push({
-            severity: "error",
-            filePath,
-            location: `${location}[${i}].content[${j}]`,
-            message: `Cannot read referenced file: ${value} (${error.message})`
-          });
-        }
-      }
-    }
-  }
-}
-
-// src/commands/eval/targets.ts
-var ANSI_YELLOW2 = "\x1B[33m";
-var ANSI_RED2 = "\x1B[31m";
-var ANSI_RESET2 = "\x1B[0m";
-function isTTY() {
-  return process.stdout.isTTY ?? false;
-}
-async function readTestSuiteTarget(testFilePath) {
-  const metadata = await readTestSuiteMetadata(testFilePath);
-  return metadata.target;
-}
-function pickTargetName(options) {
-  const cliName = options.cliTargetName?.trim();
-  if (cliName && cliName !== "default") {
-    return { name: cliName, source: "cli" };
-  }
-  const fileName = options.fileTargetName?.trim();
-  if (fileName && fileName.length > 0) {
-    return { name: fileName, source: "test-file" };
-  }
-  return { name: "default", source: "default" };
-}
-async function selectTarget(options) {
-  const {
-    testFilePath,
-    repoRoot,
-    cwd,
-    explicitTargetsPath,
-    cliTargetName,
-    dryRun,
-    dryRunDelay,
-    dryRunDelayMin,
-    dryRunDelayMax,
-    env
-  } = options;
-  const targetsFilePath = await discoverTargetsFile({
-    explicitPath: explicitTargetsPath,
-    testFilePath,
-    repoRoot,
-    cwd
-  });
-  const validationResult = await validateTargetsFile(targetsFilePath);
-  const warnings = validationResult.errors.filter((e) => e.severity === "warning");
-  const useColors = isTTY();
-  if (warnings.length > 0) {
-    console.warn(`
-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;
-      console.warn(`${prefix}${location} ${message}`);
-    }
-    console.warn("");
-  }
-  const errors = validationResult.errors.filter((e) => e.severity === "error");
-  if (errors.length > 0) {
-    console.error(`
-Errors in ${targetsFilePath}:`);
-    for (const error of errors) {
-      const location = error.location ? ` [${error.location}]` : "";
-      const prefix = useColors ? `${ANSI_RED2}  \u2717${ANSI_RESET2}` : "  \u2717";
-      const message = useColors ? `${ANSI_RED2}${error.message}${ANSI_RESET2}` : error.message;
-      console.error(`${prefix}${location} ${message}`);
-    }
-    throw new Error(`Targets file validation failed with ${errors.length} error(s)`);
-  }
-  const definitions = await readTargetDefinitions(targetsFilePath);
-  const fileTargetName = await readTestSuiteTarget(testFilePath);
-  const targetChoice = pickTargetName({ cliTargetName, fileTargetName });
-  const targetDefinition = definitions.find(
-    (definition) => definition.name === targetChoice.name
-  );
-  if (!targetDefinition) {
-    const available = listTargetNames(definitions).join(", ");
-    throw new Error(
-      `Target '${targetChoice.name}' not found in ${targetsFilePath}. Available targets: ${available}`
-    );
-  }
-  if (dryRun) {
-    const mockTarget = {
-      kind: "mock",
-      name: `${targetDefinition.name}-dry-run`,
-      judgeTarget: void 0,
-      config: {
-        response: '{"answer":"Mock dry-run response"}',
-        delayMs: dryRunDelay,
-        delayMinMs: dryRunDelayMin,
-        delayMaxMs: dryRunDelayMax
-      }
-    };
-    return {
-      definitions,
-      resolvedTarget: mockTarget,
-      targetName: targetChoice.name,
-      targetSource: targetChoice.source,
-      targetsFilePath
-    };
-  }
-  try {
-    const resolvedTarget = resolveTargetDefinition(targetDefinition, env, testFilePath);
-    return {
-      definitions,
-      resolvedTarget,
-      targetName: targetChoice.name,
-      targetSource: targetChoice.source,
-      targetsFilePath
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to resolve target '${targetChoice.name}': ${message}`);
-  }
-}
-async function selectMultipleTargets(options) {
-  const {
-    testFilePath,
-    repoRoot,
-    cwd,
-    explicitTargetsPath,
-    dryRun,
-    dryRunDelay,
-    dryRunDelayMin,
-    dryRunDelayMax,
-    env,
-    targetNames
-  } = options;
-  const targetsFilePath = await discoverTargetsFile({
-    explicitPath: explicitTargetsPath,
-    testFilePath,
-    repoRoot,
-    cwd
-  });
-  const validationResult = await validateTargetsFile(targetsFilePath);
-  const warnings = validationResult.errors.filter((e) => e.severity === "warning");
-  const useColors = isTTY();
-  if (warnings.length > 0) {
-    console.warn(`
-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;
-      console.warn(`${prefix}${location} ${message}`);
-    }
-    console.warn("");
-  }
-  const errors = validationResult.errors.filter((e) => e.severity === "error");
-  if (errors.length > 0) {
-    console.error(`
-Errors in ${targetsFilePath}:`);
-    for (const error of errors) {
-      const location = error.location ? ` [${error.location}]` : "";
-      const prefix = useColors ? `${ANSI_RED2}  \u2717${ANSI_RESET2}` : "  \u2717";
-      const message = useColors ? `${ANSI_RED2}${error.message}${ANSI_RESET2}` : error.message;
-      console.error(`${prefix}${location} ${message}`);
-    }
-    throw new Error(`Targets file validation failed with ${errors.length} error(s)`);
-  }
-  const definitions = await readTargetDefinitions(targetsFilePath);
-  const results = [];
-  for (const name of targetNames) {
-    const targetDefinition = definitions.find(
-      (definition) => definition.name === name
-    );
-    if (!targetDefinition) {
-      const available = listTargetNames(definitions).join(", ");
-      throw new Error(
-        `Target '${name}' not found in ${targetsFilePath}. Available targets: ${available}`
-      );
-    }
-    if (dryRun) {
-      const mockTarget = {
-        kind: "mock",
-        name: `${targetDefinition.name}-dry-run`,
-        judgeTarget: void 0,
-        config: {
-          response: '{"answer":"Mock dry-run response"}',
-          delayMs: dryRunDelay,
-          delayMinMs: dryRunDelayMin,
-          delayMaxMs: dryRunDelayMax
-        }
-      };
-      results.push({
-        definitions,
-        resolvedTarget: mockTarget,
-        targetName: name,
-        targetSource: "cli",
-        targetsFilePath
-      });
-    } else {
-      try {
-        const resolvedTarget = resolveTargetDefinition(targetDefinition, env, testFilePath);
-        results.push({
-          definitions,
-          resolvedTarget,
-          targetName: name,
-          targetSource: "cli",
-          targetsFilePath
-        });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to resolve target '${name}': ${message}`);
-      }
-    }
-  }
-  return results;
-}
-
-// src/commands/eval/run-eval.ts
-var DEFAULT_WORKERS = 3;
-function normalizeBoolean(value) {
-  return value === true;
-}
-function normalizeString(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function resolveTimestampPlaceholder(value) {
-  if (!value.includes("{timestamp}")) {
-    return value;
-  }
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return value.replaceAll("{timestamp}", timestamp);
-}
-function normalizeNumber(value, fallback) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string") {
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isNaN(parsed)) {
-      return parsed;
-    }
-  }
-  return fallback;
-}
-function normalizeOptionalNumber(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string") {
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isNaN(parsed)) {
-      return parsed;
-    }
-  }
-  return void 0;
-}
-function normalizeWorkspaceMode(value) {
-  return value === "pooled" || value === "temp" || value === "static" ? value : void 0;
-}
-function normalizeOptions(rawOptions, config, yamlExecution) {
-  const cliFormat = normalizeString(rawOptions.outputFormat);
-  const configFormat = config?.output?.format;
-  const formatStr = cliFormat ?? configFormat ?? "jsonl";
-  const format = formatStr === "yaml" ? "yaml" : "jsonl";
-  const cliWorkers = normalizeOptionalNumber(rawOptions.workers);
-  const configWorkers = config?.execution?.workers;
-  const workers = cliWorkers ?? configWorkers ?? 0;
-  const rawOutputPaths = rawOptions.output;
-  const outputPaths = Array.isArray(rawOutputPaths) ? rawOutputPaths.filter((v) => typeof v === "string" && v.trim().length > 0) : [];
-  const rawTarget = rawOptions.target;
-  let cliTargets = [];
-  let singleTarget;
-  if (Array.isArray(rawTarget)) {
-    cliTargets = rawTarget.filter((v) => typeof v === "string" && v.trim().length > 0);
-    singleTarget = cliTargets.length === 1 ? cliTargets[0] : void 0;
-  } else if (typeof rawTarget === "string") {
-    const trimmed = rawTarget.trim();
-    if (trimmed.length > 0 && trimmed !== "default") {
-      cliTargets = [trimmed];
-      singleTarget = trimmed;
-    }
-  }
-  const cliAgentTimeout = normalizeOptionalNumber(rawOptions.agentTimeout);
-  const configAgentTimeoutSeconds = config?.execution?.agentTimeoutMs != null ? config.execution.agentTimeoutMs / 1e3 : void 0;
-  const cliMaxRetries = normalizeOptionalNumber(rawOptions.maxRetries);
-  const configMaxRetries = config?.execution?.maxRetries;
-  const cliCache = normalizeBoolean(rawOptions.cache);
-  const cliNoCache = normalizeBoolean(rawOptions.noCache);
-  const configCacheEnabled = config?.cache?.enabled;
-  const resolvedCache = cliCache || !cliNoCache && configCacheEnabled === true;
-  const resolvedNoCache = cliNoCache;
-  const cliOut = normalizeString(rawOptions.out);
-  const configOut = config?.output?.dir;
-  const cliWorkspacePath = normalizeString(rawOptions.workspacePath);
-  const cliWorkspaceModeRaw = normalizeString(rawOptions.workspaceMode);
-  const cliWorkspaceMode = normalizeWorkspaceMode(rawOptions.workspaceMode);
-  if (cliWorkspacePath && cliWorkspaceModeRaw && cliWorkspaceMode !== "static") {
-    throw new Error("--workspace-path requires --workspace-mode=static (or omit --workspace-mode)");
-  }
-  const yamlExecutionRecord = yamlExecution;
-  const yamlWorkspaceMode = normalizeWorkspaceMode(yamlExecutionRecord?.workspace_mode);
-  const yamlWorkspacePath = normalizeString(yamlExecutionRecord?.workspace_path);
-  const workspacePath = cliWorkspacePath ?? yamlWorkspacePath;
-  const workspaceMode = cliWorkspacePath ? "static" : cliWorkspaceMode ?? yamlWorkspaceMode;
-  return {
-    target: singleTarget,
-    cliTargets,
-    targetsPath: normalizeString(rawOptions.targets),
-    filter: normalizeString(rawOptions.filter),
-    workers: workers > 0 ? workers : void 0,
-    outPath: cliOut ?? configOut,
-    outputPaths,
-    format,
-    dryRun: normalizeBoolean(rawOptions.dryRun),
-    dryRunDelay: normalizeNumber(rawOptions.dryRunDelay, 0),
-    dryRunDelayMin: normalizeNumber(rawOptions.dryRunDelayMin, 0),
-    dryRunDelayMax: normalizeNumber(rawOptions.dryRunDelayMax, 0),
-    agentTimeoutSeconds: cliAgentTimeout ?? configAgentTimeoutSeconds,
-    maxRetries: cliMaxRetries ?? configMaxRetries ?? 2,
-    cache: resolvedCache,
-    noCache: resolvedNoCache,
-    // Boolean OR: config `true` cannot be overridden to `false` from CLI.
-    // Intentional — there are no --no-verbose / --no-keep-workspaces flags.
-    // Precedence: CLI > YAML config > TS config
-    verbose: normalizeBoolean(rawOptions.verbose) || yamlExecution?.verbose === true || config?.execution?.verbose === true,
-    // Precedence: CLI > YAML config > TS config
-    otelFile: normalizeString(rawOptions.otelFile) ?? (yamlExecution?.otel_file ? resolveTimestampPlaceholder(yamlExecution.otel_file) : void 0) ?? (config?.execution?.otelFile ? resolveTimestampPlaceholder(config.execution.otelFile) : void 0),
-    traceFile: normalizeString(rawOptions.traceFile) ?? (yamlExecution?.trace_file ? resolveTimestampPlaceholder(yamlExecution.trace_file) : void 0) ?? (config?.execution?.traceFile ? resolveTimestampPlaceholder(config.execution.traceFile) : void 0),
-    exportOtel: normalizeBoolean(rawOptions.exportOtel),
-    otelBackend: normalizeString(rawOptions.otelBackend),
-    otelCaptureContent: normalizeBoolean(rawOptions.otelCaptureContent),
-    otelGroupTurns: normalizeBoolean(rawOptions.otelGroupTurns),
-    retryErrors: normalizeString(rawOptions.retryErrors),
-    workspaceMode,
-    workspacePath
-  };
-}
-async function ensureFileExists(filePath, description) {
-  try {
-    await access4(filePath, constants4.F_OK);
-  } catch {
-    throw new Error(`${description} not found: ${filePath}`);
-  }
-}
-function buildDefaultOutputPath(cwd, format) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const baseName = "eval";
-  const extension = getDefaultExtension(format);
-  return path10.join(cwd, ".agentv", "results", `${baseName}_${timestamp}${extension}`);
-}
-function createProgressReporter(maxWorkers, options) {
-  const display = new ProgressDisplay(maxWorkers, options);
-  return {
-    isInteractive: display.isInteractiveMode(),
-    start: () => display.start(),
-    setTotal: (total) => display.setTotalTests(total),
-    update: (workerId, progress) => display.updateWorker({ ...progress, workerId }),
-    finish: () => display.finish(),
-    addLogPaths: (paths, provider) => display.addLogPaths(paths, provider)
-  };
-}
-function makeEvalKey(testFilePath, evalId) {
-  return `${path10.resolve(testFilePath)}::${evalId}`;
-}
-function createDisplayIdTracker() {
-  const map = /* @__PURE__ */ new Map();
-  let nextId = 1;
-  return {
-    getOrAssign(evalKey) {
-      const existing = map.get(evalKey);
-      if (existing !== void 0) {
-        return existing;
-      }
-      const assigned = nextId++;
-      map.set(evalKey, assigned);
-      return assigned;
-    }
-  };
-}
-function applyVerboseOverride(selection, cliVerbose) {
-  const { resolvedTarget } = selection;
-  if (resolvedTarget.kind !== "cli") {
-    return selection;
-  }
-  return {
-    ...selection,
-    resolvedTarget: {
-      ...resolvedTarget,
-      config: {
-        ...resolvedTarget.config,
-        verbose: cliVerbose
-      }
-    }
-  };
-}
-async function prepareFileMetadata(params) {
-  const { testFilePath, repoRoot, cwd, options } = params;
-  await ensureFileExists(testFilePath, "Test file");
-  await loadEnvFromHierarchy({
-    testFilePath,
-    repoRoot,
-    verbose: options.verbose
-  });
-  const suite = await loadTestSuite(testFilePath, repoRoot, {
-    verbose: options.verbose,
-    filter: options.filter
-  });
-  const filteredIds = suite.tests.map((value) => value.id);
-  const cliTargets = options.cliTargets;
-  const suiteTargets = suite.targets;
-  let targetNames;
-  if (cliTargets.length > 0) {
-    targetNames = cliTargets;
-  } else if (suiteTargets && suiteTargets.length > 0) {
-    targetNames = suiteTargets;
-  } else {
-    targetNames = [];
-  }
-  let selections;
-  if (targetNames.length > 1) {
-    const multiSelections = await selectMultipleTargets({
-      testFilePath,
-      repoRoot,
-      cwd,
-      explicitTargetsPath: options.targetsPath,
-      dryRun: options.dryRun,
-      dryRunDelay: options.dryRunDelay,
-      dryRunDelayMin: options.dryRunDelayMin,
-      dryRunDelayMax: options.dryRunDelayMax,
-      env: process.env,
-      targetNames
-    });
-    selections = multiSelections.map((sel) => {
-      const providerLabel = options.dryRun ? `${sel.resolvedTarget.kind} (dry-run)` : sel.resolvedTarget.kind;
-      return {
-        selection: sel,
-        inlineTargetLabel: `${sel.targetName} [provider=${providerLabel}]`
-      };
-    });
-  } else {
-    const selection = await selectTarget({
-      testFilePath,
-      repoRoot,
-      cwd,
-      explicitTargetsPath: options.targetsPath,
-      cliTargetName: targetNames.length === 1 ? targetNames[0] : options.target,
-      dryRun: options.dryRun,
-      dryRunDelay: options.dryRunDelay,
-      dryRunDelayMin: options.dryRunDelayMin,
-      dryRunDelayMax: options.dryRunDelayMax,
-      env: process.env
-    });
-    const providerLabel = options.dryRun ? `${selection.resolvedTarget.kind} (dry-run)` : selection.resolvedTarget.kind;
-    selections = [
-      {
-        selection,
-        inlineTargetLabel: `${selection.targetName} [provider=${providerLabel}]`
-      }
-    ];
-  }
-  return {
-    evalIds: filteredIds,
-    evalCases: suite.tests,
-    selections,
-    trialsConfig: suite.trials,
-    suiteTargets,
-    yamlCache: suite.cacheConfig?.enabled,
-    yamlCachePath: suite.cacheConfig?.cachePath,
-    totalBudgetUsd: suite.totalBudgetUsd,
-    failOnError: suite.failOnError
-  };
-}
-async function runWithLimit(items, limit, task) {
-  const safeLimit = Math.max(1, limit);
-  let index = 0;
-  const workers = Array.from({ length: safeLimit }, async () => {
-    while (index < items.length) {
-      const current = items[index];
-      index += 1;
-      await task(current);
-    }
-  });
-  await Promise.all(workers);
-}
-async function runSingleEvalFile(params) {
-  const {
-    testFilePath,
-    cwd,
-    repoRoot,
-    options,
-    outputWriter,
-    otelExporter,
-    cache,
-    evaluationRunner,
-    workersOverride,
-    progressReporter,
-    seenEvalCases,
-    displayIdTracker,
-    selection,
-    inlineTargetLabel,
-    evalCases,
-    trialsConfig,
-    matrixMode,
-    totalBudgetUsd,
-    failOnError
-  } = params;
-  const targetName = selection.targetName;
-  await ensureFileExists(testFilePath, "Test file");
-  const resolvedTargetSelection = applyVerboseOverride(selection, options.verbose);
-  const providerLabel = options.dryRun ? `${resolvedTargetSelection.resolvedTarget.kind} (dry-run)` : resolvedTargetSelection.resolvedTarget.kind;
-  const targetMessage = options.verbose ? `Using target (${resolvedTargetSelection.targetSource}): ${resolvedTargetSelection.targetName} [provider=${providerLabel}] via ${resolvedTargetSelection.targetsFilePath}` : `Using target: ${inlineTargetLabel}`;
-  if (!progressReporter.isInteractive || options.verbose) {
-    console.log(targetMessage);
-  }
-  const agentTimeoutMs = options.agentTimeoutSeconds != null ? Math.max(0, options.agentTimeoutSeconds) * 1e3 : void 0;
-  const workerPreference = workersOverride ?? options.workers;
-  let resolvedWorkers = workerPreference ?? resolvedTargetSelection.resolvedTarget.workers ?? DEFAULT_WORKERS;
-  if (resolvedWorkers < 1 || resolvedWorkers > 50) {
-    throw new Error(`Workers must be between 1 and 50, got: ${resolvedWorkers}`);
-  }
-  const isVSCodeProvider = ["vscode", "vscode-insiders"].includes(
-    resolvedTargetSelection.resolvedTarget.kind
-  );
-  if (isVSCodeProvider && resolvedWorkers > 1) {
-    console.warn(
-      `Warning: VSCode providers require window focus. Limiting workers from ${resolvedWorkers} to 1 to prevent race conditions.`
-    );
-    resolvedWorkers = 1;
-  }
-  if (isVSCodeProvider && !options.dryRun) {
-    const vsConfig = resolvedTargetSelection.resolvedTarget.config;
-    await ensureVSCodeSubagents({
-      kind: resolvedTargetSelection.resolvedTarget.kind,
-      count: resolvedWorkers,
-      verbose: options.verbose,
-      vscodeCmd: vsConfig.executable
-    });
-  }
-  const streamingObserver = otelExporter?.createStreamingObserver() ?? null;
-  const results = await evaluationRunner({
-    testFilePath,
-    repoRoot,
-    target: resolvedTargetSelection.resolvedTarget,
-    targets: resolvedTargetSelection.definitions,
-    env: process.env,
-    maxRetries: Math.max(0, options.maxRetries),
-    agentTimeoutMs,
-    cache,
-    useCache: (() => {
-      if (!cache) return false;
-      const targetConfig = resolvedTargetSelection.resolvedTarget.config;
-      if (shouldSkipCacheForTemperature(targetConfig)) {
-        if (options.verbose) {
-          console.log("Cache skipped: target temperature > 0");
-        }
-        return false;
-      }
-      return true;
-    })(),
-    evalCases,
-    verbose: options.verbose,
-    maxConcurrency: resolvedWorkers,
-    workspaceMode: options.workspaceMode,
-    workspacePath: options.workspacePath,
-    trials: trialsConfig,
-    totalBudgetUsd,
-    failOnError,
-    streamCallbacks: streamingObserver?.getStreamCallbacks(),
-    onResult: async (result) => {
-      streamingObserver?.finalizeEvalCase(result.score, result.error);
-      const { output: _, ...resultWithoutTrace } = result;
-      await outputWriter.append(resultWithoutTrace);
-      if (otelExporter && !streamingObserver) {
-        try {
-          await otelExporter.exportResult(result);
-        } catch (err) {
-          if (options.verbose) {
-            console.warn(
-              `OTel export warning: ${err instanceof Error ? err.message : String(err)}`
-            );
-          }
-        }
-      }
-    },
-    onProgress: async (event) => {
-      const evalKeyId = matrixMode ? `${event.testId}@${targetName}` : event.testId;
-      const evalKey = makeEvalKey(testFilePath, evalKeyId);
-      if (event.status === "pending" && !seenEvalCases.has(evalKey)) {
-        seenEvalCases.add(evalKey);
-        progressReporter.setTotal(seenEvalCases.size);
-      }
-      const displayId = displayIdTracker.getOrAssign(evalKey);
-      if (event.status === "running" && streamingObserver) {
-        streamingObserver.startEvalCase(event.testId, targetName, testFilePath);
-      }
-      progressReporter.update(displayId, {
-        workerId: displayId,
-        testId: matrixMode ? `${event.testId}@${targetName}` : event.testId,
-        status: event.status,
-        startedAt: event.startedAt,
-        completedAt: event.completedAt,
-        error: event.error,
-        targetLabel: inlineTargetLabel
-      });
-    }
-  });
-  return { results: [...results] };
-}
-async function runEvalCommand(input) {
-  const cwd = process.cwd();
-  let config = null;
-  try {
-    config = await loadTsConfig(cwd);
-  } catch (err) {
-    console.warn(
-      `Warning: Failed to load agentv config: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  const repoRoot = await findRepoRoot(cwd);
-  const yamlConfig = await loadConfig(path10.join(cwd, "_"), repoRoot);
-  if (yamlConfig?.required_version) {
-    await enforceRequiredVersion(yamlConfig.required_version, {
-      strict: normalizeBoolean(input.rawOptions.strict)
-    });
-  }
-  let options = normalizeOptions(input.rawOptions, config, yamlConfig?.execution);
-  let retryNonErrorResults;
-  if (options.retryErrors) {
-    const retryPath = path10.resolve(options.retryErrors);
-    await ensureFileExists(retryPath, "Retry-errors JSONL file");
-    const errorIds = await loadErrorTestIds(retryPath);
-    if (errorIds.length === 0) {
-      console.log("No execution errors found in the previous output. Nothing to retry.");
-      return;
-    }
-    console.log(`Retrying ${errorIds.length} execution-error test(s): ${errorIds.join(", ")}`);
-    const filterPattern = errorIds.length === 1 ? errorIds[0] : `{${errorIds.join(",")}}`;
-    options = { ...options, filter: filterPattern };
-    retryNonErrorResults = await loadNonErrorResults(retryPath);
-  }
-  if (options.workspacePath) {
-    const resolvedWorkspace = path10.resolve(options.workspacePath);
-    try {
-      const { stat: stat2 } = await import("node:fs/promises");
-      const stats = await stat2(resolvedWorkspace);
-      if (!stats.isDirectory()) {
-        throw new Error(`--workspace-path is not a directory: ${resolvedWorkspace}`);
-      }
-    } catch (err) {
-      if (err.code === "ENOENT") {
-        throw new Error(`--workspace-path does not exist: ${resolvedWorkspace}`);
-      }
-      throw err;
-    }
-    options = { ...options, workspacePath: resolvedWorkspace };
-  }
-  if (options.verbose) {
-    console.log(`Repository root: ${repoRoot}`);
-  }
-  let otelExporter = null;
-  const useFileExport = !!(options.otelFile || options.traceFile);
-  if (options.exportOtel || useFileExport) {
-    try {
-      const { OtelTraceExporter, OTEL_BACKEND_PRESETS } = await import("./dist-MQBGD6LP.js");
-      let endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-      let headers = {};
-      if (options.otelBackend) {
-        const preset = OTEL_BACKEND_PRESETS[options.otelBackend];
-        if (preset) {
-          endpoint = preset.endpoint;
-          headers = preset.headers(process.env);
-        } else {
-          console.warn(`Unknown OTel backend preset: ${options.otelBackend}`);
-        }
-      }
-      if (process.env.OTEL_EXPORTER_OTLP_HEADERS) {
-        for (const pair of process.env.OTEL_EXPORTER_OTLP_HEADERS.split(",")) {
-          const [key, ...rest] = pair.split("=");
-          if (key) headers[key.trim()] = rest.join("=").trim();
-        }
-      }
-      const captureContent = options.otelCaptureContent || process.env.AGENTV_OTEL_CAPTURE_CONTENT === "true";
-      otelExporter = new OtelTraceExporter({
-        endpoint,
-        headers,
-        captureContent,
-        groupTurns: options.otelGroupTurns,
-        otlpFilePath: options.otelFile ? path10.resolve(options.otelFile) : void 0,
-        traceFilePath: options.traceFile ? path10.resolve(options.traceFile) : void 0
-      });
-      const initialized = await otelExporter.init();
-      if (!initialized) {
-        console.warn(
-          "OTel export requested but @opentelemetry packages not available. Install them to enable export."
-        );
-        otelExporter = null;
-      }
-    } catch (err) {
-      console.warn(
-        `OTel export initialization failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-      otelExporter = null;
-    }
-  }
-  const outputPath = options.outPath ? path10.resolve(options.outPath) : buildDefaultOutputPath(cwd, options.format);
-  const extraOutputPaths = options.outputPaths.map((p) => path10.resolve(p));
-  const allOutputPaths = extraOutputPaths.length > 0 ? [outputPath, ...extraOutputPaths] : [outputPath];
-  const uniqueOutputPaths = [...new Set(allOutputPaths)];
-  let outputWriter;
-  if (uniqueOutputPaths.length === 1) {
-    outputWriter = await createOutputWriter(outputPath, options.format);
-    console.log(`Output path: ${outputPath}`);
-  } else {
-    outputWriter = await createMultiWriter(uniqueOutputPaths);
-    console.log("Output paths:");
-    for (const p of uniqueOutputPaths) {
-      console.log(`  ${p}`);
-    }
-  }
-  const resolvedTestFiles = input.testFiles.map((file) => path10.resolve(file));
-  if (options.otelFile) {
-    console.log(`OTLP JSON file: ${path10.resolve(options.otelFile)}`);
-  }
-  if (options.traceFile) {
-    console.log(`Trace file: ${path10.resolve(options.traceFile)}`);
-  }
-  const evaluationRunner = await resolveEvaluationRunner();
-  const allResults = [];
-  const seenEvalCases = /* @__PURE__ */ new Set();
-  const displayIdTracker = createDisplayIdTracker();
-  const totalWorkers = options.workers ?? DEFAULT_WORKERS;
-  const fileConcurrency = Math.min(
-    Math.max(1, totalWorkers),
-    Math.max(1, resolvedTestFiles.length)
-  );
-  const perFileWorkers = options.workers ? Math.max(1, Math.floor(totalWorkers / fileConcurrency)) : void 0;
-  const fileMetadata = /* @__PURE__ */ new Map();
-  for (const testFilePath of resolvedTestFiles) {
-    const meta = await prepareFileMetadata({
-      testFilePath,
-      repoRoot,
-      cwd,
-      options
-    });
-    fileMetadata.set(testFilePath, meta);
-  }
-  const firstMeta = fileMetadata.values().next().value;
-  const yamlCacheEnabled = firstMeta?.yamlCache;
-  const yamlCachePath = firstMeta?.yamlCachePath;
-  const cacheEnabled = shouldEnableCache({
-    cliCache: options.cache,
-    cliNoCache: options.noCache,
-    yamlCache: yamlCacheEnabled
-  });
-  const cache = cacheEnabled ? new ResponseCache(yamlCachePath ? path10.resolve(yamlCachePath) : void 0) : void 0;
-  const useCache = cacheEnabled;
-  if (cacheEnabled) {
-    console.log(`Response cache: enabled${yamlCachePath ? ` (${yamlCachePath})` : ""}`);
-  }
-  const isMatrixMode = Array.from(fileMetadata.values()).some((meta) => meta.selections.length > 1);
-  let totalEvalCount = 0;
-  for (const meta of fileMetadata.values()) {
-    const suiteTargetNames = meta.selections.map((s) => s.selection.targetName);
-    for (const test of meta.evalCases) {
-      const testTargetNames = test.targets && test.targets.length > 0 ? test.targets.filter((t) => suiteTargetNames.includes(t)) : suiteTargetNames;
-      totalEvalCount += testTargetNames.length > 0 ? testTargetNames.length : 1;
-    }
-  }
-  if (totalEvalCount === 0) {
-    throw new Error("No tests matched the provided filters.");
-  }
-  const progressReporter = createProgressReporter(totalWorkers, { verbose: options.verbose });
-  progressReporter.start();
-  progressReporter.setTotal(totalEvalCount);
-  const seenCodexLogPaths = /* @__PURE__ */ new Set();
-  const unsubscribeCodexLogs = subscribeToCodexLogEntries((entry) => {
-    if (!entry.filePath || seenCodexLogPaths.has(entry.filePath)) {
-      return;
-    }
-    seenCodexLogPaths.add(entry.filePath);
-    progressReporter.addLogPaths([entry.filePath], "codex");
-  });
-  const seenPiLogPaths = /* @__PURE__ */ new Set();
-  const unsubscribePiLogs = subscribeToPiLogEntries((entry) => {
-    if (!entry.filePath || seenPiLogPaths.has(entry.filePath)) {
-      return;
-    }
-    seenPiLogPaths.add(entry.filePath);
-    progressReporter.addLogPaths([entry.filePath], "pi");
-  });
-  const seenCopilotLogPaths = /* @__PURE__ */ new Set();
-  const unsubscribeCopilotSdkLogs = subscribeToCopilotSdkLogEntries((entry) => {
-    if (!entry.filePath || seenCopilotLogPaths.has(entry.filePath)) {
-      return;
-    }
-    seenCopilotLogPaths.add(entry.filePath);
-    progressReporter.addLogPaths([entry.filePath], "copilot");
-  });
-  const unsubscribeCopilotCliLogs = subscribeToCopilotCliLogEntries((entry) => {
-    if (!entry.filePath || seenCopilotLogPaths.has(entry.filePath)) {
-      return;
-    }
-    seenCopilotLogPaths.add(entry.filePath);
-    progressReporter.addLogPaths([entry.filePath], "copilot");
-  });
-  for (const [testFilePath, meta] of fileMetadata.entries()) {
-    for (const { selection, inlineTargetLabel } of meta.selections) {
-      for (const testId of meta.evalIds) {
-        const evalKey = makeEvalKey(
-          testFilePath,
-          meta.selections.length > 1 ? `${testId}@${selection.targetName}` : testId
-        );
-        seenEvalCases.add(evalKey);
-        const displayId = displayIdTracker.getOrAssign(evalKey);
-        progressReporter.update(displayId, {
-          workerId: displayId,
-          testId: meta.selections.length > 1 ? `${testId}@${selection.targetName}` : testId,
-          status: "pending",
-          targetLabel: inlineTargetLabel
-        });
-      }
-    }
-  }
-  try {
-    await runWithLimit(resolvedTestFiles, fileConcurrency, async (testFilePath) => {
-      const targetPrep = fileMetadata.get(testFilePath);
-      if (!targetPrep) {
-        throw new Error(`Missing metadata for ${testFilePath}`);
-      }
-      const targetResults = await Promise.all(
-        targetPrep.selections.map(async ({ selection, inlineTargetLabel }) => {
-          const targetName = selection.targetName;
-          const applicableEvalCases = targetPrep.selections.length > 1 ? targetPrep.evalCases.filter((test) => {
-            if (test.targets && test.targets.length > 0) {
-              return test.targets.includes(targetName);
-            }
-            return true;
-          }) : targetPrep.evalCases;
-          if (applicableEvalCases.length === 0) {
-            return [];
-          }
-          const result = await runSingleEvalFile({
-            testFilePath,
-            cwd,
-            repoRoot,
-            options,
-            outputWriter,
-            otelExporter,
-            cache,
-            evaluationRunner,
-            workersOverride: perFileWorkers,
-            progressReporter,
-            seenEvalCases,
-            displayIdTracker,
-            selection,
-            inlineTargetLabel,
-            evalCases: applicableEvalCases,
-            trialsConfig: targetPrep.trialsConfig,
-            matrixMode: targetPrep.selections.length > 1,
-            totalBudgetUsd: targetPrep.totalBudgetUsd,
-            failOnError: targetPrep.failOnError
-          });
-          return result.results;
-        })
-      );
-      for (const results of targetResults) {
-        allResults.push(...results);
-      }
-    });
-    progressReporter.finish();
-    if (retryNonErrorResults && retryNonErrorResults.length > 0) {
-      for (const preserved of retryNonErrorResults) {
-        await outputWriter.append(preserved);
-      }
-      allResults.push(...retryNonErrorResults);
-      console.log(
-        `Merged ${retryNonErrorResults.length} non-error result(s) from previous output.`
-      );
-    }
-    const summary = calculateEvaluationSummary(allResults);
-    console.log(formatEvaluationSummary(summary));
-    if (isMatrixMode && allResults.length > 0) {
-      console.log(formatMatrixSummary(allResults));
-    }
-    const failedWithWorkspaces = allResults.filter(
-      (r) => r.workspacePath && (r.error || r.score < 0.5)
-    );
-    if (failedWithWorkspaces.length > 0) {
-      console.log("\nWorkspaces preserved for debugging:");
-      for (const result of failedWithWorkspaces) {
-        console.log(`  ${result.testId}: ${result.workspacePath}`);
-      }
-    }
-    if (allResults.length > 0) {
-      if (uniqueOutputPaths.length === 1) {
-        console.log(`
-Results written to: ${outputPath}`);
-      } else {
-        console.log("\nResults written to:");
-        for (const p of uniqueOutputPaths) {
-          console.log(`  ${p}`);
-        }
-      }
-    }
-  } finally {
-    unsubscribeCodexLogs();
-    unsubscribePiLogs();
-    unsubscribeCopilotSdkLogs();
-    unsubscribeCopilotCliLogs();
-    await outputWriter.close().catch(() => void 0);
-    if (otelExporter) {
-      try {
-        await otelExporter.shutdown();
-      } catch {
-      }
-    }
-  }
-}
-async function resolveEvaluationRunner() {
-  const overridePath = process.env.AGENTEVO_CLI_EVAL_RUNNER;
-  if (!overridePath) {
-    return runEvaluation;
-  }
-  const resolved = path10.isAbsolute(overridePath) ? overridePath : path10.resolve(process.cwd(), overridePath);
-  const moduleUrl = pathToFileURL(resolved).href;
-  const mod = await import(moduleUrl);
-  const candidate = mod.runEvaluation;
-  if (typeof candidate !== "function") {
-    throw new Error(
-      `Module '${resolved}' must export a 'runEvaluation' function to override the default implementation`
-    );
-  }
-  return candidate;
-}
-
-export {
-  package_default,
-  toSnakeCaseDeep,
-  resolveEvalPaths,
-  findRepoRoot,
-  detectFileType,
-  validateEvalFile,
-  validateTargetsFile,
-  validateConfigFile,
-  validateFileReferences,
-  TARGET_FILE_CANDIDATES,
-  fileExists,
-  selectTarget,
-  runEvalCommand
-};
-//# sourceMappingURL=chunk-4MSAOMCC.js.map