@tangle-network/agent-eval 0.216.0 → 0.217.1

package/dist/{llm-judge-PXV7Xljl.js → llm-judge-C8jMTNNG.js}

@@ -1,25 +1,25 @@
-import { i as JudgeError, s as ValidationError } from "./errors-Dngq5h35.js";
-import { a as hashCanonical, i as compareCodeUnits, r as canonicalString, t as LEDGER_HASH_PATTERN } from "./canonical-BsZVgBhW.js";
-import { t as mulberry32 } from "./random-Dn5fPWkt.js";
-import { o as summarizeNumberSeries, s as weightedComposite, t as confidenceInterval } from "./descriptive-CnU8Yq29.js";
-import { r as minimumPairsForPairedDeltaTest, t as decidePairedPromotion } from "./paired-promotion-decision-BN6IQTiu.js";
-import { a as heldoutSignificance, i as dimensionRegressions, o as pairHoldout } from "./statistical-heldout-1Gbmex7v.js";
-import { i as modelHasSnapshot, s as searchCellRunId } from "./run-record-DlTZ_lqe.js";
-import { n as contentHash } from "./verdict-cache-BQEsVy9n.js";
-import { r as projectCampaignCellQuality, t as campaignCellCostProvenance } from "./run-record-ES07wfz9.js";
-import { i as CostLedger, t as CostAccountingIncompleteError } from "./cost-ledger-D2FnJPBF.js";
-import { B as assertCampaignDesign, D as FinalEvidenceError, E as FinalEvidenceConflictError, F as surfaceHash, G as campaignSplitDigest, H as assertCompleteCampaign, I as surfaceHashMatches, L as BackendIntegrityError, M as renderSurfaceDiff, N as surfaceContentHash, P as surfaceDispatchRef, U as campaignCoverage, V as assertCampaignSplitIdentity, W as campaignScenarioIdentity, b as campaignMeanCompositeOrNull, q as formatCoverageFailures, t as createCampaignEvidenceReceipt, v as campaignBreakdown, y as campaignMeanComposite } from "./campaign-evidence-OcUciD-N.js";
-import { m as mapConcurrent } from "./journal-DvKCvjty.js";
+import { i as JudgeError, s as ValidationError } from "./errors-BcOs5MKW.js";
+import { a as hashCanonical, i as compareCodeUnits, r as canonicalString, t as LEDGER_HASH_PATTERN } from "./canonical-Dq2hOQ8L.js";
+import { i as modelHasSnapshot, s as searchCellRunId } from "./run-record-DhEJgoPz.js";
+import { t as mulberry32 } from "./random-DDDcC7YU.js";
+import { o as summarizeNumberSeries, s as weightedComposite, t as confidenceInterval } from "./descriptive-CVNy48rR.js";
+import { r as minimumPairsForPairedDeltaTest } from "./paired-promotion-decision-D0SHb-ZL.js";
+import { a as heldoutSignificance, i as dimensionRegressions, o as pairHoldout } from "./statistical-heldout-Bksv92Th.js";
+import { n as contentHash } from "./verdict-cache-CL_7tePD.js";
+import { r as projectCampaignCellQuality, t as campaignCellCostProvenance } from "./run-record-CysKLB93.js";
+import { n as CostAccountingIncompleteError, t as CostLedger } from "./cost-ledger-D0352Z4d.js";
+import { A as surfaceHashMatches, D as surfaceContentHash, E as renderSurfaceDiff, F as assertCampaignSplitIdentity, I as assertCompleteCampaign, L as campaignCoverage, O as surfaceDispatchRef, P as assertCampaignDesign, R as campaignScenarioIdentity, V as formatCoverageFailures, b as FinalEvidenceConflictError, f as campaignBreakdown, j as BackendIntegrityError, k as surfaceHash, m as campaignMeanCompositeOrNull, p as campaignMeanComposite, x as FinalEvidenceError, z as campaignSplitDigest } from "./campaign-evidence-CQYw8_0H.js";
 import { t as deepFreezeCanonicalJson } from "./deep-freeze-CurcOQg3.js";
-import { N as createRunCostLedger, P as fsCampaignStorage, g as isRecord, h as isExternalTextCandidate } from "./external-optimizer-subprocess-DcerlZSG.js";
-import { r as summarizeEvaluationUnits, t as defineEvaluationClaim } from "./claim-BXcZw-jo.js";
-import { f as redactText, n as REDACTION_VERSION, o as detectCredential, s as detectPersonalData } from "./redact-Dk1ZdJEm.js";
-import { t as detectRewardHacking } from "./reward-hacking-BFcQgkux.js";
-import { t as assertProposalFindings } from "./proposal-findings-BZiMTzAF.js";
-import { O as paretoFrontier, a as searchPolicyView, i as searchExpansionIndex, k as paretoFrontierWithCrowding, m as EXPANSION_OPERATORS, n as runSearch, t as SEARCH_KERNEL_SOURCE, x as estimateNode } from "./search-kernel-BztlERLv.js";
-import { a as validateSearchLedgerEvent, d as searchTaskSetDigest, i as replaySearchLedgerText, l as searchCellId, n as openSearchLedger, u as searchNodeId } from "./search-ledger-d7V8o9Lk.js";
-import { n as searchProposerView, t as renderSearchSummary } from "./search-summary-CBvz3u_S.js";
-import { C as combineAbortSignals, d as stripFencedJson, o as costReceiptFromLlm, s as costReceiptFromLlmError, u as maximumChargeForLlmRequest } from "./llm-client-DQveoxSM.js";
+import { M as fsCampaignStorage, h as isExternalTextCandidate, j as createRunCostLedger } from "./external-optimizer-subprocess-XIHBOSKt.js";
+import { r as summarizeEvaluationUnits, t as defineEvaluationClaim } from "./claim-BPVuyHuy.js";
+import { d as detectPersonalData, s as redactText, t as REDACTION_VERSION, u as detectCredential } from "./redact-mtkTiJVk.js";
+import { t as detectRewardHacking } from "./reward-hacking-ByuETaIb.js";
+import { t as assertProposalFindings } from "./proposal-findings-BbWidvUk.js";
+import { i as runSearch, m as searchExpansionIndex, n as paretoFrontier, o as searchPolicyView, p as SEARCH_KERNEL_SOURCE, r as paretoFrontierWithCrowding, s as EXPANSION_OPERATORS, w as estimateNode } from "./pareto-BzsxidFD.js";
+import { a as validateSearchLedgerEvent, d as searchNodeId, f as searchTaskSetDigest, i as replaySearchLedgerText, n as openSearchLedger, u as searchCellId } from "./search-ledger-TUvB5gWH.js";
+import { n as searchProposerView, t as renderSearchSummary } from "./search-summary-DQIvJsSB.js";
+import { i as stripFencedJson, n as isRecord } from "./json-BhdsJaOQ.js";
+import { a as maximumChargeForLlmRequest, i as costReceiptFromLlmError, r as costReceiptFromLlm } from "./llm-client-BshCREn6.js";
 import { createHash } from "node:crypto";
 import { writeFileSync } from "node:fs";
 import { z } from "zod";
@@ -1200,8 +1200,8 @@ function detectCalibrationDrift(runs, opts) {
 				alpha,
 				recentN: recent.length,
 				historyN: historical.length,
-				recentMean: mean$2(recent),
-				historyMean: mean$2(historical)
+				recentMean: mean$1(recent),
+				historyMean: mean$1(historical)
 			}
 		}],
 		evaluation: {
@@ -1438,7 +1438,7 @@ function chiSquareCritical(df, alpha) {
 	}
 	return TABLE[10][idx];
 }
