@tangle-network/agent-eval 0.216.0 → 0.217.1

package/dist/{campaign-BQ-Jujuj.js → campaign-CJGkxAQ6.js}

@@ -1,115 +1,29 @@
-import { s as ValidationError, t as AgentEvalError } from "./errors-Dngq5h35.js";
-import { a as hashCanonical, i as compareCodeUnits, r as canonicalString } from "./canonical-BsZVgBhW.js";
-import { c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, s as agentProfileHash, t as extractProducedState } from "./produced-state-ZCtDBxAE.js";
-import { o as buildAgentProfileCell } from "./agent-profile-cell-BYc0bxsL.js";
-import { r as pairedBootstrap } from "./paired-tests-jbwPdSz5.js";
-import { t as comparePairedArms } from "./paired-arms-DzKn0TfY.js";
-import { o as pairHoldout } from "./statistical-heldout-1Gbmex7v.js";
-import { c as validateRunRecord, i as modelHasSnapshot, n as UNKNOWN_MODEL, o as runTaskScore } from "./run-record-DlTZ_lqe.js";
-import { n as contentHash, t as canonicalJson } from "./verdict-cache-BQEsVy9n.js";
-import { at as resolveRunDir, d as combineComparisonCosts, it as planCampaignRun, lt as cellCachePath, rt as runCampaign, u as executeOptimizationMethod, ut as computeManifestHash, v as labelTrustRank } from "./llm-judge-PXV7Xljl.js";
-import { n as campaignCellToRunRecord, r as projectCampaignCellQuality, t as campaignCellCostProvenance } from "./run-record-ES07wfz9.js";
-import { t as CostAccountingIncompleteError } from "./cost-ledger-D2FnJPBF.js";
-import { B as assertCampaignDesign, N as surfaceContentHash, R as assertRealBackend, W as campaignScenarioIdentity, k as assertCodeSurfaceIdentity, z as summarizeBackendIntegrity } from "./campaign-evidence-OcUciD-N.js";
-import { m as mapConcurrent } from "./journal-DvKCvjty.js";
-import { P as fsCampaignStorage } from "./external-optimizer-subprocess-DcerlZSG.js";
-import "./search-kernel-BztlERLv.js";
-import "./search-ledger-d7V8o9Lk.js";
-import "./search-summary-CBvz3u_S.js";
-import { a as scoreAnalystFindings } from "./benchmark-BywPeAUo.js";
-import "./external-optimizer-process-nnsY5D_4.js";
-import "./skillopt-optimization-method-CCtzralq.js";
-import "./sequential-D-1PPCmM.js";
+import { s as ValidationError, t as AgentEvalError } from "./errors-BcOs5MKW.js";
+import { a as hashCanonical, i as compareCodeUnits, r as canonicalString } from "./canonical-Dq2hOQ8L.js";
+import { c as agentProfileModelId, o as agentProfileHash, r as verifyCompletion, s as agentProfileId, u as harnessAxisOf } from "./completion-verifier-B_jw6C9p.js";
+import { i as buildAgentProfileCell } from "./agent-profile-cell-B1V1gUZs.js";
+import { c as validateRunRecord, i as modelHasSnapshot, n as UNKNOWN_MODEL, o as runTaskScore } from "./run-record-DhEJgoPz.js";
+import { t as comparePairedArms } from "./paired-arms-Ct4LTKc1.js";
+import { i as pairedBootstrap } from "./mean-BbA_JCzW.js";
+import { o as pairHoldout } from "./statistical-heldout-Bksv92Th.js";
+import { n as contentHash, t as canonicalJson } from "./verdict-cache-CL_7tePD.js";
+import { $ as planCampaignRun, Q as runCampaign, et as resolveRunDir, nt as cellCachePath, rt as computeManifestHash, s as executeOptimizationMethod, u as combineComparisonCosts } from "./llm-judge-C8jMTNNG.js";
+import { n as campaignCellToRunRecord, r as projectCampaignCellQuality, t as campaignCellCostProvenance } from "./run-record-CysKLB93.js";
+import { C as assertCodeSurfaceIdentity, D as surfaceContentHash, M as assertRealBackend, N as summarizeBackendIntegrity, P as assertCampaignDesign, R as campaignScenarioIdentity } from "./campaign-evidence-CQYw8_0H.js";
+import { a as mapConcurrent } from "./journal-CR4QikYp.js";
+import { M as fsCampaignStorage } from "./external-optimizer-subprocess-XIHBOSKt.js";
+import "./pareto-BzsxidFD.js";
+import "./search-ledger-TUvB5gWH.js";
+import "./search-summary-DQIvJsSB.js";
+import "./external-optimizer-process-KVFGvYX1.js";
+import "./skillopt-optimization-method-kyL94-ri.js";
+import "./sequential-CimQrbjv.js";
 import { createHash } from "node:crypto";
