@tangle-network/agent-eval 0.216.1 → 0.218.1

package/dist/index.js

@@ -1,66 +1,64 @@
 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-DVZiqS7K.js";
-import { a as hashCanonical, r as canonicalString } from "./canonical-B2RqLofv.js";
-import { a as CODING_HARNESSES, c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, n as completionVerdict, o as HARNESS_NATIVE_MODEL, r as createLlmCorrectnessChecker, s as agentProfileHash, t as extractProducedState, u as expandProfileAxes } from "./produced-state-BsDmnwxc.js";
-import { d as verifyAgentProfileCell, l as toAgentProfileJson, m as manifestContentDigest, o as buildAgentProfileCell, p as hashJson, r as agentProfileCellKey, s as groupRunsByAgentProfileCell, t as AGENT_PROFILE_KINDS, u as validateAgentProfileCell } from "./agent-profile-cell-BK8mlqlq.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-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 { a as isToolSpan, i as isLlmSpan, r as isJudgeSpan, t as FAILURE_CLASSES } from "./schema-CSf6qWgZ.js";
-import { a as parseRunRecordSafe, c as validateRunRecord, i as modelHasSnapshot, n as UNKNOWN_MODEL, o as runTaskScore, r as isRunRecord, s as searchCellRunId, t as RunRecordValidationError } from "./run-record-Boc5IUTp.js";
-import { i as summaryTable, n as gainHistogram, r as paretoChart } from "./summary-report-V_JACR4Y.js";
+import { i as isToolSpan, n as isJudgeSpan, r as isLlmSpan, t as FAILURE_CLASSES } from "./schema-Bt2vLFm3.js";
+import { a as parseRunRecordSafe, c as validateRunRecord, i as modelHasSnapshot, n as UNKNOWN_MODEL, o as runTaskScore, r as isRunRecord, t as RunRecordValidationError } from "./run-record-DhEJgoPz.js";
+import { a as cliffsDelta, c as pairedCohensDz, i as summaryTable, n as gainHistogram, o as cohensD, s as interpretCliffs } from "./summary-report-BsXJoYX5.js";
 import { t as interpolatedQuantile } from "./quantile--0yb07pD.js";
-import { a as medianInPlace, i as makeRng, t as assertFiniteSample } from "./internal-Epl-YBZW.js";
-import { t as mulberry32 } from "./random-ByUSnV9w.js";
-import { a as spearmanR, c as weightedMean, i as ranks, n as partialCredit, o as summarizeNumberSeries, r as pearsonR, s as weightedComposite, t as confidenceInterval } from "./descriptive-DboxPZrG.js";
-import { n as calibrateJudgeContinuous, o as verbosityBias, r as continuousAgreement, t as calibrateJudge } from "./judge-calibration-BpCy5XQl.js";
-import { n as corpusInterRaterAgreementFromJudgeScores, r as interRaterReliability, t as corpusInterRaterAgreement } from "./agreement-irr-BEWLIF3_.js";
-import { i as pairedCohensDz, n as cohensD, r as interpretCliffs, t as cliffsDelta } from "./effect-sizes-BhzEpXMc.js";
-import { a as chiSquaredPValue, c as normalTwoSidedPValue, i as chiSquared, l as studentTTwoSidedPValue, n as iqr, o as fisherExactTwoSided, r as welchsTTest, s as linearRegressionSlope, u as twoByTwoPValue } from "./baseline-Udi_PLuT.js";
-import { n as bonferroni, r as holm, t as benjaminiHochberg } from "./multiplicity-DQUFcbW4.js";
-import { a as pairedRiskDifferenceExact, c as wilson, i as pairedRiskDifference, n as mcnemar, o as pairedRiskDifferenceScore, r as pairedBinaryScale, s as passAtK, t as isBinaryOutcomeVector } from "./paired-binary-CvpFHfKZ.js";
-import { a as pairedDeltaTieFraction, i as pairedBootstrap, n as BOOTSTRAP_GATE_MIN_N, o as pairedSignTest, r as DECISION_PAIRED_DELTA_STATISTIC, s as pairedTTest, t as mean$1 } from "./mean-DHoMiudD.js";
-import { a as requiredSampleSize, i as requiredPairedSampleSize, n as mcnemarRequiredN, r as pairedMde, t as mcnemarPower } from "./power-and-mde-Hj2ubb4B.js";
-import { a as wilcoxonSignedRank, i as mannWhitneyU, n as pairArms, r as pairRunRecords, t as comparePairedArms } from "./paired-arms-CwMGJsrS.js";
-import { t as eProcess } from "./sequential-eprocess-DM_qENCl.js";
-import { i as pairedDeltaTest, n as pairedDecisionShape, r as minimumPairsForPairedDeltaTest, t as decidePairedPromotion } from "./paired-promotion-decision-DsAPYGCm.js";
-import { n as checkCanaries, t as analyzeRuns } from "./analyze-runs-C84irm4i.js";
-import { o as judgeSpans, r as argHash, u as runsForScenario } from "./query-BUCZCK7F.js";
-import { n as contentHash, r as fileVerdictCache, t as canonicalJson } from "./verdict-cache-Bm8EKL2s.js";
-import { J as redTeamReport, K as DEFAULT_RED_TEAM_CORPUS, X as runCanaries, Y as scoreRedTeamOutput, a as transientDispatchFailure, i as quotaExhaustedUntil, o as aggregateRunScore, q as redTeamDataset, rt as runCampaign, s as clamp01, t as llmJudge } from "./llm-judge-CG12SQJq.js";
+import { a as medianInPlace, i as makeRng, t as assertFiniteSample } from "./internal-BTK91Bqt.js";
+import { t as mulberry32 } from "./random-DDDcC7YU.js";
+import { a as spearmanR, c as weightedMean, i as ranks, n as partialCredit, o as summarizeNumberSeries, r as pearsonR, s as weightedComposite, t as confidenceInterval } from "./descriptive-CVNy48rR.js";
+import { n as calibrateJudgeContinuous, o as verbosityBias, r as continuousAgreement, t as calibrateJudge } from "./judge-calibration-BkXMIWA4.js";
+import { n as corpusInterRaterAgreementFromJudgeScores, r as interRaterReliability, t as corpusInterRaterAgreement } from "./agreement-irr-BhAqjluA.js";
+import { a as wilcoxonSignedRank, i as mannWhitneyU, n as pairArms, r as pairRunRecords, t as comparePairedArms } from "./paired-arms-Ct4LTKc1.js";
+import { a as welchsTTest, c as fisherExactTwoSided, d as studentTTwoSidedPValue, f as twoByTwoPValue, i as iqr, l as linearRegressionSlope, n as checkCanaries, o as chiSquared, s as chiSquaredPValue, t as analyzeRuns, u as normalTwoSidedPValue } from "./analyze-runs-DqPJaJ4X.js";
+import { n as bonferroni, r as holm, t as benjaminiHochberg } from "./multiplicity-Sg0U7h8j.js";
+import { a as pairedRiskDifferenceScore, i as pairedRiskDifferenceExact, o as passAtK, r as pairedRiskDifference, s as wilson, t as mcnemar } from "./paired-binary-B_nejA44.js";
+import { i as pairedBootstrap, n as BOOTSTRAP_GATE_MIN_N, o as pairedSignTest, s as pairedTTest, t as mean$1 } from "./mean-BbA_JCzW.js";
+import { a as requiredSampleSize, i as requiredPairedSampleSize, n as mcnemarRequiredN, r as pairedMde, t as mcnemarPower } from "./power-and-mde-N5nU4_Ly.js";
+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-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 { a as CostLedgerPersistenceError, c as costForTokenPricing, i as CostCeilingReachedError, l as costForUsage, n as CostAccountingIncompleteError, o as CostReceiptCaptureError, r as CostCallConflictError, s as CostReservationExceededError, t as CostLedger, u as modelPriceKey } from "./cost-ledger-BP8V4kUQ.js";
-import { C as parseReflectionResponse, L as BackendIntegrityError, N as surfaceContentHash, R as assertRealBackend, S as buildReflectionPrompt, c as verifyAttestation, o as ATTESTATION_ALGORITHM, s as attest, z as summarizeBackendIntegrity } from "./campaign-evidence-Clrn4hBV.js";
-import { c as redactText, l as shareAllowed, n as REDACTION_VERSION, o as redact, r as assessShareSafety, s as redactForShare } from "./redact-B5xXKqQ3.js";
-import { a as makeFinding, i as computeFindingId, o as makeProposalFinding } from "./types-IXD2HJzu.js";
-import { S as requiredPairsForPairedPromotion, n as paretoFrontier, t as dominates, x as pairedPromotionPower } from "./pareto-Cm6ndrWN.js";
-import { r as selfImprove, t as defineAgentEval } from "./define-agent-eval-CNTPzIkp.js";
-import { n as equivalenceVerdict, t as certificationEvidenceDigest } from "./verdict-Dl0tiT1X.js";
-import { t as TraceEmitter } from "./emitter-DbMXUIVP.js";
-import { t as buildTrajectory } from "./trajectory-D_7rLrvE.js";
-import { t as runCounterfactual } from "./counterfactual-Dn3veueY.js";
-import { G as DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS, U as parseFindingSubject, h as TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, l as createBoundedTraceAnalysisStore, m as DEFAULT_TRACE_ANALYST_BUDGETS, t as createTraceAnalyst } from "./kind-factory-BobI5Jy3.js";
-import { _ as completedAnalystReviewQuality, b as validateAnalystReviewDecisions, c as FAILURE_MODE_KIND_SPEC, g as assertUniqueFindingIds, h as analystRunDigest, i as DEFAULT_TRACE_ANALYST_KINDS, m as analystFindingDigest, n as AnalystRegistry, t as buildDefaultAnalystRegistry, v as readAnalystReview, y as snapshotAnalystRun } from "./default-registry-COhk9g36.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-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-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-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-BJ-Pq6yL.js";
 import { OUTPUT_VALUE } from "./trace-attributes.js";
-import { r as extractUsageFromSse, t as extractUsage } from "./extract-usage-BrnzRJ6H.js";
-import { n as InMemoryRawProviderSink, r as NoopRawProviderSink, t as FileSystemRawProviderSink } from "./raw-provider-sink-DoHz4JNG.js";
-import { S as exportRunAsOtlp, T as captureFetchToRawSink, _ as tokenizeDomainWords, d as inferDomainKeywords, g as scoreTraceInsightReadiness, l as describeTraceInsightScope, n as toolSpansToTraceAnalysisStore, o as buildTraceInsightContext, s as buildTraceInsightPrompt, u as domainEvidencePattern, v as analyzeTraces } from "./store-tool-spans-CIX5arAG.js";
-import { n as assertRunCaptured, t as RunIntegrityError } from "./integrity-BXOsAb3i.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";
+import { _ as exportRunAsOtlp, b as captureFetchToRawSink, c as describeTraceInsightScope, g as analyzeTraces, h as tokenizeDomainWords, l as domainEvidencePattern, m as scoreTraceInsightReadiness, n as toolSpansToTraceAnalysisStore, o as buildTraceInsightContext, s as buildTraceInsightPrompt, u as inferDomainKeywords } from "./store-tool-spans-D5l_OfTJ.js";
+import { t as TraceEmitter } from "./emitter-DbMXUIVP.js";
+import { n as assertRunCaptured, t as RunIntegrityError } from "./integrity-W4CADcFc.js";
 import { n as InMemoryTraceStore, t as FileSystemTraceStore } from "./store-BhNuLdJw.js";
 import { t as packageVersion$1 } from "./package-version-D7lQHt_-.js";
