@tangle-network/agent-eval 0.173.3 → 0.175.0

package/dist/{define-agent-eval-8h3lXXee.js → define-agent-eval-ox5McL6e.js}

@@ -10,9 +10,9 @@ import "./query-D1nLIKt7.js";
 import { r as observedSplitScore } from "./reward-nw2xZGZG.js";
 import { c as validateRunRecord, i as modelHasSnapshot } from "./run-record-ZIsR9Fif.js";
 import { r as paretoChart } from "./summary-report-Bgh8CpNK.js";
-import { D as assertOptimizationResult, I as surfaceContentHash, L as surfaceHash, Q as defaultProductionGate, _ as runImprovementLoop, d as emitLoopProvenance, f as loopProvenanceArgsFromResult, it as runEval, st as resolveRunDir } from "./llm-judge-BfqMFo4h.js";
+import { J as defaultProductionGate, K as runFinalComparison, T as runImprovementLoop, _ as campaignMeasurementDigest, at as surfaceDispatchRef, b as loopProvenanceArgsFromResult, c as assertOptimizationResult, h as createMethodCostScope, it as surfaceContentHash, m as costFromLedgerSummary, ot as surfaceHash, p as combineComparisonCosts, q as openAutoPr, st as runEval, ut as resolveRunDir, v as canonicalDigest, vt as campaignSplitDigest, y as emitLoopProvenance } from "./llm-judge-DmNaBrXB.js";
 import { c as campaignCellTaskScore, l as campaignCellToRunRecord, o as campaignCellExecutionEvidence, s as campaignCellJudgeDimensions } from "./reward-hacking-CKW4teig.js";
-import { C as inMemoryCampaignStorage, S as fsCampaignStorage, x as createRunCostLedger } from "./external-optimizer-subprocess-wBWeoG6A.js";
+import { C as inMemoryCampaignStorage, S as fsCampaignStorage, x as createRunCostLedger } from "./external-optimizer-subprocess-CQi27uEI.js";
 import { t as powerPreflight } from "./power-preflight-CFXm0Vjo.js";
 import { t as createHostedClient } from "./client-BlLY6o2w.js";
 //#region src/contamination-guard.ts
@@ -965,6 +965,306 @@ function buildRecommendations(ctx) {
 	return out;
 }
 //#endregion