-import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync } from "node:fs";
 import { z } from "zod";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { devNull, tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
-//#region src/campaign/analyst-surface.ts
-function buildTraceAnalystSurfaceDispatch(options) {
-	return async (surface, scenario, context) => {
-		if (typeof surface !== "string") throw new TypeError(`buildTraceAnalystSurfaceDispatch requires a string prompt, received ${surface.kind}`);
-		return options.analyze({
-			instructions: surface,
-			traceStore: scenario.traceStore,
-			runId: `${context.cellId}:${scenario.id}`,
-			signal: context.signal
-		});
-	};
-}
-function traceAnalystQualityJudge() {
-	return {
-		name: "trace-analyst-quality",
-		judgeVersion: "agent-eval:trace-analyst-quality:v3",
-		dimensions: [
-			{
-				key: "issue_recall",
-				description: "share of labeled issues found"
-			},
-			{
-				key: "finding_precision",
-				description: "share of findings tied to a labeled issue"
-			},
-			{
-				key: "f1",
-				description: "harmonic mean of issue recall and finding precision"
-			},
-			{
-				key: "critical_step_accuracy",
-				description: "share of labeled causal steps cited"
-			},
-			{
-				key: "citation_coverage",
-				description: "share of findings with evidence citations"
-			},
-			{
-				key: "citation_label_agreement",
-				description: "share of citations matching a labeled case location"
-			},
-			{
-				key: "clean",
-				description: "1 when a clean case produces no findings"
-			}
-		],
-		appliesTo: (scenario) => scenario.kind === "trace-analyst" && scenario.labelState !== "unlabeled",
-		score({ artifact, scenario }) {
-			assertScorableScenario(scenario);
-			return traceAnalystJudgeScore(scoreAnalystFindings({
-				id: scenario.id,
-				expectedIssues: scenario.expectedIssues,
-				labeledEvidence: scenario.labeledEvidence
-			}, artifact.findings));
-		}
-	};
-}
-function assertScorableScenario(scenario) {
-	if (scenario.labelState === "unlabeled") throw new TypeError(`trace analyst scenario '${scenario.id}' has no quality labels`);
-	if (scenario.labelState === "positive" && scenario.expectedIssues.length === 0) throw new TypeError(`positive trace analyst scenario '${scenario.id}' requires expected issues`);
-	if (scenario.labelState === "trusted-negative" && scenario.expectedIssues.length > 0) throw new TypeError(`trusted-negative trace analyst scenario '${scenario.id}' cannot contain expected issues`);
-}
-function traceAnalystJudgeScore(score) {
-	const dimensions = {
-		issue_recall: score.issueRecall,
-		finding_precision: score.findingPrecision,
-		f1: score.f1,
-		clean: score.predictionOnLabelEmptyCase ? 0 : 1
-	};
-	if (score.criticalStepAccuracy !== null) dimensions.critical_step_accuracy = score.criticalStepAccuracy;
-	if (score.citationCoverage !== null) dimensions.citation_coverage = score.citationCoverage;
-	if (score.citationLabelAgreement !== null) dimensions.citation_label_agreement = score.citationLabelAgreement;
-	const notes = [
-		`${score.matchedIssueIds.length}/${score.expectedIssueCount} issues found`,
-		`${score.supportedFindingIndexes.length}/${score.supportedFindingIndexes.length + score.unsupportedFindingIndexes.length} findings supported`,
-		`${score.unlabeledEvidence.length} citations outside labeled locations`
-	].join("; ");
-	return {
-		dimensions,
-		composite: score.criticalStepAccuracy === null ? score.f1 : (score.f1 + score.criticalStepAccuracy) / 2,
-		notes
-	};
-}
-//#endregion
 //#region src/campaign/cross-surface-context.ts
 function validateCrossSurfaceInput(input) {
 	assertNonEmptyUnique(input.taskOrder, "taskOrder");
@@ -283,92 +197,7 @@ function arraysEqual(left, right) {
 	return left.length === right.length && left.every((value, index) => value === right[index]);
 }
 //#endregion
-//#region src/campaign/cross-surface-interaction.ts
-/**
-* Task-paired comparison and deterministic selection for independently
-* proposed agent surfaces. Unlike factorial cell-mean attribution, every
-* benefit, regression, and interaction remains attached to its task row.
-*/
-/**
-* Build the complete cross-surface evidence matrix and derive all three frozen
-* candidates. The task/candidate/component orders are part of the input so
-* neither insertion order nor an after-the-fact tie-break can change a result.
-*/
-function analyzeCrossSurfaceInteractions(input) {
-	const context = validateCrossSurfaceInput(input);
-	const baseline = context.candidateById.get(input.baselineCandidateId);
-	const preliminary = context.candidates.map((candidate) => summarizeCandidate(context, candidate, baseline));
-	const baselineSummary = preliminary.find((summary) => summary.candidate.candidateId === input.baselineCandidateId);
-	const summaries = preliminary.map((summary) => summary.candidate.candidateId === input.baselineCandidateId ? summary : {
-		...summary,
-		eligibility: candidateEligibility(context, summary, baselineSummary)
-	});
-	const summaryById = new Map(summaries.map((summary) => [summary.candidate.candidateId, summary]));
-	const eligibleSingles = rankedEligibleSingles(context, summaryById);
-	const interactionReadySingles = rankedInteractionReadySingles(context, summaryById);
-	const pairwise = buildPairwise(context, summaryById, interactionReadySingles, baselineSummary);
-	const selections = selectCandidates(context, summaryById, eligibleSingles, interactionReadySingles, pairwise);
-	const rows = context.candidates.flatMap((candidate) => input.taskOrder.map((taskId) => context.rowsByCandidate.get(candidate.candidateId).get(taskId)));
-	return {
-		taskIds: [...input.taskOrder],
-		componentIds: [...input.componentOrder],
-		candidateIds: [...input.candidateOrder],
-		costMetrics: [...input.costMetricOrder],
-		rows,
-		missingAttempts: rows.filter((row) => row.completeness === "missing"),
-		invalidAttempts: rows.filter((row) => row.completeness === "invalid"),
-		candidates: summaries,
-		pairwise,
-		selections
-	};
-}
-function summarizeCandidate(context, candidate, baseline) {
-	const rows = crossSurfaceRowsFor(context, candidate.candidateId);
-	const outcome = summarizeOutcome(context, rows, crossSurfaceRowsFor(context, baseline.candidateId), candidate.candidateId === baseline.candidateId);
-	const completeScores = rows.filter((row) => row.completeness === "complete").map((row) => row.score);
-	const costs = Object.fromEntries(context.input.costMetricOrder.map((metric) => [metric, distribution(rows.map((row) => row.cost[metric]))]));
-	return {
-		candidate,
-		outcome,
-		score: completeScores.length === 0 ? null : distribution(completeScores),
-		costs,
-		firing: summarizeCandidateEvidence(rows, candidate.componentIds, "fired"),
-		effect: summarizeCandidateEvidence(rows, candidate.componentIds, "effectObserved"),
-		comparisonToBaseline: candidate.candidateId === baseline.candidateId ? null : pairedComparison(context, baseline.candidateId, candidate.candidateId),
-		eligibility: null
-	};
-}
-function summarizeOutcome(context, rows, baselineRows, isBaseline) {
-	const resolvedTaskIds = [];
-	const failedTaskIds = [];
-	const missingTaskIds = [];
-	const invalidTaskIds = [];
-	const benefitTaskIds = [];
-	const regressionTaskIds = [];
-	const comparisonMissingTaskIds = [];
-	for (let index = 0; index < context.input.taskOrder.length; index++) {
-		const row = rows[index];
-		const baseline = baselineRows[index];
-		if (row.completeness === "missing") missingTaskIds.push(row.taskId);
-		else if (row.completeness === "invalid") invalidTaskIds.push(row.taskId);
-		else if (row.pass) resolvedTaskIds.push(row.taskId);
-		else failedTaskIds.push(row.taskId);
-		if (isBaseline) continue;
-		if (row.completeness !== "complete" || baseline.completeness !== "complete") comparisonMissingTaskIds.push(row.taskId);
-		else if (row.pass && !baseline.pass) benefitTaskIds.push(row.taskId);
-		else if (!row.pass && baseline.pass) regressionTaskIds.push(row.taskId);
-	}
-	return {
-		resolvedTaskIds,
-		failedTaskIds,
-		missingTaskIds,
-		invalidTaskIds,
-		benefitTaskIds,
-		regressionTaskIds,
-		comparisonMissingTaskIds,
-		netBenefit: benefitTaskIds.length - regressionTaskIds.length
-	};
-}
+//#region src/campaign/cross-surface-evidence.ts
 function summarizeCandidateEvidence(rows, componentIds, field) {
 	if (componentIds.length === 0) return {
 		byComponent: [],
@@ -413,49 +242,161 @@ function summarizeCandidateEvidence(rows, componentIds, field) {
 		unobservedTaskIds
 	};
 }
-function candidateEligibility(context, summary, baseline) {
-	const reasons = [];
-	if (summary.outcome.missingTaskIds.length > 0) reasons.push("missing_attempt");
-	if (summary.outcome.invalidTaskIds.length > 0) reasons.push("invalid_attempt");
-	if (summary.outcome.comparisonMissingTaskIds.length > 0) reasons.push("baseline_outcome_missing");
-	if (summary.outcome.benefitTaskIds.length <= summary.outcome.regressionTaskIds.length) reasons.push("benefit_not_greater_than_regression");
-	appendEvidenceEligibilityReasons(reasons, summary.firing, context.input.selection.minimumFiringTasks, context.input.selection.requireObservedFiring, "firing_below_minimum", "firing_unobserved");
-	appendEvidenceEligibilityReasons(reasons, summary.effect, context.input.selection.minimumEffectTasks, context.input.selection.requireObservedEffect, "effect_below_minimum", "effect_unobserved");
-	if (!withinCostLimits(context, summary, baseline)) reasons.push("cost_limit_exceeded");
+function summarizePairEvidence(rows, leftComponentId, rightComponentId, field) {
+	const bothTaskIds = [];
+	const leftOnlyTaskIds = [];
+	const rightOnlyTaskIds = [];
+	const neitherTaskIds = [];
+	const unobservedTaskIds = [];
+	for (const row of rows) {
+		const left = evidenceValue(row, leftComponentId, field);
+		const right = evidenceValue(row, rightComponentId, field);
+		if (left === null || right === null) unobservedTaskIds.push(row.taskId);
+		else if (left && right) bothTaskIds.push(row.taskId);
+		else if (left) leftOnlyTaskIds.push(row.taskId);
+		else if (right) rightOnlyTaskIds.push(row.taskId);
+		else neitherTaskIds.push(row.taskId);
+	}
 	return {
-		eligible: reasons.length === 0,
-		reasons: unique(reasons)
+		bothTaskIds,
+		leftOnlyTaskIds,
+		rightOnlyTaskIds,
+		neitherTaskIds,
+		unobservedTaskIds
 	};
 }
-function appendEvidenceEligibilityReasons(reasons, evidence, minimum, requireObserved, belowReason, unobservedReason) {
+function evidenceValue(row, componentId, field) {
+	return row.componentEvidence.find((evidence) => evidence.componentId === componentId)[field];
+}
+function appendEvidenceReasons(reasons, evidence, minimum, requireObserved, belowReason, unobservedReason) {
 	if (evidence.byComponent.some((component) => component.observedTaskIds.length < minimum)) reasons.push(belowReason);
 	if (requireObserved && evidence.byComponent.some((component) => component.unobservedTaskIds.length > 0)) reasons.push(unobservedReason);
 }
-function rankedEligibleSingles(context, summaryById) {
-	return [...context.singleByComponent.values()].map((candidate) => summaryById.get(candidate.candidateId)).filter((summary) => summary.eligibility?.eligible).sort((left, right) => compareSingleSummaries(context, left, right));
-}
+//#endregion
+//#region src/campaign/cross-surface-interaction.ts
 /**
-* A neutral constituent may seed a composition when it has complete, bounded,
-* observed evidence and causes no baseline regression. Individual benefit is
-* deliberately left to the best-single arm rather than used as a pair gate.
+* Task-paired comparison and deterministic selection for independently
+* proposed agent surfaces. Unlike factorial cell-mean attribution, every
+* benefit, regression, and interaction remains attached to its task row.
 */
-function rankedInteractionReadySingles(context, summaryById) {
-	return [...context.singleByComponent.values()].map((candidate) => summaryById.get(candidate.candidateId)).filter((summary) => summary.outcome.regressionTaskIds.length === 0 && summary.eligibility?.reasons.every((reason) => reason === "benefit_not_greater_than_regression")).sort((left, right) => compareSingleSummaries(context, left, right));
+/**
+* Build the complete cross-surface evidence matrix and derive all three frozen
+* candidates. The task/candidate/component orders are part of the input so
+* neither insertion order nor an after-the-fact tie-break can change a result.
+*/
+function analyzeCrossSurfaceInteractions(input) {
+	const context = validateCrossSurfaceInput(input);
+	const baseline = context.candidateById.get(input.baselineCandidateId);
+	const preliminary = context.candidates.map((candidate) => summarizeCandidate(context, candidate, baseline));
+	const baselineSummary = preliminary.find((summary) => summary.candidate.candidateId === input.baselineCandidateId);
+	const summaries = preliminary.map((summary) => summary.candidate.candidateId === input.baselineCandidateId ? summary : {
+		...summary,
+		eligibility: candidateEligibility(context, summary, baselineSummary)
+	});
+	const summaryById = new Map(summaries.map((summary) => [summary.candidate.candidateId, summary]));
+	const eligibleSingles = rankedEligibleSingles(context, summaryById);
+	const interactionReadySingles = rankedInteractionReadySingles(context, summaryById);
+	const pairwise = buildPairwise(context, summaryById, interactionReadySingles, baselineSummary);
+	const selections = selectCandidates(context, summaryById, eligibleSingles, interactionReadySingles, pairwise);
+	const rows = context.candidates.flatMap((candidate) => input.taskOrder.map((taskId) => context.rowsByCandidate.get(candidate.candidateId).get(taskId)));
+	return {
+		taskIds: [...input.taskOrder],
+		componentIds: [...input.componentOrder],
+		candidateIds: [...input.candidateOrder],
+		costMetrics: [...input.costMetricOrder],
+		rows,
+		missingAttempts: rows.filter((row) => row.completeness === "missing"),
+		invalidAttempts: rows.filter((row) => row.completeness === "invalid"),
+		candidates: summaries,
+		pairwise,
+		selections
+	};
 }
-function compareSingleSummaries(context, left, right) {
-	const byNetBenefit = right.outcome.netBenefit - left.outcome.netBenefit;
-	if (byNetBenefit !== 0) return byNetBenefit;
-	const byBenefit = right.outcome.benefitTaskIds.length - left.outcome.benefitTaskIds.length;
-	if (byBenefit !== 0) return byBenefit;
-	const byRegression = left.outcome.regressionTaskIds.length - right.outcome.regressionTaskIds.length;
-	if (byRegression !== 0) return byRegression;
-	for (const metric of context.input.costMetricOrder) {
-		const byCost = left.costs[metric].median - right.costs[metric].median;
-		if (byCost !== 0) return byCost;
+function compareCandidates(context, summaryById, comparatorCandidateId, treatmentCandidateId) {
+	const winsTaskIds = [];
+	const regressionTaskIds = [];
+	const missingTaskIds = [];
+	for (const taskId of context.input.taskOrder) {
+		const comparator = crossSurfaceRowFor(context, comparatorCandidateId, taskId);
+		const treatment = crossSurfaceRowFor(context, treatmentCandidateId, taskId);
+		if (comparator.completeness !== "complete" || treatment.completeness !== "complete") missingTaskIds.push(taskId);
+		else if (treatment.pass && !comparator.pass) winsTaskIds.push(taskId);
+		else if (!treatment.pass && comparator.pass) regressionTaskIds.push(taskId);
 	}
-	const byBytes = left.candidate.artifactBytes - right.candidate.artifactBytes;
-	if (byBytes !== 0) return byBytes;
-	return context.candidateIndex.get(left.candidate.candidateId) - context.candidateIndex.get(right.candidate.candidateId);
+	return {
+		comparatorCandidateId,
+		treatmentCandidateId,
+		winsTaskIds,
+		regressionTaskIds,
+		missingTaskIds,
+		paired: pairedComparison(context, comparatorCandidateId, treatmentCandidateId),
+		relativeCost: relativeCosts(context, summaryById.get(treatmentCandidateId), summaryById.get(comparatorCandidateId))
+	};
+}
+function pairedComparison(context, comparatorCandidateId, treatmentCandidateId) {
+	const rows = [];
+	for (const taskId of context.input.taskOrder) {
+		rows.push(toPairedArmRow(context, crossSurfaceRowFor(context, comparatorCandidateId, taskId)));
+		rows.push(toPairedArmRow(context, crossSurfaceRowFor(context, treatmentCandidateId, taskId)));
+	}
+	return comparePairedArms(rows, {
+		baselineArm: comparatorCandidateId,
+		treatmentArm: treatmentCandidateId,
+		metricNames: ["score", ...context.input.costMetricOrder],
+		bootstrap: {
+			...context.input.bootstrap,
+			statistic: "mean"
+		}
+	});
+}
+function toPairedArmRow(context, row) {
+	const metrics = Object.fromEntries(context.input.costMetricOrder.map((metric) => [metric, row.cost[metric]]));
+	if (row.completeness === "complete") metrics.score = row.score;
+	return {
+		pairKey: row.taskId,
+		arm: row.candidateId,
+		...row.completeness === "complete" ? { pass: row.pass } : {},
+		metrics
+	};
+}
+function relativeCosts(context, treatment, comparator) {
+	return Object.fromEntries(context.input.costMetricOrder.map((metric) => {
+		const treatmentMedian = treatment.costs[metric].median;
+		const comparatorMedian = comparator.costs[metric].median;
+		return [metric, {
+			treatmentMedian,
+			comparatorMedian,
+			medianDelta: treatmentMedian - comparatorMedian,
+			medianRatio: comparatorMedian === 0 ? treatmentMedian === 0 ? 1 : null : treatmentMedian / comparatorMedian
+		}];
+	}));
+}
+function withinCostLimits(context, treatment, baseline) {
+	const relative = relativeCosts(context, treatment, baseline);
+	return Object.entries(context.input.selection.maximumMedianCostRatioToBaseline).every(([metric, limit]) => {
+		const ratio = relative[metric].medianRatio;
+		return ratio !== null && ratio <= limit;
+	});
+}
+function distribution(values) {
+	const sorted = [...values].sort((left, right) => left - right);
+	const total = sorted.reduce((sum, value) => sum + value, 0);
+	const middle = Math.floor(sorted.length / 2);
+	const median = sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+	return {
+		n: sorted.length,
+		min: sorted[0],
+		median,
+		mean: total / sorted.length,
+		max: sorted[sorted.length - 1],
+		total
+	};
+}
+function meanOrNull$1(values) {
+	return values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function unique(values) {
+	return [...new Set(values)];
 }
 function buildPairwise(context, summaryById, interactionReadySingles, baseline) {
 	const interactionReadyIds = new Set(interactionReadySingles.map((summary) => summary.candidate.candidateId));
@@ -682,8 +623,8 @@ function evaluateAddition(context, summaryById, pairByComponents, baseline, curr
 	const comparison = compareCandidates(context, summaryById, current.candidate.candidateId, bundle.candidateId);
 	if (comparison.winsTaskIds.length === 0) reasons.push("no_incremental_resolution");
 	if (comparison.regressionTaskIds.length > 0) reasons.push("incremental_regression");
-	appendBundleEvidenceReasons(reasons, bundleSummary.firing, context.input.selection.minimumFiringTasks, context.input.selection.requireObservedFiring, "firing_below_minimum", "firing_unobserved");
-	appendBundleEvidenceReasons(reasons, bundleSummary.effect, context.input.selection.minimumEffectTasks, context.input.selection.requireObservedEffect, "effect_below_minimum", "effect_unobserved");
+	appendEvidenceReasons(reasons, bundleSummary.firing, context.input.selection.minimumFiringTasks, context.input.selection.requireObservedFiring, "firing_below_minimum", "firing_unobserved");
+	appendEvidenceReasons(reasons, bundleSummary.effect, context.input.selection.minimumEffectTasks, context.input.selection.requireObservedEffect, "effect_below_minimum", "effect_unobserved");
 	if (!withinCostLimits(context, bundleSummary, baseline)) reasons.push("cost_limit_exceeded");
 	return {
 		additionCandidateId: addition.candidate.candidateId,
@@ -708,134 +649,105 @@ function emptyAdditionDecision(addition, additionComponentId, reasons) {
 		eligible: false,
 		selected: false,
 		reasons: unique(reasons)
-	};
-}
-function appendBundleEvidenceReasons(reasons, evidence, minimum, requireObserved, belowReason, unobservedReason) {
-	if (evidence.byComponent.some((component) => component.observedTaskIds.length < minimum)) reasons.push(belowReason);
-	if (requireObserved && evidence.byComponent.some((component) => component.unobservedTaskIds.length > 0)) reasons.push(unobservedReason);
-}
-function compareAdditionDecisions(context, summaryById, left, right) {
-	const byWins = right.incrementalResolutionTaskIds.length - left.incrementalResolutionTaskIds.length;
-	if (byWins !== 0) return byWins;
-	for (const metric of context.input.costMetricOrder) {
-		const byCost = left.incrementalMedianCost[metric] - right.incrementalMedianCost[metric];
-		if (byCost !== 0) return byCost;
-	}
-	const byBytes = summaryById.get(left.additionCandidateId).candidate.artifactBytes - summaryById.get(right.additionCandidateId).candidate.artifactBytes;
-	if (byBytes !== 0) return byBytes;
-	return context.candidateIndex.get(left.additionCandidateId) - context.candidateIndex.get(right.additionCandidateId);
-}
-function compareCandidates(context, summaryById, comparatorCandidateId, treatmentCandidateId) {
-	const winsTaskIds = [];
-	const regressionTaskIds = [];
-	const missingTaskIds = [];
-	for (const taskId of context.input.taskOrder) {
-		const comparator = crossSurfaceRowFor(context, comparatorCandidateId, taskId);
-		const treatment = crossSurfaceRowFor(context, treatmentCandidateId, taskId);
-		if (comparator.completeness !== "complete" || treatment.completeness !== "complete") missingTaskIds.push(taskId);
-		else if (treatment.pass && !comparator.pass) winsTaskIds.push(taskId);
-		else if (!treatment.pass && comparator.pass) regressionTaskIds.push(taskId);
-	}
-	return {
-		comparatorCandidateId,
-		treatmentCandidateId,
-		winsTaskIds,
-		regressionTaskIds,
-		missingTaskIds,
-		paired: pairedComparison(context, comparatorCandidateId, treatmentCandidateId),
-		relativeCost: relativeCosts(context, summaryById.get(treatmentCandidateId), summaryById.get(comparatorCandidateId))
-	};
-}
-function pairedComparison(context, comparatorCandidateId, treatmentCandidateId) {
-	const rows = [];
-	for (const taskId of context.input.taskOrder) {
-		rows.push(toPairedArmRow(context, crossSurfaceRowFor(context, comparatorCandidateId, taskId)));
-		rows.push(toPairedArmRow(context, crossSurfaceRowFor(context, treatmentCandidateId, taskId)));
+	};
+}
+function compareAdditionDecisions(context, summaryById, left, right) {
+	const byWins = right.incrementalResolutionTaskIds.length - left.incrementalResolutionTaskIds.length;
+	if (byWins !== 0) return byWins;
+	for (const metric of context.input.costMetricOrder) {
+		const byCost = left.incrementalMedianCost[metric] - right.incrementalMedianCost[metric];
+		if (byCost !== 0) return byCost;
 	}
-	return comparePairedArms(rows, {
-		baselineArm: comparatorCandidateId,
-		treatmentArm: treatmentCandidateId,
-		metricNames: ["score", ...context.input.costMetricOrder],
-		bootstrap: {
-			...context.input.bootstrap,
-			statistic: "mean"
-		}
-	});
+	const byBytes = summaryById.get(left.additionCandidateId).candidate.artifactBytes - summaryById.get(right.additionCandidateId).candidate.artifactBytes;
+	if (byBytes !== 0) return byBytes;
+	return context.candidateIndex.get(left.additionCandidateId) - context.candidateIndex.get(right.additionCandidateId);
 }
-function toPairedArmRow(context, row) {
-	const metrics = Object.fromEntries(context.input.costMetricOrder.map((metric) => [metric, row.cost[metric]]));
-	if (row.completeness === "complete") metrics.score = row.score;
+function summarizeCandidate(context, candidate, baseline) {
+	const rows = crossSurfaceRowsFor(context, candidate.candidateId);
+	const outcome = summarizeOutcome(context, rows, crossSurfaceRowsFor(context, baseline.candidateId), candidate.candidateId === baseline.candidateId);
+	const completeScores = rows.filter((row) => row.completeness === "complete").map((row) => row.score);
+	const costs = Object.fromEntries(context.input.costMetricOrder.map((metric) => [metric, distribution(rows.map((row) => row.cost[metric]))]));
 	return {
-		pairKey: row.taskId,
-		arm: row.candidateId,
-		...row.completeness === "complete" ? { pass: row.pass } : {},
-		metrics
+		candidate,
+		outcome,
+		score: completeScores.length === 0 ? null : distribution(completeScores),
+		costs,
+		firing: summarizeCandidateEvidence(rows, candidate.componentIds, "fired"),
+		effect: summarizeCandidateEvidence(rows, candidate.componentIds, "effectObserved"),
+		comparisonToBaseline: candidate.candidateId === baseline.candidateId ? null : pairedComparison(context, baseline.candidateId, candidate.candidateId),
+		eligibility: null
 	};
 }
-function summarizePairEvidence(rows, leftComponentId, rightComponentId, field) {
-	const bothTaskIds = [];
-	const leftOnlyTaskIds = [];
-	const rightOnlyTaskIds = [];
-	const neitherTaskIds = [];
-	const unobservedTaskIds = [];
-	for (const row of rows) {
-		const left = evidenceValue(row, leftComponentId, field);
-		const right = evidenceValue(row, rightComponentId, field);
-		if (left === null || right === null) unobservedTaskIds.push(row.taskId);
-		else if (left && right) bothTaskIds.push(row.taskId);
-		else if (left) leftOnlyTaskIds.push(row.taskId);
-		else if (right) rightOnlyTaskIds.push(row.taskId);
-		else neitherTaskIds.push(row.taskId);
+function summarizeOutcome(context, rows, baselineRows, isBaseline) {
+	const resolvedTaskIds = [];
+	const failedTaskIds = [];
+	const missingTaskIds = [];
+	const invalidTaskIds = [];
+	const benefitTaskIds = [];
+	const regressionTaskIds = [];
+	const comparisonMissingTaskIds = [];
+	for (let index = 0; index < context.input.taskOrder.length; index++) {
+		const row = rows[index];
+		const baseline = baselineRows[index];
+		if (row.completeness === "missing") missingTaskIds.push(row.taskId);
+		else if (row.completeness === "invalid") invalidTaskIds.push(row.taskId);
+		else if (row.pass) resolvedTaskIds.push(row.taskId);
+		else failedTaskIds.push(row.taskId);
+		if (isBaseline) continue;
+		if (row.completeness !== "complete" || baseline.completeness !== "complete") comparisonMissingTaskIds.push(row.taskId);
+		else if (row.pass && !baseline.pass) benefitTaskIds.push(row.taskId);
+		else if (!row.pass && baseline.pass) regressionTaskIds.push(row.taskId);
 	}
 	return {
-		bothTaskIds,
-		leftOnlyTaskIds,
-		rightOnlyTaskIds,
-		neitherTaskIds,
-		unobservedTaskIds
+		resolvedTaskIds,
+		failedTaskIds,
+		missingTaskIds,
+		invalidTaskIds,
+		benefitTaskIds,
+		regressionTaskIds,
+		comparisonMissingTaskIds,
+		netBenefit: benefitTaskIds.length - regressionTaskIds.length
 	};
 }
-function relativeCosts(context, treatment, comparator) {
-	return Object.fromEntries(context.input.costMetricOrder.map((metric) => {
-		const treatmentMedian = treatment.costs[metric].median;
-		const comparatorMedian = comparator.costs[metric].median;
-		return [metric, {
-			treatmentMedian,
-			comparatorMedian,
-			medianDelta: treatmentMedian - comparatorMedian,
-			medianRatio: comparatorMedian === 0 ? treatmentMedian === 0 ? 1 : null : treatmentMedian / comparatorMedian
-		}];
-	}));
-}
-function withinCostLimits(context, treatment, baseline) {
-	const relative = relativeCosts(context, treatment, baseline);
-	return Object.entries(context.input.selection.maximumMedianCostRatioToBaseline).every(([metric, limit]) => {
-		const ratio = relative[metric].medianRatio;
-		return ratio !== null && ratio <= limit;
-	});
-}
-function distribution(values) {
-	const sorted = [...values].sort((left, right) => left - right);
-	const total = sorted.reduce((sum, value) => sum + value, 0);
-	const middle = Math.floor(sorted.length / 2);
-	const median = sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+function candidateEligibility(context, summary, baseline) {
+	const reasons = [];
+	if (summary.outcome.missingTaskIds.length > 0) reasons.push("missing_attempt");
+	if (summary.outcome.invalidTaskIds.length > 0) reasons.push("invalid_attempt");
+	if (summary.outcome.comparisonMissingTaskIds.length > 0) reasons.push("baseline_outcome_missing");
+	if (summary.outcome.benefitTaskIds.length <= summary.outcome.regressionTaskIds.length) reasons.push("benefit_not_greater_than_regression");
+	appendEvidenceReasons(reasons, summary.firing, context.input.selection.minimumFiringTasks, context.input.selection.requireObservedFiring, "firing_below_minimum", "firing_unobserved");
+	appendEvidenceReasons(reasons, summary.effect, context.input.selection.minimumEffectTasks, context.input.selection.requireObservedEffect, "effect_below_minimum", "effect_unobserved");
+	if (!withinCostLimits(context, summary, baseline)) reasons.push("cost_limit_exceeded");
 	return {
-		n: sorted.length,
-		min: sorted[0],
-		median,
-		mean: total / sorted.length,
-		max: sorted[sorted.length - 1],
-		total
+		eligible: reasons.length === 0,
+		reasons: unique(reasons)
 	};
 }
-function evidenceValue(row, componentId, field) {
-	return row.componentEvidence.find((evidence) => evidence.componentId === componentId)[field];
+function rankedEligibleSingles(context, summaryById) {
+	return [...context.singleByComponent.values()].map((candidate) => summaryById.get(candidate.candidateId)).filter((summary) => summary.eligibility?.eligible).sort((left, right) => compareSingleSummaries(context, left, right));
 }
-function meanOrNull$1(values) {
-	return values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0) / values.length;
+/**
+* A neutral constituent may seed a composition when it has complete, bounded,
+* observed evidence and causes no baseline regression. Individual benefit is
+* deliberately left to the best-single arm rather than used as a pair gate.
+*/
+function rankedInteractionReadySingles(context, summaryById) {
+	return [...context.singleByComponent.values()].map((candidate) => summaryById.get(candidate.candidateId)).filter((summary) => summary.outcome.regressionTaskIds.length === 0 && summary.eligibility?.reasons.every((reason) => reason === "benefit_not_greater_than_regression")).sort((left, right) => compareSingleSummaries(context, left, right));
 }
-function unique(values) {
-	return [...new Set(values)];
+function compareSingleSummaries(context, left, right) {
+	const byNetBenefit = right.outcome.netBenefit - left.outcome.netBenefit;
+	if (byNetBenefit !== 0) return byNetBenefit;
+	const byBenefit = right.outcome.benefitTaskIds.length - left.outcome.benefitTaskIds.length;
+	if (byBenefit !== 0) return byBenefit;
+	const byRegression = left.outcome.regressionTaskIds.length - right.outcome.regressionTaskIds.length;
+	if (byRegression !== 0) return byRegression;
+	for (const metric of context.input.costMetricOrder) {
+		const byCost = left.costs[metric].median - right.costs[metric].median;
+		if (byCost !== 0) return byCost;
+	}
+	const byBytes = left.candidate.artifactBytes - right.candidate.artifactBytes;
+	if (byBytes !== 0) return byBytes;
+	return context.candidateIndex.get(left.candidate.candidateId) - context.candidateIndex.get(right.candidate.candidateId);
 }
 //#endregion
 //#region src/campaign/fixtures.ts
@@ -1047,264 +959,6 @@ function neutralizationGate(options) {
 	};
 }
 //#endregion
-//#region src/campaign/grounded-reflection.ts
-/**
-* Deterministic per-field diff of call arguments between passing and failing
-* rollouts. A field set by failing rollouts but left unset by passing ones is
-* the classic poison-input signature; a field whose values differ across the
-* split points at the correct value. Feed `text` to the reviser verbatim.
-*/
-function rolloutArgumentDiff(rollouts, opts = {}) {
-	const passThreshold = opts.passThreshold ?? 1;
-	const maxValues = opts.maxValuesPerField ?? 4;
-	const collect = (pass) => {
-		const byField = /* @__PURE__ */ new Map();
-		for (const r of rollouts) {
-			if (pass !== r.score >= passThreshold) continue;
-			for (const c of r.calls) for (const [k, v] of Object.entries(c.args)) {
-				const set = byField.get(k) ?? /* @__PURE__ */ new Set();
-				set.add(String(v));
-				byField.set(k, set);
-			}
-		}
-		return byField;
-	};
-	const passing = collect(true);
-	const failing = collect(false);
-	const lines = [];
-	for (const field of /* @__PURE__ */ new Set([...passing.keys(), ...failing.keys()])) {
-		const pv = [...passing.get(field) ?? []].slice(0, maxValues);
-		const fv = [...failing.get(field) ?? []].slice(0, maxValues);
-		const render = (vals) => vals.length ? JSON.stringify(vals) : "NOT SET (omitted)";
-		lines.push(`  ${field}: passing runs -> ${render(pv)} | failing runs -> ${render(fv)}`);
-	}
-	const lower = (m) => {
-		const out = /* @__PURE__ */ new Set();
-		for (const vals of m.values()) for (const v of vals) out.add(v.toLowerCase());
-		return out;
-	};
-	return {
-		text: lines.join("\n") || "  (no calls observed)",
-		passingValues: lower(passing),
-		failingValues: lower(failing)
-	};
-}
-/**
-* Scan revised artifact text for single-quoted single-word literals (the
-* "use exactly 'new'" pattern) that appear in no passing rollout's argument
-* values. Multi-word quotes pass (they are prose, not prescriptions).
-* Callers should reject on `harmful` (with a bounded retry) and at most log
-* `ungrounded` - see the module header for why the severities differ.
-*/
-function classifyUngroundedLiterals(text, diff) {
-	const ungrounded = /* @__PURE__ */ new Set();
-	for (const m of text.matchAll(/'([a-z][a-z_-]{1,19})'/gi)) {
-		const w = m[1].toLowerCase();
-		if (!diff.passingValues.has(w)) ungrounded.add(w);
-	}
-	const all = [...ungrounded];
-	return {
-		ungrounded: all,
-		harmful: all.filter((w) => diff.failingValues.has(w))
-	};
-}
-//#endregion
-//#region src/campaign/labeled-store/fs-adapter.ts
-/**
-* Filesystem `LabeledScenarioStore` adapter. The default capture sink for
-* traces + eval artifacts. Production deployments typically swap for a
-* Turso/SQLite adapter (same interface).
-*
-* Records land as one JSONL file per source under `<root>/<source>.jsonl`.
-* Each line is a `LabeledScenarioRecord`. Append-only — no in-place edits.
-*
-* Safety properties enforced at write-time:
-*
-*   - **Provenance required**: writes without `source`, `sourceVersionHash`,
-*     `capturedAt`, `redactionStatus` are rejected. Closes the alignment
-*     reviewer's data-poisoning gap.
-*   - **Per-source rate limits**: optional `rateLimitBucket` + `maxWritesPerMinute`
-*     stops a single tenant/source from flooding the store.
-*
-* Safety properties enforced at sample-time:
-*
-*   - **Required split + capturedBefore**: substrate refuses to sample without
-*     an explicit `split` ('train' | 'test') AND a temporal cutoff. Eliminates
-*     accidental train/test contamination.
-*   - **Default training-source filter**: when the store is sampled with
-*     `split: 'train'`, production-trace records are EXCLUDED unless the
-*     caller passes `filter.source: 'production-trace'` explicitly. Closes
-*     the contamination-by-default gap flagged by the senior eval engineer.
-*/
-/** Typed rejection from a labeled-scenario store (bad provenance, rate limit, invalid sample args) — carries a stable string `code`. */
-var LabeledScenarioStoreError = class extends Error {
-	code;
-	constructor(code, message) {
-		super(message);
-		this.code = code;
-		this.name = "LabeledScenarioStoreError";
-	}
-};
-/**
-* Filesystem `LabeledScenarioStore`: appends one JSONL file per source with provenance and
-* rate-limit guards. For tests, local dev, and small workloads — high-throughput lands in Turso.
-*/
-var FsLabeledScenarioStore = class {
-	options;
-	now;
-	rateLimits = /* @__PURE__ */ new Map();
-	constructor(options) {
-		this.options = options;
-		if (!existsSync(options.root)) mkdirSync(options.root, { recursive: true });
-		this.now = options.now ?? Date.now;
-	}
-	async observe(write) {
-		this.assertProvenance(write);
-		this.assertRateLimit(write);
-		const record = this.toRecord(write);
-		appendLine(this.pathForSource(write.source), `${JSON.stringify(record)}\n`);
-	}
-	async sample(args) {
-		if (!args.split) throw new LabeledScenarioStoreError("split_required", "sample() requires an explicit `split` (train | test) — substrate refuses ambiguous reads");
-		if (!args.capturedBefore) throw new LabeledScenarioStoreError("capturedBefore_required", "sample() requires an explicit `capturedBefore` timestamp for temporal-split discipline");
-		const all = [];
-		for (const source of ALL_SOURCES) {
-			if (args.split === "train" && source === "production-trace") {
-				if (!sourceFilterContains(args.filter?.source, "production-trace")) continue;
-			}
-			const path = this.pathForSource(source);
-			if (!existsSync(path)) continue;
-			const lines = readFileSync(path, "utf8").split("\n").filter(Boolean);
-			for (const line of lines) {
-				let record;
-				try {
-					record = JSON.parse(line);
-				} catch {
-					continue;
-				}
-				if (!matchesFilter(record, args, source)) continue;
-				all.push(record);
-			}
-		}
-		all.sort((a, b) => {
-			if (a.capturedAt !== b.capturedAt) return compareCodeUnits(a.capturedAt, b.capturedAt);
-			return compareCodeUnits(a.recordHash, b.recordHash);
-		});
-		return all.slice(0, args.count);
-	}
-	async size() {
-		const bySource = {};
-		const byTrust = {
-			unverified: 0,
-			"verified-signal": 0,
-			"human-rated": 0
-		};
-		let total = 0;
-		for (const source of ALL_SOURCES) {
-			const path = this.pathForSource(source);
-			if (!existsSync(path)) {
-				bySource[source] = 0;
-				continue;
-			}
-			const lines = readFileSync(path, "utf8").split("\n").filter(Boolean);
-			bySource[source] = lines.length;
-			total += lines.length;
-			for (const line of lines) {
-				let trust = "unverified";
-				try {
-					trust = JSON.parse(line).labelTrust ?? "unverified";
-				} catch {}
-				byTrust[trust] += 1;
-			}
-		}
-		return {
-			train: total,
-			test: total,
-			bySource,
-			byTrust
-		};
-	}
-	assertProvenance(write) {
-		if (!write.source) throw new LabeledScenarioStoreError("missing_source", "LabeledScenarioWrite requires `source`");
-		if (!write.sourceVersionHash || write.sourceVersionHash.length === 0) throw new LabeledScenarioStoreError("missing_source_version", "LabeledScenarioWrite requires `sourceVersionHash` (git sha or substrate version)");
-		if (!write.capturedAt) throw new LabeledScenarioStoreError("missing_captured_at", "LabeledScenarioWrite requires `capturedAt` ISO timestamp");
-		if (!write.redactionStatus) throw new LabeledScenarioStoreError("missing_redaction_status", "LabeledScenarioWrite requires explicit `redactionStatus` — raw / redacted-pii / redacted-secrets / fully-redacted");
-		if (!ALL_SOURCES.includes(write.source)) throw new LabeledScenarioStoreError("unknown_source", `LabeledScenarioWrite.source must be one of: ${ALL_SOURCES.join(", ")}`);
-	}
-	assertRateLimit(write) {
-		const cap = this.options.maxWritesPerMinutePerBucket;
-		if (!cap || !write.rateLimitBucket) return;
-		const now = this.now();
-		const windowMs = 6e4;
-		let state = this.rateLimits.get(write.rateLimitBucket);
-		if (!state || now - state.windowStartMs >= windowMs) {
-			state = {
-				bucket: write.rateLimitBucket,
-				windowStartMs: now,
-				count: 0
-			};
-			this.rateLimits.set(write.rateLimitBucket, state);
-		}
-		if (state.count >= cap) throw new LabeledScenarioStoreError("rate_limit_exceeded", `LabeledScenarioStore: bucket ${write.rateLimitBucket} exceeded ${cap} writes/min`);
-		state.count += 1;
-	}
-	toRecord(write) {
-		const recordHash = sha256$1(JSON.stringify({
-			id: write.scenario.id,
-			src: write.source,
-			at: write.capturedAt,
-			ver: write.sourceVersionHash
-		}));
-		return {
-			...write,
-			recordHash,
-			split: "train"
-		};
-	}
-	pathForSource(source) {
-		return join(this.options.root, `${source}.jsonl`);
-	}
-};
-const ALL_SOURCES = [
-	"production-trace",
-	"eval-run",
-	"manual",
-	"red-team",
-	"synthetic"
-];
-function sourceFilterContains(filter, needle) {
-	if (!filter) return false;
-	if (Array.isArray(filter)) return filter.includes(needle);
-	return filter === needle;
-}
-function matchesFilter(record, args, source) {
-	if (args.split === "train" && record.capturedAt >= args.capturedBefore) return false;
-	if (args.split === "test" && record.capturedAt < args.capturedBefore) return false;
-	const f = args.filter;
-	if (!f) return true;
-	if (f.kind && record.scenario.kind !== f.kind) return false;
-	if (f.source) {
-		if (!(Array.isArray(f.source) ? f.source : [f.source]).includes(source)) return false;
-	}
-	if (f.minComposite !== void 0 || f.maxComposite !== void 0) {
-		const composites = Object.values(record.judgeScores).map((s) => s.composite);
-		const max = composites.length === 0 ? 0 : Math.max(...composites);
-		if (f.minComposite !== void 0 && max < f.minComposite) return false;
-		if (f.maxComposite !== void 0 && max > f.maxComposite) return false;
-	}
-	if (f.minTrust !== void 0 && labelTrustRank(record.labelTrust) < labelTrustRank(f.minTrust)) return false;
-	return true;
-}
-function sha256$1(input) {
-	return createHash("sha256").update(input).digest("hex").slice(0, 16);
-}
-function appendLine(path, line) {
-	if (existsSync(path)) {
-		const existing = readFileSync(path, "utf8");
-		writeFileSync(path, existing + line);
-	} else writeFileSync(path, line);
-}
-//#endregion
 //#region src/campaign/neutralize.ts
 /**
 * @module
@@ -1444,20 +1098,6 @@ function sequentialOptimizationMethod(options) {
 //#endregion
 //#region src/campaign/presets/playback.ts
 /**
-* Adapt a `PlaybackDriver` into a `runProfileMatrix` dispatch. The artifact the
-* matrix scores is the `ProducedState` extracted from the driver's event
-* stream — grade it with `scoreUserStory` (or a judge wrapping it).
-*/
-function makePlaybackDispatch(driver) {
-	return async (profile, scenario, ctx) => {
-		const events = await driver.run(scenario, {
-			...ctx,
-			profile
-		});
-		return extractProducedState(events);
-	};
-}
-/**
 * Score one story's produced state against its requirements. Thin wrapper over
 * `verifyCompletion` that builds the gold from the story and returns a
 * per-requirement PASS/FAIL verdict. `checkCorrectness` is injected — a
@@ -2763,155 +2403,6 @@ function scoreDiscrimination(signals, opts) {
 		};
 	}).sort(compareDiscrimination);
 }
-/**
-* Select the top-`k` most discriminative scenario ids for a holdout, EXCLUDING
-* fully saturated ties when enough non-tied scenarios exist (a tie in the
-* holdout wastes a paired cell).
-*
-* Prefers non-tied scenarios; if fewer than `k` non-tied exist, fills with the
-* least-saturated tied ones (tied scenarios are already ordered least-saturated
-* first by `meanScore` asc). Deterministic. Throws if `k < 1`. If
-* `signals.length <= k`, returns all ids in discrimination order.
-*/
-function selectDiscriminative(signals, k, opts) {
-	if (k < 1) throw new Error(`selectDiscriminative: k must be >= 1 (got ${k})`);
-	const ranked = scoreDiscrimination(signals, opts);
-	if (ranked.length <= k) return ranked.map((s) => s.scenarioId);
-	const nonTied = ranked.filter((s) => !s.tied);
-	if (nonTied.length >= k) return nonTied.slice(0, k).map((s) => s.scenarioId);
-	const fill = ranked.filter((s) => s.tied).slice(0, k - nonTied.length);
-	return [...nonTied, ...fill].map((s) => s.scenarioId);
-}
-//#endregion
-//#region src/campaign/upstream-evaluators.ts
-function phoenixEvaluatorJudge(evaluator, options) {
-	if ((evaluator.optimizationDirection === "MINIMIZE" || evaluator.optimizationDirection === "NEUTRAL") && !options.toComposite) throw new TypeError(`phoenixEvaluatorJudge requires toComposite for a ${evaluator.optimizationDirection} evaluator`);
-	const paidCall = validatePaidEvaluation(evaluator.name, evaluator.kind, options.paidCall);
-	return upstreamJudge({
-		name: options.name ?? evaluator.name,
-		dimension: options.dimension,
-		judgeVersion: options.judgeVersion,
-		appliesTo: options.appliesTo,
-		toComposite: options.toComposite
-	}, async (input) => {
-		const result = await runUpstreamEvaluation({
-			name: evaluator.name,
-			kind: evaluator.kind,
-			signal: input.signal,
-			costLedger: input.costLedger,
-			costPhase: input.costPhase,
-			costTags: input.costTags,
-			scenarioId: input.scenario.id,
-			paidCall,
-			execute: (context) => evaluator.evaluate(options.mapInput({
-				artifact: input.artifact,
-				scenario: input.scenario
-			}), context)
-		});
-		if (result.score === void 0 || !Number.isFinite(result.score)) throw new Error(`${evaluator.name}: Phoenix evaluator returned no finite score`);
-		return {
-			score: result.score,
-			notes: [result.label, result.explanation].filter(Boolean).join(": ") || evaluator.name
-		};
-	});
-}
-function autoevalsScorerJudge(scorer, options) {
-	const paidCall = validatePaidEvaluation(options.name, options.kind, options.paidCall);
-	return upstreamJudge(options, async (input) => {
-		const result = await runUpstreamEvaluation({
-			name: options.name,
-			kind: options.kind,
-			signal: input.signal,
-			costLedger: input.costLedger,
-			costPhase: input.costPhase,
-			costTags: input.costTags,
-			scenarioId: input.scenario.id,
-			paidCall,
-			execute: (context) => scorer(options.mapInput({
-				artifact: input.artifact,
-				scenario: input.scenario
-			}), context)
-		});
-		if (result.score === null || !Number.isFinite(result.score)) throw new Error(`${options.name}: Autoevals scorer returned no finite score`);
-		return {
-			score: result.score,
-			notes: result.metadata ? JSON.stringify(result.metadata) : result.name
-		};
-	});
-}
-function upstreamJudge(options, evaluate) {
-	const dimension = options.dimension ?? options.name;
-	return {
-		name: options.name,
-		judgeVersion: options.judgeVersion,
-		dimensions: [{
-			key: dimension,
-			description: `Score from ${options.name}`
-		}],
-		appliesTo: options.appliesTo,
-		async score(input) {
-			const result = await evaluate(input);
-			const composite = options.toComposite ? options.toComposite(result.score) : result.score;
-			if (!Number.isFinite(composite)) throw new Error(`${options.name}: toComposite returned a non-finite score`);
-			return {
-				dimensions: { [dimension]: result.score },
-				composite,
-				notes: result.notes
-			};
-		}
-	};
-}
-function validatePaidEvaluation(name, kind, paidCall) {
-	if (kind === "CODE") {
-		if (paidCall) throw new TypeError(`${name}: CODE evaluator cannot declare paidCall`);
-		return;
-	}
-	if (!paidCall) throw new TypeError(`${name}: LLM evaluator requires paidCall cost and token capture`);
-	if (!paidCall.model.trim()) throw new TypeError(`${name}: paidCall.model must be non-empty`);
-	return paidCall;
-}
-async function runUpstreamEvaluation(input) {
-	if (input.kind === "CODE") return abortableEvaluation(input.signal, () => input.execute({ signal: input.signal }));
-	if (!input.paidCall) throw new CostAccountingIncompleteError(`${input.name}: missing paid-call configuration`);
-	if (!input.costLedger) throw new CostAccountingIncompleteError(`${input.name}: LLM evaluator requires the campaign cost ledger`);
-	const paid = await input.costLedger.runPaidCall({
-		channel: "judge",
-		phase: input.costPhase ?? "judge",
-		actor: input.name,
-		model: input.paidCall.model,
-		...input.paidCall.maximumCharge ? { maximumCharge: input.paidCall.maximumCharge } : {},
-		tags: {
-			...input.costTags,
-			scenarioId: input.scenarioId
-		},
-		signal: input.signal,
-		execute: (signal, callId) => Promise.resolve(input.execute({
-			signal,
-			callId
-		})),
-		receipt: input.paidCall.receipt,
-		...input.paidCall.receiptFromError ? { receiptFromError: input.paidCall.receiptFromError } : {}
-	});
-	if (!paid.succeeded) throw paid.error;
-	const recorded = input.costLedger.list().find((receipt) => receipt.callId === paid.callId);
-	if (!recorded) throw new CostAccountingIncompleteError(`${input.name}: paid evaluator returned without a recorded cost receipt`);
-	if (recorded.costUnknown || recorded.usageUnknown) throw new CostAccountingIncompleteError(`${input.name}: paid evaluator returned without complete cost and token usage`);
-	return paid.value;
-}
-async function abortableEvaluation(signal, execute) {
-	if (signal.aborted) throw signal.reason;
-	let rejectAborted;
-	const aborted = new Promise((_resolve, reject) => {
-		rejectAborted = reject;
-	});
-	const onAbort = () => rejectAborted(signal.reason);
-	signal.addEventListener("abort", onAbort, { once: true });
-	try {
-		return await Promise.race([Promise.resolve().then(execute), aborted]);
-	} finally {
-		signal.removeEventListener("abort", onAbort);
-	}
-}
 //#endregion
 //#region src/campaign/worktree/index.ts
 /**
@@ -3434,6 +2925,6 @@ function resolveWorktreePath(surface, worktreeDir) {
 	return verifyCodeSurface(surface, worktreeDir).path;
 }
 //#endregion
-export { loadEvalFixtureScenarios as A, FsLabeledScenarioStore as C, neutralizationGate as D, rolloutArgumentDiff as E, analyzeCrossSurfaceInteractions as M, buildTraceAnalystSurfaceDispatch as N, discoverEvalFixtures as O, traceAnalystQualityJudge as P, neutralizeText as S, classifyUngroundedLiterals as T, scoreUserStory as _, autoevalsScorerJudge as a, scopedOptimizationMethod as b, selectDiscriminative as c, finalizeProfileMatrix as d, runProfileMatrixSegment as f, renderScoreboardMarkdown as g, makePlaybackDispatch as h, verifyCodeSurface as i, planEvalFixtureRun as j, loadEvalFixture as k, createRetainedDispatch as l, runProfileMatrix as m, gitWorktreeAdapter as n, phoenixEvaluatorJudge as o, ProfileMatrixError as p, resolveWorktreePath as r, scoreDiscrimination as s, WorktreeAdapterError as t, createProfileMatrixPlan as u, scoreboardSummary as v, LabeledScenarioStoreError as w, sequentialOptimizationMethod as x, userStoryScoreboard as y };
+export { analyzeCrossSurfaceInteractions as S, neutralizationGate as _, createRetainedDispatch as a, loadEvalFixtureScenarios as b, runProfileMatrixSegment as c, scoreUserStory as d, scoreboardSummary as f, neutralizeText as g, sequentialOptimizationMethod as h, scoreDiscrimination as i, runProfileMatrix as l, scopedOptimizationMethod as m, resolveWorktreePath as n, createProfileMatrixPlan as o, userStoryScoreboard as p, verifyCodeSurface as r, finalizeProfileMatrix as s, gitWorktreeAdapter as t, renderScoreboardMarkdown as u, discoverEvalFixtures as v, planEvalFixtureRun as x, loadEvalFixture as y };
 
-//# sourceMappingURL=campaign-BQ-Jujuj.js.map
+//# sourceMappingURL=campaign-CJGkxAQ6.js.map