@tangle-network/agent-eval 0.119.0 → 0.120.0

package/dist/{chunk-RLCJQ6VZ.js → chunk-32BZXMSO.js}

@@ -1,15 +1,19 @@
 import {
+  assertCampaignSplitIdentity,
+  campaignCoverage,
+  canonicalJson,
   contentHash,
   createRunCostLedger,
+  formatCoverageFailures,
   fsCampaignStorage,
   resolveRunDir,
   runCampaign,
-  summarizeBackendIntegrity
-} from "./chunk-PAHNGS65.js";
+  summarizeAgentReceiptIntegrity
+} from "./chunk-XDIRG3TO.js";
 import {
   clamp01,
   validatePolicyEditCandidateRecord
-} from "./chunk-7A4LIMMY.js";
+} from "./chunk-S5TT5R3L.js";
 import {
   detectRewardHacking
 } from "./chunk-ARU2PZFM.js";
@@ -21,8 +25,11 @@ import {
   stripFencedJson
 } from "./chunk-NJC7U437.js";
 import {
+  mcnemar,
   pairedBootstrap,
-  weightedComposite
+  pairedRiskDifference,
+  weightedComposite,
+  wilcoxonSignedRank
 } from "./chunk-PJQFMIOX.js";
 import {
   CostLedger
@@ -292,6 +299,155 @@ async function runJudgeChat(tc, input, judgeName, request) {
   return paid.value;
 }
 
+// src/paired-arms.ts
+function pairArms(rows, opts) {
+  const { baselineArm, treatmentArm } = opts;
+  if (baselineArm === treatmentArm) {
+    throw new ValidationError(
+      `pairArms: baselineArm and treatmentArm are both '${baselineArm}' \u2014 an arm cannot be compared to itself`
+    );
+  }
+  const byArm = /* @__PURE__ */ new Map();
+  const armsSeen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    armsSeen.add(row.arm);
+    if (row.arm !== baselineArm && row.arm !== treatmentArm) continue;
+    const byKey = byArm.get(row.arm) ?? /* @__PURE__ */ new Map();
+    const group = byKey.get(row.pairKey) ?? [];
+    group.push(row);
+    byKey.set(row.pairKey, group);
+    byArm.set(row.arm, byKey);
+  }
+  for (const arm of [baselineArm, treatmentArm]) {
+    if (!byArm.has(arm)) {
+      const seen = [...armsSeen].sort().join(", ") || "<none>";
+      throw new ValidationError(`pairArms: no rows for arm '${arm}' (arms present: ${seen})`);
+    }
+  }
+  const baselineByKey = byArm.get(baselineArm);
+  const treatmentByKey = byArm.get(treatmentArm);
+  const allKeys = [.../* @__PURE__ */ new Set([...baselineByKey.keys(), ...treatmentByKey.keys()])].sort();
+  const pairs = [];
+  const unpairedBaseline = [];
+  const unpairedTreatment = [];
+  for (const pairKey of allKeys) {
+    const b = baselineByKey.get(pairKey) ?? [];
+    const t = treatmentByKey.get(pairKey) ?? [];
+    if (b.length <= 1 && t.length <= 1) {
+      if (b.length === 1 && t.length === 1) {
+        pairs.push({ pairKey, repIndex: 0, baseline: b[0], treatment: t[0] });
+      } else {
+        unpairedBaseline.push(...b);
+        unpairedTreatment.push(...t);
+      }
+      continue;
+    }
+    const bByRep = indexByRepKey(b, pairKey, baselineArm);
+    const tByRep = indexByRepKey(t, pairKey, treatmentArm);
+    const repKeys = [.../* @__PURE__ */ new Set([...bByRep.keys(), ...tByRep.keys()])].sort();
+    let repIndex = 0;
+    for (const repKey of repKeys) {
+      const baseline = bByRep.get(repKey);
+      const treatment = tByRep.get(repKey);
+      if (baseline !== void 0 && treatment !== void 0) {
+        pairs.push({ pairKey, repIndex: repIndex++, baseline, treatment });
+      } else if (baseline !== void 0) {
+        unpairedBaseline.push(baseline);
+      } else if (treatment !== void 0) {
+        unpairedTreatment.push(treatment);
+      }
+    }
+  }
+  return { pairs, unpairedBaseline, unpairedTreatment };
+}
+function indexByRepKey(group, pairKey, arm) {
+  const byRep = /* @__PURE__ */ new Map();
+  for (const row of group) {
+    if (row.repKey === void 0) {
+      throw new ValidationError(
+        `pairArms: pairKey '${pairKey}' has multiple reps in an arm, but a row in arm '${arm}' is missing repKey \u2014 multi-rep items require an explicit repKey on every row so reps pair by identity (pairing reps by outcome or by index would bias the paired statistics)`
+      );
+    }
+    if (byRep.has(row.repKey)) {
+      throw new ValidationError(
+        `pairArms: duplicate repKey '${row.repKey}' for pairKey '${pairKey}' in arm '${arm}' \u2014 (pairKey, repKey) must uniquely identify a rep within an arm`
+      );
+    }
+    byRep.set(row.repKey, row);
+  }
+  return byRep;
+}
+function comparePairedArms(rows, opts) {
+  const { pairs, unpairedBaseline, unpairedTreatment } = pairArms(rows, opts);
+  let correctness = null;
+  const baselinePass = [];
+  const treatmentPass = [];
+  for (const pair of pairs) {
+    if (pair.baseline.pass === void 0 || pair.treatment.pass === void 0) continue;
+    baselinePass.push(pair.baseline.pass ? 1 : 0);
+    treatmentPass.push(pair.treatment.pass ? 1 : 0);
+  }
+  if (baselinePass.length > 0) {
+    const mc = mcnemar(baselinePass, treatmentPass);
+    correctness = {
+      b10: mc.b,
+      b01: mc.c,
+      mcnemar: mc,
+      riskDifference: pairedRiskDifference(baselinePass, treatmentPass)
+    };
+  }
+  const metricNames = opts.metricNames ?? [
+    ...new Set(
+      pairs.flatMap((p) => [
+        ...Object.keys(p.baseline.metrics ?? {}),
+        ...Object.keys(p.treatment.metrics ?? {})
+      ])
+    )
+  ].sort();
+  const metricDeltas = metricNames.map((name) => {
+    const before = [];
+    const after = [];
+    let nMissing = 0;
+    for (const pair of pairs) {
+      const b = metricValue(pair.baseline, name);
+      const t = metricValue(pair.treatment, name);
+      if (b === void 0 || t === void 0) {
+        nMissing++;
+        continue;
+      }
+      before.push(b);
+      after.push(t);
+    }
+    const bootstrapCi = before.length === 0 ? null : pairedBootstrap(before, after, opts.bootstrap);
+    return {
+      name,
+      n: before.length,
+      nMissing,
+      medianDelta: bootstrapCi === null ? Number.NaN : bootstrapCi.median,
+      meanDelta: bootstrapCi === null ? Number.NaN : bootstrapCi.mean,
+      bootstrapCi,
+      wilcoxon: before.length === 0 ? null : wilcoxonSignedRank(before, after)
+    };
+  });
+  return {
+    nPairs: pairs.length,
+    nUnpairedBaseline: unpairedBaseline.length,
+    nUnpairedTreatment: unpairedTreatment.length,
+    correctness,
+    metricDeltas
+  };
+}
+function metricValue(row, name) {
+  const v = row.metrics?.[name];
+  if (v === void 0) return void 0;
+  if (!Number.isFinite(v)) {
+    throw new ValidationError(
+      `comparePairedArms: non-finite value for metric '${name}' on pairKey '${row.pairKey}' (arm '${row.arm}'): ${v}`
+    );
+  }
+  return v;
+}
+
 // src/pareto.ts
 function dominates(a, b, objectives) {
   let strictlyBetter = false;
@@ -1679,7 +1835,7 @@ function defaultProductionGate(options) {
         detail: {
           candidateUsd: ctx.cost.candidate,
           baselineUsd: ctx.cost.baseline,
-          budgetUsd: options.budgetUsd
+          ...options.budgetUsd === void 0 ? {} : { budgetUsd: options.budgetUsd }
         }
       });
       if (!budgetPass) {
@@ -2326,7 +2482,7 @@ function assertCodeSurfaceIdentity(surface) {
 function codeSurfaceIdentityMaterial(surface) {
   assertCodeSurfaceIdentity(surface);
   return JSON.stringify({
-    schema: "tangle.code-surface.v1",
+    schema: "tangle.code-surface",
     baseCommit: surface.baseCommit,
     baseTree: surface.baseTree,
     candidateTree: surface.candidateTree,
@@ -2344,6 +2500,33 @@ function surfaceContentHash(surface) {
 function surfaceHash(surface) {
   return surfaceContentHash(surface).slice("sha256:".length, "sha256:".length + 16);
 }
+function renderSurfaceDiff(winnerSurface, baselineSurface) {
+  if (typeof winnerSurface === "string" && typeof baselineSurface === "string") {
+    return [
+      "--- baseline",
+      "+++ winner",
+      ...baselineSurface.split("\n").map((line) => `- ${line}`),
+      ...winnerSurface.split("\n").map((line) => `+ ${line}`)
+    ].join("\n");
+  }
+  const describe = (surface) => {
+    if (typeof surface === "string") return "(prompt surface)";
+    assertCodeSurfaceIdentity(surface);
+    return [
+      `baseCommit=${surface.baseCommit}`,
+      `baseTree=${surface.baseTree}`,
+      `candidateCommit=${surface.candidateCommit}`,
+      `candidateTree=${surface.candidateTree}`,
+      `patch=${surface.patch.sha256}`,
+      `patchBytes=${surface.patch.byteLength}`,
+      ...surface.summary ? [surface.summary] : []
+    ].join("\n");
+  };
+  return `--- baseline
+${describe(baselineSurface)}
++++ winner
+${describe(winnerSurface)}`;
+}
 
 // src/campaign/proposers/gepa.ts
 var REFLECTION_SYSTEM = 'You are an expert prompt engineer performing GEPA-style reflective mutation. You are given a prompt surface, its top trials (preserve what works) and its bottom trials (the evidence to fix). For each proposal, reason in this order before writing the payload: (1) LOCALIZE \u2014 point to the exact span of the current surface responsible for a bottom-trial failure; (2) DIAGNOSE the root cause (a missing rule, an ambiguous instruction, an over-broad directive), not just the symptom; (3) propose the MINIMAL, GENERALIZABLE edit that fixes the whole failure class \u2014 state it as a rule the agent should follow, never a patch memorized to the shown trials (that is overfitting and will not transfer to the held-out set); (4) PRESERVE every instruction the top trials depend on \u2014 do not delete or weaken working guidance. Put this localize\u2192diagnose\u2192fix reasoning in each proposal\'s `rationale`. Output ONLY a JSON object of shape {"proposals":[{"label":string,"rationale":string,"payload":string}]} where each `payload` is the FULL improved surface text. No prose outside the JSON.';
@@ -2595,79 +2778,6 @@ function campaignBreakdown(campaign) {
   return { dimensions, scenarios };
 }
 
-// src/campaign/coverage.ts
-function campaignCoverage(cells, scenarios, reps, requireJudgeScore) {
-  const expectedCellIds = designedCellIds(scenarios, reps);
-  const cellsById = /* @__PURE__ */ new Map();
-  for (const cell of cells) {
-    const matches = cellsById.get(cell.cellId) ?? [];
-    matches.push(cell);
-    cellsById.set(cell.cellId, matches);
-  }
-  const scorableCellIds = [];
-  const unscorableCells = [];
-  for (const cellId of expectedCellIds) {
-    const matches = cellsById.get(cellId) ?? [];
-    if (matches.length === 0) {
-      unscorableCells.push({ cellId, reason: "missing campaign cell" });
-      continue;
-    }
-    if (matches.length > 1) {
-      unscorableCells.push({ cellId, reason: `duplicate campaign cell (${matches.length})` });
-      continue;
-    }
-    const cell = matches[0];
-    const scoreEntries = Object.entries(cell.judgeScores);
-    const successfulScores = scoreEntries.map(([, score]) => score).filter((score) => score.failed !== true && Number.isFinite(score.composite));
-    const nonFiniteScores = scoreEntries.filter(
-      ([, score]) => score.failed !== true && (!Number.isFinite(score.composite) || Object.values(score.dimensions).some((value) => !Number.isFinite(value)))
-    );
-    const reasons = [];
-    if (cell.error) reasons.push(cell.error);
-    if (cell.artifact === null || cell.artifact === void 0) reasons.push("missing artifact");
-    if (!cell.error && requireJudgeScore && successfulScores.length === 0) {
-      reasons.push("no successful finite judge score");
-    }
-    if (scoreEntries.some(([, score]) => score.failed === true)) {
-      reasons.push("judge score marked failed");
-    }
-    if (nonFiniteScores.length > 0) {
-      reasons.push(
-        `non-finite judge score: ${nonFiniteScores.map(([name]) => name).sort().join(", ")}`
-      );
-    }
-    if (reasons.length > 0) {
-      unscorableCells.push({ cellId, reason: reasons.join("; ") });
-    } else {
-      scorableCellIds.push(cellId);
-    }
-  }
-  const expected = new Set(expectedCellIds);
-  for (const cell of cells) {
-    if (!expected.has(cell.cellId)) {
-      unscorableCells.push({ cellId: cell.cellId, reason: "unexpected campaign cell" });
-    }
-  }
-  return {
-    complete: unscorableCells.length === 0 && scorableCellIds.length === expectedCellIds.length,
-    expectedCellIds,
-    scorableCellIds,
-    unscorableCells
-  };
-}
-function formatCoverageFailures(coverage) {
-  const shown = coverage.unscorableCells.slice(0, 3).map((cell) => `${cell.cellId}: ${cell.reason}`).join("; ");
-  const remainder = coverage.unscorableCells.length - Math.min(3, coverage.unscorableCells.length);
-  return remainder > 0 ? `${shown}; +${remainder} more` : shown || "unknown coverage failure";
-}
-function designedCellIds(scenarios, reps) {
-  const ids = [];
-  for (const scenario of scenarios) {
-    for (let rep = 0; rep < reps; rep++) ids.push(`${scenario.id}:${rep}`);
-  }
-  return ids;
-}
-
 // src/campaign/presets/run-optimization.ts
 async function runOptimization(opts) {
   const { proposer } = opts;
@@ -2760,6 +2870,7 @@ async function runOptimization(opts) {
       costLedger,
       costPhase: "search.proposal"
     });
+    if (proposed.length === 0) break;
     const candidates = proposed.map(
       (p) => isProposedCandidate(p) ? p : { surface: p, label: "", rationale: "" }
     );
@@ -2937,7 +3048,7 @@ var DEFAULT_DISPATCH_TIMEOUT_MS = 6e5;
 async function runImprovementLoop(opts) {
   if (opts.autoOnPromote === "config") {
     throw new Error(
-      "runImprovementLoop: autoOnPromote='config' is deferred to Pass B (requires shadow deploy + rollback + ensemble judges). Use 'pr' or 'none' in v0.40."
+      "runImprovementLoop: autoOnPromote='config' requires isolated deployment, rollback, and independent validation. Use 'pr' or 'none'."
     );
   }
   if (opts.tracing === "off" && opts.proposer) {
@@ -2970,7 +3081,7 @@ async function runImprovementLoop(opts) {
   const dispatchTimeoutMs = opts.dispatchTimeoutMs ?? DEFAULT_DISPATCH_TIMEOUT_MS;
   const optimization = await runOptimization({ ...opts, dispatchTimeoutMs, costLedger });
   const winnerIsBaseline = optimization.winnerSurfaceHash === surfaceHash(opts.baselineSurface);
-  const { runCampaign: runCampaign2 } = await import("./run-campaign-OBXSN5WK.js");
+  const { runCampaign: runCampaign2 } = await import("./run-campaign-HNFPJET4.js");
   const baselineOnHoldout = await runCampaign2({
     ...opts,
     costLedger,
@@ -3020,15 +3131,18 @@ async function runImprovementLoop(opts) {
   }
   let neutralizedArtifacts;
   let neutralizedJudgeScores;
+  let neutralizedOnHoldout;
+  let neutralizedSurface;
   if (opts.neutralize && !winnerIsBaseline) {
-    const neutralizedSurface = opts.neutralize(optimization.winnerSurface, opts.baselineSurface);
-    const neutralizedOnHoldout = await runCampaign2({
+    const surface = opts.neutralize(optimization.winnerSurface, opts.baselineSurface);
+    neutralizedSurface = surface;
+    neutralizedOnHoldout = await runCampaign2({
       ...opts,
       costLedger,
       costPhase: "holdout.neutralized",
       dispatchTimeoutMs,
       scenarios: opts.holdoutScenarios,
-      dispatch: (scenario, ctx) => opts.dispatchWithSurface(neutralizedSurface, scenario, ctx),
+      dispatch: (scenario, ctx) => opts.dispatchWithSurface(surface, scenario, ctx),
       runDir: `${opts.runDir}/holdout-neutralized`
     });
     assertCompleteHoldout("neutralized", neutralizedOnHoldout);
@@ -3064,8 +3178,7 @@ async function runImprovementLoop(opts) {
     costPhase: "promotion.gate",
     signal: new AbortController().signal
   });
-  const render = opts.renderPromotedDiff ?? defaultRenderDiff;
-  const promotedDiff = optimization.winnerSurfaceHash === surfaceHash(opts.baselineSurface) ? "" : render(optimization.winnerSurface, opts.baselineSurface);
+  const promotedDiff = optimization.winnerSurfaceHash === surfaceHash(opts.baselineSurface) ? "" : renderSurfaceDiff(optimization.winnerSurface, opts.baselineSurface);
   let prResult;
   if (opts.autoOnPromote === "pr" && gateResult.decision === "ship") {
     prResult = openAutoPr({
@@ -3080,28 +3193,13 @@ async function runImprovementLoop(opts) {
     ...optimization,
     baselineOnHoldout,
     winnerOnHoldout,
+    ...neutralizedOnHoldout && neutralizedSurface ? { neutralizedOnHoldout, neutralizedSurface } : {},
     gateResult,
     promotedDiff,
     prResult,
     cost: costLedger.summary()
   };
 }
-function defaultRenderDiff(winnerSurface, baselineSurface) {
-  if (typeof winnerSurface !== "string" || typeof baselineSurface !== "string") {
-    const fmt = (s) => typeof s === "string" ? "(prompt surface)" : `worktree=${s.worktreeRef}${s.baseRef ? ` base=${s.baseRef}` : ""}${s.summary ? `
-${s.summary}` : ""}`;
-    return `--- baseline
-${fmt(baselineSurface)}
-+++ winner
-${fmt(winnerSurface)}`;
-  }
-  const lines = [];
-  lines.push("--- baseline");
-  lines.push("+++ winner");
-  for (const l of baselineSurface.split("\n")) lines.push(`- ${l}`);
-  for (const l of winnerSurface.split("\n")) lines.push(`+ ${l}`);
-  return lines.join("\n");
-}
 
 // src/campaign/presets/run-eval.ts
 async function runEval(opts) {
@@ -3126,6 +3224,39 @@ function evolutionaryProposer(opts) {
 // src/campaign/provenance.ts
 import { createHash as createHash2 } from "crypto";
 import { join as join2 } from "path";
+function loopProvenanceArgsFromResult(input) {
+  const { result } = input;
+  return {
+    runId: input.runId,
+    runDir: input.runDir,
+    timestamp: input.timestamp,
+    baselineSurface: input.baselineSurface,
+    winnerSurface: result.winnerSurface,
+    ...result.winnerLabel ? { winnerLabel: result.winnerLabel } : {},
+    ...result.winnerRationale ? { winnerRationale: result.winnerRationale } : {},
+    baselineSearchCampaign: result.baselineCampaign,
+    generations: result.generations.map(({ record, surfaces }) => ({
+      generationIndex: record.generationIndex,
+      candidates: record.candidates,
+      promoted: record.promoted,
+      surfaces: surfaces.map(({ surfaceHash: surfaceHash2, surface, campaign }) => ({
+        surfaceHash: surfaceHash2,
+        surface,
+        campaign
+      }))
+    })),
+    gate: result.gateResult,
+    baselineOnHoldout: result.baselineOnHoldout,
+    winnerOnHoldout: result.winnerOnHoldout,
+    ...result.neutralizedSurface && result.neutralizedOnHoldout ? {
+      neutralizedSurface: result.neutralizedSurface,
+      neutralizedOnHoldout: result.neutralizedOnHoldout
+    } : {},
+    costReceipts: input.costReceipts,
+    totalCostUsd: input.totalCostUsd,
+    totalDurationMs: input.totalDurationMs
+  };
+}
 function meanHoldoutComposite(campaign) {
   const xs = [];
   for (const cell of campaign.cells) {
@@ -3136,29 +3267,41 @@ function meanHoldoutComposite(campaign) {
   return xs.length ? xs.reduce((a, b) => a + b, 0) / xs.length : 0;
 }
 function buildLoopProvenanceRecord(args) {
-  const integrity = summarizeBackendIntegrity(args.workerRecords);
-  const models = [...new Set(args.workerRecords.map((r) => r.model))].sort();
-  if (!Number.isFinite(args.baselineSearchComposite)) {
+  if (!args.runId.trim() || !args.runDir.trim()) {
+    throw new Error("buildLoopProvenanceRecord: runId and runDir must be non-empty");
+  }
+  const timestampMs = Date.parse(args.timestamp);
+  if (!Number.isFinite(timestampMs) || new Date(timestampMs).toISOString() !== args.timestamp) {
+    throw new Error("buildLoopProvenanceRecord: timestamp must be a canonical ISO instant");
+  }
+  const agentReceipts = args.costReceipts.filter((receipt) => receipt.channel === "agent");
+  const integrity = summarizeAgentReceiptIntegrity(agentReceipts);
+  const models = [...new Set(agentReceipts.map((receipt) => receipt.model))].sort();
+  const baselineSearchComposite = campaignMeanComposite(args.baselineSearchCampaign);
+  if (!Number.isFinite(baselineSearchComposite)) {
     throw new Error("buildLoopProvenanceRecord: baselineSearchComposite must be finite");
   }
   const candidates = [];
   let incumbentSurfaceHash = surfaceHash(args.baselineSurface);
-  let incumbentComposite = args.baselineSearchComposite;
+  let incumbentComposite = baselineSearchComposite;
   let previousGeneration = -1;
   for (const gen of args.generations) {
-    if (!Number.isSafeInteger(gen.generationIndex) || gen.generationIndex <= previousGeneration) {
+    if (!Number.isSafeInteger(gen.generationIndex) || gen.generationIndex !== previousGeneration + 1) {
       throw new Error(
-        "buildLoopProvenanceRecord: generation indices must be strictly increasing integers"
+        "buildLoopProvenanceRecord: generation indices must be contiguous integers starting at zero"
       );
     }
     previousGeneration = gen.generationIndex;
+    if (gen.candidates.length === 0) {
+      throw new Error("buildLoopProvenanceRecord: a recorded generation must contain a candidate");
+    }
     if (new Set(gen.promoted).size !== gen.promoted.length || gen.promoted.length > 1) {
       throw new Error(
         "buildLoopProvenanceRecord: each generation may promote at most one candidate"
       );
     }
     const promotedSet = new Set(gen.promoted);
-    const surfaceByHash = new Map(gen.surfaces.map((s) => [s.surfaceHash, s.surface]));
+    const surfaceByHash = new Map(gen.surfaces.map((measured) => [measured.surfaceHash, measured]));
     const candidateByHash = new Map(
       gen.candidates.map((candidate) => [candidate.surfaceHash, candidate])
     );
@@ -3185,19 +3328,26 @@ function buildLoopProvenanceRecord(args) {
         incumbentComposite,
         promotedSet.has(c.surfaceHash)
       );
-      const surface = surfaceByHash.get(c.surfaceHash);
-      if (surface === void 0) {
+      const measured = surfaceByHash.get(c.surfaceHash);
+      if (measured === void 0) {
         throw new Error("buildLoopProvenanceRecord: measured candidate is missing its surface");
       }
+      const { surface, campaign } = measured;
       if (surfaceHash(surface) !== c.surfaceHash) {
         throw new Error(
           "buildLoopProvenanceRecord: candidate surface hash does not match its surface bytes"
         );
       }
+      if (campaign.splitDigest !== args.baselineSearchCampaign.splitDigest) {
+        throw new Error(
+          "buildLoopProvenanceRecord: candidate campaign does not match the search split"
+        );
+      }
       const entry = {
         generation: gen.generationIndex,
         surfaceHash: c.surfaceHash,
         contentHash: surfaceContentHash(surface),
+        campaignDigest: campaignMeasurementDigest(campaign),
         parentSurfaceHash: c.parentSurfaceHash,
         parentComposite: c.parentComposite,
         eligibleForPromotion: c.eligibleForPromotion,
@@ -3233,23 +3383,61 @@ function buildLoopProvenanceRecord(args) {
   }
   const baselineHoldoutComposite = meanHoldoutComposite(args.baselineOnHoldout);
   const winnerHoldoutComposite = meanHoldoutComposite(args.winnerOnHoldout);
-  const record = {
-    schema: "tangle.loop-provenance.v3",
+  if (args.baselineOnHoldout.splitDigest !== args.winnerOnHoldout.splitDigest) {
+    throw new Error("buildLoopProvenanceRecord: baseline and winner use different holdout splits");
+  }
+  if (args.neutralizedSurface === void 0 !== (args.neutralizedOnHoldout === void 0)) {
+    throw new Error(
+      "buildLoopProvenanceRecord: neutralized surface and campaign must be supplied together"
+    );
+  }
+  if (args.neutralizedOnHoldout && args.neutralizedOnHoldout.splitDigest !== args.baselineOnHoldout.splitDigest) {
+    throw new Error(
+      "buildLoopProvenanceRecord: neutralized campaign uses a different holdout split"
+    );
+  }
+  const neutralizedComposite = args.neutralizedOnHoldout ? meanHoldoutComposite(args.neutralizedOnHoldout) : void 0;
+  const diff = surfaceContentHash(args.baselineSurface) === surfaceContentHash(args.winnerSurface) ? "" : renderSurfaceDiff(args.winnerSurface, args.baselineSurface);
+  const recordWithoutDigest = {
+    schema: "tangle.loop-provenance",
     runId: args.runId,
     runDir: args.runDir,
     timestamp: args.timestamp,
     baselineContentHash: surfaceContentHash(args.baselineSurface),
     winnerContentHash: surfaceContentHash(args.winnerSurface),
-    diff: args.diff,
+    diff,
     candidates,
-    baselineSearchComposite: args.baselineSearchComposite,
+    evidence: {
+      search: {
+        splitDigest: args.baselineSearchCampaign.splitDigest,
+        baselineCampaignDigest: campaignMeasurementDigest(args.baselineSearchCampaign)
+      },
+      holdout: {
+        splitDigest: args.baselineOnHoldout.splitDigest,
+        baselineCampaignDigest: campaignMeasurementDigest(args.baselineOnHoldout),
+        winnerCampaignDigest: campaignMeasurementDigest(args.winnerOnHoldout),
+        ...args.neutralizedSurface && args.neutralizedOnHoldout && neutralizedComposite !== void 0 ? {
+          neutralized: {
+            contentHash: surfaceContentHash(args.neutralizedSurface),
+            campaignDigest: campaignMeasurementDigest(args.neutralizedOnHoldout),
+            composite: neutralizedComposite,
+            lift: neutralizedComposite - baselineHoldoutComposite
+          }
+        } : {}
+      },
+      costReceiptsDigest: canonicalDigest(
+        [...args.costReceipts].sort((left, right) => left.callId.localeCompare(right.callId))
+      )
+    },
+    baselineSearchComposite,
     gate: {
       decision: args.gate.decision,
       reasons: args.gate.reasons,
       delta: args.gate.delta,
       contributingGates: args.gate.contributingGates.map((g) => ({
         name: g.name,
-        passed: g.passed
+        passed: g.passed,
+        detail: durableGateDetail(g.detail)
       }))
     },
     baselineHoldoutComposite,
@@ -3266,10 +3454,81 @@ function buildLoopProvenanceRecord(args) {
     totalCostUsd: args.totalCostUsd,
     totalDurationMs: args.totalDurationMs
   };
-  if (args.winnerLabel) record.winnerLabel = args.winnerLabel;
-  if (args.winnerRationale) record.winnerRationale = args.winnerRationale;
+  if (args.winnerLabel) recordWithoutDigest.winnerLabel = args.winnerLabel;
+  if (args.winnerRationale) recordWithoutDigest.winnerRationale = args.winnerRationale;
+  return {
+    ...recordWithoutDigest,
+    recordDigest: canonicalDigest(recordWithoutDigest)
+  };
+}
+function campaignMeasurementDigest(campaign) {
+  assertCampaignSplitIdentity(campaign.scenarios, campaign.reps, campaign.splitDigest);
+  return canonicalDigest({
+    schema: "tangle.campaign-measurement",
+    manifestHash: campaign.manifestHash,
+    splitDigest: campaign.splitDigest,
+    seed: campaign.seed,
+    reps: campaign.reps,
+    runDir: campaign.runDir,
+    scenarios: campaign.scenarios,
+    cells: [...campaign.cells].sort((left, right) => left.cellId.localeCompare(right.cellId)).map((cell) => ({
+      manifestHash: cell.manifestHash ?? null,
+      cellId: cell.cellId,
+      scenarioId: cell.scenarioId,
+      rep: cell.rep,
+      generation: cell.generation ?? null,
+      judgeScores: cell.judgeScores,
+      costUsd: cell.costUsd,
+      costEstimated: cell.costEstimated ?? null,
+      costCallIds: [...cell.costCallIds ?? []].sort(),
+      tokenUsage: cell.tokenUsage,
+      resolvedModel: cell.resolvedModel ?? null,
+      durationMs: cell.durationMs,
+      seed: cell.seed,
+      cached: cell.cached,
+      error: cell.error ?? null
+    }))
+  });
+}
+function verifyLoopProvenanceRecord(record) {
+  if (record.schema !== "tangle.loop-provenance") {
+    throw new Error("loop provenance has an unsupported schema");
+  }
+  const { recordDigest, ...recordWithoutDigest } = record;
+  if (recordDigest !== canonicalDigest(recordWithoutDigest)) {
+    throw new Error("loop provenance record digest does not match its contents");
+  }
   return record;
 }
+function canonicalDigest(value) {
+  const json = JSON.stringify(value, function strictJson(_key, item) {
+    if (typeof item === "number" && !Number.isFinite(item)) {
+      throw new Error("canonical digest cannot encode a non-finite number");
+    }
+    if (typeof item === "bigint" || typeof item === "function" || typeof item === "symbol") {
+      throw new Error(`canonical digest cannot encode ${typeof item}`);
+    }
+    if (item === void 0 && Array.isArray(this)) {
+      throw new Error("canonical digest cannot encode an undefined array item");
+    }
+    if (item instanceof Map || item instanceof Set) {
+      throw new Error(`canonical digest cannot encode ${item instanceof Map ? "Map" : "Set"}`);
+    }
+    return item;
+  });
+  if (json === void 0) throw new Error("canonical digest value is not serializable");
+  return `sha256:${contentHash(JSON.parse(json))}`;
+}
+function durableGateDetail(detail) {
+  if (detail === void 0) return null;
+  try {
+    return JSON.parse(canonicalJson(detail));
+  } catch (cause) {
+    throw new Error("buildLoopProvenanceRecord: gate detail must be canonical JSON", {
+      cause
+    });
+  }
+}
 function validateCandidateMeasurement(candidate, expectedParentHash, expectedParentComposite, promoted) {
   if (!Number.isFinite(candidate.composite)) {
     throw new Error("buildLoopProvenanceRecord: candidate composite must be finite");
@@ -3552,6 +3811,8 @@ export {
   adversarialJudge,
   createCustomJudge,
   defaultJudges,
+  pairArms,
+  comparePairedArms,
   recoverTruncatedJson,
   dominates,
   paretoFrontier,
@@ -3594,6 +3855,7 @@ export {
   codeSurfaceIdentityMaterial,
   surfaceContentHash,
   surfaceHash,
+  renderSurfaceDiff,
   gepaProposer,
   extractH2Sections,
   countSentenceEdits,
@@ -3601,13 +3863,16 @@ export {
   campaignBreakdown,
   runOptimization,
   runImprovementLoop,
-  defaultRenderDiff,
   runEval,
   evolutionaryProposer,
+  loopProvenanceArgsFromResult,
   buildLoopProvenanceRecord,
+  campaignMeasurementDigest,
+  verifyLoopProvenanceRecord,
+  canonicalDigest,
   loopProvenanceSpans,
   provenanceRecordPath,
   provenanceSpansPath,
   emitLoopProvenance
 };
-//# sourceMappingURL=chunk-RLCJQ6VZ.js.map
+//# sourceMappingURL=chunk-32BZXMSO.js.map