+//#region src/contract/self-improve-reporting.ts
+function meanComposite(byScenario) {
+	const perScenario = {};
+	const values = [];
+	for (const [id, agg] of Object.entries(byScenario)) {
+		perScenario[id] = agg.meanComposite;
+		values.push(agg.meanComposite);
+	}
+	return {
+		compositeMean: values.length === 0 ? 0 : values.reduce((s, v) => s + v, 0) / values.length,
+		perScenario
+	};
+}
+/** 32-bit FNV-1a over raw UTF-16 code units, rendered as hex for a cell key.
+*
+*  Frozen: the key names a persisted cell, so a change orphans every cell
+*  already written. This is a cell-key function, not a general-purpose hash. */
+function hashString(s) {
+	let h = 2166136261;
+	for (let i = 0; i < s.length; i++) {
+		h ^= s.charCodeAt(i);
+		h = Math.imul(h, 16777619) >>> 0;
+	}
+	return h.toString(16).padStart(8, "0");
+}
+/**
+* Adapt campaign cells into the `RunRecord` shape `analyzeRuns()` consumes.
+* Each cell becomes one run; `candidateId` is the caller-supplied label so
+* baseline + winner pair cleanly on `(experimentId, scenarioId, seed)`.
+*
+* `promptHash` identifies the executed surface; `configHash` identifies the candidate label.
+*/
+function cellsToRunRecords(cells, candidateId, runId, surface, splitTag, fallbackModel) {
+	const promptHash = surfaceContentHash(surface);
+	const configHash = surfaceContentHash(candidateId);
+	return cells.map((cell) => {
+		const receiptModels = cell.resolvedModels ?? (cell.resolvedModel ? [cell.resolvedModel] : []);
+		if (receiptModels.length > 1) throw new ValidationError(`selfImprove cell ${cell.cellId} used multiple agent models: ${receiptModels.join(", ")}`);
+		const model = receiptModels[0] ?? fallbackModel;
+		if (!model) throw new ValidationError(`selfImprove.model is required when cell ${cell.cellId} has no paid-call model receipt`);
+		if (!modelHasSnapshot(model)) throw new ValidationError(`selfImprove model "${model}" lacks a snapshot version for cell ${cell.cellId}`);
+		return campaignCellToRunRecord(cell, {
+			runId: `${runId}::${candidateId}::${cell.cellId}`,
+			experimentId: runId,
+			candidateId,
+			seed: cell.rep * 1e6 + hashString(cell.scenarioId).slice(0, 6).split("").reduce((a, c) => a * 31 + c.charCodeAt(0) >>> 0, 0),
+			model,
+			promptHash,
+			configHash,
+			commitSha: "cell",
+			splitTag
+		});
+	});
+}
+//#endregion
+//#region src/contract/self-improve-method.ts
+/** Complete methods own search and selection; this path only measures their final choice. */
+async function runSelfImproveMethod(args) {
+	const { opts, train, selection, holdout, costLedger, storage, runDir, startedAt } = args;
+	const budget = opts.budget ?? {};
+	if (opts.autoOnPromote === "pr" && (!opts.ghOwner || !opts.ghRepo)) throw new Error("selfImprove: autoOnPromote='pr' requires ghOwner + ghRepo");
+	const baselineSurface = structuredClone(opts.baselineSurface);
+	const judge = {
+		...opts.judge,
+		dimensions: opts.judge.dimensions.map((dimension) => Object.freeze({ ...dimension }))
+	};
+	Object.freeze(judge.dimensions);
+	Object.freeze(judge);
+	const methodCostScope = createMethodCostScope(costLedger, opts.method.name);
+	const method = await opts.method.optimize(Object.freeze({
+		baselineSurface: structuredClone(baselineSurface),
+		trainScenarios: Object.freeze(train.map((scenario) => structuredClone(scenario))),
+		selectionScenarios: Object.freeze(selection.map((scenario) => structuredClone(scenario))),
+		dispatchWithSurface: opts.agent,
+		judges: Object.freeze([judge]),
+		runDir: `${runDir}/optimization/${opts.method.name.replace(/[^a-zA-Z0-9._-]/g, "_")}`,
+		seed: 42,
+		runOptions: Object.freeze({
+			storage,
+			maxConcurrency: budget.maxConcurrency ?? 2,
+			reps: budget.reps,
+			dispatchRef: opts.dispatchRef,
+			dispatchTimeoutMs: opts.dispatchTimeoutMs,
+			cellRetry: opts.cellRetry,
+			cellPlacement: opts.cellPlacement,
+			labeledStore: opts.labeledStore,
+			captureSource: opts.captureSource,
+			expectUsage: opts.expectUsage ?? "assert"
+		}),
+		costLedger: methodCostScope.ledger
+	}));
+	assertOptimizationResult(opts.method.name, method);
+	const selected = structuredClone(method);
+	const methodCost = methodCostScope.reconcile(selected.cost);
+	const finalPhase = "selfImprove.method-final";
+	const finalCost = () => combineComparisonCosts([
+		"holdout.baseline",
+		"holdout.winner",
+		"holdout.neutralized",
+		"promotion.gate"
+	].map((phase) => ({
+		label: phase,
+		cost: costFromLedgerSummary(costLedger.summary({ phase: `${finalPhase}.${phase}` }))
+	})));
+	const totalCost = () => combineComparisonCosts([{
+		label: opts.method.name,
+		cost: methodCost
+	}, {
+		label: "final comparison",
+		cost: finalCost()
+	}]);
+	const gate = opts.gate ?? defaultProductionGate({
+		holdoutScenarios: holdout,
+		deltaThreshold: .05
+	});
+	const comparison = await runFinalComparison({
+		baselineSurface,
+		winnerSurface: selected.winnerSurface,
+		scenarios: holdout,
+		dispatchWithSurface: opts.agent,
+		dispatchRef: opts.dispatchRef,
+		judges: [judge],
+		holdout: budget.holdout,
+		neutralize: opts.neutralize,
+		gate: {
+			...gate,
+			async decide(context) {
+				const cost = totalCost();
+				if (budget.dollars !== void 0 && (!cost.accountingComplete || cost.totalCostUsd > budget.dollars)) return {
+					decision: "hold",
+					reasons: ["complete method spend cannot satisfy the declared run budget"],
+					contributingGates: [{
+						name: "budget",
+						status: "fail",
+						detail: {
+							cost,
+							budgetUsd: budget.dollars
+						}
+					}]
+				};
+				return gate.decide(context);
+			}
+		},
+		runDir,
+		storage,
+		costLedger,
+		costPhase: finalPhase,
+		reps: budget.reps,
+		maxConcurrency: budget.maxConcurrency ?? 2,
+		dispatchTimeoutMs: opts.dispatchTimeoutMs,
+		cellRetry: opts.cellRetry,
+		cellPlacement: opts.cellPlacement,
+		expectUsage: opts.expectUsage ?? "assert",
+		label: "selfImprove"
+	});
+	const deferred = comparison.holdout === "deferred";
+	const baseline = deferred ? null : meanComposite(comparison.baselineOnHoldout.aggregates.byScenario);
+	const winner = deferred ? null : meanComposite(comparison.winnerOnHoldout.aggregates.byScenario);
+	const lift = baseline && winner ? winner.compositeMean - baseline.compositeMean : void 0;
+	const insight = deferred ? void 0 : await analyzeRuns({
+		runs: [...cellsToRunRecords(comparison.baselineOnHoldout.cells, "baseline", runDir, baselineSurface, "holdout", opts.model), ...comparison.winnerOnHoldout === comparison.baselineOnHoldout ? [] : cellsToRunRecords(comparison.winnerOnHoldout.cells, "winner", runDir, selected.winnerSurface, "holdout", opts.model)],
+		baselineCandidateId: "baseline",
+		...comparison.winnerOnHoldout === comparison.baselineOnHoldout ? {} : { candidateCandidateId: "winner" }
+	});
+	const cost = totalCost();
+	const optimization = {
+		name: opts.method.name,
+		cost: methodCost,
+		...selected.durationMs === void 0 ? {} : { durationMs: selected.durationMs },
+		...selected.provenance === void 0 ? {} : { provenance: selected.provenance }
+	};
+	const durationMs = Date.now() - startedAt;
+	const receipts = costLedger.list();
+	const record = {
+		schema: "tangle.method-improvement",
+		runId: `${runDir}#${startedAt}`,
+		runDir,
+		timestamp: new Date(startedAt).toISOString(),
+		baselineContentHash: surfaceContentHash(baselineSurface),
+		winnerContentHash: surfaceContentHash(selected.winnerSurface),
+		diff: comparison.promotedDiff,
+		optimizationMethod: optimization,
+		evidence: {
+			trainSplitDigest: campaignSplitDigest(train, budget.reps ?? 1),
+			selectionSplitDigest: campaignSplitDigest(selection, budget.reps ?? 1),
+			holdoutSplitDigest: campaignSplitDigest(holdout, budget.reps ?? 1),
+			baselineCampaignDigest: campaignMeasurementDigest(comparison.baselineOnHoldout),
+			winnerCampaignDigest: campaignMeasurementDigest(comparison.winnerOnHoldout),
+			costReceiptsDigest: canonicalDigest(receipts),
+			...comparison.neutralizedOnHoldout ? { neutralizedCampaignDigest: campaignMeasurementDigest(comparison.neutralizedOnHoldout) } : {}
+		},
+		gate: comparison.gateResult,
+		...deferred ? { holdout: "deferred" } : {},
+		...baseline && winner ? {
+			baselineHoldoutComposite: baseline.compositeMean,
+			winnerHoldoutComposite: winner.compositeMean,
+			heldOutLift: lift
+		} : {},
+		cost,
+		totalCostUsd: cost.totalCostUsd,
+		totalDurationMs: durationMs
+	};
+	const serialized = JSON.parse(JSON.stringify(record));
+	const provenance = {
+		...serialized,
+		recordDigest: canonicalDigest(serialized)
+	};
+	storage.ensureDir(runDir);
+	storage.write(`${runDir}/method-provenance.json`, JSON.stringify(provenance, null, 2));
+	opts.onProvenance?.(provenance);
+	opts.onProgress?.({
+		kind: "gate.decided",
+		decision: comparison.gateResult.decision,
+		...lift === void 0 ? {} : { lift }
+	});
+	const prResult = opts.autoOnPromote === "pr" && comparison.gateResult.decision === "ship" ? openAutoPr({
+		result: comparison.winnerOnHoldout,
+		gate: comparison.gateResult,
+		promotedDiff: comparison.promotedDiff,
+		ghOwner: opts.ghOwner,
+		ghRepo: opts.ghRepo
+	}) : void 0;
+	const result = {
+		mode: "method",
+		baseline,
+		winner: {
+			surface: selected.winnerSurface,
+			compositeMean: winner?.compositeMean ?? null,
+			perScenario: winner?.perScenario ?? {},
+			label: opts.method.name
+		},
+		...lift === void 0 ? {} : { lift },
+		diff: comparison.promotedDiff,
+		gateDecision: comparison.gateResult.decision,
+		provenance,
+		optimization,
+		cost,
+		ledgerCost: costLedger.summary(),
+		totalCostUsd: cost.totalCostUsd,
+		durationMs,
+		receipts,
+		...insight ? { insight } : {},
+		...selected.searchHistory ? { searchHistory: selected.searchHistory } : {},
+		raw: {
+			...comparison,
+			kind: "method",
+			baselineSurface,
+			winnerSurface: selected.winnerSurface,
+			winnerSurfaceHash: surfaceHash(selected.winnerSurface),
+			method: selected,
+			cost,
+			...prResult ? { prResult } : {}
+		}
+	};
+	if (opts.hostedTenant) {
+		const snapshot = (index, surface, campaign) => ({
+			index,
+			surfaceHash: surfaceHash(surface),
+			surface,
+			cells: campaign.cells.map((cell) => {
+				const execution = campaignCellExecutionEvidence(cell);
+				return {
+					scenarioId: cell.scenarioId,
+					rep: cell.rep,
+					compositeMean: campaignCellTaskScore(cell) ?? null,
+					dimensions: campaignCellJudgeDimensions(cell),
+					terminalOutcome: execution.terminalOutcome,
+					executionErrorCount: execution.executionErrorCount ?? null,
+					...cell.error ? { errorMessage: cell.error } : {}
+				};
+			}),
+			compositeMean: deferred ? null : meanComposite(campaign.aggregates.byScenario).compositeMean,
+			costUsd: campaign.aggregates.cost.totalCostUsd,
+			durationMs: campaign.durationMs
+		});
+		try {
+			await createHostedClient(opts.hostedTenant).ingestEvalRun({
+				runId: provenance.runId,
+				runDir,
+				timestamp: provenance.timestamp,
+				status: "finished",
+				labels: {
+					...opts.hostedLabels,
+					mode: "method"
+				},
+				baseline: snapshot(0, baselineSurface, comparison.baselineOnHoldout),
+				generations: [snapshot(1, selected.winnerSurface, comparison.winnerOnHoldout)],
+				gateDecision: result.gateDecision,
+				...lift === void 0 ? {} : { holdoutLift: lift },
+				totalCostUsd: result.totalCostUsd,
+				totalDurationMs: durationMs,
+				...insight ? { insightReport: insight } : {}
+			});
+		} catch (error) {
+			console.warn(`[agent-eval] hosted ingest failed (continuing): ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	return result;
+}
+//#endregion
 //#region src/contract/self-improve.ts
 /** Failed self-improvement run with an immutable receipt snapshot. */
 var SelfImproveRunError = class extends Error {
@@ -986,9 +1286,9 @@ function assertSelfImproveSearchMode(opts) {
 	}
 	if (typeof opts.method.name !== "string" || !opts.method.name.trim() || opts.method.name.trim() !== opts.method.name || typeof opts.method.optimize !== "function") throw new Error("selfImprove: method must have a trimmed name and optimize(input)");
 	const budget = opts.budget;
-	if (budget?.generations !== void 0 && budget.generations !== 1) throw new Error("selfImprove: method owns its rounds; budget.generations must be 1 when set");
-	if (budget?.populationSize !== void 0 && budget.populationSize !== 1) throw new Error("selfImprove: method owns its candidates; budget.populationSize must be 1 when set");
-	if (budget?.candidateConcurrency !== void 0 || budget?.maxImprovementShots !== void 0 || opts.analyzeGeneration !== void 0 || opts.findings !== void 0 || opts.selectParent !== void 0) throw new Error("selfImprove: candidateConcurrency, maxImprovementShots, analyzeGeneration, findings, and selectParent apply only to proposer mode");
+	if (budget?.generations !== void 0) throw new Error("selfImprove: method owns its rounds; budget.generations applies only to proposer mode");
+	if (budget?.populationSize !== void 0) throw new Error("selfImprove: method owns its candidates; budget.populationSize applies only to proposer mode");
+	if (budget?.candidateConcurrency !== void 0 || budget?.maxImprovementShots !== void 0 || opts.analyzeGeneration !== void 0 || opts.findings !== void 0 || opts.selectParent !== void 0 || opts.premeasuredBaseline !== void 0 || opts.selectionRankKey !== void 0 || opts.searchLedger !== void 0) throw new Error("selfImprove: candidateConcurrency, maxImprovementShots, analyzeGeneration, findings, selectParent, premeasuredBaseline, selectionRankKey, and searchLedger apply only to proposer mode");
 }
 function splitMethodPartitions(searchScenarios, explicitSelection, fraction) {
 	if (!Number.isFinite(fraction) || fraction <= 0 || fraction >= 1) throw new Error("selfImprove: budget.selectionFraction must be in (0, 1)");
@@ -1020,9 +1320,6 @@ function splitMethodPartitions(searchScenarios, explicitSelection, fraction) {
 		train: sorted.slice(count)
 	};
 }
-function safeRunComponent(value) {
-	return value.replace(/[^a-zA-Z0-9._-]/g, "_");
-}
 /** 32-bit FNV-1a over raw UTF-16 code units, read as an unsigned int and used
 *  only to order scenarios deterministically.
 *
@@ -1050,18 +1347,6 @@ function splitTrainHoldout(scenarios, fraction) {
 		train: sorted.slice(nHoldout)
 	};
 }
-function meanComposite(byScenario) {
-	const perScenario = {};
-	const values = [];
-	for (const [id, agg] of Object.entries(byScenario)) {
-		perScenario[id] = agg.meanComposite;
-		values.push(agg.meanComposite);
-	}
-	return {
-		compositeMean: values.length === 0 ? 0 : values.reduce((s, v) => s + v, 0) / values.length,
-		perScenario
-	};
-}
 /**
 * Latest search campaign measured for the winner surface; the baseline search
 * campaign when the winner IS the baseline. Used by the deferred-holdout
@@ -1074,32 +1359,6 @@ function winnerSearchCampaign(result) {
 	}
 	return result.baselineCampaign;
 }
-/**
-* One-shot self-improvement loop. See module docstring for defaults +
-* extension points.
-*
-* @example Minimum:
-*
-*   const result = await selfImprove({
-*     agent: (surface, scenario, ctx) => myAgent(surface, scenario, ctx.signal),
-*     scenarios,
-*     judge,
-*     baselineSurface: DEFAULT_PROMPT,
-*     proposer,
-*   })
-*   console.log(`lift: ${result.lift.toFixed(3)} (${result.gateDecision})`)
-*
-* @example Distributed (workers in three regions):
-*
-*   await selfImprove({
-*     agent: httpDispatch({ resolveUrl: ({ placement }) => REGION_URLS[placement!] }),
-*     scenarios,
-*     judge,
-*     baselineSurface: DEFAULT_PROMPT,
-*     cellPlacement: ({ scenario }) => scenario.region,
-*     budget: { maxConcurrency: 12 },
-*   })
-*/
 async function selfImprove(opts) {
 	const startedAt = Date.now();
 	const runDir = resolveRunDir(opts.runDir ?? (opts.method ? `.agent-eval/runs/self-improve-${startedAt}` : `mem://selfImprove-${startedAt}`));
@@ -1118,8 +1377,6 @@ async function selfImprove(opts) {
 async function runSelfImprove(opts, costLedger, startedAt, runDir, storage) {
 	const budget = opts.budget ?? {};
 	assertSelfImproveSearchMode(opts);
-	const generations = opts.method ? 1 : budget.generations ?? 3;
-	const populationSize = opts.method ? 1 : budget.populationSize ?? 2;
 	const maxConcurrency = budget.maxConcurrency ?? 2;
 	const holdoutFraction = budget.holdoutFraction ?? .25;
 	const holdoutMode = budget.holdout ?? "measured";
@@ -1135,41 +1392,26 @@ async function runSelfImprove(opts, costLedger, startedAt, runDir, storage) {
 	} : splitTrainHoldout(opts.scenarios, holdoutFraction);
 	if (train.length === 0) throw new Error("selfImprove: train split is empty. Reduce holdoutFraction or pass more scenarios.");
 	if (holdout.length === 0 && !holdoutDeferred) throw new Error("selfImprove: holdout split is empty. Pass more scenarios.");
-	if (generations > 0 && !opts.proposer && !opts.method) throw new Error("selfImprove: method or proposer is required when budget.generations is greater than zero");
-	let optimizationResult;
-	const methodPartitions = opts.method ? splitMethodPartitions(train, opts.selectionScenarios, budget.selectionFraction ?? .25) : void 0;
-	const proposer = opts.method ? {
-		kind: `method:${opts.method.name}`,
-		propose: async (context) => {
-			if (context.generation > 0) return [];
-			const result = await opts.method.optimize(Object.freeze({
-				baselineSurface: structuredClone(context.currentSurface),
-				trainScenarios: Object.freeze(methodPartitions.train.map((scenario) => structuredClone(scenario))),
-				selectionScenarios: Object.freeze(methodPartitions.selection.map((scenario) => structuredClone(scenario))),
-				dispatchWithSurface: opts.agent,
-				judges: Object.freeze([opts.judge]),
-				runDir: `${runDir}/optimization/${safeRunComponent(opts.method.name)}`,
-				seed: 42,
-				runOptions: Object.freeze({
-					storage,
-					maxConcurrency,
-					reps: budget.reps,
-					dispatchTimeoutMs: opts.dispatchTimeoutMs,
-					cellRetry: opts.cellRetry,
-					expectUsage,
-					costCeiling: budget.dollars
-				}),
-				costLedger
-			}));
-			assertOptimizationResult(opts.method.name, result);
-			optimizationResult = structuredClone(result);
-			return [{
-				surface: structuredClone(result.winnerSurface),
-				label: opts.method.name,
-				rationale: `${opts.method.name} selected this surface without final cases.`
-			}];
-		}
-	} : opts.proposer ?? {
+	if (opts.method) {
+		const partitions = splitMethodPartitions(train, opts.selectionScenarios, budget.selectionFraction ?? .25);
+		return runSelfImproveMethod({
+			opts: {
+				...opts,
+				method: opts.method
+			},
+			train: partitions.train,
+			selection: partitions.selection,
+			holdout,
+			costLedger,
+			storage,
+			runDir,
+			startedAt
+		});
+	}
+	const generations = budget.generations ?? 3;
+	const populationSize = budget.populationSize ?? 2;
+	if (generations > 0 && !opts.proposer) throw new Error("selfImprove: method or proposer is required when budget.generations is greater than zero");
+	const proposer = opts.proposer ?? {
 		kind: "baseline-only",
 		propose: async () => []
 	};
@@ -1186,6 +1428,7 @@ async function runSelfImprove(opts, costLedger, startedAt, runDir, storage) {
 		baselineSurface: opts.baselineSurface,
 		premeasuredBaseline: opts.premeasuredBaseline,
 		dispatchWithSurface: opts.agent,
+		dispatchRef: opts.dispatchRef,
 		proposer,
 		judges: [opts.judge],
 		populationSize,
@@ -1255,9 +1498,9 @@ async function runSelfImprove(opts, costLedger, startedAt, runDir, storage) {
 	const cost = result.cost;
 	const totalCost = cost.totalCostUsd;
 	const insight = await analyzeRuns({
-		runs: [...cellsToRunRecords(reportBaselineCampaign.cells, "baseline", runDir, opts.baselineSurface, reportSplit, opts.model), ...cellsToRunRecords(reportWinnerCampaign.cells, "winner", runDir, result.winnerSurface, reportSplit, opts.model)],
+		runs: [...cellsToRunRecords(reportBaselineCampaign.cells, "baseline", runDir, opts.baselineSurface, reportSplit, opts.model), ...reportWinnerCampaign === reportBaselineCampaign ? [] : cellsToRunRecords(reportWinnerCampaign.cells, "winner", runDir, result.winnerSurface, reportSplit, opts.model)],
 		baselineCandidateId: "baseline",
-		candidateCandidateId: "winner"
+		...reportWinnerCampaign === reportBaselineCampaign ? {} : { candidateCandidateId: "winner" }
 	});
 	const durationMs = Date.now() - startedAt;
 	const { record: provenance } = await emitLoopProvenance({
@@ -1271,17 +1514,12 @@ async function runSelfImprove(opts, costLedger, startedAt, runDir, storage) {
 			totalCostUsd: totalCost,
 			totalDurationMs: durationMs
 		}),
-		...optimizationResult ? { optimizationMethod: {
-			name: opts.method.name,
-			cost: structuredClone(optimizationResult.cost),
-			...optimizationResult.durationMs === void 0 ? {} : { durationMs: optimizationResult.durationMs },
-			...optimizationResult.provenance === void 0 ? {} : { provenance: structuredClone(optimizationResult.provenance) }
-		} } : {},
 		storage,
 		hostedClient: opts.hostedTenant ? createHostedClient(opts.hostedTenant) : void 0
 	});
 	if (opts.onProvenance) opts.onProvenance(provenance);
 	const summary = {
+		mode: "proposer",
 		baseline,
 		winner: {
 			...winnerStats,
@@ -1298,12 +1536,6 @@ async function runSelfImprove(opts, costLedger, startedAt, runDir, storage) {
 		totalCostUsd: totalCost,
 		cost,
 		receipts: costLedger.list(),
-		...optimizationResult ? { optimization: {
-			name: opts.method.name,
-			cost: structuredClone(optimizationResult.cost),
-			...optimizationResult.durationMs === void 0 ? {} : { durationMs: optimizationResult.durationMs },
-			...optimizationResult.provenance === void 0 ? {} : { provenance: structuredClone(optimizationResult.provenance) }
-		} } : {},
 		...result.searchHistory ? { searchHistory: result.searchHistory } : {},
 		insight,
 		...power ? { power } : {},
@@ -1371,52 +1603,6 @@ function averageComposite(campaign) {
 	const aggs = Object.values(campaign.aggregates.byScenario);
 	return aggs.length === 0 ? 0 : aggs.reduce((s, a) => s + a.meanComposite, 0) / aggs.length;
 }
-/** 32-bit FNV-1a over raw UTF-16 code units, rendered as hex for a cell key.
-*
-*  Frozen: the key names a persisted cell, so a change orphans every cell
-*  already written. Same loop as `stableScenarioHash` above but a different
-*  return form; neither is a general-purpose hash. */
-function hashString(s) {
-	let h = 2166136261;
-	for (let i = 0; i < s.length; i++) {
-		h ^= s.charCodeAt(i);
-		h = Math.imul(h, 16777619) >>> 0;
-	}
-	return h.toString(16).padStart(8, "0");
-}
-/**
-* Adapt campaign cells into the `RunRecord` shape `analyzeRuns()` consumes.
-* Each cell becomes one run; `candidateId` is the caller-supplied label so
-* baseline + winner pair cleanly on `(experimentId, scenarioId, seed)`.
-*
-* `promptHash` is the REAL sha256 content hash of the surface this cell ran
-* (baseline vs winner are byte-distinguishable + byte-identical-verifiable);
-* `configHash` is the sha256 of the candidate label so the two candidates'
-* config rows differ. Both were previously the literal `'sha256:cell'`, which
-* made baseline and winner indistinguishable in every downstream record.
-*/
-function cellsToRunRecords(cells, candidateId, runId, surface, splitTag, fallbackModel) {
-	const promptHash = surfaceContentHash(surface);
-	const configHash = surfaceContentHash(candidateId);
-	return cells.map((cell) => {
-		const receiptModels = cell.resolvedModels ?? (cell.resolvedModel ? [cell.resolvedModel] : []);
-		if (receiptModels.length > 1) throw new ValidationError(`selfImprove cell ${cell.cellId} used multiple agent models: ${receiptModels.join(", ")}`);
-		const model = receiptModels[0] ?? fallbackModel;
-		if (!model) throw new ValidationError(`selfImprove.model is required when cell ${cell.cellId} has no paid-call model receipt`);
-		if (!modelHasSnapshot(model)) throw new ValidationError(`selfImprove model "${model}" lacks a snapshot version for cell ${cell.cellId}`);
-		return campaignCellToRunRecord(cell, {
-			runId: `${runId}::${candidateId}::${cell.cellId}`,
-			experimentId: runId,
-			candidateId,
-			seed: cell.rep * 1e6 + hashString(cell.scenarioId).slice(0, 6).split("").reduce((a, c) => a * 31 + c.charCodeAt(0) >>> 0, 0),
-			model,
-			promptHash,
-			configHash,
-			commitSha: "cell",
-			splitTag
-		});
-	});
-}
 //#endregion
 //#region src/contract/define-agent-eval.ts
 /**
@@ -1444,6 +1630,7 @@ function defineAgentEval(defaults) {
 				runDir: selectedRunDir,
 				scenarios: scenarios ?? defaults.scenarios,
 				dispatch: (scenario, ctx) => selectedAgent(selectedSurface, scenario, ctx),
+				dispatchRef: surfaceDispatchRef(selectedSurface, campaignOpts.dispatchRef ?? defaults.dispatchRef),
 				judges: evaluateJudges(judges, judge ?? defaults.judge)
 			};
 			if (evalOptions.reps !== void 0) evalOptions.reps = requirePositiveInteger(evalOptions.reps, "reps");
@@ -1509,4 +1696,4 @@ function requirePositiveInteger(value, field) {
 //#endregion
 export { summarizeExecution as a, analyzeRuns as i, SelfImproveRunError as n, checkCanaries as o, selfImprove as r, defineAgentEval as t };
 
-//# sourceMappingURL=define-agent-eval-8h3lXXee.js.map
+//# sourceMappingURL=define-agent-eval-ox5McL6e.js.map