@tangle-network/agent-eval 0.217.1 → 0.218.1

package/dist/index.js

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { i as JudgeError, n as CaptureIntegrityError, o as NotFoundError, r as ConfigError, s as ValidationError, t as AgentEvalError } from "./errors-BcOs5MKW.js";
 import { a as hashCanonical, r as canonicalString } from "./canonical-Dq2hOQ8L.js";
-import { a as HARNESS_NATIVE_MODEL, c as agentProfileModelId, i as CODING_HARNESSES, l as expandProfileAxes, n as createLlmCorrectnessChecker, o as agentProfileHash, r as verifyCompletion, s as agentProfileId, t as completionVerdict, u as harnessAxisOf } from "./completion-verifier-B_jw6C9p.js";
+import { a as HARNESS_NATIVE_MODEL, c as agentProfileModelId, i as CODING_HARNESSES, l as expandProfileAxes, n as createLlmCorrectnessChecker, o as agentProfileHash, r as verifyCompletion, s as agentProfileId, t as completionVerdict, u as harnessAxisOf } from "./completion-verifier-DbLVf3i8.js";
 import { a as groupRunsByAgentProfileCell, c as verifyAgentProfileCell, i as buildAgentProfileCell, l as hashJson, o as toAgentProfileJson, r as agentProfileCellKey, s as validateAgentProfileCell, t as AGENT_PROFILE_KINDS, u as manifestContentDigest } from "./agent-profile-cell-B1V1gUZs.js";
 import { r as observedSplitScore, t as isRealnessGated } from "./reward-nw2xZGZG.js";
 import { i as isToolSpan, n as isJudgeSpan, r as isLlmSpan, t as FAILURE_CLASSES } from "./schema-Bt2vLFm3.js";
@@ -23,18 +23,18 @@ import { t as eProcess } from "./sequential-eprocess-DodI6RoF.js";
 import { i as pairedDeltaTest, n as pairedDecisionShape, r as minimumPairsForPairedDeltaTest, t as decidePairedPromotion } from "./paired-promotion-decision-D0SHb-ZL.js";
 import { c as runsForScenario, i as judgeSpans, t as argHash } from "./query-B_RZ36an.js";
 import { n as contentHash, r as fileVerdictCache, t as canonicalJson } from "./verdict-cache-CL_7tePD.js";
-import { G as runCanaries, H as redTeamDataset, Q as runCampaign, U as redTeamReport, V as DEFAULT_RED_TEAM_CORPUS, W as scoreRedTeamOutput, a as aggregateRunScore, i as transientDispatchFailure, o as clamp01, t as llmJudge } from "./llm-judge-C8jMTNNG.js";
+import { G as runCanaries, H as redTeamDataset, Q as runCampaign, U as redTeamReport, V as DEFAULT_RED_TEAM_CORPUS, W as scoreRedTeamOutput, a as aggregateRunScore, i as transientDispatchFailure, o as clamp01, t as llmJudge } from "./llm-judge-Djxh-Uhs.js";
 import { a as resolveModelPricing, i as isModelPriced, n as estimateCost, r as estimateTokens, t as MODEL_PRICING } from "./metrics-BKaPBtIG.js";
 import { c as costForTokenPricing, i as CostCeilingReachedError, l as costForUsage, n as CostAccountingIncompleteError, t as CostLedger } from "./cost-ledger-D0352Z4d.js";
-import { D as surfaceContentHash, M as assertRealBackend, N as summarizeBackendIntegrity, _ as parseReflectionResponse, a as ATTESTATION_ALGORITHM, g as buildReflectionPrompt, j as BackendIntegrityError, o as attest, s as verifyAttestation } from "./campaign-evidence-CQYw8_0H.js";
+import { D as surfaceContentHash, M as assertRealBackend, N as summarizeBackendIntegrity, _ as parseReflectionResponse, a as ATTESTATION_ALGORITHM, g as buildReflectionPrompt, j as BackendIntegrityError, o as attest, s as verifyAttestation } from "./campaign-evidence-DunzcJGv.js";
 import { a as redact, c as shareAllowed, n as assessShareSafety, o as redactForShare, s as redactText, t as REDACTION_VERSION } from "./redact-mtkTiJVk.js";
 import { a as makeProposalFinding, i as makeFinding, r as computeFindingId } from "./types-DqFMNTgK.js";
-import { S as requiredPairsForPairedPromotion, n as paretoFrontier, t as dominates, x as pairedPromotionPower } from "./pareto-BzsxidFD.js";
+import { S as requiredPairsForPairedPromotion, n as paretoFrontier, t as dominates, x as pairedPromotionPower } from "./pareto-CTv8vozZ.js";
 import { a as LlmCallError, i as stripFencedJson, n as isRecord, o as LlmResponseError } from "./json-BhdsJaOQ.js";
-import { r as selfImprove, t as defineAgentEval } from "./define-agent-eval-BDxNlP3D.js";
+import { r as selfImprove, t as defineAgentEval } from "./define-agent-eval-BGdFKlrc.js";
 import { n as equivalenceVerdict, t as certificationEvidenceDigest } from "./verdict-BGQmxQ8A.js";
 import { c as createBoundedTraceAnalysisStore, p as DEFAULT_TRACE_ANALYST_BUDGETS, t as createTraceAnalyst } from "./kind-factory-Gy4fXixd.js";
-import { _ as readAnalystReview, c as FAILURE_MODE_KIND_SPEC, g as completedAnalystReviewQuality, h as assertUniqueFindingIds, i as DEFAULT_TRACE_ANALYST_KINDS, m as analystRunDigest, n as AnalystRegistry, p as analystFindingDigest, t as buildDefaultAnalystRegistry, v as snapshotAnalystRun, y as validateAnalystReviewDecisions } from "./default-registry-ClYjq3QE.js";
+import { _ as readAnalystReview, c as FAILURE_MODE_KIND_SPEC, g as completedAnalystReviewQuality, h as assertUniqueFindingIds, i as DEFAULT_TRACE_ANALYST_KINDS, m as analystRunDigest, n as AnalystRegistry, p as analystFindingDigest, t as buildDefaultAnalystRegistry, v as snapshotAnalystRun, y as validateAnalystReviewDecisions } from "./default-registry-BJ-Pq6yL.js";
 import { OUTPUT_VALUE } from "./trace-attributes.js";
 import { n as extractUsageFromSse, t as extractUsage } from "./extract-usage-BZLU01kR.js";
 import { n as InMemoryRawProviderSink, r as NoopRawProviderSink, t as FileSystemRawProviderSink } from "./raw-provider-sink-75w4FWBj.js";
@@ -46,19 +46,19 @@ import { t as packageVersion$1 } from "./package-version-D7lQHt_-.js";
 import { t as buildTrajectory } from "./trajectory-D_7rLrvE.js";
 import { i as failureBlame, n as classifyFailure, r as classifyFailureReason } from "./failure-taxonomy-Bx5oWqaW.js";
 import { n as runBoundedProcess, t as DEFAULT_BOUNDED_PROCESS_TIMEOUT_MS } from "./bounded-process-Cj9YjXbE.js";
-import { t as runEvalCampaign } from "./eval-campaign-BLEfBGbA.js";
-import "./rollout-D6C50mfA.js";
-import { t as mintRolloutRows } from "./mint-zszyYlpA.js";
+import { t as runEvalCampaign } from "./eval-campaign-BUMIxKTE.js";
+import "./rollout-Dd1ucT_M.js";
+import { t as mintRolloutRows } from "./mint-CbdwjTPW.js";
 import { n as pairedEvalueSequence, t as evaluateInterimReleaseConfidence } from "./sequential-BVv1sjsw.js";
