@tangle-network/agent-eval 0.144.6 → 0.144.8

package/dist/{skillopt-optimization-method-Bfb-vBKe.js → skillopt-optimization-method-CkaI2ly4.js}

@@ -1,12 +1,14 @@
 import { c as ValidationError, i as JudgeError, t as AgentEvalError } from "./errors-D-LKuDhb.js";
 import { i as CostLedger, t as CostAccountingIncompleteError } from "./cost-ledger-DMFxsLKr.js";
-import { f as maximumChargeForLlmRequest, l as costReceiptFromLlm, m as stripFencedJson, u as costReceiptFromLlmError } from "./llm-client-Dv5BiKLE.js";
+import { f as maximumChargeForLlmRequest, l as costReceiptFromLlm, m as stripFencedJson, u as costReceiptFromLlmError } from "./llm-client-DzvMUsS_.js";
 import { a as clamp01, o as combineAbortSignals, t as assertProposalFindings } from "./proposal-findings-2GIUo1et.js";
-import { A as removeCredentialEnvironment, D as isCandidateText, E as assertNoCredentialValues, M as resolveExternalOptimizerProcessLimits, N as safePathComponent, O as isExternalTextCandidate, T as assertJsonValue, d as closeExternalOptimizerResources, f as runWithCleanup, j as resolveExternalOptimizerCallbackLimits, k as isRecord, l as startExternalOptimizerCallback, n as createRunCostLedger, p as startExternalOptimizerModelProxy, r as fsCampaignStorage, t as acquireSingleRunLock, u as runExternalOptimizerProcess, v as canonicalJson, w as assertExternalOptimizerModelBudget, y as contentHash } from "./single-run-lock-D5iN0Xzb.js";
+import { C as isExternalTextCandidate, D as resolveExternalOptimizerProcessLimits, E as resolveExternalOptimizerCallbackLimits, O as safePathComponent, S as isCandidateText, T as removeCredentialEnvironment, b as assertJsonValue, d as closeExternalOptimizerResources, f as runWithCleanup, l as startExternalOptimizerCallback, n as createRunCostLedger, p as startExternalOptimizerModelProxy, r as fsCampaignStorage, t as acquireSingleRunLock, u as runExternalOptimizerProcess, w as isRecord, x as assertNoCredentialValues, y as assertExternalOptimizerModelBudget } from "./single-run-lock-BMQEv1wG.js";
+import { n as canonicalJson, r as contentHash } from "./verdict-cache-BCcOh0kF.js";
 import { p as mapConcurrent } from "./ledger-core-DXZIqu17.js";
-import { E as pairedBootstrap, H as weightedComposite, M as pairedRiskDifferenceScore, N as pairedSignTest, O as pairedDeltaTieFraction, T as pairedBinaryScale, d as confidenceInterval, j as pairedRiskDifferenceExact } from "./statistics-ByxzSiOM.js";
+import { E as pairedBootstrap, H as weightedComposite, d as confidenceInterval } from "./statistics-ByxzSiOM.js";
+import { c as heldoutSignificance, l as pairHoldout, s as dimensionRegressions } from "./promotion-policy-CrLrmys8.js";
 import { t as DEFAULT_REDACTION_RULES } from "./redact-7Aq1ukl-.js";
-import { a as campaignCellCostProvenance, o as campaignCellExecutionEvidence, t as detectRewardHacking, u as projectCampaignCellQuality } from "./reward-hacking-CyuzxKly.js";
+import { a as campaignCellCostProvenance, o as campaignCellExecutionEvidence, t as detectRewardHacking, u as projectCampaignCellQuality } from "./reward-hacking-B2tPL9a3.js";
 import { z } from "zod";
 import { writeFileSync } from "node:fs";
 import { basename, isAbsolute, join } from "node:path";
@@ -153,243 +155,6 @@ function assertBackendReport(report, opts) {
 	return report;
 }
 //#endregion
