@tangle-network/agent-eval 0.215.1 → 0.216.1

package/dist/{campaign-CpnsCgfz.js → campaign-BudZ70zo.js}

@@ -1,25 +1,25 @@
-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-BGp4BX8t.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-Cd5s5Ei6.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 { S as fsCampaignStorage } from "./external-optimizer-subprocess-BUxifb8g.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-GngofQML.js";
-import "./skillopt-optimization-method-Dcepr6QL.js";
-import "./sequential-D-1PPCmM.js";
+import { s as ValidationError, t as AgentEvalError } from "./errors-DVZiqS7K.js";
+import { a as hashCanonical, i as compareCodeUnits, r as canonicalString } from "./canonical-B2RqLofv.js";
+import { c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, s as agentProfileHash, t as extractProducedState } from "./produced-state-BsDmnwxc.js";
+import { o as buildAgentProfileCell } from "./agent-profile-cell-BK8mlqlq.js";
+import { c as validateRunRecord, i as modelHasSnapshot, n as UNKNOWN_MODEL, o as runTaskScore } from "./run-record-Boc5IUTp.js";
+import { i as pairedBootstrap } from "./mean-DHoMiudD.js";
+import { t as comparePairedArms } from "./paired-arms-CwMGJsrS.js";
+import { o as pairHoldout } from "./statistical-heldout-42NlCNDe.js";
+import { n as contentHash, t as canonicalJson } from "./verdict-cache-Bm8EKL2s.js";
+import { _ as labelTrustRank, at as resolveRunDir, c as executeOptimizationMethod, d as combineComparisonCosts, it as planCampaignRun, lt as cellCachePath, rt as runCampaign, ut as computeManifestHash } from "./llm-judge-CG12SQJq.js";
+import { n as campaignCellToRunRecord, r as projectCampaignCellQuality, t as campaignCellCostProvenance } from "./run-record-C5e7FjhJ.js";
+import { n as CostAccountingIncompleteError } from "./cost-ledger-BP8V4kUQ.js";
+import { B as assertCampaignDesign, N as surfaceContentHash, R as assertRealBackend, W as campaignScenarioIdentity, k as assertCodeSurfaceIdentity, z as summarizeBackendIntegrity } from "./campaign-evidence-Clrn4hBV.js";
+import { m as mapConcurrent } from "./journal-DfRz9kps.js";
+import { P as fsCampaignStorage } from "./external-optimizer-subprocess-BqW0hHcI.js";
+import "./pareto-Cm6ndrWN.js";
+import "./search-ledger-CVUGLDZp.js";
+import "./search-summary-BQCSWf1g.js";
+import { a as scoreAnalystFindings } from "./benchmark-CXmVVHH2.js";
+import "./external-optimizer-process-BjMGUuds.js";
+import "./skillopt-optimization-method-BiwA8nfX.js";
+import "./sequential-Bf_pbE50.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 { z } from "zod";
@@ -283,92 +283,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 +328,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 +709,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,
@@ -710,10 +737,6 @@ function emptyAdditionDecision(addition, additionComponentId, reasons) {
 		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;
@@ -725,117 +748,92 @@ function compareAdditionDecisions(context, summaryById, left, right) {
 	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)));
-	}
-	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;
+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
@@ -3436,4 +3434,4 @@ function resolveWorktreePath(surface, worktreeDir) {
 //#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 };
 
-//# sourceMappingURL=campaign-CpnsCgfz.js.map
+//# sourceMappingURL=campaign-BudZ70zo.js.map