agentv 2.6.0 → 2.7.1-next.3

package/dist/chunk-H5FFZCKI.js

@@ -0,0 +1,2957 @@
+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,
+  loadTestSuite,
+  loadTsConfig,
+  normalizeLineEndings,
+  readTargetDefinitions,
+  readTestSuiteMetadata,
+  resolveFileReference,
+  resolveTargetDefinition,
+  runEvaluation,
+  shouldEnableCache,
+  shouldSkipCacheForTemperature,
+  subscribeToCodexLogEntries,
+  subscribeToCopilotSdkLogEntries,
+  subscribeToPiLogEntries
+} from "./chunk-BWLYFF5N.js";
+
+// 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/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.trace?.durationMs ? (r.trace.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/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 scores = results.map((result) => result.score);
+  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: []
+    };
+  }
+  const mean = computeMean(scores);
+  const median = computeMedian(scores);
+  const min = Math.min(...scores);
+  const max = Math.max(...scores);
+  const standardDeviation = computeStandardDeviation(scores);
+  const histogram = buildHistogram(scores);
+  const sortedResults = [...results].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));
+  return {
+    total,
+    mean,
+    median,
+    min,
+    max,
+    standardDeviation,
+    histogram,
+    topResults,
+    bottomResults,
+    errorCount,
+    errors
+  };
+}
+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("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}`);
+  if (summary.errorCount > 0) {
+    lines.push(`Failed: ${summary.errorCount}`);
+    lines.push(`Passed: ${summary.total - summary.errorCount}`);
+  }
+  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)}`);
+  });
+  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_VALUE = /* @__PURE__ */ new Set(["contains", "equals", "regex"]);
+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);
+  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);
+    }
+  }
+  return {
+    valid: errors.filter((e) => e.severity === "error").length === 0,
+    filePath: absolutePath,
+    fileType: "eval",
+    errors
+  };
+}
+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 typeValue = item.type;
+    if (typeValue === void 0 || typeof typeValue !== "string") {
+      errors.push({
+        severity: "warning",
+        filePath,
+        location: `${location}.type`,
+        message: "Assertion item is missing a 'type' field."
+      });
+      continue;
+    }
+    if (!isEvaluatorKind(typeValue)) {
+      errors.push({
+        severity: "warning",
+        filePath,
+        location: `${location}.type`,
+        message: `Unknown assertion type '${typeValue}'.`
+      });
+      continue;
+    }
+    if (ASSERTION_TYPES_WITH_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.`
+          });
+        }
+      }
+    }
+    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 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":
+    case "copilot-sdk":
+    case "copilot_sdk":
+    case "copilot-cli":
+      return COPILOT_SDK_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 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 (!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 commandTemplate = target.command_template ?? target.commandTemplate;
+    if (typeof commandTemplate !== "string" || commandTemplate.trim().length === 0) {
+      errors2.push({
+        severity: "error",
+        filePath: absolutePath2,
+        location: `${location}.commandTemplate`,
+        message: "CLI provider requires 'command_template' or 'commandTemplate' as a non-empty string"
+      });
+    } else {
+      recordUnknownPlaceholders(
+        commandTemplate,
+        absolutePath2,
+        `${location}.commandTemplate`,
+        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 type = healthcheck.type;
+    if (type !== "http" && type !== "command") {
+      errors2.push({
+        severity: "error",
+        filePath: absolutePath2,
+        location: `${location}.type`,
+        message: "healthcheck.type must be either 'http' or 'command'"
+      });
+      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"
+        });
+      }
+    }
+    if (type === "http") {
+      const url = healthcheck.url;
+      if (typeof url !== "string" || url.trim().length === 0) {
+        errors2.push({
+          severity: "error",
+          filePath: absolutePath2,
+          location: `${location}.url`,
+          message: "healthcheck.url must be a non-empty string for http checks"
+        });
+      }
+      return;
+    }
+    const commandTemplate = healthcheck.command_template ?? healthcheck.commandTemplate;
+    if (typeof commandTemplate !== "string" || commandTemplate.trim().length === 0) {
+      errors2.push({
+        severity: "error",
+        filePath: absolutePath2,
+        location: `${location}.commandTemplate`,
+        message: "healthcheck.commandTemplate must be a non-empty string for command checks"
+      });
+    } else {
+      recordUnknownPlaceholders(
+        commandTemplate,
+        absolutePath2,
+        `${location}.commandTemplate`,
+        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_YELLOW = "\x1B[33m";
+var ANSI_RED = "\x1B[31m";
+var ANSI_RESET = "\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_YELLOW}  \u26A0${ANSI_RESET}` : "  \u26A0";
+      const message = useColors ? `${ANSI_YELLOW}${warning.message}${ANSI_RESET}` : 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_RED}  \u2717${ANSI_RESET}` : "  \u2717";
+      const message = useColors ? `${ANSI_RED}${error.message}${ANSI_RESET}` : 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_YELLOW}  \u26A0${ANSI_RESET}` : "  \u26A0";
+      const message = useColors ? `${ANSI_YELLOW}${warning.message}${ANSI_RESET}` : 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_RED}  \u2717${ANSI_RESET}` : "  \u2717";
+      const message = useColors ? `${ANSI_RED}${error.message}${ANSI_RESET}` : 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 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 normalizeOptions(rawOptions, config) {
+  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;
+  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 ?? 120,
+    maxRetries: cliMaxRetries ?? configMaxRetries ?? 2,
+    cache: resolvedCache,
+    noCache: resolvedNoCache,
+    verbose: normalizeBoolean(rawOptions.verbose),
+    keepWorkspaces: normalizeBoolean(rawOptions.keepWorkspaces),
+    cleanupWorkspaces: normalizeBoolean(rawOptions.cleanupWorkspaces),
+    trace: normalizeBoolean(rawOptions.trace),
+    otelFile: normalizeString(rawOptions.otelFile),
+    traceFile: normalizeString(rawOptions.traceFile),
+    exportOtel: normalizeBoolean(rawOptions.exportOtel),
+    otelBackend: normalizeString(rawOptions.otelBackend),
+    otelCaptureContent: normalizeBoolean(rawOptions.otelCaptureContent),
+    otelGroupTurns: normalizeBoolean(rawOptions.otelGroupTurns)
+  };
+}
+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
+  };
+}
+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
+  } = 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 = Math.max(0, options.agentTimeoutSeconds) * 1e3;
+  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,
+    keepWorkspaces: options.keepWorkspaces,
+    cleanupWorkspaces: options.cleanupWorkspaces,
+    trials: trialsConfig,
+    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 options = normalizeOptions(input.rawOptions, config);
+  const repoRoot = await findRepoRoot(cwd);
+  if (options.keepWorkspaces && options.cleanupWorkspaces) {
+    console.warn(
+      "Warning: Both --keep-workspaces and --cleanup-workspaces specified. --cleanup-workspaces takes precedence."
+    );
+  }
+  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-R3OCWGXH.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 unsubscribeCopilotLogs = subscribeToCopilotSdkLogEntries((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}`);
+      }
+      for (const { selection, inlineTargetLabel } of targetPrep.selections) {
+        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) {
+          continue;
+        }
+        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
+        });
+        allResults.push(...result.results);
+      }
+    });
+    progressReporter.finish();
+    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();
+    unsubscribeCopilotLogs();
+    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 {
+  toSnakeCaseDeep,
+  resolveEvalPaths,
+  findRepoRoot,
+  detectFileType,
+  validateEvalFile,
+  validateTargetsFile,
+  validateConfigFile,
+  validateFileReferences,
+  TARGET_FILE_CANDIDATES,
+  fileExists,
+  selectTarget,
+  runEvalCommand
+};
+//# sourceMappingURL=chunk-H5FFZCKI.js.map