@tangle-network/agent-eval 0.144.5 → 0.144.7

package/dist/promotion-policy-CrLrmys8.js

@@ -0,0 +1,682 @@
+import { E as pairedBootstrap, M as pairedRiskDifferenceScore, N as pairedSignTest, O as pairedDeltaTieFraction, T as pairedBinaryScale, j as pairedRiskDifferenceExact } from "./statistics-ByxzSiOM.js";
+//#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.
+*
+* ## A zero-width interval is never significant
+*
+* When every paired delta is identical the resample distribution is a point
+* mass and the interval collapses: `[0, 0]` when all pairs tie, `[g, g]` on n
+* identical deltas of g. Neither says the effect is certain — both say the
+* sample carries no information about how far the estimate could be wrong, and
+* `low > threshold` then answers on the point estimate alone. It fails in both
+* directions: `[0, 0]` clears every NEGATIVE threshold, which is how a
+* tie-dominated pass/fail comparison laundered a regression into a
+* noninferiority pass, and `[g, g]` clears every threshold below g with no
+* spread behind it. Under a bounded asymmetric null whose true mean paired
+* delta is exactly 0 — 2 % of pairs dropping by 1.0, the rest gaining 0.0204 —
+* every sample that misses the drop is exactly that shape, and deciding on
+* `low > 0` promoted 65.65 % of samples at n = 20 against a nominal 5 %.
+*
+* So `indeterminate` is reported and `significant` is false whenever the
+* interval has zero width, on BOTH paths: at small n the exact sign test is a
+* test of the MEDIAN and a zero-spread sample is precisely where it stops
+* saying anything about the mean the caller is thresholding.
+*
+* `threshold` may be negative — that is a noninferiority margin, and it is the
+* regime the zero-width hole is worst in. For a two-point (pass/fail) outcome
+* the percentile bootstrap is not a valid interval at a nonzero margin at all;
+* use {@link decidePairedPromotion}, which routes those to Tango's score
+* interval, rather than thresholding this function's bootstrap directly.
+*/
+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;
+	const indeterminate = bootstrap.n > 0 && (!Number.isFinite(bootstrap.low) || !Number.isFinite(bootstrap.high) || bootstrap.low === bootstrap.high);
+	if (bootstrap.gateEligible) return {
+		bootstrap,
+		method: "bootstrap-ci",
+		pValue: null,
+		minimumPairs,
+		sufficient,
+		indeterminate,
+		significant: sufficient && !indeterminate && 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,
+		indeterminate,
+		significant: sufficient && !indeterminate && estimate > threshold && exact.pValue <= (1 - bootstrap.confidence) / 2
+	};
+}
+//#endregion
+//#region src/paired-promotion-decision.ts
+/**
+* @module
+* ONE rule for "does this paired interval clear a promotion threshold".
+*
+* The rule below was derived on `HeldOutGate` (#479) after the same estimator
+* bug shipped twice. It then turned out that a SECOND gate — the composable
+* `heldOutGate`, plus everything else routed through `heldoutSignificance` —
+* still carried the original defect, because the rule had been written into one
+* gate's method body rather than into a shared function. Two copies of a
+* statistical rule is how a defect survives in one of them, so there is now
+* exactly one copy and both gates call it.
+*
+* Three things the rule does that a bare `pairedBootstrap(...).low > threshold`
+* does not:
+*
+* 1. **Two-point (pass/fail) outcomes decide on Tango's SCORE interval.** On a
+*    pass/fail eval the paired delta vector is dominated by ties, so the
+*    bootstrap of the mean is a resample of a lattice with three atoms and its
+*    percentile interval is not valid at a nonzero margin. The score interval
+*    (`pairedRiskDifferenceScore`) re-estimates the nuisance loss rate under
+*    each hypothesised margin instead of fixing it at the observed value, which
+*    is the only construction that stays a confidence interval as the margin
+*    moves off zero — the regime every noninferiority threshold lives in.
+*    Measured on the composable gate before this change, at a true risk
+*    difference sitting exactly on the production caller's -0.05 margin and a
+*    nominal 5 %: 14.60 % false promotion at n = 40 and 10.10 % at n = 76.
+* 2. **McNemar's exact test holds a VETO at every non-negative threshold.**
+*    Redundant with the interval by construction and kept anyway, so that
+*    swapping the estimator for one without that duality cannot silently
+*    reintroduce "promotes what the exact test refuses". Witness: n = 6, b = 5,
+*    c = 0 — no exact argument reaches alpha = 0.05 with 5 discordant pairs
+*    (two-sided floor 2/2^5 = 0.0625), whatever an interval says. A NEGATIVE
+*    threshold is a noninferiority question, which McNemar's test of "no
+*    difference" is not the right test for, so the veto does not apply there.
+* 3. **A ZERO-WIDTH interval is refused, wherever it sits.** At [0, 0] it
+*    cannot tell a gain from a regression and clears every negative threshold.
+*    Away from zero it fails the opposite way: n identical positive deltas give
+*    [g, g], which clears threshold 0 on no spread at all. Both are an absence
+*    of evidence. Measured on the composable gate before this change, under a
+*    bounded asymmetric null whose true mean paired delta is exactly 0: 88.50 %
+*    false promotion at n = 6 and 65.65 % at n = 20 against a nominal 5 %.
+*
+* Orthogonal to the small-sample switch inside {@link pairedDeltaTest}: that
+* picks the TEST from the sample size (bootstrap CI at n >= 20, pre-registered
+* exact sign test below it), this picks the ESTIMATOR from the outcome's shape.
+* Both are needed — an exact sign test applied to a tie-pinned median is still
+* blind, and a mean bootstrap CI at n = 6 is still not a valid test.
+*/
+/**
+* Which estimator {@link decidePairedPromotion} would use on this data, and the
+* shape facts behind it — for callers that must report the shape on a path
+* where no interval is computed at all (an early rejection, or zero pairs).
+* Cheap: no bootstrap, no interval.
+*/
+function pairedDecisionShape(before, after, statistic = "mean") {
+	const tieFraction = before.length === 0 ? null : pairedDeltaTieFraction(before, after);
+	if (statistic === "median") return {
+		statistic: "median_bootstrap",
+		binaryScale: null,
+		tieFraction
+	};
+	const binaryScale = pairedBinaryScale(before, after);
+	if (binaryScale !== null) return {
+		statistic: "paired_risk_difference",
+		binaryScale,
+		tieFraction
+	};
+	return {
+		statistic: "mean_bootstrap",
+		binaryScale: null,
+		tieFraction
+	};
+}
+/**
+* Decide whether a paired candidate-minus-baseline delta clears a promotion
+* threshold. `before` is the baseline arm, `after` the candidate arm, paired by
+* position. Throws on unequal lengths.
+*/
+function decidePairedPromotion(before, after, options = {}) {
+	if (before.length !== after.length) throw new Error(`decidePairedPromotion: unequal sample sizes (${before.length} vs ${after.length})`);
+	const threshold = options.threshold ?? 0;
+	if (!Number.isFinite(threshold)) throw new Error(`decidePairedPromotion: threshold must be finite, got ${threshold}`);
+	const confidence = options.confidence ?? .95;
+	const exactMinimum = minimumPairsForPairedDeltaTest(confidence);
+	const requestedMinimum = options.minPairs ?? exactMinimum;
+	if (!Number.isInteger(requestedMinimum) || requestedMinimum < 1) throw new Error(`decidePairedPromotion: minPairs must be a positive integer, got ${requestedMinimum}`);
+	const minimumPairs = Math.max(requestedMinimum, exactMinimum);
+	const n = before.length;
+	const sufficient = n >= minimumPairs;
+	const { binaryScale, tieFraction } = pairedDecisionShape(before, after, options.statistic);
+	let core;
+	if (binaryScale !== null) {
+		const unitControl = before.map((v) => v / binaryScale);
+		const unitTreatment = after.map((v) => v / binaryScale);
+		const exact = pairedRiskDifferenceExact(unitControl, unitTreatment, confidence);
+		const score = pairedRiskDifferenceScore(unitControl, unitTreatment, confidence);
+		const low = score.lower * binaryScale;
+		core = {
+			statistic: "paired_risk_difference",
+			method: "score-interval",
+			delta: score.riskDifference * binaryScale,
+			low,
+			high: score.upper * binaryScale,
+			bootstrap: null,
+			mcnemar: {
+				b: exact.b,
+				c: exact.c,
+				nDiscordant: exact.nDiscordant,
+				pValue: exact.pValue
+			},
+			pValue: null,
+			clearsThreshold: low > threshold,
+			label: "success-rate",
+			methodDetail: ""
+		};
+	} else {
+		const bootstrapStatistic = options.statistic === "median" ? "median" : "mean";
+		const test = pairedDeltaTest(before, after, {
+			confidence,
+			resamples: options.resamples,
+			statistic: bootstrapStatistic,
+			seed: options.seed,
+			threshold,
+			minPairs: options.minPairs
+		});
+		const ci = test.bootstrap;
+		core = {
+			statistic: bootstrapStatistic === "mean" ? "mean_bootstrap" : "median_bootstrap",
+			method: test.method,
+			delta: bootstrapStatistic === "mean" ? ci.mean : ci.median,
+			low: ci.low,
+			high: ci.high,
+			bootstrap: ci,
+			mcnemar: null,
+			pValue: test.pValue,
+			clearsThreshold: test.significant,
+			label: bootstrapStatistic,
+			methodDetail: test.method === "exact-sign" ? ` Below ${test.minimumPairs} pairs the interval is descriptive only; the decision is the exact one-sided sign test, p=${fmt(test.pValue ?? 1)}.` : ""
+		};
+	}
+	const indeterminate = !Number.isFinite(core.low) || !Number.isFinite(core.high) || core.low === core.high;
+	const indeterminateCause = !indeterminate ? "" : tieFraction === 1 ? "every paired delta is an exact tie" : core.mcnemar !== null && core.mcnemar.nDiscordant === 0 ? "every pair is concordant (0 discordant pairs)" : `the ${core.label} CI collapsed to a point at ${fmt(core.low)}`;
+	const exactTestVetoes = core.mcnemar !== null && threshold >= 0 && !(core.mcnemar.pValue < 1 - confidence);
+	return {
+		n,
+		threshold,
+		confidence,
+		binaryScale,
+		tieFraction,
+		minimumPairs,
+		sufficient,
+		indeterminate,
+		indeterminateCause,
+		exactTestVetoes,
+		promote: sufficient && !indeterminate && core.clearsThreshold && !exactTestVetoes,
+		...core
+	};
+}
+function fmt(x) {
+	return x.toFixed(4);
+}
+//#endregion
+//#region src/campaign/gates/statistical-heldout.ts
+/**
+* Statistical held-out promotion machinery — the trustworthy core the
+* point-estimate `heldout-delta` gate lacked.
+*
+* The shipped false positive it prevents: a winner re-scored against the
+* baseline on the holdout read run-to-run model NOISE (e.g. 91 vs 95) as a
+* "+4 lift" and shipped, because the gate compared point estimates with no
+* confidence interval. Here we pair candidate vs baseline holdout observations
+* and bootstrap a CI on the paired delta — a candidate ships only when the CI
+* lower bound clears the effect-size threshold (the gain is real at the
+* confidence level, not noise), and is blocked when a critical dimension
+* (e.g. `hallucination_free` for a legal agent) significantly regresses even if
+* the net composite rose (anti-Goodhart).
+*
+* Two traps this module is built around (both produce a NEW false positive if
+* gotten wrong):
+*   1. PAIRING GRANULARITY — pairs by FULL `cellId` (`scenario:rep`), never by
+*      `scenarioId` (which averages reps away and destroys the within-pair
+*      variance reduction that makes a paired bootstrap tighter than unpaired).
+*      One paired observation per cell ⇒ reps multiply n.
+*   2. SCALE — a judge may emit composites/dimensions on [0,1] or 0-100. The
+*      threshold + tolerance are interpreted in the judge's NATIVE scale; the
+*      per-dimension tolerance auto-scales off the observed baseline magnitudes
+*      so `-0.10` on [0,1] doesn't silently become a no-op on a 0-100 dimension.
+*/
+/** Tie fraction at/above which a gate annotates its verdict with the tie share.
+*  Tie-domination of the median bites structurally at >= 0.5 (the median is then
+*  0 by construction); 0.4 is a softer warn threshold that flags a run APPROACHING
+*  that regime, so an operator sees it before the median goes fully blind. */
+const TIE_WARN_FRACTION = .4;
+/**
+* Pair candidate vs baseline holdout observations by FULL cellId. `select`
+* pulls the scalar from a cell's judge reports (composite, or a named
+* dimension); a cell contributes the mean of `select` across its judges. Cells
+* whose scenario is not in `scenarioIds`, or where `select` is undefined for
+* every judge on either side, are skipped on BOTH sides so the arrays stay
+* paired. Throws when the two maps disagree on which holdout cells exist — a
+* load-bearing invariant: the baseline + winner holdout campaigns run the same
+* scenarios with the same seed base, so their cellIds MUST align; a mismatch
+* means a silent pairing bug, not a soft fallback.
+*/
+function pairHoldout(candidate, baseline, scenarioIds, select) {
+	const cellValue = (byCell, cellId) => {
+		const scores = byCell.get(cellId);
+		if (!scores) return void 0;
+		const vals = [];
+		for (const s of Object.values(scores)) {
+			if (s.failed === true) throw new Error(`pairHoldout: cell '${cellId}' contains a failed judge score`);
+			const v = select(s);
+			if (typeof v === "number" && !Number.isFinite(v)) throw new Error(`pairHoldout: cell '${cellId}' contains a non-finite selected score`);
+			if (typeof v === "number") vals.push(v);
+		}
+		if (vals.length === 0) return void 0;
+		return vals.reduce((a, b) => a + b, 0) / vals.length;
+	};
+	const inScope = (cellId) => scenarioIds.has(cellId.split(":")[0] ?? "");
+	const candCells = [...candidate.keys()].filter(inScope).sort();
+	const baseCells = [...baseline.keys()].filter(inScope).sort();
+	if (candCells.length !== baseCells.length || candCells.some((c, i) => c !== baseCells[i])) throw new Error(`pairHoldout: candidate/baseline holdout cells do not align — candidate=[${candCells.join(",")}] baseline=[${baseCells.join(",")}]. Both holdout campaigns must run the same scenarios with the same seed base.`);
+	const before = [];
+	const after = [];
+	const cellIds = [];
+	for (const cellId of candCells) {
+		const b = cellValue(baseline, cellId);
+		const a = cellValue(candidate, cellId);
+		if (b === void 0 && a === void 0) continue;
+		if (b === void 0 || a === void 0) throw new Error(`pairHoldout: cell '${cellId}' has a selected score on only one arm`);
+		before.push(b);
+		after.push(a);
+		cellIds.push(cellId);
+	}
+	return {
+		before,
+		after,
+		cellIds
+	};
+}
+/**
+* Significance of the held-out composite lift: ship only when the lower bound
+* of the interval the outcome's shape ADMITS exceeds `deltaThreshold` (default
+* 0 ⇒ "confidently positive"). Interpret `deltaThreshold` in the judge's native
+* scale.
+*
+* The decision is delegated whole to {@link decidePairedPromotion}, the one
+* copy of the rule (`src/paired-promotion-decision.ts`), which `HeldOutGate`
+* also calls. That module's header carries the measurements; the short version
+* is three guards a bare `bootstrap.low > threshold` does not have:
+*
+*   - a two-point (pass/fail) outcome decides on Tango's SCORE interval, the
+*     only paired-binary construction that stays valid at a nonzero margin;
+*   - McNemar's exact test VETOES at any non-negative threshold;
+*   - a ZERO-WIDTH interval is refused rather than promoted, in either
+*     direction — [0,0] clears every negative threshold and [g,g] clears every
+*     threshold below g, and both are an absence of evidence, not a result.
+*
+* Measured on this function before those guards landed, at a nominal 5 %:
+* 14.60 % false promotion at n = 40 on a paired-binary noninferiority boundary,
+* and 88.50 % at n = 6 under a bounded asymmetric null whose true mean paired
+* delta is exactly 0.
+*
+* At small n, where the percentile bootstrap is descriptive only, a
+* pre-registered exact sign test still carries the bootstrap path.
+*/
+function heldoutSignificance(paired, opts = {}) {
+	const deltaThreshold = opts.deltaThreshold ?? 0;
+	const confidence = opts.confidence ?? .95;
+	const resamples = opts.resamples ?? 2e3;
+	const seed = opts.seed ?? 1337;
+	const statistic = opts.statistic ?? "mean";
+	const decision = decidePairedPromotion(paired.before, paired.after, {
+		confidence,
+		resamples,
+		statistic,
+		seed,
+		threshold: deltaThreshold,
+		minPairs: opts.minProductiveRuns
+	});
+	const bootstrap = decision.bootstrap ?? pairedBootstrap(paired.before, paired.after, {
+		confidence,
+		resamples,
+		statistic,
+		seed
+	});
+	const medianBootstrap = statistic === "median" ? bootstrap : pairedBootstrap(paired.before, paired.after, {
+		confidence,
+		resamples,
+		statistic: "median",
+		seed
+	});
+	const n = paired.before.length;
+	let ties = 0;
+	for (let i = 0; i < n; i += 1) {
+		const after = paired.after[i] ?? 0;
+		const before = paired.before[i] ?? 0;
+		if (Math.abs(after - before) < 1e-9) ties += 1;
+	}
+	const tieFraction = n === 0 ? 0 : ties / n;
+	return {
+		paired,
+		bootstrap,
+		medianBootstrap,
+		decision,
+		decisionStatistic: decision.statistic,
+		mcnemar: decision.mcnemar,
+		tieFraction,
+		n,
+		minimumRequired: decision.minimumPairs,
+		decisionMethod: decision.method,
+		pValue: decision.pValue,
+		significant: decision.promote,
+		fewRuns: !decision.sufficient
+	};
+}
+/** Detect the native scale of a set of scores: 0-100 when any magnitude clears
+*  1.5, else [0,1]. Used to auto-scale the regression tolerance so a default
+*  expressed for [0,1] is not silently a no-op on a 0-100 dimension. */
+function detectScale(values) {
+	return values.some((v) => Math.abs(v) > 1.5) ? 100 : 1;
+}
+/** Per-critical-dimension regression guard. For each dimension, pair the
+*  candidate vs baseline values by full cellId and bootstrap the paired delta;
+*  a dimension is "regressed" when the CI lower bound < −tolerance (conservative
+*  — blocks if the credible worst case exceeds tolerance, which is the right
+*  posture for safety dimensions like `hallucination_free`). When `tolerance`
+*  is omitted it auto-scales: 0.05 on [0,1], 5 on 0-100.
+*
+*  The interval comes from {@link decidePairedPromotion}, so a pass/fail
+*  dimension is judged on Tango's score interval rather than a percentile
+*  bootstrap of the mean — `tolerance` is a NONZERO margin, and the bootstrap
+*  is not a valid interval at one. That matters most here because this guard
+*  fails OPEN by construction: `tolerance` is positive, so an interval pinned at
+*  [0,0] never satisfies `low < −tolerance` and a real regression on a safety
+*  dimension would be reported as `regressed: false`. On the median it fails the
+*  same way for the same reason — when most pairs tie, which is automatic for a
+*  pass/fail dimension on {0,1} and on the 0-100 encoding `detectScale` exists
+*  to support, the median CI collapses to [0,0]. Pass `statistic: 'median'` to
+*  restore the pre-0.134 behaviour. */
+function dimensionRegressions(candidate, baseline, scenarioIds, criticalDimensions, opts = {}) {
+	const out = [];
+	for (const dim of criticalDimensions) {
+		const paired = pairHoldout(candidate, baseline, scenarioIds, (s) => s.dimensions[dim]);
+		if (paired.before.length === 0) continue;
+		const tolerance = opts.tolerance ?? .05 * detectScale([...paired.before, ...paired.after]);
+		const bootstrapStatistic = opts.statistic ?? "mean";
+		const shared = {
+			confidence: opts.confidence ?? .95,
+			resamples: opts.resamples ?? 2e3,
+			statistic: bootstrapStatistic,
+			seed: opts.seed ?? 1337
+		};
+		const guard = decidePairedPromotion(paired.before, paired.after, shared);
+		const regression = decidePairedPromotion(paired.after, paired.before, {
+			...shared,
+			threshold: tolerance
+		});
+		const bootstrap = guard.bootstrap ?? pairedBootstrap(paired.before, paired.after, shared);
+		out.push({
+			dimension: dim,
+			bootstrap,
+			bootstrapStatistic,
+			ci: {
+				low: guard.low,
+				high: guard.high
+			},
+			decisionStatistic: guard.statistic,
+			mcnemar: guard.mcnemar,
+			indeterminate: guard.indeterminate,
+			regressed: bootstrap.low < -tolerance || regression.promote,
+			tolerance,
+			n: paired.before.length
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/campaign/gates/power-preflight.ts
+/** Two-sided z for the common confidence levels; interpolation is overkill here. */
+function zFor(confidence) {
+	if (confidence >= .99) return 2.576;
+	if (confidence >= .95) return 1.96;
+	if (confidence >= .9) return 1.645;
+	return 1.282;
+}
+/** Estimate the minimum detectable lift a paired-holdout improvement run can
+*  ship at a given budget, from the baseline holdout composites — call it BEFORE
+*  spending a search to learn whether the effect you are hunting is even
+*  observable at this holdout size and worker variance. */
+function powerPreflight(opts) {
+	const composites = opts.baselineComposites.filter((v) => Number.isFinite(v));
+	if (composites.length < 3) throw new Error(`powerPreflight: need >= 3 finite baseline composites to estimate variance, got ${composites.length}`);
+	const deltaThreshold = opts.deltaThreshold ?? .05;
+	const confidence = opts.confidence ?? .95;
+	const n = opts.pairedN ?? composites.length;
+	if (n < 2) throw new Error(`powerPreflight: pairedN must be >= 2, got ${n}`);
+	const mean = composites.reduce((a, b) => a + b, 0) / composites.length;
+	const variance = composites.reduce((a, b) => a + (b - mean) * (b - mean), 0) / (composites.length - 1);
+	const sd = Math.sqrt(variance);
+	const z = zFor(confidence);
+	const mde = deltaThreshold + z * Math.SQRT2 * sd / Math.sqrt(n);
+	const scaleAssumed = composites.every((v) => v >= -.001 && v <= 1.5);
+	const headroom = Math.max(0, 1 - mean);
+	const underpowered = scaleAssumed && mde > headroom;
+	const sharedChannelCaveat = opts.sharedScorerChannel ? "Holdout and gate share one scoring channel: raising n/reps reduces only idiosyncratic noise — systematic judge bias remains and this MDE is a lower bound. Full debiasing needs an independent second scoring channel (different judge/benchmark family)." : void 0;
+	const recommendation = underpowered ? `UNDERPOWERED: minimum detectable lift ${mde.toFixed(3)} exceeds the ${headroom.toFixed(3)} headroom above the baseline (${mean.toFixed(3)}) — no achievable effect can ship at this budget. Raise paired n (scenarios x reps) to ~${Math.ceil((z * Math.SQRT2 * sd / Math.max(headroom - deltaThreshold, .01)) ** 2)} or reduce worker variance before searching.` : `Minimum detectable lift at n=${n}: ${mde.toFixed(3)} (baseline sd ${sd.toFixed(3)}). Effects smaller than this cannot clear the gate; budget the search for effects you believe exceed it.`;
+	return {
+		n,
+		sd,
+		mde,
+		baselineMean: mean,
+		headroom,
+		underpowered,
+		scaleAssumed,
+		deltaThreshold,
+		confidence,
+		...sharedChannelCaveat ? { sharedChannelCaveat } : {},
+		recommendation: sharedChannelCaveat ? `${recommendation} ${sharedChannelCaveat}` : recommendation
+	};
+}
+//#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
+* a single source of truth governs pairing granularity + scale handling.
+*/
+function buildEvidenceVector(ctx, objectives, opts = {}) {
+	if (objectives.length === 0) throw new Error("buildEvidenceVector: at least 1 objective required");
+	const confidence = opts.confidence ?? .95;
+	const resamples = opts.resamples ?? 2e3;
+	const seed = opts.seed ?? 1337;
+	const baseline = ctx.baselineJudgeScores ?? ctx.judgeScores;
+	const scenarioIds = new Set(ctx.scenarios.map((s) => s.id));
+	const axes = [];
+	for (const obj of objectives) {
+		let select;
+		if (obj.source.kind === "composite") select = (s) => s.composite;
+		else {
+			const dim = obj.source.dimension;
+			select = (s) => s.dimensions[dim];
+		}
+		const paired = pairHoldout(ctx.judgeScores, baseline, scenarioIds, select);
+		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 bootstrapStatistic = opts.statistic ?? "mean";
+		const improvement = decidePairedPromotion(before, after, {
+			confidence,
+			resamples,
+			statistic: bootstrapStatistic,
+			seed,
+			threshold: gainThreshold,
+			minPairs: opts.minProductiveRuns
+		});
+		const regression = decidePairedPromotion(after, before, {
+			confidence,
+			resamples,
+			statistic: bootstrapStatistic,
+			seed,
+			threshold: floorTolerance,
+			minPairs: opts.minProductiveRuns
+		});
+		const bootstrap = improvement.bootstrap ?? pairedBootstrap(before, after, {
+			confidence,
+			resamples,
+			statistic: bootstrapStatistic,
+			seed
+		});
+		const floorBreached = bootstrap.low < -floorTolerance || regression.promote;
+		const verdict = !improvement.sufficient ? "few_runs" : floorBreached ? "regressed" : improvement.promote ? "improved" : "flat";
+		axes.push({
+			name: obj.name,
+			source: obj.source,
+			direction: obj.direction,
+			bootstrap,
+			bootstrapStatistic,
+			ci: {
+				low: improvement.low,
+				high: improvement.high
+			},
+			decisionStatistic: improvement.statistic,
+			mcnemar: improvement.mcnemar,
+			indeterminate: improvement.indeterminate,
+			n,
+			minimumRequired: improvement.minimumPairs,
+			decisionMethod: improvement.method,
+			gainThreshold,
+			floorTolerance,
+			verdict
+		});
+	}
+	const ns = axes.map((a) => a.n).filter((n) => n > 0);
+	return {
+		axes,
+		minN: ns.length > 0 ? Math.min(...ns) : 0,
+		cost: {
+			candidate: ctx.cost.candidate,
+			baseline: ctx.cost.baseline
+		}
+	};
+}
+/**
+* The default strategy: symmetric multi-objective Pareto significance. Ship iff
+* the candidate weakly dominates the baseline at the confidence level — no axis
+* credibly worse AND ≥1 axis credibly better. Floor breach on any axis → hold
+* (anti-Goodhart, dominates everything). Insufficient evidence on any axis →
+* need_more_work. Statistically equivalent → hold (never ship noise).
+*/
+const paretoPolicy = (ev) => {
+	const contributingGates = ev.axes.map((ax) => ({
+		name: `objective:${ax.name}`,
+		status: ax.verdict === "regressed" ? "fail" : ax.verdict === "few_runs" ? "not_evaluated" : "pass",
+		detail: {
+			direction: ax.direction,
+			source: ax.source,
+			verdict: ax.verdict,
+			n: ax.n,
+			deltaMedian: ax.bootstrap.median,
+			ciLow: ax.ci.low,
+			ciHigh: ax.ci.high,
+			decisionStatistic: ax.decisionStatistic,
+			decisionMethod: ax.decisionMethod,
+			mcnemar: ax.mcnemar,
+			indeterminate: ax.indeterminate,
+			bootstrapCiLow: ax.bootstrap.low,
+			bootstrapCiHigh: ax.bootstrap.high,
+			confidence: ax.bootstrap.confidence,
+			gainThreshold: ax.gainThreshold,
+			floorTolerance: ax.floorTolerance
+		}
+	}));
+	const regressed = ev.axes.filter((a) => a.verdict === "regressed");
+	const fewRuns = ev.axes.filter((a) => a.verdict === "few_runs");
+	const improved = ev.axes.filter((a) => a.verdict === "improved");
+	let decision;
+	const reasons = [];
+	if (regressed.length > 0) {
+		decision = "hold";
+		for (const a of regressed) reasons.push(`objective '${a.name}' regressed: good-direction CI.low ${a.ci.low.toFixed(3)} < -${a.floorTolerance} (n=${a.n})`);
+	} else if (fewRuns.length > 0) {
+		decision = "need_more_work";
+		for (const a of fewRuns) reasons.push(`objective '${a.name}' has only n=${a.n} paired runs — insufficient evidence to claim significance`);
+	} else if (improved.length > 0) {
+		decision = "ship";
+		reasons.push(`Pareto improvement at the confidence level: ${improved.map((a) => `'${a.name}' +${a.ci.low > 0 ? a.ci.low.toFixed(3) : a.bootstrap.mean.toFixed(3)} (CI.low ${a.ci.low.toFixed(3)})`).join(", ")}; no objective regressed`);
+	} else {
+		decision = "hold";
+		reasons.push("no Pareto improvement: candidate statistically equivalent to baseline on every objective");
+	}
+	const composite = ev.axes.find((a) => a.source.kind === "composite") ?? ev.axes[0];
+	return {
+		decision,
+		reasons,
+		contributingGates,
+		delta: composite?.bootstrap.median
+	};
+};
+/**
+* Wrap the bus + a policy as a `Gate`. Plugs into the existing
+* `runImprovementLoop({ gate })` slot and composes via `composeGate`; default
+* loop behavior is unchanged because consumers opt in by passing this gate.
+*/
+function paretoSignificanceGate(options) {
+	if (options.objectives.length === 0) throw new Error("paretoSignificanceGate: at least 1 objective required");
+	const policy = options.policy ?? paretoPolicy;
+	return {
+		name: options.name ?? "paretoSignificanceGate",
+		async decide(ctx) {
+			const ev = buildEvidenceVector(ctx, options.objectives, options);
+			return policy(ev);
+		}
+	};
+}
+//#endregion
+export { TIE_WARN_FRACTION as a, heldoutSignificance as c, pairedDecisionShape as d, minimumPairsForPairedDeltaTest as f, powerPreflight as i, pairHoldout as l, paretoPolicy as n, detectScale as o, pairedDeltaTest as p, paretoSignificanceGate as r, dimensionRegressions as s, buildEvidenceVector as t, decidePairedPromotion as u };
+
+//# sourceMappingURL=promotion-policy-CrLrmys8.js.map