-function mean$2(xs) {
+function mean$1(xs) {
 	if (xs.length === 0) return 0;
 	return xs.reduce((s, x) => s + x, 0) / xs.length;
 }
@@ -3190,7 +3190,6 @@ function nonEmpty(value, label) {
 * and a fact already in the ledger is not appended again, so a resumed search
 * continues its ledger instead of conflicting with its own history.
 */
-const MAX_LABEL_CHARS = 200;
 /** The default claim: development numbers over exactly the supplied tasks. */
 function developmentClaim(populationId) {
 	return {
@@ -3554,7 +3553,7 @@ function declaredSurfaces(surface, artifact) {
 }
 function boundedLabel(label) {
 	const redacted = redactText(label.trim(), { profile: "share" });
-	return redacted.length <= MAX_LABEL_CHARS ? redacted : `${redacted.slice(0, 199)}…`;
+	return redacted.length <= 200 ? redacted : `${redacted.slice(0, 199)}…`;
 }
 /** The header without its stamp, for comparing a resumed opening to the stored one. */
 function headerMaterial(header) {
@@ -3709,7 +3708,7 @@ function crowdedFrontierParent(options) {
 	});
 }
 /**
-* AIDE's search policy (`aide/agent.py`, `search_policy`) with three changes
+* AIDE's search_policy with three changes
 * for noisy scores.
 *
 * 1. **Draft** while fewer than `drafts` nodes were drafted: the root is the
@@ -3968,7 +3967,7 @@ function hillClimb(spec) {
 					evidence: {
 						...chosen.evidence,
 						units: units.length,
-						...units.length > 0 ? { mean: mean$1(units.map((unit) => unit.mean)) } : {},
+						...units.length > 0 ? { mean: mean(units.map((unit) => unit.mean)) } : {},
 						isLeader: chosen.nodeId === kept ? 1 : 0
 					}
 				}
@@ -4024,7 +4023,7 @@ function paretoMembers(view) {
 		members.push({
 			nodeId,
 			ordinal,
-			mean: sign * mean$1([...objectives.values()]),
+			mean: sign * mean([...objectives.values()]),
 			objectives,
 			distance: 0
 		});
@@ -4046,7 +4045,7 @@ function compareCrowded(a, b) {
 	if (a.mean !== b.mean) return a.mean > b.mean ? -1 : 1;
 	return a.ordinal - b.ordinal;
 }
-function mean$1(values) {
+function mean(values) {
 	let total = 0;
 	for (const value of values) total += value;
 	return total / values.length;
@@ -4058,285 +4057,9 @@ function mean$1(values) {
 function isProposedCandidate(value) {
 	return typeof value === "object" && value !== null && "surface" in value && "label" in value && "rationale" in value;
 }
-const LABEL_TRUST_RANK = {
-	unverified: 0,
-	"verified-signal": 1,
-	"human-rated": 2
-};
-/** Ordinal rank for a label-trust tier; absent ⇒ `unverified` (rank 0). */
-function labelTrustRank(trust) {
-	return LABEL_TRUST_RANK[trust ?? "unverified"];
-}
 //#endregion
-//#region src/campaign/presets/run-optimization.ts
-/**
-* `runOptimization` improves a mutable surface with a caller-owned proposer,
-* as a search on the one kernel (`runSearch`).
-*
-* The baseline is the seeded root. The scenarios are the train split: the
-* proposer reads their scores, and the policy ranks on them because the loop
-* has no private selection split. A "generation" is one proposal of
-* `populationSize` candidates from the node the policy chose (by default the
-* incumbent, once every earlier candidate is measured). Every candidate is a
-* node measured on every scenario at every repeat, one cell at a time on the
-* run's lanes. The kept surface is the policy's leader: a budget decision on
-* the train split that claims nothing; `runImprovementLoop` compares it with
-* the baseline on separate cases.
-*
-* The search ledger is always written, beside the run (`<runDir>/search/`) or
-* where `searchLedger` puts it, and it is the run's only checkpoint: running
-* again on the same run directory and options continues an interrupted run
-* instead of starting over, and reruns nothing that settled.
-*/
-/** Improve a surface as a search on the kernel; see the module comment. */
-async function runOptimization(opts) {
-	const candidateConcurrency = opts.candidateConcurrency ?? 1;
-	if (typeof opts.runDir !== "string" || opts.runDir.trim().length === 0) throw new Error("runOptimization: runDir is required and must be a non-empty string");
-	if (!Number.isInteger(candidateConcurrency) || candidateConcurrency < 1) throw new Error("runOptimization: candidateConcurrency must be a positive integer");
-	for (const [name, value] of [["populationSize", opts.populationSize], ["maxGenerations", opts.maxGenerations]]) if (!Number.isSafeInteger(value) || value < 0) throw new Error(`runOptimization: ${name} must be a non-negative integer`);
-	const initialFindings = immutableProposalSnapshot(assertProposalFindings(opts.findings ?? [], "runOptimization initial proposal findings"), "initial findings");
-	const baselineSurface = immutableProposalSnapshot(opts.baselineSurface, "baseline surface");
-	const runDir = resolveRunDir(opts.runDir, opts.repo);
-	const storage = opts.storage ?? fsCampaignStorage();
-	const costLedger = opts.costLedger ?? createRunCostLedger({
-		storage,
-		runDir,
-		costCeilingUsd: opts.costCeiling
-	});
-	const reps = opts.reps ?? 1;
-	const seed = opts.seed ?? 42;
-	const requireJudgeScore = (opts.judges?.length ?? 0) > 0;
-	const premeasured = opts.premeasuredBaseline ? validatedPremeasuredBaseline({
-		input: opts.premeasuredBaseline,
-		baselineSurface,
-		scenarios: opts.scenarios,
-		reps,
-		seed,
-		judges: opts.judges ?? [],
-		dispatchRef: surfaceDispatchRef(baselineSurface, opts.dispatchRef),
-		requireJudgeScore
-	}) : void 0;
-	const splitDigest = campaignSplitDigest(opts.scenarios, reps);
-	const binding = opts.searchLedger ?? await defaultBinding(opts, runDir, storage);
-	const { identity } = binding;
-	const execution = {
-		model: identity.model,
-		agent: identity.agent,
-		benchmark: {
-			uri: "campaign://scenarios",
-			revision: splitDigest
-		}
-	};
-	const policy = opts.policy ?? incumbent();
-	const allocation = uniform({ reps });
-	const recorder = await SearchRecorder.open({
-		ledger: binding.ledger,
-		storage
-	}, {
-		subject: identity.subject ?? opts.proposer.kind,
-		process: {
-			name: "runOptimization",
-			executionRef: identity.search
-		},
-		artifactKind: artifactKindOf(baselineSurface),
-		objective: {
-			metric: "composite",
-			direction: "maximize",
-			judge: identity.judge ?? { unknown: "runOptimization receives its judges as functions without a pinned source" },
-			claim: identity.claim ?? developmentClaim(splitDigest)
-		},
-		splits: {
-			train: opts.scenarios.map((scenario) => ({
-				taskId: scenario.id,
-				unitId: scenario.id,
-				source: {
-					uri: `scenario://${scenario.id}`,
-					revision: hashCanonical(scenario)
-				}
-			})),
-			selection: [],
-			test: [],
-			heldOutUnits: true
-		},
-		policy: {
-			expansion: policy.name,
-			allocation: allocation.name,
-			seed
-		},
-		budget: {
-			maxUsd: opts.costCeiling ?? null,
-			maxCells: null,
-			maxNodes: 1 + opts.populationSize * opts.maxGenerations,
-			deadline: null,
-			maxConcurrency: null,
-			reservedClaimUsd: 0
-		},
-		containment: null,
-		derivedFrom: null,
-		identity: execution
-	});
-	const nodes = new SurfaceNodes({
-		opts,
-		recorder,
-		runDir,
-		costLedger,
-		execution,
-		premeasured
-	});
-	const scenarioById = new Map(opts.scenarios.map((scenario) => [scenario.id, scenario]));
-	let findings = initialFindings;
-	const executor = {
-		lanes: () => [{
-			name: "campaign",
-			capacity: candidateConcurrency * (opts.maxConcurrency ?? 2),
-			costCap: "estimate",
-			cellUsd: 0
-		}],
-		place: () => "campaign",
-		run: (work) => nodes.runCell(work, scenarioById),
-		adopt: (work) => nodes.adoptCell(work)
-	};
-	const proposer = opts.proposer;
-	const proposerSource = identity.proposer.source;
-	const port = {
-		name: proposer.kind,
-		kind: "optimizer",
-		source: proposerSource,
-		execution: identity.proposer,
-		childrenPerProposal: opts.populationSize,
-		async propose(request) {
-			const phases = [
-				"search.proposal",
-				"analysis.baseline",
-				"analysis.generation"
-			];
-			const before = new Set(phases.flatMap((phase) => costLedger.list({ phase })).map(receiptKey));
-			const accounting = () => {
-				const fresh = phases.flatMap((phase) => costLedger.list({ phase })).filter((receipt) => !before.has(receiptKey(receipt)));
-				return {
-					accounting: searchReceiptAccounting(fresh),
-					execution: opts.searchLedger ? identity.proposer : searchProposalExecution(fresh, identity.model.provider, proposerSource)
-				};
-			};
-			const earlier = await recorder.state();
-			const root = earlier.rootNodeId;
-			const rootCampaign = nodes.campaign(earlier, root);
-			const rootCoverage = campaignCoverage(rootCampaign.cells, opts.scenarios, reps, requireJudgeScore);
-			if (!rootCoverage.complete) throw new Error(`runOptimization: ${premeasured ? "premeasured baseline" : "baseline"} is incomplete (${rootCoverage.scorableCellIds.length}/${rootCoverage.expectedCellIds.length} designed cells scorable) — ${formatCoverageFailures(rootCoverage)}. Refusing to optimize against an incomplete incumbent.`);
-			const generation = nodes.generations(earlier).length;
-			if (opts.analyzeGeneration) {
-				const previous = generation - 1;
-				const candidates = (previous < 0 ? [root] : nodes.expansionNodes(earlier, nodes.generations(earlier)[previous])).map((nodeId) => {
-					const campaign = nodes.campaign(earlier, nodeId);
-					return {
-						surfaceHash: surfaceHash(nodes.surface(earlier, nodeId)),
-						campaign,
-						composite: campaignMeanCompositeOrNull(campaign)
-					};
-				});
-				const history = nodes.history(earlier, policy);
-				if (candidates.some(({ campaign }) => campaign.cells.length > 0)) {
-					const fresh = await opts.analyzeGeneration({
-						generation: previous,
-						runDir: previous < 0 ? rootCampaign.runDir : `${runDir}/candidates`,
-						candidates,
-						history,
-						costLedger,
-						costPhase: previous < 0 ? "analysis.baseline" : "analysis.generation"
-					});
-					if (!Array.isArray(fresh)) throw new TypeError("runOptimization: analyzeGeneration must return an array");
-					findings = immutableProposalSnapshot(assertProposalFindings(fresh, "runOptimization analysis findings"), "analysis findings");
-				}
-			}
-			const state = await recorder.state();
-			const proposalHistory = immutableProposalSnapshot(nodes.history(state, policy), "history");
-			const parent = request.parents[0];
-			const context = Object.freeze({
-				currentSurface: immutableProposalSnapshot(parent.artifact, "current surface"),
-				operator: request.operator,
-				parents: immutableProposalSnapshot(request.parents.map(({ nodeId, artifact }) => ({
-					nodeId,
-					artifact: immutableProposalSnapshot(artifact, "parent surface")
-				})), "parents"),
-				train: searchProposerView(state),
-				summary: renderSearchSummary(state, { split: "train" }),
-				history: proposalHistory,
-				findings: immutableProposalSnapshot(assertProposalFindings(findings, "runOptimization proposal findings"), "findings"),
-				populationSize: opts.populationSize,
-				generation,
-				signal: request.signal,
-				baselineOutcome: immutableProposalSnapshot(nodes.outcome(state, root), "baseline"),
-				incumbentOutcome: immutableProposalSnapshot(nodes.outcome(state, request.leader), "incumbent outcome"),
-				parentOutcome: immutableProposalSnapshot(nodes.outcome(state, parent.nodeId), "parent outcome"),
-				maxImprovementShots: opts.maxImprovementShots,
-				paretoParents: immutableProposalSnapshot(nodes.frontier(state), "Pareto parents"),
-				costLedger,
-				costPhase: "search.proposal"
-			});
-			if (proposer.decide?.({ history: proposalHistory }).stop) return {
-				children: [],
-				stop: "the proposer decided to stop",
-				...accounting()
-			};
-			const proposed = await proposer.propose(context);
-			if (!Array.isArray(proposed)) throw new TypeError("runOptimization: proposer must return an array");
-			return {
-				children: immutableProposalSnapshot(proposed, "candidate outputs").slice(0, opts.populationSize).map((candidate) => isProposedCandidate(candidate) ? {
-					artifact: candidate.surface,
-					label: candidate.label,
-					rationale: candidate.rationale,
-					...candidate.attribution ? { attribution: candidate.attribution } : {}
-				} : {
-					artifact: candidate,
-					label: "",
-					rationale: ""
-				}),
-				...accounting()
-			};
-		}
-	};
-	const result = await runSearch({
-		recorder,
-		root: baselineSurface,
-		codec: surfaceCodec,
-		policy,
-		allocation,
-		proposer: port,
-		executor,
-		maxExpansions: opts.maxGenerations,
-		signal: opts.signal
-	});
-	const state = result.state;
-	const winnerSurface = nodes.surface(state, result.leader);
-	const firstEdge = state.edge(state.node(result.leader).edgeIds[0]);
-	const winnerRationale = firstEdge.operator === "seed" || !("sha256" in firstEdge.rationale) ? void 0 : recorder.readBlob(firstEdge.rationale).text;
-	const expansions = nodes.generations(state);
-	return {
-		generations: nodes.history(state, policy).map((record) => ({
-			record,
-			surfaces: nodes.expansionNodes(state, expansions[record.generationIndex]).map((nodeId) => {
-				const surface = nodes.surface(state, nodeId);
-				return {
-					surfaceHash: surfaceHash(surface),
-					surface,
-					campaign: nodes.campaign(state, nodeId)
-				};
-			})
-		})),
-		baselineSurface,
-		winnerSurface,
-		winnerSurfaceHash: surfaceHash(winnerSurface),
-		...firstEdge.operator !== "seed" && firstEdge.label ? { winnerLabel: firstEdge.label } : {},
-		...winnerRationale ? { winnerRationale } : {},
-		baselineCampaign: nodes.campaign(state, state.rootNodeId),
-		cost: costLedger.summary(),
-		searchHistory: recorder.receipt({
-			producerId: proposer.kind,
-			runId: runDir
-		}),
-		paretoFrontier: nodes.frontier(state)
-	};
-}
+//#region src/campaign/presets/optimization-surface-nodes.ts
+/** Surface-node campaigns, cached cell adoption, and proposer history from the search ledger. */
 /** A mutable surface as a search artifact. */
 const surfaceCodec = {
 	node: surfaceNode,
@@ -4364,14 +4087,14 @@ var SurfaceNodes = class {
 	proposals = /* @__PURE__ */ new Map();
 	/** Cells this process ran or adopted, by node, keyed `scenarioId:rep`. */
 	cells = /* @__PURE__ */ new Map();
-	constructor(input) {
-		this.opts = input.opts;
-		this.recorder = input.recorder;
-		this.runDir = input.runDir;
-		this.costLedger = input.costLedger;
-		this.execution = input.execution;
-		this.premeasured = input.premeasured;
-		this.storage = input.opts.storage ?? fsCampaignStorage();
+	constructor(opts, recorder, runDir, costLedger, execution, premeasured) {
+		this.opts = opts;
+		this.recorder = recorder;
+		this.runDir = runDir;
+		this.costLedger = costLedger;
+		this.execution = execution;
+		this.premeasured = premeasured;
+		this.storage = opts.storage ?? fsCampaignStorage();
 	}
 	/** `<runDir>/baseline` for the root, `<runDir>/candidates/<surfaceHash>`
 	* for every other node: content-addressed, so a cell's directory needs no
@@ -4406,7 +4129,10 @@ var SurfaceNodes = class {
 		const cell = cached === void 0 ? void 0 : JSON.parse(cached);
 		if (cell?.manifestHash !== this.manifestFor(work.artifact)) return null;
 		this.remember(work.nodeId, cell);
-		return this.cellResult(cell, work);
+		return campaignCellSearchResult(cell, {
+			execution: this.execution,
+			lane: work.lane
+		});
 	}
 	/** Run one cell as a one-cell campaign in its node's directory; a cached
 	* cell is read back, not dispatched again. */
@@ -4421,7 +4147,10 @@ var SurfaceNodes = class {
 		})).cells[0];
 		if (!cell) throw new Error(`runOptimization: cell ${work.cellId} produced no campaign cell`);
 		this.remember(work.nodeId, cell);
-		return this.cellResult(cell, work);
+		return campaignCellSearchResult(cell, {
+			execution: this.execution,
+			lane: work.lane
+		});
 	}
 	/** The node's campaign over the cells the ledger settled: the cells this
 	* process ran, else their cached results or failure receipts. */
@@ -4589,7 +4318,10 @@ var SurfaceNodes = class {
 	premeasuredCell(work) {
 		const cell = this.premeasured.cells.find((candidate) => candidate.scenarioId === work.taskId && candidate.rep === work.rep);
 		if (!cell) throw new Error(`runOptimization: premeasured baseline lacks ${work.taskId}:${work.rep}`);
-		return this.cellResult(cell, work);
+		return campaignCellSearchResult(cell, {
+			execution: this.execution,
+			lane: work.lane
+		});
 	}
 	/** A cell's result as its campaign stored it for this surface: the cache of
 	* a scored cell, the final failure receipt of a failed one. A result another
@@ -4606,34 +4338,334 @@ var SurfaceNodes = class {
 			const cell = result !== void 0 ? JSON.parse(result) : receipt !== void 0 ? JSON.parse(receipt).cell : void 0;
 			return cell?.manifestHash === manifestHash ? cell : void 0;
 		}
-		const cached = this.storage.read(cellCachePath(dir, cellId));
-		const scored = cached === void 0 ? void 0 : JSON.parse(cached);
-		if (scored?.manifestHash === manifestHash) return scored;
-		const receipt = this.storage.read(join(cellDirectory(dir, cellId), "failure-receipt.json"));
-		const failed = receipt === void 0 ? void 0 : JSON.parse(receipt).cell;
-		return failed?.manifestHash === manifestHash ? failed : void 0;
-	}
-	manifestFor(surface) {
-		return computeManifestHash({
-			scenarios: this.opts.scenarios,
-			judges: this.opts.judges ?? [],
-			dispatchRef: surfaceDispatchRef(surface, this.opts.dispatchRef),
-			seed: this.opts.seed ?? 42,
-			reps: this.opts.reps ?? 1
-		});
-	}
-	remember(nodeId, cell) {
-		const cells = this.cells.get(nodeId) ?? /* @__PURE__ */ new Map();
-		cells.set(`${cell.scenarioId}:${cell.rep}`, cell);
-		this.cells.set(nodeId, cells);
-	}
-	cellResult(cell, work) {
-		return campaignCellSearchResult(cell, {
-			execution: this.execution,
-			lane: work.lane
-		});
-	}
-};
+		const cached = this.storage.read(cellCachePath(dir, cellId));
+		const scored = cached === void 0 ? void 0 : JSON.parse(cached);
+		if (scored?.manifestHash === manifestHash) return scored;
+		const receipt = this.storage.read(join(cellDirectory(dir, cellId), "failure-receipt.json"));
+		const failed = receipt === void 0 ? void 0 : JSON.parse(receipt).cell;
+		return failed?.manifestHash === manifestHash ? failed : void 0;
+	}
+	manifestFor(surface) {
+		return computeManifestHash({
+			scenarios: this.opts.scenarios,
+			judges: this.opts.judges ?? [],
+			dispatchRef: surfaceDispatchRef(surface, this.opts.dispatchRef),
+			seed: this.opts.seed ?? 42,
+			reps: this.opts.reps ?? 1
+		});
+	}
+	remember(nodeId, cell) {
+		const cells = this.cells.get(nodeId) ?? /* @__PURE__ */ new Map();
+		cells.set(`${cell.scenarioId}:${cell.rep}`, cell);
+		this.cells.set(nodeId, cells);
+	}
+};
+/** A scored campaign as a frontier member: per-scenario composite objectives. */
+function toParetoParent(surface, campaign, generation, label) {
+	const objectives = {};
+	for (const { scenarioId, composite } of campaignBreakdown(campaign).scenarios) objectives[scenarioId] = composite;
+	const parent = {
+		surface,
+		surfaceHash: surfaceHash(surface),
+		objectives,
+		composite: campaignMeanComposite(campaign),
+		generation
+	};
+	if (label) parent.label = label;
+	return parent;
+}
+/** The non-dominated set over the per-scenario objective vectors. */
+function computeParetoFrontier(scored) {
+	if (scored.length <= 1) return [...scored];
+	const ids = /* @__PURE__ */ new Set();
+	for (const p of scored) for (const id of Object.keys(p.objectives)) ids.add(id);
+	if (ids.size === 0) return [...scored];
+	const objectives = [...ids].map((id) => ({
+		name: id,
+		direction: "maximize",
+		value: (p) => p.objectives[id] ?? Number.NEGATIVE_INFINITY
+	}));
+	return paretoFrontier(scored, objectives).frontier;
+}
+function toScoredSurfaceOutcome(hash, campaign, coverage, generation) {
+	const breakdown = campaignBreakdown(campaign);
+	return {
+		split: "search",
+		generation,
+		surfaceHash: hash,
+		composite: campaignMeanComposite(campaign),
+		dimensions: breakdown.dimensions,
+		scenarios: breakdown.scenarios,
+		coverage: {
+			expectedCells: coverage.expectedCellIds.length,
+			scorableCells: coverage.scorableCellIds.length
+		}
+	};
+}
+//#endregion
+//#region src/campaign/presets/run-optimization.ts
+/**
+* `runOptimization` improves a mutable surface with a caller-owned proposer,
+* as a search on the one kernel (`runSearch`).
+*
+* The baseline is the seeded root. The scenarios are the train split: the
+* proposer reads their scores, and the policy ranks on them because the loop
+* has no private selection split. A "generation" is one proposal of
+* `populationSize` candidates from the node the policy chose (by default the
+* incumbent, once every earlier candidate is measured). Every candidate is a
+* node measured on every scenario at every repeat, one cell at a time on the
+* run's lanes. The kept surface is the policy's leader: a budget decision on
+* the train split that claims nothing; `runImprovementLoop` compares it with
+* the baseline on separate cases.
+*
+* The search ledger is always written, beside the run (`<runDir>/search/`) or
+* where `searchLedger` puts it, and it is the run's only checkpoint: running
+* again on the same run directory and options continues an interrupted run
+* instead of starting over, and reruns nothing that settled.
+*/
+/** Compose the optimization proposer and cell executor on the shared search kernel. */
+/** Improve a surface as a search on the kernel; see the module comment. */
+async function runOptimization(opts) {
+	const candidateConcurrency = opts.candidateConcurrency ?? 1;
+	if (typeof opts.runDir !== "string" || opts.runDir.trim().length === 0) throw new Error("runOptimization: runDir is required and must be a non-empty string");
+	if (!Number.isInteger(candidateConcurrency) || candidateConcurrency < 1) throw new Error("runOptimization: candidateConcurrency must be a positive integer");
+	for (const [name, value] of [["populationSize", opts.populationSize], ["maxGenerations", opts.maxGenerations]]) if (!Number.isSafeInteger(value) || value < 0) throw new Error(`runOptimization: ${name} must be a non-negative integer`);
+	const initialFindings = immutableProposalSnapshot(assertProposalFindings(opts.findings ?? [], "runOptimization initial proposal findings"), "initial findings");
+	const baselineSurface = immutableProposalSnapshot(opts.baselineSurface, "baseline surface");
+	const runDir = resolveRunDir(opts.runDir, opts.repo);
+	const storage = opts.storage ?? fsCampaignStorage();
+	const costLedger = opts.costLedger ?? createRunCostLedger({
+		storage,
+		runDir,
+		costCeilingUsd: opts.costCeiling
+	});
+	const reps = opts.reps ?? 1;
+	const seed = opts.seed ?? 42;
+	const requireJudgeScore = (opts.judges?.length ?? 0) > 0;
+	const premeasured = opts.premeasuredBaseline ? validatedPremeasuredBaseline({
+		input: opts.premeasuredBaseline,
+		baselineSurface,
+		scenarios: opts.scenarios,
+		reps,
+		seed,
+		judges: opts.judges ?? [],
+		dispatchRef: surfaceDispatchRef(baselineSurface, opts.dispatchRef),
+		requireJudgeScore
+	}) : void 0;
+	const splitDigest = campaignSplitDigest(opts.scenarios, reps);
+	const binding = opts.searchLedger ?? await defaultBinding(opts, runDir, storage);
+	const { identity } = binding;
+	const execution = {
+		model: identity.model,
+		agent: identity.agent,
+		benchmark: {
+			uri: "campaign://scenarios",
+			revision: splitDigest
+		}
+	};
+	const policy = opts.policy ?? incumbent();
+	const allocation = uniform({ reps });
+	const recorder = await SearchRecorder.open({
+		ledger: binding.ledger,
+		storage
+	}, {
+		subject: identity.subject ?? opts.proposer.kind,
+		process: {
+			name: "runOptimization",
+			executionRef: identity.search
+		},
+		artifactKind: typeof baselineSurface === "object" && baselineSurface.kind === "code" ? "code" : "prompt",
+		objective: {
+			metric: "composite",
+			direction: "maximize",
+			judge: identity.judge ?? { unknown: "runOptimization receives its judges as functions without a pinned source" },
+			claim: identity.claim ?? developmentClaim(splitDigest)
+		},
+		splits: {
+			train: opts.scenarios.map((scenario) => ({
+				taskId: scenario.id,
+				unitId: scenario.id,
+				source: {
+					uri: `scenario://${scenario.id}`,
+					revision: hashCanonical(scenario)
+				}
+			})),
+			selection: [],
+			test: [],
+			heldOutUnits: true
+		},
+		policy: {
+			expansion: policy.name,
+			allocation: allocation.name,
+			seed
+		},
+		budget: {
+			maxUsd: opts.costCeiling ?? null,
+			maxCells: null,
+			maxNodes: 1 + opts.populationSize * opts.maxGenerations,
+			deadline: null,
+			maxConcurrency: null,
+			reservedClaimUsd: 0
+		},
+		containment: null,
+		derivedFrom: null,
+		identity: execution
+	});
+	const nodes = new SurfaceNodes(opts, recorder, runDir, costLedger, execution, premeasured);
+	const scenarioById = new Map(opts.scenarios.map((scenario) => [scenario.id, scenario]));
+	let findings = initialFindings;
+	const executor = {
+		lanes: () => [{
+			name: "campaign",
+			capacity: candidateConcurrency * (opts.maxConcurrency ?? 2),
+			costCap: "estimate",
+			cellUsd: 0
+		}],
+		place: () => "campaign",
+		run: (work) => nodes.runCell(work, scenarioById),
+		adopt: (work) => nodes.adoptCell(work)
+	};
+	const proposer = opts.proposer;
+	const proposerSource = identity.proposer.source;
+	const port = {
+		name: proposer.kind,
+		kind: "optimizer",
+		source: proposerSource,
+		execution: identity.proposer,
+		childrenPerProposal: opts.populationSize,
+		async propose(request) {
+			const phases = [
+				"search.proposal",
+				"analysis.baseline",
+				"analysis.generation"
+			];
+			const before = new Set(phases.flatMap((phase) => costLedger.list({ phase })).map((receipt) => receipt.callId));
+			const accounting = () => {
+				const fresh = phases.flatMap((phase) => costLedger.list({ phase })).filter((receipt) => !before.has(receipt.callId));
+				return {
+					accounting: searchReceiptAccounting(fresh),
+					execution: opts.searchLedger ? identity.proposer : searchProposalExecution(fresh, identity.model.provider, proposerSource)
+				};
+			};
+			const earlier = await recorder.state();
+			const root = earlier.rootNodeId;
+			const rootCampaign = nodes.campaign(earlier, root);
+			const rootCoverage = campaignCoverage(rootCampaign.cells, opts.scenarios, reps, requireJudgeScore);
+			if (!rootCoverage.complete) throw new Error(`runOptimization: ${premeasured ? "premeasured baseline" : "baseline"} is incomplete (${rootCoverage.scorableCellIds.length}/${rootCoverage.expectedCellIds.length} designed cells scorable) — ${formatCoverageFailures(rootCoverage)}. Refusing to optimize against an incomplete incumbent.`);
+			const generation = nodes.generations(earlier).length;
+			if (opts.analyzeGeneration) {
+				const previous = generation - 1;
+				const candidates = (previous < 0 ? [root] : nodes.expansionNodes(earlier, nodes.generations(earlier)[previous])).map((nodeId) => {
+					const campaign = nodes.campaign(earlier, nodeId);
+					return {
+						surfaceHash: surfaceHash(nodes.surface(earlier, nodeId)),
+						campaign,
+						composite: campaignMeanCompositeOrNull(campaign)
+					};
+				});
+				const history = nodes.history(earlier, policy);
+				if (candidates.some(({ campaign }) => campaign.cells.length > 0)) {
+					const fresh = await opts.analyzeGeneration({
+						generation: previous,
+						runDir: previous < 0 ? rootCampaign.runDir : `${runDir}/candidates`,
+						candidates,
+						history,
+						costLedger,
+						costPhase: previous < 0 ? "analysis.baseline" : "analysis.generation"
+					});
+					if (!Array.isArray(fresh)) throw new TypeError("runOptimization: analyzeGeneration must return an array");
+					findings = immutableProposalSnapshot(assertProposalFindings(fresh, "runOptimization analysis findings"), "analysis findings");
+				}
+			}
+			const state = await recorder.state();
+			const proposalHistory = immutableProposalSnapshot(nodes.history(state, policy), "history");
+			const parent = request.parents[0];
+			const context = Object.freeze({
+				currentSurface: immutableProposalSnapshot(parent.artifact, "current surface"),
+				operator: request.operator,
+				parents: immutableProposalSnapshot(request.parents.map(({ nodeId, artifact }) => ({
+					nodeId,
+					artifact: immutableProposalSnapshot(artifact, "parent surface")
+				})), "parents"),
+				train: searchProposerView(state),
+				summary: renderSearchSummary(state, { split: "train" }),
+				history: proposalHistory,
+				findings: immutableProposalSnapshot(assertProposalFindings(findings, "runOptimization proposal findings"), "findings"),
+				populationSize: opts.populationSize,
+				generation,
+				signal: request.signal,
+				baselineOutcome: immutableProposalSnapshot(nodes.outcome(state, root), "baseline"),
+				incumbentOutcome: immutableProposalSnapshot(nodes.outcome(state, request.leader), "incumbent outcome"),
+				parentOutcome: immutableProposalSnapshot(nodes.outcome(state, parent.nodeId), "parent outcome"),
+				maxImprovementShots: opts.maxImprovementShots,
+				paretoParents: immutableProposalSnapshot(nodes.frontier(state), "Pareto parents"),
+				costLedger,
+				costPhase: "search.proposal"
+			});
+			if (proposer.decide?.({ history: proposalHistory }).stop) return {
+				children: [],
+				stop: "the proposer decided to stop",
+				...accounting()
+			};
+			const proposed = await proposer.propose(context);
+			if (!Array.isArray(proposed)) throw new TypeError("runOptimization: proposer must return an array");
+			return {
+				children: immutableProposalSnapshot(proposed, "candidate outputs").slice(0, opts.populationSize).map((candidate) => isProposedCandidate(candidate) ? {
+					artifact: candidate.surface,
+					label: candidate.label,
+					rationale: candidate.rationale,
+					...candidate.attribution ? { attribution: candidate.attribution } : {}
+				} : {
+					artifact: candidate,
+					label: "",
+					rationale: ""
+				}),
+				...accounting()
+			};
+		}
+	};
+	const result = await runSearch({
+		recorder,
+		root: baselineSurface,
+		codec: surfaceCodec,
+		policy,
+		allocation,
+		proposer: port,
+		executor,
+		maxExpansions: opts.maxGenerations,
+		signal: opts.signal
+	});
+	const state = result.state;
+	const winnerSurface = nodes.surface(state, result.leader);
+	const firstEdge = state.edge(state.node(result.leader).edgeIds[0]);
+	const winnerRationale = firstEdge.operator === "seed" || !("sha256" in firstEdge.rationale) ? void 0 : recorder.readBlob(firstEdge.rationale).text;
+	const expansions = nodes.generations(state);
+	return {
+		generations: nodes.history(state, policy).map((record) => ({
+			record,
+			surfaces: nodes.expansionNodes(state, expansions[record.generationIndex]).map((nodeId) => {
+				const surface = nodes.surface(state, nodeId);
+				return {
+					surfaceHash: surfaceHash(surface),
+					surface,
+					campaign: nodes.campaign(state, nodeId)
+				};
+			})
+		})),
+		baselineSurface,
+		winnerSurface,
+		winnerSurfaceHash: surfaceHash(winnerSurface),
+		...firstEdge.operator !== "seed" && firstEdge.label ? { winnerLabel: firstEdge.label } : {},
+		...winnerRationale ? { winnerRationale } : {},
+		baselineCampaign: nodes.campaign(state, state.rootNodeId),
+		cost: costLedger.summary(),
+		searchHistory: recorder.receipt({
+			producerId: proposer.kind,
+			runId: runDir
+		}),
+		paretoFrontier: nodes.frontier(state)
+	};
+}
 /** The default ledger and identities when the caller binds none. Revisions are
 * content digests of what the caller declared, and each uri names what its
 * digest covers: the dispatch ref, the proposer kind, the kernel. */