-import { a as maximumChargeForLlmRequest, c as ModelSubstitutionError, f as assertServedModels, g as judgeFamily, h as assertCrossFamily, i as costReceiptFromLlmError, l as assertCrossFamilyServed, m as CrossFamilyError, o as backoffMs, p as checkServedModel, r as costReceiptFromLlm, s as isTransientLlmError, u as assertServedModel } from "./llm-client-BshCREn6.js";
-import { n as paidJsonChat } from "./chat-json-call-DavzexSp.js";
-import { t as createDspyRlmTraceEngine } from "./dspy-rlm-engine-DhdCr1Dc.js";
-import { n as diffFindings, r as createChatTraceEngine, t as FindingsStore } from "./findings-store-BMVQtEsm.js";
+import { a as maximumChargeForLlmRequest, c as ModelSubstitutionError, f as assertServedModels, g as judgeFamily, h as assertCrossFamily, i as costReceiptFromLlmError, l as assertCrossFamilyServed, m as CrossFamilyError, o as backoffMs, p as checkServedModel, r as costReceiptFromLlm, s as isTransientLlmError, u as assertServedModel } from "./llm-client-_Y6ic-tf.js";
+import { n as paidJsonChat } from "./chat-json-call-Dm9c-b41.js";
+import { t as createDspyRlmTraceEngine } from "./dspy-rlm-engine-CSMwudLO.js";
+import { n as diffFindings, r as createChatTraceEngine, t as FindingsStore } from "./findings-store-BtTzPL0d.js";
 import { a as budgetBreachView, i as failureClusterView, n as computeToolUseMetrics, r as judgeAgreementView, t as toolWasteView } from "./tool-waste-DLsjS_p-.js";
 import { a as judgeGateDecision, c as snapshotFromJudgeAgreement, g as analyzeSeries, i as assertJudgeMayGate, n as JudgeGateRefusedError, o as measureJudgeAgreement, r as addCalibrationVerdicts, s as registerCalibrationSet, t as DEFAULT_JUDGE_GATE_POLICY } from "./judge-gate-Co5tuh57.js";
 import { a as spanRecordsToTraceAnalysisStore, i as otlpTextToTraceAnalysisStore, r as OtlpFileTraceStore } from "./store-otlp-BteDAbHK.js";
 import { n as bootstrapCi, t as evaluateReleaseConfidence } from "./release-confidence-CYIFH-fp.js";