-//#region src/paired-delta-test.ts
-/** Smallest all-positive sample that can clear a one-sided exact sign test. */
-function minimumPairsForPairedDeltaTest(confidence = .95) {
-	if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) throw new Error(`minimumPairsForPairedDeltaTest: confidence must be in (0,1), got ${confidence}`);
-	const oneSidedAlpha = (1 - confidence) / 2;
-	return Math.ceil(Math.log2(1 / oneSidedAlpha));
-}
-/**
-* Tests whether a paired candidate-minus-baseline delta clears a threshold.
-*
-* At 20 or more pairs, the percentile bootstrap lower bound carries the
-* decision. Below that point the interval is descriptive only, so the function
-* switches to a pre-registered one-sided exact sign test. The exact path is
-* deliberately conservative: it requires both a point estimate above the
-* threshold and enough consistently positive paired differences.
-*
-* ## 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/json-recovery.ts
 /**
 * Truncation-tolerant JSON recovery — shared by every parser that reads JSON
@@ -4364,190 +4129,6 @@ function mean(xs) {
 	if (xs.length === 0) return 0;
 	return xs.reduce((s, x) => s + x, 0) / xs.length;
 }
-/**
-* 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/default-production-gate.ts
 /**
@@ -4887,231 +4468,6 @@ function heldOutGate(options) {
 	};
 }
 //#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
 //#region src/campaign/external-optimizer-accounting.ts
 const TOKEN_USAGE_FIELDS = [
 	"inputTokens",
@@ -5851,6 +5207,7 @@ async function runOptimization(opts) {
 	const selectionRankKey = opts.selectionRankKey ?? ((campaign) => [campaignMeanComposite(campaign)]);
 	let winnerSurface = baselineSurface;
 	let winnerSurfaceHash = surfaceHash(baselineSurface);
+	const admittedCandidateHashes = /* @__PURE__ */ new Set([winnerSurfaceHash]);
 	let winnerComposite = campaignMeanComposite(baselineCampaign);
 	let winnerRankKey = selectionRankKey(baselineCampaign);
 	assertFiniteRankKey(winnerRankKey, "selectionRankKey for baseline");