-import { a as classifyFailure, i as INFRA_FAILURE_BLAMES, o as classifyFailureReason, r as FAILURE_BLAME, s as failureBlame, t as DEFAULT_FAILURE_REASON_RULES } from "./failure-taxonomy-CjabTATj.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-90jeaCAI.js";
-import "./rollout-DZV1t2Wg.js";
-import { t as mintRolloutRows } from "./mint-QaD5cA0u.js";
-import { n as pairedEvalueSequence, t as evaluateInterimReleaseConfidence } from "./sequential-CzK5DarL.js";
-import { C as LlmResponseError, S as LlmCallError, _ as assertCrossFamily, a as maximumChargeForLlmRequest, c as ModelSubstitutionError, d as assertServedModel, g as CrossFamilyError, h as servedModelAcceptable, i as costReceiptFromLlmError, l as ServedCrossFamilyError, m as checkServedModel, o as backoffMs, p as assertServedModels, r as costReceiptFromLlm, s as isTransientLlmError, u as assertCrossFamilyServed, v as judgeFamily, x as stripFencedJson } from "./llm-client-CyBAoYiX.js";
-import { n as paidJsonChat } from "./chat-json-call-puMArmtW.js";
-import { t as createDspyRlmTraceEngine } from "./dspy-rlm-engine-LRCu61m5.js";
-import { a as diffFindings, n as runSemanticConceptJudge, o as createChatTraceEngine, r as FindingsStore, t as SEMANTIC_CONCEPT_JUDGE_VERSION } from "./semantic-concept-judge-BQF8te0T.js";
-import { a as budgetBreachView, i as failureClusterView, n as computeToolUseMetrics, r as judgeAgreementView, t as toolWasteView } from "./tool-waste-BlesqTqW.js";
-import { _ as analyzeSeries, a as judgeGateDecision, c as snapshotFromJudgeAgreement, i as assertJudgeMayGate, n as JudgeGateRefusedError, o as measureJudgeAgreement, r as addCalibrationVerdicts, s as registerCalibrationSet, t as DEFAULT_JUDGE_GATE_POLICY } from "./judge-gate-iY9s4L44.js";
-import { a as spanRecordsToTraceAnalysisStore, i as otlpTextToTraceAnalysisStore, r as OtlpFileTraceStore } from "./store-otlp-DJ9dtA5x.js";
-import { n as evaluateReleaseConfidence, r as bootstrapCi } from "./release-confidence-CpuP65S5.js";
-import { t as createChatClient } from "./chat-client-l-MVDlDk.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-_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-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";
@@ -3460,37 +3458,6 @@ var ProductClient = class {
 * implementations live with their consumer because they depend on
 * SDK-specific Box / Sandbox types that don't belong in this package.
 */
-/**
-* Host-process runner, mapped onto {@link runBoundedProcess} so the package
-* has one spawn site rather than two.
-*
-* It used `spawnSync` and therefore had none of the bounds that runner exists
-* to provide: a `capMs` timeout killed the direct child and left any
-* descendant it had started running, a killed run could still report exit
-* code 0, captured output was unbounded, and the whole run blocked the event
-* loop. This runner spawns build, test and lint commands, which are exactly
-* the commands most likely to start descendants.
-*
-* It is not the package's last private spawn: `nodeProcessRunner`
-* (`src/trace-repair/docker-environment.ts`) and `runProcess`
-* (`src/campaign/external-optimizer-subprocess.ts`) still spawn their own
-* detached children, and several one-shot `spawnSync` git and CLI calls
-* remain. What this removes is the second spawn behind the `CommandRunner`
-* contract, which is the one that graded build, test and lint commands.
-*
-* Two behaviours the mapping changes on purpose:
-*   - a run with no `capMs` is now bounded by
-*     {@link LOCAL_COMMAND_RUNNER_DEFAULT_CAP_MS} instead of running forever;
-*   - the run no longer blocks the event loop, so a minutes-long `capMs` no
-*     longer stalls everything else in the process.
-*/
-/**
-* Wall clock {@link localCommandRunner} applies when the caller names no
-* `capMs`. It is `runBoundedProcess`'s own default, stated here because this
-* runner used to be unbounded: a consumer whose command runs longer names its
-* own `capMs`, and a run the bound stops says so with `timedOut: true`.
-*/
-const LOCAL_COMMAND_RUNNER_DEFAULT_CAP_MS = DEFAULT_BOUNDED_PROCESS_TIMEOUT_MS;
 const localCommandRunner = {
 	name: "local",
 	async run(input) {
@@ -3771,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) {
@@ -3780,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 {
@@ -4254,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,
@@ -4424,65 +4311,6 @@ async function discoverPersonas(dir, opts = {}) {
 	return results;
 }
 //#endregion
-//#region src/improvement-verdict.ts
-const DEFAULTS = {
-	keepThreshold: 5,
-	regressionThreshold: 5,
-	iqrUnstableAbove: 10,
-	stddevUnstableAbove: Number.POSITIVE_INFINITY,
-	minRepsForVerdict: 3
-};
-function resolveThresholds(t) {
-	const r = {
-		...DEFAULTS,
-		...t ?? {}
-	};
-	if (r.keepThreshold < 0) throw new ValidationError(`improvement-verdict: keepThreshold must be >= 0, got ${r.keepThreshold}`);
-	if (r.regressionThreshold < 0) throw new ValidationError(`improvement-verdict: regressionThreshold must be >= 0, got ${r.regressionThreshold}`);
-	if (r.minRepsForVerdict < 1) throw new ValidationError(`improvement-verdict: minRepsForVerdict must be >= 1, got ${r.minRepsForVerdict}`);
-	return r;
-}
-/**
-* Verdict for a candidate against its parent. Pure — operates on already-computed
-* stats. KEEP/REGRESSION require both sides to have `>= minRepsForVerdict` reps
-* AND the candidate to be `stable`; otherwise the result is NOISE (unstable) or
-* ITERATE (not enough reps / no parent).
-*/
-function improvementVerdict(candidate, parent, thresholds) {
-	const t = resolveThresholds(thresholds);
-	if (!parent) return {
-		verdict: "ITERATE",
-		medianDelta: null,
-		reason: "no parent experiment to compare against"
-	};
-	if (candidate.n < t.minRepsForVerdict || parent.n < t.minRepsForVerdict) return {
-		verdict: "ITERATE",
-		medianDelta: null,
-		reason: `need >= ${t.minRepsForVerdict} reps on both sides (candidate n=${candidate.n}, parent n=${parent.n})`
-	};
-	if (!candidate.stable) return {
-		verdict: "NOISE",
-		medianDelta: candidate.median - parent.median,
-		reason: `candidate unstable (iqr=${candidate.iqr}, stddev=${candidate.stddev.toFixed(2)})`
-	};
-	const medianDelta = candidate.median - parent.median;
-	if (medianDelta > t.keepThreshold) return {
-		verdict: "KEEP",
-		medianDelta,
-		reason: `median +${medianDelta} > +${t.keepThreshold}`
-	};
-	if (medianDelta < -t.regressionThreshold) return {
-		verdict: "REGRESSION",
-		medianDelta,
-		reason: `median ${medianDelta} < -${t.regressionThreshold}`
-	};
-	return {
-		verdict: "NOISE",
-		medianDelta,
-		reason: `median delta ${medianDelta} inside noise band [-${t.regressionThreshold}, +${t.keepThreshold}]`
-	};
-}
-//#endregion
 //#region src/propose-review.ts
 /**
 * Propose / Verify / Review — the core multi-shot primitive.
@@ -4553,14 +4381,14 @@ function jsonlReviewStore(path) {
 		}
 	};
 }
-const DEFAULT_FALLBACK_INSTRUCTION$1 = "Inspect the verification failures above. Fix the critical issues first, then the major ones. Do not restate the failures — act on them.";
+const DEFAULT_FALLBACK_INSTRUCTION = "Inspect the verification failures above. Fix the critical issues first, then the major ones. Do not restate the failures — act on them.";
 async function runProposeReview(config) {
 	const maxShots = config.maxShots ?? 10;
 	const maxWallMs = config.maxWallMs ?? 6e5;
 	const confidenceFloor = config.confidenceFloor ?? .3;
 	const confidenceFloorWindow = config.confidenceFloorWindow ?? 2;
 	const memory = config.memory ?? inMemoryReviewStore();
-	const fallbackInstruction = config.fallbackInstruction ?? DEFAULT_FALLBACK_INSTRUCTION$1;
+	const fallbackInstruction = config.fallbackInstruction ?? DEFAULT_FALLBACK_INSTRUCTION;
 	const emitter = config.store ? new TraceEmitter(config.store) : null;
 	if (emitter) await emitter.startRun({
 		scenarioId: config.scenarioId ?? "propose-review",
@@ -4793,196 +4621,6 @@ function safeJson(x) {
 	}
 }
 //#endregion
-//#region src/propose-review-control.ts
-const DEFAULT_FALLBACK_INSTRUCTION = "Inspect the verification failures above. Fix the critical issues first, then the major ones. Do not restate the failures — act on them.";
-async function runProposeReviewAsControlLoop(config) {
-	const maxShots = config.maxShots ?? 10;
-	const confidenceFloor = config.confidenceFloor ?? .3;
-	const confidenceFloorWindow = config.confidenceFloorWindow ?? 2;
-	const memory = config.memory ?? inMemoryReviewStore();
-	const fallbackInstruction = config.fallbackInstruction ?? DEFAULT_FALLBACK_INSTRUCTION;
-	const failureClassFromVerification = config.failureClassFromVerification ?? controlFailureClassFromVerification;
-	let lowConfidenceStreak = 0;
-	let current = {
-		shot: 0,
-		state: config.initialState,
-		priorReview: null,
-		verification: { pass: false },
-		memory: await memory.load(),
-		completed: false,
-		reviewAvailable: false
-	};
-	return runAgentControlLoop({
-		intent: config.goal,
-		budget: {
-			maxSteps: maxShots,
-			maxWallMs: config.maxWallMs
-		},
-		store: config.store,
-		scenarioId: config.scenarioId ?? "propose-review-control",
-		projectId: config.projectId,
-		variantId: config.variantId,
-		actionFailure: config.actionFailure ?? "stop",
-		observe: () => current,
-		validate: ({ state }) => [objectiveEval({
-			id: "verification",
-			passed: state.verification.pass,
-			score: state.verification.score,
-			severity: "critical",
-			detail: state.verification.pass ? "verification passed" : `verification failed${state.verification.failingLayers?.length ? `: ${state.verification.failingLayers.join(", ")}` : ""}`
-		})],
-		shouldStop: ({ state }) => {
-			if (state.verification.pass) return {
-				stop: true,
-				pass: true,
-				reason: "verification passed",
-				score: state.verification.score
-			};
-			if (state.completed) return {
-				stop: true,
-				pass: false,
-				reason: "reviewer stopped continuation",
-				score: state.verification.score,
-				failureClass: failureClassFromVerification(state.verification)
-			};
-			return {
-				stop: false,
-				pass: false,
-				reason: "verification still failing",
-				score: state.verification.score
-			};
-		},
-		decide: ({ state }) => ({
-			type: "continue",
-			action: {
-				type: "propose-review-shot",
-				shot: state.shot + 1
-			},
-			reason: state.priorReview?.nextShotInstruction ?? fallbackInstruction
-		}),
-		act: async (action, ctx) => {
-			const shot = action.shot;
-			const proposeOut = await config.propose({
-				shot,
-				goal: config.goal,
-				state: current.state,
-				priorReview: current.priorReview,
-				abortSignal: ctx.abortSignal,
-				emitter: ctx.emitter
-			});
-			const nextState = proposeOut.state;
-			const verification = await config.verify(nextState);
-			let review = null;
-			let reviewAvailable = false;
-			let reviewError;
-			let shouldContinue = !verification.pass;
-			if (!verification.pass) try {
-				review = await config.review({
-					shot,
-					goal: config.goal,
-					state: nextState,
-					verification,
-					traceSummary: proposeOut.traceSummary,
-					memory: await memory.load()
-				});
-				reviewAvailable = true;
-				shouldContinue = review.shouldContinue;
-				lowConfidenceStreak = review.confidence <= confidenceFloor ? lowConfidenceStreak + 1 : 0;
-				if (confidenceFloorWindow > 0 && lowConfidenceStreak >= confidenceFloorWindow) shouldContinue = false;
-			} catch (err) {
-				reviewError = err instanceof Error ? err.message : String(err);
-				review = current.priorReview ?? {
-					observations: "Reviewer unavailable.",
-					diagnosis: reviewError,
-					nextShotInstruction: fallbackInstruction,
-					shouldContinue: true,
-					confidence: 0
-				};
-				shouldContinue = true;
-			}
-			else review = {
-				observations: "Verification passed.",
-				diagnosis: "No further revision needed.",
-				nextShotInstruction: "",
-				shouldContinue: false,
-				confidence: 1
-			};
-			const entry = {
-				...review ?? {
-					observations: "No review.",
-					diagnosis: "",
-					nextShotInstruction: fallbackInstruction,
-					shouldContinue,
-					confidence: 0
-				},
-				shot,
-				timestamp: Date.now(),
-				verification: {
-					pass: verification.pass,
-					score: verification.score,
-					failingLayers: verification.failingLayers
-				}
-			};
-			await memory.append(entry);
-			current = {
-				shot,
-				state: nextState,
-				priorReview: review,
-				verification,
-				traceSummary: proposeOut.traceSummary,
-				memory: await memory.load(),
-				completed: verification.pass || !shouldContinue,
-				reviewAvailable,
-				reviewError
-			};
-			return {
-				state: nextState,
-				verification,
-				traceSummary: proposeOut.traceSummary,
-				review,
-				reviewAvailable,
-				reviewError
-			};
-		}
-	});
-}
-function controlFailureClassFromVerification(verification) {
-	if (verification.pass) return void 0;
-	return verification.failingLayers?.length ? "instruction_following" : "unknown";
-}
-//#endregion
-//#region src/analyst/steer-firewall.ts
-/** True iff the finding is a JUDGE VERDICT (an acceptance score lifted into a
-*  finding), identified by provenance set at the lift site — independent of
-*  whatever evidence it cites. */
-function isJudgeVerdict(finding) {
-	return finding.derived_from_judge === true;
-}
-/**
-* THE steer firewall. Fail-loud guard for any path that admits analyst findings
-* as STEERING input (the `f(trace)` role): rejects — naming the offenders — any
-* finding whose provenance is a judge verdict, rather than let `J` leak into the
-* loop. Returns the findings unchanged for chaining.
-*
-* Call this at the chokepoint where a detector that ALSO scores/gates has its
-* findings turned into a steer (the judge-and-steer dual-role case). It keys on
-* provenance, so it correctly admits evidence-less trace-analyst observations and
-* correctly rejects an artifact-citing judge verdict — the cases an evidence
-* check gets backwards.
-*
-* It is necessary, not sufficient: it stops PROVENANCE-tagged verdicts. A judge
-* whose output is laundered through a hand-built finding with no provenance flag
-* is out of its reach — provenance must be honestly set at every judge→finding
-* lift (today: createJudgeAdapter). That is why the integrity rule lives at the
-* lift site, and why ProposeContext.judgeScores?: never is the complementary
-* compile-time tripwire on the obvious direct channel.
-*/
-function assertNoJudgeVerdict(findings, context = "steer") {
-	const leaks = findings.filter(isJudgeVerdict);
-	if (leaks.length > 0) throw new Error(`${context}: a judge verdict cannot be admitted as steering input — that is the held-out judge leaking into the loop. Offending judge-derived findings: [${leaks.map((f) => f.finding_id).join(", ")}]. Steering consumes observations of behavior, never acceptance verdicts.`);
-	return findings;
-}
-//#endregion
 //#region src/analyst/policy-edit.ts
 const POLICY_EDIT_AXES = [
 	"carrier",
@@ -5013,20 +4651,7 @@ var PolicyEditValidationError = class extends ValidationError {
 		this.path = path;
 	}
 };
-const DEFAULT_MIN_SCORE = .7;
-const DEFAULT_MIN_EXPECTED_GAIN = .01;
 const POLICY_EDIT_ID = /^policy-edit:sha256:[0-9a-f]{64}$/;
-function makePolicyEdit(init) {
-	const normalized = normalizePolicyEdit({
-		schemaVersion: "policy-edit/v1",
-		...init,
-		source: normalizeSource(init.source)
-	});
-	return validatePolicyEdit({
-		...normalized,
-		editId: init.editId ?? computePolicyEditId(normalized)
-	});
-}
 function computePolicyEditId(edit) {
 	const { editId: _editId, schemaVersion, ...material } = edit;
 	return `policy-edit:${hashCanonical({
@@ -5080,363 +4705,6 @@ function validatePolicyEditCandidateRecord(input) {
 		policyEdit: validatePolicyEdit(snapshot)
 	};
 }
-function policyEditsFromFindings(findings, opts = {}) {
-	assertNoJudgeVerdict(findings, "policyEditsFromFindings");
-	const edits = [];
-	for (const finding of findings) {
-		const edit = policyEditFromFinding(finding, opts);
-		if (edit) edits.push(edit);
-	}
-	return edits;
-}
-function policyEditFromFinding(finding, opts = {}) {
-	assertNoJudgeVerdict([finding], "policyEditFromFinding");
-	if (!finding.recommended_action?.trim()) return null;
-	const expectedGain = resolveExpectedGain(finding, opts);
-	if (!expectedGain) return null;
-	if (typeof finding.confidence !== "number" || !Number.isFinite(finding.confidence) || finding.confidence < 0 || finding.confidence > 1) return null;
-	const routed = routeFindingSubject(finding.subject, opts);
-	const risk = resolveRisk(finding, opts);
-	return makePolicyEdit({
-		axis: routed.axis,
-		target: routed.target,
-		change: {
-			kind: "text",
-			mode: "append",
-			value: finding.recommended_action.trim()
-		},
-		claim: finding.claim,
-		rationale: finding.rationale,
-		expectedGain,
-		confidence: finding.confidence,
-		risk,
-		validationPlan: finding.validation_plan,
-		source: {
-			findingIds: [finding.finding_id],
-			analystIds: [finding.analyst_id],
-			evidenceRefs: finding.evidence_refs,
-			derivedFromJudge: finding.derived_from_judge
-		}
-	});
-}
-function scorePolicyEditReadiness(edit, opts = {}) {
-	validatePolicyEdit(edit);
-	const minExpectedGain = opts.minExpectedGain ?? DEFAULT_MIN_EXPECTED_GAIN;
-	const requireEvidence = opts.requireEvidence ?? false;
-	const evidenceScore = Math.min(1, edit.source.evidenceRefs.length / 2);
-	const confidenceScore = clamp01$3(edit.confidence);
-	const gainScore = clamp01$3(Math.abs(edit.expectedGain.amount) / Math.max(minExpectedGain * 5, .001));
-	const targetScore = targetSpecificityScore(edit);
-	const riskPenalty = edit.risk === "high" && opts.allowHighRisk !== true ? .35 : edit.risk === "unknown" ? .2 : 0;
-	return clamp01$3((requireEvidence ? .3 * evidenceScore + .25 * confidenceScore + .25 * gainScore + .2 * targetScore : .35 * confidenceScore + .35 * gainScore + .3 * targetScore + .1 * evidenceScore) - riskPenalty);
-}
-function admitPolicyEdit(edit, opts = {}) {
-	const validated = validatePolicyEdit(edit);
-	const score = scorePolicyEditReadiness(validated, opts);
-	const reasons = [];
-	const minExpectedGain = opts.minExpectedGain ?? DEFAULT_MIN_EXPECTED_GAIN;
-	const requireEvidence = opts.requireEvidence ?? false;
-	if (validated.source.derivedFromJudge) reasons.push("source is judge-derived; judge verdicts cannot steer policy edits");
-	if (requireEvidence && validated.source.evidenceRefs.length === 0) reasons.push("missing evidence refs");
-	if (Math.abs(validated.expectedGain.amount) < minExpectedGain) reasons.push(`expected gain below ${minExpectedGain}`);
-	if (validated.risk === "high" && opts.allowHighRisk !== true) reasons.push("high-risk edit requires explicit allowHighRisk");
-	if (score < (opts.minScore ?? DEFAULT_MIN_SCORE)) reasons.push(`readiness score ${score.toFixed(3)} below ${(opts.minScore ?? DEFAULT_MIN_SCORE).toFixed(3)}`);
-	return {
-		edit: validated,
-		decision: reasons.length === 0 ? "admit" : "reject",
-		score,
-		reasons
-	};
-}
-function applyPolicyEditToSurface(surface, edit) {
-	const validated = validatePolicyEdit(edit);
-	if (validated.change.kind === "text") return applyTextChange(surface, validated.change);
-	return applyJsonChange(surface, validated.change);
-}
-function routeFindingSubject(subject, opts) {
-	const parsed = parseFindingSubject(subject);
-	if (!parsed) return {
-		axis: opts.defaultAxis ?? "representation",
-		target: { surface: opts.defaultTargetSurface ?? "prompt" }
-	};
-	return routeParsedSubject(parsed);
-}
-function routeParsedSubject(subject) {
-	switch (subject.kind) {
-		case "system-prompt": return {
-			axis: "representation",
-			target: {
-				surface: "prompt",
-				path: `system-prompt:${subject.section}`
-			}
-		};
-		case "skill": return {
-			axis: "agent_profile",
-			target: {
-				surface: "agent-profile",
-				path: `skill:${subject.name}`
-			}
-		};
-		case "tool-doc": return {
-			axis: "tool_contract",
-			target: {
-				surface: "tool-contract",
-				path: subject.aspect ? `tool-doc:${subject.tool}:${subject.aspect}` : `tool-doc:${subject.tool}`
-			}
-		};
-		case "new-tool": return {
-			axis: "tool_contract",
-			target: {
-				surface: "tool-contract",
-				path: `new-tool:${subject.name}`
-			}
-		};
-		case "mcp": return {
-			axis: "tool_contract",
-			target: {
-				surface: "agent-profile",
-				path: subject.tool ? `mcp:${subject.server}:${subject.tool}` : `mcp:${subject.server}`
-			}
-		};
-		case "hook": return {
-			axis: "agent_profile",
-			target: {
-				surface: "agent-profile",
-				path: `hook:${subject.name}`
-			}
-		};
-		case "subagent": return {
-			axis: "routing",
-			target: {
-				surface: "agent-profile",
-				path: `subagent:${subject.name}`
-			}
-		};
-		case "workflow": return {
-			axis: "routing",
-			target: {
-				surface: "runtime-config",
-				path: `workflow:${subject.name}`
-			}
-		};
-		case "rollout-policy": return {
-			axis: rolloutPolicyAxis(subject.field),
-			target: {
-				surface: "runtime-config",
-				path: `rollout-policy:${subject.field}`
-			}
-		};
-		case "agent-profile": return {
-			axis: "agent_profile",
-			target: {
-				surface: "agent-profile",
-				path: `agent-profile:${subject.field}`
-			}
-		};
-		case "code": return {
-			axis: "representation",
-			target: {
-				surface: "code",
-				path: `code:${subject.path}`
-			}
-		};
-		case "rag": return {
-			axis: "memory",
-			target: {
-				surface: "memory",
-				path: `rag:${subject.corpus}:${subject.docId}`
-			}
-		};
-		case "memory": return {
-			axis: "memory",
-			target: {
-				surface: "memory",
-				path: `memory:${subject.key}`
-			}
-		};
-		case "scaffolding": return {
-			axis: "routing",
-			target: {
-				surface: "runtime-config",
-				path: `scaffolding:${subject.concern}`
-			}
-		};
-		case "output-schema": return {
-			axis: "output_contract",
-			target: {
-				surface: "runtime-config",
-				path: `output-schema:${subject.field}`
-			}
-		};
-		case "knowledge.wiki": return {
-			axis: "memory",
-			target: {
-				surface: "memory",
-				path: `agent-knowledge:wiki:${subject.slug}${subject.heading ? `#${subject.heading}` : ""}`
-			}
-		};
-		case "knowledge.claim": return {
-			axis: "memory",
-			target: {
-				surface: "memory",
-				path: `agent-knowledge:claim:${subject.topic}`
-			}
-		};
-		case "knowledge.raw": return {
-			axis: "memory",
-			target: {
-				surface: "memory",
-				path: `agent-knowledge:raw:${subject.sourceId}`
-			}
-		};
-		case "knowledge.stale": return {
-			axis: "memory",
-			target: {
-				surface: "memory",
-				path: `agent-knowledge:stale:${subject.slug}`
-			}
-		};
-		case "websearch.outdated": return {
-			axis: "memory",
-			target: {
-				surface: "memory",
-				path: `websearch:outdated:${subject.topic}`
-			}
-		};
-		case "prior-run-summary": return {
-			axis: "memory",
-			target: {
-				surface: "memory",
-				path: `prior-run-summary:${subject.topic}`
-			}
-		};
-		case "cluster": return {
-			axis: "representation",
-			target: {
-				surface: "prompt",
-				path: subject.label
-			}
-		};
-	}
-}
-function rolloutPolicyAxis(field) {
-	const normalized = field.toLowerCase();
-	if (/budget|max(?:imum)?[-_. ]?(?:turns?|tokens?|cost)|timeout|deadline/.test(normalized)) return "budget";
-	if (/temperature|top[-_. ]?p|sampling|seed|shots?|parallel|concurrency/.test(normalized)) return "sampling";
-	if (/output|schema|format/.test(normalized)) return "output_contract";
-	return "routing";
-}
-function resolveExpectedGain(finding, opts) {
-	if (typeof opts.expectedGain === "function") return opts.expectedGain(finding) ?? null;
-	if (opts.expectedGain) return opts.expectedGain;
-	return readExpectedGainFromMetadata(finding.metadata);
-}
-function readExpectedGainFromMetadata(metadata) {
-	const raw = readPolicyEditMetadata(metadata)?.expectedGain ?? readPolicyEditMetadata(metadata)?.expected_gain;
-	if (!raw || typeof raw !== "object") return null;
-	const obj = raw;
-	if (typeof obj.metric !== "string" || obj.direction !== "increase" && obj.direction !== "decrease" || typeof obj.amount !== "number" || !Number.isFinite(obj.amount) || obj.amount <= 0) return null;
-	const out = {
-		metric: obj.metric,
-		direction: obj.direction,
-		amount: obj.amount
-	};
-	if (obj.unit === "absolute" || obj.unit === "relative" || obj.unit === "percent" || obj.unit === "score") out.unit = obj.unit;
-	if (typeof obj.rationale === "string") out.rationale = obj.rationale;
-	return out;
-}
-function readPolicyEditMetadata(metadata) {
-	const raw = metadata?.policyEdit ?? metadata?.policy_edit;
-	return raw && typeof raw === "object" ? raw : null;
-}
-function resolveRisk(finding, opts) {
-	if (typeof opts.risk === "function") return opts.risk(finding);
-	if (opts.risk) return opts.risk;
-	const raw = readPolicyEditMetadata(finding.metadata)?.risk;
-	if (raw === "low" || raw === "medium" || raw === "high" || raw === "unknown") return raw;
-	if (finding.severity === "critical" || finding.severity === "high") return "medium";
-	return "low";
-}
-function applyTextChange(surface, change) {
-	if (typeof surface !== "string") throw new PolicyEditValidationError("text policy edits require a string surface", "change");
-	if (change.mode === "append") {
-		if (hasExactTextBlock(surface, change.value)) return surface;
-		return `${surface.trimEnd()}\n\n${change.value}`.trimStart();
-	}
-	if (change.mode === "prepend") {
-		if (hasExactTextBlock(surface, change.value)) return surface;
-		return `${change.value}\n\n${surface.trimStart()}`.trimEnd();
-	}
-	const find = expectNonEmpty(change.find, "change.find");
-	if (!surface.includes(find)) throw new PolicyEditValidationError("replace target not found in surface", "change.find");
-	return surface.replace(find, change.value);
-}
-function applyJsonChange(surface, change) {
-	const root = parseJsonSurface(surface);
-	const path = splitPath(change.path);
-	if (change.mode === "remove") return setJsonAtPath(root, path, void 0, "remove");
-	if (change.mode === "set") return setJsonAtPath(root, path, change.value ?? null, "set");
-	const prior = readJsonAtPath(root, path);
-	return setJsonAtPath(root, path, prior && typeof prior === "object" && !Array.isArray(prior) && change.value && typeof change.value === "object" && !Array.isArray(change.value) ? {
-		...prior,
-		...change.value
-	} : change.value ?? null, "set");
-}
-function parseJsonSurface(surface) {
-	if (typeof surface === "string") try {
-		return JSON.parse(surface);
-	} catch {
-		throw new PolicyEditValidationError("json policy edits require a JSON string surface", "change");
-	}
-	assertJson(surface, "surface");
-	return surface;
-}
-function readJsonAtPath(root, path) {
-	let cursor = root;
-	for (const part of path) {
-		if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) return void 0;
-		cursor = cursor[part];
-	}
-	return cursor;
-}
-function setJsonAtPath(root, path, value, mode) {
-	if (path.length === 0) {
-		if (mode === "remove") return null;
-		return value ?? null;
-	}
-	if (root === null || typeof root !== "object" || Array.isArray(root)) throw new PolicyEditValidationError("json edit root must be an object", "change.path");
-	const out = { ...root };
-	let cursor = out;
-	for (let i = 0; i < path.length - 1; i++) {
-		const key = path[i];
-		const existing = cursor[key];
-		if (mode === "remove" && (!existing || typeof existing !== "object" || Array.isArray(existing))) return out;
-		const next = existing && typeof existing === "object" && !Array.isArray(existing) ? { ...existing } : {};
-		cursor[key] = next;
-		cursor = next;
-	}
-	const leaf = path[path.length - 1];
-	if (mode === "remove") delete cursor[leaf];
-	else cursor[leaf] = value ?? null;
-	return out;
-}
-function normalizePolicyEdit(input) {
-	const out = {
-		schemaVersion: "policy-edit/v1",
-		axis: input.axis,
-		target: normalizeTarget(input.target),
-		change: normalizeChange(input.change),
-		claim: input.claim.trim(),
-		expectedGain: normalizeExpectedGain(input.expectedGain),
-		confidence: input.confidence,
-		risk: input.risk,
-		source: normalizeSource(input.source)
-	};
-	if (input.rationale?.trim()) out.rationale = input.rationale.trim();
-	if (input.validationPlan?.trim()) out.validationPlan = input.validationPlan.trim();
-	if (input.metadata) out.metadata = input.metadata;
-	return out;
-}
 function assertJsonSafe(value, path, ancestors = /* @__PURE__ */ new WeakSet()) {
 	if (value === null || typeof value === "string" || typeof value === "boolean") return;
 	if (typeof value === "number") {
@@ -5458,50 +4726,6 @@ function assertJsonSafe(value, path, ancestors = /* @__PURE__ */ new WeakSet())
 	}
 	ancestors.delete(value);
 }
-function normalizeTarget(target) {
-	const out = { surface: target.surface };
-	if (target.path?.trim()) out.path = target.path.trim();
-	if (target.agentProfileCell) out.agentProfileCell = validateAgentProfileCell(target.agentProfileCell);
-	if (target.label?.trim()) out.label = target.label.trim();
-	return out;
-}
-function normalizeChange(change) {
-	if (change.kind === "text") {
-		const out = {
-			kind: "text",
-			mode: change.mode,
-			value: change.value.trim()
-		};
-		if (change.find?.trim()) out.find = change.find.trim();
-		return out;
-	}
-	const out = {
-		kind: "json",
-		mode: change.mode,
-		path: change.path.trim()
-	};
-	if (change.value !== void 0) out.value = change.value;
-	return out;
-}
-function normalizeExpectedGain(gain) {
-	const out = {
-		metric: gain.metric.trim(),
-		direction: gain.direction,
-		amount: gain.amount
-	};
-	if (gain.unit) out.unit = gain.unit;
-	if (gain.rationale?.trim()) out.rationale = gain.rationale.trim();
-	return out;
-}
-function normalizeSource(source) {
-	const out = {
-		findingIds: uniqueSorted(source.findingIds.map((s) => s.trim()).filter(Boolean)),
-		analystIds: uniqueSorted(source.analystIds.map((s) => s.trim()).filter(Boolean)),
-		evidenceRefs: source.evidenceRefs
-	};
-	if (source.derivedFromJudge) out.derivedFromJudge = true;
-	return out;
-}
 function validateTarget(target) {
 	if (!target || typeof target !== "object") throw new PolicyEditValidationError("expected object", "target");
 	const obj = target;
@@ -5584,14 +4808,6 @@ function assertJson(value, path) {
 	}
 	throw new PolicyEditValidationError("expected JSON-compatible value", path);
 }
-function targetSpecificityScore(edit) {
-	let score = .4;
-	if (edit.target.path) score += .25;
-	if (edit.target.agentProfileCell) score += .15;
-	if (edit.change.kind === "json" || edit.change.mode === "replace") score += .2;
-	else if (edit.change.value.length > 0) score += .1;
-	return clamp01$3(score);
-}
 const FORBIDDEN_PATH_KEYS = /* @__PURE__ */ new Set([
 	"__proto__",
 	"constructor",
@@ -5609,21 +4825,9 @@ function expectLiteral(value, expected, path) {
 function expectString$1(value, path) {
 	if (typeof value !== "string" || value.trim().length === 0) throw new PolicyEditValidationError("expected non-empty string", path);
 }
-function expectNonEmpty(value, path) {
-	expectString$1(value, path);
-	return value;
-}
 function expectConfidence(value, path) {
 	if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) throw new PolicyEditValidationError("expected finite number in [0,1]", path);
 }
-function hasExactTextBlock(surface, value) {
-	const needle = normalizeTextBlock(value);
-	const normalizedSurface = surface.replace(/\r\n/g, "\n");
-	return [...normalizedSurface.split(/\n{2,}/), ...normalizedSurface.split("\n")].some((block) => normalizeTextBlock(block) === needle);
-}
-function normalizeTextBlock(value) {
-	return value.replace(/\r\n/g, "\n").trim();
-}
 function expectOneOf(value, allowed, path) {
 	if (typeof value !== "string" || !allowed.includes(value)) throw new PolicyEditValidationError(`expected one of ${allowed.join(", ")}`, path);
 }
@@ -5635,15 +4839,6 @@ function expectNonEmptyStringArray(value, path) {
 	expectStringArray$1(value, path);
 	if (value.length === 0) throw new PolicyEditValidationError("expected non-empty array", path);
 }
-function uniqueSorted(values) {
-	return [...new Set(values)].sort();
-}
-function clamp01$3(n) {
-	if (!Number.isFinite(n)) return 0;
-	if (n < 0) return 0;
-	if (n > 1) return 1;
-	return n;
-}
 //#endregion
 //#region src/capability-headroom.ts
 /**
@@ -6208,58 +5403,6 @@ function partitionHeldOut(ids, options = {}) {
 function assertFraction(f) {
 	if (!Number.isFinite(f) || f <= 0 || f >= 1) throw new ValidationError(`partitionHeldOut: holdoutFraction must be in (0, 1), got ${f}`);
 }
-/**
-* Partition items into disjoint train, selection and test sets, the three
-* partitions `compareOptimizationMethods` and Runtime `improve()` take.
-*
-* Assignment is per unit: `hashToUnit(unit, seed)` below `testFraction` is
-* test, below `testFraction + selectionFraction` is selection, and the rest is
-* train. A unit therefore keeps its partition as the corpus grows, and items of
-* one unit never straddle two partitions. Fail-loud like `partitionHeldOut`:
-* empty input, a duplicate or empty id, an empty unit, fractions outside
-* (0, 1) or summing to 1 or more, and a partition below its floor all throw.
-* Order within each partition follows the input order.
-*/
-function partitionTrainSelectionTest(items, options = {}) {
-	const seed = options.seed ?? "train-selection-test-v1";
-	const selectionFraction = options.selectionFraction ?? .25;
-	const testFraction = options.testFraction ?? .25;
-	assertSplitFraction("selectionFraction", selectionFraction);
-	assertSplitFraction("testFraction", testFraction);
-	if (selectionFraction + testFraction >= 1) throw new ValidationError(`partitionTrainSelectionTest: selectionFraction + testFraction must be below 1, got ${selectionFraction + testFraction}`);
-	if (items.length === 0) throw new ValidationError("partitionTrainSelectionTest: no items supplied");
-	const unitOf = options.unitOf ?? ((item) => item.id);
-	const seen = /* @__PURE__ */ new Set();
-	const partition = {
-		train: [],
-		selection: [],
-		test: [],
-		seed,
-		selectionFraction,
-		testFraction
-	};
-	for (const item of items) {
-		if (typeof item.id !== "string" || item.id.length === 0) throw new ValidationError(`partitionTrainSelectionTest: ids must be non-empty strings, got ${JSON.stringify(item.id)}`);
-		if (seen.has(item.id)) throw new ValidationError(`partitionTrainSelectionTest: duplicate id "${item.id}" — one item cannot be scored in two partitions`);
-		seen.add(item.id);
-		const unit = unitOf(item);
-		if (typeof unit !== "string" || unit.length === 0) throw new ValidationError(`partitionTrainSelectionTest: item "${item.id}" has no unit`);
-		const position = hashToUnit(unit, seed);
-		if (position < testFraction) partition.test.push(item);
-		else if (position < testFraction + selectionFraction) partition.selection.push(item);
-		else partition.train.push(item);
-	}
-	const floors = [
-		["train", options.minTrain ?? 1],
-		["selection", options.minSelection ?? 1],
-		["test", options.minTest ?? 1]
-	];
-	for (const [name, floor] of floors) if (partition[name].length < floor) throw new ValidationError(`partitionTrainSelectionTest: ${name} has ${partition[name].length} item(s), below the floor of ${floor} (n=${items.length}, selectionFraction=${selectionFraction}, testFraction=${testFraction}, seed=${seed})`);
-	return partition;
-}
-function assertSplitFraction(name, value) {
-	if (!Number.isFinite(value) || value <= 0 || value >= 1) throw new ValidationError(`partitionTrainSelectionTest: ${name} must be in (0, 1), got ${value}`);
-}
 //#endregion
 //#region src/product-benchmark/export.ts
 /**
@@ -7224,9 +6367,6 @@ function parseRuntimeTrajectoryHookEvent(input) {
 function runtimeTrajectoryRecordKey(record, index, recordIdOf) {
 	return stringOrUndefined(recordIdOf?.(record, index)) ?? stringOrUndefined(record.id) ?? `record[${index}]`;
 }
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function stringOrUndefined(value) {
 	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
@@ -7475,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.
@@ -7634,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,
@@ -7691,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,
@@ -7733,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 —
@@ -7819,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) {
@@ -7883,42 +7050,52 @@ 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);
 }
 //#endregion
 //#region src/hidden-criteria-grading.ts
+/**
+* Hidden-criteria grading firewall — grade an agent on criteria it never saw.
+*
+* A trustworthy benchmark splits every scenario's data by WHERE each field is
+* allowed to flow, then proves the held-out / judge-only fields never reach the
+* agent during the run. The coding bench expresses this with four destinations
+* (prompt / develop-against / held-out suite / rubric); this module lifts the
+* domain-FREE core out of it so research, legal, tax, content — any domain —
+* can declare the same routing and get the same firewall enforcement and the
+* same held-out-weighted composite, plugging in its OWN grader.
+*
+* Two reusable pieces, both domain-agnostic:
+*
+*   1. FIELD ROUTING BY DESTINATION. A scenario declares each field's
+*      `FieldDestination`; `assertNoHiddenLeak` is a pure checker that throws if
+*      a grading-only or judge-only field's value appears in what reaches the
+*      agent. The domain decides which fields exist and where they go — the
+*      substrate only enforces "hidden stays hidden".
+*
+*   2. HIDDEN-CRITERIA GRADING. The domain supplies its own grader
+*      `(artifact, hiddenCriteria) => { passRate, total }` — the coding
+*      node-test executor is ONE such grader a consumer plugs in; the substrate
+*      bakes in NO node/test/TS/exec/regex. `gradeOnHidden` runs that grader
+*      behind the firewall and `blendHeldout` composes its pass rate with a
+*      judge score into the final number the leaderboard ranks on.
+*
+* Shape mirrors `treatment-gate`/`authenticity`: pure predicates and pure
+* composition over already-computed values, fail-loud, with the
+* "which field / which weight / which grader" decisions left as parameters and
+* no domain literal anywhere in the module.
+*
+* Lives next to `test-graded-scenario` and `partition-held-out` — it is a
+* scorecard/grading concept that makes sense without a running agent loop.
+*/
 /** The destinations a value must be kept OUT of the agent context for. */
 const hiddenDestinations = /* @__PURE__ */ new Set(["grading-only", "judge-only"]);
 /** True for the destinations whose values must never reach the agent context. */
@@ -7926,26 +7103,6 @@ function isHiddenDestination(destination) {
 	return hiddenDestinations.has(destination);
 }
 /**
-* Route a domain's named fields by destination into the firewall's input shape.
-* The `routing` declares each field's destination; the `values` carry each
-* field's renderable string. A field present in `routing` but missing from
-* `values` is an authoring error (fail loud) — every routed field must have a
-* value the firewall can check.
-*/
-function routeFields(routing, values) {
-	const out = [];
-	for (const name of Object.keys(routing)) {
-		const value = values[name];
-		if (value === void 0) throw new ValidationError(`routed field "${name}" has a destination but no value — every routed field must carry its value`);
-		out.push({
-			name,
-			value,
-			destination: routing[name]
-		});
-	}
-	return out;
-}
-/**
 * The FIREWALL. Throws `ValidationError` if any `grading-only`/`judge-only`
 * field's value is found inside `agentContext` — the exact text that reaches the
 * agent during the run (its prompt, its seeded files concatenated, whatever the
@@ -7974,34 +7131,6 @@ function assertNoHiddenLeak(fields, agentContext, opts = {}) {
 	}
 	return fields;
 }
-/** Normalize a grader's raw `{passed, total}` into a `HiddenGradeResult` with a
-*  consistent, fail-loud `passRate` — the canonical "honest zero on no-run"
-*  rule, single-sourced so every domain grader gets it. */
-function hiddenGrade(passed, total, notes) {
-	const p = Number.isFinite(passed) && passed > 0 ? Math.floor(passed) : 0;
-	const t = Number.isFinite(total) && total > 0 ? Math.floor(total) : 0;
-	const passRate = t > 0 ? Math.min(1, p / t) : 0;
-	return {
-		passed: Math.min(p, t > 0 ? t : p),
-		total: t,
-		passRate,
-		notes
-	};
-}
-/**
-* Run a domain's hidden-criteria grader behind the firewall. Before grading, it
-* re-asserts the firewall against the agent context the run actually used —
-* proving (at grading time, on real data) that the hidden criteria never
-* reached the agent — then invokes the grader and returns its pass rate. A
-* domain that wants the firewall and the grader wired together in one call uses
-* this; a domain that already asserted the firewall at dispatch time can call
-* its grader directly and feed the result to `blendHeldout`.
-*/
-async function gradeOnHidden(args) {
-	assertNoHiddenLeak(args.firewall.fields, args.firewall.agentContext, args.firewall.options);
-	const result = await args.grader(args.artifact, args.hiddenCriteria, args.signal);
-	return hiddenGrade(result.passed, result.total, result.notes);
-}
 /** Default blend: 0.7 hidden correctness, 0.3 judge quality. The coding bench's
 *  long-standing split — execution truth dominates, style refines. */
 const defaultBlendWeights = {
@@ -8032,33 +7161,6 @@ function blendHeldout(heldoutPassRate, judgeScore, weights = defaultBlendWeights
 	const judge = clampUnit(judgeScore);
 	return w.heldout * heldout + w.judge * judge;
 }
-/**
-* Wrap a judge's `score` so the `composite` it REPORTS is the held-out-weighted
-* blend. The judge still scores its quality dimensions (recorded, secondary),
-* but the composite that downstream selection/scorecard reads becomes
-* `blendHeldout(heldoutPassRate(artifact), judgeComposite, weights)`. The held-
-* out pass rate is read off the artifact via `heldoutPassRate` — already
-* computed before the judge runs — so no second grading pass is needed.
-*
-* Generic over the artifact type, inferred from `heldoutPassRate`, so it
-* composes with both a `campaign` `JudgeConfig.score` and a bare scoring
-* function. The input is the judge's `{ artifact, ... }` — any extra fields
-* (`scenario`, `signal`) ride through untouched via the index signature.
-*/
-function withHeldoutBlend(score, heldoutPassRate, weights = defaultBlendWeights) {
-	return async (input) => {
-		const base = await score(input);
-		if (base.failed) return base;
-		const rate = clampUnit(heldoutPassRate(input.artifact));
-		const composite = blendHeldout(rate, base.composite, weights);
-		const w = normalizeWeights(weights);
-		return {
-			...base,
-			composite,
-			notes: `composite=${composite.toFixed(3)} (held-out ${(rate * 100).toFixed(0)}% × ${w.heldout.toFixed(2)} + quality ${base.composite.toFixed(3)} × ${w.judge.toFixed(2)})` + (base.notes ? ` — ${base.notes}` : "")
-		};
-	};
-}
 function clampUnit(value) {
 	if (!Number.isFinite(value)) return 0;
 	return Math.max(0, Math.min(1, value));
@@ -8141,12 +7243,12 @@ function assertSingleBackend(agent, judge, opts = {}) {
 //#endregion
 //#region src/intent-match-judge.ts
 const INTENT_MATCH_JUDGE_VERSION = "intent-match-judge-v1-2026-04-24";
-const DEFAULT_MODEL = "claude-sonnet-4-6";
-const DEFAULT_TIMEOUT = 3e5;
-const DEFAULT_MAX_TOKENS = 800;
-const DEFAULT_MAX_SOURCE = 25e3;
-const DEFAULT_MAX_PER_FILE = 12e3;
-const DEFAULT_MAX_HTML = 2e4;
+const DEFAULT_MODEL$1 = "claude-sonnet-4-6";
+const DEFAULT_TIMEOUT$1 = 3e5;
+const DEFAULT_MAX_TOKENS$1 = 800;
+const DEFAULT_MAX_SOURCE$1 = 25e3;
+const DEFAULT_MAX_PER_FILE$1 = 12e3;
+const DEFAULT_MAX_HTML$1 = 2e4;
 const INTENT_SCHEMA = {
 	type: "object",
 	additionalProperties: false,
@@ -8164,11 +7266,11 @@ const INTENT_SCHEMA = {
 		}
 	}
 };
-function truncate(body, cap, label) {
+function truncate$1(body, cap, label) {
 	if (body.length <= cap) return body;
 	return `${body.slice(0, cap)}\n… [truncated ${body.length - cap} chars of ${label}]`;
 }
-function buildPrompt(input, opts) {
+function buildPrompt$1(input, opts) {
 	const sourceBlob = input.sourceFiles.filter((f) => f.content.length <= opts.maxPerFileChars).map((f) => `--- FILE: ${f.path} ---\n${f.content}`).join("\n\n");
 	const html = input.servedHtml ?? "";
 	return `You are evaluating whether an agent built THE RIGHT APP for a user request.
@@ -8181,8 +7283,8 @@ project entirely?
 USER REQUEST:
 ${input.userRequest}
 
-${input.artifactLabel ? `ARTIFACT METADATA:\n  name: ${input.artifactLabel}\n  description: ${input.artifactDescription ?? ""}\n\n` : ""}${html ? `SERVED HTML (what the preview returns):\n${truncate(html, opts.maxHtmlChars, "HTML")}\n\n` : ""}SOURCE FILES (the agent's workdir):
-${truncate(sourceBlob, opts.maxSourceChars, "source")}
+${input.artifactLabel ? `ARTIFACT METADATA:\n  name: ${input.artifactLabel}\n  description: ${input.artifactDescription ?? ""}\n\n` : ""}${html ? `SERVED HTML (what the preview returns):\n${truncate$1(html, opts.maxHtmlChars, "HTML")}\n\n` : ""}SOURCE FILES (the agent's workdir):
+${truncate$1(sourceBlob, opts.maxSourceChars, "source")}
 
 Score 0–1:
   1.0 — unmistakably the right app. Even with bugs, gaps, or missing
@@ -8214,12 +7316,12 @@ async function runIntentMatchJudge(input, options) {
 	const start = Date.now();
 	const opts = {
 		chat: options.chat,
-		model: options.model ?? options.chat.defaultModel ?? DEFAULT_MODEL,
-		timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT,
-		maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
-		maxSourceChars: options.maxSourceChars ?? DEFAULT_MAX_SOURCE,
-		maxPerFileChars: options.maxPerFileChars ?? DEFAULT_MAX_PER_FILE,
-		maxHtmlChars: options.maxHtmlChars ?? DEFAULT_MAX_HTML,
+		model: options.model ?? options.chat.defaultModel ?? DEFAULT_MODEL$1,
+		timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT$1,
+		maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS$1,
+		maxSourceChars: options.maxSourceChars ?? DEFAULT_MAX_SOURCE$1,
+		maxPerFileChars: options.maxPerFileChars ?? DEFAULT_MAX_PER_FILE$1,
+		maxHtmlChars: options.maxHtmlChars ?? DEFAULT_MAX_HTML$1,
 		...options.pricing ? { pricing: options.pricing } : {},
 		costLedger: options.costLedger ?? new CostLedger(),
 		costPhase: options.costPhase ?? "judge.intent-match",
@@ -8245,7 +7347,7 @@ async function runIntentMatchJudge(input, options) {
 				content: "You are a holistic code reviewer answering one question: did the agent build the right app for the user. Return strict JSON. No prose outside."
 			}, {
 				role: "user",
-				content: buildPrompt(input, opts)
+				content: buildPrompt$1(input, opts)
 			}],
 			jsonSchema: {
 				name: "intent_match_judge",
@@ -8920,38 +8022,6 @@ function mergeSignals(a, b) {
 * `'test'`-strategy certification: an oracle set IS a small answer key,
 * and certifies nothing outside its own coverage.
 */
-function textInSnapshot(needle, opts = {}) {
-	const id = `text-in-snapshot(${needle})`;
-	return {
-		id,
-		check(obs) {
-			const hay = obs.text ?? "";
-			const found = opts.caseSensitive ? hay.includes(needle) : hay.toLowerCase().includes(needle.toLowerCase());
-			return {
-				id,
-				pass: found,
-				detail: found ? `"${needle}" found` : `"${needle}" not present in observation`,
-				evidence: found ? excerpt(hay, needle, opts.caseSensitive) : void 0
-			};
-		}
-	};
-}
-function urlContains(fragment) {
-	const id = `url-contains(${fragment})`;
-	return {
-		id,
-		check(obs) {
-			const url = obs.url ?? "";
-			const pass = url.toLowerCase().includes(fragment.toLowerCase());
-			return {
-				id,
-				pass,
-				detail: pass ? `url ok (${url})` : `url "${url}" missing "${fragment}"`,
-				evidence: url
-			};
-		}
-	};
-}
 function jsonShape(expected) {
 	const id = `json-shape(${Object.keys(expected).join(",")})`;
 	return {
@@ -8991,77 +8061,6 @@ function jsonShape(expected) {
 		}
 	};
 }
-function regexMatches(pattern) {
-	const id = `regex(${pattern.source})`;
-	return {
-		id,
-		check(obs) {
-			const m = (obs.text ?? "").match(pattern);
-			return {
-				id,
-				pass: m !== null,
-				detail: m ? `matched "${m[0]}"` : `pattern ${pattern.source} not matched`,
-				evidence: m?.[0]
-			};
-		}
-	};
-}
-/**
-* Anti-bot detector — distinguishes genuine failures from blocked navigation
-* (cloudflare, recaptcha, etc). Returns an Oracle that PASSES when no block
-* marker is present; on block, detail names the blocker so runners can tag
-* results as "blocked" rather than "failed". Lifted from browser-agent-driver.
-*/
-function notBlocked() {
-	const id = "not-blocked";
-	const markers = [
-		{
-			name: "cloudflare",
-			re: /just a moment|verifying you are human|cf-chl-|cloudflare/i
-		},
-		{
-			name: "recaptcha",
-			re: /recaptcha|i'?m not a robot|challenge.?form/i
-		},
-		{
-			name: "hcaptcha",
-			re: /hcaptcha/i
-		},
-		{
-			name: "akamai",
-			re: /akamai|pragma: no-cache/i
-		},
-		{
-			name: "perimeterx",
-			re: /perimeterx|px-captcha/i
-		},
-		{
-			name: "rate-limit",
-			re: /rate.?limit|429 too many requests/i
-		},
-		{
-			name: "access-denied",
-			re: /access denied|403 forbidden/i
-		}
-	];
-	return {
-		id,
-		check(obs) {
-			const hay = obs.text ?? "";
-			for (const { name, re } of markers) if (re.test(hay)) return {
-				id,
-				pass: false,
-				detail: `blocked by ${name}`,
-				evidence: (hay.match(re) ?? [])[0]
-			};
-			return {
-				id,
-				pass: true,
-				detail: "no anti-bot block detected"
-			};
-		}
-	};
-}
 /** Run all oracles against one observation and aggregate. */
 function evaluateOracles(obs, oracles) {
 	const results = oracles.map((o) => o.check(obs));
@@ -9088,19 +8087,305 @@ function evaluateOracles(obs, oracles) {
 		}
 	};
 }
-function excerpt(hay, needle, caseSensitive = false) {
-	const haySearch = caseSensitive ? hay : hay.toLowerCase();
-	const needleSearch = caseSensitive ? needle : needle.toLowerCase();
-	const idx = haySearch.indexOf(needleSearch);
-	if (idx === -1) return "";
-	const start = Math.max(0, idx - 20);
-	const end = Math.min(hay.length, idx + needle.length + 20);
-	return (start > 0 ? "…" : "") + hay.slice(start, end) + (end < hay.length ? "…" : "");
-}
 function isObject(v) {
 	return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 //#endregion
+//#region src/produced-state.ts
+function artifactKind(mimeType) {
+	if (!mimeType) return "file";
+	if (mimeType.includes("json")) return "json";
+	if (mimeType.startsWith("text/")) return "text";
+	return "file";
+}
+/**
+* Normalize an emission-ordered stream into its latest observed produced state.
+* Artifacts are keyed by their exact output path (name, then URI, then id);
+* proposals by id. Later observations replace earlier ones, including missing
+* content or a rejected status. An obsolete version cannot prove completion.
+* Distinct paths remain distinct; no path normalization or aliasing is inferred.
+* Results retain first-seen identity order. Tool names describe invocation,
+* not success, and are deduplicated in first-seen order.
+*
+* An artifact without observed content yields empty content, which the
+* completion oracle rejects. This projection does not verify external effects,
+* recover dropped events, or establish freshness beyond the supplied stream.
+*/
+function extractProducedState(events) {
+	const artifacts = /* @__PURE__ */ new Map();
+	const proposals = /* @__PURE__ */ new Map();
+	const toolCalls = [];
+	const seenTools = /* @__PURE__ */ new Set();
+	for (const ev of events) if (ev.type === "tool_call") {
+		const name = ev.toolName;
+		if (name && !seenTools.has(name)) {
+			seenTools.add(name);
+			toolCalls.push(name);
+		}
+	} else if (ev.type === "artifact") {
+		const a = ev;
+		const path = a.name ?? a.uri ?? a.artifactId;
+		artifacts.set(path, {
+			kind: artifactKind(a.mimeType),
+			path,
+			content: a.content ?? ""
+		});
+	} else if (ev.type === "proposal_created") {
+		const p = ev;
+		proposals.set(p.proposalId, {
+			id: p.proposalId,
+			title: p.title,
+			status: p.status ?? "pending",
+			...p.content !== void 0 ? { content: p.content } : {}
+		});
+	}
+	return {
+		artifacts: [...artifacts.values()],
+		proposals: [...proposals.values()],
+		toolCalls
+	};
+}
+//#endregion
+//#region src/semantic-concept-judge.ts
+const DEFAULT_COMPLEXITY_WEIGHTS = {
+	render: 1,
+	integrate: 2,
+	compute: 2.5
+};
+const SEMANTIC_CONCEPT_JUDGE_VERSION = "semantic-concept-judge-v1-2026-04-24";
+const DEFAULT_MAX_SOURCE = 45e3;
+const DEFAULT_MAX_HTML = 3e4;
+const DEFAULT_MAX_PER_FILE = 2e4;
+const DEFAULT_TIMEOUT = 3e5;
+const DEFAULT_MAX_TOKENS = 16e3;
+const DEFAULT_MODEL = "claude-sonnet-4-6";
+const SEMANTIC_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	required: ["summary", "concepts"],
+	properties: {
+		summary: {
+			type: "string",
+			minLength: 20,
+			maxLength: 600
+		},
+		concepts: {
+			type: "array",
+			minItems: 1,
+			items: {
+				type: "object",
+				additionalProperties: false,
+				required: [
+					"concept",
+					"present",
+					"score",
+					"evidence",
+					"severity"
+				],
+				properties: {
+					concept: {
+						type: "string",
+						minLength: 1,
+						maxLength: 120
+					},
+					present: { type: "boolean" },
+					score: {
+						type: "number",
+						minimum: 0,
+						maximum: 10
+					},
+					evidence: {
+						type: "string",
+						minLength: 5,
+						maxLength: 400
+					},
+					severity: {
+						type: "string",
+						enum: [
+							"critical",
+							"major",
+							"minor",
+							"info"
+						]
+					}
+				}
+			}
+		}
+	}
+};
+function truncate(body, cap, label) {
+	if (body.length <= cap) return body;
+	return `${body.slice(0, cap)}\n… [truncated ${body.length - cap} chars of ${label}]`;
+}
+function buildPrompt(input, opts) {
+	const sourceBlob = input.sourceFiles.filter((f) => f.content.length <= opts.maxPerFileChars).map((f) => `--- FILE: ${f.path} ---\n${f.content}`).join("\n\n");
+	const html = input.servedHtml ?? "";
+	return `You are a strict code-review judge evaluating whether an agent's 0-to-1 build actually implements the features the user asked for.
+
+You MUST distinguish:
+  (a) WORKING code that implements the concept (rendered UI, wired handler, real API call),
+  (b) KEYWORD-PRESENT stub (comments mentioning the concept, variable names, TODOs),
+  (c) ABSENT (concept nowhere).
+
+A comment like "// TODO: add mint button" is NOT present — score 2-3. Only count a concept as present if there is real functional code: a rendered component, a call handler wired to state or a network call, a computed value actually used.
+
+USER REQUEST (what the agent was asked to build):
+${input.userRequest}
+
+${input.artifactLabel ? `ARTIFACT METADATA:\n  name: ${input.artifactLabel}\n  description: ${input.artifactDescription ?? ""}\n\n` : ""}EXPECTED CONCEPTS (each must be graded independently):
+${input.expectedConcepts.map((c, i) => `  ${i + 1}. "${c.name}"${c.keywords?.length ? ` — hints: [${c.keywords.slice(0, 6).join(" | ")}]` : ""}`).join("\n")}
+
+${html ? `SERVED HTML (what the preview returns when hit):\n${truncate(html, opts.maxHtmlChars, "HTML")}\n\n` : ""}SOURCE FILES (the agent's workdir):
+${truncate(sourceBlob, opts.maxSourceChars, "source")}
+
+For EACH concept, return:
+  - concept: the concept name as given (match exactly)
+  - present: boolean — does a working implementation exist?
+  - score: 0-10 — 10 = production-ready; 7 = functional but thin; 4 = partial/stubbed; 2 = keyword-only comment; 0 = absent
+  - evidence: cite "<file>:<line>" or "served-html:<selector>" pointing at the strongest supporting code. If the concept is absent or stubbed, explain what's missing.
+  - severity:
+      "info" when present: true AND score >= 7
+      "minor" when present: true AND 4 <= score < 7
+      "major" when present: false OR score < 4
+      "critical" when the concept is not only absent but a core user flow depends on it
+
+Also produce a "summary" (one sentence, 20-600 chars): overall verdict on whether this is a shippable implementation of the user request vs a keyword-dense placeholder.
+
+BE SKEPTICAL. Keyword matching already passed — your job is to catch what keyword matching misses. If the agent shipped a working build, say so. If it shipped a stub, say so. Don't grade on effort.
+
+Return STRICT JSON. No prose outside the JSON.`;
+}
+/**
+* Run the semantic concept judge. Soft-fails to available=false on
+* LLM/JSON errors — callers in a MultiLayerVerifier pipeline can treat
+* that as "skip" rather than "fail."
+*/
+async function runSemanticConceptJudge(input, options) {
+	const start = Date.now();
+	const totalCount = input.expectedConcepts.length;
+	if (totalCount === 0) return {
+		kind: "semantic-concept",
+		version: SEMANTIC_CONCEPT_JUDGE_VERSION,
+		score: 0,
+		presentCount: 0,
+		totalCount: 0,
+		findings: [],
+		summary: "no expected concepts declared",
+		durationMs: 0,
+		costUsd: null,
+		available: false,
+		error: "no expected concepts declared"
+	};
+	const opts = {
+		chat: options.chat,
+		model: options.model ?? options.chat.defaultModel ?? DEFAULT_MODEL,
+		timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT,
+		maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
+		maxSourceChars: options.maxSourceChars ?? DEFAULT_MAX_SOURCE,
+		maxPerFileChars: options.maxPerFileChars ?? DEFAULT_MAX_PER_FILE,
+		maxHtmlChars: options.maxHtmlChars ?? DEFAULT_MAX_HTML,
+		...options.pricing ? { pricing: options.pricing } : {},
+		costLedger: options.costLedger ?? new CostLedger(),
+		costPhase: options.costPhase ?? "judge.semantic-concept",
+		costTags: options.costTags ?? {},
+		signal: options.signal ?? new AbortController().signal,
+		weightConcepts: options.weightConcepts ?? "mean",
+		complexityWeights: {
+			...DEFAULT_COMPLEXITY_WEIGHTS,
+			...options.complexityWeights ?? {}
+		}
+	};
+	const weightForConcept = (spec) => {
+		if (opts.weightConcepts === "mean") return 1;
+		if (spec.weight != null) return spec.weight;
+		if (opts.weightConcepts === "complexity") return opts.complexityWeights[spec.complexity ?? "render"] ?? 1;
+		return 1;
+	};
+	const weightByName = new Map(input.expectedConcepts.map((c) => [c.name, weightForConcept(c)]));
+	let receipt;
+	try {
+		const request = {
+			model: opts.model,
+			messages: [{
+				role: "system",
+				content: "You are a strict code-review judge. Return strict JSON only. No prose outside the JSON. A keyword in a comment is NOT a working implementation."
+			}, {
+				role: "user",
+				content: buildPrompt(input, opts)
+			}],
+			jsonSchema: {
+				name: "semantic_concept_judge",
+				schema: SEMANTIC_SCHEMA
+			},
+			temperature: 0,
+			maxTokens: opts.maxTokens,
+			timeoutMs: opts.timeoutMs
+		};
+		const paid = await paidJsonChat({
+			chat: opts.chat,
+			request,
+			ledger: opts.costLedger,
+			channel: "judge",
+			phase: opts.costPhase,
+			actor: "semantic-concept",
+			tags: opts.costTags,
+			signal: opts.signal,
+			...opts.pricing ? { pricing: opts.pricing } : {}
+		});
+		receipt = paid.receipt;
+		if (!paid.succeeded) throw paid.error;
+		const { value } = paid;
+		if (!value?.concepts || !Array.isArray(value.concepts)) throw new Error("judge returned malformed response — expected array under \"concepts\"");
+		const findings = value.concepts.map((c) => ({
+			concept: String(c.concept),
+			present: Boolean(c.present),
+			score: Math.max(0, Math.min(10, Number(c.score ?? 0))),
+			evidence: String(c.evidence ?? ""),
+			severity: [
+				"critical",
+				"major",
+				"minor",
+				"info"
+			].includes(c.severity) ? c.severity : "info"
+		}));
+		const presentCount = findings.filter((f) => f.present && f.score >= 7).length;
+		let weightSum = 0;
+		let weightedScoreSum = 0;
+		for (const f of findings) {
+			const w = weightByName.get(f.concept) ?? 1;
+			weightSum += w;
+			weightedScoreSum += w * f.score;
+		}
+		const scoreAvg = weightSum > 0 ? weightedScoreSum / weightSum : findings.reduce((a, f) => a + f.score, 0) / Math.max(1, findings.length);
+		return {
+			kind: "semantic-concept",
+			version: SEMANTIC_CONCEPT_JUDGE_VERSION,
+			score: Number((scoreAvg / 10).toFixed(3)),
+			presentCount,
+			totalCount,
+			findings,
+			summary: String(value.summary ?? ""),
+			durationMs: Date.now() - start,
+			costUsd: paid.receipt.costUnknown ? null : paid.receipt.costUsd,
+			available: true
+		};
+	} catch (err) {
+		return {
+			kind: "semantic-concept",
+			version: SEMANTIC_CONCEPT_JUDGE_VERSION,
+			score: 0,
+			presentCount: 0,
+			totalCount,
+			findings: [],
+			summary: "",
+			durationMs: Date.now() - start,
+			costUsd: receipt && !receipt.costUnknown ? receipt.costUsd : null,
+			available: false,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+//#endregion
 //#region src/treatment-gate.ts
 /**
 * Core predicate. Gated (treatment-not-applied) ONLY when telemetry was
@@ -9670,6 +8955,6 @@ function rankRows(rows, weights) {
 	})).sort((a, b) => b.mean - a.mean);
 }
 //#endregion
-export { AGENT_PROFILE_KINDS, ATTESTATION_ALGORITHM, AgentEvalError, AnalystRegistry, BOOTSTRAP_GATE_MIN_N, BackendIntegrityError, BudgetBreachError, BudgetGuard, CODING_HARNESSES, ConfigError, CostAccountingIncompleteError, CostCallConflictError, CostCeilingReachedError, CostLedger, CostLedgerPersistenceError, CostReceiptCaptureError, CostReservationExceededError, CostTracker, CrossFamilyError, DECISION_PAIRED_DELTA_STATISTIC, DEFAULT_BOUNDED_PROCESS_TIMEOUT_MS, DEFAULT_FAILURE_REASON_RULES, DEFAULT_JUDGE_GATE_POLICY, DEFAULT_RED_TEAM_CORPUS, DEFAULT_TRACE_ANALYST_BUDGETS, DEFAULT_TRACE_ANALYST_KINDS, DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS, ERROR_COUNT_PATTERNS, EquivalenceProtocolError, FAILURE_BLAME, FAILURE_CLASSES, FAILURE_MODE_KIND_SPEC, FileSystemFeedbackTrajectoryStore, FileSystemRawProviderSink, FileSystemTraceStore, FindingsStore, HARNESS_NATIVE_MODEL, HeldOutGate, INFRA_FAILURE_BLAMES, InMemoryFeedbackTrajectoryStore, InMemoryRawProviderSink, InMemoryTraceStore, JudgeError, JudgeGateRefusedError, LOCAL_COMMAND_RUNNER_DEFAULT_CAP_MS, LlmCallError, LlmResponseError, MODEL_PRICING, ModelSubstitutionError, MultiLayerVerifier, NoopRawProviderSink, NotFoundError, OUTPUT_VALUE, OtlpFileTraceStore, POLICY_EDIT_CANDIDATE_RECORD_SCHEMA, PairwiseSteeringOptimizer, PolicyEditValidationError, ProductClient, PromptRegistry, REDACTION_VERSION, RunIntegrityError, RunRecordValidationError, SEMANTIC_CONCEPT_JUDGE_VERSION, ServedCrossFamilyError, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TraceEmitter, UNKNOWN_MODEL, VERIFICATION_STRATEGIES, VERIFICATION_STRATEGY_SOURCES, ValidationError, acquisitionPlansForKnowledgeGaps, addCalibrationVerdicts, admitPolicyEdit, agentProfileCellKey, agentProfileHash, agentProfileId, aggregateJudgeVerdicts, aggregateRunScore, analystFindingDigest, analystRunDigest, analystRunToFeedbackTrajectory, analystRunToReviewRequests, analyzeAntiSlop, analyzeRuns, analyzeSeries, analyzeTraces, applyPolicyEditToSurface, argHash, assertCapabilityHeadroom, assertCrossFamily, assertCrossFamilyServed, assertJudgeMayGate, assertNoHiddenLeak, assertNoJudgeVerdict, assertProductBenchmarkRun, assertRealBackend, assertRunCaptured, assertServedModel, assertServedModels, assertSingleBackend, assessShareSafety, assignFeedbackSplit, attest, benjaminiHochberg, blendHeldout, blockingKnowledgeEval, bonferroni, bootstrapCi, budgetBreachView, buildAgentProfileCell, buildDefaultAnalystRegistry, buildEquivalenceRecord, buildReflectionPrompt, buildTraceInsightContext, buildTraceInsightPrompt, buildTrajectory, calibrateJudge, calibrateJudgeContinuous, canonicalJson, capabilityHeadroom, captureFetchToRawSink, certificationEvidenceDigest, checkCanaries, checkServedModel, checkTraceContracts, chiSquared, chiSquaredPValue, clamp01, classifyFailure, classifyFailureReason, cliffsDelta, cohensD, comparePairedArms, compileTraceContractSpec, completionVerdict, computeFindingId, computePolicyEditId, computeToolUseMetrics, confidenceInterval, contentHash, continuousAgreement, controlRunToFeedbackTrajectory, corpusInterRaterAgreement, corpusInterRaterAgreementFromJudgeScores, costForTokenPricing, costForUsage, costReceiptFromLlm, costReceiptFromLlmError, createAntiSlopJudge, createBoundedTraceAnalysisStore, createChatClient, createChatTraceEngine, createDspyRlmTraceEngine, createFeedbackTrajectory, createLlmCorrectnessChecker, createLlmReviewer, createTraceAnalyst, decidePairedPromotion, defaultBlendWeights, defineAgentEval, defineEquivalenceCheck, deployGateLayer, describeTraceInsightScope, diffFindings, diffScorecard, discoverPersonas, domainEvidencePattern, dominates, eProcess, ensembleJudge, equivalenceVerdict, errorStreakDetector, estimateCost, estimateTokens, evaluateActionPolicy, evaluateInterimReleaseConfidence, evaluateOracles, evaluateReleaseConfidence, evaluateTraceContract, expandProfileAxes, explainTraceContract, exportProductBenchmark, exportProductBenchmarkRuns, exportRunAsOtlp, extractErrorCount, extractProducedState, extractUsage, extractUsageFromSse, failureBlame, failureClusterView, feedbackTrajectoriesToDatasetScenarios, feedbackTrajectoriesToOptimizerRows, feedbackTrajectoryToOptimizerRow, fileVerdictCache, fisherExactTwoSided, formatScorecardDiff, gainHistogram, gateTreatmentApplied, gradeOnHidden, gradeSemanticStatus, groupRunsByAgentProfileCell, harnessAxisOf, hashContent, hashJson, hiddenGrade, holm, improvementVerdict, inMemoryReviewStore, inferDomainKeywords, interRaterReliability, interpretCliffs, iqr, isBinaryOutcomeVector, isJudgeSpan, isLlmSpan, isModelPriced, isRunRecord, isToolSpan, isTransientLlmError, jsonShape, jsonlReviewStore, jsonlRunRecordBackend, judgeAgreementView, judgeFamily, judgeGateDecision, judgeSpans, knowledgeReadinessTracePayload, leaderboard, linearRegressionSlope, lintTraceContractSpec, llmJudge, loadScorecard, localCommandRunner, makeFinding, makePolicyEdit, makePolicyEditCandidateRecord, makeProposalFinding, manifestContentDigest, mannWhitneyU, maximumChargeForLlmRequest, mcnemar, mcnemarPower, mcnemarRequiredN, measureJudgeAgreement, minimumPairsForPairedDeltaTest, mintRolloutRows, modelHasSnapshot, modelPriceKey, mulberry32, normalTwoSidedPValue, notBlocked, objectiveEval, observeAll, otlpTextToTraceAnalysisStore, pairArms, pairRunRecords, pairedBinaryScale, pairedBootstrap, pairedCohensDz, pairedDeltaTest, pairedDeltaTieFraction, pairedEvalueSequence, pairedMde, pairedPromotionPower, pairedRiskDifference, pairedRiskDifferenceExact, pairedRiskDifferenceScore, pairedSignTest, pairedTTest, paretoChart, paretoFrontier, parseReflectionResponse, parseRunRecordSafe, partialCredit, partitionHeldOut, partitionTrainSelectionTest, passAtK, pearsonR, policyEditsFromFindings, preflightModels, productBenchmarkRepoIdentity, profile_exports as profile, projectRuntimeTrajectoryEvidence, proposeSynthesisTargets, quotaExhaustedUntil, ranks, readProductBenchmarkManifest, recordRuns, recordRunsToScorecard, redTeamDataset, redTeamReport, redact, redactForShare, redactText, regexMatches, registerCalibrationSet, renderPreferenceMemoryMarkdown, repeatedActionDetector, requiredPairedSampleSize, requiredPairsForPairedPromotion, requiredSampleSize, resolveModelPricing, resolveSeat, routeFields, runAgentControlLoop, runBoundedProcess, runCampaign, runCanaries, runCounterfactual, runEquivalenceCheck, runEvalCampaign, runIntentMatchJudge, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runProposeReview, runProposeReviewAsControlLoop, runSemanticConceptJudge, runTaskScore, runsForScenario, sampleMedian, scoreKnowledgeReadiness, scoreRedTeamOutput, scoreTraceInsightReadiness, searchCellRunId, seatPresets, selfImprove, servedModelAcceptable, shareAllowed, snapshotFromJudgeAgreement, spanRecordsToTraceAnalysisStore, spearmanR, stripFencedJson, studentTTwoSidedPValue, subjectiveEval, summarizeBackendIntegrity, summarizeNumberSeries, summarizePreferenceMemory, summarizeSample, summaryTable, textInSnapshot, toAgentProfileJson, tokenizeDomainWords, toolSpansToTraceAnalysisStore, toolWasteView, traceContract, transientDispatchFailure, twoByTwoPValue, urlContains, userQuestionsForKnowledgeGaps, validatePolicyEdit, validatePolicyEditCandidateRecord, validateRunRecord, verbosityBias, verifyAgentProfileCell, verifyAttestation, verifyCompletion, viteDeployRunner, weightedComposite, weightedMean, welchsTTest, wilcoxonSignedRank, wilson, withAssignedFeedbackSplit, withHeldoutBlend, withJudgeRetry, wranglerDeployRunner };
+export { AGENT_PROFILE_KINDS, ATTESTATION_ALGORITHM, AgentEvalError, AnalystRegistry, BOOTSTRAP_GATE_MIN_N, BackendIntegrityError, BudgetBreachError, BudgetGuard, CODING_HARNESSES, ConfigError, CostAccountingIncompleteError, CostCeilingReachedError, CostLedger, CostTracker, CrossFamilyError, DEFAULT_BOUNDED_PROCESS_TIMEOUT_MS, DEFAULT_JUDGE_GATE_POLICY, DEFAULT_RED_TEAM_CORPUS, DEFAULT_TRACE_ANALYST_BUDGETS, DEFAULT_TRACE_ANALYST_KINDS, ERROR_COUNT_PATTERNS, EquivalenceProtocolError, FAILURE_CLASSES, FAILURE_MODE_KIND_SPEC, FileSystemFeedbackTrajectoryStore, FileSystemRawProviderSink, FileSystemTraceStore, FindingsStore, HARNESS_NATIVE_MODEL, HeldOutGate, InMemoryFeedbackTrajectoryStore, InMemoryRawProviderSink, InMemoryTraceStore, JudgeError, JudgeGateRefusedError, LlmCallError, LlmResponseError, MODEL_PRICING, ModelSubstitutionError, MultiLayerVerifier, NoopRawProviderSink, NotFoundError, OUTPUT_VALUE, OtlpFileTraceStore, PairwiseSteeringOptimizer, ProductClient, PromptRegistry, REDACTION_VERSION, RunIntegrityError, RunRecordValidationError, SEMANTIC_CONCEPT_JUDGE_VERSION, TraceEmitter, UNKNOWN_MODEL, VERIFICATION_STRATEGIES, VERIFICATION_STRATEGY_SOURCES, ValidationError, acquisitionPlansForKnowledgeGaps, addCalibrationVerdicts, agentProfileCellKey, agentProfileHash, agentProfileId, aggregateJudgeVerdicts, aggregateRunScore, analystRunDigest, analystRunToFeedbackTrajectory, analystRunToReviewRequests, analyzeAntiSlop, analyzeRuns, analyzeSeries, analyzeTraces, argHash, assertCapabilityHeadroom, assertCrossFamily, assertCrossFamilyServed, assertJudgeMayGate, assertNoHiddenLeak, assertProductBenchmarkRun, assertRealBackend, assertRunCaptured, assertServedModel, assertServedModels, assertSingleBackend, assessShareSafety, assignFeedbackSplit, attest, benjaminiHochberg, blendHeldout, blockingKnowledgeEval, bonferroni, bootstrapCi, budgetBreachView, buildAgentProfileCell, buildDefaultAnalystRegistry, buildReflectionPrompt, buildTraceInsightContext, buildTraceInsightPrompt, buildTrajectory, calibrateJudge, calibrateJudgeContinuous, canonicalJson, capabilityHeadroom, captureFetchToRawSink, certificationEvidenceDigest, checkCanaries, checkServedModel, checkTraceContracts, chiSquared, chiSquaredPValue, clamp01, classifyFailure, classifyFailureReason, cliffsDelta, cohensD, comparePairedArms, compileTraceContractSpec, completionVerdict, computeFindingId, computeToolUseMetrics, confidenceInterval, contentHash, continuousAgreement, controlRunToFeedbackTrajectory, corpusInterRaterAgreement, corpusInterRaterAgreementFromJudgeScores, costForTokenPricing, costForUsage, costReceiptFromLlm, costReceiptFromLlmError, createAntiSlopJudge, createBoundedTraceAnalysisStore, createChatClient, createChatTraceEngine, createDspyRlmTraceEngine, createFeedbackTrajectory, createLlmCorrectnessChecker, createLlmReviewer, createTraceAnalyst, decidePairedPromotion, defineAgentEval, defineEquivalenceCheck, deployGateLayer, describeTraceInsightScope, diffFindings, diffScorecard, discoverPersonas, domainEvidencePattern, dominates, eProcess, ensembleJudge, equivalenceVerdict, errorStreakDetector, estimateCost, estimateTokens, evaluateActionPolicy, evaluateInterimReleaseConfidence, evaluateOracles, evaluateReleaseConfidence, evaluateTraceContract, expandProfileAxes, explainTraceContract, exportProductBenchmark, exportProductBenchmarkRuns, exportRunAsOtlp, extractErrorCount, extractProducedState, extractUsage, extractUsageFromSse, failureBlame, failureClusterView, feedbackTrajectoriesToDatasetScenarios, feedbackTrajectoriesToOptimizerRows, feedbackTrajectoryToOptimizerRow, fileVerdictCache, fisherExactTwoSided, formatScorecardDiff, gainHistogram, gateTreatmentApplied, gradeSemanticStatus, groupRunsByAgentProfileCell, harnessAxisOf, hashContent, hashJson, holm, inMemoryReviewStore, inferDomainKeywords, interRaterReliability, interpretCliffs, iqr, isJudgeSpan, isLlmSpan, isModelPriced, isRunRecord, isToolSpan, isTransientLlmError, jsonShape, jsonlReviewStore, jsonlRunRecordBackend, judgeAgreementView, judgeFamily, judgeGateDecision, judgeSpans, knowledgeReadinessTracePayload, leaderboard, linearRegressionSlope, lintTraceContractSpec, llmJudge, loadScorecard, localCommandRunner, makeFinding, makePolicyEditCandidateRecord, makeProposalFinding, manifestContentDigest, mannWhitneyU, maximumChargeForLlmRequest, mcnemar, mcnemarPower, mcnemarRequiredN, measureJudgeAgreement, minimumPairsForPairedDeltaTest, mintRolloutRows, modelHasSnapshot, mulberry32, normalTwoSidedPValue, objectiveEval, observeAll, otlpTextToTraceAnalysisStore, pairArms, pairRunRecords, pairedBootstrap, pairedCohensDz, pairedDeltaTest, pairedEvalueSequence, pairedMde, pairedPromotionPower, pairedRiskDifference, pairedRiskDifferenceExact, pairedRiskDifferenceScore, pairedSignTest, pairedTTest, paretoFrontier, parseReflectionResponse, parseRunRecordSafe, partialCredit, partitionHeldOut, passAtK, pearsonR, preflightModels, productBenchmarkRepoIdentity, profile_exports as profile, projectRuntimeTrajectoryEvidence, proposeSynthesisTargets, ranks, readProductBenchmarkManifest, recordRuns, recordRunsToScorecard, redTeamDataset, redTeamReport, redact, redactForShare, redactText, registerCalibrationSet, renderPreferenceMemoryMarkdown, repeatedActionDetector, requiredPairedSampleSize, requiredPairsForPairedPromotion, requiredSampleSize, resolveModelPricing, resolveSeat, runAgentControlLoop, runBoundedProcess, runCampaign, runCanaries, runEquivalenceCheck, runEvalCampaign, runIntentMatchJudge, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runProposeReview, runSemanticConceptJudge, runTaskScore, runsForScenario, sampleMedian, scoreKnowledgeReadiness, scoreRedTeamOutput, scoreTraceInsightReadiness, seatPresets, selfImprove, shareAllowed, snapshotFromJudgeAgreement, spanRecordsToTraceAnalysisStore, spearmanR, stripFencedJson, studentTTwoSidedPValue, subjectiveEval, summarizeBackendIntegrity, summarizeNumberSeries, summarizePreferenceMemory, summarizeSample, summaryTable, toAgentProfileJson, tokenizeDomainWords, toolSpansToTraceAnalysisStore, toolWasteView, traceContract, transientDispatchFailure, twoByTwoPValue, userQuestionsForKnowledgeGaps, validateRunRecord, verbosityBias, verifyAgentProfileCell, verifyAttestation, verifyCompletion, viteDeployRunner, weightedComposite, weightedMean, welchsTTest, wilcoxonSignedRank, wilson, withAssignedFeedbackSplit, withJudgeRetry, wranglerDeployRunner };
 
 //# sourceMappingURL=index.js.map