-import { t as createChatClient } from "./chat-client-ldqxYYTN.js";
+import { t as createChatClient } from "./chat-client-B2pXlPdx.js";
 import { createHash } from "node:crypto";
 import { accessSync, appendFileSync, constants, cpSync, existsSync, mkdirSync, promises, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
@@ -3738,7 +3738,6 @@ function observeAll(detectors, event) {
 //#region src/control-runtime.ts
 async function runAgentControlLoop(config) {
 	const budget = normalizeBudget(config.budget);
-	const actionFailure = config.actionFailure ?? "continue";
 	const controller = new AbortController();
 	const upstreamAbort = () => controller.abort(config.signal?.reason);
 	if (config.signal) {
@@ -3747,473 +3746,51 @@ async function runAgentControlLoop(config) {
 	}
 	const started = Date.now();
 	const wallTimer = budget.maxWallMs ? setTimeout(() => controller.abort(/* @__PURE__ */ new Error("control runtime wall timeout")), budget.maxWallMs) : void 0;
-	const history = [];
-	const emitter = config.store ? new TraceEmitter(config.store, { onCaptureError: () => void 0 }) : void 0;
-	let spentCostUsd = 0;
-	const runtimeErrors = [];
-	const repeatedDetector = repeatedActionDetector({ maxRepeated: config.stopPolicies?.maxRepeatedActions ?? 0 });
-	const progressDetector = noProgressDetector({
-		maxNoProgress: config.stopPolicies?.maxNoProgressSteps ?? 0,
-		minScoreDelta: config.stopPolicies?.minScoreDelta ?? .001
-	});
+	const run = {
+		config,
+		budget,
+		signal: controller.signal,
+		started,
+		history: [],
+		emitter: config.store ? new TraceEmitter(config.store, { onCaptureError: () => void 0 }) : void 0,
+		runtimeErrors: [],
+		repeatedDetector: repeatedActionDetector({ maxRepeated: config.stopPolicies?.maxRepeatedActions ?? 0 }),
+		progressDetector: noProgressDetector({
+			maxNoProgress: config.stopPolicies?.maxNoProgressSteps ?? 0,
+			minScoreDelta: config.stopPolicies?.minScoreDelta ?? .001
+		}),
+		spentCostUsd: 0,
+		state: void 0,
+		evals: []
+	};
 	try {
-		if (emitter) await runTrace(emitter, runtimeErrors, 0, () => emitter.startRun({
-			scenarioId: config.scenarioId ?? "agent-control-loop",
-			projectId: config.projectId,
-			variantId: config.variantId,
-			layer: "meta",
-			tags: {
-				intent: config.intent.slice(0, 120),
-				maxSteps: String(budget.maxSteps),
-				...budget.maxCostUsd !== void 0 ? { maxCostUsd: String(budget.maxCostUsd) } : {}
-			}
-		}));
-		let state;
-		let evals;
-		try {
-			state = await config.observe({
-				history,
-				abortSignal: controller.signal
-			});
-		} catch (err) {
-			const error = runtimeError("observe", 0, err);
-			runtimeErrors.push(error);
-			return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: false,
-				reason: error.message,
-				steps: history,
-				finalState: void 0,
-				finalEvals: [],
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "unknown",
-				runtimeErrors,
-				stoppedBy: "runtime-error"
-			});
-		}
-		try {
-			evals = await config.validate({
-				intent: config.intent,
-				state,
-				history,
-				abortSignal: controller.signal
-			});
-			await recordEvalSpans(emitter, evals, "initial", runtimeErrors, 0);
-		} catch (err) {
-			const error = runtimeError("validate", 0, err);
-			runtimeErrors.push(error);
-			return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: false,
-				reason: error.message,
-				steps: history,
-				finalState: state,
-				finalEvals: [],
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "unknown",
-				runtimeErrors,
-				stoppedBy: "runtime-error"
-			});
-		}
-		progressDetector.observe({
-			stateFingerprint: fingerprintState(state, config.stopPolicies),
-			score: averageScore(evals)
+		await startTrace(run);
+		const failedStart = await observeInitial(run);
+		if (failedStart) return failedStart;
+		run.progressDetector.observe({
+			stateFingerprint: fingerprintState(run.state, config.stopPolicies),
+			score: averageScore(run.evals)
 		});
 		for (let stepIndex = 0; stepIndex < budget.maxSteps; stepIndex++) {
-			if (controller.signal.aborted) return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: false,
-				reason: abortReason(controller.signal),
-				score: void 0,
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "timeout",
-				runtimeErrors,
-				stoppedBy: "abort"
-			});
-			const budgetStop = budgetStopDecision(budget, spentCostUsd);
-			if (budgetStop.stop) return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: false,
-				reason: budgetStop.reason,
-				score: averageScore(evals),
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "budget_exceeded",
-				runtimeErrors,
-				stoppedBy: "budget"
-			});
-			const ctx = makeContext(config.intent, state, evals, history, budget, stepIndex, started, spentCostUsd, controller.signal, emitter);
-			let stop;
-			try {
-				stop = config.shouldStop ? await config.shouldStop(ctx) : defaultStopDecision(evals);
-			} catch (err) {
-				runtimeErrors.push(runtimeError("stop-policy", stepIndex, err));
-				return finish(emitter, {
-					intent: config.intent,
-					pass: false,
-					completed: false,
-					reason: runtimeErrors[runtimeErrors.length - 1].message,
-					score: averageScore(evals),
-					steps: history,
-					finalState: state,
-					finalEvals: evals,
-					wallMs: Date.now() - started,
-					spentCostUsd,
-					runId: emitter?.runId ?? null,
-					failureClass: "unknown",
-					runtimeErrors,
-					stoppedBy: "runtime-error"
-				});
-			}
-			if (stop.stop) return finish(emitter, {
-				intent: config.intent,
-				pass: stop.pass,
-				completed: true,
-				reason: stop.reason,
-				score: stop.score,
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: stop.failureClass,
-				runtimeErrors,
-				stoppedBy: "stop-policy"
-			});
-			let decision;
-			try {
-				decision = await config.decide(ctx);
-			} catch (err) {
-				runtimeErrors.push(runtimeError("decide", stepIndex, err));
-				return finish(emitter, {
-					intent: config.intent,
-					pass: false,
-					completed: false,
-					reason: runtimeErrors[runtimeErrors.length - 1].message,
-					score: averageScore(evals),
-					steps: history,
-					finalState: state,
-					finalEvals: evals,
-					wallMs: Date.now() - started,
-					spentCostUsd,
-					runId: emitter?.runId ?? null,
-					failureClass: "unknown",
-					runtimeErrors,
-					stoppedBy: "runtime-error"
-				});
-			}
-			if (decision.type === "stop") {
-				const pass = decision.pass ?? false;
-				return finish(emitter, {
-					intent: config.intent,
-					pass,
-					completed: true,
-					reason: decision.reason,
-					score: decision.score,
-					steps: history,
-					finalState: state,
-					finalEvals: evals,
-					wallMs: Date.now() - started,
-					spentCostUsd,
-					runId: emitter?.runId ?? null,
-					failureClass: pass ? void 0 : decision.failureClass ?? "unknown",
-					runtimeErrors,
-					stoppedBy: "policy"
-				});
-			}
-			const actionFingerprint = fingerprintAction(decision.action, config.stopPolicies);
-			const repeatedActionSignal = repeatedDetector.observe({ actionFingerprint });
-			const repeatedActionStreak = repeatedDetector.streak;
-			if (repeatedActionSignal) return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: true,
-				reason: repeatedActionSignal.reason,
-				score: averageScore(evals),
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "tool_recovery_failure",
-				runtimeErrors,
-				stoppedBy: "stop-policy"
-			});
-			const beforeState = state;
-			const evalsBefore = evals;
-			const scoreBefore = averageScore(evals);
-			const actionStarted = Date.now();
-			const stepHandle = emitter ? await runTrace(emitter, runtimeErrors, stepIndex, () => emitter.tool({
-				name: `control-step-${stepIndex}`,
-				toolName: "agent-control-action",
-				args: decision.action,
-				attributes: {
-					decision: decision.reason ?? "continue",
-					repeatedActionStreak
-				}
-			})) : void 0;
-			let actionOutcome;
-			try {
-				const result = await config.act(decision.action, ctx);
-				const rawCostUsd = config.getActionCostUsd?.({
-					action: decision.action,
-					result,
-					state,
-					evals,
-					history
-				});
-				const costUsd = normalizeActionCostUsd(rawCostUsd, runtimeErrors, stepIndex);
-				if (costUsd !== void 0 && Number.isFinite(costUsd) && costUsd > 0) {
-					spentCostUsd += costUsd;
-					await recordCostBudget(emitter, budget, spentCostUsd, stepHandle, runtimeErrors, stepIndex);
-				}
-				actionOutcome = {
-					ok: true,
-					result,
-					...costUsd !== void 0 ? { costUsd } : {},
-					durationMs: Date.now() - actionStarted
-				};
-			} catch (err) {
-				runtimeErrors.push(runtimeError("act", stepIndex, err));
-				actionOutcome = {
-					ok: false,
-					error: runtimeErrors[runtimeErrors.length - 1].message,
-					durationMs: Date.now() - actionStarted
-				};
-				if (actionFailure === "stop") {
-					await runTrace(emitter, runtimeErrors, stepIndex, () => stepHandle?.fail(actionOutcome.error ?? "action failed"));
-					const step = {
-						index: stepIndex,
-						decision,
-						beforeState,
-						afterState: state,
-						evalsBefore,
-						evalsAfter: evals,
-						actionOutcome,
-						startedAt: new Date(actionStarted).toISOString(),
-						endedAt: (/* @__PURE__ */ new Date()).toISOString()
-					};
-					history.push(step);
-					await runOnStep(config.onStep, step, runtimeErrors);
-					return finish(emitter, {
-						intent: config.intent,
-						pass: false,
-						completed: false,
-						reason: actionOutcome.error ?? "action failed",
-						score: averageScore(evals),
-						steps: history,
-						finalState: state,
-						finalEvals: evals,
-						wallMs: Date.now() - started,
-						spentCostUsd,
-						runId: emitter?.runId ?? null,
-						failureClass: "unknown",
-						runtimeErrors,
-						stoppedBy: "runtime-error"
-					});
-				}
-			}
-			let observationPhase = "observe";
-			try {
-				state = await config.observe({
-					history,
-					abortSignal: controller.signal
-				});
-				observationPhase = "validate";
-				evals = await config.validate({
-					intent: config.intent,
-					state,
-					history,
-					abortSignal: controller.signal
-				});
-				await recordEvalSpans(emitter, evals, `step-${stepIndex}`, runtimeErrors, stepIndex, stepHandle?.span.spanId);
-			} catch (err) {
-				runtimeErrors.push(runtimeError(observationPhase, stepIndex, err));
-				const afterState = observationPhase === "observe" ? beforeState : state;
-				const step = {
-					index: stepIndex,
-					decision,
-					beforeState,
-					afterState,
-					evalsBefore,
-					evalsAfter: evals,
-					actionOutcome,
-					startedAt: new Date(actionStarted).toISOString(),
-					endedAt: (/* @__PURE__ */ new Date()).toISOString()
-				};
-				history.push(step);
-				await runTrace(emitter, runtimeErrors, stepIndex, () => stepHandle?.fail(runtimeErrors[runtimeErrors.length - 1].message));
-				await runOnStep(config.onStep, step, runtimeErrors);
-				return finish(emitter, {
-					intent: config.intent,
-					pass: false,
-					completed: false,
-					reason: runtimeErrors[runtimeErrors.length - 1].message,
-					score: averageScore(evals),
-					steps: history,
-					finalState: afterState,
-					finalEvals: evals,
-					wallMs: Date.now() - started,
-					spentCostUsd,
-					runId: emitter?.runId ?? null,
-					failureClass: "unknown",
-					runtimeErrors,
-					stoppedBy: "runtime-error"
-				});
-			}
-			const scoreAfter = averageScore(evals);
-			const stateFingerprint = fingerprintState(state, config.stopPolicies);
-			const noProgressSignal = progressDetector.observe({
-				stateFingerprint,
-				score: scoreAfter
-			});
-			const noProgressStreak = progressDetector.streak;
-			const step = {
-				index: stepIndex,
-				decision,
-				beforeState,
-				afterState: state,
-				evalsBefore,
-				evalsAfter: evals,
-				actionOutcome,
-				startedAt: new Date(actionStarted).toISOString(),
-				endedAt: (/* @__PURE__ */ new Date()).toISOString()
-			};
-			history.push(step);
-			if (actionOutcome.ok) await runTrace(emitter, runtimeErrors, stepIndex, () => stepHandle?.end({ attributes: {
-				actionCostUsd: actionOutcome.costUsd ?? null,
-				spentCostUsd,
-				scoreBefore: scoreBefore ?? null,
-				scoreAfter: scoreAfter ?? null,
-				noProgressStreak
-			} }));
-			else await runTrace(emitter, runtimeErrors, stepIndex, () => stepHandle?.fail(actionOutcome.error ?? "action failed", { attributes: {
-				spentCostUsd,
-				noProgressStreak
-			} }));
-			await runOnStep(config.onStep, step, runtimeErrors);
-			if (noProgressSignal) return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: true,
-				reason: noProgressSignal.reason,
-				score: scoreAfter,
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "tool_recovery_failure",
-				runtimeErrors,
-				stoppedBy: "stop-policy"
-			});
-			const postStepBudgetStop = budgetStopDecision(budget, spentCostUsd);
-			if (postStepBudgetStop.stop) return finish(emitter, {
-				intent: config.intent,
-				pass: false,
-				completed: false,
-				reason: postStepBudgetStop.reason,
-				score: scoreAfter,
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: "budget_exceeded",
-				runtimeErrors,
-				stoppedBy: "budget"
-			});
-			const postStepCtx = makeContext(config.intent, state, evals, history, budget, stepIndex + 1, started, spentCostUsd, controller.signal, emitter);
-			let postStepStop;
-			try {
-				postStepStop = config.shouldStop ? await config.shouldStop(postStepCtx) : defaultStopDecision(evals);
-			} catch (err) {
-				runtimeErrors.push(runtimeError("stop-policy", stepIndex + 1, err));
-				return finish(emitter, {
-					intent: config.intent,
-					pass: false,
-					completed: false,
-					reason: runtimeErrors[runtimeErrors.length - 1].message,
-					score: averageScore(evals),
-					steps: history,
-					finalState: state,
-					finalEvals: evals,
-					wallMs: Date.now() - started,
-					spentCostUsd,
-					runId: emitter?.runId ?? null,
-					failureClass: "unknown",
-					runtimeErrors,
-					stoppedBy: "runtime-error"
-				});
-			}
-			if (postStepStop.stop) return finish(emitter, {
-				intent: config.intent,
-				pass: postStepStop.pass,
-				completed: true,
-				reason: postStepStop.reason,
-				score: postStepStop.score,
-				steps: history,
-				finalState: state,
-				finalEvals: evals,
-				wallMs: Date.now() - started,
-				spentCostUsd,
-				runId: emitter?.runId ?? null,
-				failureClass: postStepStop.failureClass,
-				runtimeErrors,
-				stoppedBy: "stop-policy"
-			});
+			const ended = await runStep(run, stepIndex);
+			if (ended) return ended;
 		}
