@iowarp/clio-coder 0.3.0

package/dist/eval-B3KZZESM.js

@@ -0,0 +1,2674 @@
+import {
+  renderCodewikiDigest
+} from "./chunk-X3BR7HWV.js";
+import {
+  EvalTaskFileError,
+  createEvalId,
+  evalClioProvenance,
+  evalEnvironmentProvenance,
+  loadEvalArtifactV4,
+  loadEvalTaskFile,
+  verifyReceiptIntegrity,
+  writeEvalArtifactV4
+} from "./chunk-7BHLZB3A.js";
+import {
+  detectProjectProfile,
+  enumerateWorkspaceFiles,
+  readCodewiki,
+  structuralCodewikiHash
+} from "./chunk-TPOCL34A.js";
+import "./chunk-WD6AJM35.js";
+import "./chunk-QV47YRF4.js";
+import {
+  shellQuote
+} from "./chunk-GOTUR54M.js";
+import "./chunk-PIDUD6M2.js";
+import {
+  printError
+} from "./chunk-67MTHP2E.js";
+import "./chunk-5LDRNKX2.js";
+import {
+  InvalidIdError
+} from "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import {
+  clioDataDir
+} from "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/eval.ts
+import { resolve as resolve7 } from "node:path";
+
+// src/domains/eval/compare/compare.ts
+function compareEvalArtifactsV4(baseline, candidate) {
+  const baselineTokens = baseline.summary.tokens;
+  const candidateTokens = candidate.summary.tokens;
+  return {
+    baselineEvalId: baseline.evalId,
+    candidateEvalId: candidate.evalId,
+    passRateDelta: candidate.summary.passRate - baseline.summary.passRate,
+    tokenDelta: baselineTokens.measured && candidateTokens.measured ? candidateTokens.total - baselineTokens.total : null,
+    wallTimeDelta: candidate.summary.wallTimeMs - baseline.summary.wallTimeMs
+  };
+}
+function renderEvalComparisonV4(summary) {
+  return [
+    `baseline eval: ${summary.baselineEvalId}`,
+    `candidate eval: ${summary.candidateEvalId}`,
+    `pass-rate delta: ${(summary.passRateDelta * 100).toFixed(2)}%`,
+    `token delta: ${summary.tokenDelta === null ? "unmeasured" : summary.tokenDelta}`,
+    `wall-time delta ms: ${summary.wallTimeDelta}`,
+    ""
+  ].join("\n");
+}
+
+// src/domains/eval/compare/thresholds.ts
+import { readFileSync } from "node:fs";
+import { parse as parseYaml } from "yaml";
+function loadThresholds(path) {
+  const parsed = parseYaml(readFileSync(path, "utf8"));
+  if (isRecord(parsed) && Array.isArray(parsed.fail)) return { fail: parsed.fail };
+  if (isRecord(parsed) && isRecord(parsed.thresholds) && Array.isArray(parsed.thresholds.fail)) {
+    return { fail: parsed.thresholds.fail };
+  }
+  throw new Error(`invalid thresholds file: ${path}`);
+}
+function resolveMetricAssertion(assertion, metrics, artifact) {
+  const actual = metricValue(assertion.metric, metrics, artifact);
+  return { actual, unresolved: actual === null, holds: comparisonHolds(assertion, actual) };
+}
+function comparisonHolds(assertion, actual) {
+  switch (assertion.op) {
+    case "lt":
+      return typeof actual === "number" && typeof assertion.value === "number" && actual < assertion.value;
+    case "lte":
+      return typeof actual === "number" && typeof assertion.value === "number" && actual <= assertion.value;
+    case "gt":
+      return typeof actual === "number" && typeof assertion.value === "number" && actual > assertion.value;
+    case "gte":
+      return typeof actual === "number" && typeof assertion.value === "number" && actual >= assertion.value;
+    case "eq":
+      return actual === assertion.value;
+    case "neq":
+      return actual !== assertion.value;
+  }
+}
+function metricValue(metric, metrics, artifact) {
+  if (metric in metrics) return metrics[metric];
+  if (artifact !== void 0) {
+    if (metric === "result.pass") return artifact.summary.failed === 0;
+    if (metric === "latency.wallMs") return artifact.summary.wallTimeMs;
+    if (metric === "tokens.total") return artifact.summary.tokens.measured ? artifact.summary.tokens.total : null;
+    if (metric.startsWith("summary.")) return summaryValue(artifact, metric.slice("summary.".length));
+  }
+  return null;
+}
+function summaryValue(artifact, path) {
+  let current = artifact.summary;
+  for (const segment of path.split(".")) {
+    if (!isRecord(current) || !(segment in current)) return null;
+    current = current[segment];
+  }
+  return typeof current === "number" || typeof current === "string" || typeof current === "boolean" ? current : null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/domains/eval/compare/gates.ts
+function evaluateGate(artifact, thresholds) {
+  const failures = [];
+  for (const assertion of thresholds.fail) {
+    const whole = resolveMetricAssertion(assertion, {}, artifact);
+    if (!whole.unresolved) {
+      if (whole.holds) failures.push({ assertion, actual: whole.actual, unresolved: false });
+      continue;
+    }
+    if (artifact.results.length === 0) {
+      failures.push({ assertion, actual: null, unresolved: true });
+      continue;
+    }
+    for (const result of artifact.results) {
+      const perRun = resolveMetricAssertion(assertion, result.metrics);
+      if (!perRun.unresolved && !perRun.holds) continue;
+      failures.push({
+        assertion,
+        actual: perRun.actual,
+        unresolved: perRun.unresolved,
+        taskId: result.taskId,
+        repeatIndex: result.repeatIndex
+      });
+    }
+  }
+  return { pass: failures.length === 0, failures };
+}
+function renderGateFailure(failure) {
+  const run = failure.taskId === void 0 ? "" : ` [${failure.taskId}#${failure.repeatIndex ?? 0}]`;
+  const { metric, op, value } = failure.assertion;
+  return failure.unresolved ? `  ${metric}${run}: unresolved metric (fail closed)
+` : `  ${metric} ${op} ${JSON.stringify(value)}${run}: actual ${JSON.stringify(failure.actual)}
+`;
+}
+
+// src/domains/eval/reports/json.ts
+function renderEvalJsonReportV4(artifact) {
+  return `${JSON.stringify(artifact, null, 2)}
+`;
+}
+
+// src/domains/eval/reports/junit.ts
+function renderEvalJunitReportV4(artifact) {
+  const cases = artifact.results.map((result) => {
+    const name = escapeXml(
+      `${result.taskId}[${result.target.id}:${result.target.model ?? "default"}:${result.repeatIndex}]`
+    );
+    if (result.pass) return `  <testcase name="${name}" />`;
+    return `  <testcase name="${name}"><failure message="${escapeXml(result.failureClass ?? "failed")}" /></testcase>`;
+  }).join("\n");
+  return [
+    `<testsuite name="${escapeXml(artifact.suite.id)}" tests="${artifact.summary.runs}" failures="${artifact.summary.failed}">`,
+    cases,
+    "</testsuite>",
+    ""
+  ].join("\n");
+}
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+
+// src/domains/eval/reports/markdown.ts
+function renderEvalMarkdownReportV4(artifact) {
+  const lines = [
+    `# Eval ${artifact.evalId}`,
+    "",
+    `Suite: ${artifact.suite.id}`,
+    `Target: ${artifact.matrix.target}`,
+    `Pass rate: ${(artifact.summary.passRate * 100).toFixed(2)}%`,
+    "",
+    "| Task | Target | Model | Repeat | Pass | Failure |",
+    "|---|---|---|---:|---|---|",
+    ...artifact.results.map(
+      (result) => `| ${result.taskId} | ${result.target.id} | ${result.target.model ?? ""} | ${result.repeatIndex} | ${result.pass ? "pass" : "fail"} | ${result.failureClass ?? ""} |`
+    ),
+    ""
+  ];
+  return `${lines.join("\n")}`;
+}
+
+// src/domains/eval/reports/swe-jsonl.ts
+function renderEvalSweJsonlReportV4(artifact) {
+  return artifact.results.map(
+    (result) => JSON.stringify({
+      instance_id: result.taskId,
+      model_name_or_path: artifact.matrix.model ?? artifact.matrix.target,
+      model_patch: typeof result.artifacts.patch === "string" ? result.artifacts.patch : "",
+      status: result.pass ? "pass" : "fail",
+      pass: result.pass
+    })
+  ).join("\n").concat(artifact.results.length === 0 ? "" : "\n");
+}
+
+// src/domains/eval/reports/text.ts
+function renderEvalTextReportV4(artifact) {
+  const tokens = artifact.summary.tokens;
+  return [
+    `eval: ${artifact.evalId}`,
+    `suite: ${artifact.suite.id}`,
+    `target: ${artifact.matrix.target}`,
+    `model: ${artifact.matrix.model ?? "none"}`,
+    `runs: ${artifact.summary.runs}`,
+    `passed: ${artifact.summary.passed}`,
+    `failed: ${artifact.summary.failed}`,
+    `pass rate: ${(artifact.summary.passRate * 100).toFixed(2)}%`,
+    // A run whose child Clio work is out of the harness's sight has no token
+    // count. Saying "0" would claim it cost nothing, so the count is
+    // reported next to how many runs it actually covers.
+    !tokens.measured ? `tokens total: unmeasured (0 of ${tokens.runs} runs reported usage)` : tokens.measuredRuns === tokens.runs ? `tokens total: ${tokens.total}` : `tokens total: ${tokens.total} (measured in ${tokens.measuredRuns} of ${tokens.runs} runs)`,
+    `wall time ms: ${artifact.summary.wallTimeMs}`,
+    ""
+  ].join("\n");
+}
+
+// src/domains/eval/suites/load.ts
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { parse as parseYaml2 } from "yaml";
+
+// src/domains/eval/schema/suite.ts
+var EVAL_SUITE_V2_VERSION = 2;
+
+// src/domains/eval/schema/validate.ts
+var RUNNER_KINDS = /* @__PURE__ */ new Set(["clio-run", "context-index", "context-init", "external-command"]);
+var WORKSPACE_KINDS = /* @__PURE__ */ new Set(["local", "git", "temp-copy"]);
+var OPS = /* @__PURE__ */ new Set(["lt", "lte", "gt", "gte", "eq", "neq"]);
+function validateEvalSuiteV2(value) {
+  const issues = [];
+  if (!isRecord2(value)) return { valid: false, issues: [{ path: "$", message: "expected object" }] };
+  if (value.version !== EVAL_SUITE_V2_VERSION) issues.push({ path: "$.version", message: "expected version 2" });
+  const suite = readSuiteInfo(value.suite, "$.suite", issues);
+  const matrix = readMatrix(value.matrix, "$.matrix", issues);
+  const tasks = readTasks(value.tasks, "$.tasks", issues);
+  const thresholds = readThresholds(value.thresholds, "$.thresholds", issues);
+  if (issues.length > 0 || suite === null || matrix === null || tasks === null) return { valid: false, issues };
+  return {
+    valid: true,
+    suite: {
+      version: 2,
+      suite,
+      matrix,
+      tasks,
+      ...thresholds === void 0 ? {} : { thresholds }
+    }
+  };
+}
+function readSuiteInfo(value, path, issues) {
+  if (!isRecord2(value)) {
+    issues.push({ path, message: "expected object" });
+    return null;
+  }
+  const id = readId(value, path, "id", issues);
+  const title = readNonEmptyString(value, path, "title", issues);
+  const visibility = readNonEmptyString(value, path, "visibility", issues);
+  if (id === null || title === null || visibility === null) return null;
+  const description = optionalString(value, "description");
+  const provenance = isRecord2(value.provenance) ? value.provenance : void 0;
+  return {
+    id,
+    title,
+    visibility,
+    ...description === void 0 ? {} : { description },
+    ...provenance ? { provenance } : {}
+  };
+}
+function readMatrix(value, path, issues) {
+  if (!isRecord2(value)) {
+    issues.push({ path, message: "expected object" });
+    return null;
+  }
+  const repeats = readPositiveInteger(value, path, "repeats", issues);
+  if (!Array.isArray(value.targets) || value.targets.length === 0) {
+    issues.push({ path: `${path}.targets`, message: "expected non-empty array" });
+    return null;
+  }
+  const targets = value.targets.flatMap((target, index) => {
+    if (!isRecord2(target)) {
+      issues.push({ path: `${path}.targets[${index}]`, message: "expected object" });
+      return [];
+    }
+    const id = readId(target, `${path}.targets[${index}]`, "id", issues);
+    if (id === null) return [];
+    const suiteTarget = { id };
+    const model = optionalString(target, "model");
+    const thinking = optionalString(target, "thinking");
+    return [
+      { ...suiteTarget, ...model === void 0 ? {} : { model }, ...thinking === void 0 ? {} : { thinking } }
+    ];
+  });
+  if (repeats === null || targets.length === 0) return null;
+  const maxCostUsd = value.maxCostUsd;
+  if (maxCostUsd !== void 0 && (typeof maxCostUsd !== "number" || !Number.isFinite(maxCostUsd) || maxCostUsd < 0)) {
+    issues.push({ path: `${path}.maxCostUsd`, message: "expected non-negative number" });
+    return null;
+  }
+  return { targets, repeats, ...maxCostUsd === void 0 ? {} : { maxCostUsd } };
+}
+function readTasks(value, path, issues) {
+  if (!Array.isArray(value) || value.length === 0) {
+    issues.push({ path, message: "expected non-empty array" });
+    return null;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const tasks = [];
+  for (let index = 0; index < value.length; index += 1) {
+    const task = readTask(value[index], `${path}[${index}]`, issues);
+    if (task === null) continue;
+    if (seen.has(task.id)) issues.push({ path: `${path}[${index}].id`, message: `duplicate task id: ${task.id}` });
+    seen.add(task.id);
+    tasks.push(task);
+  }
+  return tasks.length > 0 ? tasks : null;
+}
+function readTask(value, path, issues) {
+  if (!isRecord2(value)) {
+    issues.push({ path, message: "expected object" });
+    return null;
+  }
+  const id = readId(value, path, "id", issues);
+  const workspace = readWorkspace(value.workspace, `${path}.workspace`, issues);
+  const runner = readRunner(value.runner, `${path}.runner`, issues);
+  const timeoutMs = readPositiveInteger(value, path, "timeoutMs", issues);
+  if (id === null || workspace === null || runner === null || timeoutMs === null) return null;
+  return {
+    id,
+    tags: readOptionalStringArray(value, "tags", `${path}.tags`, issues),
+    workspace,
+    runner,
+    verify: readVerify(value.verify, `${path}.verify`, issues),
+    metrics: readMetrics(value.metrics, `${path}.metrics`, issues),
+    timeoutMs
+  };
+}
+function readWorkspace(value, path, issues) {
+  if (!isRecord2(value)) {
+    issues.push({ path, message: "expected object" });
+    return null;
+  }
+  const kind = value.kind;
+  if (typeof kind !== "string" || !WORKSPACE_KINDS.has(kind)) {
+    issues.push({ path: `${path}.kind`, message: "expected local, git, or temp-copy" });
+    return null;
+  }
+  const pathValue = optionalString(value, "path");
+  const url = optionalString(value, "url");
+  const commit = optionalString(value, "commit");
+  const checkout = optionalString(value, "checkout");
+  return {
+    kind,
+    ...pathValue === void 0 ? {} : { path: pathValue },
+    ...url === void 0 ? {} : { url },
+    ...commit === void 0 ? {} : { commit },
+    ...checkout === void 0 ? {} : { checkout },
+    excludes: readOptionalStringArray(value, "excludes", `${path}.excludes`, issues),
+    setup: readOptionalStringArray(value, "setup", `${path}.setup`, issues)
+  };
+}
+function readRunner(value, path, issues) {
+  if (!isRecord2(value)) {
+    issues.push({ path, message: "expected object" });
+    return null;
+  }
+  const kind = value.kind;
+  if (typeof kind !== "string" || !RUNNER_KINDS.has(kind)) {
+    issues.push({ path: `${path}.kind`, message: "expected clio-run, context-index, context-init, or external-command" });
+    return null;
+  }
+  const prompt = optionalString(value, "prompt");
+  const agent = optionalString(value, "agent");
+  if (agent !== void 0 && kind !== "clio-run") {
+    issues.push({ path: `${path}.agent`, message: "agent is only valid on the clio-run runner" });
+  }
+  const command = optionalString(value, "command");
+  return {
+    kind,
+    ...prompt === void 0 ? {} : { prompt },
+    ...agent === void 0 ? {} : { agent },
+    ...command === void 0 ? {} : { command },
+    commands: readOptionalStringArray(value, "commands", `${path}.commands`, issues),
+    args: readOptionalStringArray(value, "args", `${path}.args`, issues),
+    ...typeof value.timeoutMs === "number" ? { timeoutMs: value.timeoutMs } : {}
+  };
+}
+function readVerify(value, path, issues) {
+  if (value === void 0) return {};
+  if (!isRecord2(value)) {
+    issues.push({ path, message: "expected object" });
+    return {};
+  }
+  return {
+    commands: readOptionalStringArray(value, "commands", `${path}.commands`, issues),
+    measure: readOptionalStringArray(value, "measure", `${path}.measure`, issues),
+    assertions: readAssertions(value.assertions, `${path}.assertions`, issues),
+    forbidPaths: readOptionalStringArray(value, "forbidPaths", `${path}.forbidPaths`, issues)
+  };
+}
+function readMetrics(value, path, issues) {
+  if (value === void 0) return { collect: [] };
+  if (!isRecord2(value)) {
+    issues.push({ path, message: "expected object" });
+    return { collect: [] };
+  }
+  return { collect: readOptionalStringArray(value, "collect", `${path}.collect`, issues) };
+}
+function readThresholds(value, path, issues) {
+  if (value === void 0) return void 0;
+  if (!isRecord2(value)) {
+    issues.push({ path, message: "expected object" });
+    return void 0;
+  }
+  return { fail: readAssertions(value.fail, `${path}.fail`, issues) };
+}
+function readAssertions(value, path, issues) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    issues.push({ path, message: "expected array" });
+    return [];
+  }
+  const out = [];
+  for (let index = 0; index < value.length; index += 1) {
+    const entry = value[index];
+    if (!isRecord2(entry)) {
+      issues.push({ path: `${path}[${index}]`, message: "expected object" });
+      continue;
+    }
+    const metric = readNonEmptyString(entry, `${path}[${index}]`, "metric", issues);
+    const op = entry.op;
+    if (typeof op !== "string" || !OPS.has(op)) {
+      issues.push({ path: `${path}[${index}].op`, message: "expected lt, lte, gt, gte, eq, or neq" });
+      continue;
+    }
+    const valueField = entry.value;
+    if (metric === null || !["number", "string", "boolean"].includes(typeof valueField)) {
+      issues.push({ path: `${path}[${index}].value`, message: "expected number, string, or boolean" });
+      continue;
+    }
+    out.push({ metric, op, value: valueField });
+  }
+  return out;
+}
+function readId(record, path, field, issues) {
+  const value = readNonEmptyString(record, path, field, issues);
+  if (value !== null && !/^[A-Za-z0-9._-]+$/.test(value)) {
+    issues.push({
+      path: `${path}.${field}`,
+      message: "expected id with letters, numbers, dots, underscores, or hyphens"
+    });
+  }
+  return value;
+}
+function readNonEmptyString(record, path, field, issues) {
+  const value = record[field];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    issues.push({ path: `${path}.${field}`, message: "expected non-empty string" });
+    return null;
+  }
+  return value;
+}
+function readPositiveInteger(record, path, field, issues) {
+  const value = record[field];
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    issues.push({ path: `${path}.${field}`, message: "expected positive integer" });
+    return null;
+  }
+  return value;
+}
+function readOptionalStringArray(record, field, path, issues) {
+  const value = record[field];
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    issues.push({ path, message: "expected string array" });
+    return [];
+  }
+  return value.flatMap((entry, index) => {
+    if (typeof entry === "string" && entry.trim().length > 0) return [entry];
+    issues.push({ path: `${path}[${index}]`, message: "expected non-empty string" });
+    return [];
+  });
+}
+function optionalString(record, field) {
+  const value = record[field];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/domains/eval/suites/load.ts
+var EvalSuiteFileError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`eval suite invalid (${issues.length} ${issues.length === 1 ? "issue" : "issues"})`);
+    this.name = "EvalSuiteFileError";
+    this.issues = [...issues];
+  }
+};
+async function loadEvalSuiteFile(path) {
+  const resolved = resolve(path);
+  const raw = await readFile(resolved, "utf8");
+  let parsed;
+  try {
+    parsed = parseYaml2(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new EvalSuiteFileError([{ path: "$", message: `invalid YAML: ${message}` }]);
+  }
+  const result = validateEvalSuiteV2(parsed);
+  if (!result.valid) throw new EvalSuiteFileError(result.issues);
+  return {
+    path: resolved,
+    baseDir: dirname(resolved),
+    hash: sha256Hex(raw),
+    suite: result.suite
+  };
+}
+async function loadV1TaskFileAsSuite(path, repeatOverride) {
+  const loaded = await loadEvalTaskFile(path);
+  const suite = {
+    version: 2,
+    suite: {
+      id: "v1-task-file",
+      title: "v1 task file",
+      visibility: "local",
+      description: "Compatibility adapter for version 1 eval task files.",
+      provenance: { taskFileVersion: 1 }
+    },
+    matrix: {
+      targets: [{ id: "local" }],
+      repeats: repeatOverride ?? 1
+    },
+    tasks: loaded.taskFile.tasks.map((task) => ({
+      id: task.id,
+      tags: task.tags,
+      workspace: { kind: "local", path: task.cwd },
+      runner: { kind: "external-command", commands: task.setup },
+      verify: { commands: task.verifier },
+      metrics: { collect: ["latency.wallMs", "verifier.exitCode"] },
+      timeoutMs: task.timeoutMs
+    }))
+  };
+  return {
+    path: loaded.path,
+    baseDir: loaded.baseDir,
+    hash: loaded.contentHash,
+    suite
+  };
+}
+function sha256Hex(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+
+// src/domains/eval/suites/resolve.ts
+function resolveSuiteForRun(suite, options) {
+  const targets = resolveTargets(suite.matrix.targets, options);
+  return {
+    ...suite,
+    matrix: {
+      ...suite.matrix,
+      targets
+    }
+  };
+}
+function artifactMatrixIdentity(targets) {
+  if (targets.length === 1) {
+    const target = targets[0];
+    return {
+      target: target?.id ?? "unknown",
+      model: target?.model ?? null,
+      thinking: target?.thinking ?? null
+    };
+  }
+  return { target: "multiple", model: null, thinking: null };
+}
+function resolveTargets(targets, options) {
+  const filtered = options.target === void 0 ? [...targets] : targets.filter((target) => target.id === options.target);
+  const selected = filtered.length > 0 ? filtered : options.target === void 0 ? [...targets] : [{ id: options.target }];
+  return selected.map((target) => ({
+    ...target,
+    ...options.model === void 0 ? {} : { model: options.model }
+  }));
+}
+
+// src/domains/eval/suites/run.ts
+import { mkdtemp as mkdtemp3, rm as rm3 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import { resolve as resolve6 } from "node:path";
+
+// src/domains/eval/metrics/context.ts
+function collectContextMetrics(cwd) {
+  try {
+    const codewiki = readCodewiki(cwd);
+    if (!codewiki) throw new Error("codewiki unavailable");
+    const visiblePaths = new Set(enumerateWorkspaceFiles(cwd));
+    const artifactSourceFiles = codewiki.files.filter((file) => file.lang !== "config");
+    const indexedFiles = artifactSourceFiles.filter((file) => visiblePaths.has(file.path)).length;
+    const staleFiles = artifactSourceFiles.length - indexedFiles;
+    const sourceFiles = detectProjectProfile(cwd).sourceFiles;
+    const digest = renderCodewikiDigest(codewiki);
+    return {
+      "context.indexedFiles": indexedFiles,
+      "context.artifactFiles": artifactSourceFiles.length,
+      "context.staleFiles": staleFiles,
+      "context.coverage": sourceFiles === 0 ? artifactSourceFiles.length === 0 ? 1 : 0 : indexedFiles / sourceFiles,
+      "context.structuralHash": structuralCodewikiHash(codewiki),
+      "context.digestTokens": Math.ceil(digest.length / 4)
+    };
+  } catch {
+    return {
+      "context.indexedFiles": 0,
+      "context.artifactFiles": 0,
+      "context.staleFiles": 0,
+      "context.coverage": 0,
+      "context.structuralHash": null,
+      "context.digestTokens": 0
+    };
+  }
+}
+
+// src/domains/eval/metrics/fleet-loop-stream.ts
+var EMPTY_FLEET_LOOP_OBSERVATION = { summaryCount: 0, loops: [] };
+var DECLARED_LOOP_REASONS = /* @__PURE__ */ new Set([
+  "resolved",
+  "loop_bound_exhausted",
+  "loop_step_failed",
+  "loop_not_reached"
+]);
+function createFleetLoopFold() {
+  let summaryCount = 0;
+  let loops = [];
+  let pending = "";
+  const consume = (line) => {
+    if (line.trim().length === 0) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (!isRecord3(parsed) || typeof parsed.fleet !== "string" || !Array.isArray(parsed.loops)) return;
+    summaryCount += 1;
+    const unneeded = Array.isArray(parsed.unneeded) ? parsed.unneeded.length : 0;
+    const skipped = Array.isArray(parsed.skipped) ? parsed.skipped.length : 0;
+    loops = parsed.loops.flatMap((entry) => {
+      const loop = parseLoop(entry, unneeded, skipped);
+      return loop === null ? [] : [loop];
+    });
+  };
+  return {
+    push(chunk) {
+      pending += chunk;
+      for (; ; ) {
+        const newline = pending.indexOf("\n");
+        if (newline === -1) break;
+        consume(pending.slice(0, newline).replace(/\r$/u, ""));
+        pending = pending.slice(newline + 1);
+      }
+    },
+    observation() {
+      if (pending.length > 0) {
+        consume(pending.replace(/\r$/u, ""));
+        pending = "";
+      }
+      return { summaryCount, loops: loops.map((loop) => ({ ...loop })) };
+    }
+  };
+}
+function addFleetLoopObservations(left, right) {
+  const summaryCount = left.summaryCount + right.summaryCount;
+  return { summaryCount, loops: summaryCount === 1 ? [...left.loops, ...right.loops] : [] };
+}
+function fleetLoopMetricEntries(observation) {
+  if (observation.summaryCount !== 1 || observation.loops.length === 0) return {};
+  const loops = observation.loops;
+  return {
+    "loop.count": loops.length,
+    "loop.attemptsSpent": sum(loops.map((loop) => loop.attempts)),
+    "loop.repairsSpent": sum(loops.map((loop) => loop.repairs)),
+    "loop.resolved": loops.every((loop) => loop.resolved),
+    "loop.reasonExhausted": loops.every((loop) => loop.resolved || loop.reason === "loop_bound_exhausted"),
+    "loop.reasonDeclared": loops.every(
+      (loop) => DECLARED_LOOP_REASONS.has(loop.reason) && loop.resolved === (loop.reason === "resolved")
+    ),
+    "loop.unneededNodes": loops[0]?.unneeded ?? 0,
+    "loop.skippedNodes": loops[0]?.skipped ?? 0
+  };
+}
+function fleetLoopReceiptAgreement(loopMetrics, journalMetrics) {
+  const repairs = loopMetrics["loop.repairsSpent"];
+  const recoveries = journalMetrics["receipt.recoveryCount"];
+  if (typeof repairs !== "number" || typeof recoveries !== "number") return {};
+  return { "loop.receiptsMatchRepairs": repairs === recoveries };
+}
+function parseLoop(entry, unneeded, skipped) {
+  if (!isRecord3(entry)) return null;
+  const { attempts, repairs, resolved, reason } = entry;
+  if (!isFiniteInteger(attempts) || attempts < 0) return null;
+  if (!isFiniteInteger(repairs) || repairs < 0) return null;
+  if (typeof resolved !== "boolean" || typeof reason !== "string" || reason.length === 0) return null;
+  return { attempts, repairs, resolved, reason, unneeded, skipped };
+}
+function sum(values) {
+  return values.reduce((total, value) => total + value, 0);
+}
+function isFiniteInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/domains/eval/metrics/invariants.ts
+import { existsSync, readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { join } from "node:path";
+function readRunJournal(stateDir) {
+  if (!existsSync(stateDir)) return null;
+  return {
+    envelopes: readEnvelopes(join(stateDir, "runs.json")),
+    ...readReceipts(join(stateDir, "receipts"))
+  };
+}
+function readEnvelopes(runsPath) {
+  const envelopes = /* @__PURE__ */ new Map();
+  if (!existsSync(runsPath)) return envelopes;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(runsPath, "utf8"));
+  } catch {
+    return envelopes;
+  }
+  if (!Array.isArray(parsed)) return envelopes;
+  for (const entry of parsed) {
+    if (isRecord4(entry) && typeof entry.id === "string") envelopes.set(entry.id, entry);
+  }
+  return envelopes;
+}
+function readReceipts(receiptsDir) {
+  if (!existsSync(receiptsDir)) return { receipts: [], receiptFiles: 0 };
+  let names;
+  try {
+    names = readdirSync(receiptsDir).filter((name) => name.endsWith(".json"));
+  } catch {
+    return { receipts: [], receiptFiles: 0 };
+  }
+  const receipts = [];
+  for (const name of names) {
+    try {
+      const parsed = JSON.parse(readFileSync2(join(receiptsDir, name), "utf8"));
+      if (isReceiptShaped(parsed)) receipts.push(parsed);
+    } catch {
+    }
+  }
+  return { receipts, receiptFiles: names.length };
+}
+function receiptInvariantMetrics(journal, processExitCode) {
+  if (journal === null) return {};
+  const sealed = journal.receiptFiles > 0;
+  const roots = journal.receipts.filter(isRootReceipt);
+  const base = {
+    "receipt.count": journal.receiptFiles,
+    "receipt.sealed": sealed,
+    "receipt.rootCount": roots.length,
+    // Every attempt after the first is `recovery`. A bounded loop's repairs
+    // are exactly those attempts, so this is what a loop's attempt accounting
+    // is checked against.
+    "receipt.recoveryCount": journal.receipts.filter((receipt) => receipt.executionRole === "recovery").length
+  };
+  if (!sealed) return base;
+  return {
+    ...base,
+    "receipt.integrityValid": integrityValid(journal),
+    "receipt.outcomeMatchesExit": outcomeMatchesExit(journal, roots, processExitCode)
+  };
+}
+function receiptUsageMetrics(journal) {
+  if (journal === null) return {};
+  if (journal.receiptFiles === 0) return { "receiptUsage.measured": false };
+  if (!integrityValid(journal)) return { "receiptUsage.measured": false };
+  let totalTokens = 0;
+  let costUsd = 0;
+  for (const receipt of journal.receipts) {
+    totalTokens += finiteNumber(receipt.tokenCount);
+    costUsd += finiteNumber(receipt.costUsd);
+  }
+  return {
+    "receiptUsage.measured": true,
+    "receiptUsage.receiptCount": journal.receipts.length,
+    "receiptUsage.totalTokens": totalTokens,
+    "receiptUsage.costUsd": costUsd
+  };
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function integrityValid(journal) {
+  if (journal.receipts.length !== journal.receiptFiles) return false;
+  return journal.receipts.every((receipt) => {
+    const envelope = journal.envelopes.get(receipt.runId);
+    if (envelope === void 0) return false;
+    return verifyReceiptIntegrity(receipt, envelope).ok;
+  });
+}
+function outcomeMatchesExit(journal, roots, processExitCode) {
+  if (journal.receipts.length !== journal.receiptFiles) return false;
+  const selfConsistent = journal.receipts.every(
+    (receipt) => receipt.outcome === "succeeded" === (receipt.exitCode === 0)
+  );
+  if (!selfConsistent) return false;
+  const root = roots.length === 1 ? roots[0] : void 0;
+  if (root === void 0) return true;
+  return root.exitCode === 0 === (processExitCode === 0);
+}
+function isRootReceipt(receipt) {
+  return receipt.lineage === void 0 || receipt.lineage.rootRunId === receipt.runId;
+}
+function sessionInvariantMetrics(stateDir) {
+  const sessionDirs = findSessionDirs(join(stateDir, "sessions"));
+  if (sessionDirs.length === 0) return {};
+  let formatVersion = Number.POSITIVE_INFINITY;
+  let toolPairsUnmatched = 0;
+  let assistantBetweenCallAndResult = 0;
+  let compactionSummaryPresent = false;
+  let answeredFromPreCompaction = false;
+  let turnsAfterCompaction = 0;
+  for (const sessionDir of sessionDirs) {
+    const transcript = readSessionTranscript(join(sessionDir, "current.jsonl"));
+    formatVersion = Math.min(formatVersion, transcript.formatVersion);
+    toolPairsUnmatched += transcript.toolPairsUnmatched;
+    assistantBetweenCallAndResult += transcript.assistantBetweenCallAndResult;
+    compactionSummaryPresent ||= transcript.compactionSummaryPresent;
+    answeredFromPreCompaction ||= transcript.answeredFromPreCompaction;
+    turnsAfterCompaction += transcript.turnsAfterCompaction;
+  }
+  return {
+    "ledger.formatVersion": formatVersion,
+    "ledger.toolPairsUnmatched": toolPairsUnmatched,
+    "ledger.assistantBetweenCallAndResult": assistantBetweenCallAndResult,
+    "ledger.sessionCount": sessionDirs.length,
+    "continuity.compactionSummaryPresent": compactionSummaryPresent,
+    "continuity.answeredFromPreCompaction": answeredFromPreCompaction,
+    "continuity.turnsAfterCompaction": turnsAfterCompaction
+  };
+}
+function findSessionDirs(sessionsRoot) {
+  try {
+    const dirs = [];
+    for (const cwdDir of readdirSync(sessionsRoot, { withFileTypes: true })) {
+      if (!cwdDir.isDirectory()) continue;
+      const cwdPath = join(sessionsRoot, cwdDir.name);
+      try {
+        for (const sessionDir of readdirSync(cwdPath, { withFileTypes: true })) {
+          if (sessionDir.isDirectory()) dirs.push(join(cwdPath, sessionDir.name));
+        }
+      } catch {
+      }
+    }
+    return dirs;
+  } catch {
+    return [];
+  }
+}
+function readSessionTranscript(path) {
+  let lines;
+  try {
+    lines = readFileSync2(path, "utf8").split(/\r?\n/u);
+  } catch {
+    return {
+      formatVersion: 0,
+      toolPairsUnmatched: 0,
+      assistantBetweenCallAndResult: 0,
+      compactionSummaryPresent: false,
+      answeredFromPreCompaction: false,
+      turnsAfterCompaction: 0
+    };
+  }
+  const entries = lines.map(parseJsonRecord);
+  const header = entries[0];
+  const formatVersion = header?.type === "session" && Number.isInteger(header.version) && header.version > 0 ? header.version : 0;
+  const pendingCalls = /* @__PURE__ */ new Map();
+  let invalidCalls = 0;
+  let orphanResults = 0;
+  let assistantGeneration = 0;
+  let assistantBetweenCallAndResult = 0;
+  const readCalls = /* @__PURE__ */ new Map();
+  const completedReads = [];
+  let latestCompactionIndex = -1;
+  for (const [entryIndex, entry] of entries.entries()) {
+    if (isCompactionSummary(entry)) latestCompactionIndex = entryIndex;
+    if (entry?.kind !== "message") continue;
+    if (entry.role === "assistant") {
+      assistantGeneration += 1;
+      continue;
+    }
+    if (entry.role !== "tool_call" && entry.role !== "tool_result") continue;
+    const payload = isRecord4(entry.payload) ? entry.payload : void 0;
+    const toolCallId = payload?.toolCallId;
+    if (entry.role === "tool_call") {
+      if (typeof toolCallId !== "string" || toolCallId.length === 0) {
+        invalidCalls += 1;
+        continue;
+      }
+      const calls2 = pendingCalls.get(toolCallId) ?? [];
+      calls2.push(assistantGeneration);
+      pendingCalls.set(toolCallId, calls2);
+      if (payload?.name === "read") {
+        const args = isRecord4(payload.args) ? payload.args : void 0;
+        const readPath2 = args?.path;
+        if (typeof readPath2 === "string" && readPath2.trim().length > 0) {
+          const paths = readCalls.get(toolCallId) ?? [];
+          paths.push(readPath2.trim());
+          readCalls.set(toolCallId, paths);
+        }
+      }
+      continue;
+    }
+    if (typeof toolCallId !== "string" || toolCallId.length === 0) {
+      orphanResults += 1;
+      continue;
+    }
+    const calls = pendingCalls.get(toolCallId);
+    const callGeneration = calls?.shift();
+    if (callGeneration === void 0) {
+      orphanResults += 1;
+      continue;
+    }
+    if (calls?.length === 0) pendingCalls.delete(toolCallId);
+    if (assistantGeneration > callGeneration) assistantBetweenCallAndResult += 1;
+    const readPaths = readCalls.get(toolCallId);
+    const readPath = readPaths?.shift();
+    if (readPaths?.length === 0) readCalls.delete(toolCallId);
+    if (readPath !== void 0 && payload?.isError !== true) completedReads.push({ path: readPath, entryIndex });
+  }
+  let danglingCalls = invalidCalls;
+  for (const calls of pendingCalls.values()) danglingCalls += calls.length;
+  const pathsReadBeforeCompaction = new Set(
+    completedReads.filter((read) => read.entryIndex < latestCompactionIndex).map((read) => read.path)
+  );
+  const answeredFromPreCompaction = completedReads.some(
+    (read) => read.entryIndex > latestCompactionIndex && pathsReadBeforeCompaction.has(read.path)
+  );
+  return {
+    formatVersion,
+    toolPairsUnmatched: danglingCalls + orphanResults,
+    assistantBetweenCallAndResult,
+    compactionSummaryPresent: latestCompactionIndex >= 0,
+    answeredFromPreCompaction: latestCompactionIndex >= 0 && answeredFromPreCompaction,
+    turnsAfterCompaction: latestCompactionIndex < 0 ? 0 : entries.slice(latestCompactionIndex + 1).filter((entry) => entry?.kind === "message").length
+  };
+}
+function isCompactionSummary(entry) {
+  return entry?.kind === "compactionSummary" && typeof entry.summary === "string" && typeof entry.tokensBefore === "number" && Number.isFinite(entry.tokensBefore) && typeof entry.firstKeptTurnId === "string";
+}
+function parseJsonRecord(line) {
+  if (line.trim().length === 0) return void 0;
+  try {
+    const parsed = JSON.parse(line);
+    return isRecord4(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function processInvariantMetrics(journal) {
+  if (journal === null) return {};
+  const attested = journal.receipts.flatMap(
+    (receipt) => receipt.attestation === void 0 ? [] : [receipt.attestation]
+  );
+  if (attested.length === 0) return {};
+  const orphaned = attested.filter((attestation) => {
+    if (isProcessAlive(attestation.pid)) return true;
+    const group = attestation.processGroupId;
+    return group !== null && group === attestation.pid && isProcessAlive(-group);
+  });
+  return { "process.attestedWorkers": attested.length, "process.orphanedChildren": orphaned.length };
+}
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid === 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function writeBoundaryInvariantMetrics(stateDir) {
+  const files = findWriteBoundaryVerdicts(join(stateDir, "write-boundaries"));
+  if (files.length === 0) return {};
+  let sealed = true;
+  let violationsDetected = 0;
+  let violationsRolledBack = 0;
+  let rollbackIncomplete = 0;
+  for (const file of files) {
+    const verdict = parseJsonFile(file);
+    if (verdict === void 0) {
+      sealed = false;
+      continue;
+    }
+    if (!isNonEmptyString(verdict.digest) || !isNonEmptyString(verdict.baselineHead)) sealed = false;
+    if (verdict.reason === WRITES_BOUNDARY_VIOLATION) violationsDetected += 1;
+    if (verdict.status === "rolled-back") violationsRolledBack += 1;
+    if (verdict.status === "rollback-incomplete") rollbackIncomplete += 1;
+  }
+  return {
+    "boundary.verdictCount": files.length,
+    "boundary.verdictSealed": sealed,
+    "boundary.violationsDetected": violationsDetected,
+    "boundary.violationsRolledBack": violationsRolledBack,
+    "boundary.rollbackIncomplete": rollbackIncomplete
+  };
+}
+var WRITES_BOUNDARY_VIOLATION = "writes_boundary_violation";
+function findWriteBoundaryVerdicts(root) {
+  const files = [];
+  try {
+    for (const rootDir of readdirSync(root, { withFileTypes: true })) {
+      if (!rootDir.isDirectory()) continue;
+      const dir = join(root, rootDir.name);
+      try {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+          if (entry.isFile() && entry.name.endsWith(".json")) files.push(join(dir, entry.name));
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return [];
+  }
+  return files;
+}
+function parseJsonFile(path) {
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return isRecord4(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+var EMPTY_STREAM_INVARIANTS = {
+  messageUpdateCount: 0,
+  cumulativeSnapshots: 0,
+  usageMessages: 0,
+  repeatedResponses: 0,
+  identifiedResponses: 0,
+  messageTokenTotal: 0,
+  segmentTokenTotal: 0,
+  measuredSegments: 0
+};
+function addStreamInvariants(left, right) {
+  return {
+    messageUpdateCount: left.messageUpdateCount + right.messageUpdateCount,
+    cumulativeSnapshots: left.cumulativeSnapshots + right.cumulativeSnapshots,
+    usageMessages: left.usageMessages + right.usageMessages,
+    repeatedResponses: left.repeatedResponses + right.repeatedResponses,
+    identifiedResponses: left.identifiedResponses + right.identifiedResponses,
+    messageTokenTotal: left.messageTokenTotal + right.messageTokenTotal,
+    segmentTokenTotal: left.segmentTokenTotal + right.segmentTokenTotal,
+    measuredSegments: left.measuredSegments + right.measuredSegments
+  };
+}
+function createStreamInvariantFold() {
+  const state = {
+    messageUpdateCount: 0,
+    cumulativeSnapshots: 0,
+    usageMessages: 0,
+    repeatedResponses: 0,
+    identifiedResponses: 0,
+    messageTokenTotal: 0,
+    segmentTokenTotal: 0,
+    measuredSegments: 0
+  };
+  const seenResponses = /* @__PURE__ */ new Set();
+  let pending = "";
+  const consume = (line) => {
+    if (line.trim().length === 0) return;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (!isRecord4(event)) return;
+    if (event.type === "message_update") {
+      state.messageUpdateCount += 1;
+      const assistantEvent = isRecord4(event.assistantMessageEvent) ? event.assistantMessageEvent : void 0;
+      if (event.message !== void 0 || assistantEvent?.partial !== void 0) state.cumulativeSnapshots += 1;
+      return;
+    }
+    if (event.type === "agent_end") {
+      if (Array.isArray(event.messages)) state.cumulativeSnapshots += 1;
+      const usage2 = isRecord4(event.usage) ? event.usage : void 0;
+      if (usage2 === void 0 || usage2.measured !== true) return;
+      state.measuredSegments += 1;
+      state.segmentTokenTotal += numberField(usage2, "totalTokens");
+      return;
+    }
+    if (event.type !== "message_end") return;
+    const message = isRecord4(event.message) ? event.message : void 0;
+    if (message === void 0 || message.role !== "assistant") return;
+    const usage = isRecord4(message.usage) ? message.usage : void 0;
+    if (usage === void 0) return;
+    state.usageMessages += 1;
+    const input = numberField(usage, "input");
+    const output = numberField(usage, "output");
+    const cacheRead = numberField(usage, "cacheRead");
+    const cacheWrite = numberField(usage, "cacheWrite");
+    const totalTokens = numberField(usage, "totalTokens");
+    state.messageTokenTotal += totalTokens > 0 ? totalTokens : input + output + cacheRead + cacheWrite;
+    const responseId = message.responseId;
+    if (typeof responseId !== "string" || responseId.length === 0) return;
+    state.identifiedResponses += 1;
+    if (seenResponses.has(responseId)) state.repeatedResponses += 1;
+    seenResponses.add(responseId);
+  };
+  return {
+    push(chunk) {
+      pending += chunk;
+      for (; ; ) {
+        const newline = pending.indexOf("\n");
+        if (newline === -1) break;
+        consume(pending.slice(0, newline).replace(/\r$/u, ""));
+        pending = pending.slice(newline + 1);
+      }
+    },
+    invariants() {
+      if (pending.length > 0) {
+        consume(pending.replace(/\r$/u, ""));
+        pending = "";
+      }
+      return { ...state };
+    }
+  };
+}
+function streamInvariantMetrics(stream) {
+  return {
+    "stream.messageUpdateCount": stream.messageUpdateCount,
+    "stream.cumulativeSnapshots": stream.cumulativeSnapshots,
+    ...stream.identifiedResponses === 0 ? {} : { "stream.usageDoubleCounted": stream.repeatedResponses > 0 },
+    ...stream.measuredSegments === 0 ? {} : { "stream.segmentUsageMatchesMessages": stream.segmentTokenTotal === stream.messageTokenTotal }
+  };
+}
+function numberField(record, field) {
+  const value = record[field];
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function isReceiptShaped(value) {
+  if (!isRecord4(value)) return false;
+  return typeof value.runId === "string" && typeof value.agentId === "string" && typeof value.exitCode === "number" && typeof value.outcome === "string" && isRecord4(value.integrity);
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/domains/eval/metrics/latency.ts
+function wallTimeMetric(metrics) {
+  const value = metrics["latency.wallMs"];
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+// src/domains/eval/schema/artifact.ts
+var ZERO_TOKEN_METRICS_V4 = {
+  input: 0,
+  output: 0,
+  total: 0,
+  cacheRead: 0,
+  cacheWrite: 0
+};
+
+// src/domains/eval/metrics/coverage.ts
+function tokenMeasurementCoverage(results) {
+  let measured = 0;
+  for (const result of results) {
+    if (result.metrics["tokens.measured"] === true) measured += 1;
+  }
+  return { total: results.length, measured };
+}
+
+// src/domains/eval/metrics/tokens.ts
+function tokenAccountingFrom(results) {
+  const coverage = tokenMeasurementCoverage(results);
+  if (coverage.measured === 0) return { measured: false, runs: coverage.total, measuredRuns: 0 };
+  const totals = results.reduce(
+    (total, result) => result.metrics["tokens.measured"] === true ? addTokenMetrics(total, tokenMetricsFrom(result.metrics)) : total,
+    zeroTokenMetrics()
+  );
+  return { measured: true, runs: coverage.total, measuredRuns: coverage.measured, ...totals };
+}
+function tokenMetricsFrom(metrics) {
+  return {
+    input: numberMetric(metrics, "tokens.input"),
+    output: numberMetric(metrics, "tokens.output"),
+    total: numberMetric(metrics, "tokens.total"),
+    cacheRead: numberMetric(metrics, "tokens.cacheRead"),
+    cacheWrite: numberMetric(metrics, "tokens.cacheWrite")
+  };
+}
+function addTokenMetrics(left, right) {
+  return {
+    input: left.input + right.input,
+    output: left.output + right.output,
+    total: left.total + right.total,
+    cacheRead: left.cacheRead + right.cacheRead,
+    cacheWrite: left.cacheWrite + right.cacheWrite
+  };
+}
+function zeroTokenMetrics() {
+  return { ...ZERO_TOKEN_METRICS_V4 };
+}
+function numberMetric(metrics, key) {
+  const value = metrics[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+// src/domains/eval/metrics/tool-calls.ts
+function zeroToolCallMetrics() {
+  return {
+    "tools.totalCalls": 0,
+    "tools.failed": 0,
+    "tools.blocked": 0
+  };
+}
+
+// src/domains/eval/metrics/evidence.ts
+function receiptFromRunJsonStdout(stdout) {
+  let searchEnd = stdout.length;
+  while (searchEnd > 0) {
+    const start = stdout.lastIndexOf("\n{", searchEnd - 1);
+    if (start === -1) break;
+    const candidate = stdout.slice(start + 1);
+    try {
+      const parsed = JSON.parse(candidate);
+      if (isReceiptShaped2(parsed)) return parsed;
+    } catch {
+    }
+    if (start === 0) break;
+    searchEnd = start;
+  }
+  return null;
+}
+function isReceiptShaped2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.runId === "string" && typeof record.agentId === "string" && typeof record.exitCode === "number" && typeof record.integrity === "object" && record.integrity !== null;
+}
+function evidenceMetricsFromReceipt(receipt) {
+  return {
+    "evidence.verification": receipt.verification.state,
+    ...receipt.findingsSummary === void 0 ? {} : { "evidence.firstPassSuccess": receipt.findingsSummary.firstPassSuccess === true },
+    "evidence.quality.typedValidationCount": receipt.quality.typedValidations.length,
+    "evidence.responseSchema.digest": receipt.quality.responseSchema.schemaDigest ?? "none",
+    ...typeof receipt.costUsd === "number" && Number.isFinite(receipt.costUsd) ? { "cost.usd": receipt.costUsd } : {}
+  };
+}
+function dispatchCountFromJsonl(stdout) {
+  let executionEnds = 0;
+  let canonicalFinishes = 0;
+  const seenExecutionEnds = /* @__PURE__ */ new Set();
+  const seenCanonicalFinishes = /* @__PURE__ */ new Set();
+  let sawCanonicalFinishEvent = false;
+  for (const event of jsonlEvents(stdout)) {
+    if (event.type === "tool_execution_end") {
+      if (stringField(event, "toolName") !== "dispatch") continue;
+      const callId2 = stringField(event, "toolCallId");
+      if (callId2 !== void 0) {
+        if (seenExecutionEnds.has(callId2)) continue;
+        seenExecutionEnds.add(callId2);
+      }
+      executionEnds += 1;
+      continue;
+    }
+    if (event.type !== "clio_tool_finish" || !isRecord5(event.payload)) continue;
+    sawCanonicalFinishEvent = true;
+    if (stringField(event.payload, "tool") !== "dispatch") continue;
+    const callId = stringField(event.payload, "toolCallId") ?? stringField(event, "toolCallId");
+    if (callId !== void 0) {
+      if (seenCanonicalFinishes.has(callId)) continue;
+      seenCanonicalFinishes.add(callId);
+    }
+    canonicalFinishes += 1;
+  }
+  return sawCanonicalFinishEvent ? canonicalFinishes : executionEnds;
+}
+function scoutDispatchCountFromJsonl(stdout) {
+  const seen = /* @__PURE__ */ new Set();
+  let count = 0;
+  for (const event of jsonlEvents(stdout)) {
+    if (event.type !== "tool_execution_start" || stringField(event, "toolName") !== "dispatch") continue;
+    if (!isRecord5(event.args) || !dispatchArgsIncludeAgent(event.args, "scout")) continue;
+    const callId = stringField(event, "toolCallId");
+    if (callId !== void 0) {
+      if (seen.has(callId)) continue;
+      seen.add(callId);
+    }
+    count += 1;
+  }
+  return count;
+}
+function dispatchArgsIncludeAgent(args, expectedAgent) {
+  const sharedAgent = stringField(args, "agent") ?? stringField(args, "agent_id") ?? stringField(args, "agentId");
+  let tasks = args.tasks;
+  if (typeof tasks === "string") {
+    const trimmed = tasks.trim();
+    if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+      try {
+        tasks = JSON.parse(trimmed);
+      } catch {
+      }
+    }
+  }
+  const taskList = Array.isArray(tasks) ? tasks : tasks === void 0 ? [{ task: args.task }] : [tasks];
+  return taskList.some((task) => {
+    if (typeof task === "string") return sharedAgent?.toLowerCase() === expectedAgent;
+    if (!isRecord5(task)) return false;
+    const agent = stringField(task, "agent") ?? stringField(task, "agent_id") ?? stringField(task, "agentId") ?? sharedAgent;
+    return agent?.toLowerCase() === expectedAgent;
+  });
+}
+function wikiStaleAcknowledgedFromJsonl(stdout) {
+  let sawWikiLookup = false;
+  for (const event of jsonlEvents(stdout)) {
+    if (event.type !== "tool_execution_start") continue;
+    const toolName = stringField(event, "toolName");
+    if (toolName === "code_nav" && isRecord5(event.args) && event.args.mode === "wiki") {
+      sawWikiLookup = true;
+      continue;
+    }
+    if (sawWikiLookup && (toolName === "read" || toolName === "grep")) return true;
+  }
+  return false;
+}
+function* jsonlEvents(stdout) {
+  for (const line of stdout.split(/\r?\n/)) {
+    if (line.trim().length === 0) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (isRecord5(parsed)) yield parsed;
+    } catch {
+    }
+  }
+}
+function stringField(record, field) {
+  const value = record[field];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/domains/eval/metrics/token-stream.ts
+var UNMEASURED_TOKEN_USAGE = {
+  measured: false,
+  tokens: { input: 0, output: 0, total: 0, cacheRead: 0, cacheWrite: 0 },
+  costUsd: 0
+};
+function createTokenUsageFold() {
+  const tokens = { input: 0, output: 0, total: 0, cacheRead: 0, cacheWrite: 0 };
+  let costUsd = 0;
+  let measured = false;
+  let pending = "";
+  const consume = (line) => {
+    if (line.trim().length === 0) return;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (!isRecord6(event) || event.type !== "message_end") return;
+    const message = isRecord6(event.message) ? event.message : void 0;
+    if (message === void 0 || message.role !== "assistant") return;
+    const usage = isRecord6(message.usage) ? message.usage : void 0;
+    if (usage === void 0) return;
+    measured = true;
+    const input = numberField2(usage, "input");
+    const output = numberField2(usage, "output");
+    const cacheRead = numberField2(usage, "cacheRead");
+    const cacheWrite = numberField2(usage, "cacheWrite");
+    const totalTokens = numberField2(usage, "totalTokens");
+    tokens.input += input;
+    tokens.output += output;
+    tokens.cacheRead += cacheRead;
+    tokens.cacheWrite += cacheWrite;
+    tokens.total += totalTokens > 0 ? totalTokens : input + output + cacheRead + cacheWrite;
+    if (isRecord6(usage.cost)) costUsd += numberField2(usage.cost, "total");
+  };
+  return {
+    push(chunk) {
+      pending += chunk;
+      for (; ; ) {
+        const newline = pending.indexOf("\n");
+        if (newline === -1) break;
+        consume(pending.slice(0, newline).replace(/\r$/u, ""));
+        pending = pending.slice(newline + 1);
+      }
+    },
+    usage() {
+      if (pending.length > 0) {
+        consume(pending.replace(/\r$/u, ""));
+        pending = "";
+      }
+      return { measured, tokens: { ...tokens }, costUsd };
+    }
+  };
+}
+function addTokenStreamUsage(left, right) {
+  return {
+    measured: left.measured || right.measured,
+    tokens: {
+      input: left.tokens.input + right.tokens.input,
+      output: left.tokens.output + right.tokens.output,
+      total: left.tokens.total + right.tokens.total,
+      cacheRead: left.tokens.cacheRead + right.tokens.cacheRead,
+      cacheWrite: left.tokens.cacheWrite + right.tokens.cacheWrite
+    },
+    costUsd: left.costUsd + right.costUsd
+  };
+}
+function tokenMetricEntries(usage) {
+  if (!usage.measured) return { "tokens.measured": false };
+  return {
+    "tokens.measured": true,
+    "tokens.input": usage.tokens.input,
+    "tokens.output": usage.tokens.output,
+    "tokens.total": usage.tokens.total,
+    "tokens.cacheRead": usage.tokens.cacheRead,
+    "tokens.cacheWrite": usage.tokens.cacheWrite,
+    ...usage.costUsd > 0 ? { "cost.usd": usage.costUsd } : {}
+  };
+}
+function numberField2(record, field) {
+  const value = record[field];
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/domains/eval/runners/external-command.ts
+import { spawn } from "node:child_process";
+
+// src/domains/eval/metrics/chaos-stream.ts
+var EMPTY_CHAOS_OBSERVATION = { markerCount: 0, marker: null };
+function createChaosFold() {
+  let markerCount = 0;
+  let marker = null;
+  let pending = "";
+  const consume = (line) => {
+    if (line.trim().length === 0) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (!isRecord7(parsed) || parsed.type !== "clio_soak_chaos") return;
+    markerCount += 1;
+    marker = parseChaosMarker(parsed);
+  };
+  return {
+    push(chunk) {
+      pending += chunk;
+      for (; ; ) {
+        const newline = pending.indexOf("\n");
+        if (newline === -1) break;
+        consume(pending.slice(0, newline).replace(/\r$/u, ""));
+        pending = pending.slice(newline + 1);
+      }
+    },
+    observation() {
+      if (pending.length > 0) {
+        consume(pending.replace(/\r$/u, ""));
+        pending = "";
+      }
+      return { markerCount, marker: marker === null ? null : { ...marker } };
+    }
+  };
+}
+function addChaosObservations(left, right) {
+  const markerCount = left.markerCount + right.markerCount;
+  return {
+    markerCount,
+    marker: markerCount === 1 ? left.marker ?? right.marker : null
+  };
+}
+function chaosMetricEntries(observation) {
+  if (observation.markerCount !== 1 || observation.marker === null) return {};
+  return {
+    "chaos.seed": observation.marker.seed,
+    "chaos.faultInjected": observation.marker.faultInjected,
+    "chaos.exitCode": observation.marker.exitCode,
+    "process.orphanedChildren": observation.marker.orphanedChildren
+  };
+}
+function parseChaosMarker(event) {
+  if (event.type !== "clio_soak_chaos") return null;
+  const { seed, faultInjected, exitCode, orphanedChildren } = event;
+  if (!isFiniteInteger2(seed) || typeof faultInjected !== "boolean" || !isFiniteInteger2(exitCode)) return null;
+  if (!isFiniteInteger2(orphanedChildren) || orphanedChildren < 0) return null;
+  return { seed, faultInjected, exitCode, orphanedChildren };
+}
+function isFiniteInteger2(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/domains/eval/runners/external-command.ts
+var OUTPUT_LIMIT = 2e5;
+var OUTPUT_HEAD_LIMIT = 2e4;
+var OUTPUT_TRUNCATION_MARKER = "\n[output middle truncated; tail preserved]\n";
+var METRIC_JSONL_LIMIT = 256e3;
+var METRIC_JSONL_LINE_LIMIT = 64e3;
+async function runExternalCommandRunner(runner, cwd, timeoutMs, env) {
+  const runnerCommands = runner.commands ?? [];
+  const commands = runnerCommands.length > 0 ? runnerCommands : runner.command === void 0 ? [] : [runner.command];
+  let stdout = "";
+  let stderr = "";
+  let wallTimeMs = 0;
+  let usage = UNMEASURED_TOKEN_USAGE;
+  let streamInvariants = EMPTY_STREAM_INVARIANTS;
+  let chaos = EMPTY_CHAOS_OBSERVATION;
+  let fleetLoops = EMPTY_FLEET_LOOP_OBSERVATION;
+  for (const command of commands) {
+    const result = await runShellCommand(command, cwd, runner.timeoutMs ?? timeoutMs, env);
+    stdout = appendLimited(stdout, result.stdout);
+    stderr = appendLimited(stderr, result.stderr);
+    wallTimeMs += result.wallTimeMs;
+    usage = addTokenStreamUsage(usage, result.usage);
+    streamInvariants = addStreamInvariants(streamInvariants, result.streamInvariants);
+    chaos = addChaosObservations(chaos, result.chaos);
+    fleetLoops = addFleetLoopObservations(fleetLoops, result.fleetLoops);
+    if (result.exitCode !== 0) {
+      return {
+        assignmentId: null,
+        terminalReceiptDigest: null,
+        exitCode: result.exitCode,
+        stdout,
+        stderr,
+        wallTimeMs,
+        metrics: {
+          "latency.wallMs": wallTimeMs,
+          ...tokenMetricEntries(usage),
+          ...streamInvariantMetrics(streamInvariants),
+          ...chaosMetricEntries(chaos),
+          ...fleetLoopMetricEntries(fleetLoops),
+          "verifier.exitCode": result.exitCode
+        },
+        artifacts: chaosArtifacts(chaos)
+      };
+    }
+  }
+  return {
+    assignmentId: null,
+    terminalReceiptDigest: null,
+    exitCode: 0,
+    stdout,
+    stderr,
+    wallTimeMs,
+    metrics: {
+      "latency.wallMs": wallTimeMs,
+      ...tokenMetricEntries(usage),
+      ...streamInvariantMetrics(streamInvariants),
+      ...chaosMetricEntries(chaos),
+      ...fleetLoopMetricEntries(fleetLoops),
+      "verifier.exitCode": 0
+    },
+    artifacts: chaosArtifacts(chaos)
+  };
+}
+function runShellCommand(command, cwd, timeoutMs, env) {
+  const started = Date.now();
+  return new Promise((resolve8) => {
+    let stdout = "";
+    let stderr = "";
+    const metricCapture = createJsonlMetricCapture();
+    const usageFold = createTokenUsageFold();
+    const streamFold = createStreamInvariantFold();
+    const chaosFold = createChaosFold();
+    const fleetLoopFold = createFleetLoopFold();
+    let timedOut = false;
+    let settled = false;
+    const child = spawn(command, {
+      cwd,
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"],
+      // The overlay is additive: an eval item pins where Clio writes its
+      // journal, and inherits everything else the operator's shell provides.
+      env: env === void 0 ? process.env : { ...process.env, ...env }
+    });
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout = appendLimited(stdout, chunk);
+      metricCapture.push(chunk);
+      usageFold.push(chunk);
+      streamFold.push(chunk);
+      chaosFold.push(chunk);
+      fleetLoopFold.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr = appendLimited(stderr, chunk);
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 1e3);
+    }, timeoutMs);
+    const finish = (exitCode) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve8({
+        command,
+        exitCode,
+        stdout,
+        metricJsonl: metricCapture.finish(),
+        usage: usageFold.usage(),
+        streamInvariants: streamFold.invariants(),
+        chaos: chaosFold.observation(),
+        fleetLoops: fleetLoopFold.observation(),
+        stderr,
+        wallTimeMs: Math.max(0, Date.now() - started),
+        timedOut
+      });
+    };
+    child.on("error", (error) => {
+      stderr = appendLimited(stderr, error.message);
+      finish(1);
+    });
+    child.on("close", (code) => {
+      finish(typeof code === "number" ? code : timedOut ? 124 : 1);
+    });
+  });
+}
+function appendLimited(current, chunk) {
+  const next = `${current}${chunk}`;
+  if (next.length <= OUTPUT_LIMIT) return next;
+  const tailLimit = OUTPUT_LIMIT - OUTPUT_HEAD_LIMIT - OUTPUT_TRUNCATION_MARKER.length;
+  return `${next.slice(0, OUTPUT_HEAD_LIMIT)}${OUTPUT_TRUNCATION_MARKER}${next.slice(-tailLimit)}`;
+}
+function createJsonlMetricCapture() {
+  const lines = [];
+  let storedBytes = 0;
+  let pending = "";
+  let discardingOversizedLine = false;
+  let finished = false;
+  const store = (line) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (!isRecord8(parsed)) return;
+    const compact = compactMetricEvent(parsed);
+    if (compact === null) return;
+    const encoded = JSON.stringify(compact);
+    if (encoded.length > METRIC_JSONL_LINE_LIMIT) return;
+    lines.push(encoded);
+    storedBytes += encoded.length + 1;
+    while (storedBytes > METRIC_JSONL_LIMIT && lines.length > 1) {
+      const removed = lines.shift();
+      if (removed !== void 0) storedBytes -= removed.length + 1;
+    }
+  };
+  const push = (chunk) => {
+    if (finished || chunk.length === 0) return;
+    let remaining = chunk;
+    if (discardingOversizedLine) {
+      const newline = remaining.indexOf("\n");
+      if (newline === -1) return;
+      remaining = remaining.slice(newline + 1);
+      discardingOversizedLine = false;
+    }
+    pending += remaining;
+    for (; ; ) {
+      const newline = pending.indexOf("\n");
+      if (newline === -1) break;
+      store(pending.slice(0, newline).replace(/\r$/u, ""));
+      pending = pending.slice(newline + 1);
+    }
+    if (pending.length > METRIC_JSONL_LINE_LIMIT) {
+      pending = "";
+      discardingOversizedLine = true;
+    }
+  };
+  return {
+    push,
+    finish() {
+      if (!finished && !discardingOversizedLine && pending.length > 0) store(pending.replace(/\r$/u, ""));
+      finished = true;
+      pending = "";
+      return lines.join("\n");
+    }
+  };
+}
+function compactMetricEvent(event) {
+  const type = event.type;
+  if (type === "clio_soak_chaos") {
+    const marker = parseChaosMarker(event);
+    return marker === null ? null : { type, ...marker };
+  }
+  if (type === "tool_execution_start") {
+    const toolName = stringField2(event, "toolName");
+    if (toolName !== "dispatch" && toolName !== "code_nav" && toolName !== "read" && toolName !== "grep") {
+      return null;
+    }
+    return {
+      type,
+      ...stringField2(event, "toolCallId") !== void 0 ? { toolCallId: stringField2(event, "toolCallId") } : {},
+      toolName,
+      ...toolName === "dispatch" && isRecord8(event.args) ? { args: event.args } : toolName === "code_nav" && isRecord8(event.args) ? { args: { mode: event.args.mode } } : {}
+    };
+  }
+  if (type === "tool_execution_end") {
+    return {
+      type,
+      ...stringField2(event, "toolCallId") !== void 0 ? { toolCallId: stringField2(event, "toolCallId") } : {},
+      ...stringField2(event, "toolName") !== void 0 ? { toolName: stringField2(event, "toolName") } : {},
+      ...event.isError === true ? { isError: true } : {},
+      ...stringField2(event, "outcome") !== void 0 ? { outcome: stringField2(event, "outcome") } : {}
+    };
+  }
+  if (type !== "clio_tool_finish" || !isRecord8(event.payload)) return null;
+  return {
+    type,
+    payload: {
+      ...stringField2(event.payload, "tool") !== void 0 ? { tool: stringField2(event.payload, "tool") } : {},
+      ...stringField2(event.payload, "toolCallId") !== void 0 ? { toolCallId: stringField2(event.payload, "toolCallId") } : stringField2(event, "toolCallId") !== void 0 ? { toolCallId: stringField2(event, "toolCallId") } : {},
+      ...stringField2(event.payload, "outcome") !== void 0 ? { outcome: stringField2(event.payload, "outcome") } : {}
+    }
+  };
+}
+function chaosArtifacts(observation) {
+  return observation.markerCount === 1 && observation.marker !== null ? { chaosSeed: String(observation.marker.seed) } : {};
+}
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField2(record, field) {
+  const value = record[field];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+// src/domains/eval/runners/clio-run.ts
+async function runClioRunRunner(runner, cwd, clioEntry, timeoutMs, target, env) {
+  const prompt = runner.prompt ?? "";
+  const args = [
+    shellQuote(clioEntry),
+    "run",
+    "--json",
+    ...runner.agent === void 0 ? [] : ["--agent", shellQuote(runner.agent)],
+    "--target",
+    shellQuote(target.id),
+    ...target.model === void 0 ? [] : ["--model", shellQuote(target.model)],
+    ...target.thinking === void 0 ? [] : ["--thinking", shellQuote(target.thinking)],
+    shellQuote(prompt)
+  ];
+  const result = await runShellCommand(`${process.execPath} ${args.join(" ")}`, cwd, runner.timeoutMs ?? timeoutMs, env);
+  const tokens = result.usage;
+  const toolMetricStream = result.metricJsonl.length > 0 ? result.metricJsonl : result.stdout;
+  const tools = toolCallMetricsFromJsonl(toolMetricStream);
+  const receipt = receiptFromRunJsonStdout(result.stdout);
+  return {
+    assignmentId: receipt === null ? null : receipt.lineage?.rootRunId ?? receipt.runId,
+    terminalReceiptDigest: receipt?.integrity.digest ?? null,
+    exitCode: result.exitCode,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    wallTimeMs: result.wallTimeMs,
+    metrics: {
+      "latency.wallMs": result.wallTimeMs,
+      ...tokenMetricEntries(tokens),
+      // Folded live for the same reason the usage is: the structural
+      // promise these check is broken by a run whose middle is truncated.
+      ...streamInvariantMetrics(result.streamInvariants),
+      "tools.totalCalls": tools.totalCalls,
+      "tools.failed": tools.failed,
+      "tools.blocked": tools.blocked,
+      "verifier.exitCode": result.exitCode,
+      "dispatch.count": dispatchCountFromJsonl(toolMetricStream),
+      "dispatch.scoutCount": scoutDispatchCountFromJsonl(toolMetricStream),
+      "wiki.staleAcknowledged": wikiStaleAcknowledgedFromJsonl(toolMetricStream),
+      ...receipt === null ? {} : evidenceMetricsFromReceipt(receipt),
+      ...receipt === null ? {} : { "evidence.qualityLabel": receipt.quality.typedValidations.length > 0 ? "measured" : "unmeasured" }
+    },
+    artifacts: {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      ...receipt === null ? {} : { receipt: JSON.stringify(receipt) }
+    }
+  };
+}
+function toolCallMetricsFromJsonl(stdout) {
+  const executionEnds = { totalCalls: 0, failed: 0, blocked: 0 };
+  const canonicalFinishes = { totalCalls: 0, failed: 0, blocked: 0 };
+  const seenExecutionEnds = /* @__PURE__ */ new Set();
+  const seenCanonicalFinishes = /* @__PURE__ */ new Set();
+  for (const line of stdout.split(/\r?\n/)) {
+    if (line.trim().length === 0) continue;
+    let event;
+    try {
+      const parsed = JSON.parse(line);
+      if (!isRecord9(parsed)) continue;
+      event = parsed;
+    } catch {
+      continue;
+    }
+    if (event.type === "tool_execution_end") {
+      const callId2 = stringField3(event, "toolCallId");
+      if (callId2 !== void 0) {
+        if (seenExecutionEnds.has(callId2)) continue;
+        seenExecutionEnds.add(callId2);
+      }
+      recordToolOutcome(executionEnds, toolOutcome(event) ?? (event.isError === true ? "error" : "ok"));
+      continue;
+    }
+    if (event.type !== "clio_tool_finish" || !isRecord9(event.payload)) continue;
+    const outcome = toolOutcome(event.payload);
+    if (outcome === void 0) continue;
+    const callId = stringField3(event.payload, "toolCallId") ?? stringField3(event, "toolCallId");
+    if (callId !== void 0) {
+      if (seenCanonicalFinishes.has(callId)) continue;
+      seenCanonicalFinishes.add(callId);
+    }
+    recordToolOutcome(canonicalFinishes, outcome);
+  }
+  return canonicalFinishes.totalCalls > 0 ? canonicalFinishes : executionEnds;
+}
+function recordToolOutcome(metrics, outcome) {
+  metrics.totalCalls += 1;
+  if (outcome === "error") metrics.failed += 1;
+  else if (outcome === "blocked") metrics.blocked += 1;
+}
+function toolOutcome(record) {
+  const outcome = record.outcome;
+  return outcome === "ok" || outcome === "error" || outcome === "blocked" ? outcome : void 0;
+}
+function stringField3(record, field) {
+  const value = record[field];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function isRecord9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/domains/eval/runners/context-index.ts
+async function runContextIndexRunner(cwd, clioEntry, timeoutMs, target, env) {
+  const result = await runShellCommand(
+    `${shellQuote(process.execPath)} ${shellQuote(clioEntry)} context index --json`,
+    cwd,
+    timeoutMs,
+    env
+  );
+  const parsed = parseContextIndexOutput(result.stdout);
+  return {
+    assignmentId: null,
+    terminalReceiptDigest: null,
+    exitCode: result.exitCode,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    wallTimeMs: result.wallTimeMs,
+    metrics: {
+      "latency.wallMs": result.wallTimeMs,
+      "context.indexedFiles": parsed.indexedSourceFiles ?? 0,
+      "context.coverage": parsed.coverage ?? 0,
+      "context.structuralHash": parsed.structuralHash ?? null,
+      "verifier.exitCode": result.exitCode
+    },
+    artifacts: {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      target: target.id
+    }
+  };
+}
+function parseContextIndexOutput(stdout) {
+  try {
+    const parsed = JSON.parse(stdout);
+    const metrics = {};
+    if (typeof parsed.indexedSourceFiles === "number") metrics.indexedSourceFiles = parsed.indexedSourceFiles;
+    if (typeof parsed.coverage === "number") metrics.coverage = parsed.coverage;
+    if (typeof parsed.structuralHash === "string") metrics.structuralHash = parsed.structuralHash;
+    return metrics;
+  } catch {
+    return {};
+  }
+}
+
+// src/domains/eval/runners/context-init.ts
+import { existsSync as existsSync2, statSync } from "node:fs";
+import { join as join2 } from "node:path";
+async function runContextInitRunner(runner, cwd, clioEntry, timeoutMs, target, env) {
+  const extraArgs = runner.args ?? [];
+  const command = [
+    process.execPath,
+    clioEntry,
+    "context",
+    "init",
+    "--yes",
+    "--json",
+    "--target",
+    target.id,
+    ...target.model === void 0 ? [] : ["--model", target.model],
+    ...target.thinking === void 0 ? [] : ["--thinking", target.thinking],
+    ...extraArgs
+  ].map(shellQuote).join(" ");
+  const result = await runShellCommand(command, cwd, runner.timeoutMs ?? timeoutMs, env);
+  const payload = parseInitPayload(result.stdout);
+  const candidateGeneration = recordField(payload, "generation");
+  const generation = isValidGenerationPayload(payload, candidateGeneration) ? candidateGeneration : null;
+  const routeError = generation ? generationRouteError(generation, target) : null;
+  const payloadError = generation ? routeError : "context-init runner did not receive a valid JSON generation result";
+  const exitCode = result.exitCode === 0 && payloadError ? 1 : result.exitCode;
+  const stderr = payloadError ? `${result.stderr}${result.stderr.endsWith("\n") || result.stderr.length === 0 ? "" : "\n"}${payloadError}
+` : result.stderr;
+  const run = recordField(generation, "run");
+  const tokens = recordField(run, "tokens");
+  const effectiveTarget = stringField4(run, "targetId");
+  const effectiveModel = stringField4(run, "wireModelId");
+  const effectiveRuntime = stringField4(run, "runtimeId");
+  const effectiveRuntimeKind = stringField4(run, "runtimeKind");
+  const effectiveThinking = stringField4(run, "thinkingLevel");
+  const structuredOutputMode = stringField4(run, "structuredOutputMode");
+  const clioMdPath = join2(cwd, "CLIO-CODER.md");
+  const clioMdBytes = existsSync2(clioMdPath) ? statSync(clioMdPath).size : 0;
+  return {
+    assignmentId: null,
+    terminalReceiptDigest: null,
+    exitCode,
+    stdout: result.stdout,
+    stderr,
+    wallTimeMs: result.wallTimeMs,
+    metrics: {
+      "latency.wallMs": result.wallTimeMs,
+      "latency.modelMs": numberField3(run, "durationMs"),
+      "tokens.input": numberField3(tokens, "input"),
+      "tokens.output": numberField3(tokens, "output"),
+      "tokens.total": numberField3(tokens, "total"),
+      "tokens.cacheRead": numberField3(tokens, "cacheRead"),
+      "tokens.cacheWrite": numberField3(tokens, "cacheWrite"),
+      "tools.totalCalls": numberField3(run, "toolCalls"),
+      "tools.failed": numberField3(run, "toolFailures"),
+      "tools.blocked": numberField3(run, "toolBlocked"),
+      "context.clioMdBytes": clioMdBytes,
+      "context.initMode": stringField4(generation, "mode") ?? "unknown",
+      "context.initParserOutcome": stringField4(generation, "parserOutcome") ?? "unknown",
+      "context.initFallback": stringField4(generation, "fallbackReason") !== null,
+      "context.initPromptBytes": numberField3(run, "promptBytes"),
+      "context.initOutputBytes": numberField3(run, "outputBytes"),
+      "context.initTargetId": effectiveTarget,
+      "context.initModelId": effectiveModel,
+      "context.initRuntimeId": effectiveRuntime,
+      "context.initRuntimeKind": effectiveRuntimeKind,
+      "context.initThinkingLevel": effectiveThinking,
+      "context.initStructuredOutputMode": structuredOutputMode,
+      "verifier.exitCode": exitCode
+    },
+    artifacts: {
+      stdout: result.stdout,
+      stderr,
+      requestedTarget: target.id,
+      requestedModel: target.model ?? null,
+      requestedThinking: target.thinking ?? null,
+      effectiveTarget,
+      effectiveModel,
+      effectiveRuntime,
+      effectiveThinking,
+      bootstrapRunId: stringField4(run, "runId")
+    }
+  };
+}
+var GENERATION_MODES = /* @__PURE__ */ new Set(["model", "heuristic", "existing"]);
+var PARSER_OUTCOMES = /* @__PURE__ */ new Set(["parsed", "rejected", "not-run"]);
+function isNonnegativeFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isValidRunPayload(value) {
+  const run = recordField(value);
+  if (!run) return false;
+  for (const key of ["durationMs", "promptBytes", "outputBytes"]) {
+    if (!isNonnegativeFiniteNumber(run[key])) return false;
+  }
+  if (run.structuredOutputMode !== "native-schema" && run.structuredOutputMode !== "prompt-parser") return false;
+  for (const key of ["toolCalls", "toolFailures", "toolBlocked"]) {
+    if (run[key] !== void 0 && !isNonnegativeFiniteNumber(run[key])) return false;
+  }
+  const tokens = recordField(run, "tokens");
+  if (run.tokens !== void 0 && !tokens) return false;
+  if (tokens) {
+    for (const key of ["total", "input", "output", "cacheRead", "cacheWrite", "reasoning"]) {
+      if (tokens[key] !== void 0 && !isNonnegativeFiniteNumber(tokens[key])) return false;
+    }
+  }
+  return true;
+}
+function hasReceiptIdentity(run) {
+  if (!run) return false;
+  return ["runId", "targetId", "wireModelId", "runtimeId", "runtimeKind", "thinkingLevel"].every(
+    (key) => typeof run[key] === "string" && run[key].trim().length > 0
+  );
+}
+function isValidGenerationPayload(payload, generation) {
+  if (payload?.version !== 1 || !generation) return false;
+  const mode = generation.mode;
+  const parserOutcome = generation.parserOutcome;
+  if (typeof mode !== "string" || !GENERATION_MODES.has(mode)) return false;
+  if (typeof parserOutcome !== "string" || !PARSER_OUTCOMES.has(parserOutcome)) return false;
+  if (generation.fallbackReason !== void 0 && (typeof generation.fallbackReason !== "string" || generation.fallbackReason.trim().length === 0)) {
+    return false;
+  }
+  const runPresent = generation.run !== void 0;
+  if (runPresent && !isValidRunPayload(generation.run)) return false;
+  const run = recordField(generation, "run");
+  if (mode === "model" && (parserOutcome !== "parsed" || !hasReceiptIdentity(run))) return false;
+  if ((parserOutcome === "parsed" || parserOutcome === "rejected") && !runPresent) return false;
+  if (parserOutcome === "rejected" && !hasReceiptIdentity(run)) return false;
+  return true;
+}
+function generationRouteError(generation, target) {
+  const run = recordField(generation, "run");
+  if (!run) return null;
+  const actualTarget = stringField4(run, "targetId");
+  const actualModel = stringField4(run, "wireModelId");
+  const actualThinking = stringField4(run, "thinkingLevel");
+  if (actualTarget !== null && actualTarget !== target.id) {
+    return `context-init runner requested target '${target.id}' but the bootstrap receipt used '${actualTarget}'`;
+  }
+  if (target.model !== void 0 && actualModel !== null && actualModel !== target.model) {
+    return `context-init runner requested model '${target.model}' but the bootstrap receipt used '${actualModel}'`;
+  }
+  if (target.thinking !== void 0 && actualThinking !== null && actualThinking !== target.thinking) {
+    return `context-init runner requested thinking '${target.thinking}' but the bootstrap receipt used '${actualThinking}'`;
+  }
+  return null;
+}
+function parseInitPayload(stdout) {
+  try {
+    const parsed = JSON.parse(stdout);
+    return recordField(parsed);
+  } catch {
+    return null;
+  }
+}
+function recordField(value, field) {
+  const selected = field && typeof value === "object" && value !== null && !Array.isArray(value) ? value[field] : value;
+  return typeof selected === "object" && selected !== null && !Array.isArray(selected) ? selected : null;
+}
+function numberField3(value, field) {
+  const record = recordField(value);
+  const selected = record?.[field];
+  return typeof selected === "number" && Number.isFinite(selected) ? selected : null;
+}
+function stringField4(value, field) {
+  const record = recordField(value);
+  const selected = record?.[field];
+  return typeof selected === "string" && selected.length > 0 ? selected : null;
+}
+
+// src/domains/eval/verifiers/command.ts
+async function runCommandVerifiers(commands, cwd, timeoutMs) {
+  let stdout = "";
+  let stderr = "";
+  let wallTimeMs = 0;
+  for (const command of commands) {
+    const result = await runShellCommand(command, cwd, timeoutMs);
+    stdout += result.stdout;
+    stderr += result.stderr;
+    wallTimeMs += result.wallTimeMs;
+    if (result.exitCode !== 0) return { pass: false, exitCode: result.exitCode, stdout, stderr, wallTimeMs };
+  }
+  return { pass: true, exitCode: 0, stdout, stderr, wallTimeMs };
+}
+
+// src/domains/eval/verifiers/file-exists.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+function forbiddenPathHits(cwd, paths) {
+  return paths.filter((path) => existsSync3(resolve2(cwd, path)));
+}
+
+// src/domains/eval/verifiers/patch.ts
+import { spawnSync } from "node:child_process";
+function collectPatchMetrics(cwd) {
+  const diff = spawnSync("git", ["diff", "--", "."], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  const text = diff.status === 0 && typeof diff.stdout === "string" ? diff.stdout : "";
+  const files = text.split(/\r?\n/).filter((line) => line.startsWith("diff --git ")).map((line) => line.split(" b/")[1] ?? "");
+  return {
+    bytes: Buffer.byteLength(text, "utf8"),
+    filesChanged: files.length,
+    testFilesModified: files.filter((file) => /(^|\/)(test|tests|spec|__tests__)(\/|$)|\.(test|spec)\./.test(file)).length
+  };
+}
+
+// src/domains/eval/workspaces/git.ts
+import { spawn as spawn2 } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve as resolve3 } from "node:path";
+async function prepareGitWorkspace(workspace) {
+  if (workspace.url === void 0) throw new Error("git workspace requires url");
+  const dest = await mkdtemp(resolve3(tmpdir(), "clio-eval-git-"));
+  try {
+    await runGit(["clone", "--quiet", workspace.url, dest], process.cwd());
+    const ref = workspace.checkout ?? workspace.commit;
+    if (ref !== void 0) await runGit(["checkout", "--quiet", ref], dest);
+    return {
+      dir: dest,
+      cleanup: async () => {
+        await rm(dest, { recursive: true, force: true });
+      }
+    };
+  } catch (error) {
+    await rm(dest, { recursive: true, force: true });
+    throw error;
+  }
+}
+function runGit(args, cwd) {
+  return new Promise((resolveRun, rejectRun) => {
+    const child = spawn2("git", [...args], { cwd, stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", rejectRun);
+    child.on("close", (code) => {
+      if (code === 0) resolveRun();
+      else rejectRun(new Error(`git ${args.join(" ")} failed: ${stderr.trim()}`));
+    });
+  });
+}
+
+// src/domains/eval/workspaces/local.ts
+import { access } from "node:fs/promises";
+import { resolve as resolve4 } from "node:path";
+async function prepareLocalWorkspace(baseDir, workspace) {
+  const dir = resolve4(baseDir, workspace.path ?? ".");
+  await access(dir);
+  return { dir, cleanup: async () => {
+  } };
+}
+
+// src/domains/eval/workspaces/temp-copy.ts
+import { cp, mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { relative, resolve as resolve5 } from "node:path";
+async function prepareTempCopyWorkspace(baseDir, workspace) {
+  const source = resolve5(baseDir, workspace.path ?? ".");
+  const dest = await mkdtemp2(resolve5(tmpdir2(), "clio-eval-workspace-"));
+  const excludes = workspace.excludes ?? [];
+  await cp(source, dest, {
+    recursive: true,
+    filter: (path) => !isExcluded(relative(source, path), excludes)
+  });
+  return {
+    dir: dest,
+    cleanup: async () => {
+      await rm2(dest, { recursive: true, force: true });
+    }
+  };
+}
+function isExcluded(rel, excludes) {
+  const normalized = rel.replaceAll("\\", "/");
+  return excludes.some((entry) => normalized === entry || normalized.startsWith(`${entry.replaceAll("\\", "/")}/`));
+}
+
+// src/domains/eval/suites/matrix.ts
+function expandEvalMatrix(suite) {
+  const runs = [];
+  for (let repeatIndex = 0; repeatIndex < suite.matrix.repeats; repeatIndex += 1) {
+    for (const target of suite.matrix.targets) {
+      for (const task of suite.tasks) {
+        runs.push({ task, target, repeatIndex });
+      }
+    }
+  }
+  return runs;
+}
+
+// src/domains/eval/suites/run.ts
+var EvalWorkspaceSetupError = class extends Error {
+  constructor(exitCode, stderr) {
+    super(`workspace setup failed (exit ${exitCode}): ${stderr.trim()}`);
+    this.name = "EvalWorkspaceSetupError";
+  }
+};
+async function runEvalSuiteV2(loaded, options) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const started = now();
+  const evalId = createEvalId(started, loaded.hash);
+  const results = [];
+  const maxCostUsd = loaded.suite.matrix.maxCostUsd;
+  let spentUsd = 0;
+  for (const item of expandEvalMatrix(loaded.suite)) {
+    if (maxCostUsd !== void 0 && spentUsd > maxCostUsd) {
+      results.push(budgetExhaustedResult(item.task.id, item.target, item.repeatIndex, spentUsd, maxCostUsd));
+      continue;
+    }
+    const result = await runMatrixItem(loaded, item.task, item.target, item.repeatIndex, options.clioEntry);
+    spentUsd += resultCostUsd(result);
+    results.push(result);
+  }
+  return buildArtifact(loaded, evalId, results, options.clioEntry);
+}
+function resultCostUsd(result) {
+  const value = result.metrics["cost.usd"];
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function budgetExhaustedResult(taskId, target, repeatIndex, spentUsd, maxCostUsd) {
+  return {
+    assignmentId: null,
+    terminalReceiptDigest: null,
+    taskId,
+    repeatIndex,
+    target: { id: target.id, model: target.model ?? null, thinking: target.thinking ?? null },
+    pass: false,
+    failureClass: "budget_exhausted",
+    metrics: {
+      "result.pass": false,
+      "result.failureClass": "budget_exhausted",
+      "verifier.exitCode": 1,
+      "latency.wallMs": 0
+    },
+    artifacts: {
+      error: `matrix cost budget exhausted: spent $${spentUsd.toFixed(4)} of max $${maxCostUsd.toFixed(4)} before this item`
+    }
+  };
+}
+async function runMatrixItem(loaded, task, target, repeatIndex, clioEntry) {
+  let workspace = null;
+  const stateDir = await mkdtemp3(resolve6(tmpdir3(), "clio-eval-state-"));
+  try {
+    workspace = await prepareWorkspace(loaded.baseDir, task);
+    const setup = await runCommandVerifiers(task.workspace.setup ?? [], workspace.dir, task.timeoutMs);
+    if (!setup.pass) throw new EvalWorkspaceSetupError(setup.exitCode, setup.stderr);
+    const runner = await runTaskRunner(task, target, workspace.dir, clioEntry, {
+      CLIO_CODER_STATE_DIR: stateDir,
+      CLIO_CODER_ENTRY: clioEntry
+    });
+    const patch = collectPatchMetrics(workspace.dir);
+    const receiptExitCode = receiptProcessExitCode(runner);
+    const journalMetrics = invariantMetrics(stateDir, receiptExitCode);
+    const metrics = {
+      ...zeroToolCallMetrics(),
+      ...collectContextMetrics(workspace.dir),
+      // A runner may have exact measurements from command output. Those win
+      // over the generic post-run artifact collector.
+      ...runner.metrics,
+      ...journalMetrics,
+      // The one reading that needs both sides: what the loop reported it
+      // spent, and what the journal shows it sealed.
+      ...fleetLoopReceiptAgreement(runner.metrics, journalMetrics),
+      "patch.bytes": patch.bytes,
+      "patch.filesChanged": patch.filesChanged,
+      "patch.testFilesModified": patch.testFilesModified,
+      "result.pass": runner.exitCode === 0,
+      "result.failureClass": runner.exitCode === 0 ? null : "runner_failed",
+      ...await measureTaskOutcome(task, workspace.dir)
+    };
+    const verifier = await runVerifiers(task, workspace.dir, metrics);
+    const pass = runner.exitCode === 0 && verifier.pass;
+    const failureClass = pass ? null : runner.exitCode !== 0 ? "runner_failed" : verifier.failureClass;
+    metrics["verifier.exitCode"] = verifier.exitCode;
+    metrics["result.pass"] = pass;
+    metrics["result.failureClass"] = failureClass;
+    return {
+      assignmentId: runner.assignmentId,
+      terminalReceiptDigest: runner.terminalReceiptDigest,
+      taskId: task.id,
+      repeatIndex,
+      target: { id: target.id, model: target.model ?? null, thinking: target.thinking ?? null },
+      pass,
+      failureClass,
+      metrics,
+      artifacts: {
+        ...runner.artifacts,
+        ...verifier.stdout.length > 0 ? { verifierStdout: verifier.stdout } : {},
+        ...verifier.stderr.length > 0 ? { verifierStderr: verifier.stderr } : {}
+      }
+    };
+  } catch (error) {
+    const failureClass = error instanceof EvalWorkspaceSetupError ? "setup_failed" : "command_error";
+    return {
+      assignmentId: null,
+      terminalReceiptDigest: null,
+      taskId: task.id,
+      repeatIndex,
+      target: { id: target.id, model: target.model ?? null, thinking: target.thinking ?? null },
+      pass: false,
+      failureClass,
+      metrics: {
+        "result.pass": false,
+        "result.failureClass": failureClass,
+        "verifier.exitCode": 1,
+        "latency.wallMs": 0
+      },
+      artifacts: { error: error instanceof Error ? error.message : String(error) }
+    };
+  } finally {
+    await workspace?.cleanup();
+    await rm3(stateDir, { recursive: true, force: true });
+  }
+}
+function receiptProcessExitCode(runner) {
+  const chaosExitCode = runner.metrics["chaos.exitCode"];
+  return typeof chaosExitCode === "number" && Number.isInteger(chaosExitCode) ? chaosExitCode : runner.exitCode;
+}
+function invariantMetrics(stateDir, runnerExitCode) {
+  const journal = readRunJournal(stateDir);
+  return {
+    ...receiptInvariantMetrics(journal, runnerExitCode),
+    ...receiptUsageMetrics(journal),
+    ...sessionInvariantMetrics(stateDir),
+    ...processInvariantMetrics(journal),
+    ...writeBoundaryInvariantMetrics(stateDir)
+  };
+}
+async function prepareWorkspace(baseDir, task) {
+  if (task.workspace.kind === "local") return prepareLocalWorkspace(baseDir, task.workspace);
+  if (task.workspace.kind === "git") return prepareGitWorkspace(task.workspace);
+  return prepareTempCopyWorkspace(baseDir, task.workspace);
+}
+async function runTaskRunner(task, target, cwd, clioEntry, env) {
+  if (task.runner.kind === "external-command") return runExternalCommandRunner(task.runner, cwd, task.timeoutMs, env);
+  if (task.runner.kind === "context-index") return runContextIndexRunner(cwd, clioEntry, task.timeoutMs, target, env);
+  if (task.runner.kind === "context-init")
+    return runContextInitRunner(task.runner, cwd, clioEntry, task.timeoutMs, target, env);
+  return runClioRunRunner(task.runner, cwd, clioEntry, task.timeoutMs, target, env);
+}
+async function measureTaskOutcome(task, cwd) {
+  const commands = task.verify.measure ?? [];
+  if (commands.length === 0) return {};
+  const result = await runCommandVerifiers(commands, cwd, task.timeoutMs);
+  return { "task.exitCode": result.exitCode, "task.solved": result.exitCode === 0 };
+}
+async function runVerifiers(task, cwd, metrics) {
+  const commandResult = await runCommandVerifiers(task.verify.commands ?? [], cwd, task.timeoutMs);
+  if (!commandResult.pass) {
+    return {
+      pass: false,
+      exitCode: commandResult.exitCode,
+      failureClass: "verifier_failed",
+      stdout: commandResult.stdout,
+      stderr: commandResult.stderr
+    };
+  }
+  const forbidden = forbiddenPathHits(cwd, task.verify.forbidPaths ?? []);
+  if (forbidden.length > 0) {
+    return {
+      pass: false,
+      exitCode: 1,
+      failureClass: "forbidden_path",
+      stdout: "",
+      stderr: `forbidden paths exist: ${forbidden.join(", ")}`
+    };
+  }
+  for (const assertion of task.verify.assertions ?? []) {
+    const resolution = resolveMetricAssertion(assertion, metrics);
+    if (!resolution.unresolved && resolution.holds) continue;
+    return {
+      pass: false,
+      exitCode: 1,
+      failureClass: resolution.unresolved ? "assertion_unresolved" : "assertion_failed",
+      stdout: "",
+      stderr: resolution.unresolved ? `assertion unresolved (fail closed): ${assertion.metric} was not measured by this run` : assertionMessage(assertion, resolution.actual)
+    };
+  }
+  return { pass: true, exitCode: 0, failureClass: null, stdout: commandResult.stdout, stderr: commandResult.stderr };
+}
+function buildArtifact(loaded, evalId, results, clioEntry) {
+  const passed = results.filter((result) => result.pass).length;
+  return {
+    version: 4,
+    evalId,
+    suite: { id: loaded.suite.suite.id, hash: loaded.hash },
+    clio: evalClioProvenance({ entry: clioEntry }),
+    environment: evalEnvironmentProvenance(),
+    matrix: artifactMatrixIdentity(loaded.suite.matrix.targets),
+    summary: {
+      runs: results.length,
+      passed,
+      failed: results.length - passed,
+      passRate: results.length === 0 ? 0 : passed / results.length,
+      tokens: tokenAccountingFrom(results),
+      wallTimeMs: results.reduce((sum2, result) => sum2 + wallTimeMetric(result.metrics), 0)
+    },
+    results
+  };
+}
+function assertionMessage(assertion, actual) {
+  return `assertion failed: ${assertion.metric} ${assertion.op} ${String(assertion.value)} (actual ${JSON.stringify(actual)})`;
+}
+
+// src/cli/eval.ts
+var HELP = `clio-coder eval <command>
+
+Commands:
+  clio-coder eval validate --suite <suite.yaml>
+  clio-coder eval run --suite <suite.yaml> [--target <id>] [--model <id>] [--out <path>] [--clio-entry <path>]
+  clio-coder eval run --task-file <tasks.yaml> [--repeat <n>] [--out <path>] [--clio-entry <path>]
+  clio-coder eval report <evalId> --format text|json|md|swe-jsonl|junit
+  clio-coder eval compare <baselineEvalId> <candidateEvalId>
+  clio-coder eval gate <candidateEvalId> --baseline <baselineEvalId> [--thresholds <file>]
+`;
+function parseEvalArgs(args) {
+  const parsed = { repeat: 1, compareIds: [], format: "text", help: false };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === void 0) continue;
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (parsed.command === void 0) {
+      if (arg === "validate" || arg === "run" || arg === "report" || arg === "compare" || arg === "gate") {
+        parsed.command = arg;
+        continue;
+      }
+      throw new Error(`unknown eval command: ${arg}`);
+    }
+    if (parsed.command === "validate") {
+      if (arg === "--suite") {
+        parsed.suite = requiredValue(args, index, "--suite");
+        index += 1;
+        continue;
+      }
+      throw new Error(`unknown eval validate argument: ${arg}`);
+    }
+    if (parsed.command === "run") {
+      if (arg === "--suite") {
+        parsed.suite = requiredValue(args, index, "--suite");
+        index += 1;
+        continue;
+      }
+      if (arg === "--task-file") {
+        parsed.taskFile = requiredValue(args, index, "--task-file");
+        index += 1;
+        continue;
+      }
+      if (arg === "--target") {
+        parsed.target = requiredValue(args, index, "--target");
+        index += 1;
+        continue;
+      }
+      if (arg === "--model") {
+        parsed.model = requiredValue(args, index, "--model");
+        index += 1;
+        continue;
+      }
+      if (arg === "--out") {
+        parsed.out = requiredValue(args, index, "--out");
+        index += 1;
+        continue;
+      }
+      if (arg === "--clio-entry") {
+        parsed.clioEntry = requiredValue(args, index, "--clio-entry");
+        index += 1;
+        continue;
+      }
+      if (arg === "--repeat") {
+        parsed.repeat = positiveInteger(requiredValue(args, index, "--repeat"), "--repeat");
+        index += 1;
+        continue;
+      }
+      throw new Error(`unknown eval run argument: ${arg}`);
+    }
+    if (parsed.command === "report") {
+      if (arg === "--format") {
+        parsed.format = reportFormat(requiredValue(args, index, "--format"));
+        index += 1;
+        continue;
+      }
+      if (parsed.evalId === void 0 && !arg.startsWith("-")) {
+        parsed.evalId = arg;
+        continue;
+      }
+      throw new Error(`unexpected eval report argument: ${arg}`);
+    }
+    if (parsed.command === "compare") {
+      if (!arg.startsWith("-")) {
+        parsed.compareIds.push(arg);
+        continue;
+      }
+      throw new Error(`unexpected eval compare argument: ${arg}`);
+    }
+    if (parsed.command === "gate") {
+      if (arg === "--baseline") {
+        parsed.baseline = requiredValue(args, index, "--baseline");
+        index += 1;
+        continue;
+      }
+      if (arg === "--thresholds") {
+        parsed.thresholds = requiredValue(args, index, "--thresholds");
+        index += 1;
+        continue;
+      }
+      if (parsed.evalId === void 0 && !arg.startsWith("-")) {
+        parsed.evalId = arg;
+        continue;
+      }
+      throw new Error(`unexpected eval gate argument: ${arg}`);
+    }
+  }
+  if (parsed.help) return parsed;
+  if (parsed.command === void 0) throw new Error("eval requires a command");
+  if (parsed.command === "validate" && parsed.suite === void 0) throw new Error("validate requires --suite <path>");
+  if (parsed.command === "run" && parsed.suite === void 0 === (parsed.taskFile === void 0)) {
+    throw new Error("run requires exactly one of --suite or --task-file");
+  }
+  if (parsed.command === "report" && parsed.evalId === void 0) throw new Error("report requires an eval id");
+  if (parsed.command === "compare" && parsed.compareIds.length !== 2) {
+    throw new Error("compare requires <baselineEvalId> <candidateEvalId>");
+  }
+  if (parsed.command === "gate" && (parsed.evalId === void 0 || parsed.baseline === void 0)) {
+    throw new Error("gate requires <candidateEvalId> --baseline <baselineEvalId>");
+  }
+  return parsed;
+}
+async function runEvalCommand(args) {
+  let parsed;
+  try {
+    parsed = parseEvalArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (parsed.command === "validate") return runEvalValidate(parsed);
+  if (parsed.command === "run") return runEvalRun(parsed);
+  if (parsed.command === "report") return runEvalReportCommand(parsed);
+  if (parsed.command === "compare") return runEvalCompareCommand(parsed);
+  if (parsed.command === "gate") return runEvalGateCommand(parsed);
+  printError("eval requires a command");
+  return 2;
+}
+async function runEvalValidate(parsed) {
+  try {
+    const loaded = await loadEvalSuiteFile(parsed.suite ?? "");
+    process.stdout.write(`valid suite: ${loaded.suite.suite.id}
+`);
+    return 0;
+  } catch (error) {
+    return handleEvalLoadError(error);
+  }
+}
+async function runEvalRun(parsed) {
+  try {
+    const loaded = parsed.suite !== void 0 ? await loadEvalSuiteFile(parsed.suite) : await loadV1TaskFileAsSuite(parsed.taskFile ?? "", parsed.repeat);
+    const resolveOptions = {};
+    if (parsed.target !== void 0) resolveOptions.target = parsed.target;
+    if (parsed.model !== void 0) resolveOptions.model = parsed.model;
+    const suite = resolveSuiteForRun(loaded.suite, resolveOptions);
+    const clioEntry = resolve7(parsed.clioEntry ?? process.argv[1] ?? "dist/cli/index.js");
+    const artifact = await runEvalSuiteV2({ ...loaded, suite }, { clioEntry });
+    const artifactPath = await writeEvalArtifactV4(clioDataDir(), artifact, parsed.out);
+    process.stdout.write(`${renderEvalTextReportV4(artifact)}artifact: ${artifactPath}
+`);
+    const gate = suite.thresholds === void 0 ? null : evaluateGate(artifact, suite.thresholds);
+    if (gate !== null && !gate.pass) {
+      process.stdout.write(`gate: fail (${gate.failures.length} threshold failure)
+`);
+      for (const failure of gate.failures) process.stdout.write(renderGateFailure(failure));
+    }
+    return artifact.summary.failed === 0 && (gate === null || gate.pass) ? 0 : 1;
+  } catch (error) {
+    return handleEvalLoadError(error, 1);
+  }
+}
+async function runEvalReportCommand(parsed) {
+  try {
+    const dataDir = clioDataDir();
+    const artifact = await loadEvalArtifactV4(dataDir, parsed.evalId ?? "");
+    process.stdout.write(renderArtifactReport(artifact, parsed.format, dataDir));
+    return 0;
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return error instanceof InvalidIdError ? 2 : 1;
+  }
+}
+async function runEvalCompareCommand(parsed) {
+  const baselineEvalId = parsed.compareIds[0] ?? "";
+  const candidateEvalId = parsed.compareIds[1] ?? "";
+  try {
+    const dataDir = clioDataDir();
+    const baseline = await loadEvalArtifactV4(dataDir, baselineEvalId);
+    const candidate = await loadEvalArtifactV4(dataDir, candidateEvalId);
+    process.stdout.write(renderEvalComparisonV4(compareEvalArtifactsV4(baseline, candidate)));
+    return 0;
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return error instanceof InvalidIdError ? 2 : 1;
+  }
+}
+async function runEvalGateCommand(parsed) {
+  try {
+    const dataDir = clioDataDir();
+    const candidate = await loadEvalArtifactV4(dataDir, parsed.evalId ?? "");
+    await loadEvalArtifactV4(dataDir, parsed.baseline ?? "");
+    const thresholds = parsed.thresholds === void 0 ? { fail: [{ metric: "result.pass", op: "eq", value: false }] } : loadThresholds(parsed.thresholds);
+    const gate = evaluateGate(candidate, thresholds);
+    if (gate.pass) {
+      process.stdout.write("gate: pass\n");
+      return 0;
+    }
+    process.stdout.write(`gate: fail (${gate.failures.length} threshold failure)
+`);
+    for (const failure of gate.failures) process.stdout.write(renderGateFailure(failure));
+    return 1;
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return error instanceof InvalidIdError ? 2 : 1;
+  }
+}
+function renderArtifactReport(artifact, format, _dataDir) {
+  if (format === "json") return renderEvalJsonReportV4(artifact);
+  if (format === "md") return renderEvalMarkdownReportV4(artifact);
+  if (format === "swe-jsonl") return renderEvalSweJsonlReportV4(artifact);
+  if (format === "junit") return renderEvalJunitReportV4(artifact);
+  return renderEvalTextReportV4(artifact);
+}
+function handleEvalLoadError(error, fallback = 2) {
+  if (error instanceof EvalSuiteFileError || error instanceof EvalTaskFileError) {
+    printError(error.message);
+    for (const issue of error.issues) process.stderr.write(`  ${issue.path}: ${issue.message}
+`);
+    return 2;
+  }
+  printError(error instanceof Error ? error.message : String(error));
+  return fallback;
+}
+function requiredValue(args, index, flag) {
+  const value = args[index + 1];
+  if (value === void 0 || value.startsWith("-")) throw new Error(`${flag} requires a value`);
+  return value;
+}
+function positiveInteger(value, flag) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0 || String(parsed) !== value) {
+    throw new Error(`${flag} requires a positive integer`);
+  }
+  return parsed;
+}
+function reportFormat(value) {
+  if (value === "text" || value === "json" || value === "md" || value === "swe-jsonl" || value === "junit") return value;
+  throw new Error("--format must be text, json, md, swe-jsonl, or junit");
+}
+export {
+  runEvalCommand
+};
+//# sourceMappingURL=eval-B3KZZESM.js.map