@tangle-network/agent-eval 0.119.1 → 0.120.1

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

@@ -1,11 +1,15 @@
 import {
+  assertCampaignSplitIdentity,
+  campaignCoverage,
+  canonicalJson,
   contentHash,
   createRunCostLedger,
+  formatCoverageFailures,
   fsCampaignStorage,
   resolveRunDir,
   runCampaign,
-  summarizeBackendIntegrity
-} from "./chunk-PAHNGS65.js";
+  summarizeAgentReceiptIntegrity
+} from "./chunk-XDIRG3TO.js";
 import {
   clamp01,
   validatePolicyEditCandidateRecord
@@ -1831,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) {
@@ -2478,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,
@@ -2496,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.';
@@ -2747,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;
@@ -2912,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: "" }
     );
@@ -3089,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) {
@@ -3122,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,
@@ -3172,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);
@@ -3216,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({
@@ -3232,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) {
@@ -3278,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) {
@@ -3288,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])
     );
@@ -3337,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,
@@ -3385,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,
@@ -3418,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");
@@ -3748,6 +3855,7 @@ export {
   codeSurfaceIdentityMaterial,
   surfaceContentHash,
   surfaceHash,
+  renderSurfaceDiff,
   gepaProposer,
   extractH2Sections,
   countSentenceEdits,
@@ -3755,13 +3863,16 @@ export {
   campaignBreakdown,
   runOptimization,
   runImprovementLoop,
-  defaultRenderDiff,
   runEval,
   evolutionaryProposer,
+  loopProvenanceArgsFromResult,
   buildLoopProvenanceRecord,
+  campaignMeasurementDigest,
+  verifyLoopProvenanceRecord,
+  canonicalDigest,
   loopProvenanceSpans,
   provenanceRecordPath,
   provenanceSpansPath,
   emitLoopProvenance
 };
-//# sourceMappingURL=chunk-PSXJ32SR.js.map
+//# sourceMappingURL=chunk-32BZXMSO.js.map