@tangle-network/agent-eval 0.133.2 → 0.134.0

package/dist/{skillopt-optimization-method-CF6a327Q.js → skillopt-optimization-method-BY6vKLJB.js}

@@ -1,12 +1,12 @@
 import { i as JudgeError, s as ValidationError, t as AgentEvalError } from "./errors-8YnH8WlF.js";
 import { c as costForTokenPricing, i as CostLedger, t as CostAccountingIncompleteError } from "./cost-ledger-BrJxbrMy.js";
 import { f as maximumChargeForLlmRequest, l as costReceiptFromLlm, m as stripFencedJson, u as costReceiptFromLlmError } from "./llm-client-ClPW-dWB.js";
-import { i as combineAbortSignals, r as clamp01 } from "./run-score-iEEAWiBY.js";
+import { a as clamp01, o as combineAbortSignals, t as assertProposalFindings } from "./proposal-findings-DCawte-y.js";
 import { n as mapConcurrent } from "./concurrency-MUjT7VjM.js";
-import { a as confidenceInterval, j as weightedComposite, v as pairedBootstrap } from "./statistics-DWM_AyLe.js";
+import { C as pairedBootstrap, D as pairedSignTest, I as weightedComposite, u as confidenceInterval } from "./statistics-RwRNu2__.js";
 import { t as DEFAULT_REDACTION_RULES } from "./redact-7Aq1ukl-.js";
-import { a as campaignCellExecutionEvidence, l as projectCampaignCellQuality, t as detectRewardHacking } from "./reward-hacking-Dl2UBzej.js";
-import { a as tryWithLedgerFileLock, i as appendLedgerLine, m as tryAcquireAtomicFileLock, p as probeAtomicFileLock } from "./ledger-core-CPZfcrC2.js";
+import { a as campaignCellExecutionEvidence, l as projectCampaignCellQuality, t as detectRewardHacking } from "./reward-hacking-DCdRK9TY.js";
+import { a as appendLedgerLine, h as tryAcquireAtomicFileLock, m as probeAtomicFileLock, o as tryWithLedgerFileLock } from "./ledger-core-DAKFKRzi.js";
 import { createRequire } from "node:module";
 import { z } from "zod";
 import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
@@ -155,6 +155,51 @@ function assertBackendReport(report, opts) {
 	return report;
 }
 //#endregion
