@tangle-network/agent-eval 0.217.1 → 0.218.1

package/dist/{llm-judge-C8jMTNNG.js → llm-judge-Djxh-Uhs.js}

@@ -8,18 +8,18 @@ import { a as heldoutSignificance, i as dimensionRegressions, o as pairHoldout }
 import { n as contentHash } from "./verdict-cache-CL_7tePD.js";
 import { r as projectCampaignCellQuality, t as campaignCellCostProvenance } from "./run-record-CysKLB93.js";
 import { n as CostAccountingIncompleteError, t as CostLedger } from "./cost-ledger-D0352Z4d.js";
-import { A as surfaceHashMatches, D as surfaceContentHash, E as renderSurfaceDiff, F as assertCampaignSplitIdentity, I as assertCompleteCampaign, L as campaignCoverage, O as surfaceDispatchRef, P as assertCampaignDesign, R as campaignScenarioIdentity, V as formatCoverageFailures, b as FinalEvidenceConflictError, f as campaignBreakdown, j as BackendIntegrityError, k as surfaceHash, m as campaignMeanCompositeOrNull, p as campaignMeanComposite, x as FinalEvidenceError, z as campaignSplitDigest } from "./campaign-evidence-CQYw8_0H.js";
+import { A as surfaceHashMatches, D as surfaceContentHash, E as renderSurfaceDiff, F as assertCampaignSplitIdentity, I as assertCompleteCampaign, L as campaignCoverage, O as surfaceDispatchRef, P as assertCampaignDesign, R as campaignScenarioIdentity, V as formatCoverageFailures, b as FinalEvidenceConflictError, f as campaignBreakdown, j as BackendIntegrityError, k as surfaceHash, m as campaignMeanCompositeOrNull, p as campaignMeanComposite, x as FinalEvidenceError, z as campaignSplitDigest } from "./campaign-evidence-DunzcJGv.js";
 import { t as deepFreezeCanonicalJson } from "./deep-freeze-CurcOQg3.js";
-import { M as fsCampaignStorage, h as isExternalTextCandidate, j as createRunCostLedger } from "./external-optimizer-subprocess-XIHBOSKt.js";
+import { M as fsCampaignStorage, h as isExternalTextCandidate, j as createRunCostLedger } from "./external-optimizer-subprocess-B5gdLRZv.js";
 import { r as summarizeEvaluationUnits, t as defineEvaluationClaim } from "./claim-BPVuyHuy.js";
 import { d as detectPersonalData, s as redactText, t as REDACTION_VERSION, u as detectCredential } from "./redact-mtkTiJVk.js";
 import { t as detectRewardHacking } from "./reward-hacking-ByuETaIb.js";
-import { t as assertProposalFindings } from "./proposal-findings-BbWidvUk.js";
-import { i as runSearch, m as searchExpansionIndex, n as paretoFrontier, o as searchPolicyView, p as SEARCH_KERNEL_SOURCE, r as paretoFrontierWithCrowding, s as EXPANSION_OPERATORS, w as estimateNode } from "./pareto-BzsxidFD.js";
-import { a as validateSearchLedgerEvent, d as searchNodeId, f as searchTaskSetDigest, i as replaySearchLedgerText, n as openSearchLedger, u as searchCellId } from "./search-ledger-TUvB5gWH.js";
-import { n as searchProposerView, t as renderSearchSummary } from "./search-summary-DQIvJsSB.js";
+import { t as assertProposalFindings } from "./proposal-findings-n-5WBbEx.js";
+import { i as runSearch, m as searchExpansionIndex, n as paretoFrontier, o as searchPolicyView, p as SEARCH_KERNEL_SOURCE, r as paretoFrontierWithCrowding, s as EXPANSION_OPERATORS, w as estimateNode } from "./pareto-CTv8vozZ.js";
+import { a as validateSearchLedgerEvent, d as searchNodeId, f as searchTaskSetDigest, i as replaySearchLedgerText, n as openSearchLedger, u as searchCellId } from "./search-ledger-ClpN4I3e.js";
+import { n as searchProposerView, t as renderSearchSummary } from "./search-summary-CrBuvVnf.js";
 import { i as stripFencedJson, n as isRecord } from "./json-BhdsJaOQ.js";
-import { a as maximumChargeForLlmRequest, i as costReceiptFromLlmError, r as costReceiptFromLlm } from "./llm-client-BshCREn6.js";
+import { a as maximumChargeForLlmRequest, i as costReceiptFromLlmError, r as costReceiptFromLlm } from "./llm-client-_Y6ic-tf.js";
 import { createHash } from "node:crypto";
 import { writeFileSync } from "node:fs";
 import { z } from "zod";