@@ -5899,11 +5256,19 @@ async function runOptimization(opts) {
 		if (!Array.isArray(proposed)) throw new TypeError("runOptimization: proposer must return an array");
 		const proposalSnapshot = immutableProposalSnapshot(proposed, "candidate outputs");
 		if (proposalSnapshot.length === 0) break;
-		const surfaceResults = await mapConcurrent(proposalSnapshot.map((p) => isProposedCandidate(p) ? p : {
+		const candidates = proposalSnapshot.map((p) => isProposedCandidate(p) ? p : {
 			surface: p,
 			label: "",
 			rationale: ""
-		}), candidateConcurrency, async ({ surface, label, rationale }, i) => {
+		});
+		const generationHashes = /* @__PURE__ */ new Set();
+		for (const { surface } of candidates) {
+			const hash = surfaceHash(surface);
+			if (admittedCandidateHashes.has(hash) || generationHashes.has(hash)) throw new Error(`runOptimization: duplicate candidate surface hash "${hash}" in generation ${gen}; candidate surfaces must be unique`);
+			generationHashes.add(hash);
+		}
+		for (const hash of generationHashes) admittedCandidateHashes.add(hash);
+		const surfaceResults = await mapConcurrent(candidates, candidateConcurrency, async ({ surface, label, rationale }, i) => {
 			const hash = surfaceHash(surface);
 			const campaign = await runCampaign({
 				...opts,
@@ -7162,6 +6527,6 @@ function skillOptOptimizationMethod(config) {
 	};
 }
 //#endregion
-export { assertCampaignSplitIdentity as $, assertOptimizationResult as A, summarizeAgentReceiptIntegrity as At, surfaceContentHash as B, detectScale as C, decidePairedPromotion as Ct, runCanaries as D, BackendIntegrityError as Dt, pairHoldout as E, pairedDeltaTest as Et, assertCodeSurfaceIdentity as F, DEFAULT_MUTATION_PRIMITIVES as G, campaignBreakdown as H, assertComponentSurface as I, planCampaignRun as J, buildReflectionPrompt as K, codeSurfaceIdentityMaterial as L, compareOptimizationMethods as M, JudgeParseError as Mt, costFromLedgerSummary as N, composeGate as O, assertRealAgentReceipts as Ot, optimizationTokenUsageFromSummary as P, assertCampaignDesign as Q, componentSurfaceIdentityMaterial as R, defaultProductionGate as S, recoverTruncatedJson as St, heldoutSignificance as T, minimumPairsForPairedDeltaTest as Tt, campaignMeanComposite as U, surfaceHash as V, compareRankKeys as W, resolveRunDir as X, runCampaign as Y, tangleTracesRoot as Z, buildEvidenceVector as _, crowdingDistance as _t, emitLoopProvenance as a, REFERENCE_EQUIVALENCE_JUDGE_VERSION as at, powerPreflight as b, paretoFrontierWithCrowding as bt, provenanceRecordPath as c, DEFAULT_RED_TEAM_CORPUS as ct, runImprovementLoop as d, scoreRedTeamOutput as dt, campaignScenarioIdentity as et, runOptimization as f, toolNamesForRun as ft, gepaOptimizationMethod as g, llmJudge as gt, labelTrustRank as h, hashScenarios as ht, canonicalDigest as i, REFERENCE_EQUIVALENCE_INPUT_LIMITS as it, combineComparisonCosts as j, summarizeBackendIntegrity as jt, externalTextOptimizationMethod as k, assertRealBackend as kt, provenanceSpansPath as l, redTeamDataset as lt, isProposedCandidate as m, HoldoutLockedError as mt, buildLoopProvenanceRecord as n, campaignSplitDigestFromIdentities as nt, loopProvenanceArgsFromResult as o, createReferenceEquivalenceJudge as ot, runEval as p, Dataset as pt, parseReflectionResponse as q, campaignMeasurementDigest as r, openAutoPr as rt, loopProvenanceSpans as s, runReferenceEquivalenceJudge as st, skillOptOptimizationMethod as t, campaignSplitDigest as tt, verifyLoopProvenanceRecord as u, redTeamReport as ut, paretoPolicy as v, dominates as vt, dimensionRegressions as w, pairedDecisionShape as wt, heldOutGate as x, scalarScore as xt, paretoSignificanceGate as y, paretoFrontier as yt, renderSurfaceDiff as z };
+export { runReferenceEquivalenceJudge as $, componentSurfaceIdentityMaterial as A, planCampaignRun as B, combineComparisonCosts as C, assertCodeSurfaceIdentity as D, optimizationTokenUsageFromSummary as E, campaignMeanComposite as F, assertCampaignSplitIdentity as G, resolveRunDir as H, compareRankKeys as I, campaignSplitDigestFromIdentities as J, campaignScenarioIdentity as K, DEFAULT_MUTATION_PRIMITIVES as L, surfaceContentHash as M, surfaceHash as N, assertComponentSurface as O, campaignBreakdown as P, createReferenceEquivalenceJudge as Q, buildReflectionPrompt as R, assertOptimizationResult as S, costFromLedgerSummary as T, tangleTracesRoot as U, runCampaign as V, assertCampaignDesign as W, REFERENCE_EQUIVALENCE_INPUT_LIMITS as X, openAutoPr as Y, REFERENCE_EQUIVALENCE_JUDGE_VERSION as Z, heldOutGate as _, assertRealBackend as _t, emitLoopProvenance as a, Dataset as at, composeGate as b, JudgeParseError as bt, provenanceRecordPath as c, llmJudge as ct, runImprovementLoop as d, paretoFrontier as dt, DEFAULT_RED_TEAM_CORPUS as et, runOptimization as f, paretoFrontierWithCrowding as ft, gepaOptimizationMethod as g, assertRealAgentReceipts as gt, labelTrustRank as h, BackendIntegrityError as ht, canonicalDigest as i, toolNamesForRun as it, renderSurfaceDiff as j, codeSurfaceIdentityMaterial as k, provenanceSpansPath as l, crowdingDistance as lt, isProposedCandidate as m, recoverTruncatedJson as mt, buildLoopProvenanceRecord as n, redTeamReport as nt, loopProvenanceArgsFromResult as o, HoldoutLockedError as ot, runEval as p, scalarScore as pt, campaignSplitDigest as q, campaignMeasurementDigest as r, scoreRedTeamOutput as rt, loopProvenanceSpans as s, hashScenarios as st, skillOptOptimizationMethod as t, redTeamDataset as tt, verifyLoopProvenanceRecord as u, dominates as ut, defaultProductionGate as v, summarizeAgentReceiptIntegrity as vt, compareOptimizationMethods as w, externalTextOptimizationMethod as x, runCanaries as y, summarizeBackendIntegrity as yt, parseReflectionResponse as z };
 
-//# sourceMappingURL=skillopt-optimization-method-Bfb-vBKe.js.map
+//# sourceMappingURL=skillopt-optimization-method-CkaI2ly4.js.map