+//#region src/paired-delta-test.ts
+/** Smallest all-positive sample that can clear a one-sided exact sign test. */
+function minimumPairsForPairedDeltaTest(confidence = .95) {
+	if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) throw new Error(`minimumPairsForPairedDeltaTest: confidence must be in (0,1), got ${confidence}`);
+	const oneSidedAlpha = (1 - confidence) / 2;
+	return Math.ceil(Math.log2(1 / oneSidedAlpha));
+}
+/**
+* Tests whether a paired candidate-minus-baseline delta clears a threshold.
+*
+* At 20 or more pairs, the percentile bootstrap lower bound carries the
+* decision. Below that point the interval is descriptive only, so the function
+* switches to a pre-registered one-sided exact sign test. The exact path is
+* deliberately conservative: it requires both a point estimate above the
+* threshold and enough consistently positive paired differences.
+*/
+function pairedDeltaTest(before, after, options = {}) {
+	const threshold = options.threshold ?? 0;
+	if (!Number.isFinite(threshold)) throw new Error(`pairedDeltaTest: threshold must be finite, got ${threshold}`);
+	const exactMinimum = minimumPairsForPairedDeltaTest(options.confidence ?? .95);
+	const requestedMinimum = options.minPairs ?? exactMinimum;
+	if (!Number.isInteger(requestedMinimum) || requestedMinimum < 1) throw new Error(`pairedDeltaTest: minPairs must be a positive integer, got ${requestedMinimum}`);
+	const minimumPairs = Math.max(requestedMinimum, exactMinimum);
+	const bootstrap = pairedBootstrap(before, after, options);
+	const sufficient = bootstrap.n >= minimumPairs;
+	if (bootstrap.gateEligible) return {
+		bootstrap,
+		method: "bootstrap-ci",
+		pValue: null,
+		minimumPairs,
+		sufficient,
+		significant: sufficient && bootstrap.low > threshold
+	};
+	const exact = pairedSignTest(before.map((value, index) => after[index] - value - threshold), "greater");
+	const estimate = options.statistic === "mean" ? bootstrap.mean : bootstrap.median;
+	return {
+		bootstrap,
+		method: "exact-sign",
+		pValue: exact.pValue,
+		minimumPairs,
+		sufficient,
+		significant: sufficient && estimate > threshold && exact.pValue <= (1 - bootstrap.confidence) / 2
+	};
+}
+//#endregion
 //#region src/json-recovery.ts
 /**
 * Truncation-tolerant JSON recovery — shared by every parser that reads JSON
@@ -3835,7 +3880,7 @@ function describeExternalScenario(scenario, label, maxChars, describe) {
 	assertJsonValue(data, `${label} scenario '${scenario.id}'`);
 	const serializedChars = JSON.stringify(data).length;
 	if (serializedChars > maxChars) throw new Error(`${label} scenario '${scenario.id}' exceeds maxEvidenceChars (${serializedChars} > ${maxChars})`);
-	return deepFreeze({
+	return deepFreeze$1({
 		id: scenario.id,
 		data
 	});
@@ -3886,9 +3931,9 @@ async function scoreOneScenario(args) {
 function cloneExternalTextCandidate$1(candidate) {
 	return typeof candidate === "string" ? candidate : { ...candidate };
 }
-function deepFreeze(value) {
+function deepFreeze$1(value) {
 	if (value && typeof value === "object") {
-		for (const child of Object.values(value)) deepFreeze(child);
+		for (const child of Object.values(value)) deepFreeze$1(child);
 		Object.freeze(value);
 	}
 	return value;
@@ -5251,23 +5296,24 @@ function pairHoldout(candidate, baseline, scenarioIds, select) {
 }
 /** Significance of the held-out composite lift: ship only when the paired
 *  bootstrap CI lower bound on (candidate − baseline) exceeds `deltaThreshold`
-*  (default 0 ⇒ "confidently positive"). Below `minProductiveRuns` paired
-*  observations there is not enough evidence to claim significance → not
-*  significant (`fewRuns`). Interpret `deltaThreshold` in the judge's native
-*  composite scale. */
+*  (default 0 ⇒ "confidently positive"). At small n, where the percentile
+*  bootstrap is descriptive only, a pre-registered exact sign test carries
+*  the decision. Interpret `deltaThreshold` in the judge's native scale. */
 function heldoutSignificance(paired, opts = {}) {
 	const deltaThreshold = opts.deltaThreshold ?? 0;
-	const minProductiveRuns = opts.minProductiveRuns ?? 3;
 	const confidence = opts.confidence ?? .95;
 	const resamples = opts.resamples ?? 2e3;
 	const seed = opts.seed ?? 1337;
 	const statistic = opts.statistic ?? "mean";
-	const bootstrap = pairedBootstrap(paired.before, paired.after, {
+	const decision = pairedDeltaTest(paired.before, paired.after, {
 		confidence,
 		resamples,
 		statistic,
-		seed
+		seed,
+		threshold: deltaThreshold,
+		minPairs: opts.minProductiveRuns
 	});
+	const bootstrap = decision.bootstrap;
 	const medianBootstrap = statistic === "median" ? bootstrap : pairedBootstrap(paired.before, paired.after, {
 		confidence,
 		resamples,
@@ -5282,14 +5328,18 @@ function heldoutSignificance(paired, opts = {}) {
 		if (Math.abs(after - before) < 1e-9) ties += 1;
 	}
 	const tieFraction = n === 0 ? 0 : ties / n;
-	const fewRuns = n < minProductiveRuns;
+	const fewRuns = !decision.sufficient;
+	const significant = decision.significant;
 	return {
 		paired,
 		bootstrap,
 		medianBootstrap,
 		tieFraction,
 		n,
-		significant: !fewRuns && bootstrap.low > deltaThreshold,
+		minimumRequired: decision.minimumPairs,
+		decisionMethod: decision.method,
+		pValue: decision.pValue,
+		significant,
 		fewRuns
 	};
 }
@@ -5317,10 +5367,17 @@ function dimensionRegressions(candidate, baseline, scenarioIds, criticalDimensio
 			statistic: "median",
 			seed: opts.seed ?? 1337
 		});
+		const regression = pairedDeltaTest(paired.after, paired.before, {
+			confidence: opts.confidence ?? .95,
+			resamples: opts.resamples ?? 2e3,
+			statistic: "median",
+			seed: opts.seed ?? 1337,
+			threshold: tolerance
+		});
 		out.push({
 			dimension: dim,
 			bootstrap,
-			regressed: bootstrap.low < -tolerance,
+			regressed: regression.significant,
 			tolerance,
 			n: paired.before.length
 		});
@@ -5395,7 +5452,7 @@ function defaultProductionGate(options) {
 				if (sig.fewRuns) requiredUnavailable.add("heldout-significance");
 				if (!heldoutPass) {
 					const tieNote = sig.tieFraction >= .4 ? `; ${(sig.tieFraction * 100).toFixed(0)}% tied scenarios` : "";
-					reasons.push(sig.fewRuns ? `held-out: only ${sig.n} paired runs (< ${minProductiveRuns}) — too few to claim significance` : `held-out CI.low ${sig.bootstrap.low.toFixed(3)} ≤ threshold ${deltaThreshold} (${heldoutStatistic} Δ ${delta.toFixed(3)}, ${(sig.bootstrap.confidence * 100).toFixed(0)}% CI [${sig.bootstrap.low.toFixed(3)}, ${sig.bootstrap.high.toFixed(3)}]${tieNote})`);
+					reasons.push(sig.fewRuns ? `held-out: only ${sig.n} paired runs (< ${sig.minimumRequired}) — too few to claim significance` : `held-out CI.low ${sig.bootstrap.low.toFixed(3)} ≤ threshold ${deltaThreshold} (${heldoutStatistic} Δ ${delta.toFixed(3)}, ${(sig.bootstrap.confidence * 100).toFixed(0)}% CI [${sig.bootstrap.low.toFixed(3)}, ${sig.bootstrap.high.toFixed(3)}]${tieNote})`);
 				}
 			}
 			const dimensionsProvided = options.criticalDimensions !== void 0;
@@ -5617,7 +5674,7 @@ function heldOutGate(options) {
 			const ci = `${(sig.bootstrap.confidence * 100).toFixed(0)}% CI [${sig.bootstrap.low.toFixed(3)}, ${sig.bootstrap.high.toFixed(3)}]`;
 			return {
 				decision: passed ? "ship" : "hold",
-				reasons: passed ? [`held-out mean Δ ${delta.toFixed(3)}, CI.low ${sig.bootstrap.low.toFixed(3)} > ${deltaThreshold} (${ci}, n=${sig.n}${tieNote})`] : [sig.fewRuns ? `held-out: only ${sig.n} paired runs — too few to claim significance` : `held-out mean Δ ${delta.toFixed(3)}, CI.low ${sig.bootstrap.low.toFixed(3)} ≤ ${deltaThreshold} (${ci}, n=${sig.n}${tieNote})`],
+				reasons: passed ? [`held-out mean Δ ${delta.toFixed(3)}, CI.low ${sig.bootstrap.low.toFixed(3)} > ${deltaThreshold} (${ci}, n=${sig.n}${tieNote})`] : [sig.fewRuns ? `held-out: only ${sig.n} paired runs; ${sig.minimumRequired} required — too few to claim significance` : `held-out mean Δ ${delta.toFixed(3)}, CI.low ${sig.bootstrap.low.toFixed(3)} ≤ ${deltaThreshold} (${ci}, n=${sig.n}${tieNote})`],
 				contributingGates: [{
 					name: "heldOutGate",
 					status,
@@ -5686,6 +5743,30 @@ function powerPreflight(opts) {
 //#endregion
 //#region src/campaign/gates/promotion-policy.ts
 /**
+* Promotion policy over the evidence VECTOR — the substrate's answer to "never
+* collapse the multi-objective promotion decision into one scalar." A
+* `defaultProductionGate` is one opinionated composition; this module factors
+* the decision into two reusable pieces so MANY policies can compete over the
+* SAME evidence (the quant-desk pattern: one evidence bus, plural strategies):
+*
+*   buildEvidenceVector(ctx, objectives, opts) -> EvidenceVector   // the bus
+*   PromotionPolicy = (ev: EvidenceVector) => GateResult           // a strategy
+*   paretoPolicy(ev)                                               // the default strategy
+*   paretoSignificanceGate(options): Gate                          // bus + policy as a Gate
+*
+* The Pareto policy is SYMMETRIC multi-objective: every objective is BOTH a
+* potential gain source AND a safety floor (unlike `defaultProductionGate`,
+* where only `composite` can win and `criticalDimensions` are pure floors). A
+* candidate ships iff it weakly DOMINATES the baseline at the confidence level —
+* no objective credibly worse (CI floor breach) AND at least one objective
+* credibly better (CI gain). Insufficient evidence on ANY axis -> need_more_work
+* (NOT folded into hold: "gather more reps" and "reject" are different actions).
+*
+* Cost/latency are NOT CI axes here — `GateContext` carries only an aggregate
+* per-side cost, no per-cell observation vector to bootstrap. Treat them as hard
+* constraints (compose with a budget gate via `composeGate`), not faked CIs.
+*/
+/**
 * The Evidence Bus. For each objective, pair candidate vs baseline by full
 * cellId and bootstrap a CI on the good-direction paired delta. Reuses the
 * exact `pairHoldout` + `pairedBootstrap` machinery the held-out gate uses, so
@@ -5693,7 +5774,6 @@ function powerPreflight(opts) {
 */
 function buildEvidenceVector(ctx, objectives, opts = {}) {
 	if (objectives.length === 0) throw new Error("buildEvidenceVector: at least 1 objective required");
-	const minProductiveRuns = opts.minProductiveRuns ?? 3;
 	const confidence = opts.confidence ?? .95;
 	const resamples = opts.resamples ?? 2e3;
 	const seed = opts.seed ?? 1337;
@@ -5708,22 +5788,37 @@ function buildEvidenceVector(ctx, objectives, opts = {}) {
 			select = (s) => s.dimensions[dim];
 		}
 		const paired = pairHoldout(ctx.judgeScores, baseline, scenarioIds, select);
-		const bootstrap = pairedBootstrap(obj.direction === "maximize" ? paired.before : paired.after, obj.direction === "maximize" ? paired.after : paired.before, {
+		const before = obj.direction === "maximize" ? paired.before : paired.after;
+		const after = obj.direction === "maximize" ? paired.after : paired.before;
+		const n = paired.before.length;
+		const floorTolerance = obj.floorTolerance ?? .05 * detectScale([...paired.before, ...paired.after]);
+		const gainThreshold = obj.gainThreshold ?? 0;
+		const improvement = pairedDeltaTest(before, after, {
 			confidence,
 			resamples,
 			statistic: "median",
-			seed
+			seed,
+			threshold: gainThreshold,
+			minPairs: opts.minProductiveRuns
 		});
-		const n = paired.before.length;
-		const floorTolerance = obj.floorTolerance ?? .05 * detectScale([...paired.before, ...paired.after]);
-		const gainThreshold = obj.gainThreshold ?? 0;
-		const verdict = n < minProductiveRuns ? "few_runs" : bootstrap.low < -floorTolerance ? "regressed" : bootstrap.low > gainThreshold ? "improved" : "flat";
+		const regression = pairedDeltaTest(after, before, {
+			confidence,
+			resamples,
+			statistic: "median",
+			seed,
+			threshold: floorTolerance,
+			minPairs: opts.minProductiveRuns
+		});
+		const bootstrap = improvement.bootstrap;
+		const verdict = !improvement.sufficient ? "few_runs" : regression.significant ? "regressed" : improvement.significant ? "improved" : "flat";
 		axes.push({
 			name: obj.name,
 			source: obj.source,
 			direction: obj.direction,
 			bootstrap,
 			n,
+			minimumRequired: improvement.minimumPairs,
+			decisionMethod: improvement.method,
 			gainThreshold,
 			floorTolerance,
 			verdict
@@ -6413,6 +6508,8 @@ async function runOptimization(opts) {
 	const candidateConcurrency = opts.candidateConcurrency ?? 1;
 	if (typeof opts.runDir !== "string" || opts.runDir.trim().length === 0) throw new Error("runOptimization: runDir is required and must be a non-empty string");
 	if (!Number.isInteger(candidateConcurrency) || candidateConcurrency < 1) throw new Error("runOptimization: candidateConcurrency must be a positive integer");
+	const initialFindings = immutableProposalSnapshot(assertProposalFindings(opts.findings ?? [], "runOptimization initial proposal findings"), "initial findings");
+	const baselineSurface = immutableProposalSnapshot(opts.baselineSurface, "baseline surface");
 	opts.runDir = resolveRunDir(opts.runDir, opts.repo);
 	const storage = opts.storage ?? fsCampaignStorage();
 	const costLedger = opts.costLedger ?? createRunCostLedger({
@@ -6425,7 +6522,7 @@ async function runOptimization(opts) {
 	const premeasuredBaseline = opts.premeasuredBaseline;
 	const baselineCampaign = premeasuredBaseline ? validatedPremeasuredBaseline({
 		input: premeasuredBaseline,
-		baselineSurface: opts.baselineSurface,
+		baselineSurface,
 		scenarios: opts.scenarios,
 		reps,
 		seed: opts.seed ?? 42
@@ -6433,7 +6530,7 @@ async function runOptimization(opts) {
 		...opts,
 		costLedger,
 		costPhase: "search.baseline",
-		dispatch: (scenario, ctx) => opts.dispatchWithSurface(opts.baselineSurface, scenario, ctx),
+		dispatch: (scenario, ctx) => opts.dispatchWithSurface(baselineSurface, scenario, ctx),
 		runDir: `${opts.runDir}/baseline`
 	});
 	const baselineCoverage = campaignCoverage(baselineCampaign.cells, opts.scenarios, reps, requireJudgeScore);
@@ -6443,10 +6540,10 @@ async function runOptimization(opts) {
 	}
 	const generations = [];
 	const history = [];
-	let currentFindings = opts.findings ?? [];
+	let currentFindings = initialFindings;
 	const selectionRankKey = opts.selectionRankKey ?? ((campaign) => [campaignMeanComposite(campaign)]);
-	let winnerSurface = opts.baselineSurface;
-	let winnerSurfaceHash = surfaceHash(opts.baselineSurface);
+	let winnerSurface = baselineSurface;
+	let winnerSurfaceHash = surfaceHash(baselineSurface);
 	let winnerComposite = campaignMeanComposite(baselineCampaign);
 	let winnerRankKey = selectionRankKey(baselineCampaign);
 	assertFiniteRankKey(winnerRankKey, "selectionRankKey for baseline");
@@ -6454,7 +6551,7 @@ async function runOptimization(opts) {
 	let winnerOutcome = baselineOutcome;
 	let winnerLabel;
 	let winnerRationale;
-	const scored = [toParetoParent(opts.baselineSurface, winnerSurfaceHash, baselineCampaign, -1)];
+	const scored = [toParetoParent(baselineSurface, winnerSurfaceHash, baselineCampaign, -1)];
 	if (opts.analyzeGeneration && opts.maxGenerations > 0 && baselineCampaign.cells.length > 0) {
 		const fresh = await opts.analyzeGeneration({
 			generation: -1,
@@ -6468,31 +6565,34 @@ async function runOptimization(opts) {
 			costLedger,
 			costPhase: "analysis.baseline"
 		});
-		if (Array.isArray(fresh)) currentFindings = fresh;
+		if (!Array.isArray(fresh)) throw new TypeError("runOptimization: analyzeGeneration must return an array");
+		currentFindings = immutableProposalSnapshot(assertProposalFindings(fresh, "runOptimization baseline analysis findings"), "baseline analysis findings");
 	}
 	for (let gen = 0; gen < opts.maxGenerations; gen++) {
-		if (proposer.decide?.({ history }).stop) break;
+		const proposalHistory = immutableProposalSnapshot(history, "history");
+		if (proposer.decide?.({ history: proposalHistory }).stop) break;
 		const paretoParents = computeParetoFrontier(scored);
 		const parentSurfaceHash = winnerSurfaceHash;
 		const parentComposite = winnerComposite;
-		const proposed = await proposer.propose({
-			currentSurface: winnerSurface,
-			history,
-			findings: currentFindings,
+		const proposalContext = Object.freeze({
+			currentSurface: immutableProposalSnapshot(winnerSurface, "current surface"),
+			history: proposalHistory,
+			findings: immutableProposalSnapshot(assertProposalFindings(currentFindings, "runOptimization proposal findings"), "findings"),
 			populationSize: opts.populationSize,
 			generation: gen,
-			signal: new AbortController().signal,
-			baselineOutcome,
-			incumbentOutcome: winnerOutcome,
-			report: opts.report,
-			dataset: opts.labeledStore && opts.labeledStore !== "off" ? opts.labeledStore : void 0,
+			signal: opts.signal ?? new AbortController().signal,
+			baselineOutcome: immutableProposalSnapshot(baselineOutcome, "baseline outcome"),
+			incumbentOutcome: immutableProposalSnapshot(winnerOutcome, "incumbent outcome"),
 			maxImprovementShots: opts.maxImprovementShots,
-			paretoParents,
+			paretoParents: immutableProposalSnapshot(paretoParents, "Pareto parents"),
 			costLedger,
 			costPhase: "search.proposal"
 		});
-		if (proposed.length === 0) break;
-		const surfaceResults = await mapConcurrent(proposed.map((p) => isProposedCandidate(p) ? p : {
+		const proposed = await proposer.propose(proposalContext);
+		if (!Array.isArray(proposed)) throw new TypeError("runOptimization: proposer must return an array");
+		const proposalSnapshot = immutableProposalSnapshot(proposed, "candidate outputs");
+		if (proposalSnapshot.length === 0) break;
+		const surfaceResults = await mapConcurrent(proposalSnapshot.map((p) => isProposedCandidate(p) ? p : {
 			surface: p,
 			label: "",
 			rationale: ""
@@ -6589,11 +6689,13 @@ async function runOptimization(opts) {
 				costLedger,
 				costPhase: "analysis.generation"
 			});
-			if (Array.isArray(fresh)) currentFindings = fresh;
+			if (!Array.isArray(fresh)) throw new TypeError("runOptimization: analyzeGeneration must return an array");
+			currentFindings = immutableProposalSnapshot(assertProposalFindings(fresh, "runOptimization generation analysis findings"), "generation analysis findings");
 		}
 	}
 	return {
 		generations,
+		baselineSurface,
 		winnerSurface,
 		winnerSurfaceHash,
 		winnerLabel,
@@ -6603,6 +6705,19 @@ async function runOptimization(opts) {
 		cost: costLedger.summary()
 	};
 }
+function immutableProposalSnapshot(value, label) {
+	try {
+		return deepFreeze(structuredClone(value));
+	} catch (cause) {
+		throw new TypeError(`runOptimization: proposal ${label} must contain snapshot-safe data`, { cause });
+	}
+}
+function deepFreeze(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (typeof value !== "object" || value === null || seen.has(value)) return value;
+	seen.add(value);
+	for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(value))) if ("value" in descriptor) deepFreeze(descriptor.value, seen);
+	return Object.freeze(value);
+}
 function validatedPremeasuredBaseline(args) {
 	const { input } = args;
 	if (input.surfaceHash !== surfaceHash(args.baselineSurface)) throw new Error("runOptimization: premeasured baseline surface hash does not match baselineSurface");
@@ -6712,7 +6827,8 @@ async function runImprovementLoop(opts) {
 		dispatchTimeoutMs,
 		costLedger
 	});
-	const winnerIsBaseline = optimization.winnerSurfaceHash === surfaceHash(opts.baselineSurface);
+	const baselineSurface = optimization.baselineSurface;
+	const winnerIsBaseline = optimization.winnerSurfaceHash === surfaceHash(baselineSurface);
 	const holdoutDeferred = (opts.holdout ?? "measured") === "deferred";
 	const baselineOnHoldout = holdoutDeferred ? await runCampaign({
 		...opts,
@@ -6732,7 +6848,7 @@ async function runImprovementLoop(opts) {
 		costPhase: "holdout.baseline",
 		dispatchTimeoutMs,
 		scenarios: opts.holdoutScenarios,
-		dispatch: (scenario, ctx) => opts.dispatchWithSurface(opts.baselineSurface, scenario, ctx),
+		dispatch: (scenario, ctx) => opts.dispatchWithSurface(baselineSurface, scenario, ctx),
 		runDir: `${opts.runDir}/holdout-baseline`
 	});
 	const winnerOnHoldout = winnerIsBaseline || holdoutDeferred ? baselineOnHoldout : await runCampaign({
@@ -6772,7 +6888,7 @@ async function runImprovementLoop(opts) {
 	let neutralizedOnHoldout;
 	let neutralizedSurface;
 	if (opts.neutralize && !winnerIsBaseline && !holdoutDeferred) {
-		const surface = opts.neutralize(optimization.winnerSurface, opts.baselineSurface);
+		const surface = opts.neutralize(optimization.winnerSurface, baselineSurface);
 		neutralizedSurface = surface;
 		neutralizedOnHoldout = await runCampaign({
 			...opts,
@@ -6825,7 +6941,7 @@ async function runImprovementLoop(opts) {
 		costPhase: "promotion.gate",
 		signal: new AbortController().signal
 	});
-	const promotedDiff = optimization.winnerSurfaceHash === surfaceHash(opts.baselineSurface) ? "" : renderSurfaceDiff(optimization.winnerSurface, opts.baselineSurface);
+	const promotedDiff = optimization.winnerSurfaceHash === surfaceHash(baselineSurface) ? "" : renderSurfaceDiff(optimization.winnerSurface, baselineSurface);
 	let prResult;
 	if (opts.autoOnPromote === "pr" && gateResult.decision === "ship") prResult = openAutoPr({
 		result: winnerOnHoldout,
@@ -7717,6 +7833,6 @@ function skillOptOptimizationMethod(config) {
 	};
 }
 //#endregion
-export { SEARCH_LEDGER_FILE_CONTEXT as $, acquireSingleRunLock as A, dominates as At, surfaceContentHash as B, JudgeParseError as Bt, detectScale as C, llmJudge as Ct, runCanaries as D, fileVerdictCache as Dt, pairHoldout as E, contentHash as Et, assertCodeSurfaceIdentity as F, BackendIntegrityError as Ft, DEFAULT_MUTATION_PRIMITIVES as G, campaignBreakdown as H, assertComponentSurface as I, assertRealAgentReceipts as It, planCampaignRun as J, buildReflectionPrompt as K, codeSurfaceIdentityMaterial as L, assertRealBackend as Lt, compareOptimizationMethods as M, paretoFrontierWithCrowding as Mt, costFromLedgerSummary as N, scalarScore as Nt, composeGate as O, inMemoryVerdictCache as Ot, optimizationTokenUsageFromSummary as P, recoverTruncatedJson as Pt, inMemoryCampaignStorage as Q, componentSurfaceIdentityMaterial as R, summarizeAgentReceiptIntegrity as Rt, defaultProductionGate as S, hashScenarios as St, heldoutSignificance as T, canonicalJson as Tt, campaignMeanComposite as U, surfaceHash as V, compareRankKeys as W, createRunCostLedger as X, runCampaign as Y, fsCampaignStorage as Z, buildEvidenceVector as _, redTeamReport as _t, emitLoopProvenance as a, assertCampaignDesign as at, powerPreflight as b, Dataset as bt, provenanceRecordPath as c, campaignSplitDigest as ct, runImprovementLoop as d, REFERENCE_EQUIVALENCE_INPUT_LIMITS as dt, SearchLedgerConflictError as et, runOptimization as f, REFERENCE_EQUIVALENCE_JUDGE_VERSION as ft, gepaOptimizationMethod as g, redTeamDataset as gt, labelTrustRank as h, DEFAULT_RED_TEAM_CORPUS as ht, canonicalDigest as i, tangleTracesRoot as it, assertOptimizationResult as j, paretoFrontier as jt, externalTextOptimizationMethod as k, crowdingDistance as kt, provenanceSpansPath as l, campaignSplitDigestFromIdentities as lt, isProposedCandidate as m, runReferenceEquivalenceJudge as mt, buildLoopProvenanceRecord as n, SearchLedgerIntegrityError as nt, loopProvenanceArgsFromResult as o, assertCampaignSplitIdentity as ot, runEval as p, createReferenceEquivalenceJudge as pt, parseReflectionResponse as q, campaignMeasurementDigest as r, resolveRunDir as rt, loopProvenanceSpans as s, campaignScenarioIdentity as st, skillOptOptimizationMethod as t, SearchLedgerError as tt, verifyLoopProvenanceRecord as u, openAutoPr as ut, paretoPolicy as v, scoreRedTeamOutput as vt, dimensionRegressions as w, cachedJudge as wt, heldOutGate as x, HoldoutLockedError as xt, paretoSignificanceGate as y, toolNamesForRun as yt, renderSurfaceDiff as z, summarizeBackendIntegrity as zt };
+export { SEARCH_LEDGER_FILE_CONTEXT as $, acquireSingleRunLock as A, dominates as At, surfaceContentHash as B, summarizeAgentReceiptIntegrity as Bt, detectScale as C, llmJudge as Ct, runCanaries as D, fileVerdictCache as Dt, pairHoldout as E, contentHash as Et, assertCodeSurfaceIdentity as F, minimumPairsForPairedDeltaTest as Ft, DEFAULT_MUTATION_PRIMITIVES as G, campaignBreakdown as H, JudgeParseError as Ht, assertComponentSurface as I, pairedDeltaTest as It, planCampaignRun as J, buildReflectionPrompt as K, codeSurfaceIdentityMaterial as L, BackendIntegrityError as Lt, compareOptimizationMethods as M, paretoFrontierWithCrowding as Mt, costFromLedgerSummary as N, scalarScore as Nt, composeGate as O, inMemoryVerdictCache as Ot, optimizationTokenUsageFromSummary as P, recoverTruncatedJson as Pt, inMemoryCampaignStorage as Q, componentSurfaceIdentityMaterial as R, assertRealAgentReceipts as Rt, defaultProductionGate as S, hashScenarios as St, heldoutSignificance as T, canonicalJson as Tt, campaignMeanComposite as U, surfaceHash as V, summarizeBackendIntegrity as Vt, compareRankKeys as W, createRunCostLedger as X, runCampaign as Y, fsCampaignStorage as Z, buildEvidenceVector as _, redTeamReport as _t, emitLoopProvenance as a, assertCampaignDesign as at, powerPreflight as b, Dataset as bt, provenanceRecordPath as c, campaignSplitDigest as ct, runImprovementLoop as d, REFERENCE_EQUIVALENCE_INPUT_LIMITS as dt, SearchLedgerConflictError as et, runOptimization as f, REFERENCE_EQUIVALENCE_JUDGE_VERSION as ft, gepaOptimizationMethod as g, redTeamDataset as gt, labelTrustRank as h, DEFAULT_RED_TEAM_CORPUS as ht, canonicalDigest as i, tangleTracesRoot as it, assertOptimizationResult as j, paretoFrontier as jt, externalTextOptimizationMethod as k, crowdingDistance as kt, provenanceSpansPath as l, campaignSplitDigestFromIdentities as lt, isProposedCandidate as m, runReferenceEquivalenceJudge as mt, buildLoopProvenanceRecord as n, SearchLedgerIntegrityError as nt, loopProvenanceArgsFromResult as o, assertCampaignSplitIdentity as ot, runEval as p, createReferenceEquivalenceJudge as pt, parseReflectionResponse as q, campaignMeasurementDigest as r, resolveRunDir as rt, loopProvenanceSpans as s, campaignScenarioIdentity as st, skillOptOptimizationMethod as t, SearchLedgerError as tt, verifyLoopProvenanceRecord as u, openAutoPr as ut, paretoPolicy as v, scoreRedTeamOutput as vt, dimensionRegressions as w, cachedJudge as wt, heldOutGate as x, HoldoutLockedError as xt, paretoSignificanceGate as y, toolNamesForRun as yt, renderSurfaceDiff as z, assertRealBackend as zt };
 
-//# sourceMappingURL=skillopt-optimization-method-CF6a327Q.js.map
+//# sourceMappingURL=skillopt-optimization-method-BY6vKLJB.js.map