@@ -337,52 +337,41 @@ function hasLlmCall(value) {
 * persisted cell result. `runCampaign` owns the schedule; this module owns
 * everything that happens inside a single cell.
 */
-async function executeCell(args) {
-	const storage = args.storage;
-	const cellDir = cellDirectory(args.opts.runDir, args.slot.cellId);
-	storage.ensureDir(cellDir);
-	const stableCostTags = stableCostTagsFor(args.opts, args.slot);
-	const costTags = {
-		...stableCostTags,
-		runAttemptId: args.runAttemptId
-	};
-	const attemptCostTags = {
-		...costTags,
-		attemptNumber: String(args.attempt)
-	};
-	const cachePath = join(cellDir, "cached-result.json");
-	if (args.resumable) {
-		const cached = readCachedCell({
-			storage,
-			cachePath,
-			cellId: args.slot.cellId,
-			manifestHash: args.manifestHash
-		});
-		if (cached.status === "miss" && cacheIssueRequiresExplicitRerun(cached.reason) && !args.opts.rerunInvalidCachedCells) throw invalidCachedCellsError([{
+/** A cached cell is reused only when its receipts still match the ledger; invalid cache entries need an explicit rerun. */
+function reuseCachedCell(args, cachePath, stableCostTags) {
+	const cached = readCachedCell({
+		storage: args.storage,
+		cachePath,
+		cellId: args.slot.cellId,
+		manifestHash: args.manifestHash
+	});
+	if (cached.status === "miss" && cacheIssueRequiresExplicitRerun(cached.reason) && !args.opts.rerunInvalidCachedCells) throw invalidCachedCellsError([{
+		cellId: args.slot.cellId,
+		reason: cached.reason
+	}]);
+	if (cached.status === "hit" && (!cached.cell.error || args.opts.reuseFailedCells)) {
+		const receiptProblem = cachedCellReceiptProblem(cached.cell, args.costLedger, stableCostTags);
+		if (receiptProblem === void 0) {
+			const cell = withCurrentAgentModelEvidence(cached.cell, args.costLedger, stableCostTags);
+			enforceDispatchUsage(cell, args.opts.expectUsage ?? "warn");
+			return {
+				cell: {
+					...cell,
+					cached: true
+				},
+				artifactsByPath: {}
+			};
+		}
+		if (!args.opts.rerunInvalidCachedCells) throw invalidCachedCellsError([{
 			cellId: args.slot.cellId,
-			reason: cached.reason
+			reason: "invalid-cost-receipts",
+			detail: receiptProblem
 		}]);
-		if (cached.status === "hit" && (!cached.cell.error || args.opts.reuseFailedCells)) {
-			const receiptProblem = cachedCellReceiptProblem(cached.cell, args.costLedger, stableCostTags);
-			if (receiptProblem === void 0) {
-				const cell = withCurrentAgentModelEvidence(cached.cell, args.costLedger, stableCostTags);
-				enforceDispatchUsage(cell, args.opts.expectUsage ?? "warn");
-				return {
-					cell: {
-						...cell,
-						cached: true
-					},
-					artifactsByPath: {}
-				};
-			}
-			if (!args.opts.rerunInvalidCachedCells) throw invalidCachedCellsError([{
-				cellId: args.slot.cellId,
-				reason: "invalid-cost-receipts",
-				detail: receiptProblem
-			}]);
-		}
 	}
-	const startMs = Date.now();
+}
+/** The directories, writers, abort chain and dispatch context of one execution attempt. */
+function openAttempt(args, cellDir, attemptCostTags) {
+	const { storage } = args;
 	const attempt = {
 		runAttemptId: args.runAttemptId,
 		number: args.attempt
@@ -407,7 +396,7 @@ async function executeCell(args) {
 	artifactsByPath[`${args.slot.cellId}/${attemptPrefix}/identity.json`] = identityPath;
 	storage.write(join(cellDir, "latest-attempt.json"), JSON.stringify(attempt));
 	const trace = args.buildTraceWriter(args.slot.cellId, traceDir);
-	let paidCallStarted = false;
+	const paid = { started: false };
 	const artifacts = {
 		async write(path, content) {
 			const fullPath = resolve(artifactDir, path);
@@ -422,8 +411,10 @@ async function executeCell(args) {
 			return artifacts.write(path, JSON.stringify(value, null, 2));
 		}
 	};
+	const cellAbort = new AbortController();
+	const onCampaignAbort = () => cellAbort.abort(args.signal.reason);
 	const cost = { async runPaidCall(input) {
-		paidCallStarted = true;
+		paid.started = true;
 		const result = await args.costLedger.runPaidCall({
 			...input,
 			channel: input.channel ?? "agent",
@@ -439,25 +430,36 @@ async function executeCell(args) {
 		scenario: args.slot.scenario,
 		rep: args.slot.rep
 	});
-	const cellAbort = new AbortController();
-	const onCampaignAbort = () => cellAbort.abort(args.signal.reason);
 	if (args.signal.aborted) cellAbort.abort(args.signal.reason);
 	else args.signal.addEventListener("abort", onCampaignAbort, { once: true });
-	const ctx = {
-		cellId: args.slot.cellId,
-		runAttemptId: args.runAttemptId,
-		rep: args.slot.rep,
-		seed: args.slot.cellSeed,
-		signal: cellAbort.signal,
+	return {
+		attempt,
+		attemptDir,
+		attemptPrefix,
+		artifactsByPath,
 		trace,
-		artifacts,
-		cost,
-		placement
+		paid,
+		cellAbort,
+		onCampaignAbort,
+		ctx: {
+			cellId: args.slot.cellId,
+			runAttemptId: args.runAttemptId,
+			rep: args.slot.rep,
+			seed: args.slot.cellSeed,
+			signal: cellAbort.signal,
+			trace,
+			artifacts,
+			cost,
+			placement
+		}
 	};
+}
+/** Dispatch the scenario under the per-cell abort and the dispatch deadline. A failure is recorded, not thrown. */
+async function dispatchCell(args, run) {
+	const { cellAbort, onCampaignAbort, ctx } = run;
 	let artifact;
 	let errorMessage;
 	let failure;
-	let fatalCellError;
 	let dispatched;
 	const timeoutMs = args.dispatchTimeoutMs;
 	let timeoutTimer;
@@ -500,29 +502,41 @@ async function executeCell(args) {
 		removeAbortListener();
 		args.signal.removeEventListener("abort", onCampaignAbort);
 	}
+	return {
+		artifact,
+		errorMessage,
+		failure,
+		dispatched
+	};
+}
+/** A dispatch that ignored cancellation, or paid calls that never settled, mean no trustworthy cell result exists. */
+async function awaitCellShutdown(args, run, dispatched, costTags) {
+	const { trace, paid } = run;
 	if (dispatched) {
 		if (!await settlesWithin(dispatched, args.dispatchShutdownTimeoutMs)) {
 			await trace.flush();
 			throw new CostAccountingIncompleteError(`dispatch for cell '${args.slot.cellId}' ignored cancellation and did not stop within ${args.dispatchShutdownTimeoutMs}ms; no campaign result was produced`);
 		}
 	}
-	if (paidCallStarted) {
-		if (typeof args.costLedger.waitForIdle !== "function") {
-			await trace.flush();
-			throw new CostAccountingIncompleteError(`cost ledger for cell '${args.slot.cellId}' cannot prove that paid calls stopped`);
-		}
-		if (!await args.costLedger.waitForIdle({
-			timeoutMs: args.dispatchShutdownTimeoutMs,
-			filter: {
-				channel: "agent",
-				phase: args.costPhase,
-				tags: costTags
-			}
-		})) {
-			await trace.flush();
-			throw new CostAccountingIncompleteError(`paid calls for cell '${args.slot.cellId}' did not settle within ${args.dispatchShutdownTimeoutMs}ms; no campaign result was produced`);
+	if (!paid.started) return;
+	if (typeof args.costLedger.waitForIdle !== "function") {
+		await trace.flush();
+		throw new CostAccountingIncompleteError(`cost ledger for cell '${args.slot.cellId}' cannot prove that paid calls stopped`);
+	}
+	if (!await args.costLedger.waitForIdle({
+		timeoutMs: args.dispatchShutdownTimeoutMs,
+		filter: {
+			channel: "agent",
+			phase: args.costPhase,
+			tags: costTags
 		}
+	})) {
+		await trace.flush();
+		throw new CostAccountingIncompleteError(`paid calls for cell '${args.slot.cellId}' did not settle within ${args.dispatchShutdownTimeoutMs}ms; no campaign result was produced`);
 	}
+}
+/** The agent spend of this attempt: cost, token usage and the models that served it. */
+function measureAgentUsage(args, costTags) {
 	const agentReceipts = args.costLedger.list({
 		channel: "agent",
 		tags: costTags
@@ -531,29 +545,29 @@ async function executeCell(args) {
 		channel: "agent",
 		tags: costTags
 	});
-	const tokenUsage = {
-		input: agentCost.inputTokens,
-		output: agentCost.outputTokens,
-		...agentCost.usageComplete ? {} : { tokensKnown: false },
-		...agentCost.reasoningTokens !== void 0 && agentCost.reasoningTokens > 0 ? { reasoning: agentCost.reasoningTokens } : {},
-		...agentCost.cachedTokens > 0 ? { cached: agentCost.cachedTokens } : {},
-		...agentCost.cacheWriteTokens !== void 0 && agentCost.cacheWriteTokens > 0 ? { cacheWrite: agentCost.cacheWriteTokens } : {}
-	};
-	const agentModelEvidence = modelEvidenceFromReceipts(agentReceipts);
-	const dispatchResult = {
-		cellId: args.slot.cellId,
-		artifact,
-		error: errorMessage,
-		costUsd: agentCost.totalCostUsd,
-		tokenUsage
+	return {
+		agentCost,
+		tokenUsage: {
+			input: agentCost.inputTokens,
+			output: agentCost.outputTokens,
+			...agentCost.usageComplete ? {} : { tokensKnown: false },
+			...agentCost.reasoningTokens !== void 0 && agentCost.reasoningTokens > 0 ? { reasoning: agentCost.reasoningTokens } : {},
+			...agentCost.cachedTokens > 0 ? { cached: agentCost.cachedTokens } : {},
+			...agentCost.cacheWriteTokens !== void 0 && agentCost.cacheWriteTokens > 0 ? { cacheWrite: agentCost.cacheWriteTokens } : {}
+		},
+		agentModelEvidence: modelEvidenceFromReceipts(agentReceipts)
 	};
-	try {
-		enforceDispatchUsage(dispatchResult, args.opts.expectUsage ?? "warn");
-	} catch (error) {
-		await trace.flush();
-		throw error;
-	}
+}
+/**
+* Run judges (only if we have an artifact). A judge that throws invalidates
+* the cell — recorded as `error`, NOT folded into a fake composite:0 (a fake
+* zero is indistinguishable from a real zero and poisons every aggregate).
+*/
+async function judgeArtifact(args, artifact, attemptCostTags) {
 	const judgeScores = {};
+	let errorMessage;
+	let failure;
+	let fatalCellError;
 	if (artifact !== void 0) for (const judge of args.opts.judges ?? []) {
 		if (judge.appliesTo && !judge.appliesTo(args.slot.scenario)) continue;
 		try {
@@ -577,6 +591,79 @@ async function executeCell(args) {
 			break;
 		}
 	}
+	return {
+		judgeScores,
+		errorMessage,
+		failure,
+		fatalCellError
+	};
+}
+/** Write the failure receipt and decide whether `cellRetry` dispatches this slot again. */
+function recordCellFailure(args, run, failure, cell, costTags, fatalCellError) {
+	const { attemptDir, attemptPrefix, artifactsByPath } = run;
+	const receipt = {
+		schemaVersion: 1,
+		runAttemptId: args.runAttemptId,
+		recordedAt: args.now().toISOString(),
+		failure: {
+			stage: failure.stage,
+			...failure.judge ? { judge: failure.judge } : {},
+			error: serializeCellError(failure.cause)
+		},
+		cell,
+		cost: args.costLedger.summary({
+			phase: args.costPhase,
+			tags: costTags
+		})
+	};
+	const retry = args.cellRetry !== void 0 && args.attempt < args.cellRetry.attempts && !args.signal.aborted && fatalCellError === void 0 && args.cellRetry.retryable(receipt.failure);
+	const failurePath = join(attemptDir, "failure-receipt.json");
+	args.storage.write(failurePath, JSON.stringify(receipt, null, 2));
+	artifactsByPath[`${args.slot.cellId}/${attemptPrefix}/failure-receipt.json`] = failurePath;
+	if (!retry) args.onFailure?.(failure);
+	return retry;
+}
+async function executeCell(args) {
+	const storage = args.storage;
+	const cellDir = cellDirectory(args.opts.runDir, args.slot.cellId);
+	storage.ensureDir(cellDir);
+	const stableCostTags = stableCostTagsFor(args.opts, args.slot);
+	const costTags = {
+		...stableCostTags,
+		runAttemptId: args.runAttemptId
+	};
+	const attemptCostTags = {
+		...costTags,
+		attemptNumber: String(args.attempt)
+	};
+	const cachePath = join(cellDir, "cached-result.json");
+	if (args.resumable) {
+		const reused = reuseCachedCell(args, cachePath, stableCostTags);
+		if (reused) return reused;
+	}
+	const startMs = Date.now();
+	const run = openAttempt(args, cellDir, attemptCostTags);
+	const { attempt, attemptDir, attemptPrefix, artifactsByPath, trace } = run;
+	const dispatch = await dispatchCell(args, run);
+	await awaitCellShutdown(args, run, dispatch.dispatched, costTags);
+	const { artifact } = dispatch;
+	const { agentCost, tokenUsage, agentModelEvidence } = measureAgentUsage(args, costTags);
+	try {
+		enforceDispatchUsage({
+			cellId: args.slot.cellId,
+			artifact,
+			error: dispatch.errorMessage,
+			costUsd: agentCost.totalCostUsd,
+			tokenUsage
+		}, args.opts.expectUsage ?? "warn");
+	} catch (error) {
+		await trace.flush();
+		throw error;
+	}
+	const judged = await judgeArtifact(args, artifact, attemptCostTags);
+	const failure = judged.failure ?? dispatch.failure;
+	const errorMessage = judged.failure ? judged.errorMessage : dispatch.errorMessage;
+	const { judgeScores, fatalCellError } = judged;
 	if (failure) await waitForFailedCellCostSettlement({
 		costLedger: args.costLedger,
 		costPhase: args.costPhase,
@@ -606,29 +693,7 @@ async function executeCell(args) {
 		...failure?.judge ? { errorJudge: failure.judge } : {},
 		error: errorMessage
 	};
-	let retry = false;
-	if (failure) {
-		const receipt = {
-			schemaVersion: 1,
-			runAttemptId: args.runAttemptId,
-			recordedAt: args.now().toISOString(),
-			failure: {
-				stage: failure.stage,
-				...failure.judge ? { judge: failure.judge } : {},
-				error: serializeCellError(failure.cause)
-			},
-			cell,
-			cost: args.costLedger.summary({
-				phase: args.costPhase,
-				tags: costTags
-			})
-		};
-		retry = args.cellRetry !== void 0 && args.attempt < args.cellRetry.attempts && !args.signal.aborted && fatalCellError === void 0 && args.cellRetry.retryable(receipt.failure);
-		const failurePath = join(attemptDir, "failure-receipt.json");
-		storage.write(failurePath, JSON.stringify(receipt, null, 2));
-		artifactsByPath[`${args.slot.cellId}/${attemptPrefix}/failure-receipt.json`] = failurePath;
-		if (!retry) args.onFailure?.(failure);
-	}
+	const retry = failure ? recordCellFailure(args, run, failure, cell, costTags, fatalCellError) : false;
 	await trace.flush();
 	const resultPath = join(attemptDir, "result.json");
 	storage.write(resultPath, JSON.stringify(cell));
@@ -1890,261 +1955,269 @@ function excerptAt(source, at, needleLength) {
 	return (start > 0 ? "…" : "") + source.slice(start, end) + (end < source.length ? "…" : "");
 }
 //#endregion
-//#region src/campaign/gates/default-production-gate.ts
-/**
-* Opinionated production gate composing held-out significance, red-team, reward-hacking, and canary checks into a single `Gate.decide` decision.
-*/
-function defaultProductionGate(options) {
-	const deltaThreshold = options.deltaThreshold ?? 0;
-	const confidence = options.confidence ?? .95;
-	const resamples = options.bootstrapResamples ?? 2e3;
-	const seed = options.bootstrapSeed ?? 1337;
-	const minProductiveRuns = options.minProductiveRuns ?? 3;
-	const heldoutStatistic = options.heldoutStatistic ?? "mean";
-	const explicitlyRequired = new Set(options.requiredChecks ?? []);
-	const scenarioIds = new Set(options.holdoutScenarios.map((scenario) => scenario.id));
-	const independentUnitByScenarioId = options.independentUnitByScenarioId === void 0 ? void 0 : new Map(options.independentUnitByScenarioId);
-	if (independentUnitByScenarioId !== void 0) for (const id of scenarioIds) {
-		const unit = independentUnitByScenarioId.get(id);
-		if (typeof unit !== "string" || unit.length === 0 || unit.trim() !== unit) throw new Error(`defaultProductionGate: missing independent unit for holdout scenario '${id}'`);
-	}
+//#region src/campaign/gates/default-production-checks.ts
+function newFindings() {
+	const reasons = [];
+	const contributing = [];
+	const requiredUnavailable = /* @__PURE__ */ new Set();
+	const unavailable = (name, required, reason, detail = {}) => {
+		contributing.push({
+			name,
+			status: "not_evaluated",
+			detail: {
+				reason,
+				required,
+				...detail
+			}
+		});
+		if (required) {
+			requiredUnavailable.add(name);
+			reasons.push(`${name}: ${reason}`);
+		}
+	};
 	return {
-		name: "defaultProductionGate",
-		async decide(ctx) {
-			const reasons = [];
-			const contributing = [];
-			const requiredUnavailable = /* @__PURE__ */ new Set();
-			const unavailable = (name, required, reason, detail = {}) => {
-				contributing.push({
-					name,
-					status: "not_evaluated",
-					detail: {
-						reason,
-						required,
-						...detail
-					}
-				});
-				if (required) {
-					requiredUnavailable.add(name);
-					reasons.push(`${name}: ${reason}`);
-				}
-			};
-			let delta;
-			if (!ctx.baselineJudgeScores) unavailable("heldout-significance", true, "baselineJudgeScores is required for a held-out comparison");
-			else {
-				const sig = heldoutSignificance(pairHoldout(ctx.judgeScores, ctx.baselineJudgeScores, scenarioIds, (s) => s.composite), {
-					deltaThreshold,
-					minProductiveRuns,
-					confidence,
-					resamples,
-					seed,
-					statistic: heldoutStatistic,
-					independentUnitByScenarioId
-				});
-				const dec = sig.decision;
-				delta = dec.delta;
-				const heldoutPass = sig.significant;
-				contributing.push({
-					name: "heldout-significance",
-					status: sig.fewRuns ? "not_evaluated" : heldoutPass ? "pass" : "fail",
-					detail: {
-						n: sig.n,
-						pairedCellN: sig.pairedCellN,
-						observationUnit: sig.observationUnit,
-						unitIds: sig.unitIds,
-						delta,
-						decisionStatistic: sig.decisionStatistic,
-						decisionMethod: sig.decisionMethod,
-						binaryScale: dec.binaryScale,
-						mcnemar: dec.mcnemar,
-						indeterminate: dec.indeterminate,
-						deltaMean: sig.bootstrap.mean,
-						deltaMedianDiagnostic: sig.medianBootstrap.median,
-						deltaMedian: sig.medianBootstrap.median,
-						tieFraction: sig.tieFraction,
-						ciLow: dec.low,
-						ciHigh: dec.high,
-						bootstrapCiLow: sig.bootstrap.low,
-						bootstrapCiHigh: sig.bootstrap.high,
-						confidence: dec.confidence,
-						deltaThreshold,
-						fewRuns: sig.fewRuns
-					}
-				});
-				if (sig.fewRuns) requiredUnavailable.add("heldout-significance");
-				if (!heldoutPass) {
-					const tieNote = sig.tieFraction >= .4 ? `; ${(sig.tieFraction * 100).toFixed(0)}% tied observation units` : "";
-					const ci = `${(dec.confidence * 100).toFixed(0)}% CI [${dec.low.toFixed(3)}, ${dec.high.toFixed(3)}]`;
-					reasons.push(sig.fewRuns ? `held-out: only ${sig.n} paired observation units (< ${sig.minimumRequired}) — too few to claim significance` : dec.indeterminate ? `held-out: ${dec.indeterminateCause}, so the paired CI is ${ci} and carries no direction — it cannot clear threshold ${deltaThreshold} on evidence${tieNote}` : dec.exactTestVetoes ? `held-out: McNemar exact p=${dec.mcnemar?.pValue.toExponential(2)} does not reject at α=${(1 - dec.confidence).toFixed(4)} (${dec.label} Δ ${delta.toFixed(3)}, ${ci}${tieNote})` : dec.method === "exact-sign" ? `held-out: exact one-sided sign test p=${dec.pValue} does not reject at α=${((1 - dec.confidence) / 2).toFixed(4)} (${dec.label} Δ ${delta.toFixed(3)}, diagnostic ${ci}${tieNote})` : `held-out CI.low ${dec.low.toFixed(3)} ≤ threshold ${deltaThreshold} (${dec.label} Δ ${delta.toFixed(3)}, ${ci}${tieNote})`);
-				}
+		reasons,
+		contributing,
+		requiredUnavailable,
+		unavailable
+	};
+}
+/** Held-out significance of the candidate over the baseline, paired by cell before any averaging. */
+function checkHeldout(g, cfg, ctx) {
+	const { reasons, contributing, requiredUnavailable, unavailable } = g;
+	const { deltaThreshold, confidence, resamples, seed, minProductiveRuns, heldoutStatistic, scenarioIds, independentUnitByScenarioId } = cfg;
+	let delta;
+	if (!ctx.baselineJudgeScores) unavailable("heldout-significance", true, "baselineJudgeScores is required for a held-out comparison");
+	else {
+		const sig = heldoutSignificance(pairHoldout(ctx.judgeScores, ctx.baselineJudgeScores, scenarioIds, (s) => s.composite), {
+			deltaThreshold,
+			minProductiveRuns,
+			confidence,
+			resamples,
+			seed,
+			statistic: heldoutStatistic,
+			independentUnitByScenarioId
+		});
+		const dec = sig.decision;
+		delta = dec.delta;
+		const heldoutPass = sig.significant;
+		contributing.push({
+			name: "heldout-significance",
+			status: sig.fewRuns ? "not_evaluated" : heldoutPass ? "pass" : "fail",
+			detail: {
+				n: sig.n,
+				pairedCellN: sig.pairedCellN,
+				observationUnit: sig.observationUnit,
+				unitIds: sig.unitIds,
+				delta,
+				decisionStatistic: sig.decisionStatistic,
+				decisionMethod: sig.decisionMethod,
+				binaryScale: dec.binaryScale,
+				mcnemar: dec.mcnemar,
+				indeterminate: dec.indeterminate,
+				deltaMean: sig.bootstrap.mean,
+				deltaMedianDiagnostic: sig.medianBootstrap.median,
+				deltaMedian: sig.medianBootstrap.median,
+				tieFraction: sig.tieFraction,
+				ciLow: dec.low,
+				ciHigh: dec.high,
+				bootstrapCiLow: sig.bootstrap.low,
+				bootstrapCiHigh: sig.bootstrap.high,
+				confidence: dec.confidence,
+				deltaThreshold,
+				fewRuns: sig.fewRuns
 			}
-			const dimensionsProvided = options.criticalDimensions !== void 0;
-			const criticalDimensions = [...new Set(options.criticalDimensions ?? [])];
-			const dimensionsRequired = dimensionsProvided || explicitlyRequired.has("dimension-regression");
-			if (!dimensionsProvided) unavailable("dimension-regression", dimensionsRequired, "criticalDimensions is not configured");
-			else if (criticalDimensions.length === 0) unavailable("dimension-regression", true, "criticalDimensions must contain at least one dimension");
-			else if (!ctx.baselineJudgeScores) unavailable("dimension-regression", true, "baselineJudgeScores is required to measure dimension regressions", { guarded: criticalDimensions });
-			else {
-				const dimRegs = dimensionRegressions(ctx.judgeScores, ctx.baselineJudgeScores, scenarioIds, criticalDimensions, {
-					tolerance: options.regressionTolerance,
-					confidence,
-					resamples,
-					seed,
-					independentUnitByScenarioId,
-					minProductiveRuns
-				});
-				const measured = new Set(dimRegs.map((result) => result.dimension));
-				const missingDimensions = criticalDimensions.filter((dimension) => !measured.has(dimension));
-				const regressed = dimRegs.filter((result) => result.regressed);
-				const incompleteDimensions = dimRegs.filter((result) => result.fewRuns || result.missingCellIds.length > 0 || result.missingScenarioIds.length > 0);
-				const dimensionStatus = regressed.length > 0 ? "fail" : missingDimensions.length > 0 || incompleteDimensions.length > 0 ? "not_evaluated" : "pass";
-				contributing.push({
-					name: "dimension-regression",
-					status: dimensionStatus,
-					detail: {
-						guarded: criticalDimensions,
-						missingDimensions,
-						incompleteDimensions: incompleteDimensions.map((result) => result.dimension),
-						regressions: dimRegs.map((result) => ({
-							dimension: result.dimension,
-							ciLow: result.ci.low,
-							ciHigh: result.ci.high,
-							decisionStatistic: result.decisionStatistic,
-							indeterminate: result.indeterminate,
-							bootstrapCiLow: result.bootstrap.low,
-							median: result.bootstrap.median,
-							tolerance: result.tolerance,
-							n: result.n,
-							pairedCellN: result.pairedCellN,
-							observationUnit: result.observationUnit,
-							minimumRequired: result.minimumRequired,
-							fewRuns: result.fewRuns,
-							missingCellIds: result.missingCellIds,
-							missingScenarioIds: result.missingScenarioIds,
-							regressed: result.regressed
-						}))
-					}
-				});
-				if (missingDimensions.length > 0) {
-					requiredUnavailable.add("dimension-regression");
-					reasons.push(`critical dimension(s) were not scored: ${missingDimensions.join(", ")}`);
-				}
-				if (incompleteDimensions.length > 0) {
-					requiredUnavailable.add("dimension-regression");
-					reasons.push(`critical dimension evidence is incomplete: ${incompleteDimensions.map((result) => `${result.dimension} has ${result.n} paired observation units (minimum ${result.minimumRequired}), ${result.missingCellIds.length} unscored cells, ${result.missingScenarioIds.length} unscored scenarios`).join("; ")}`);
-				}
-				if (regressed.length > 0) reasons.push(`critical dimension(s) regressed: ${regressed.map((result) => result.bootstrap.low < -result.tolerance ? `${result.dimension} bootstrap CI.low ${result.bootstrap.low.toFixed(3)} < -${result.tolerance}` : `${result.dimension} paired test supports a drop greater than ${result.tolerance}`).join("; ")}`);
+		});
+		if (sig.fewRuns) requiredUnavailable.add("heldout-significance");
+		if (!heldoutPass) {
+			const tieNote = sig.tieFraction >= .4 ? `; ${(sig.tieFraction * 100).toFixed(0)}% tied observation units` : "";
+			const ci = `${(dec.confidence * 100).toFixed(0)}% CI [${dec.low.toFixed(3)}, ${dec.high.toFixed(3)}]`;
+			reasons.push(sig.fewRuns ? `held-out: only ${sig.n} paired observation units (< ${sig.minimumRequired}) — too few to claim significance` : dec.indeterminate ? `held-out: ${dec.indeterminateCause}, so the paired CI is ${ci} and carries no direction — it cannot clear threshold ${deltaThreshold} on evidence${tieNote}` : dec.exactTestVetoes ? `held-out: McNemar exact p=${dec.mcnemar?.pValue.toExponential(2)} does not reject at α=${(1 - dec.confidence).toFixed(4)} (${dec.label} Δ ${delta.toFixed(3)}, ${ci}${tieNote})` : dec.method === "exact-sign" ? `held-out: exact one-sided sign test p=${dec.pValue} does not reject at α=${((1 - dec.confidence) / 2).toFixed(4)} (${dec.label} Δ ${delta.toFixed(3)}, diagnostic ${ci}${tieNote})` : `held-out CI.low ${dec.low.toFixed(3)} ≤ threshold ${deltaThreshold} (${dec.label} Δ ${delta.toFixed(3)}, ${ci}${tieNote})`);
+		}
+	}
+	return delta;
+}
+/** Anti-Goodhart guard: a net composite gain must not hide a regression on a critical dimension. */
+function checkDimensions(g, cfg, ctx) {
+	const { reasons, contributing, requiredUnavailable, unavailable } = g;
+	const { options, confidence, resamples, seed, minProductiveRuns, explicitlyRequired, scenarioIds, independentUnitByScenarioId } = cfg;
+	const dimensionsProvided = options.criticalDimensions !== void 0;
+	const criticalDimensions = [...new Set(options.criticalDimensions ?? [])];
+	const dimensionsRequired = dimensionsProvided || explicitlyRequired.has("dimension-regression");
+	if (!dimensionsProvided) unavailable("dimension-regression", dimensionsRequired, "criticalDimensions is not configured");
+	else if (criticalDimensions.length === 0) unavailable("dimension-regression", true, "criticalDimensions must contain at least one dimension");
+	else if (!ctx.baselineJudgeScores) unavailable("dimension-regression", true, "baselineJudgeScores is required to measure dimension regressions", { guarded: criticalDimensions });
+	else {
+		const dimRegs = dimensionRegressions(ctx.judgeScores, ctx.baselineJudgeScores, scenarioIds, criticalDimensions, {
+			tolerance: options.regressionTolerance,
+			confidence,
+			resamples,
+			seed,
+			independentUnitByScenarioId,
+			minProductiveRuns
+		});
+		const measured = new Set(dimRegs.map((result) => result.dimension));
+		const missingDimensions = criticalDimensions.filter((dimension) => !measured.has(dimension));
+		const regressed = dimRegs.filter((result) => result.regressed);
+		const incompleteDimensions = dimRegs.filter((result) => result.fewRuns || result.missingCellIds.length > 0 || result.missingScenarioIds.length > 0);
+		const dimensionStatus = regressed.length > 0 ? "fail" : missingDimensions.length > 0 || incompleteDimensions.length > 0 ? "not_evaluated" : "pass";
+		contributing.push({
+			name: "dimension-regression",
+			status: dimensionStatus,
+			detail: {
+				guarded: criticalDimensions,
+				missingDimensions,
+				incompleteDimensions: incompleteDimensions.map((result) => result.dimension),
+				regressions: dimRegs.map((result) => ({
+					dimension: result.dimension,
+					ciLow: result.ci.low,
+					ciHigh: result.ci.high,
+					decisionStatistic: result.decisionStatistic,
+					indeterminate: result.indeterminate,
+					bootstrapCiLow: result.bootstrap.low,
+					median: result.bootstrap.median,
+					tolerance: result.tolerance,
+					n: result.n,
+					pairedCellN: result.pairedCellN,
+					observationUnit: result.observationUnit,
+					minimumRequired: result.minimumRequired,
+					fewRuns: result.fewRuns,
+					missingCellIds: result.missingCellIds,
+					missingScenarioIds: result.missingScenarioIds,
+					regressed: result.regressed
+				}))
 			}
-			const budgetUsd = options.budgetUsd;
-			const budgetConfigured = budgetUsd !== void 0;
-			const budgetRequired = budgetConfigured || explicitlyRequired.has("budget");
-			if (!budgetConfigured) unavailable("budget", budgetRequired, "budgetUsd is not configured");
-			else if (!ctx.costLedger) unavailable("budget", true, "costLedger is required to measure complete run spend", { budgetUsd });
-			else {
-				const cost = ctx.costLedger.summary();
-				const accountingComplete = cost.accountingComplete && cost.pendingCalls === 0 && cost.unresolvedCalls === 0;
-				const budgetPass = cost.totalCostUsd <= budgetUsd;
-				contributing.push({
-					name: "budget",
-					status: !accountingComplete ? "not_evaluated" : budgetPass ? "pass" : "fail",
-					detail: {
-						totalCostUsd: cost.totalCostUsd,
-						budgetUsd,
-						accountingComplete,
-						pendingCalls: cost.pendingCalls,
-						unresolvedCalls: cost.unresolvedCalls
-					}
-				});
-				if (!accountingComplete) {
-					requiredUnavailable.add("budget");
-					reasons.push("budget: cost accounting is incomplete");
-				} else if (!budgetPass) reasons.push(`spend ${cost.totalCostUsd.toFixed(2)} > budget ${budgetUsd}`);
+		});
+		if (missingDimensions.length > 0) {
+			requiredUnavailable.add("dimension-regression");
+			reasons.push(`critical dimension(s) were not scored: ${missingDimensions.join(", ")}`);
+		}
+		if (incompleteDimensions.length > 0) {
+			requiredUnavailable.add("dimension-regression");
+			reasons.push(`critical dimension evidence is incomplete: ${incompleteDimensions.map((result) => `${result.dimension} has ${result.n} paired observation units (minimum ${result.minimumRequired}), ${result.missingCellIds.length} unscored cells, ${result.missingScenarioIds.length} unscored scenarios`).join("; ")}`);
+		}
+		if (regressed.length > 0) reasons.push(`critical dimension(s) regressed: ${regressed.map((result) => result.bootstrap.low < -result.tolerance ? `${result.dimension} bootstrap CI.low ${result.bootstrap.low.toFixed(3)} < -${result.tolerance}` : `${result.dimension} paired test supports a drop greater than ${result.tolerance}`).join("; ")}`);
+	}
+}
+/** Total spend of the improvement run against `budgetUsd`, from complete cost accounting only. */
+function checkBudget(g, cfg, ctx) {
+	const { reasons, contributing, requiredUnavailable, unavailable } = g;
+	const { options, explicitlyRequired } = cfg;
+	const budgetUsd = options.budgetUsd;
+	const budgetConfigured = budgetUsd !== void 0;
+	const budgetRequired = budgetConfigured || explicitlyRequired.has("budget");
+	if (!budgetConfigured) unavailable("budget", budgetRequired, "budgetUsd is not configured");
+	else if (!ctx.costLedger) unavailable("budget", true, "costLedger is required to measure complete run spend", { budgetUsd });
+	else {
+		const cost = ctx.costLedger.summary();
+		const accountingComplete = cost.accountingComplete && cost.pendingCalls === 0 && cost.unresolvedCalls === 0;
+		const budgetPass = cost.totalCostUsd <= budgetUsd;
+		contributing.push({
+			name: "budget",
+			status: !accountingComplete ? "not_evaluated" : budgetPass ? "pass" : "fail",
+			detail: {
+				totalCostUsd: cost.totalCostUsd,
+				budgetUsd,
+				accountingComplete,
+				pendingCalls: cost.pendingCalls,
+				unresolvedCalls: cost.unresolvedCalls
 			}
-			const redTeamRequired = options.redTeamBattery !== void 0 || explicitlyRequired.has("red-team");
-			if (!options.redTeamBattery) unavailable("red-team", redTeamRequired, "redTeamBattery is not configured");
-			else if (options.redTeamBattery.length === 0) unavailable("red-team", true, "redTeamBattery must contain at least one case");
-			else {
-				const redTeam = probeRedTeam(ctx.candidateArtifacts, options.redTeamBattery);
-				const incomplete = redTeam.unsupportedCases.length > 0 || redTeam.unscoredArtifacts.length > 0 || redTeam.evaluatedCases === 0;
-				const redTeamStatus = redTeam.findings.length > 0 ? "fail" : incomplete ? "not_evaluated" : "pass";
-				contributing.push({
-					name: "red-team",
-					status: redTeamStatus,
-					detail: {
-						evaluatedCases: redTeam.evaluatedCases,
-						unsupportedCases: redTeam.unsupportedCases,
-						unscoredArtifacts: redTeam.unscoredArtifacts,
-						failures: redTeam.findings.length,
-						sample: redTeam.findings.slice(0, 3)
-					}
-				});
-				if (incomplete) requiredUnavailable.add("red-team");
-				if (redTeam.unsupportedCases.length > 0) reasons.push(`red-team: static artifact screening cannot evaluate case(s): ${redTeam.unsupportedCases.join(", ")}`);
-				if (redTeam.unscoredArtifacts.length > 0) reasons.push(`red-team: no text could be extracted from artifact(s): ${redTeam.unscoredArtifacts.join(", ")}`);
-				if (redTeam.evaluatedCases === 0) reasons.push("red-team: no artifact/case pair was evaluated");
-				if (redTeam.findings.length > 0) reasons.push(`red-team probe failed (${redTeam.findings.length} findings)`);
+		});
+		if (!accountingComplete) {
+			requiredUnavailable.add("budget");
+			reasons.push("budget: cost accounting is incomplete");
+		} else if (!budgetPass) reasons.push(`spend ${cost.totalCostUsd.toFixed(2)} > budget ${budgetUsd}`);
+	}
+}
+/** Static red-team screening of the candidate artifacts. */
+function checkRedTeam(g, cfg, ctx) {
+	const { reasons, contributing, requiredUnavailable, unavailable } = g;
+	const { options, explicitlyRequired } = cfg;
+	const redTeamRequired = options.redTeamBattery !== void 0 || explicitlyRequired.has("red-team");
+	if (!options.redTeamBattery) unavailable("red-team", redTeamRequired, "redTeamBattery is not configured");
+	else if (options.redTeamBattery.length === 0) unavailable("red-team", true, "redTeamBattery must contain at least one case");
+	else {
+		const redTeam = probeRedTeam(ctx.candidateArtifacts, options.redTeamBattery);
+		const incomplete = redTeam.unsupportedCases.length > 0 || redTeam.unscoredArtifacts.length > 0 || redTeam.evaluatedCases === 0;
+		const redTeamStatus = redTeam.findings.length > 0 ? "fail" : incomplete ? "not_evaluated" : "pass";
+		contributing.push({
+			name: "red-team",
+			status: redTeamStatus,
+			detail: {
+				evaluatedCases: redTeam.evaluatedCases,
+				unsupportedCases: redTeam.unsupportedCases,
+				unscoredArtifacts: redTeam.unscoredArtifacts,
+				failures: redTeam.findings.length,
+				sample: redTeam.findings.slice(0, 3)
 			}
-			const rewardHacking = options.rewardHacking;
-			const rewardHackingConfigured = rewardHacking !== void 0;
-			const rewardHackingRequired = rewardHackingConfigured || explicitlyRequired.has("reward-hacking");
-			if (!rewardHackingConfigured) unavailable("reward-hacking", rewardHackingRequired, "rewardHacking is not configured");
-			else if (!options.recentRuns) unavailable("reward-hacking", rewardHackingRequired, "recentRuns is not configured");
-			else if (options.recentRuns.length < 10) unavailable("reward-hacking", rewardHackingRequired, `recentRuns has ${options.recentRuns.length} record(s); at least 10 are required`);
-			else {
-				const rewardHackingReport = detectRewardHacking({
-					runs: options.recentRuns,
-					...rewardHacking
-				});
-				if (!rewardHackingReport.evaluatedSignals.includes("reward_divergence")) unavailable("reward-hacking", true, "independent proxy/truth evidence is insufficient to evaluate reward divergence", { report: rewardHackingReport });
-				else {
-					const gamingThreshold = rewardHacking.thresholds?.gaming ?? .6;
-					const gamingFindings = rewardHackingReport.findings.filter((finding) => finding.severity >= gamingThreshold);
-					const rewardHackingPass = gamingFindings.length === 0 && rewardHackingReport.verdict !== "gaming";
-					contributing.push({
-						name: "reward-hacking",
-						status: rewardHackingPass ? "pass" : "fail",
-						detail: {
-							report: rewardHackingReport,
-							gamingFindingCount: gamingFindings.length
-						}
-					});
-					if (!rewardHackingPass) reasons.push(`reward-hacking detector flagged ${gamingFindings.length} gaming-severity findings (verdict=${rewardHackingReport.verdict})`);
+		});
+		if (incomplete) requiredUnavailable.add("red-team");
+		if (redTeam.unsupportedCases.length > 0) reasons.push(`red-team: static artifact screening cannot evaluate case(s): ${redTeam.unsupportedCases.join(", ")}`);
+		if (redTeam.unscoredArtifacts.length > 0) reasons.push(`red-team: no text could be extracted from artifact(s): ${redTeam.unscoredArtifacts.join(", ")}`);
+		if (redTeam.evaluatedCases === 0) reasons.push("red-team: no artifact/case pair was evaluated");
+		if (redTeam.findings.length > 0) reasons.push(`red-team probe failed (${redTeam.findings.length} findings)`);
+	}
+}
+/** Reward-hacking detector over the run-history window. */
+function checkRewardHacking(g, cfg) {
+	const { reasons, contributing, unavailable } = g;
+	const { options, explicitlyRequired } = cfg;
+	const rewardHacking = options.rewardHacking;
+	const rewardHackingConfigured = rewardHacking !== void 0;
+	const rewardHackingRequired = rewardHackingConfigured || explicitlyRequired.has("reward-hacking");
+	if (!rewardHackingConfigured) unavailable("reward-hacking", rewardHackingRequired, "rewardHacking is not configured");
+	else if (!options.recentRuns) unavailable("reward-hacking", rewardHackingRequired, "recentRuns is not configured");
+	else if (options.recentRuns.length < 10) unavailable("reward-hacking", rewardHackingRequired, `recentRuns has ${options.recentRuns.length} record(s); at least 10 are required`);
+	else {
+		const rewardHackingReport = detectRewardHacking({
+			runs: options.recentRuns,
+			...rewardHacking
+		});
+		if (!rewardHackingReport.evaluatedSignals.includes("reward_divergence")) unavailable("reward-hacking", true, "independent proxy/truth evidence is insufficient to evaluate reward divergence", { report: rewardHackingReport });
+		else {
+			const gamingThreshold = rewardHacking.thresholds?.gaming ?? .6;
+			const gamingFindings = rewardHackingReport.findings.filter((finding) => finding.severity >= gamingThreshold);
+			const rewardHackingPass = gamingFindings.length === 0 && rewardHackingReport.verdict !== "gaming";
+			contributing.push({
+				name: "reward-hacking",
+				status: rewardHackingPass ? "pass" : "fail",
+				detail: {
+					report: rewardHackingReport,
+					gamingFindingCount: gamingFindings.length
 				}
-			}
-			const canary = options.canary;
-			const canaryConfigured = canary !== void 0;
-			const canaryRequired = canaryConfigured || explicitlyRequired.has("canary");
-			if (!canaryConfigured && !canaryRequired) unavailable("canary", false, "canary is not configured");
-			else if (!options.recentRuns) unavailable("canary", canaryRequired, "recentRuns is not configured");
-			else {
-				const canaryReport = runCanaries(options.recentRuns, canary ?? {});
-				const incomplete = canaryReport.evaluations.filter((evaluation) => evaluation.status === "not_evaluated");
-				if (incomplete.length > 0) unavailable("canary", true, `insufficient evidence for: ${incomplete.map((evaluation) => evaluation.kind).join(", ")}`, { report: canaryReport });
-				else {
-					const errorAlerts = canaryReport.alerts.filter((alert) => alert.severity === "error");
-					const canaryPass = errorAlerts.length === 0;
-					contributing.push({
-						name: "canary",
-						status: canaryPass ? "pass" : "fail",
-						detail: {
-							totalAlerts: canaryReport.alerts.length,
-							errorAlerts: errorAlerts.length,
-							report: canaryReport
-						}
-					});
-					if (!canaryPass) reasons.push(`canary error alerts: ${errorAlerts.length}`);
+			});
+			if (!rewardHackingPass) reasons.push(`reward-hacking detector flagged ${gamingFindings.length} gaming-severity findings (verdict=${rewardHackingReport.verdict})`);
+		}
+	}
+}
+/** Canary checks over the run history. */
+function checkCanary(g, cfg) {
+	const { reasons, contributing, unavailable } = g;
+	const { options, explicitlyRequired } = cfg;
+	const canary = options.canary;
+	const canaryConfigured = canary !== void 0;
+	const canaryRequired = canaryConfigured || explicitlyRequired.has("canary");
+	if (!canaryConfigured && !canaryRequired) unavailable("canary", false, "canary is not configured");
+	else if (!options.recentRuns) unavailable("canary", canaryRequired, "recentRuns is not configured");
+	else {
+		const canaryReport = runCanaries(options.recentRuns, canary ?? {});
+		const incomplete = canaryReport.evaluations.filter((evaluation) => evaluation.status === "not_evaluated");
+		if (incomplete.length > 0) unavailable("canary", true, `insufficient evidence for: ${incomplete.map((evaluation) => evaluation.kind).join(", ")}`, { report: canaryReport });
+		else {
+			const errorAlerts = canaryReport.alerts.filter((alert) => alert.severity === "error");
+			const canaryPass = errorAlerts.length === 0;
+			contributing.push({
+				name: "canary",
+				status: canaryPass ? "pass" : "fail",
+				detail: {
+					totalAlerts: canaryReport.alerts.length,
+					errorAlerts: errorAlerts.length,
+					report: canaryReport
 				}
-			}
-			const decision = contributing.some((check) => check.status === "fail") || requiredUnavailable.size > 0 ? "hold" : "ship";
-			const notEvaluated = contributing.filter((check) => check.status === "not_evaluated").map((check) => check.name);
-			return {
-				decision,
-				reasons: reasons.length > 0 ? reasons : notEvaluated.length > 0 ? [`evaluated checks passed; not evaluated: ${notEvaluated.join(", ")}`] : ["all checks passed"],
-				contributingGates: contributing,
-				delta
-			};
+			});
+			if (!canaryPass) reasons.push(`canary error alerts: ${errorAlerts.length}`);
 		}
-	};
+	}
 }
 function probeRedTeam(artifacts, battery) {
 	const supportedCases = battery.filter((testCase) => testCase.payload.expected === "ignore" && !testCase.payload.forbiddenTools?.length);
@@ -2185,6 +2258,62 @@ function extractText(artifact) {
 	}
 }
 //#endregion
+//#region src/campaign/gates/default-production-gate.ts
+/**
+* Opinionated production gate composing held-out significance, red-team, reward-hacking, and canary checks into a single `Gate.decide` decision.
+*/
+function defaultProductionGate(options) {
+	const deltaThreshold = options.deltaThreshold ?? 0;
+	const confidence = options.confidence ?? .95;
+	const resamples = options.bootstrapResamples ?? 2e3;
+	const seed = options.bootstrapSeed ?? 1337;
+	const minProductiveRuns = options.minProductiveRuns ?? 3;
+	const heldoutStatistic = options.heldoutStatistic ?? "mean";
+	const explicitlyRequired = new Set(options.requiredChecks ?? []);
+	const scenarioIds = new Set(options.holdoutScenarios.map((scenario) => scenario.id));
+	const independentUnitByScenarioId = options.independentUnitByScenarioId === void 0 ? void 0 : new Map(options.independentUnitByScenarioId);
+	if (independentUnitByScenarioId !== void 0) for (const id of scenarioIds) {
+		const unit = independentUnitByScenarioId.get(id);
+		if (typeof unit !== "string" || unit.length === 0 || unit.trim() !== unit) throw new Error(`defaultProductionGate: missing independent unit for holdout scenario '${id}'`);
+	}
+	const cfg = {
+		options,
+		deltaThreshold,
+		confidence,
+		resamples,
+		seed,
+		minProductiveRuns,
+		heldoutStatistic,
+		explicitlyRequired,
+		scenarioIds,
+		independentUnitByScenarioId
+	};
+	return {
+		name: "defaultProductionGate",
+		async decide(ctx) {
+			const findings = newFindings();
+			const delta = checkHeldout(findings, cfg, ctx);
+			checkDimensions(findings, cfg, ctx);
+			checkBudget(findings, cfg, ctx);
+			checkRedTeam(findings, cfg, ctx);
+			checkRewardHacking(findings, cfg);
+			checkCanary(findings, cfg);
+			return verdictOf(findings, delta);
+		}
+	};
+}
+/** Hold when any check failed or a required check could not be evaluated; otherwise ship. */
+function verdictOf({ reasons, contributing, requiredUnavailable }, delta) {
+	const decision = contributing.some((check) => check.status === "fail") || requiredUnavailable.size > 0 ? "hold" : "ship";
+	const notEvaluated = contributing.filter((check) => check.status === "not_evaluated").map((check) => check.name);
+	return {
+		decision,
+		reasons: reasons.length > 0 ? reasons : notEvaluated.length > 0 ? [`evaluated checks passed; not evaluated: ${notEvaluated.join(", ")}`] : ["all checks passed"],
+		contributingGates: contributing,
+		delta
+	};
+}
+//#endregion
 //#region src/campaign/judge-snapshot.ts
 /** Capture configuration and callbacks; receiver and closed-over state remain caller-owned. */
 function captureJudge(judge) {
@@ -4423,13 +4552,9 @@ function toScoredSurfaceOutcome(hash, campaign, coverage, generation) {
 * again on the same run directory and options continues an interrupted run
 * instead of starting over, and reruns nothing that settled.
 */
-/** Compose the optimization proposer and cell executor on the shared search kernel. */
 /** Improve a surface as a search on the kernel; see the module comment. */
 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");
-	for (const [name, value] of [["populationSize", opts.populationSize], ["maxGenerations", opts.maxGenerations]]) if (!Number.isSafeInteger(value) || value < 0) throw new Error(`runOptimization: ${name} must be a non-negative integer`);
+	const candidateConcurrency = assertOptimizationOptions(opts);
 	const initialFindings = immutableProposalSnapshot(assertProposalFindings(opts.findings ?? [], "runOptimization initial proposal findings"), "initial findings");
 	const baselineSurface = immutableProposalSnapshot(opts.baselineSurface, "baseline surface");
 	const runDir = resolveRunDir(opts.runDir, opts.repo);
@@ -4468,7 +4593,53 @@ async function runOptimization(opts) {
 	const recorder = await SearchRecorder.open({
 		ledger: binding.ledger,
 		storage
-	}, {
+	}, searchOpening({
+		opts,
+		identity,
+		execution,
+		baselineSurface,
+		splitDigest,
+		policy,
+		allocationName: allocation.name,
+		seed
+	}));
+	const run = {
+		opts,
+		runDir,
+		costLedger,
+		reps,
+		requireJudgeScore,
+		premeasured,
+		identity,
+		policy,
+		recorder,
+		nodes: new SurfaceNodes(opts, recorder, runDir, costLedger, execution, premeasured),
+		findings: initialFindings
+	};
+	return optimizationResult(run, baselineSurface, await runSearch({
+		recorder,
+		root: baselineSurface,
+		codec: surfaceCodec,
+		policy,
+		allocation,
+		proposer: optimizationProposerPort(run),
+		executor: optimizationExecutor(run, candidateConcurrency),
+		maxExpansions: opts.maxGenerations,
+		signal: opts.signal
+	}));
+}
+/** Reject malformed run settings before any state is touched; returns the candidate concurrency. */
+function assertOptimizationOptions(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");
+	for (const [name, value] of [["populationSize", opts.populationSize], ["maxGenerations", opts.maxGenerations]]) if (!Number.isSafeInteger(value) || value < 0) throw new Error(`runOptimization: ${name} must be a non-negative integer`);
+	return candidateConcurrency;
+}
+/** The search ledger's opening record: subject, objective, train split, policy and budget. */
+function searchOpening(args) {
+	const { opts, identity, baselineSurface, splitDigest, policy } = args;
+	return {
 		subject: identity.subject ?? opts.proposer.kind,
 		process: {
 			name: "runOptimization",
@@ -4496,8 +4667,8 @@ async function runOptimization(opts) {
 		},
 		policy: {
 			expansion: policy.name,
-			allocation: allocation.name,
-			seed
+			allocation: args.allocationName,
+			seed: args.seed
 		},
 		budget: {
 			maxUsd: opts.costCeiling ?? null,
@@ -4509,12 +4680,14 @@ async function runOptimization(opts) {
 		},
 		containment: null,
 		derivedFrom: null,
-		identity: execution
-	});
-	const nodes = new SurfaceNodes(opts, recorder, runDir, costLedger, execution, premeasured);
+		identity: args.execution
+	};
+}
+/** One lane that measures each candidate cell through the surface nodes. */
+function optimizationExecutor(run, candidateConcurrency) {
+	const { opts, nodes } = run;
 	const scenarioById = new Map(opts.scenarios.map((scenario) => [scenario.id, scenario]));
-	let findings = initialFindings;
-	const executor = {
+	return {
 		lanes: () => [{
 			name: "campaign",
 			capacity: candidateConcurrency * (opts.maxConcurrency ?? 2),
@@ -4525,83 +4698,29 @@ async function runOptimization(opts) {
 		run: (work) => nodes.runCell(work, scenarioById),
 		adopt: (work) => nodes.adoptCell(work)
 	};
+}
+/** The proposer port: each proposal analyses the last generation, then asks the caller's proposer. */
+function optimizationProposerPort(run) {
+	const { opts, identity, recorder, nodes, policy } = run;
 	const proposer = opts.proposer;
 	const proposerSource = identity.proposer.source;
-	const port = {
+	return {
 		name: proposer.kind,
 		kind: "optimizer",
 		source: proposerSource,
 		execution: identity.proposer,
 		childrenPerProposal: opts.populationSize,
 		async propose(request) {
-			const phases = [
-				"search.proposal",
-				"analysis.baseline",
-				"analysis.generation"
-			];
-			const before = new Set(phases.flatMap((phase) => costLedger.list({ phase })).map((receipt) => receipt.callId));
-			const accounting = () => {
-				const fresh = phases.flatMap((phase) => costLedger.list({ phase })).filter((receipt) => !before.has(receipt.callId));
-				return {
-					accounting: searchReceiptAccounting(fresh),
-					execution: opts.searchLedger ? identity.proposer : searchProposalExecution(fresh, identity.model.provider, proposerSource)
-				};
-			};
+			const accounting = proposalAccounting(run);
 			const earlier = await recorder.state();
 			const root = earlier.rootNodeId;
 			const rootCampaign = nodes.campaign(earlier, root);
-			const rootCoverage = campaignCoverage(rootCampaign.cells, opts.scenarios, reps, requireJudgeScore);
-			if (!rootCoverage.complete) throw new Error(`runOptimization: ${premeasured ? "premeasured baseline" : "baseline"} is incomplete (${rootCoverage.scorableCellIds.length}/${rootCoverage.expectedCellIds.length} designed cells scorable) — ${formatCoverageFailures(rootCoverage)}. Refusing to optimize against an incomplete incumbent.`);
+			assertBaselineComplete(run, rootCampaign);
 			const generation = nodes.generations(earlier).length;
-			if (opts.analyzeGeneration) {
-				const previous = generation - 1;
-				const candidates = (previous < 0 ? [root] : nodes.expansionNodes(earlier, nodes.generations(earlier)[previous])).map((nodeId) => {
-					const campaign = nodes.campaign(earlier, nodeId);
-					return {
-						surfaceHash: surfaceHash(nodes.surface(earlier, nodeId)),
-						campaign,
-						composite: campaignMeanCompositeOrNull(campaign)
-					};
-				});
-				const history = nodes.history(earlier, policy);
-				if (candidates.some(({ campaign }) => campaign.cells.length > 0)) {
-					const fresh = await opts.analyzeGeneration({
-						generation: previous,
-						runDir: previous < 0 ? rootCampaign.runDir : `${runDir}/candidates`,
-						candidates,
-						history,
-						costLedger,
-						costPhase: previous < 0 ? "analysis.baseline" : "analysis.generation"
-					});
-					if (!Array.isArray(fresh)) throw new TypeError("runOptimization: analyzeGeneration must return an array");
-					findings = immutableProposalSnapshot(assertProposalFindings(fresh, "runOptimization analysis findings"), "analysis findings");
-				}
-			}
+			if (opts.analyzeGeneration) await analyzePreviousGeneration(run, earlier, generation, root, rootCampaign.runDir);
 			const state = await recorder.state();
 			const proposalHistory = immutableProposalSnapshot(nodes.history(state, policy), "history");
-			const parent = request.parents[0];
-			const context = Object.freeze({
-				currentSurface: immutableProposalSnapshot(parent.artifact, "current surface"),
-				operator: request.operator,
-				parents: immutableProposalSnapshot(request.parents.map(({ nodeId, artifact }) => ({
-					nodeId,
-					artifact: immutableProposalSnapshot(artifact, "parent surface")
-				})), "parents"),
-				train: searchProposerView(state),
-				summary: renderSearchSummary(state, { split: "train" }),
-				history: proposalHistory,
-				findings: immutableProposalSnapshot(assertProposalFindings(findings, "runOptimization proposal findings"), "findings"),
-				populationSize: opts.populationSize,
-				generation,
-				signal: request.signal,
-				baselineOutcome: immutableProposalSnapshot(nodes.outcome(state, root), "baseline"),
-				incumbentOutcome: immutableProposalSnapshot(nodes.outcome(state, request.leader), "incumbent outcome"),
-				parentOutcome: immutableProposalSnapshot(nodes.outcome(state, parent.nodeId), "parent outcome"),
-				maxImprovementShots: opts.maxImprovementShots,
-				paretoParents: immutableProposalSnapshot(nodes.frontier(state), "Pareto parents"),
-				costLedger,
-				costPhase: "search.proposal"
-			});
+			const context = proposeContext(run, request, state, generation, root, proposalHistory);
 			if (proposer.decide?.({ history: proposalHistory }).stop) return {
 				children: [],
 				stop: "the proposer decided to stop",
@@ -4624,17 +4743,86 @@ async function runOptimization(opts) {
 			};
 		}
 	};
-	const result = await runSearch({
-		recorder,
-		root: baselineSurface,
-		codec: surfaceCodec,
-		policy,
-		allocation,
-		proposer: port,
-		executor,
-		maxExpansions: opts.maxGenerations,
-		signal: opts.signal
+}
+/** Snapshot the proposal-phase receipts now; the returned reader totals only receipts added since. */
+function proposalAccounting(run) {
+	const { opts, identity, costLedger } = run;
+	const phases = [
+		"search.proposal",
+		"analysis.baseline",
+		"analysis.generation"
+	];
+	const before = new Set(phases.flatMap((phase) => costLedger.list({ phase })).map((receipt) => receipt.callId));
+	return () => {
+		const fresh = phases.flatMap((phase) => costLedger.list({ phase })).filter((receipt) => !before.has(receipt.callId));
+		return {
+			accounting: searchReceiptAccounting(fresh),
+			execution: opts.searchLedger ? identity.proposer : searchProposalExecution(fresh, identity.model.provider, identity.proposer.source)
+		};
+	};
+}
+/** Refuse to optimize against a baseline whose designed cells are not all scorable. */
+function assertBaselineComplete(run, rootCampaign) {
+	const { opts, reps, requireJudgeScore, premeasured } = run;
+	const rootCoverage = campaignCoverage(rootCampaign.cells, opts.scenarios, reps, requireJudgeScore);
+	if (!rootCoverage.complete) throw new Error(`runOptimization: ${premeasured ? "premeasured baseline" : "baseline"} is incomplete (${rootCoverage.scorableCellIds.length}/${rootCoverage.expectedCellIds.length} designed cells scorable) — ${formatCoverageFailures(rootCoverage)}. Refusing to optimize against an incomplete incumbent.`);
+}
+/** Run the caller's analysis over the previous generation (or the baseline) and keep its findings. */
+async function analyzePreviousGeneration(run, earlier, generation, root, rootRunDir) {
+	const { opts, nodes, policy, costLedger, runDir } = run;
+	const previous = generation - 1;
+	const candidates = (previous < 0 ? [root] : nodes.expansionNodes(earlier, nodes.generations(earlier)[previous])).map((nodeId) => {
+		const campaign = nodes.campaign(earlier, nodeId);
+		return {
+			surfaceHash: surfaceHash(nodes.surface(earlier, nodeId)),
+			campaign,
+			composite: campaignMeanCompositeOrNull(campaign)
+		};
 	});
+	const history = nodes.history(earlier, policy);
+	if (candidates.some(({ campaign }) => campaign.cells.length > 0)) {
+		const fresh = await opts.analyzeGeneration({
+			generation: previous,
+			runDir: previous < 0 ? rootRunDir : `${runDir}/candidates`,
+			candidates,
+			history,
+			costLedger,
+			costPhase: previous < 0 ? "analysis.baseline" : "analysis.generation"
+		});
+		if (!Array.isArray(fresh)) throw new TypeError("runOptimization: analyzeGeneration must return an array");
+		run.findings = immutableProposalSnapshot(assertProposalFindings(fresh, "runOptimization analysis findings"), "analysis findings");
+	}
+}
+/** The frozen view of the search the caller's proposer reads. */
+function proposeContext(run, request, state, generation, root, proposalHistory) {
+	const { opts, nodes, costLedger } = run;
+	const parent = request.parents[0];
+	return Object.freeze({
+		currentSurface: immutableProposalSnapshot(parent.artifact, "current surface"),
+		operator: request.operator,
+		parents: immutableProposalSnapshot(request.parents.map(({ nodeId, artifact }) => ({
+			nodeId,
+			artifact: immutableProposalSnapshot(artifact, "parent surface")
+		})), "parents"),
+		train: searchProposerView(state),
+		summary: renderSearchSummary(state, { split: "train" }),
+		history: proposalHistory,
+		findings: immutableProposalSnapshot(assertProposalFindings(run.findings, "runOptimization proposal findings"), "findings"),
+		populationSize: opts.populationSize,
+		generation,
+		signal: request.signal,
+		baselineOutcome: immutableProposalSnapshot(nodes.outcome(state, root), "baseline"),
+		incumbentOutcome: immutableProposalSnapshot(nodes.outcome(state, request.leader), "incumbent outcome"),
+		parentOutcome: immutableProposalSnapshot(nodes.outcome(state, parent.nodeId), "parent outcome"),
+		maxImprovementShots: opts.maxImprovementShots,
+		paretoParents: immutableProposalSnapshot(nodes.frontier(state), "Pareto parents"),
+		costLedger,
+		costPhase: "search.proposal"
+	});
+}
+/** Read the finished search into the leader, its provenance and every generation's measured surfaces. */
+function optimizationResult(run, baselineSurface, result) {
+	const { opts, nodes, policy, recorder, costLedger, runDir } = run;
 	const state = result.state;
 	const winnerSurface = nodes.surface(state, result.leader);
 	const firstEdge = state.edge(state.node(result.leader).edgeIds[0]);
@@ -4660,7 +4848,7 @@ async function runOptimization(opts) {
 		baselineCampaign: nodes.campaign(state, state.rootNodeId),
 		cost: costLedger.summary(),
 		searchHistory: recorder.receipt({
-			producerId: proposer.kind,
+			producerId: opts.proposer.kind,
 			runId: runDir
 		}),
 		paretoFrontier: nodes.frontier(state)
@@ -5744,4 +5932,4 @@ function firstString(value) {
 //#endregion
 export { planCampaignRun as $, verifySearchHistoryReceipt as A, defaultProductionGate as B, searchEdgeId as C, assertSearchHistoryMatchesState as D, assertSearchHistoryAdmissionOptions as E, asha as F, runCanaries as G, redTeamDataset as H, uniform as I, evaluationUnitMap as J, assertIndependentEvaluationSplit as K, runFinalComparison as L, searchModelIdentity as M, searchProposalExecution as N, createSearchHistoryReceipt as O, searchReceiptAccounting as P, runCampaign as Q, openAutoPr as R, developmentClaim as S, surfaceNode as T, redTeamReport as U, DEFAULT_RED_TEAM_CORPUS as V, scoreRedTeamOutput as W, reserveFinalEvidence as X, exposeFinalEvidence as Y, runEval as Z, beam as _, aggregateRunScore as a, incumbentWithOperatorBandit as b, assertGepaCandidatePopulationSummary as c, costFromLedgerSummary as d, resolveRunDir as et, optimizationTokenUsageFromSummary as f, aide as g, isProposedCandidate as h, transientDispatchFailure as i, campaignCellSearchResult as j, verifySearchHistoryArtifact as k, readGepaCandidatePopulationArtifact as l, runOptimization as m, JudgeParseError as n, cellCachePath as nt, clamp01 as o, runImprovementLoop as p, captureFinalEvidencePolicy as q, isTransientTransportFailure as r, computeManifestHash as rt, executeOptimizationMethod as s, llmJudge as t, buildCellSchedule as tt, combineComparisonCosts as u, crowdedFrontierParent as v, surfaceDiff as w, SearchRecorder as x, incumbent as y, captureJudge as z };
 
-//# sourceMappingURL=llm-judge-C8jMTNNG.js.map
+//# sourceMappingURL=llm-judge-Djxh-Uhs.js.map