@@ -4676,12 +4708,6 @@ async function defaultBinding(opts, runDir, storage) {
 		};
 	}
 }
-function artifactKindOf(surface) {
-	return typeof surface === "object" && surface.kind === "code" ? "code" : "prompt";
-}
-function receiptKey(receipt) {
-	return receipt.callId;
-}
 function immutableProposalSnapshot(value, label) {
 	try {
 		return deepFreeze(structuredClone(value));
@@ -4719,48 +4745,6 @@ function validatedPremeasuredBaseline(args) {
 	if (!coverage.complete) throw new Error(`runOptimization: premeasured baseline is incomplete (${coverage.scorableCellIds.length}/${coverage.expectedCellIds.length} designed cells scorable) — ${formatCoverageFailures(coverage)}. Refusing to optimize against an incomplete incumbent.`);
 	return campaign;
 }
-/** A scored campaign as a frontier member: per-scenario composite objectives. */
-function toParetoParent(surface, campaign, generation, label) {
-	const objectives = {};
-	for (const { scenarioId, composite } of campaignBreakdown(campaign).scenarios) objectives[scenarioId] = composite;
-	const parent = {
-		surface,
-		surfaceHash: surfaceHash(surface),
-		objectives,
-		composite: campaignMeanComposite(campaign),
-		generation
-	};
-	if (label) parent.label = label;
-	return parent;
-}
-/** The non-dominated set over the per-scenario objective vectors. */
-function computeParetoFrontier(scored) {
-	if (scored.length <= 1) return [...scored];
-	const ids = /* @__PURE__ */ new Set();
-	for (const p of scored) for (const id of Object.keys(p.objectives)) ids.add(id);
-	if (ids.size === 0) return [...scored];
-	const objectives = [...ids].map((id) => ({
-		name: id,
-		direction: "maximize",
-		value: (p) => p.objectives[id] ?? Number.NEGATIVE_INFINITY
-	}));
-	return paretoFrontier(scored, objectives).frontier;
-}
-function toScoredSurfaceOutcome(hash, campaign, coverage, generation) {
-	const breakdown = campaignBreakdown(campaign);
-	return {
-		split: "search",
-		generation,
-		surfaceHash: hash,
-		composite: campaignMeanComposite(campaign),
-		dimensions: breakdown.dimensions,
-		scenarios: breakdown.scenarios,
-		coverage: {
-			expectedCells: coverage.expectedCellIds.length,
-			scorableCells: coverage.scorableCellIds.length
-		}
-	};
-}
 //#endregion
 //#region src/campaign/presets/run-improvement-loop.ts
 /**
@@ -4830,10 +4814,126 @@ async function runImprovementLoop(opts) {
 		ghRepo: opts.ghRepo
 	});
 	return {
-		...optimization,
-		...comparison,
-		prResult,
-		cost: costLedger.summary()
+		...optimization,
+		...comparison,
+		prResult,
+		cost: costLedger.summary()
+	};
+}
+//#endregion
+//#region src/campaign/optimization-cost.ts
+/** Attribute method calls while retaining the shared account's admission and read behavior. */
+function createMethodCostScope(account, methodName) {
+	const tags = { [`optimizationAttempt:${crypto.randomUUID()}`]: methodName };
+	return {
+		ledger: Object.freeze({
+			costCeilingUsd: account.costCeilingUsd,
+			runPaidCall: (input) => account.runPaidCall({
+				...input,
+				tags: {
+					...input.tags,
+					...tags
+				}
+			}),
+			summary: account.summary.bind(account),
+			list: account.list.bind(account),
+			reconcile: account.reconcile.bind(account),
+			markCompleted: account.markCompleted.bind(account),
+			costPerCompletedTask: account.costPerCompletedTask.bind(account),
+			...account.listPending ? { listPending: account.listPending.bind(account) } : {},
+			...account.waitForIdle ? { waitForIdle: account.waitForIdle.bind(account) } : {}
+		}),
+		reconcile(reported) {
+			const summary = account.summary({ tags });
+			if (summary.pendingCalls > 0) throw new Error(`optimization method '${methodName}' returned with ${summary.pendingCalls} pending paid call(s)`);
+			const recorded = costFromLedgerSummary(summary);
+			const totalCostUsd = Math.max(reported.totalCostUsd, recorded.totalCostUsd);
+			const roundingToleranceUsd = Number.EPSILON * Math.max(1, totalCostUsd) * (summary.totalCalls + 1);
+			const combined = combineComparisonCosts([{
+				label: "reported",
+				cost: reported
+			}, {
+				label: "recorded",
+				cost: recorded
+			}]);
+			const incompleteReasons = [
+				...reported.incompleteReasons,
+				...recorded.incompleteReasons.map((reason) => `recorded: ${reason}`),
+				...recorded.totalCostUsd - reported.totalCostUsd > roundingToleranceUsd ? [`reported ${reported.totalCostUsd} USD below recorded ${recorded.totalCostUsd} USD`] : []
+			];
+			return {
+				totalCostUsd,
+				costProvenance: combined.costProvenance.kind === "uncaptured" ? combined.costProvenance : {
+					kind: combined.costProvenance.kind,
+					usd: totalCostUsd
+				},
+				accountingComplete: incompleteReasons.length === 0,
+				incompleteReasons
+			};
+		}
+	};
+}
+/** Keep the cost fields a custom optimization method must report. */
+function costFromLedgerSummary(summary) {
+	const cost = {
+		totalCostUsd: summary.totalCostUsd,
+		costProvenance: structuredClone(summary.costProvenance),
+		accountingComplete: summary.accountingComplete,
+		incompleteReasons: [...summary.incompleteReasons]
+	};
+	assertComparisonCost(cost, "cost ledger");
+	return cost;
+}
+/** Combine method costs without turning one unknown bill into a known total. */
+function combineComparisonCosts(entries) {
+	const totalCostUsd = entries.reduce((total, entry) => total + entry.cost.totalCostUsd, 0);
+	const cost = {
+		totalCostUsd,
+		costProvenance: entries.some((entry) => entry.cost.costProvenance.kind === "uncaptured") ? {
+			kind: "uncaptured",
+			usd: null
+		} : entries.every((entry) => entry.cost.costProvenance.kind === "observed") ? {
+			kind: "observed",
+			usd: totalCostUsd
+		} : {
+			kind: "estimated",
+			usd: totalCostUsd
+		},
+		accountingComplete: entries.every((entry) => entry.cost.accountingComplete),
+		incompleteReasons: entries.flatMap((entry) => entry.cost.incompleteReasons.map((reason) => `${entry.label}: ${reason}`))
+	};
+	assertComparisonCost(cost, "combined cost");
+	return cost;
+}
+function assertComparisonCost(cost, label) {
+	if (!cost || typeof cost !== "object") throw new Error(`compareOptimizationMethods: ${label} returned no cost`);
+	if (!Number.isFinite(cost.totalCostUsd) || cost.totalCostUsd < 0) throw new Error(`compareOptimizationMethods: ${label} returned an invalid totalCostUsd`);
+	const provenance = cost.costProvenance;
+	if (!provenance || typeof provenance !== "object" || provenance.kind !== "observed" && provenance.kind !== "estimated" && provenance.kind !== "uncaptured" || (provenance.kind === "uncaptured" ? provenance.usd !== null : !Number.isFinite(provenance.usd) || provenance.usd < 0)) throw new Error(`compareOptimizationMethods: ${label} returned invalid costProvenance`);
+	if (provenance.kind !== "uncaptured" && provenance.usd !== cost.totalCostUsd) throw new Error(`compareOptimizationMethods: ${label} returned costProvenance inconsistent with totalCostUsd`);
+	if (typeof cost.accountingComplete !== "boolean") throw new Error(`compareOptimizationMethods: ${label} returned invalid accountingComplete`);
+	if (!Array.isArray(cost.incompleteReasons) || cost.incompleteReasons.some((reason) => typeof reason !== "string" || reason.trim().length === 0)) throw new Error(`compareOptimizationMethods: ${label} returned invalid incompleteReasons`);
+	if (cost.accountingComplete !== (cost.incompleteReasons.length === 0)) throw new Error(`compareOptimizationMethods: ${label} returned inconsistent cost completeness and reasons`);
+	if (cost.accountingComplete && provenance.kind === "uncaptured") throw new Error(`compareOptimizationMethods: ${label} cannot mark uncaptured cost as complete`);
+}
+/** Preserve every optimizer token class while keeping total input and output explicit. */
+function optimizationTokenUsageFromSummary(summary, receipts) {
+	if (!summary.usageComplete) return void 0;
+	if (receipts.length !== summary.totalCalls) throw new Error("optimization token usage receipt count does not match the cost summary");
+	const cachedInputTokens = summary.cachedTokens;
+	const cacheWriteInputTokens = summary.cacheWriteTokens ?? 0;
+	const inputTokens = summary.inputTokens + cachedInputTokens + cacheWriteInputTokens;
+	const cacheReadComplete = receipts.length === 0 || receipts.every((receipt) => receipt.cachedTokens !== void 0);
+	const cacheWriteComplete = receipts.length === 0 || receipts.every((receipt) => receipt.cacheWriteTokens !== void 0);
+	const reasoningComplete = receipts.length === 0 || receipts.every((receipt) => receipt.reasoningTokens !== void 0);
+	return {
+		inputTokens,
+		...cacheReadComplete ? { cachedInputTokens } : {},
+		...cacheWriteComplete ? { cacheWriteInputTokens } : {},
+		outputTokens: summary.outputTokens,
+		...reasoningComplete ? { reasoningTokens: summary.reasoningTokens ?? 0 } : {},
+		totalTokens: inputTokens + summary.outputTokens,
+		calls: summary.totalCalls
 	};
 }
 //#endregion
@@ -5022,102 +5122,6 @@ function assertPositiveSafeInteger(value, label) {
 	if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`GEPA candidate population ${label} must be a positive safe integer`);
 }
 //#endregion
-//#region src/campaign/optimization-cost.ts
-/** Attribute method calls while retaining the shared account's admission and read behavior. */
-function createMethodCostScope(account, methodName) {
-	const tags = { [`optimizationAttempt:${crypto.randomUUID()}`]: methodName };
-	return {
-		ledger: Object.freeze({
-			costCeilingUsd: account.costCeilingUsd,
-			runPaidCall: (input) => account.runPaidCall({
-				...input,
-				tags: {
-					...input.tags,
-					...tags
-				}
-			}),
-			summary: account.summary.bind(account),
-			list: account.list.bind(account),
-			reconcile: account.reconcile.bind(account),
-			markCompleted: account.markCompleted.bind(account),
-			costPerCompletedTask: account.costPerCompletedTask.bind(account),
-			...account.listPending ? { listPending: account.listPending.bind(account) } : {},
-			...account.waitForIdle ? { waitForIdle: account.waitForIdle.bind(account) } : {}
-		}),
-		reconcile(reported) {
-			const summary = account.summary({ tags });
-			if (summary.pendingCalls > 0) throw new Error(`optimization method '${methodName}' returned with ${summary.pendingCalls} pending paid call(s)`);
-			const recorded = costFromLedgerSummary(summary);
-			const totalCostUsd = Math.max(reported.totalCostUsd, recorded.totalCostUsd);
-			const roundingToleranceUsd = Number.EPSILON * Math.max(1, totalCostUsd) * (summary.totalCalls + 1);
-			const combined = combineComparisonCosts([{
-				label: "reported",
-				cost: reported
-			}, {
-				label: "recorded",
-				cost: recorded
-			}]);
-			const incompleteReasons = [
-				...reported.incompleteReasons,
-				...recorded.incompleteReasons.map((reason) => `recorded: ${reason}`),
-				...recorded.totalCostUsd - reported.totalCostUsd > roundingToleranceUsd ? [`reported ${reported.totalCostUsd} USD below recorded ${recorded.totalCostUsd} USD`] : []
-			];
-			return {
-				totalCostUsd,
-				costProvenance: combined.costProvenance.kind === "uncaptured" ? combined.costProvenance : {
-					kind: combined.costProvenance.kind,
-					usd: totalCostUsd
-				},
-				accountingComplete: incompleteReasons.length === 0,
-				incompleteReasons
-			};
-		}
-	};
-}
-/** Keep the cost fields a custom optimization method must report. */
-function costFromLedgerSummary(summary) {
-	const cost = {
-		totalCostUsd: summary.totalCostUsd,
-		costProvenance: structuredClone(summary.costProvenance),
-		accountingComplete: summary.accountingComplete,
-		incompleteReasons: [...summary.incompleteReasons]
-	};
-	assertComparisonCost(cost, "cost ledger");
-	return cost;
-}
-/** Combine method costs without turning one unknown bill into a known total. */
-function combineComparisonCosts(entries) {
-	const totalCostUsd = entries.reduce((total, entry) => total + entry.cost.totalCostUsd, 0);
-	const cost = {
-		totalCostUsd,
-		costProvenance: entries.some((entry) => entry.cost.costProvenance.kind === "uncaptured") ? {
-			kind: "uncaptured",
-			usd: null
-		} : entries.every((entry) => entry.cost.costProvenance.kind === "observed") ? {
-			kind: "observed",
-			usd: totalCostUsd
-		} : {
-			kind: "estimated",
-			usd: totalCostUsd
-		},
-		accountingComplete: entries.every((entry) => entry.cost.accountingComplete),
-		incompleteReasons: entries.flatMap((entry) => entry.cost.incompleteReasons.map((reason) => `${entry.label}: ${reason}`))
-	};
-	assertComparisonCost(cost, "combined cost");
-	return cost;
-}
-function assertComparisonCost(cost, label) {
-	if (!cost || typeof cost !== "object") throw new Error(`compareOptimizationMethods: ${label} returned no cost`);
-	if (!Number.isFinite(cost.totalCostUsd) || cost.totalCostUsd < 0) throw new Error(`compareOptimizationMethods: ${label} returned an invalid totalCostUsd`);
-	const provenance = cost.costProvenance;
-	if (!provenance || typeof provenance !== "object" || provenance.kind !== "observed" && provenance.kind !== "estimated" && provenance.kind !== "uncaptured" || (provenance.kind === "uncaptured" ? provenance.usd !== null : !Number.isFinite(provenance.usd) || provenance.usd < 0)) throw new Error(`compareOptimizationMethods: ${label} returned invalid costProvenance`);
-	if (provenance.kind !== "uncaptured" && provenance.usd !== cost.totalCostUsd) throw new Error(`compareOptimizationMethods: ${label} returned costProvenance inconsistent with totalCostUsd`);
-	if (typeof cost.accountingComplete !== "boolean") throw new Error(`compareOptimizationMethods: ${label} returned invalid accountingComplete`);
-	if (!Array.isArray(cost.incompleteReasons) || cost.incompleteReasons.some((reason) => typeof reason !== "string" || reason.trim().length === 0)) throw new Error(`compareOptimizationMethods: ${label} returned invalid incompleteReasons`);
-	if (cost.accountingComplete !== (cost.incompleteReasons.length === 0)) throw new Error(`compareOptimizationMethods: ${label} returned inconsistent cost completeness and reasons`);
-	if (cost.accountingComplete && provenance.kind === "uncaptured") throw new Error(`compareOptimizationMethods: ${label} cannot mark uncaptured cost as complete`);
-}
-//#endregion
 //#region src/campaign/optimization-method.ts
 /** Both complete-method workflows use the same detached inputs, accounting, and evidence admission. */
 async function executeOptimizationMethod(options) {
@@ -5266,440 +5270,6 @@ function assertOptimizationProvenance(methodName, value) {
 	if (value.optimizerModel === void 0 !== (value.optimizerCallRef === void 0) || value.optimizerModel === void 0 !== (value.modelExecutions === void 0)) fail("optimizerModel execution provenance");
 }
 //#endregion
-//#region src/campaign/presets/compare-optimization-methods.ts
-/**
-* Compare optimization methods on shared train, selection, and test data.
-* Optimizers receive only train and selection data. After every optimizer
-* finishes, their selected surfaces are measured on the same untouched test
-* data and compared with paired confidence intervals.
-*/
-/**
-* Compare complete optimization methods on disjoint train, selection, and final test data.
-*/
-async function compareOptimizationMethods(opts) {
-	opts = {
-		...opts,
-		methods: opts.methods.map((method) => ({ ...method })),
-		trainScenarios: structuredClone(opts.trainScenarios),
-		selectionScenarios: structuredClone(opts.selectionScenarios),
-		testScenarios: structuredClone(opts.testScenarios),
-		judges: opts.judges.map(captureJudge),
-		claim: opts.claim && defineEvaluationClaim(opts.claim),
-		finalEvidence: opts.finalEvidence && captureFinalEvidencePolicy(opts.finalEvidence)
-	};
-	assertOptimizationMethods(opts.methods);
-	assertComparisonPartitions(opts);
-	const searchHistoryPolicy = opts.searchHistoryPolicy ?? "allow-missing";
-	assertSearchHistoryAdmissionOptions(opts);
-	const seed = opts.seed ?? 42;
-	const confidence = opts.confidence ?? .95;
-	assertConfidence(confidence);
-	const optimizationConcurrency = opts.optimizationConcurrency ?? 1;
-	const comparisonCount = opts.methods.length * (opts.methods.length + 1) / 2;
-	const intervalConfidence = 1 - (1 - confidence) / comparisonCount;
-	const minimumResamples = minimumBootstrapResamples(confidence, comparisonCount);
-	const resamples = opts.resamples ?? Math.max(2e3, minimumResamples);
-	assertComparisonControls(opts, seed, resamples, confidence);
-	const evidence = opts.evidence === void 0 ? void 0 : structuredClone(opts.evidence);
-	const evidenceBySurface = /* @__PURE__ */ new Map();
-	const storage = opts.storage ?? fsCampaignStorage();
-	const resolvedRunDir = resolveRunDir(opts.runDir, opts.repo);
-	const baselineSurface = structuredClone(opts.baselineSurface);
-	const costLedger = opts.costLedger ?? createRunCostLedger({
-		storage,
-		runDir: `${resolvedRunDir}/cost`,
-		costCeilingUsd: opts.costCeiling
-	});
-	const scoreOnTest = async (surface, tag, costPhase) => {
-		const measuredSurface = structuredClone(surface);
-		const campaign = await runCampaign({
-			...opts,
-			storage,
-			costLedger,
-			costPhase,
-			scenarios: opts.testScenarios.map((scenario) => structuredClone(scenario)),
-			dispatch: (scenario, ctx) => opts.dispatchWithSurface(structuredClone(measuredSurface), scenario, ctx),
-			dispatchRef: finalDispatchRef(opts, measuredSurface),
-			runDir: `${resolvedRunDir}/${tag}`
-		});
-		assertCompleteCampaign(campaign, opts.testScenarios, opts.reps ?? 1, true, `compareOptimizationMethods: ${tag} final comparison`);
-		if (evidence) evidenceBySurface.set(surfaceContentHash(measuredSurface), createCampaignEvidenceReceipt({
-			campaign,
-			surface: measuredSurface,
-			context: evidence
-		}));
-		const byScenario = {};
-		for (const { scenarioId, composite } of campaignBreakdown(campaign).scenarios) byScenario[scenarioId] = composite;
-		return byScenario;
-	};
-	const scenarioIds = opts.testScenarios.map((s) => s.id).sort();
-	const unitByScenario = opts.claim ? evaluationUnitMap(opts.claim, opts.testScenarios) : new Map(scenarioIds.map((id) => [id, id]));
-	const units = opts.claim ? summarizeEvaluationUnits(opts.claim, opts.testScenarios) : {
-		observations: scenarioIds.length,
-		independentUnits: scenarioIds.length,
-		units: scenarioIds.map((id) => ({
-			id,
-			observations: 1
-		}))
-	};
-	const aggregateUnits = (arr) => {
-		const values = /* @__PURE__ */ new Map();
-		scenarioIds.forEach((id, index) => {
-			const unitId = unitByScenario.get(id);
-			const bucket = values.get(unitId) ?? [];
-			bucket.push(arr[index]);
-			values.set(unitId, bucket);
-		});
-		return units.units.map((unit) => mean(values.get(unit.id)));
-	};
-	const decisionOptions = {
-		seed,
-		resamples,
-		confidence: intervalConfidence,
-		threshold: opts.claim?.minimumEffect ?? 0
-	};
-	const align = (byScenario, label) => {
-		const missing = scenarioIds.filter((id) => !(id in byScenario));
-		if (missing.length > 0) throw new Error(`compareOptimizationMethods: ${label} produced no test score for scenario(s) [${missing.join(", ")}]. A cell failed or its judges returned nothing. Fix the dispatch or judge; the comparison will not replace missing scores with zero.`);
-		return scenarioIds.map((id) => byScenario[id]);
-	};
-	if (opts.claim?.generalization === "new-units") assertIndependentEvaluationSplit(opts.claim, opts.testScenarios, [...opts.trainScenarios, ...opts.selectionScenarios]);
-	if (opts.finalEvidence) await reserveFinalEvidence(opts.finalEvidence, opts.claim, opts.testScenarios, [...opts.trainScenarios, ...opts.selectionScenarios]);
-	const optimizationOwner = new AbortController();
-	const optimized = await mapConcurrent(opts.methods, optimizationConcurrency, async (method) => {
-		try {
-			const { selected: out, cost, history: searchHistoryCoverage } = await executeOptimizationMethod({
-				method,
-				input: createOptimizationMethodInput(opts, method.name, resolvedRunDir, seed, baselineSurface, costLedger, optimizationOwner.signal),
-				storage,
-				searchHistoryPolicy: opts.searchHistoryPolicy,
-				searchHistoryVerification: opts.searchHistoryVerification
-			});
-			const winnerSurface = out.winnerSurface;
-			return {
-				name: method.name,
-				winnerSurface,
-				cost,
-				...out.durationMs === void 0 ? {} : { durationMs: out.durationMs },
-				...out.composition === void 0 ? {} : { composition: out.composition },
-				...out.provenance === void 0 ? {} : { provenance: out.provenance },
-				searchHistoryCoverage
-			};
-		} catch (error) {
-			if (!optimizationOwner.signal.aborted) optimizationOwner.abort(error);
-			throw error;
-		}
-	});
-	assertReportedCostWithinCeiling(combineComparisonCosts(optimized.map((result) => ({
-		label: `method '${result.name}'`,
-		cost: result.cost
-	}))).totalCostUsd, opts.costCeiling, "optimization");
-	const testCostPhase = finalCostPhase(opts, baselineSurface, optimized, seed);
-	const finalEvidence = opts.finalEvidence ? await exposeFinalEvidence(opts.finalEvidence, opts.claim, opts.testScenarios, [baselineSurface, ...optimized.map((method) => method.winnerSurface)]) : void 0;
-	const baselineArr = align(await scoreOnTest(baselineSurface, "test/baseline", testCostPhase), "baseline");
-	const testScoresBySurface = /* @__PURE__ */ new Map([[surfaceContentHash(baselineSurface), baselineArr]]);
-	const winners = [];
-	for (const winner of optimized) {
-		const surfaceKey = surfaceContentHash(winner.winnerSurface);
-		let arr = testScoresBySurface.get(surfaceKey);
-		if (!arr) {
-			arr = align(await scoreOnTest(winner.winnerSurface, `test/methods/${slug(winner.name)}`, testCostPhase), `method "${winner.name}"`);
-			testScoresBySurface.set(surfaceKey, arr);
-		}
-		winners.push({
-			...winner,
-			arr
-		});
-	}
-	const scores = winners.map((w) => {
-		const baselineUnits = aggregateUnits(baselineArr);
-		const winnerUnits = aggregateUnits(w.arr);
-		const decision = decidePairedPromotion(baselineUnits, winnerUnits, decisionOptions);
-		const score = {
-			name: w.name,
-			baselineComposite: mean(baselineUnits),
-			winnerComposite: mean(winnerUnits),
-			lift: decision.delta,
-			liftCi: {
-				low: decision.low,
-				high: decision.high
-			},
-			decision,
-			optimizationCost: w.cost,
-			scenarioScores: scenarioIds.map((scenarioId, index) => ({
-				scenarioId,
-				baselineComposite: baselineArr[index],
-				winnerComposite: w.arr[index],
-				lift: w.arr[index] - baselineArr[index]
-			})),
-			unitScores: units.units.map((unit, index) => ({
-				unitId: unit.id,
-				scenarios: unit.observations,
-				baselineComposite: baselineUnits[index],
-				winnerComposite: winnerUnits[index],
-				lift: winnerUnits[index] - baselineUnits[index]
-			})),
-			winnerSurface: structuredClone(w.winnerSurface),
-			rank: 0
-		};
-		if (evidence) {
-			const baseline = evidenceBySurface.get(surfaceContentHash(baselineSurface));
-			const winner = evidenceBySurface.get(surfaceContentHash(w.winnerSurface));
-			if (!baseline || !winner) throw new Error("final measurement evidence is missing");
-			score.evidence = {
-				baseline,
-				winner
-			};
-		}
-		if (w.composition !== void 0) score.composition = structuredClone(w.composition);
-		if (w.durationMs !== void 0) score.durationMs = w.durationMs;
-		if (w.provenance !== void 0) score.provenance = structuredClone(w.provenance);
-		return score;
-	});
-	scores.sort((a, b) => b.lift - a.lift);
-	for (let start = 0; start < scores.length;) {
-		let end = start + 1;
-		while (end < scores.length && scores[end].lift === scores[start].lift) end += 1;
-		const tied = scores.slice(start, end);
-		if (tied.every((score) => score.optimizationCost.accountingComplete)) {
-			tied.sort((a, b) => a.optimizationCost.totalCostUsd - b.optimizationCost.totalCostUsd);
-			scores.splice(start, tied.length, ...tied);
-		}
-		start = end;
-	}
-	scores.forEach((s, i) => {
-		s.rank = i + 1;
-	});
-	const best = scores[0];
-	const byName = new Map(winners.map((w) => [w.name, w]));
-	const bestArr = aggregateUnits(byName.get(best.name).arr);
-	const pairwise = scores.slice(1).map((other) => {
-		const otherArr = aggregateUnits(byName.get(other.name).arr);
-		const decision = decidePairedPromotion(otherArr, bestArr, decisionOptions);
-		const reverse = decidePairedPromotion(bestArr, otherArr, decisionOptions);
-		const favored = decision.promote ? best.name : reverse.promote ? other.name : null;
-		return {
-			a: best.name,
-			b: other.name,
-			deltaMean: decision.delta,
-			low: decision.low,
-			high: decision.high,
-			favored,
-			decision
-		};
-	});
-	const optimizationCost = combineComparisonCosts(scores.map((score) => ({
-		label: `method '${score.name}'`,
-		cost: score.optimizationCost
-	})));
-	const testCost = costFromLedgerSummary(costLedger.summary({ phase: testCostPhase }));
-	const totalCost = combineComparisonCosts([{
-		label: "optimization",
-		cost: optimizationCost
-	}, {
-		label: "final test",
-		cost: testCost
-	}]);
-	assertReportedCostWithinCeiling(totalCost.totalCostUsd, opts.costCeiling, "total");
-	return {
-		scores,
-		best,
-		pairwise,
-		testScenarioIds: scenarioIds,
-		units,
-		observationUnit: opts.claim ? "registered" : "scenario",
-		pairedCellN: scenarioIds.length * (opts.reps ?? 1),
-		...opts.claim ? { claim: opts.claim } : {},
-		...finalEvidence ? { finalEvidence } : {},
-		optimizationCost,
-		testCost,
-		totalCost,
-		confidence,
-		intervalConfidence,
-		comparisonCount,
-		seed,
-		resamples,
-		reps: opts.reps ?? 1,
-		searchHistory: Object.freeze({
-			policy: searchHistoryPolicy,
-			allComplete: optimized.every((result) => result.searchHistoryCoverage.status === "complete"),
-			producers: Object.freeze(optimized.map((result) => result.searchHistoryCoverage))
-		})
-	};
-}
-function assertReportedCostWithinCeiling(totalCostUsd, costCeiling, phase) {
-	const tolerance = Number.EPSILON * Math.max(1, Math.abs(totalCostUsd), Math.abs(costCeiling ?? 0)) * 8;
-	if (costCeiling !== void 0 && totalCostUsd > costCeiling + tolerance) throw new Error(`compareOptimizationMethods: reported ${phase} cost ${totalCostUsd} exceeds costCeiling ${costCeiling}`);
-}
-function assertOptimizationMethods(methods) {
-	if (!Array.isArray(methods) || methods.length === 0) throw new Error("compareOptimizationMethods: no methods to compare");
-	const names = /* @__PURE__ */ new Set();
-	const pathOwners = /* @__PURE__ */ new Map();
-	for (const method of methods) {
-		if (!method || typeof method !== "object" || typeof method.optimize !== "function") throw new Error("compareOptimizationMethods: every method must provide optimize(input)");
-		if (!method.name || method.name.trim() !== method.name) throw new Error("compareOptimizationMethods: method names must be trimmed and non-empty");
-		if (names.has(method.name)) throw new Error(`compareOptimizationMethods: duplicate method name '${method.name}'`);
-		names.add(method.name);
-		const pathKey = slug(method.name);
-		const prior = pathOwners.get(pathKey);
-		if (prior) throw new Error(`compareOptimizationMethods: method names '${prior}' and '${method.name}' map to the same run path '${pathKey}'`);
-		pathOwners.set(pathKey, method.name);
-	}
-}
-function assertComparisonControls(opts, seed, resamples, confidence) {
-	if (opts.optimizationRunOptions && "costCeiling" in opts.optimizationRunOptions) throw new Error("compareOptimizationMethods: optimizationRunOptions.costCeiling is not supported; costCeiling covers optimization and final scoring");
-	if (!opts.judges || opts.judges.length === 0) throw new Error("compareOptimizationMethods: at least one judge is required");
-	if (typeof opts.dispatchWithSurface !== "function") throw new Error("compareOptimizationMethods: dispatchWithSurface must be a function");
-	if (opts.dispatchRef !== void 0 && (typeof opts.dispatchRef !== "string" || opts.dispatchRef.trim().length === 0 || opts.dispatchRef.trim() !== opts.dispatchRef)) throw new Error("compareOptimizationMethods: dispatchRef must be trimmed and non-empty when provided");
-	const optimizationDispatchRef = opts.optimizationRunOptions?.dispatchRef;
-	if (optimizationDispatchRef !== void 0 && (typeof optimizationDispatchRef !== "string" || optimizationDispatchRef.trim().length === 0 || optimizationDispatchRef.trim() !== optimizationDispatchRef)) throw new Error("compareOptimizationMethods: optimizationRunOptions.dispatchRef must be trimmed and non-empty when provided");
-	if (opts.dispatchRef !== void 0 && optimizationDispatchRef !== void 0 && opts.dispatchRef !== optimizationDispatchRef) throw new Error("compareOptimizationMethods: dispatchRef must match optimizationRunOptions.dispatchRef when both are provided");
-	try {
-		surfaceContentHash(opts.baselineSurface);
-	} catch (cause) {
-		throw new Error("compareOptimizationMethods: baselineSurface is invalid", { cause });
-	}
-	const judgeNames = /* @__PURE__ */ new Set();
-	for (const judge of opts.judges) {
-		if (!judge || typeof judge !== "object" || typeof judge.name !== "string" || judge.name.trim().length === 0 || judge.name.trim() !== judge.name || typeof judge.score !== "function" || !Array.isArray(judge.dimensions) || judge.dimensions.length === 0) throw new Error("compareOptimizationMethods: every judge needs a trimmed name, at least one dimension, and score(input)");
-		if (judgeNames.has(judge.name)) throw new Error(`compareOptimizationMethods: duplicate judge name '${judge.name}'`);
-		judgeNames.add(judge.name);
-		const dimensionKeys = /* @__PURE__ */ new Set();
-		for (const dimension of judge.dimensions) {
-			if (!dimension || typeof dimension.key !== "string" || dimension.key.trim().length === 0 || dimension.key.trim() !== dimension.key || typeof dimension.description !== "string" || dimension.description.trim().length === 0) throw new Error(`compareOptimizationMethods: judge '${judge.name}' has an invalid dimension`);
-			if (dimensionKeys.has(dimension.key)) throw new Error(`compareOptimizationMethods: judge '${judge.name}' has duplicate dimension '${dimension.key}'`);
-			dimensionKeys.add(dimension.key);
-		}
-	}
-	if (typeof opts.runDir !== "string" || opts.runDir.trim().length === 0) throw new Error("compareOptimizationMethods: runDir must be a non-empty string");
-	if (!Number.isSafeInteger(seed)) throw new Error(`compareOptimizationMethods: seed must be a safe integer, got ${String(seed)}`);
-	if (!Number.isSafeInteger(resamples) || resamples <= 0 || resamples > 1e6) throw new Error(`compareOptimizationMethods: resamples must be a positive safe integer no greater than 1000000, got ${String(resamples)}`);
-	if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) throw new Error(`compareOptimizationMethods: confidence must be a finite number in (0,1), got ${String(confidence)}`);
-	const minimumResamples = minimumBootstrapResamples(confidence, opts.methods.length * (opts.methods.length + 1) / 2);
-	if (resamples < minimumResamples) throw new Error(`compareOptimizationMethods: resamples must be at least ${minimumResamples} for simultaneous confidence ${confidence} across ${opts.methods.length} methods, got ${resamples}`);
-	if (opts.optimizationConcurrency !== void 0 && (!Number.isSafeInteger(opts.optimizationConcurrency) || opts.optimizationConcurrency <= 0)) throw new Error("compareOptimizationMethods: optimizationConcurrency must be a positive safe integer");
-	if (opts.maxConcurrency !== void 0 && (!Number.isSafeInteger(opts.maxConcurrency) || opts.maxConcurrency <= 0)) throw new Error("compareOptimizationMethods: maxConcurrency must be a positive safe integer");
-	if (opts.dispatchTimeoutMs !== void 0 && (!Number.isSafeInteger(opts.dispatchTimeoutMs) || opts.dispatchTimeoutMs < 0 || opts.dispatchTimeoutMs > 2147483647)) throw new Error("compareOptimizationMethods: dispatchTimeoutMs must be a non-negative safe integer no greater than 2147483647");
-	if (opts.costCeiling !== void 0 && (!Number.isFinite(opts.costCeiling) || opts.costCeiling < 0)) throw new Error("compareOptimizationMethods: costCeiling must be a finite number greater than or equal to 0");
-	if (opts.costCeiling !== void 0 && opts.costLedger !== void 0 && opts.costLedger.costCeilingUsd !== opts.costCeiling) throw new Error("compareOptimizationMethods: costCeiling must match the shared CostLedger ceiling");
-}
-function assertComparisonPartitions(opts) {
-	const partitions = [
-		{
-			name: "trainScenarios",
-			scenarios: opts.trainScenarios
-		},
-		{
-			name: "selectionScenarios",
-			scenarios: opts.selectionScenarios
-		},
-		{
-			name: "testScenarios",
-			scenarios: opts.testScenarios
-		}
-	];
-	const owner = /* @__PURE__ */ new Map();
-	for (const partition of partitions) {
-		if (!Array.isArray(partition.scenarios) || partition.scenarios.length === 0) throw new Error(`compareOptimizationMethods: ${partition.name} is empty`);
-		if (partition.name === "testScenarios" && partition.scenarios.length < 2) throw new Error("compareOptimizationMethods: testScenarios requires at least 2 scenarios to estimate uncertainty");
-		const local = /* @__PURE__ */ new Set();
-		const duplicates = /* @__PURE__ */ new Set();
-		const overlaps = /* @__PURE__ */ new Map();
-		for (const scenario of partition.scenarios) {
-			if (local.has(scenario.id)) duplicates.add(scenario.id);
-			local.add(scenario.id);
-			const prior = owner.get(scenario.id);
-			if (prior !== void 0 && prior !== partition.name) overlaps.set(scenario.id, prior);
-		}
-		if (duplicates.size > 0) throw new Error(`compareOptimizationMethods: ${partition.name} contains duplicate scenario id(s) [${[...duplicates].join(", ")}]`);
-		if (overlaps.size > 0) {
-			const detail = [...overlaps].map(([id, prior]) => `${id} (${prior} ∩ ${partition.name})`).join(", ");
-			throw new Error(`compareOptimizationMethods: trainScenarios, selectionScenarios, and testScenarios must be pairwise disjoint; overlap: [${detail}]`);
-		}
-		assertCampaignDesign(partition.scenarios, opts.reps ?? 1);
-		for (const id of local) owner.set(id, partition.name);
-	}
-}
-function mean(xs) {
-	return xs.length === 0 ? 0 : xs.reduce((a, b) => a + b, 0) / xs.length;
-}
-function slug(name) {
-	return name.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "").toLowerCase() || "method";
-}
-function assertConfidence(confidence) {
-	if (!Number.isFinite(confidence) || confidence <= 0 || confidence >= 1) throw new Error(`compareOptimizationMethods: confidence must be a finite number in (0,1), got ${String(confidence)}`);
-}
-function minimumBootstrapResamples(confidence, comparisonCount) {
-	const exact = 2 * comparisonCount / (1 - confidence);
-	return Math.ceil(exact - Number.EPSILON * Math.max(1, exact) * 32);
-}
-function createOptimizationMethodInput(opts, methodName, resolvedRunDir, seed, baselineSurface, costLedger, optimizationSignal) {
-	const methodRunDir = `${resolvedRunDir}/optimization/${slug(methodName)}`;
-	const signal = combineAbortSignals(opts.signal, opts.optimizationRunOptions?.signal, optimizationSignal);
-	return Object.freeze({
-		baselineSurface: structuredClone(baselineSurface),
-		trainScenarios: opts.trainScenarios,
-		selectionScenarios: opts.selectionScenarios,
-		dispatchWithSurface: opts.dispatchWithSurface,
-		judges: opts.judges,
-		runDir: methodRunDir,
-		seed,
-		runOptions: Object.freeze({
-			...opts.optimizationRunOptions ?? {},
-			...opts.optimizationRunOptions?.dispatchRef === void 0 && opts.dispatchRef !== void 0 ? { dispatchRef: opts.dispatchRef } : {},
-			...signal ? { signal } : {}
-		}),
-		costLedger
-	});
-}
-function finalCostPhase(opts, baselineSurface, winners, seed) {
-	return `compareOptimizationMethods.test:${contentHash({
-		baseline: surfaceContentHash(baselineSurface),
-		winners: winners.map((winner) => ({
-			name: winner.name,
-			surface: surfaceContentHash(winner.winnerSurface)
-		})),
-		testScenarios: opts.testScenarios,
-		judges: opts.judges.map((judge) => ({
-			name: judge.name,
-			dimensions: judge.dimensions,
-			version: judge.judgeVersion ?? contentHash({
-				score: judge.score.toString(),
-				appliesTo: judge.appliesTo?.toString() ?? null
-			})
-		})),
-		dispatch: callerDispatchRef(opts),
-		seed,
-		reps: opts.reps ?? 1
-	})}`;
-}
-function finalDispatchRef(opts, surface) {
-	return `compareOptimizationMethods:${callerDispatchRef(opts)}:${surfaceContentHash(surface)}`;
-}
-function callerDispatchRef(opts) {
-	return (opts.dispatchRef ?? opts.dispatchWithSurface.name) || "anonymous";
-}
-/** Preserve every optimizer token class while keeping total input and output explicit. */
-function optimizationTokenUsageFromSummary(summary, receipts) {
-	if (!summary.usageComplete) return void 0;
-	if (receipts.length !== summary.totalCalls) throw new Error("optimization token usage receipt count does not match the cost summary");
-	const cachedInputTokens = summary.cachedTokens;
-	const cacheWriteInputTokens = summary.cacheWriteTokens ?? 0;
-	const inputTokens = summary.inputTokens + cachedInputTokens + cacheWriteInputTokens;
-	const cacheReadComplete = receipts.length === 0 || receipts.every((receipt) => receipt.cachedTokens !== void 0);
-	const cacheWriteComplete = receipts.length === 0 || receipts.every((receipt) => receipt.cacheWriteTokens !== void 0);
-	const reasoningComplete = receipts.length === 0 || receipts.every((receipt) => receipt.reasoningTokens !== void 0);
-	return {
-		inputTokens,
-		...cacheReadComplete ? { cachedInputTokens } : {},
-		...cacheWriteComplete ? { cacheWriteInputTokens } : {},
-		outputTokens: summary.outputTokens,
-		...reasoningComplete ? { reasoningTokens: summary.reasoningTokens ?? 0 } : {},
-		totalTokens: inputTokens + summary.outputTokens,
-		calls: summary.totalCalls
-	};
-}
-//#endregion
 //#region src/run-score.ts
 const DEFAULT_RUN_SCORE_WEIGHTS = {
 	success: 4,
@@ -6172,6 +5742,6 @@ function firstString(value) {
 	return typeof value === "string" && value.trim() ? value : void 0;
 }
 //#endregion
-export { captureFinalEvidencePolicy as $, assertCompleteSearchHistory as A, searchReceiptAccounting as B, incumbentWithOperatorBandit as C, surfaceDiff as D, searchEdgeId as E, verifySearchHistoryArtifact as F, captureJudge as G, uniform as H, verifySearchHistoryReceipt as I, redTeamDataset as J, defaultProductionGate as K, campaignCellSearchResult as L, assertSearchHistoryMatchesState as M, createSearchHistoryReceipt as N, surfaceNode as O, searchHistoryCoverageRow as P, assertIndependentEvaluationSplit as Q, searchModelIdentity as R, incumbent as S, developmentClaim as T, runFinalComparison as U, asha as V, openAutoPr as W, scoreRedTeamOutput as X, redTeamReport as Y, runCanaries as Z, isProposedCandidate as _, transientDispatchFailure as a, resolveRunDir as at, beam as b, compareOptimizationMethods as c, buildCellSchedule as ct, combineComparisonCosts as d, evaluationUnitMap as et, costFromLedgerSummary as f, runOptimization as g, runImprovementLoop as h, quotaExhaustedUntil as i, planCampaignRun as it, assertSearchHistoryAdmissionOptions as j, SearchHistoryRequiredError as k, optimizationTokenUsageFromSummary as l, cellCachePath as lt, readGepaCandidatePopulationArtifact as m, JudgeParseError as n, runEval as nt, aggregateRunScore as o, tangleTracesRoot as ot, assertGepaCandidatePopulationSummary as p, DEFAULT_RED_TEAM_CORPUS as q, isTransientTransportFailure as r, runCampaign as rt, clamp01 as s, readCachedCell as st, llmJudge as t, reserveFinalEvidence as tt, executeOptimizationMethod as u, computeManifestHash as ut, labelTrustRank as v, SearchRecorder as w, crowdedFrontierParent as x, aide as y, searchProposalExecution as z };
+export { planCampaignRun as $, verifySearchHistoryReceipt as A, defaultProductionGate as B, searchEdgeId as C, assertSearchHistoryMatchesState as D, assertSearchHistoryAdmissionOptions as E, asha as F, runCanaries as G, redTeamDataset as H, uniform as I, evaluationUnitMap as J, assertIndependentEvaluationSplit as K, runFinalComparison as L, searchModelIdentity as M, searchProposalExecution as N, createSearchHistoryReceipt as O, searchReceiptAccounting as P, runCampaign as Q, openAutoPr as R, developmentClaim as S, surfaceNode as T, redTeamReport as U, DEFAULT_RED_TEAM_CORPUS as V, scoreRedTeamOutput as W, reserveFinalEvidence as X, exposeFinalEvidence as Y, runEval as Z, beam as _, aggregateRunScore as a, incumbentWithOperatorBandit as b, assertGepaCandidatePopulationSummary as c, costFromLedgerSummary as d, resolveRunDir as et, optimizationTokenUsageFromSummary as f, aide as g, isProposedCandidate as h, transientDispatchFailure as i, campaignCellSearchResult as j, verifySearchHistoryArtifact as k, readGepaCandidatePopulationArtifact as l, runOptimization as m, JudgeParseError as n, cellCachePath as nt, clamp01 as o, runImprovementLoop as p, captureFinalEvidencePolicy as q, isTransientTransportFailure as r, computeManifestHash as rt, executeOptimizationMethod as s, llmJudge as t, buildCellSchedule as tt, combineComparisonCosts as u, crowdedFrontierParent as v, surfaceDiff as w, SearchRecorder as x, incumbent as y, captureJudge as z };
 
-//# sourceMappingURL=llm-judge-PXV7Xljl.js.map
+//# sourceMappingURL=llm-judge-C8jMTNNG.js.map