-		return finish(emitter, {
-			intent: config.intent,
+		return settle(run, {
 			pass: false,
 			completed: false,
 			reason: `budget exhausted: maxSteps=${budget.maxSteps}`,
-			steps: history,
-			finalState: state,
-			finalEvals: evals,
-			wallMs: Date.now() - started,
-			spentCostUsd,
-			runId: emitter?.runId ?? null,
 			failureClass: "budget_exceeded",
-			runtimeErrors,
 			stoppedBy: "budget"
 		});
 	} catch (err) {
-		runtimeErrors.push(runtimeError("act", history.length, err));
-		return finish(emitter, {
-			intent: config.intent,
+		run.runtimeErrors.push(runtimeError("act", run.history.length, err));
+		return settle(run, {
 			pass: false,
 			completed: false,
-			reason: runtimeErrors[runtimeErrors.length - 1].message,
-			steps: history,
+			reason: lastErrorMessage(run),
 			finalState: void 0,
 			finalEvals: [],
-			wallMs: Date.now() - started,
-			spentCostUsd,
-			runId: emitter?.runId ?? null,
 			failureClass: "unknown",
-			runtimeErrors,
 			stoppedBy: "runtime-error"
 		});
 	} finally {
@@ -4221,6 +3798,349 @@ async function runAgentControlLoop(config) {
 		if (config.signal) config.signal.removeEventListener("abort", upstreamAbort);
 	}
 }
+/** End the run with `how`; everything not named there is read from the run as it stands now. */
+function settle(run, how) {
+	return finish(run.emitter, {
+		intent: run.config.intent,
+		pass: how.pass,
+		completed: how.completed,
+		reason: how.reason,
+		..."score" in how ? { score: how.score } : {},
+		steps: run.history,
+		finalState: "finalState" in how ? how.finalState : run.state,
+		finalEvals: how.finalEvals ?? run.evals,
+		wallMs: Date.now() - run.started,
+		spentCostUsd: run.spentCostUsd,
+		runId: run.emitter?.runId ?? null,
+		failureClass: how.failureClass,
+		runtimeErrors: run.runtimeErrors,
+		stoppedBy: how.stoppedBy
+	});
+}
+function lastErrorMessage(run) {
+	return run.runtimeErrors[run.runtimeErrors.length - 1].message;
+}
+/** End the run on the runtime error just recorded. */
+function settleOnRuntimeError(run, finalState) {
+	return settle(run, {
+		pass: false,
+		completed: false,
+		reason: lastErrorMessage(run),
+		score: averageScore(run.evals),
+		...finalState ? { finalState: finalState.value } : {},
+		failureClass: "unknown",
+		stoppedBy: "runtime-error"
+	});
+}
+async function startTrace(run) {
+	const { emitter, config, budget } = run;
+	if (!emitter) return;
+	await runTrace(emitter, run.runtimeErrors, 0, () => emitter.startRun({
+		scenarioId: config.scenarioId ?? "agent-control-loop",
+		projectId: config.projectId,
+		variantId: config.variantId,
+		layer: "meta",
+		tags: {
+			intent: config.intent.slice(0, 120),
+			maxSteps: String(budget.maxSteps),
+			...budget.maxCostUsd !== void 0 ? { maxCostUsd: String(budget.maxCostUsd) } : {}
+		}
+	}));
+}
+/** The first observation and validation. Returns the result that ends the run when either fails. */
+async function observeInitial(run) {
+	try {
+		run.state = await run.config.observe({
+			history: run.history,
+			abortSignal: run.signal
+		});
+	} catch (err) {
+		const error = runtimeError("observe", 0, err);
+		run.runtimeErrors.push(error);
+		return settle(run, {
+			pass: false,
+			completed: false,
+			reason: error.message,
+			failureClass: "unknown",
+			stoppedBy: "runtime-error"
+		});
+	}
+	try {
+		run.evals = await run.config.validate({
+			intent: run.config.intent,
+			state: run.state,
+			history: run.history,
+			abortSignal: run.signal
+		});
+		await recordEvalSpans(run.emitter, run.evals, "initial", run.runtimeErrors, 0);
+	} catch (err) {
+		const error = runtimeError("validate", 0, err);
+		run.runtimeErrors.push(error);
+		return settle(run, {
+			pass: false,
+			completed: false,
+			reason: error.message,
+			finalEvals: [],
+			failureClass: "unknown",
+			stoppedBy: "runtime-error"
+		});
+	}
+}
+/** One decide-act-observe step. Returns the result that ends the run, or nothing to go on. */
+async function runStep(run, stepIndex) {
+	const halted = await checkAbortAndBudget(run);
+	if (halted) return halted;
+	const ctx = makeRunContext(run, stepIndex);
+	const stopped = await checkStopPolicy(run, ctx, stepIndex);
+	if (stopped) return stopped;
+	const chosen = await decideAction(run, ctx, stepIndex);
+	if ("ended" in chosen) return chosen.ended;
+	const { decision } = chosen.next;
+	const repeated = await detectRepeatedAction(run, decision);
+	if ("ended" in repeated) return repeated.ended;
+	const attempt = await attemptAction(run, ctx, decision, stepIndex, repeated.next);
+	if ("ended" in attempt) return attempt.ended;
+	const observed = await observeAfterAction(run, attempt.next, stepIndex);
+	if (observed) return observed;
+	return recordStepAndCheck(run, attempt.next, stepIndex);
+}
+async function checkAbortAndBudget(run) {
+	if (run.signal.aborted) return settle(run, {
+		pass: false,
+		completed: false,
+		reason: abortReason(run.signal),
+		score: void 0,
+		failureClass: "timeout",
+		stoppedBy: "abort"
+	});
+	const budgetStop = budgetStopDecision(run.budget, run.spentCostUsd);
+	if (!budgetStop.stop) return void 0;
+	return settle(run, {
+		pass: false,
+		completed: false,
+		reason: budgetStop.reason,
+		score: averageScore(run.evals),
+		failureClass: "budget_exceeded",
+		stoppedBy: "budget"
+	});
+}
+function makeRunContext(run, stepIndex) {
+	return makeContext(run.config.intent, run.state, run.evals, run.history, run.budget, stepIndex, run.started, run.spentCostUsd, run.signal, run.emitter);
+}
+/** Ask the stop policy about the current state. `errorStep` is the step a failing policy is recorded against. */
+async function checkStopPolicy(run, ctx, errorStep) {
+	let stop;
+	try {
+		stop = run.config.shouldStop ? await run.config.shouldStop(ctx) : defaultStopDecision(run.evals);
+	} catch (err) {
+		run.runtimeErrors.push(runtimeError("stop-policy", errorStep, err));
+		return settleOnRuntimeError(run);
+	}
+	if (!stop.stop) return void 0;
+	return settle(run, {
+		pass: stop.pass,
+		completed: true,
+		reason: stop.reason,
+		score: stop.score,
+		failureClass: stop.failureClass,
+		stoppedBy: "stop-policy"
+	});
+}
+async function decideAction(run, ctx, stepIndex) {
+	let decision;
+	try {
+		decision = await run.config.decide(ctx);
+	} catch (err) {
+		run.runtimeErrors.push(runtimeError("decide", stepIndex, err));
+		return { ended: await settleOnRuntimeError(run) };
+	}
+	if (decision.type !== "stop") return { next: { decision } };
+	const pass = decision.pass ?? false;
+	return { ended: await settle(run, {
+		pass,
+		completed: true,
+		reason: decision.reason,
+		score: decision.score,
+		failureClass: pass ? void 0 : decision.failureClass ?? "unknown",
+		stoppedBy: "policy"
+	}) };
+}
+/** Feed the chosen action to the repeated-action detector; its streak is returned for the step's trace. */
+async function detectRepeatedAction(run, decision) {
+	const actionFingerprint = fingerprintAction(decision.action, run.config.stopPolicies);
+	const signal = run.repeatedDetector.observe({ actionFingerprint });
+	if (!signal) return { next: run.repeatedDetector.streak };
+	return { ended: await settle(run, {
+		pass: false,
+		completed: true,
+		reason: signal.reason,
+		score: averageScore(run.evals),
+		failureClass: "tool_recovery_failure",
+		stoppedBy: "stop-policy"
+	}) };
+}
+/** Run the chosen action under its trace span and price it. A failed action ends the run only when `actionFailure` is 'stop'. */
+async function attemptAction(run, ctx, decision, stepIndex, repeatedActionStreak) {
+	const { config, emitter, runtimeErrors } = run;
+	const beforeState = run.state;
+	const evalsBefore = run.evals;
+	const scoreBefore = averageScore(run.evals);
+	const actionStarted = Date.now();
+	const stepHandle = emitter ? await runTrace(emitter, runtimeErrors, stepIndex, () => emitter.tool({
+		name: `control-step-${stepIndex}`,
+		toolName: "agent-control-action",
+		args: decision.action,
+		attributes: {
+			decision: decision.reason ?? "continue",
+			repeatedActionStreak
+		}
+	})) : void 0;
+	let outcome;
+	try {
+		const result = await config.act(decision.action, ctx);
+		const rawCostUsd = config.getActionCostUsd?.({
+			action: decision.action,
+			result,
+			state: run.state,
+			evals: run.evals,
+			history: run.history
+		});
+		const costUsd = normalizeActionCostUsd(rawCostUsd, runtimeErrors, stepIndex);
+		if (costUsd !== void 0 && Number.isFinite(costUsd) && costUsd > 0) {
+			run.spentCostUsd += costUsd;
+			await recordCostBudget(emitter, run.budget, run.spentCostUsd, stepHandle, runtimeErrors, stepIndex);
+		}
+		outcome = {
+			ok: true,
+			result,
+			...costUsd !== void 0 ? { costUsd } : {},
+			durationMs: Date.now() - actionStarted
+		};
+	} catch (err) {
+		runtimeErrors.push(runtimeError("act", stepIndex, err));
+		outcome = {
+			ok: false,
+			error: lastErrorMessage(run),
+			durationMs: Date.now() - actionStarted
+		};
+		if ((config.actionFailure ?? "continue") === "stop") {
+			await runTrace(emitter, runtimeErrors, stepIndex, () => stepHandle?.fail(outcome.error ?? "action failed"));
+			const step = buildStep(run, {
+				decision,
+				beforeState,
+				evalsBefore,
+				scoreBefore,
+				actionStarted,
+				stepHandle,
+				outcome
+			}, stepIndex, run.state);
+			run.history.push(step);
+			await runOnStep(config.onStep, step, runtimeErrors);
+			return { ended: await settle(run, {
+				pass: false,
+				completed: false,
+				reason: outcome.error ?? "action failed",
+				score: averageScore(run.evals),
+				failureClass: "unknown",
+				stoppedBy: "runtime-error"
+			}) };
+		}
+	}
+	return { next: {
+		decision,
+		beforeState,
+		evalsBefore,
+		scoreBefore,
+		actionStarted,
+		stepHandle,
+		outcome
+	} };
+}
+function buildStep(run, attempt, stepIndex, afterState) {
+	return {
+		index: stepIndex,
+		decision: attempt.decision,
+		beforeState: attempt.beforeState,
+		afterState,
+		evalsBefore: attempt.evalsBefore,
+		evalsAfter: run.evals,
+		actionOutcome: attempt.outcome,
+		startedAt: new Date(attempt.actionStarted).toISOString(),
+		endedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+/** Observe and validate after the action. A failure records the step and ends the run. */
+async function observeAfterAction(run, attempt, stepIndex) {
+	const { config, emitter, runtimeErrors } = run;
+	let observationPhase = "observe";
+	try {
+		run.state = await config.observe({
+			history: run.history,
+			abortSignal: run.signal
+		});
+		observationPhase = "validate";
+		run.evals = await config.validate({
+			intent: config.intent,
+			state: run.state,
+			history: run.history,
+			abortSignal: run.signal
+		});
+		await recordEvalSpans(emitter, run.evals, `step-${stepIndex}`, runtimeErrors, stepIndex, attempt.stepHandle?.span.spanId);
+		return;
+	} catch (err) {
+		runtimeErrors.push(runtimeError(observationPhase, stepIndex, err));
+		const afterState = observationPhase === "observe" ? attempt.beforeState : run.state;
+		const step = buildStep(run, attempt, stepIndex, afterState);
+		run.history.push(step);
+		await runTrace(emitter, runtimeErrors, stepIndex, () => attempt.stepHandle?.fail(lastErrorMessage(run)));
+		await runOnStep(config.onStep, step, runtimeErrors);
+		return settleOnRuntimeError(run, { value: afterState });
+	}
+}
+/** Record the finished step, then apply the no-progress, budget and stop-policy checks that follow it. */
+async function recordStepAndCheck(run, attempt, stepIndex) {
+	const { config, emitter, runtimeErrors } = run;
+	const scoreAfter = averageScore(run.evals);
+	const stateFingerprint = fingerprintState(run.state, config.stopPolicies);
+	const noProgressSignal = run.progressDetector.observe({
+		stateFingerprint,
+		score: scoreAfter
+	});
+	const noProgressStreak = run.progressDetector.streak;
+	const step = buildStep(run, attempt, stepIndex, run.state);
+	run.history.push(step);
+	const { outcome, stepHandle } = attempt;
+	if (outcome.ok) await runTrace(emitter, runtimeErrors, stepIndex, () => stepHandle?.end({ attributes: {
+		actionCostUsd: outcome.costUsd ?? null,
+		spentCostUsd: run.spentCostUsd,
+		scoreBefore: attempt.scoreBefore ?? null,
+		scoreAfter: scoreAfter ?? null,
+		noProgressStreak
+	} }));
+	else await runTrace(emitter, runtimeErrors, stepIndex, () => stepHandle?.fail(outcome.error ?? "action failed", { attributes: {
+		spentCostUsd: run.spentCostUsd,
+		noProgressStreak
+	} }));
+	await runOnStep(config.onStep, step, runtimeErrors);
+	if (noProgressSignal) return settle(run, {
+		pass: false,
+		completed: true,
+		reason: noProgressSignal.reason,
+		score: scoreAfter,
+		failureClass: "tool_recovery_failure",
+		stoppedBy: "stop-policy"
+	});
+	const postStepBudgetStop = budgetStopDecision(run.budget, run.spentCostUsd);
+	if (postStepBudgetStop.stop) return settle(run, {
+		pass: false,
+		completed: false,
+		reason: postStepBudgetStop.reason,
+		score: scoreAfter,
+		failureClass: "budget_exceeded",
+		stoppedBy: "budget"
+	});
+	return checkStopPolicy(run, makeRunContext(run, stepIndex + 1), stepIndex + 1);
+}
 function makeContext(intent, state, evals, history, budget, stepIndex, started, spentCostUsd, abortSignal, emitter) {
 	return {
 		intent,
@@ -6695,6 +6615,152 @@ function wranglerDeployRunner(input) {
 	} };
 }
 //#endregion
+//#region src/held-out-gate-inputs.ts
+/** Drop gamed runs, pair both splits and measure coverage, scores, gaps and cost. */
+function collectGateInputs(candidate, baseline, baselineKey) {
+	const candidateId = inferCandidateId(candidate, baselineKey);
+	const baselineId = baselineKey;
+	assertScenarioIdentities([...candidate, ...baseline]);
+	const realnessGatedRuns = [...candidate, ...baseline].filter(isRealnessGated).length;
+	const honestCandidate = candidate.filter((run) => !isRealnessGated(run));
+	const honestBaseline = baseline.filter((run) => !isRealnessGated(run));
+	const candidateSearch = scoredRuns(honestCandidate, "search");
+	const baselineSearch = scoredRuns(honestBaseline, "search");
+	const candidateHoldout = scoredRuns(honestCandidate, "holdout");
+	const baselineHoldout = scoredRuns(honestBaseline, "holdout");
+	const searchPairing = pairRunRecords(baselineSearch, candidateSearch);
+	const holdoutPairing = pairRunRecords(baselineHoldout, candidateHoldout);
+	const searchCoverage = splitCoverage(honestBaseline, honestCandidate, "search");
+	const holdoutCoverage = splitCoverage(honestBaseline, honestCandidate, "holdout");
+	const splitScoreOf = (run, split) => observedSplitScore(run, split);
+	const beforeSearch = searchPairing.pairs.map((pair) => splitScoreOf(pair.baseline, "search"));
+	const afterSearch = searchPairing.pairs.map((pair) => splitScoreOf(pair.treatment, "search"));
+	const beforeHoldout = holdoutPairing.pairs.map((pair) => splitScoreOf(pair.baseline, "holdout"));
+	const afterHoldout = holdoutPairing.pairs.map((pair) => splitScoreOf(pair.treatment, "holdout"));
+	const productiveRuns = beforeHoldout.length;
+	const candidateSearchMean = meanOrNull(afterSearch);
+	const candidateHoldoutMean = meanOrNull(afterHoldout);
+	const baselineSearchMean = meanOrNull(beforeSearch);
+	const baselineHoldoutMean = meanOrNull(beforeHoldout);
+	const overfitGap = diffOrNull(candidateSearchMean, candidateHoldoutMean);
+	const baselineOverfitGap = diffOrNull(baselineSearchMean, baselineHoldoutMean);
+	const medianCandidateCost = completeCostMedian([...searchPairing.pairs.map((pair) => pair.treatment), ...holdoutPairing.pairs.map((pair) => pair.treatment)]);
+	const medianBaselineCost = completeCostMedian([...searchPairing.pairs.map((pair) => pair.baseline), ...holdoutPairing.pairs.map((pair) => pair.baseline)]);
+	return {
+		candidateId,
+		baselineId,
+		beforeHoldout,
+		afterHoldout,
+		productiveRuns,
+		overfitGap,
+		baselineOverfitGap,
+		medianCandidateCost,
+		medianBaselineCost,
+		searchCoverage,
+		holdoutCoverage,
+		missingSplitScores: [
+			candidateSearch.length === 0 ? "candidate search" : null,
+			candidateHoldout.length === 0 ? "candidate holdout" : null,
+			baselineSearch.length === 0 ? "baseline search" : null,
+			baselineHoldout.length === 0 ? "baseline holdout" : null
+		].filter((label) => label !== null),
+		commonEvidence: {
+			productiveRuns,
+			unpairedCandidateRuns: holdoutPairing.unpairedTreatment.length,
+			unpairedBaselineRuns: holdoutPairing.unpairedBaseline.length,
+			searchScore: candidateSearchMean,
+			holdoutScore: candidateHoldoutMean,
+			overfitGap,
+			baselineOverfitGap,
+			medianCandidateCost,
+			medianBaselineCost,
+			realnessGatedRuns,
+			searchCoverage,
+			holdoutCoverage
+		}
+	};
+}
+function inferCandidateId(candidate, baselineKey) {
+	for (const run of candidate) if (run.candidateId && run.candidateId !== baselineKey) return run.candidateId;
+	return candidate[0]?.candidateId ?? "(unknown candidate)";
+}
+function assertScenarioIdentities(runs) {
+	for (const run of runs) if (typeof run.scenarioId !== "string" || run.scenarioId.trim() === "") throw new Error(`HeldOutGate: run ${run.runId} is missing scenarioId`);
+}
+/**
+* Rows carrying a finite score on one split. RAW (`observedSplitScore`) by
+* choice: the gated runs are already removed by the caller, so applying the
+* gate again here would only zero runs that are no longer in the set, and the
+* reported means must describe the runs that actually decided the promotion.
+*/
+function scoredRuns(runs, split) {
+	return runs.filter((run) => {
+		if (run.splitTag !== split) return false;
+		const v = observedSplitScore(run, split);
+		return typeof v === "number" && Number.isFinite(v);
+	});
+}
+/** Every row tagged to one split, scored or not — the work the split was
+*  DEALT, as opposed to the work it managed to measure. */
+function dealtRuns(runs, split) {
+	return runs.filter((run) => run.splitTag === split);
+}
+function hasFiniteScore(run, split) {
+	const v = observedSplitScore(run, split);
+	return typeof v === "number" && Number.isFinite(v);
+}
+/**
+* Partition one split's dealt work into answered / unscored / one-armed.
+*
+* Pairs the UNFILTERED rows with the same `pairRunRecords` the decision uses,
+* so the denominator comes out of the same identity rules as the numerator and
+* cannot drift from it. Deliberately a SECOND pairing rather than a widening of
+* the decision's own: the decision keeps pairing exactly the rows it always
+* paired, so this check can only ever add a refusal, never move a verdict that
+* was already being made on a complete set.
+*/
+function splitCoverage(baseline, candidate, split) {
+	const pairing = pairRunRecords(dealtRuns(baseline, split), dealtRuns(candidate, split));
+	let answered = 0;
+	for (const pair of pairing.pairs) if (hasFiniteScore(pair.baseline, split) && hasFiniteScore(pair.treatment, split)) answered += 1;
+	const unscoredPairs = pairing.pairs.length - answered;
+	const candidateOnly = pairing.unpairedTreatment.length;
+	const baselineOnly = pairing.unpairedBaseline.length;
+	const dealt = pairing.pairs.length + candidateOnly + baselineOnly;
+	return {
+		dealt,
+		answered,
+		unscoredPairs,
+		candidateOnly,
+		baselineOnly,
+		coverage: dealt === 0 ? 0 : answered / dealt
+	};
+}
+function meanOrNull(xs) {
+	if (xs.length === 0) return null;
+	return xs.reduce((s, x) => s + x, 0) / xs.length;
+}
+function diffOrNull(a, b) {
+	if (a === null || b === null) return null;
+	return a - b;
+}
+function medianFinite(xs) {
+	const ys = xs.filter((x) => Number.isFinite(x)).sort((x, y) => x - y);
+	if (ys.length === 0) return null;
+	const mid = Math.floor(ys.length / 2);
+	return ys.length % 2 === 0 ? (ys[mid - 1] + ys[mid]) / 2 : ys[mid];
+}
+function completeCostMedian(runs) {
+	if (runs.length === 0) return null;
+	const costs = [];
+	for (const run of runs) {
+		const usd = run.costProvenance.usd;
+		if (usd === null) return null;
+		costs.push(usd);
+	}
+	return medianFinite(costs);
+}
+//#endregion
 //#region src/held-out-gate.ts
 /**
 * HeldOutGate — first-class held-out paired-delta promotion gate.
@@ -6854,55 +6920,35 @@ var HeldOutGate = class {
 	*  Pairing is by `(experimentId, scenarioId, seed)`.
 	*  Missing or duplicate identities throw instead of comparing by position. */
 	evaluate(candidate, baseline) {
-		const candidateId = inferCandidateId(candidate, this.baselineKey);
-		const baselineId = this.baselineKey;
-		assertScenarioIdentities([...candidate, ...baseline]);
-		const realnessGatedRuns = [...candidate, ...baseline].filter(isRealnessGated).length;
-		const honestCandidate = candidate.filter((run) => !isRealnessGated(run));
-		const honestBaseline = baseline.filter((run) => !isRealnessGated(run));
-		const candidateSearch = scoredRuns(honestCandidate, "search");
-		const baselineSearch = scoredRuns(honestBaseline, "search");
-		const candidateHoldout = scoredRuns(honestCandidate, "holdout");
-		const baselineHoldout = scoredRuns(honestBaseline, "holdout");
-		const searchPairing = pairRunRecords(baselineSearch, candidateSearch);
-		const holdoutPairing = pairRunRecords(baselineHoldout, candidateHoldout);
-		const searchCoverage = splitCoverage(honestBaseline, honestCandidate, "search");
-		const holdoutCoverage = splitCoverage(honestBaseline, honestCandidate, "holdout");
-		const splitScoreOf = (run, split) => observedSplitScore(run, split);
-		const beforeSearch = searchPairing.pairs.map((pair) => splitScoreOf(pair.baseline, "search"));
-		const afterSearch = searchPairing.pairs.map((pair) => splitScoreOf(pair.treatment, "search"));
-		const beforeHoldout = holdoutPairing.pairs.map((pair) => splitScoreOf(pair.baseline, "holdout"));
-		const afterHoldout = holdoutPairing.pairs.map((pair) => splitScoreOf(pair.treatment, "holdout"));
-		const productiveRuns = beforeHoldout.length;
-		const candidateSearchMean = meanOrNull(afterSearch);
-		const candidateHoldoutMean = meanOrNull(afterHoldout);
-		const baselineSearchMean = meanOrNull(beforeSearch);
-		const baselineHoldoutMean = meanOrNull(beforeHoldout);
-		const overfitGap = diffOrNull(candidateSearchMean, candidateHoldoutMean);
-		const baselineOverfitGap = diffOrNull(baselineSearchMean, baselineHoldoutMean);
-		const medianCandidateCost = completeCostMedian([...searchPairing.pairs.map((pair) => pair.treatment), ...holdoutPairing.pairs.map((pair) => pair.treatment)]);
-		const medianBaselineCost = completeCostMedian([...searchPairing.pairs.map((pair) => pair.baseline), ...holdoutPairing.pairs.map((pair) => pair.baseline)]);
-		const commonEvidence = {
-			productiveRuns,
-			unpairedCandidateRuns: holdoutPairing.unpairedTreatment.length,
-			unpairedBaselineRuns: holdoutPairing.unpairedBaseline.length,
-			searchScore: candidateSearchMean,
-			holdoutScore: candidateHoldoutMean,
-			overfitGap,
-			baselineOverfitGap,
-			medianCandidateCost,
-			medianBaselineCost,
-			realnessGatedRuns,
-			searchCoverage,
-			holdoutCoverage
+		const inputs = collectGateInputs(candidate, baseline, this.baselineKey);
+		const missingEvidence = this.refuseOnMissingEvidence(inputs);
+		if (missingEvidence) return missingEvidence;
+		const { overfitGap, baselineOverfitGap } = inputs;
+		if (overfitGap === null || baselineOverfitGap === null) throw new Error("HeldOutGate: complete split scores did not produce overfit gaps");
+		const { decision, evidence } = this.decidePairedDelta(inputs);
+		const refusal = this.refuseOnDelta(inputs, decision, evidence) ?? this.refuseOnOverfitOrCost(inputs, evidence, overfitGap, baselineOverfitGap);
+		if (refusal) return refusal;
+		const { candidateId, baselineId, productiveRuns, medianCandidateCost, medianBaselineCost } = inputs;
+		return {
+			promote: true,
+			candidateId,
+			baselineId,
+			evidence,
+			reason: `promote: paired holdout ${decision.label} Δ=${fmt(decision.delta)} CI=[${fmt(decision.low)}, ${fmt(decision.high)}] over ${productiveRuns} pairs; overfit gap candidate=${fmt(overfitGap)} vs baseline=${fmt(baselineOverfitGap)}; median cost candidate=$${fmt(medianCandidateCost)} vs baseline=$${fmt(medianBaselineCost)}`,
+			rejectionCode: null
 		};
+	}
+	/** Refusals decided before any interval is computed: absent split scores,
+	*  incomplete coverage, too few paired runs. */
+	refuseOnMissingEvidence(inputs) {
+		const { productiveRuns, searchCoverage, holdoutCoverage } = inputs;
 		/** Evidence for the early exits, where no CI was computed at all. The
 		*  statistic that WOULD have decided is still reported so a caller can see
 		*  which branch their data lands in without producing a verdict. */
-		const earlyShape = this.chooseShape(beforeHoldout, afterHoldout);
+		const earlyShape = this.chooseShape(inputs.beforeHoldout, inputs.afterHoldout);
 		const noCiEvidence = {
-			...commonEvidence,
-			medianPairedDelta: productiveRuns > 0 ? medianDelta(beforeHoldout, afterHoldout) : null,
+			...inputs.commonEvidence,
+			medianPairedDelta: productiveRuns > 0 ? medianDelta(inputs.beforeHoldout, inputs.afterHoldout) : null,
 			deltaStatistic: earlyShape.statistic,
 			decidingDelta: null,
 			pairedCI: null,
@@ -6911,38 +6957,19 @@ var HeldOutGate = class {
 			binaryScale: earlyShape.binaryScale,
 			tieFraction: earlyShape.tieFraction
 		};
-		const missingSplitScores = [
-			candidateSearch.length === 0 ? "candidate search" : null,
-			candidateHoldout.length === 0 ? "candidate holdout" : null,
-			baselineSearch.length === 0 ? "baseline search" : null,
-			baselineHoldout.length === 0 ? "baseline holdout" : null
-		].filter((label) => label !== null);
-		if (missingSplitScores.length > 0) return {
-			promote: false,
-			candidateId,
-			baselineId,
-			evidence: noCiEvidence,
-			reason: `missing_split_scores: ${missingSplitScores.join(", ")} score evidence is absent`,
-			rejectionCode: "missing_split_scores"
-		};
+		if (inputs.missingSplitScores.length > 0) return rejectGate(inputs, noCiEvidence, "missing_split_scores", `missing_split_scores: ${inputs.missingSplitScores.join(", ")} score evidence is absent`);
 		const shortfalls = [["holdout", holdoutCoverage], ["search", searchCoverage]].filter(([, cov]) => cov.coverage < this.minCoverage);
-		if (shortfalls.length > 0) return {
-			promote: false,
-			candidateId,
-			baselineId,
-			evidence: noCiEvidence,
-			reason: `incomplete_coverage: ${shortfalls.map(([split, cov]) => describeCoverage(split, cov)).join("; ")} — required ${fmt(this.minCoverage)} of every dealt item scored on both arms. A missing score is missing data, not an absent item: the gate will not decide on the subset that answered`,
-			rejectionCode: "incomplete_coverage"
-		};
-		if (productiveRuns < this.minProductiveRuns) return {
-			promote: false,
-			candidateId,
-			baselineId,
-			evidence: noCiEvidence,
-			reason: `few_runs: ${productiveRuns} paired holdout observation(s) < min ${this.minProductiveRuns}`,
-			rejectionCode: "few_runs"
-		};
-		if (overfitGap === null || baselineOverfitGap === null) throw new Error("HeldOutGate: complete split scores did not produce overfit gaps");
+		if (shortfalls.length > 0) return rejectGate(inputs, noCiEvidence, "incomplete_coverage", `incomplete_coverage: ${shortfalls.map(([split, cov]) => describeCoverage(split, cov)).join("; ")} — required ${fmt(this.minCoverage)} of every dealt item scored on both arms. A missing score is missing data, not an absent item: the gate will not decide on the subset that answered`);
+		if (productiveRuns < this.minProductiveRuns) return rejectGate(inputs, noCiEvidence, "few_runs", `few_runs: ${productiveRuns} paired holdout observation(s) < min ${this.minProductiveRuns}`);
+		return null;
+	}
+	/** The paired holdout delta, decided by the one shared rule (see
+	*  `paired-promotion-decision.ts`): the estimator comes from the outcome's
+	*  shape, McNemar vetoes at a non-negative threshold, and a zero-width
+	*  interval is refused. `medianPairedDelta` stays the literal median on
+	*  EVERY path so the number that made the old gate blind remains visible. */
+	decidePairedDelta(inputs) {
+		const { beforeHoldout, afterHoldout } = inputs;
 		const decision = decidePairedPromotion(beforeHoldout, afterHoldout, {
 			threshold: this.pairedDeltaThreshold,
 			confidence: this.confidence,
@@ -6953,81 +6980,46 @@ var HeldOutGate = class {
 		});
 		const literalMedian = medianDelta(beforeHoldout, afterHoldout);
 		const wilcoxon = wilcoxonSignedRank(beforeHoldout, afterHoldout);
-		const { delta: decidingDelta, low, high, label: deltaLabel } = decision;
-		const evidence = {
-			...commonEvidence,
-			medianPairedDelta: literalMedian,
-			deltaStatistic: decision.statistic,
-			decidingDelta,
-			pairedCI: {
-				low,
-				high
-			},
-			pairedPValue: wilcoxon.p,
-			mcnemar: decision.mcnemar,
-			binaryScale: decision.binaryScale,
-			tieFraction: decision.tieFraction
-		};
-		if (decision.indeterminate) return {
-			promote: false,
-			candidateId,
-			baselineId,
-			evidence,
-			reason: `indeterminate_delta: ${decision.indeterminateCause}, so the paired holdout CI is [${fmt(low)}, ${fmt(high)}] and carries no direction — it cannot clear threshold ${fmt(this.pairedDeltaThreshold)} on evidence`,
-			rejectionCode: "indeterminate_delta"
-		};
-		if (!decision.sufficient) return {
-			promote: false,
-			candidateId,
-			baselineId,
-			evidence,
-			reason: `few_runs: ${productiveRuns} paired holdout observations < ${decision.minimumPairs} required for ${deltaLabel} estimation`,
-			rejectionCode: "few_runs"
+		const { delta: decidingDelta, low, high } = decision;
+		return {
+			decision,
+			evidence: {
+				...inputs.commonEvidence,
+				medianPairedDelta: literalMedian,
+				deltaStatistic: decision.statistic,
+				decidingDelta,
+				pairedCI: {
+					low,
+					high
+				},
+				pairedPValue: wilcoxon.p,
+				mcnemar: decision.mcnemar,
+				binaryScale: decision.binaryScale,
+				tieFraction: decision.tieFraction
+			}
 		};
+	}
+	/** Refusals read off the paired delta: a zero-width interval, too few pairs
+	*  for the chosen estimator, or an interval that does not clear the threshold. */
+	refuseOnDelta(inputs, decision, evidence) {
+		const { delta: decidingDelta, low, high, label: deltaLabel } = decision;
+		if (decision.indeterminate) return rejectGate(inputs, evidence, "indeterminate_delta", `indeterminate_delta: ${decision.indeterminateCause}, so the paired holdout CI is [${fmt(low)}, ${fmt(high)}] and carries no direction — it cannot clear threshold ${fmt(this.pairedDeltaThreshold)} on evidence`);
+		if (!decision.sufficient) return rejectGate(inputs, evidence, "few_runs", `few_runs: ${inputs.productiveRuns} paired holdout observations < ${decision.minimumPairs} required for ${deltaLabel} estimation`);
 		const exactTestVetoes = decision.exactTestVetoes;
 		if (!decision.clearsThreshold || exactTestVetoes) {
 			const detail = exactTestVetoes ? ` McNemar exact p=${decision.mcnemar?.pValue.toExponential(2)} does not reject at α=${fmt(1 - this.confidence)}.` : decision.methodDetail;
-			return {
-				promote: false,
-				candidateId,
-				baselineId,
-				evidence,
-				reason: `negative_delta: paired holdout ${deltaLabel} Δ=${fmt(decidingDelta)} CI=[${fmt(low)}, ${fmt(high)}] does not clear threshold ${fmt(this.pairedDeltaThreshold)}.${detail}`,
-				rejectionCode: "negative_delta"
-			};
+			return rejectGate(inputs, evidence, "negative_delta", `negative_delta: paired holdout ${deltaLabel} Δ=${fmt(decidingDelta)} CI=[${fmt(low)}, ${fmt(high)}] does not clear threshold ${fmt(this.pairedDeltaThreshold)}.${detail}`);
 		}
-		if (overfitGap > baselineOverfitGap + this.overfitGapThreshold) return {
-			promote: false,
-			candidateId,
-			baselineId,
-			evidence,
-			reason: `overfit_gap: candidate gap=${fmt(overfitGap)} exceeds baseline gap=${fmt(baselineOverfitGap)} by more than ${fmt(this.overfitGapThreshold)}`,
-			rejectionCode: "overfit_gap"
-		};
-		if (this.costPerTaskCeiling !== void 0 && medianCandidateCost === null) return {
-			promote: false,
-			candidateId,
-			baselineId,
-			evidence,
-			reason: "missing_cost: candidate cost evidence is incomplete",
-			rejectionCode: "missing_cost"
-		};
-		if (this.costPerTaskCeiling !== void 0 && medianCandidateCost !== null && medianCandidateCost > this.costPerTaskCeiling) return {
-			promote: false,
-			candidateId,
-			baselineId,
-			evidence,
-			reason: `cost_ceiling: candidate median cost $${fmt(medianCandidateCost)} exceeds ceiling $${fmt(this.costPerTaskCeiling)} (baseline $${fmt(medianBaselineCost)})`,
-			rejectionCode: "cost_ceiling"
-		};
-		return {
-			promote: true,
-			candidateId,
-			baselineId,
-			evidence,
-			reason: `promote: paired holdout ${deltaLabel} Δ=${fmt(decidingDelta)} CI=[${fmt(low)}, ${fmt(high)}] over ${productiveRuns} pairs; overfit gap candidate=${fmt(overfitGap)} vs baseline=${fmt(baselineOverfitGap)}; median cost candidate=$${fmt(medianCandidateCost)} vs baseline=$${fmt(medianBaselineCost)}`,
-			rejectionCode: null
-		};
+		return null;
+	}
+	/** The overfit-gap and cost-ceiling refusals, run after the quality gates so
+	*  a cost-driven rejection never masks a quality failure. */
+	refuseOnOverfitOrCost(inputs, evidence, overfitGap, baselineOverfitGap) {
+		const { medianCandidateCost, medianBaselineCost } = inputs;
+		if (overfitGap > baselineOverfitGap + this.overfitGapThreshold) return rejectGate(inputs, evidence, "overfit_gap", `overfit_gap: candidate gap=${fmt(overfitGap)} exceeds baseline gap=${fmt(baselineOverfitGap)} by more than ${fmt(this.overfitGapThreshold)}`);
+		if (this.costPerTaskCeiling !== void 0 && medianCandidateCost === null) return rejectGate(inputs, evidence, "missing_cost", "missing_cost: candidate cost evidence is incomplete");
+		if (this.costPerTaskCeiling !== void 0 && medianCandidateCost !== null && medianCandidateCost > this.costPerTaskCeiling) return rejectGate(inputs, evidence, "cost_ceiling", `cost_ceiling: candidate median cost $${fmt(medianCandidateCost)} exceeds ceiling $${fmt(this.costPerTaskCeiling)} (baseline $${fmt(medianBaselineCost)})`);
+		return null;
 	}
 	/**
 	* Which paired statistic decides this data, and the shape facts behind it —
@@ -7039,60 +7031,15 @@ var HeldOutGate = class {
 		return pairedDecisionShape(before, after, this.deltaStatistic === "median" ? "median" : "mean");
 	}
 };
-function inferCandidateId(candidate, baselineKey) {
-	for (const run of candidate) if (run.candidateId && run.candidateId !== baselineKey) return run.candidateId;
-	return candidate[0]?.candidateId ?? "(unknown candidate)";
-}
-function assertScenarioIdentities(runs) {
-	for (const run of runs) if (typeof run.scenarioId !== "string" || run.scenarioId.trim() === "") throw new Error(`HeldOutGate: run ${run.runId} is missing scenarioId`);
-}
-/**
-* Rows carrying a finite score on one split. RAW (`observedSplitScore`) by
-* choice: the gated runs are already removed by the caller, so applying the
-* gate again here would only zero runs that are no longer in the set, and the
-* reported means must describe the runs that actually decided the promotion.
-*/
-function scoredRuns(runs, split) {
-	return runs.filter((run) => {
-		if (run.splitTag !== split) return false;
-		const v = observedSplitScore(run, split);
-		return typeof v === "number" && Number.isFinite(v);
-	});
-}
-/** Every row tagged to one split, scored or not — the work the split was
-*  DEALT, as opposed to the work it managed to measure. */
-function dealtRuns(runs, split) {
-	return runs.filter((run) => run.splitTag === split);
-}
-function hasFiniteScore(run, split) {
-	const v = observedSplitScore(run, split);
-	return typeof v === "number" && Number.isFinite(v);
-}
-/**
-* Partition one split's dealt work into answered / unscored / one-armed.
-*
-* Pairs the UNFILTERED rows with the same `pairRunRecords` the decision uses,
-* so the denominator comes out of the same identity rules as the numerator and
-* cannot drift from it. Deliberately a SECOND pairing rather than a widening of
-* the decision's own: the decision keeps pairing exactly the rows it always
-* paired, so this check can only ever add a refusal, never move a verdict that
-* was already being made on a complete set.
-*/
-function splitCoverage(baseline, candidate, split) {
-	const pairing = pairRunRecords(dealtRuns(baseline, split), dealtRuns(candidate, split));
-	let answered = 0;
-	for (const pair of pairing.pairs) if (hasFiniteScore(pair.baseline, split) && hasFiniteScore(pair.treatment, split)) answered += 1;
-	const unscoredPairs = pairing.pairs.length - answered;
-	const candidateOnly = pairing.unpairedTreatment.length;
-	const baselineOnly = pairing.unpairedBaseline.length;
-	const dealt = pairing.pairs.length + candidateOnly + baselineOnly;
+/** A refusal verdict carrying the evidence gathered so far. */
+function rejectGate(inputs, evidence, rejectionCode, reason) {
 	return {
-		dealt,
-		answered,
-		unscoredPairs,
-		candidateOnly,
-		baselineOnly,
-		coverage: dealt === 0 ? 0 : answered / dealt
+		promote: false,
+		candidateId: inputs.candidateId,
+		baselineId: inputs.baselineId,
+		evidence,
+		reason,
+		rejectionCode
 	};
 }
 function describeCoverage(split, cov) {
@@ -7103,36 +7050,12 @@ function describeCoverage(split, cov) {
 	].filter((part) => part !== null);
 	return `${split} scored ${cov.answered} of ${cov.dealt} dealt items (coverage ${fmt(cov.coverage)})` + (dark.length > 0 ? ` — ${dark.join(", ")}` : "");
 }
-function meanOrNull(xs) {
-	if (xs.length === 0) return null;
-	return xs.reduce((s, x) => s + x, 0) / xs.length;
-}
-function diffOrNull(a, b) {
-	if (a === null || b === null) return null;
-	return a - b;
-}
 function medianDelta(before, after) {
 	const ds = before.map((b, i) => after[i] - b).sort((x, y) => x - y);
 	if (ds.length === 0) throw new Error("HeldOutGate: median delta requires at least one pair");
 	const mid = Math.floor(ds.length / 2);
 	return ds.length % 2 === 0 ? (ds[mid - 1] + ds[mid]) / 2 : ds[mid];
 }
-function medianFinite(xs) {
-	const ys = xs.filter((x) => Number.isFinite(x)).sort((x, y) => x - y);
-	if (ys.length === 0) return null;
-	const mid = Math.floor(ys.length / 2);
-	return ys.length % 2 === 0 ? (ys[mid - 1] + ys[mid]) / 2 : ys[mid];
-}
-function completeCostMedian(runs) {
-	if (runs.length === 0) return null;
-	const costs = [];
-	for (const run of runs) {
-		const usd = run.costProvenance.usd;
-		if (usd === null) return null;
-		costs.push(usd);
-	}
-	return medianFinite(costs);
-}
 function fmt(x) {
 	if (x === null) return "n/a";
 	return x.toFixed(4);