@iowarp/clio-coder 0.4.4 → 0.4.6

package/dist/{eval-OQOQUDHK.js → eval-V2RTN3UH.js}

@@ -1,14 +1,17 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   EVAL_SUITE_V2_VERSION
-} from "./chunk-4IUZQIJ3.js";
+} from "./chunk-5PHVPU4G.js";
 import {
-  loadFragments,
-  renderCodewikiDigest
-} from "./chunk-V6HJFQZE.js";
+  isProjectPreloadClass
+} from "./chunk-5ZSZEYJK.js";
 import {
   discoverAgentRecipes
-} from "./chunk-7UGL4MB5.js";
+} from "./chunk-VAHLPXPY.js";
+import "./chunk-536HXRFE.js";
+import "./chunk-DNCE23JJ.js";
+import "./chunk-U7H5WRG5.js";
+import "./chunk-5VTJP36Q.js";
 import {
   EvalTaskFileError,
   TRUST_STATUS_AXES,
@@ -21,13 +24,15 @@ import {
   formatTrustSummary,
   inspectRunReceiptTrustStatus,
   loadEvalTaskFile,
+  loadFragments,
+  renderCodewikiDigest,
   summarizeTrustStatus,
   verifyReceiptIntegrity
-} from "./chunk-CUSRQKPU.js";
+} from "./chunk-HZ2T2YED.js";
 import {
   listSessionLedgerRefs,
   parseSessionEntries
-} from "./chunk-6UINWWS6.js";
+} from "./chunk-DXLUVUD4.js";
 import {
   EVAL_BEHAVIOR_METRIC_DEFINITIONS_V1,
   EVAL_EXECUTION_ENVELOPE_SCHEMA_V1,
@@ -42,104 +47,110 @@ import {
   loadEvalArtifactV4,
   normalizeEvalRunnerKind,
   normalizeEvalSchemaId,
+  parseEvalArtifactV4,
   parseEvalBehaviorScenarioV1,
   parseEvalExecutionMatrixDimensionsV1,
   parseEvalVerdictEnvelopeV1,
   renderEvalServingConfiguration,
   sameEvalServingConfiguration,
   writeEvalArtifactV4
-} from "./chunk-FTMGRKEF.js";
-import "./chunk-W6GROXXM.js";
-import "./chunk-RKKLTLYB.js";
-import "./chunk-2ZSONWVL.js";
-import "./chunk-NDDGJUXD.js";
-import "./chunk-YECAMM3D.js";
-import "./chunk-3DPEIQKN.js";
-import "./chunk-TQAHXW6Y.js";
-import "./chunk-5MEZN6CB.js";
-import "./chunk-3ODX73FK.js";
-import "./chunk-HVDIIIQW.js";
+} from "./chunk-U44YYLVV.js";
+import "./chunk-O5F25NIE.js";
+import "./chunk-CXQ37WJH.js";
+import "./chunk-QH3ZTUOA.js";
+import "./chunk-22PQ4TX4.js";
+import "./chunk-DZK63TZJ.js";
 import {
-  printError
-} from "./chunk-JCI2ROMZ.js";
-import "./chunk-AUPNRN7C.js";
-import "./chunk-6PAZTBPA.js";
+  shellQuote
+} from "./chunk-SD7SHNDW.js";
+import "./chunk-DNHVRBH4.js";
 import {
-  createSafetyPolicyEngine
-} from "./chunk-6Q3CYFD3.js";
-import "./chunk-H7IXIC72.js";
+  printError
+} from "./chunk-3T4DXWP6.js";
+import "./chunk-K2HL3GBL.js";
+import "./chunk-YPRSNUTC.js";
+import "./chunk-LY4N4TTL.js";
 import {
   agentSpecFingerprint,
   normalizeAgentSpec
-} from "./chunk-KFV5L5SK.js";
-import "./chunk-NXYCB2VD.js";
-import "./chunk-ECH6PKUQ.js";
-import "./chunk-DXKJURES.js";
-import "./chunk-HHV2GANA.js";
-import "./chunk-GYV6VZOC.js";
-import "./chunk-UL3WSD3F.js";
-import "./chunk-54X7T7DK.js";
-import "./chunk-I5FWO7L5.js";
-import "./chunk-4NSRCOYP.js";
-import "./chunk-CFGTUFWB.js";
+} from "./chunk-OQM5IVJY.js";
+import "./chunk-KAFMW7WM.js";
+import {
+  createSafetyPolicyEngine
+} from "./chunk-IKRWLEDA.js";
+import "./chunk-NTK3WTHM.js";
+import "./chunk-MCJKEGHO.js";
 import {
   extractReasoningTokens
-} from "./chunk-NZMNUPZZ.js";
-import "./chunk-KXDSS5WJ.js";
-import "./chunk-GHS5EBTQ.js";
+} from "./chunk-77CZRFTE.js";
+import "./chunk-LUL5Z66S.js";
+import "./chunk-M6TAYK66.js";
+import "./chunk-KQ6IDQIB.js";
+import "./chunk-PZN2LQY6.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-M4KFUXS7.js";
+import "./chunk-EM2WNQS2.js";
+import "./chunk-WNGF5AJX.js";
 import {
   namingCompatibilityEnvironment
-} from "./chunk-D7E7WCDF.js";
-import "./chunk-HAXOFFRH.js";
+} from "./chunk-DVNAPPXU.js";
+import "./chunk-5CY4Q6QI.js";
+import "./chunk-FQOOGXBH.js";
 import {
   InvalidIdError
-} from "./chunk-R346GLFC.js";
+} from "./chunk-UHW5V7HC.js";
+import "./chunk-B6UM3OZC.js";
+import {
+  ALL_TOOL_NAMES
+} from "./chunk-EHOSNVVM.js";
 import {
   normalizeClioCoderEventRecord,
   normalizeClioCoderEventType
-} from "./chunk-BTK3SSSK.js";
-import "./chunk-F4EKGO4N.js";
+} from "./chunk-KMF54VH3.js";
+import "./chunk-HL26ADLH.js";
 import {
   readCodewiki,
   structuralCodewikiHash
-} from "./chunk-LBMZMYH2.js";
+} from "./chunk-W2RJEH6Q.js";
 import {
   detectProjectProfile
-} from "./chunk-XAKHZX5N.js";
+} from "./chunk-CVDAFGPW.js";
 import {
   enumerateWorkspaceFiles
-} from "./chunk-33YXPOE3.js";
-import "./chunk-7CR24IG7.js";
-import "./chunk-XPLRXC72.js";
-import "./chunk-IWHMRKLL.js";
-import "./chunk-UXCU4E3T.js";
-import "./chunk-LL4KHSZI.js";
-import "./chunk-S66XZJOF.js";
-import "./chunk-TOIVGRUX.js";
-import "./chunk-U6TMQNSI.js";
-import "./chunk-EBY63B7G.js";
-import "./chunk-6EJMN2Y3.js";
-import "./chunk-ID64D7PE.js";
-import "./chunk-336NSSKI.js";
-import "./chunk-IKCO5N3L.js";
-import "./chunk-3I7MS7N2.js";
+} from "./chunk-PPEZJWUG.js";
+import "./chunk-WDV62RKY.js";
+import "./chunk-GD55RTIW.js";
+import "./chunk-E3LEPLQ2.js";
+import "./chunk-3BJGMT2D.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-GJ24ODAX.js";
+import "./chunk-LTR5QCLS.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-HXHFDHB6.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-2QPI3TR3.js";
+import "./chunk-TK2BMCBZ.js";
 import {
   require_dist
-} from "./chunk-APJ265NV.js";
-import "./chunk-WEPFGWHJ.js";
-import "./chunk-YXLYO42X.js";
+} from "./chunk-B5GGDIHT.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-DXVMLM3Z.js";
 import {
   clioDataDir,
   clioStateDir
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   __toESM,
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/cli/eval.ts
 init_esm_shims();
-import { resolve as resolve8 } from "node:path";
+import { readFile as readFile4 } from "node:fs/promises";
+import { resolve as resolve10 } from "node:path";
 
 // src/domains/eval/compare/compare.ts
 init_esm_shims();
@@ -238,28 +249,33 @@ init_esm_shims();
 // src/domains/eval/compare/envelope.ts
 init_esm_shims();
 function compareEvalExecutionEnvelopesV1(identity, baseline, candidate, baselineDimensions, candidateDimensions) {
+  const mismatchIdentity = {
+    scenarioId: identity.scenarioId,
+    role: identity.role,
+    target: { id: identity.target.id, model: identity.target.model }
+  };
   const leftDimensions = [...baselineDimensions].sort();
   const rightDimensions = [...candidateDimensions].sort();
   if (stableJson(leftDimensions) !== stableJson(rightDimensions)) {
-    return { ...identity, fields: ["matrix.dimensions"] };
+    return { ...mismatchIdentity, fields: ["matrix.dimensions"] };
   }
   if (baseline.some((result) => result.executionEnvelope !== void 0) && baseline.some((result) => result.executionEnvelope === void 0) || candidate.some((result) => result.executionEnvelope !== void 0) && candidate.some((result) => result.executionEnvelope === void 0)) {
-    return { ...identity, fields: ["executionEnvelope.missingTrial"] };
+    return { ...mismatchIdentity, fields: ["executionEnvelope.missingTrial"] };
   }
   const ignored = new Set(leftDimensions);
   const baselineEnvelopes = uniqueEnvelopes(baseline, ignored);
   const candidateEnvelopes = uniqueEnvelopes(candidate, ignored);
   if (baselineEnvelopes.length === 0 && candidateEnvelopes.length === 0) return null;
   if (baselineEnvelopes.length === 0 || candidateEnvelopes.length === 0) {
-    return { ...identity, fields: ["executionEnvelope"] };
+    return { ...mismatchIdentity, fields: ["executionEnvelope"] };
   }
   if (baselineEnvelopes.length > 1 || candidateEnvelopes.length > 1) {
-    return { ...identity, fields: ["executionEnvelope.withinRunVariance"] };
+    return { ...mismatchIdentity, fields: ["executionEnvelope.withinRunVariance"] };
   }
   const left = baselineEnvelopes[0];
   const right = candidateEnvelopes[0];
   if (left === void 0 || right === void 0 || stableJson(left) === stableJson(right)) return null;
-  return { ...identity, fields: differingFields(left, right, ignored) };
+  return { ...mismatchIdentity, fields: differingFields(left, right, ignored) };
 }
 function uniqueEnvelopes(results, ignored) {
   const byIdentity = /* @__PURE__ */ new Map();
@@ -322,26 +338,45 @@ function stableJson(value) {
 
 // src/domains/eval/compare/behavioral.ts
 function compareEvalBehaviorMetricsV1(baseline, candidate) {
-  const baselineGroups = behaviorGroups(baseline);
-  const candidateGroups = behaviorGroups(candidate);
+  const baselineDimensions = baseline.matrix.dimensions ?? [];
+  const candidateDimensions = candidate.matrix.dimensions ?? [];
+  const varying = new Set(baselineDimensions.filter((dimension) => candidateDimensions.includes(dimension)));
+  const baselineGroups = behaviorGroups(baseline, varying);
+  const candidateGroups = behaviorGroups(candidate, varying);
   const keys = /* @__PURE__ */ new Set([...baselineGroups.keys(), ...candidateGroups.keys()]);
   const comparisons = [];
   const envelopeMismatches = [];
-  const baselineDimensions = baseline.matrix.dimensions ?? [];
-  const candidateDimensions = candidate.matrix.dimensions ?? [];
   for (const key of [...keys].sort((left, right) => left.localeCompare(right))) {
     const baselineGroup = baselineGroups.get(key);
     const candidateGroup = candidateGroups.get(key);
-    const identity = baselineGroup ?? candidateGroup;
-    if (identity === void 0) continue;
-    const envelopeMismatch = compareEvalExecutionEnvelopesV1(
+    const group = baselineGroup ?? candidateGroup;
+    if (group === void 0) continue;
+    const identity = {
+      scenarioId: group.scenarioId,
+      role: group.role,
+      target: { id: group.target.id, model: group.target.model }
+    };
+    const routes = {
+      baselineTargets: baselineGroup?.targets ?? [],
+      candidateTargets: candidateGroup?.targets ?? []
+    };
+    let envelopeMismatch = compareEvalExecutionEnvelopesV1(
       identity,
       baselineGroup?.results ?? [],
       candidateGroup?.results ?? [],
       baselineDimensions,
       candidateDimensions
     );
-    if (envelopeMismatch !== null) envelopeMismatches.push(envelopeMismatch);
+    if (routes.baselineTargets.length > 1 || routes.candidateTargets.length > 1) {
+      envelopeMismatch = {
+        ...identity,
+        fields: ["behavioralMetrics.ambiguousRouteGroup", ...envelopeMismatch?.fields ?? []]
+      };
+    }
+    if (envelopeMismatch !== null) {
+      envelopeMismatch = { ...envelopeMismatch, ...routes };
+      envelopeMismatches.push(envelopeMismatch);
+    }
     const comparability = {
       comparable: envelopeMismatch === null,
       mismatchedFields: envelopeMismatch?.fields ?? []
@@ -349,18 +384,21 @@ function compareEvalBehaviorMetricsV1(baseline, candidate) {
     for (const definition of EVAL_BEHAVIOR_METRIC_DEFINITIONS_V1) {
       const baselineDistribution = behaviorDistribution(baselineGroup?.results ?? [], definition);
       const candidateDistribution = behaviorDistribution(candidateGroup?.results ?? [], definition);
+      const noiseBand = definition.family === "safety" ? 0 : distributionNoiseBand(baselineDistribution, candidateDistribution);
       comparisons.push({
         scenarioId: identity.scenarioId,
         role: identity.role,
         target: identity.target,
+        ...routes,
         metric: definition.name,
         family: definition.family,
         direction: definition.direction,
         hardGate: definition.hardGate,
         baseline: baselineDistribution,
         candidate: candidateDistribution,
-        change: envelopeMismatch === null ? classifyChange(baselineDistribution.mean, candidateDistribution.mean, definition.direction) : "incomparable",
+        change: envelopeMismatch === null ? classifyChange(baselineDistribution.mean, candidateDistribution.mean, definition.direction, noiseBand) : "incomparable",
         meanDelta: subtractNullable(candidateDistribution.mean, baselineDistribution.mean),
+        noiseBand,
         varianceChange: envelopeMismatch === null ? classifyChange(baselineDistribution.variance, candidateDistribution.variance, "lower") : "incomparable",
         varianceDelta: subtractNullable(candidateDistribution.variance, baselineDistribution.variance),
         comparability
@@ -373,6 +411,8 @@ function compareEvalBehaviorMetricsV1(baseline, candidate) {
         scenarioId: comparison.scenarioId,
         role: comparison.role,
         target: comparison.target,
+        baselineTargets: comparison.baselineTargets,
+        candidateTargets: comparison.candidateTargets,
         metric: comparison.metric,
         change: comparison.change
       }
@@ -388,24 +428,28 @@ function compareEvalBehaviorMetricsV1(baseline, candidate) {
     envelopeMismatches
   };
 }
-function classifyChange(baseline, candidate, direction) {
+function classifyChange(baseline, candidate, direction, noiseBand = 0) {
   if (baseline === null || candidate === null) return "incomparable";
-  if (baseline === candidate) return "unchanged";
+  if (Math.abs(candidate - baseline) <= noiseBand) return "unchanged";
   if (direction === "higher") return candidate > baseline ? "improved" : "regressed";
   return candidate < baseline ? "improved" : "regressed";
 }
-function behaviorGroups(artifact) {
+function behaviorGroups(artifact, varying) {
   const groups = /* @__PURE__ */ new Map();
   for (const result of artifact.results) {
     const behavioral = result.behavioralMetrics;
     if (behavioral === void 0) continue;
-    const key = groupKey(behavioral.scenarioId, behavioral.role, behavioral.target);
+    const key = groupKey(behavioral.scenarioId, behavioral.role, behavioral.target, varying);
     const group = groups.get(key) ?? {
       scenarioId: behavioral.scenarioId,
       role: behavioral.role,
       target: behavioral.target,
+      targets: [],
       results: []
     };
+    if (!group.targets.some((target) => target.id === behavioral.target.id && target.model === behavioral.target.model)) {
+      group.targets.push(behavioral.target);
+    }
     group.results.push(result);
     groups.set(key, group);
   }
@@ -444,12 +488,21 @@ function behaviorDistribution(results, definition) {
     source: definition.source
   };
 }
-function groupKey(scenarioId, role, target) {
-  return JSON.stringify([scenarioId, role, target.id, target.model]);
+function groupKey(scenarioId, role, target, varying) {
+  return JSON.stringify([
+    scenarioId,
+    role,
+    varying.has("target") ? null : target.id,
+    varying.has("wireModel") ? null : target.model
+  ]);
 }
 function subtractNullable(left, right) {
   return left === null || right === null ? null : left - right;
 }
+function distributionNoiseBand(baseline, candidate) {
+  if (baseline.measured < 2 || candidate.measured < 2 || baseline.unmeasured > 0 || candidate.unmeasured > 0) return 0;
+  return 2 * Math.sqrt((baseline.variance ?? 0) / (baseline.measured - 1) + (candidate.variance ?? 0) / (candidate.measured - 1));
+}
 
 // src/domains/eval/compare/compare.ts
 var EvalServingConfigurationDriftError = class extends Error {
@@ -507,7 +560,7 @@ function compareEvalArtifactsV4(baseline, candidate, options = {}) {
 }
 function renderEvalComparisonV4(summary) {
   const envelopeFailures = summary.envelopeMismatches.map(
-    (mismatch) => `  incomparable envelope: ${mismatch.scenarioId} ${mismatch.role} ${mismatch.target.id}/${mismatch.target.model ?? "none"} fields=${mismatch.fields.join(",")}`
+    (mismatch) => `  incomparable envelope: ${mismatch.scenarioId} ${mismatch.role} ${renderEvalComparisonRoutesV1(mismatch)} fields=${mismatch.fields.join(",")}`
   );
   const affected = summary.affectedCorpusResults.map(
     (result) => `  affected corpus result: ${result.scenarioId} role=${result.role} changed=${result.changedFields.join(",")}`
@@ -515,7 +568,7 @@ function renderEvalComparisonV4(summary) {
   const scenarioReports = renderRollups("per-scenario baseline/candidate report", summary.scenarioReports);
   const roleReports = renderRollups("per-role baseline/candidate report", summary.roleReports);
   const hardFailures = summary.hardGate.failures.map(
-    (failure) => `  hard failure: ${failure.scenarioId} ${failure.role} ${failure.target.id}/${failure.target.model ?? "none"} ${failure.metric} ${failure.change}`
+    (failure) => `  hard failure: ${failure.scenarioId} ${failure.role} ${renderEvalComparisonRoutesV1(failure)} ${failure.metric} ${failure.change}`
   );
   const tracked = summary.trackedMetrics.flatMap((row, index) => [
     ...index === 0 ? [
@@ -542,13 +595,12 @@ function renderEvalComparisonV4(summary) {
   const behavioral = summary.behavioralMetrics.flatMap((row, index) => [
     ...index === 0 ? [
       "behavioral metrics:",
-      "scenario role target model family metric baseline_mean baseline_variance baseline_coverage candidate_mean candidate_variance candidate_coverage mean_delta variance_delta change variance_change comparability gate source"
+      "scenario role baseline_target/model -> candidate_target/model family metric baseline_mean baseline_variance baseline_coverage candidate_mean candidate_variance candidate_coverage mean_delta variance_delta noise_band change variance_change comparability gate source"
     ] : [],
     [
       row.scenarioId,
       row.role,
-      row.target.id,
-      row.target.model ?? "none",
+      renderEvalComparisonRoutesV1(row),
       row.family,
       row.metric,
       formatMetric(row.baseline.mean),
@@ -559,6 +611,7 @@ function renderEvalComparisonV4(summary) {
       `${row.candidate.measured}/${row.candidate.observations}`,
       formatSignedMetric(row.meanDelta),
       formatSignedMetric(row.varianceDelta),
+      formatMetric(row.noiseBand),
       row.change,
       row.varianceChange,
       row.comparability.comparable ? "comparable" : `incomparable:${row.comparability.mismatchedFields.join(",")}`,
@@ -586,6 +639,10 @@ function renderEvalComparisonV4(summary) {
     ""
   ].join("\n");
 }
+function renderEvalComparisonRoutesV1(identity) {
+  const render = (targets) => targets.map((target) => `${target.id}/${target.model ?? "none"}`).join(",") || "missing";
+  return `${render(identity.baselineTargets ?? [identity.target])} -> ${render(identity.candidateTargets ?? [identity.target])}`;
+}
 function behaviorRollups(rows, keyOf) {
   const groups = /* @__PURE__ */ new Map();
   for (const row of rows) groups.set(keyOf(row), [...groups.get(keyOf(row)) ?? [], row]);
@@ -845,7 +902,7 @@ function renderEvalComparisonReportV1(summary, format2) {
 }
 function renderMarkdown(summary) {
   const rows = summary.behavioralMetrics.map(
-    (row) => `| ${cell(row.scenarioId)} | ${cell(row.role)} | ${cell(`${row.target.id}/${row.target.model ?? "none"}`)} | ${row.family} | ${row.metric} | ${format(row.baseline.mean)} | ${format(row.baseline.variance)} | ${row.baseline.measured}/${row.baseline.observations} | ${format(row.candidate.mean)} | ${format(row.candidate.variance)} | ${row.candidate.measured}/${row.candidate.observations} | ${row.change} | ${row.varianceChange} | ${row.comparability.comparable ? "comparable" : cell(row.comparability.mismatchedFields.join(", "))} | ${row.hardGate ? "hard" : "informational"} |`
+    (row) => `| ${cell(row.scenarioId)} | ${cell(row.role)} | ${cell(renderEvalComparisonRoutesV1(row))} | ${row.family} | ${row.metric} | ${format(row.baseline.mean)} | ${format(row.baseline.variance)} | ${row.baseline.measured}/${row.baseline.observations} | ${format(row.candidate.mean)} | ${format(row.candidate.variance)} | ${row.candidate.measured}/${row.candidate.observations} | ${format(row.noiseBand)} | ${row.change} | ${row.varianceChange} | ${row.comparability.comparable ? "comparable" : cell(row.comparability.mismatchedFields.join(", "))} | ${row.hardGate ? "hard" : "informational"} |`
   );
   const scenarioRows = summary.scenarioReports.map(
     (report) => `| ${cell(report.id)} | ${changeCounts2(report.metrics)} | ${changeCounts2(report.variance)} |`
@@ -858,10 +915,10 @@ function renderMarkdown(summary) {
     "",
     `Behavioral hard gate: **${summary.hardGate.pass ? "pass" : "fail"}**`,
     ...summary.hardGate.failures.map(
-      (failure) => `- Hard failure: ${failure.scenarioId} / ${failure.role} / ${failure.target.id}/${failure.target.model ?? "none"} / ${failure.metric}: ${failure.change}`
+      (failure) => `- Hard failure: ${failure.scenarioId} / ${failure.role} / ${renderEvalComparisonRoutesV1(failure)} / ${failure.metric}: ${failure.change}`
     ),
     ...summary.envelopeMismatches.map(
-      (mismatch) => `- Incomparable envelope: ${mismatch.scenarioId} / ${mismatch.role} / ${mismatch.target.id}/${mismatch.target.model ?? "none"}: ${mismatch.fields.join(", ")}`
+      (mismatch) => `- Incomparable envelope: ${mismatch.scenarioId} / ${mismatch.role} / ${renderEvalComparisonRoutesV1(mismatch)}: ${mismatch.fields.join(", ")}`
     ),
     ...summary.affectedCorpusResults.map(
       (result) => `- Affected corpus result: ${result.scenarioId} / ${result.role}: ${result.changedFields.join(", ")}`
@@ -870,8 +927,8 @@ function renderMarkdown(summary) {
     `Token delta: ${summary.tokenDelta === null ? "unmeasured" : summary.tokenDelta}`,
     `Wall-time delta ms: ${summary.wallTimeDelta}`,
     "",
-    "| Scenario | Role | Target/model | Family | Metric | Baseline mean | Baseline variance | Baseline measured | Candidate mean | Candidate variance | Candidate measured | Change | Variance | Comparability | Gate |",
-    "|---|---|---|---|---|---:|---:|---:|---:|---:|---:|---|---|---|---|",
+    "| Scenario | Role | Baseline -> candidate target/model | Family | Metric | Baseline mean | Baseline variance | Baseline measured | Candidate mean | Candidate variance | Candidate measured | Noise band | Change | Variance | Comparability | Gate |",
+    "|---|---|---|---|---|---:|---:|---:|---:|---:|---:|---:|---|---|---|---|",
     ...rows,
     "",
     "## Per-scenario baseline/candidate report",
@@ -896,7 +953,7 @@ function renderJunit(summary) {
   );
   const represented = /* @__PURE__ */ new Set();
   const cases = summary.behavioralMetrics.map((row) => {
-    const name = `${row.scenarioId}[${row.role}:${row.target.id}:${row.target.model ?? "none"}].${row.metric}`;
+    const name = `${row.scenarioId}[${row.role}:${renderEvalComparisonRoutesV1(row)}].${row.metric}`;
     const key = JSON.stringify([row.scenarioId, row.role, row.target.id, row.target.model, row.metric]);
     represented.add(key);
     const detail = `change=${row.change} variance=${row.varianceChange} baseline=${format(row.baseline.mean)} candidate=${format(row.candidate.mean)}`;
@@ -911,13 +968,13 @@ function renderJunit(summary) {
       failure.metric
     ]);
     if (represented.has(key)) continue;
-    const name = `${failure.scenarioId}[${failure.role}:${failure.target.id}:${failure.target.model ?? "none"}].${failure.metric}`;
+    const name = `${failure.scenarioId}[${failure.role}:${renderEvalComparisonRoutesV1(failure)}].${failure.metric}`;
     cases.push(
       `  <testcase classname="eval.behavior.hard" name="${escapeXml(name)}"><failure message="${escapeXml(failure.change)}">hard behavioral gate</failure></testcase>`
     );
   }
   for (const failure of summary.hardGate.envelopeFailures) {
-    const name = `${failure.scenarioId}[${failure.role}:${failure.target.id}:${failure.target.model ?? "none"}].execution-envelope`;
+    const name = `${failure.scenarioId}[${failure.role}:${renderEvalComparisonRoutesV1(failure)}].execution-envelope`;
     cases.push(
       `  <testcase classname="eval.behavior.envelope" name="${escapeXml(name)}"><failure message="incomparable">${escapeXml(failure.fields.join(", "))}</failure></testcase>`
     );
@@ -1261,6 +1318,7 @@ function readVerify(value, path, issues) {
   return {
     commands: readOptionalStringArray(value, "commands", `${path}.commands`, issues),
     measure: readOptionalStringArray(value, "measure", `${path}.measure`, issues),
+    protectedFiles: readOptionalStringArray(value, "protectedFiles", `${path}.protectedFiles`, issues),
     assertions: readAssertions(value.assertions, `${path}.assertions`, issues),
     forbidPaths: readOptionalStringArray(value, "forbidPaths", `${path}.forbidPaths`, issues)
   };
@@ -1481,9 +1539,10 @@ function resolveTargets(targets, options) {
 
 // src/domains/eval/suites/run.ts
 init_esm_shims();
-import { mkdtemp as mkdtemp3, rm as rm3, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { lstat as lstat3, mkdir, mkdtemp as mkdtemp3, open, readdir, realpath, rm as rm3, writeFile } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import { resolve as resolve7 } from "node:path";
+import { isAbsolute as isAbsolute3, relative as relative4, resolve as resolve9, sep as sep3 } from "node:path";
 
 // src/domains/eval/execution-provenance.ts
 init_esm_shims();
@@ -1644,6 +1703,9 @@ function sha256(value) {
 
 // src/domains/eval/metrics/context.ts
 init_esm_shims();
+import { createHash as createHash3 } from "node:crypto";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join } from "node:path";
 function collectContextMetrics(cwd) {
   try {
     const codewiki = readCodewiki(cwd);
@@ -1651,13 +1713,26 @@ function collectContextMetrics(cwd) {
     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;
+    let contentValidFiles = 0;
+    let missingFiles = 0;
+    for (const file of artifactSourceFiles) {
+      try {
+        const hash = createHash3("sha256").update(readFileSync2(join(cwd, file.path), "utf8")).digest("hex").slice(0, 16);
+        if (visiblePaths.has(file.path) && file.hash === hash) contentValidFiles += 1;
+      } catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR") missingFiles += 1;
+      }
+    }
+    const staleFiles = artifactSourceFiles.length - contentValidFiles;
     const sourceFiles = detectProjectProfile(cwd).sourceFiles;
     const digest = renderCodewikiDigest(codewiki);
     return {
       "context.indexedFiles": indexedFiles,
       "context.artifactFiles": artifactSourceFiles.length,
       "context.staleFiles": staleFiles,
+      "context.contentValidFiles": contentValidFiles,
+      "context.missingFiles": missingFiles,
       "context.coverage": sourceFiles === 0 ? artifactSourceFiles.length === 0 ? 1 : 0 : indexedFiles / sourceFiles,
       "context.structuralHash": structuralCodewikiHash(codewiki),
       "context.digestTokens": Math.ceil(digest.length / 4)
@@ -1667,6 +1742,8 @@ function collectContextMetrics(cwd) {
       "context.indexedFiles": 0,
       "context.artifactFiles": 0,
       "context.staleFiles": 0,
+      "context.contentValidFiles": 0,
+      "context.missingFiles": 0,
       "context.coverage": 0,
       "context.structuralHash": null,
       "context.digestTokens": 0
@@ -1769,13 +1846,13 @@ function isRecord3(value) {
 
 // src/domains/eval/metrics/invariants.ts
 init_esm_shims();
-import { existsSync, readdirSync, readFileSync as readFileSync2 } from "node:fs";
-import { join } from "node:path";
+import { existsSync, readdirSync, readFileSync as readFileSync3 } from "node:fs";
+import { join as join2 } from "node:path";
 function readRunJournal(stateDir) {
   if (!existsSync(stateDir)) return null;
   return {
-    envelopes: readEnvelopes(join(stateDir, "runs.json")),
-    ...readReceipts(join(stateDir, "receipts"))
+    envelopes: readEnvelopes(join2(stateDir, "runs.json")),
+    ...readReceipts(join2(stateDir, "receipts"))
   };
 }
 function readEnvelopes(runsPath) {
@@ -1783,7 +1860,7 @@ function readEnvelopes(runsPath) {
   if (!existsSync(runsPath)) return envelopes;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync2(runsPath, "utf8"));
+    parsed = JSON.parse(readFileSync3(runsPath, "utf8"));
   } catch {
     return envelopes;
   }
@@ -1804,7 +1881,7 @@ function readReceipts(receiptsDir) {
   const receipts = [];
   for (const name of names) {
     try {
-      const parsed = JSON.parse(readFileSync2(join(receiptsDir, name), "utf8"));
+      const parsed = JSON.parse(readFileSync3(join2(receiptsDir, name), "utf8"));
       if (isReceiptShaped(parsed)) receipts.push(parsed);
     } catch {
     }
@@ -1873,7 +1950,7 @@ function isRootReceipt(receipt) {
   return receipt.lineage === void 0 || receipt.lineage.rootRunId === receipt.runId;
 }
 function sessionInvariantMetrics(stateDir) {
-  const sessionDirs = findSessionDirs(join(stateDir, "sessions"));
+  const sessionDirs = findSessionDirs(join2(stateDir, "sessions"));
   if (sessionDirs.length === 0) return {};
   let formatVersion = Number.POSITIVE_INFINITY;
   let toolPairsUnmatched = 0;
@@ -1882,7 +1959,7 @@ function sessionInvariantMetrics(stateDir) {
   let answeredFromPreCompaction = false;
   let turnsAfterCompaction = 0;
   for (const sessionDir of sessionDirs) {
-    const transcript = readSessionTranscript(join(sessionDir, "current.jsonl"));
+    const transcript = readSessionTranscript(join2(sessionDir, "current.jsonl"));
     formatVersion = Math.min(formatVersion, transcript.formatVersion);
     toolPairsUnmatched += transcript.toolPairsUnmatched;
     assistantBetweenCallAndResult += transcript.assistantBetweenCallAndResult;
@@ -1905,10 +1982,10 @@ function findSessionDirs(sessionsRoot) {
     const dirs = [];
     for (const cwdDir of readdirSync(sessionsRoot, { withFileTypes: true })) {
       if (!cwdDir.isDirectory()) continue;
-      const cwdPath = join(sessionsRoot, cwdDir.name);
+      const cwdPath = join2(sessionsRoot, cwdDir.name);
       try {
         for (const sessionDir of readdirSync(cwdPath, { withFileTypes: true })) {
-          if (sessionDir.isDirectory()) dirs.push(join(cwdPath, sessionDir.name));
+          if (sessionDir.isDirectory()) dirs.push(join2(cwdPath, sessionDir.name));
         }
       } catch {
       }
@@ -1921,7 +1998,7 @@ function findSessionDirs(sessionsRoot) {
 function readSessionTranscript(path) {
   let lines;
   try {
-    lines = readFileSync2(path, "utf8").split(/\r?\n/u);
+    lines = readFileSync3(path, "utf8").split(/\r?\n/u);
   } catch {
     return {
       formatVersion: 0,
@@ -2041,7 +2118,7 @@ function isProcessAlive(pid) {
   }
 }
 function writeBoundaryInvariantMetrics(stateDir) {
-  const files = findWriteBoundaryVerdicts(join(stateDir, "write-boundaries"));
+  const files = findWriteBoundaryVerdicts(join2(stateDir, "write-boundaries"));
   if (files.length === 0) return {};
   let sealed = true;
   let violationsDetected = 0;
@@ -2072,10 +2149,10 @@ function findWriteBoundaryVerdicts(root) {
   try {
     for (const rootDir of readdirSync(root, { withFileTypes: true })) {
       if (!rootDir.isDirectory()) continue;
-      const dir = join(root, rootDir.name);
+      const dir = join2(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));
+          if (entry.isFile() && entry.name.endsWith(".json")) files.push(join2(dir, entry.name));
         }
       } catch {
       }
@@ -2087,7 +2164,7 @@ function findWriteBoundaryVerdicts(root) {
 }
 function parseJsonFile(path) {
   try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
     return isRecord4(parsed) ? parsed : void 0;
   } catch {
     return void 0;
@@ -2290,7 +2367,7 @@ function zeroToolCallMetrics() {
 // src/domains/eval/metrics/tracked.ts
 init_esm_shims();
 import { readFile as readFile2 } from "node:fs/promises";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { dirname as dirname2, join as join3 } from "node:path";
 function selectEvalLedgerEntries(durable, stream) {
   const sessionCalls = assistantCalls(durable).length;
   const streamCalls = assistantCalls(stream).length;
@@ -2314,7 +2391,7 @@ async function readEvalLedgerSnapshot(stateDir) {
     } catch {
     }
     try {
-      const manifest = await readFile2(join2(dirname2(ref.path), "prompt-manifest.jsonl"), "utf8");
+      const manifest = await readFile2(join3(dirname2(ref.path), "prompt-manifest.jsonl"), "utf8");
       for (const line of manifest.split(/\r?\n/u)) {
         const record = parseJsonRecord2(line);
         if (record === null) continue;
@@ -2327,7 +2404,7 @@ async function readEvalLedgerSnapshot(stateDir) {
     } catch {
     }
     try {
-      const snapshots = await readFile2(join2(dirname2(ref.path), "context-snapshots.jsonl"), "utf8");
+      const snapshots = await readFile2(join3(dirname2(ref.path), "context-snapshots.jsonl"), "utf8");
       for (const line of snapshots.split(/\r?\n/u)) {
         const record = parseJsonRecord2(line);
         if (record === null) continue;
@@ -2580,14 +2657,7 @@ function promptManifestObservation(record) {
     return contentHash === null ? [] : [{ id: entry.id, contentHash }];
   });
   const preload = record.projectPreload;
-  const projectPreload = preload === null ? null : isRecord5(preload) && (preload.mode === "full" || preload.mode === "synopsis" || preload.mode === "none") && typeof preload.chars === "number" && Number.isInteger(preload.chars) && typeof preload.lines === "number" && Number.isInteger(preload.lines) && typeof preload.nearLimit === "boolean" && typeof preload.label === "string" ? {
-    mode: preload.mode,
-    chars: preload.chars,
-    lines: preload.lines,
-    reason: nullableString(preload.reason),
-    nearLimit: preload.nearLimit,
-    label: preload.label
-  } : null;
+  const projectPreload = isProjectPreloadClass(preload) ? preload : null;
   return {
     systemPromptHash,
     thinkingLevel: nullableString(record.thinkingLevel),
@@ -2611,8 +2681,8 @@ import { isAbsolute, relative, resolve as resolve2, sep } from "node:path";
 
 // src/domains/eval/metrics/evidence.ts
 init_esm_shims();
-import { readFileSync as readFileSync3 } from "node:fs";
-import { join as join3 } from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+import { join as join4 } from "node:path";
 function dispatchScopeMetrics(receipt) {
   const scope = receipt.pathScope;
   if (scope === void 0) return {};
@@ -2676,7 +2746,7 @@ function evidenceTrustMetrics(receipt, envelope) {
 }
 function readRunEnvelopeForReceipt(receipt, stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync3(join3(stateDir, "runs.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync4(join4(stateDir, "runs.json"), "utf8"));
     if (!Array.isArray(parsed)) return null;
     const row = parsed.find(
       (entry) => typeof entry === "object" && entry !== null && entry.id === receipt.runId
@@ -3073,7 +3143,7 @@ async function runExternalCommandRunner(runner, cwd, timeoutMs, env) {
 }
 function runShellCommand(command, cwd, timeoutMs, env) {
   const started = performance2.now();
-  return new Promise((resolve9) => {
+  return new Promise((resolve11) => {
     let stdout = "";
     let stderr = "";
     const metricCapture = createJsonlMetricCapture();
@@ -3109,7 +3179,7 @@ function runShellCommand(command, cwd, timeoutMs, env) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve9({
+      resolve11({
         command: commandLine,
         exitCode,
         stdout,
@@ -3379,19 +3449,22 @@ function toolBehaviorMetricEntriesFromJsonl(stdout, cwd, readObservation) {
   const terminals = canonicalFinishes.length > 0 ? canonicalFinishes : executionEnds;
   const calls = /* @__PURE__ */ new Map();
   const succeeded = /* @__PURE__ */ new Map();
+  const failed = /* @__PURE__ */ new Map();
   const blocked = /* @__PURE__ */ new Map();
   for (const terminal of terminals) {
     const tool = metricToolName(terminal.tool);
     calls.set(tool, (calls.get(tool) ?? 0) + 1);
     if (terminal.outcome === "ok") succeeded.set(tool, (succeeded.get(tool) ?? 0) + 1);
     if (terminal.outcome === "blocked") blocked.set(tool, (blocked.get(tool) ?? 0) + 1);
+    if (terminal.outcome === "error") failed.set(tool, (failed.get(tool) ?? 0) + 1);
   }
-  const namedTools = /* @__PURE__ */ new Set(["bash", "dispatch", "read", ...calls.keys(), ...succeeded.keys(), ...blocked.keys()]);
+  const namedTools = /* @__PURE__ */ new Set([...ALL_TOOL_NAMES, ...calls.keys()]);
   const entries = { "tools.read.distinctPaths": readPaths.size };
   for (const tool of [...namedTools].sort()) {
     entries[`tools.calls.${tool}`] = calls.get(tool) ?? 0;
     entries[`tools.succeeded.${tool}`] = succeeded.get(tool) ?? 0;
     entries[`tools.blocked.${tool}`] = blocked.get(tool) ?? 0;
+    entries[`tools.failed.${tool}`] = failed.get(tool) ?? 0;
   }
   if (readObservation !== void 0) {
     const allowed = readObservation.allowedPaths.map((path) => normalizeObservedPath(cwd, path));
@@ -3484,7 +3557,7 @@ function parseContextIndexOutput(stdout) {
 // src/domains/eval/runners/context-init.ts
 init_esm_shims();
 import { existsSync as existsSync2, statSync } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 async function runContextInitRunner(runner, cwd, clioEntry, timeoutMs, target, env) {
   const extraArgs = runner.args ?? [];
   const args = [
@@ -3517,7 +3590,7 @@ async function runContextInitRunner(runner, cwd, clioEntry, timeoutMs, target, e
   const effectiveRuntimeKind = stringField3(run, "runtimeKind");
   const effectiveThinking = stringField3(run, "thinkingLevel");
   const structuredOutputMode = stringField3(run, "structuredOutputMode");
-  const clioMdPath = join4(cwd, "CLIO-CODER.md");
+  const clioMdPath = join5(cwd, "CLIO-CODER.md");
   const clioMdBytes = existsSync2(clioMdPath) ? statSync(clioMdPath).size : 0;
   return {
     assignmentId: null,
@@ -3654,7 +3727,7 @@ function stringField3(value, field) {
 
 // src/domains/eval/schema/adapter.ts
 init_esm_shims();
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function adaptSuiteV2ResultToVerdictV1(result, trackedMetrics) {
   const machinery = result.pass || result.failureClass === "grader_failed" ? "ok" : "infrastructure_failure";
   const outcome = result.pass ? "pass" : "fail";
@@ -3688,7 +3761,7 @@ function adaptSuiteV2ResultToBehaviorV1(result, verdict, scenario) {
     observedSources.add(source);
     if (!requestedFacts.has(`${source}\0${key}`)) return [];
     const serialized = JSON.stringify({ source, key, value });
-    const digest = createHash3("sha256").update(serialized, "utf8").digest("hex");
+    const digest = createHash4("sha256").update(serialized, "utf8").digest("hex");
     const fact = {
       id: `metric-${digest.slice(0, 16)}`,
       source,
@@ -3743,12 +3816,93 @@ function forbiddenPathHits(cwd, paths) {
   return paths.filter((path) => existsSync3(resolve3(cwd, path)));
 }
 
+// src/domains/eval/verifiers/integrity.ts
+init_esm_shims();
+import { createHash as createHash5 } from "node:crypto";
+import { lstat, readFile as readFile3 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve4, sep as sep2 } from "node:path";
+var EvalGraderIntegrityError = class extends Error {
+};
+async function protectGraderFiles(cwd, files) {
+  const paths = files.map((file) => {
+    const path = resolve4(cwd, file);
+    const rel = relative2(cwd, path);
+    if (isAbsolute2(file) || rel === ".." || rel.startsWith(`..${sep2}`))
+      throw new EvalGraderIntegrityError(`grader dependency escapes workspace: ${file}`);
+    return path;
+  });
+  const fingerprint = async (path) => {
+    let current = path;
+    while (current !== resolve4(cwd)) {
+      if ((await lstat(current)).isSymbolicLink())
+        throw new EvalGraderIntegrityError(`grader dependency is a symlink: ${path}`);
+      current = resolve4(current, "..");
+    }
+    return createHash5("sha256").update(await readFile3(path)).digest("hex");
+  };
+  const hashes = await Promise.all(paths.map(fingerprint));
+  return async () => {
+    for (const [index, path] of paths.entries()) {
+      try {
+        if (await fingerprint(path) === hashes[index]) continue;
+      } catch {
+      }
+      throw new EvalGraderIntegrityError(`grader dependency changed during trial: ${relative2(cwd, path)}`);
+    }
+  };
+}
+
 // src/domains/eval/verifiers/patch.ts
 init_esm_shims();
 import { spawnSync } from "node:child_process";
+import { createHash as createHash6 } from "node:crypto";
+import { readdirSync as readdirSync2, readFileSync as readFileSync5, readlinkSync } from "node:fs";
+import { join as join6, resolve as resolve5 } from "node:path";
+var baselines = /* @__PURE__ */ new Map();
+function recordPatchBaseline(cwd) {
+  baselines.set(resolve5(cwd), snapshotFiles(cwd));
+}
+function forgetPatchBaseline(cwd) {
+  baselines.delete(resolve5(cwd));
+}
+function snapshotFiles(cwd) {
+  const files = /* @__PURE__ */ new Map();
+  function walk(dir, prefix) {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      if (entry.name === ".git") continue;
+      const path = join6(dir, entry.name);
+      const relative5 = prefix + entry.name;
+      if (entry.isDirectory()) walk(path, `${relative5}/`);
+      else if (entry.isFile() || entry.isSymbolicLink()) {
+        const bytes = entry.isSymbolicLink() ? Buffer.from(readlinkSync(path)) : readFileSync5(path);
+        files.set(relative5, {
+          hash: createHash6("sha256").update(entry.isSymbolicLink() ? "link:" : "file:").update(bytes).digest("hex"),
+          bytes: bytes.length
+        });
+      }
+    }
+  }
+  walk(cwd, "");
+  return files;
+}
 function collectPatchMetrics(cwd) {
+  const baseline = baselines.get(resolve5(cwd));
+  if (baseline !== void 0) {
+    const current = snapshotFiles(cwd);
+    const changed = [.../* @__PURE__ */ new Set([...baseline.keys(), ...current.keys()])].filter(
+      (path) => baseline.get(path)?.hash !== current.get(path)?.hash
+    );
+    return {
+      // For hash baselines this is changed file content bytes, including deleted
+      // content, rather than a textual Git diff (which cannot represent all files).
+      bytes: changed.reduce((sum2, path) => sum2 + (current.get(path)?.bytes ?? baseline.get(path)?.bytes ?? 0), 0),
+      filesChanged: changed.length,
+      testFilesModified: changed.filter((file) => /(^|\/)(test|tests|spec|__tests__)(\/|$)|\.(test|spec)\./.test(file)).length
+    };
+  }
   const diff = spawnSync("git", ["diff", "--", "."], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
-  const text = diff.status === 0 && typeof diff.stdout === "string" ? diff.stdout : "";
+  if (diff.status !== 0 || typeof diff.stdout !== "string") return null;
+  const text = 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"),
@@ -3762,10 +3916,10 @@ init_esm_shims();
 import { spawn as spawn2 } from "node:child_process";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 async function prepareGitWorkspace(workspace) {
   if (workspace.url === void 0) throw new Error("git workspace requires url");
-  const dest = await mkdtemp(resolve4(tmpdir(), "clio-coder-eval-git-"));
+  const dest = await mkdtemp(resolve6(tmpdir(), "clio-coder-eval-git-"));
   try {
     await runGit(["clone", "--quiet", workspace.url, dest], process.cwd());
     const ref = workspace.checkout ?? workspace.commit;
@@ -3800,9 +3954,9 @@ function runGit(args, cwd) {
 // src/domains/eval/workspaces/local.ts
 init_esm_shims();
 import { access } from "node:fs/promises";
-import { resolve as resolve5 } from "node:path";
+import { resolve as resolve7 } from "node:path";
 async function prepareLocalWorkspace(baseDir, workspace) {
-  const dir = resolve5(baseDir, workspace.path ?? ".");
+  const dir = resolve7(baseDir, workspace.path ?? ".");
   await access(dir);
   return { dir, cleanup: async () => {
   } };
@@ -3811,26 +3965,28 @@ async function prepareLocalWorkspace(baseDir, workspace) {
 // src/domains/eval/workspaces/temp-copy.ts
 init_esm_shims();
 import { execFile } from "node:child_process";
-import { cp, lstat, mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
+import { cp, lstat as lstat2, mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { relative as relative2, resolve as resolve6 } from "node:path";
+import { relative as relative3, resolve as resolve8 } from "node:path";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
 var GIT_FILE_LIST_LIMIT_BYTES = 128 * 1024 * 1024;
 async function prepareTempCopyWorkspace(baseDir, workspace, options = {}) {
-  const source = resolve6(baseDir, workspace.path ?? ".");
-  const dest = await mkdtemp2(resolve6(options.tempRoot ?? tmpdir2(), "clio-coder-eval-workspace-"));
+  const source = resolve8(baseDir, workspace.path ?? ".");
+  const dest = await mkdtemp2(resolve8(options.tempRoot ?? tmpdir2(), "clio-coder-eval-workspace-"));
   try {
     const selection = await gitCopySelection(source);
     const excludes = workspace.excludes ?? [];
     const copyWorkspace = options.copy ?? defaultCopy;
     await copyWorkspace(source, dest, {
       recursive: true,
-      filter: (path) => shouldCopy(relative2(source, path), excludes, selection)
+      filter: (path) => shouldCopy(relative3(source, path), excludes, selection)
     });
+    recordPatchBaseline(dest);
     return {
       dir: dest,
       cleanup: async () => {
+        forgetPatchBaseline(dest);
         await rm2(dest, { recursive: true, force: true });
       }
     };
@@ -3903,16 +4059,16 @@ function normalizeGitPath(path) {
   return normalized;
 }
 async function hasGitMarker(source) {
-  let current = resolve6(source);
+  let current = resolve8(source);
   while (true) {
     try {
-      await lstat(resolve6(current, ".git"));
+      await lstat2(resolve8(current, ".git"));
       return true;
     } catch (error) {
       const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
       if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
     }
-    const parent = resolve6(current, "..");
+    const parent = resolve8(current, "..");
     if (parent === current) return false;
     current = parent;
   }
@@ -3959,7 +4115,8 @@ async function runEvalSuiteV2(loaded, options) {
       item.repeatIndex,
       options.clioEntry,
       options.freshWorkspaces === true,
-      options.tempCopy
+      options.tempCopy,
+      resolve9(clioDataDir(), "evals", evalId, "transcripts", String(results.length))
     );
     spentUsd += resultCostUsd(completed.result);
     results.push(completed.result);
@@ -3996,27 +4153,33 @@ function budgetExhaustedResult(loaded, task, target, repeatIndex, spentUsd, maxC
   attachExecutionEnvelope(result, task, target, loaded.baseDir, null, emptyLedgerSnapshot());
   return result;
 }
-async function runMatrixItem(loaded, task, target, repeatIndex, clioEntry, freshWorkspace, tempCopy) {
+async function runMatrixItem(loaded, task, target, repeatIndex, clioEntry, freshWorkspace, tempCopy, transcriptDir) {
   let workspace = null;
   let receipt = null;
   let runnerWallTimeMs = 0;
+  let runnerEvidence = null;
+  let retention;
   let executionObservation;
-  const stateDir = await mkdtemp3(resolve7(tempCopy?.tempRoot ?? tmpdir3(), "clio-coder-eval-state-"));
+  const stateDir = await mkdtemp3(resolve9(tempCopy?.tempRoot ?? tmpdir3(), "clio-coder-eval-state-"));
   try {
     workspace = await prepareWorkspace(loaded.baseDir, task, freshWorkspace, tempCopy);
     const setup = await runCommandVerifiers(task.workspace.setup ?? [], workspace.dir, task.timeoutMs);
     if (!setup.pass) throw new EvalWorkspaceSetupError(setup.exitCode, setup.stderr);
+    if (task.workspace.kind !== "local" || freshWorkspace) recordPatchBaseline(workspace.dir);
+    const checkGraderIntegrity = await protectGraderFiles(workspace.dir, task.verify.protectedFiles ?? []);
     const runner = await runTaskRunner(task, target, workspace.dir, clioEntry, {
       CLIO_CODER_STATE_DIR: stateDir,
       CLIO_CODER_ENTRY: clioEntry
     });
-    const runnerStdoutFile = resolve7(stateDir, "eval-runner-output.jsonl");
-    await writeFile(runnerStdoutFile, runner.stdout, "utf8");
+    runnerEvidence = runner;
     receipt = runner.receipt ?? null;
     runnerWallTimeMs = runner.wallTimeMs;
+    const runnerStdoutFile = resolve9(stateDir, "eval-runner-output.jsonl");
+    await writeFile(runnerStdoutFile, runner.stdout, { encoding: "utf8", mode: 384, flag: "wx" });
     const patch = collectPatchMetrics(workspace.dir);
     const receiptExitCode = runner.exitCode;
     const journalMetrics = invariantMetrics(stateDir, receiptExitCode);
+    await checkGraderIntegrity();
     const measurement = await measureTaskOutcome(task, workspace.dir, {
       ...namingCompatibilityEnvironment(
         "CLIO_CODER_EVAL_RUNNER_STDOUT_FILE",
@@ -4035,14 +4198,18 @@ async function runMatrixItem(loaded, task, target, repeatIndex, clioEntry, fresh
       // 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,
+      ...patch === null ? {} : {
+        "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",
       ...measurement.metrics
     };
+    await checkGraderIntegrity();
     const verifier = await runVerifiers(task, workspace.dir, metrics);
+    await checkGraderIntegrity();
     const graderFailed = metrics["task.solved"] === false;
     const pass = runner.exitCode === 0 && verifier.pass && !graderFailed;
     const failureClass = pass ? null : runner.exitCode !== 0 ? "runner_failed" : !verifier.pass ? verifier.failureClass : "grader_failed";
@@ -4065,7 +4232,10 @@ async function runMatrixItem(loaded, task, target, repeatIndex, clioEntry, fresh
         ...verifier.stderr.length > 0 ? { verifierStderr: verifier.stderr } : {}
       }
     };
-    const snapshot = await readEvalLedgerSnapshot(stateDir);
+    retention ??= retainSessionLedgers(stateDir, transcriptDir, runnerEvidence?.stdout);
+    const retained = await retention;
+    applyRetainedSessionLedgers(result, retained);
+    const snapshot = retained.errors.length > 0 ? emptyLedgerSnapshot() : await readEvalLedgerSnapshot(stateDir);
     const selected = selectEvalLedgerEntries(snapshot.entries, runner.ledgerEntries ?? []);
     result.artifacts.trackedMetricSources = JSON.stringify({
       assistantCalls: selected.source,
@@ -4094,10 +4264,10 @@ async function runMatrixItem(loaded, task, target, repeatIndex, clioEntry, fresh
       serving: evalServingObservationFrom(target, receipt ?? null, snapshot.compiledPromptHashes)
     };
   } catch (error) {
-    const failureClass = error instanceof EvalWorkspaceSetupError ? "setup_failed" : "command_error";
+    const failureClass = error instanceof EvalGraderIntegrityError ? "grader_integrity" : error instanceof EvalWorkspaceSetupError ? "setup_failed" : "command_error";
     const result = {
-      assignmentId: null,
-      terminalReceiptDigest: null,
+      assignmentId: runnerEvidence?.assignmentId ?? null,
+      terminalReceiptDigest: runnerEvidence?.terminalReceiptDigest ?? null,
       taskId: task.id,
       repeatIndex,
       target: { id: target.id, model: target.model ?? null, thinking: target.thinking ?? null },
@@ -4110,11 +4280,15 @@ async function runMatrixItem(loaded, task, target, repeatIndex, clioEntry, fresh
         "latency.wallMs": 0
       },
       artifacts: {
+        ...runnerEvidence?.artifacts,
         error: error instanceof Error ? error.message : String(error),
         ...workspace === null ? {} : { workspace: workspace.dir }
       }
     };
-    const snapshot = await readEvalLedgerSnapshot(stateDir);
+    retention ??= retainSessionLedgers(stateDir, transcriptDir, runnerEvidence?.stdout);
+    const retained = await retention;
+    applyRetainedSessionLedgers(result, retained);
+    const snapshot = retained.errors.length > 0 ? emptyLedgerSnapshot() : await readEvalLedgerSnapshot(stateDir);
     result.verdict = adaptSuiteV2ResultToVerdictV1(
       result,
       buildEvalTrackedMetrics({
@@ -4139,6 +4313,7 @@ async function runMatrixItem(loaded, task, target, repeatIndex, clioEntry, fresh
     };
   } finally {
     try {
+      if (workspace !== null) forgetPatchBaseline(workspace.dir);
       await workspace?.cleanup();
     } finally {
       await rm3(stateDir, { recursive: true, force: true });
@@ -4328,6 +4503,128 @@ function nullableNonNegativeInteger(value) {
 function stringArray(value) {
   return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
 }
+function applyRetainedSessionLedgers(result, retained) {
+  if (retained.runnerStdoutPath !== void 0) result.artifacts.runnerStdoutFile = retained.runnerStdoutPath;
+  if (retained.paths.length > 0 || retained.errors.length > 0) result.artifacts.sessionLedgers = retained.paths;
+  if (retained.errors.length === 0) return;
+  result.artifacts.sessionLedgerErrors = retained.errors;
+  result.metrics["evidence.retentionComplete"] = false;
+  if (result.pass || result.failureClass === "grader_failed") {
+    result.artifacts.outcomeBeforeEvidenceFailure = result.failureClass ?? "pass";
+    result.pass = false;
+    result.failureClass = "evidence_integrity";
+    result.metrics["result.pass"] = false;
+    result.metrics["result.failureClass"] = "evidence_integrity";
+  }
+}
+async function plainLedgerPath(root, path) {
+  const rel = relative4(root, path);
+  if (isAbsolute3(rel) || rel === ".." || rel.startsWith(`..${sep3}`)) throw new Error("unsafe ledger path");
+  let current = root;
+  for (const part of ["", ...rel.split(sep3)]) {
+    current = resolve9(current, part);
+    if ((await lstat3(current)).isSymbolicLink()) throw new Error("unsafe ledger symlink");
+  }
+}
+async function readOwnedLedger(root, path) {
+  await plainLedgerPath(root, path);
+  const before = await lstat3(path);
+  if (!before.isFile()) throw new Error("ledger is not a regular file");
+  const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const opened = await file.stat();
+    await plainLedgerPath(root, path);
+    if (opened.dev !== before.dev || opened.ino !== before.ino) throw new Error("ledger changed while opening");
+    return await file.readFile();
+  } finally {
+    await file.close();
+  }
+}
+async function transcriptCaptureDirectory(destination) {
+  const base = clioDataDir();
+  await mkdir(base, { recursive: true, mode: 448 });
+  let current = await realpath(base);
+  const rel = relative4(base, destination);
+  if (isAbsolute3(rel) || rel === ".." || rel.startsWith(`..${sep3}`)) throw new Error("unsafe transcript destination");
+  for (const part of rel.split(sep3)) {
+    current = resolve9(current, part);
+    try {
+      await mkdir(current, { mode: 448 });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    const info = await lstat3(current);
+    if (info.isSymbolicLink() || !info.isDirectory()) throw new Error("unsafe transcript destination");
+  }
+  return mkdtemp3(resolve9(current, "capture-"));
+}
+async function discoverOwnedLedgers(stateDir, errors) {
+  const root = resolve9(stateDir, "sessions");
+  try {
+    await plainLedgerPath(stateDir, root);
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const paths = [];
+  for (const cwd of await readdir(root, { withFileTypes: true })) {
+    if (cwd.isSymbolicLink()) {
+      errors.push("session directory rejected: symlink");
+      continue;
+    }
+    if (!cwd.isDirectory()) continue;
+    const cwdPath = resolve9(root, cwd.name);
+    try {
+      await plainLedgerPath(stateDir, cwdPath);
+      for (const session of await readdir(cwdPath, { withFileTypes: true })) {
+        if (session.isSymbolicLink()) {
+          errors.push("session directory rejected: symlink");
+          continue;
+        }
+        if (session.isDirectory()) paths.push(resolve9(cwdPath, session.name, "current.jsonl"));
+      }
+    } catch {
+      errors.push("session directory unreadable or unsafe");
+    }
+  }
+  return paths.sort();
+}
+async function retainSessionLedgers(stateDir, destination, runnerStdout) {
+  const retained = { paths: [], errors: [] };
+  try {
+    const refs = await discoverOwnedLedgers(stateDir, retained.errors);
+    if (refs.length === 0 && !runnerStdout) return retained;
+    const directory = await transcriptCaptureDirectory(destination);
+    if (runnerStdout) {
+      const path = resolve9(directory, "runner-stdout.jsonl");
+      await writeFile(path, runnerStdout, { mode: 384, flag: "wx" });
+      retained.runnerStdoutPath = path;
+    }
+    for (const [index, pathToLedger] of refs.entries()) {
+      try {
+        let content;
+        try {
+          content = await readOwnedLedger(stateDir, pathToLedger);
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+          content = await readOwnedLedger(stateDir, `${pathToLedger}.tmp`);
+          retained.errors.push(`ledger ${index}: incomplete current ledger; temporary evidence retained`);
+        }
+        const path = resolve9(directory, `${index}.jsonl`);
+        await writeFile(path, content, { mode: 384, flag: "wx" });
+        retained.paths.push(path);
+      } catch (error) {
+        const code = error.code;
+        retained.errors.push(
+          `ledger ${index}: retention failed (${code === "ENOENT" ? "missing" : "unsafe or unreadable"})`
+        );
+      }
+    }
+  } catch {
+    retained.errors.push("session ledger retention failed: artifact storage unavailable or unsafe");
+  }
+  return retained;
+}
 
 // src/cli/eval.ts
 var HELP = `clio-coder eval <command>
@@ -4421,6 +4718,11 @@ function parseEvalArgs(args) {
       throw new Error(`unknown eval run argument: ${arg}`);
     }
     if (parsed.command === "report") {
+      if (arg === "--artifact") {
+        parsed.artifact = requiredValue(args, index, "--artifact");
+        index += 1;
+        continue;
+      }
       if (arg === "--format") {
         parsed.format = reportFormat(requiredValue(args, index, "--format"));
         index += 1;
@@ -4477,7 +4779,9 @@ function parseEvalArgs(args) {
   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 === "report" && parsed.evalId === void 0 === (parsed.artifact === void 0)) {
+    throw new Error("report requires exactly one of an eval id or --artifact <path>");
+  }
   if (parsed.command === "compare" && parsed.compareIds.length !== 2) {
     throw new Error("compare requires <baselineEvalId> <candidateEvalId>");
   }
@@ -4488,7 +4792,7 @@ function parseEvalArgs(args) {
 }
 async function runEvalCommand(args) {
   if (args[0] === "inventory") {
-    const { runEvalInventory } = await import("./eval-inventory-Y6QRFOH5.js");
+    const { runEvalInventory } = await import("./eval-inventory-QOYZERXJ.js");
     return runEvalInventory(args.slice(1));
   }
   let parsed;
@@ -4531,13 +4835,15 @@ async function runEvalRun(parsed) {
       ...resolveOptions,
       ...parsed.trials ? { trials: parsed.trials } : {}
     });
-    const clioEntry = resolve8(parsed.clioEntry ?? process.argv[1] ?? "dist/cli/index.js");
+    const clioEntry = resolve10(parsed.clioEntry ?? process.argv[1] ?? "dist/cli/index.js");
     const artifact = await runEvalSuiteV2(
       { ...loaded, suite },
       { clioEntry, freshWorkspaces: parsed.trials !== void 0 }
     );
     const artifactPath = await writeEvalArtifactV4(clioDataDir(), artifact, parsed.out);
     process.stdout.write(`${renderEvalTextReportV4(artifact)}artifact: ${artifactPath}
+`);
+    process.stdout.write(`report: clio-coder eval report --artifact ${shellQuote(resolve10(artifactPath))} --format md
 `);
     const gate = suite.thresholds === void 0 ? null : evaluateGate(artifact, suite.thresholds);
     if (gate !== null && !gate.pass) {
@@ -4558,7 +4864,7 @@ async function runEvalRun(parsed) {
 async function runEvalReportCommand(parsed) {
   try {
     const dataDir = clioDataDir();
-    const artifact = await loadEvalArtifactV4(dataDir, parsed.evalId ?? "");
+    const artifact = parsed.artifact === void 0 ? await loadEvalArtifactV4(dataDir, parsed.evalId ?? "") : parseEvalArtifactV4(JSON.parse(await readFile4(parsed.artifact, "utf8")), parsed.artifact);
     process.stdout.write(renderArtifactReport(artifact, parsed.format, dataDir));
     return 0;
   } catch (error) {
@@ -4663,4 +4969,4 @@ function comparisonFormat(value) {
 export {
   runEvalCommand
 };
-//# sourceMappingURL=eval-OQOQUDHK.js.map
+//# sourceMappingURL=eval-V2RTN3UH.js.map